; Filename: CVTX.M68 Date: 05/01/91

;*************************** AMUS Program Label ******************************
; Filename: CVTX.M68 Date: 05/01/91
; Category: UTIL Hash Code: 305-560-730-131 Version: 1.0(102)
; Initials: Name: John Paiement
; Company: Holidair Insurance Services Ltd. Telephone #: 6044214047
; Related Files: CVTX0.M68, CVTSYM.M68
; Min. Op. Sys.: Expertise Level: INT
; Special: Terminal needs box draw and reverse video capability.
; Description: Full function calculator/ Numeric base translator with memory
; operations.
;
;*****************************************************************************
;*; Updated on 01-May-91 at 4:36 PM by John Paiement; edit time: 0:44:49
;
; NOTE all floats are in standard AM format (48 bit)

OBJNAM CVTX.LIT
RADIX 8

SEARCH SYS
SEARCH SYSSYM
SEARCH TRM
COPY CVTSYM.M68 ; Symbols and equates for CVTX

; -------------------------------------------------------------
;
; START OF PROGRAM CODE
;

PHDR -1,0,PH$REE!PH$REU ; Program header

;
; Initialization section
;
GETIMP IMPSIZ,A5 ; A5 * to impure area
MOVB #0,XITFLG(A5)

ECHO
CALL DRAWSC ; Draw calculator

MOVB #ADDF,FUNC(A5) ; Start in ADD function
CALL U.FUNC

MOVB #DECN,BASE(A5) ; Start in Decimal base
CALL U.BASE

CALL MAIN ; Call main loop

EXIT:
PRTTAB 23.,1 ; Position at 23,1 & end
EXIT

MAIN:
;
; Main processing loop
;
CALL G1CH

CMPB XITFLG(A5),#0
BEQ MAIN ; Loop if not set

RTN ; Else exit

; -------------------------------------------------------------
;
; INPUT ROUTINES

G1CH:
;
; Controlling module for processing of user input.
; The first character is processed alone to determine special key handling
; The no-input flag is set on special handling to bypass processing.
;

CLRBUF
MOVB #0,NOINP(A5) ; Clear no-input flag

ONEKEY ; Get one character
LEA A2,BASE(A5) ; Check base to process
MOVB @A2,D1
CMPB D1,#RADN
BNE G.35
MOVB #36.,D2 ; Rad input at column 36
JMP G.36

G.35:
MOVB #35.,D2
CMPB D1, #PPNN ; Ppn input at column 36
BNE G.36
INCB D2

G.36:
ROWCOL
ECHO
KBD ; Get 1 character input
UCS
CTRLC SETXIT ; Exit on CTRL-C
CMPB D1,#ESC ; Or ESC
BNE GET.IN

JMP SETXIT

GET.IN:
;
; Check first character for change of base/function or memory operations
; BYPASS(A5) is set when memory functions selected to avoid placing first
; character in BUFFER
;
PUSH D1
CALL CK1CH
CALL U.FUNC
POP D1

CMPB BYPASS(A5),#1
BEQ NO.BUF

MOVB D1,BUFFER(A5)
JMP CK10

NO.BUF:
MOVB #0,BYPASS(A5)
JMP C2FLT ; Bypass input routine

CK10:
CMPB NOINP(A5),#0
BEQ PRC.IN ; Continue as value input

RTN

PRC.IN:
LEA A4,BUFFER(A5)
CMPB BASE(A5),#DECN
BNE ISIT.H
CALL D.IN ; Call for decimal input validation

LEA A2,BUFFER(A5) ; Point to input buffer
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

C2FLT:
LEA A2,INVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT ; Display all values
CALL AC.VAL
RTN

ISIT.H:
CMPB BASE(A5),#HEXN
BNE ISIT.O
CALL H.IN ; Call for hex input

SETHEX ; Set for hex conversion
LEA A2,BUFFER(A5) ; Point to input buffer
GTOCT ; Place hex in D1
PUSH D1
CLRBUF

LEA A2,BUFFER(A5)
POP D1
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

JMP C2FLT

ISIT.O:
CMPB BASE(A5),#OCTN
BNE ISIT.R
CALL O.IN ; Call for OCTAL input

SETOCT ; Set for octal conversion
LEA A2,BUFFER(A5) ; Point to input buffer
GTOCT ; Place octal in D1
PUSH D1
CLRBUF

LEA A2,BUFFER(A5)
POP D1
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

JMP C2FLT

ISIT.R:
CMPB BASE(A5),#RADN
BEQ R.CONT
JMP ISIT.B

R.CONT:
CALL R.IN ; Call for RAD input

LEA A2,BUFFER(A5)
MOVB (A2)+,D1
MOV #0,D2
MOV #0,D3

RLOOP:
CMPB D1,#0
BEQ R.OVER

CMPB D1,#32.
BNE R.10
MOVB #0,D1 ; Set space = 0
JMP R.40

R.10:
CMPB D1,#36.
BNE R.20
MOVB #27.,D1 ; Set $ = 27
JMP R.40

R.20:
CMPB D1,#64.
BGE R.30
ADDB #46.,D1 ; If chr-64 < 0 add 46

R.30:
SUBB #64.,D1 ; Subtract 64 from ascii value
R.40:
LEA A4,BUF2(A5) ; Place mult figure in radin
CMPW D2,#0.
BEQ R.50
CMPW D2,#1600.
BEQ R.60
MOVW #1,D2
JMP R.ADD

R.50:
MOVW #1600.,D2
JMP R.ADD

R.60:
MOVW #40.,D2

R.ADD:
MOVW D2,@A4
MUL D1,@A4
ADD D1,D3

MOV #0,D1
MOVB (A2)+,D1
JMP RLOOP

R.OVER:
MOV D3,D1
LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

JMP C2FLT

ISIT.B:
CMPB BASE(A5),#BINN
BEQ B.LP
JMP ISIT.P

B.LP:
CALL B.IN

MOV #0,D3
LEA A2,BUFFER(A5)
MOVB (A2)+,D1

B.LP1:
CMPB D1,#0
BEQ B.DON
SUBB #48.,D1
ADDB D1,D3
MOVB (A2)+,D1
CMPB D1,#0
BEQ B.DON
LSL D3,#1
JMP B.LP1

B.DON:
CLRBUF
MOV D3,D1
LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

JMP C2FLT

ISIT.P:
CALL P.IN ; Call for OCTAL input

SETOCT ; Set for octal conversion
LEA A2,BUFFER(A5) ; Point to input buffer
GTOCT ; Place octal in D1
LSLW D1,#8.
PUSH D1

CLRBUF
LEA A2,BUF2(A5) ; Point to input buffer
GTOCT ; Place octal in D1
MOVW D1,D2
POP D1
ADDW D2,D1

LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

JMP C2FLT

D.IN:
;
; input of decimal number
;
CMP D1,#CR ; Is it CR?
BEQ D.DONE

CMPB D1,#NINE ; > asc(9)?
BGT D.BUZZ
CMPB D1,#ZERO ; < asc(0)?
BGE D.OK
CMP D1,#PERD ; Is it '.'
BNE D.BUZZ

D.OK:
MOVB D1,(A4)+ ; Place in buffer
PUSH D1
ROWCOL
POP D1
TTY ; Echo character
INCB D2 ; Inc column
DL2:
CALL CHR.IN ; Get next char of input
JMP D.IN ; Validate

D.BUZZ:
CMP D1,#RUB ; [101] Process the RUBOUT char
BNE D.RING
CMPB D2,#35.
BEQ D.B2
MOVB #0,-(A4)
DECB D2
D.B2:
ROWCOL
MOVB #32.,D1
JMP D.ECH
D.RING:
MOVB #BELL,D1 ; Ring bell
D.ECH:
TTY
JMP DL2 ; Get again

D.DONE:

RTN

H.IN:
;
; input of Hex number
;

CMP D1,#CR ; Is it CR?
BEQ H.DONE
CMPB D1,#F ; > asc(F)?
BGT H.BUZZ
CMPB D1,#ZERO ; < asc(0)?
BGE H.OK

CMP D1,#NINE ; > acs(9)
BLE H.OK
CMP D1,#A
BLT H.BUZZ

H.OK:
MOVB D1,(A4)+ ; Place in buffer
PUSH D1
ROWCOL
POP D1
TTY ; Echo character
INCB D2 ; Inc column
H.LOOP:
CALL CHR.IN ; Get next
JMP H.IN

H.BUZZ:
CMP D1,#RUB ; [101] Process the RUBOUT char
BNE H.RING
CMPB D2,#35.
BEQ H.B2
MOVB #0,-(A4)
DECB D2
H.B2:
ROWCOL
MOVB #32.,D1
JMP H.ECH
H.RING:
MOVB #BELL,D1 ; Ring bell
H.ECH:
TTY
JMP H.LOOP ; Get again

H.DONE:

RTN

O.IN:
;
; input of Octal number
;

CMP D1,#CR ; Is it CR?
BEQ O.DONE
CMPB D1,#SEVN ; > asc(7)?
BGT O.BUZZ
CMPB D1,#ZERO ; < asc(0)?
BLT O.BUZZ

MOVB D1,(A4)+ ; Place in buffer
PUSH D1
ROWCOL
POP D1
TTY ; Echo character
INCB D2 ; Inc column
O.LOOP:
CALL CHR.IN ; Get rest of input
JMP O.IN ; Get next

O.BUZZ:
CMP D1,#RUB ; [101] Process the RUBOUT char
BNE O.RING
CMPB D2,#35.
BEQ O.B2
MOVB #0,-(A4)
DECB D2
O.B2:
ROWCOL
MOVB #32.,D1
JMP O.ECH
O.RING:
MOVB #BELL,D1 ; Ring bell
O.ECH:
TTY
JMP O.LOOP ; Get again

O.DONE:

RTN

R.IN:
;
; input of Rad50 number
;

MOVB #1,D3

PUSH D1
ROWCOL
POP D1
TTY ; Echo character
MOVB D1,(A4)+ ; Place in buffer
INCB D2 ; Inc column

R.GET:
CALL CHR.IN ; Get 2nd char
CMP D1,#RUB ; [101] Process the RUBOUT char
BNE R.SAV

CMPB D2,#36.
BEQ R.G2
MOVB #0,-(A4)
DECB D2
CMPB D3, #1
BLT R.G2
DECB D3

R.G2:
ROWCOL
MOVB #32.,D1
TTY
JMP R.GET

R.SAV:
MOVB D1,(A4)+ ; Place in buffer
PUSH D1
ROWCOL
POP D1
TTY ; Echo character
INCB D2 ; Inc column
INCB D3
CMP D3,#3.
BLT R.GET

RTN

B.IN:
;
; input of Binary number
;

CMP D1,#CR ; Is it CR?
BEQ B.DONE
CMPB D1,#ONE ; > asc(1)?
BGT B.BUZZ
CMPB D1,#ZERO ; < asc(0)?
BLT B.BUZZ

MOVB D1,(A4)+ ; Place in buffer
PUSH D1
ROWCOL
POP D1
TTY ; Echo character
INCB D2 ; Inc column
B.LOOP:
CALL CHR.IN ; Get rest of input
JMP B.IN ; Get next

B.BUZZ:
CMP D1,#RUB ; [101] Process the RUBOUT char
BNE B.RING
CMPB D2,#35.
BEQ B.B2
MOVB #0,-(A4)
DECB D2
B.B2:
ROWCOL
MOVB #32.,D1
JMP B.ECH
B.RING:
MOVB #BELL,D1 ; Ring bell
B.ECH:
TTY
JMP B.LOOP ; Get again

B.DONE:

RTN

P.IN:
;
; input of PPN number
;

CMP D1,#CR ; Is it CR?
BEQ P.DONE
CMPB D1,#SEVN ; > asc(7)?
BGT P.BUZZ
CMPB D1,#ZERO ; < asc(0)?
BGE P.CNT
CMPB D1,#COMA
BNE P.BUZZ
LEA A4,BUF2(A5)
INCB D2
JMP P.LOOP

P.CNT:
MOVB D1,(A4)+ ; Place in buffer
PUSH D1
ROWCOL
POP D1
TTY ; Echo character
INCB D2 ; Inc column
P.LOOP:
CALL CHR.IN ; Get rest of input
JMP P.IN ; Get next

P.BUZZ:
CMP D1,#RUB ; [101] Process the RUBOUT char
BNE P.RING
CMPB D2,#36.
BEQ P.B2
MOVB #0,-(A4)
DECB D2
P.B2:
ROWCOL
MOVB #32.,D1
JMP P.ECH
P.RING:
MOVB #BELL,D1 ; Ring bell
P.ECH:
TTY
JMP P.LOOP ; Get again

P.DONE:

RTN

CK1CH:
;
; Check first character input for special processing
;
CMPB D1,#CR ; Display total on CR
BNE C10

LEA A2,ACCUM(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the ACCUM to be displayed
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
CALL N.PROC

RTN

C10:
CMPB D1,#CLRM ; Clear memory
BNE CLR.D

LEA A2,MEMVAL(A5)
MOV #0,(A2)+
MOVW #0, @A2
LEA A2,MEMVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the ACCUM to be displayed
MOVW @A2,@A4

MOVB #56.,D2
CALL SHW.IT
CALL N.PROC
RTN

CLR.D:
CMPB D1,#CLRD ; Clear display
BNE S.ADD

CLRACC ; Clear accumulator
CLRVAL ; Clear input value

LEA A2,INVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
CALL N.PROC
RTN

S.ADD:
CMPB D1,#PLUS ; Set function to ADD
BNE S.SUB
MOVB #ADDF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.SUB:
CMPB D1,#MINS ; Set function to Subt
BNE S.MUL
MOVB #SUBF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.MUL:
CMPB D1,#TIMS ; Set function to Mult
BNE S.DIV
MOVB #MULF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.DIV:
CMPB D1,#DIVS ; Set function to Div
BNE S.AND
MOVB #DIVF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.AND:
CMPB D1,#LAND ; Set function to And
BNE S.OR
MOVB #ANDF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.OR:
CMPB D1,#LOR ; Set function to Or
BNE S.NOT
MOVB #ORF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.NOT:
CMPB D1,#LNOT ; Set function to Not
BNE S.XOR
MOVB #NOTF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

S.XOR:
CMPB D1,#LXOR ; Set function to Xor
BNE CK.MEM
MOVB #XORF,FUNC(A5)
CALL N.PROC ; Set No-processing flag
RTN

CK.MEM:
CMPB D1,#MFNC ; Check if memory manipulation CTRL-P
BEQ M.ADD
CMPB D1,#TAB ; Change base
BEQ S.BAS
RTN

S.BAS:
CALL SLCT.B
CALL N.PROC ; Set No-processing flag
RTN

M.ADD:
KBD ; Get 2nd half of memory op
UCS

CMPB D1,#PLUS ; Add to memory <+>
BNE M.SUB

LEA A2,DISVAL(A5)
LEA A3,MEMVAL(A5)
FADD A2, A3

LEA A2,MEMVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the ACCUM to be displayed
MOVW @A2,@A4

MOVB #56.,D2
CALL SHW.IT
CALL N.PROC ; Set No-processing flag
RTN

M.SUB:
CMPB D1,#MINS ; Subtract from memory <->
BNE M.OUT

LEA A2,DISVAL(A5)
LEA A3,MEMVAL(A5)
FSUB A2, A3

LEA A2,MEMVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the ACCUM to be displayed
MOVW @A2,@A4

MOVB #56.,D2
CALL SHW.IT
CALL N.PROC ; Set No-processing flag
RTN

M.OUT:
CMPB D1,#CR ; Recall memory on <CR>
BNE M.IN

LEA A2,MEMVAL(A5) ; Move memval to inval
LEA A3,INVAL(A5)
MOV (A2)+,(A3)+
MOVW @A2,@A3

LEA A2,INVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
MOVB #1,BYPASS(A5)
RTN

M.IN:
CMPB D1,#EQLS ; Memory in <=>
BNE CK.DON

LEA A2,MEMVAL(A5) ; Move accum to memval
LEA A3,DISVAL(A5)
MOV (A3)+,(A2)+
MOVW @A3,@A2

LEA A2,MEMVAL(A5)
LEA A4,DISVAL(A5)
MOV (A2)+,(A4)+ ; Set the ACCUM to be displayed
MOVW @A2,@A4
MOVB #56.,D2
CALL SHW.IT
CALL N.PROC ; Set No-processing flag

CK.DON:
RTN

CHR.IN:
;
; Get the rest of the input from user
;
ROWCOL
ECHO
KBD
UCS
RTN

SETXIT:
;
; Set the exit flag
;

MOVB #1,XITFLG(A5) ; Set flag for exit
RTN

; -------------------------------------------------------------
;
; DISPLAY FUNCTIONS

SHW.IT:
;
; display all values in appropriate window from display value float DISVAL(A5)
;
CLRBUF

WINROW 5 ; Clear decimal line
TYPE < >
WINROW 5
LEA A2,BUFFER(A5) ; Point to buffer
GTDEC

LEA A2,BUFFER(A5)
FCVT DISVAL(A5),0,OT$TRM,0,0 ; Place ascii string in window
FCVT DISVAL(A5),0,OT$MEM,0,0 ; Place ascii string in BUFFER

; hex
INCB D2
WINROW 6
TYPE < >
SETHEX
LEA A2,BUFFER(A5) ; Point to buffer
BYP

MOV #0,D1
GTDEC
BMI DIS.O
WINROW 6
LEA A2,BUFFER(A5) ; Point to buffer
OCVT 0,OT$TRM

DIS.O:
WINROW 7
TYPE < >
SETOCT
LEA A2,BUFFER(A5) ; Point to buffer
BYP

MOV #0,D1
GTDEC
BMI DIS.R
WINROW 7
LEA A2,BUFFER(A5) ; Point to buffer
OCVT 0,OT$TRM

DIS.R:
MOV D1,D4
MOVW D1,BUF2(A5)
WINROW 8.
TYPE < >
EVEN

MOV D4,D1
CMP D1,#65535.
BGT O16B

CLRBUF
LEA A2,BUFFER(A5)
LEA A1,BUF2(A5)
MOVB #91.,(A2)+
UNPACK
MOVB #93.,(A2)+
WINROW 8.
OUTL BUFFER(A5),OT$TRM
JMP DIS.B

O16B:
WINROW 8.
TYPE <[---]>
EVEN

DIS.B:
WINROW 9.
TYPE < >
EVEN

MOV D4,D1
CMP D1,#65535.
BGT DIS.P

CLRBUF
MOV #0,D7
LEA A2,BUFFER(A5)
MOVW #32768.,D3 ; Bit index at 16th bit

DIS.10:
MOVW D4,D1
ANDW D3,D1
CMPW D1,#0
BEQ DIS.20
MOVB #49.,(A2)+
MOVB #1,D7 ; Flag first '1' output
JMP DIS.40

DIS.20:
CMPB D7,#0 ; Place space until first '1' output
BEQ DIS.30
MOVB #48.,(A2)+
JMP DIS.40

DIS.30:
MOVB #32.,(A2)+

DIS.40:
LSRW D3,#1
CMPW D3,#0
BEQ DIS.50
JMP DIS.10

DIS.50:
WINROW 9.
OUTL BUFFER(A5),OT$TRM

DIS.P:
INCB D2
WINROW 10.
TYPE < >
EVEN

MOV D4,D1
CMP D1,#65535.
BGT NO.PD
CMP D1,#0
BEQ NO.PD

WINROW 10.
MOVW D4, D1
LSRW D1, #8.
AND #255.,D1 ; Mask off high bytes

OCVT 0,OT$TRM
TYPE <,>

MOVW D4, D1
ANDW #255.,D1 ; Mask off high byte
OCVT 0,OT$TRM

TYPE <]>
JMP DS.DON

NO.PD:
WINROW 10.
TYPE <---,---]>
EVEN

DS.DON:
RTN

; -------------------------------------------------------------
;
; ACCUMULATOR and MATH/LOGICAL FUNCTIONS

AC.VAL:
;
; perform accumulator functions
;
CMPB FUNC(A5),#ADDF
BNE AC.SUB

LEA A2,INVAL(A5)
LEA A3,ACCUM(A5)
FADD A2, A3
RTN

AC.SUB:
CMPB FUNC(A5),#SUBF
BNE AC.MUL

LEA A2,INVAL(A5)
LEA A3,ACCUM(A5)
FSUB A2, A3
RTN

AC.MUL:
CMPB FUNC(A5),#MULF
BNE AC.DIV

LEA A2,INVAL(A5)
LEA A3,ACCUM(A5)
FMUL A2, A3
RTN

AC.DIV:
CMPB FUNC(A5),#DIVF
BNE AC.AND

LEA A2,INVAL(A5)
LEA A3,ACCUM(A5)
FDIV A2, A3
RTN

AC.AND:
CMPB FUNC(A5),#ANDF
BEQ AC.CNT
JMP AC.OR

AC.CNT:
CALL CVTACC
CMPB BYPASS(A5),#1
BEQ ANDOUT

MOV D1,D2
CALL CVTVAL
CMPB BYPASS(A5),#1
BEQ ANDOUT

AND D2,D1
CLRBUF
CLRVAL
LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

LEA A2,INVAL(A5)
LEA A3,DISVAL(A5)
LEA A4,ACCUM(A5)
MOV (A3)+,@A4
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A3,@A4
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
ANDOUT:
MOVB #0,BYPASS(A5)
RTN

AC.OR:
CMPB FUNC(A5),#ORF
BNE AC.XOR

CALL CVTACC
CMPB BYPASS(A5),#1
BEQ OROUT

MOV D1,D2
CALL CVTVAL
CMPB BYPASS(A5),#1
BEQ OROUT

OR D2,D1
CLRBUF
CLRVAL
LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

LEA A2,INVAL(A5)
LEA A3,DISVAL(A5)
LEA A4,ACCUM(A5)
MOV (A3)+,@A4
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A3,@A4
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
OROUT:
MOVB #0,BYPASS(A5)
RTN

AC.XOR:
CMPB FUNC(A5),#XORF
BNE AC.NOT

CALL CVTACC
CMPB BYPASS(A5),#1
BEQ XOROUT

MOV D1,D2
CALL CVTVAL
CMPB BYPASS(A5),#1
BEQ XOROUT

XOR D2,D1
CLRBUF
CLRVAL
LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

LEA A2,INVAL(A5)
LEA A3,DISVAL(A5)
LEA A4,ACCUM(A5)
MOV (A3)+,@A4
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A3,@A4
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
XOROUT:
MOVB #0,BYPASS(A5)
RTN

AC.NOT:
CMPB FUNC(A5),#NOTF
BEQ ACN1
JMP AC.WHO

ACN1:
PUSH D1
CALL CVTACC
POP D1
CMPB BYPASS(A5),#1
BEQ NOTOUT

NOT D1
CLRBUF
CLRVAL
LEA A2,BUFFER(A5)
DCVT 0,OT$MEM ; Place decimal string in buffer
LEA A2,BUFFER(A5)
GTFLT INVAL(A5) ; Convert buffer to float at INVAL

LEA A2,INVAL(A5)
LEA A3,DISVAL(A5)
LEA A4,ACCUM(A5)
MOV (A3)+,@A4
MOV (A2)+,(A4)+ ; Set the INVAL to be displayed
MOVW @A3,@A4
MOVW @A2,@A4

MOVB #34.,D2
CALL SHW.IT
NOTOUT:
MOVB #0,BYPASS(A5)
MOVB #ADDF,FUNC(A5)

AC.WHO:
RTN

CVTACC:
CLRBUF
LEA A2,BUFFER(A5)
FCVT ACCUM(A5),0,OT$MEM,0,0 ; Place ascii string in window
LEA A2,BUFFER(A5) ; Point to buffer
BYP
MOV #0,D1
GTDEC
CMP D1,#^H0FFFFFFFF
BGE AC.1
JMP NO.GO
AC.1:
RTN

CVTVAL:
CLRBUF
LEA A2,BUFFER(A5)
FCVT INVAL(A5),0,OT$MEM,0,0 ; Place ascii string in window
LEA A2,BUFFER(A5) ; Point to buffer
BYP

MOV #0,D1
GTDEC
CMP D1,#^H0FFFFFFFF
BGE AC.2
JMP NO.GO
AC.2:
RTN

NO.GO:
PRTTAB 24.,1
TYPE <No logical operations on values over 2**32>
EVEN
MOV #BELL,D1
TTY
KBD
PRTTAB 24.,1
TYPE < >
EVEN
MOVB #1,BYPASS(A5)
RTN

N.PROC:
;
; Set the no-input-processing flag
;
MOVB #1,NOINP(A5)
RTN

; -------------------------------------------------------------
;
;CHANGE BASE FUNCTIONS
;

SLCT.B:
;
; Controlling module for selection of base
;

ONEKEY

BAS.10:
CALL HILIT
PRTTAB -1,29. ; Cursor off
MOVB #28.,D2
ROWCOL
KBD
UCS
CALL UNLIT

CMPB D1,#CR ; Is it CR
BNE NOT.CR
JMP ACCEPT

NOT.CR:
CMPB D1,#ESC ; Is it ESC
BNE NO.ESC

ACCEPT:
PRTTAB -1,28. ; Cursor on
RTN

NO.ESC:
CMPB D1,#11. ; Is it CURS UP
BNE NOT.UP

LEA A2,BASE(A5)
MOVB @A2,D1
CMPB D1,#DECN
BEQ LST.E

DECB D1
JMP MV.BAR ; Set base and update

LST.E:
MOVB #PPNN,D1

MV.BAR:
LEA A2,BASE(A5)
MOVB D1,@A2 ; Store the new base
CALL U.BASE
JMP BAS.10

NOT.UP:
CMPB D1,#10. ; Is it CURS DN
BNE NOT.DN

LEA A2,BASE(A5)
MOVB @A2,D1
INCB D1
CMPB D1,#PPNN
BLE MV.BAR
MOVB #DECN,D1
JMP MV.BAR

NOT.DN:
CMPB D1,#68. ; Is it D
BNE CHK.H
MOVB #DECN,BASE(A5)
PRTTAB -1,28. ; Cursor on
JMP SB.END

CHK.H:
CMPB D1,#72. ; Is it H
BNE CHK.O
MOVB #HEXN,BASE(A5)
JMP SB.END

CHK.O:
CMPB D1,#79. ; Is it O
BNE CHK.R
MOVB #OCTN,BASE(A5)
JMP SB.END

CHK.R:
CMPB D1,#82. ; Is it R
BNE CHK.B
MOVB #RADN,BASE(A5)
JMP SB.END

CHK.B:
CMPB D1,#66. ; Is it B
BNE CHK.P
MOVB #BINN,BASE(A5)
JMP SB.END

CHK.P:
CMPB D1,#80. ; Is it P
BEQ PPN
JMP BAS.10

PPN:
MOVB #PPNN,BASE(A5)

SB.END:
CALL U.BASE
PRTTAB -1,28. ; Cursor on
RTN

HILIT:
;
; Hilite the current base for selection
;
PUSH D1
MOVB #28.,D2
ROWCOL ; At current base row,28
PRTTAB -1,32. ; Hilite char
MOVB #34.,D2
ROWCOL
PRTTAB -1,33.
POP D1
RTN

UNLIT:
;
; Restore normal video on selection
;
PUSH D1
MOVB #28.,D2
ROWCOL ; At current base row,28
PRTTAB -1,33. ; End Hilite char
POP D1
RTN

U.BASE:
;
; Update the base in calculator window
;

MOV #0,D1
MOVB BASE(A5),D1
LSL D1,#1
PRTTAB 3,48.
LEA A2,BT1
ADDW D1,A2
MOVW @A2,D1
ADDW D1,A2
TTYL @A2

RTN

U.FUNC:
;
; Update the function in calculator window
;

MOV #0,D1
MOVB FUNC(A5),D1
LSL D1,#1
PRTTAB 3,36.
LEA A2,FT1-2
ADDW D1,A2
MOVW @A2,D1
ADDW D1,A2
TTYL @A2

RTN

DEFINE OFFTAB A0,A1,A2,A3,A4,A5
IF NB, A0, WORD A0-.
IF NB, A1, WORD A1-.
IF NB, A2, WORD A2-.
IF NB, A3, WORD A3-.
IF NB, A4, WORD A4-.
IF NB, A5, WORD A5-.
ENDM

; Word offset and data table for base/function text placement
;
BT1: OFFTAB BA0,BA1,BA2,BA3,BA4,BA5
FT1: OFFTAB FA1,FA2,FA3,FA4,FA5,FA6
OFFTAB FA7,FA8

BA0: ASCII /Dec/
BYTE 0
BA1: ASCII /Hex/
BYTE 0
BA2: ASCII /Oct/
BYTE 0
BA3: ASCII /Rad/
BYTE 0
BA4: ASCII /Bin/
BYTE 0
BA5: ASCII /Ppn/
BYTE 0

FA1: ASCII / Add/
BYTE 0
FA2: ASCII /Subt/
BYTE 0
FA3: ASCII /Mult/
BYTE 0
FA4: ASCII / Div/
BYTE 0
FA5: ASCII / And/
BYTE 0
FA6: ASCII / Or /
BYTE 0
FA7: ASCII / Not/
BYTE 0
FA8: ASCII / Xor/
BYTE 0

; -------------------------------------------------------------
; SCREEN DRAW MODULE

COPY CVTX0.M68
END