|
DataMuseum.dkPresents historical artifacts from the history of: CP/M |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about CP/M Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 60416 (0xec00)
Types: TextFile
Names: »EENTRY.MAC«
└─⟦4f77bd9c1⟧ Bits:30005982/disk2.imd RC Computer - Turn Key Data Entry System - Vers. 1.91
└─⟦this⟧ »EENTRY.MAC«
└─⟦8417fc433⟧ Bits:30005982/disk1.imd RC Computer - Turn Key Data Entry System - Vers. 1.91
└─⟦this⟧ »EENTRY.MAC«
;*************************************************
;* *
;* MODULE : EENTRY.MAC (RC-850) *
;* DATE : 05.02.82 *
;* BY : ASE GmbH , 6472 Altenstadt *
;* VERSION: 1.90 *
;* *
;*************************************************
;
; THIS IS THE KEYSTROKE-PROCESSING MODUL WHICH HANDLES ALL
; KEYSTROKES AND FUNCTION-KEYS BASED ON THE FIELD-DESCRIPTIONS
; IT IS USED IN ALL MODES EXCEPT 'FORMAT' AND 'FORMAT-UPDATE'.
;
;
; THE FOLLOWING CONTAINS
; THE KEYBOARD CODES FOR THE RC-850 KEYBOARD (MODEL PTY 001)
;
RSTCHR equ 01h ;reset character
CHRADV equ 24 ;character advance (right arrow)
CHRBWD equ 08h ;character backward (left arrow)
CTRLQ equ 86h ;this is the quit-function (PF11)
HOME equ 29 ;cursor home position (arrow north-west)
CTRLK equ 82h ;change format-chain-key (pa3)
CLRKEY equ 20 ;this is the del.record key (ERASE INPUT)
CARTN equ 0dh ;carriage return key
FADV equ 09h ;field advance (diode symbol pointing right)
FBWD equ 05h ;field backward (diode symbol pointing left)
CTRLD equ 31 ;duplication key (DUP)
CTRLA equ 85h ;PF10-key , auto-skip-dup off
CTRLFR equ 81h ;pa2 is record advance
CTRLBR equ 80h ;pa1 is record backward
FLDCRR equ 84h ;field corr. key (PA5)
CTRLZ equ 28 ;this is the insert rec key (INS LINE)
CTRLC equ 02 ;this is the send-key
DCD equ 88h ;pf13 is the display check-digit key
RGDSP equ 87h ;pf12 is the register display key
NUMDUP equ 31 ;is equal to dup-key
;
;THE FOLLOWING EQUATES ARE DEFINED FOR THE 850-CRT-MEMORY-MAP.
;
ENDCRT equ 0ff3dh ;end of 850-crt-buffer
FCKDSP equ 0ff1bh ;format-chain-key display area (rc 850)
FDBDSP equ 0feadh ;field-definition-byte-display in line 25 (rc 850)
ASDDSP equ 0fea5h ;ASD-indicator display in line 25 (rc 850)
;
;
PUBLIC ENTFLG
PUBLIC ENTRY
PUBLIC FMTCHK
PUBLIC STBMSK
PUBLIC CLRFLG
PUBLIC CLBMSK
PUBLIC DUPBFF
PUBLIC UPDFLG
PUBLIC EOFLD
PUBLIC KEYER3
PUBLIC SVEBF1
PUBLIC REGCHK
PUBLIC SVEBFF
PUBLIC TSTFDB
PUBLIC REGCHK
PUBLIC SVEBF2
PUBLIC CAVFLG
PUBLIC UPDM15
PUBLIC VCRFLG
PUBLIC MINFLG
PUBLIC EFTFLG
PUBLIC KEYER7
PUBLIC CBWD4
PUBLIC RSTBFF
PUBLIC NXTLPE
PUBLIC MFLCHK
PUBLIC SKRRAC
PUBLIC DUPFLD
PUBLIC SETMSG
PUBLIC FNFLG
PUBLIC KEYERR
PUBLIC BRFLD
PUBLIC DTEFLG
PUBLIC F03FLG
PUBLIC FLDZRO
PUBLIC EFRCHD
PUBLIC UPDM19
PUBLIC SKIP
PUBLIC RAVER
;
ext R0FLG
ext R1FLG
ext R2FLG
ext R3FLG
ext R4FLG
ext R5FLG
ext R6FLG
ext R7FLG
ext R8FLG
ext R9FLG
ext R10FLG
ext R11FLG
ext R12FLG
ext R13FLG
ext R14FLG
ext R15FLG
ext R16FLG
ext R17FLG
ext R18FLG
ext R19FLG
ext R20FLG
ext R21FLG
ext R22FLG
ext R23FLG
ext R24FLG
ext R25FLG
ext LFSTB
ext FDBTAB
ext USRABT
ext ENTSND
ext FTMFLG
ext ENTHME
ext CFLAG
ext INTFLG
ext CLDEF
ext AUTFLG
ext FLDADV
ext FLDBWD
ext XFMT
ext VFPCTR
ext ENTCPL
ext VFCTR
ext FRMCPL
ext ILLFNO
ext FBFADD
ext SOFUBA
ext CBFADD
ext SOFCBA
ext BFNO
ext FPTTAB
ext SOFFBA
ext INCCRS
ext ALLINC
ext DSPMSG
ext GENFSB
ext ILLFRM
ext CHRRD
ext CHKBTE
ext NXTFDB
ext EFOFLG
ext ENDFRM
ext BCPCTR
ext DEMODE
ext UBFADD
ext INBUFF
ext FMTINT
ext DELREC
ext CBWFLG
ext FTMFLG
ext DUPFLG
ext FRMCHN
ext EERCTR
ext VERCTR
ext NKECTR
ext NKVCTR
ext FNCFLG
ext VRTCTR
ext VCRCTR
ext FMFFLG
ext FILCTR
ext RECBWD
ext RECADV
ext INSRCD
ext EOFPRC
ext RACHK
ext REGPRC
ext REGFLG
ext INCCRS
ext QFLD
ext TFLD
ext MLNFLG
ext AUTINC
ext DSPCD
ext CHRCNV
ext SGNCHK
ext SGNSET
ext ZNSGN
ext DSPREG
ext FCORR
ext VCRPSS
ext PF2FLG
ext SOKBBA
ext ATTBYT
ext ATTSVE
ext BLINIT
ext BLMVE
ext ATTCHK
ext co
ext CONST
ext SGNCHK
;
;
;
;the following mainly checks for a legal field number and
;builds up the field oriented pointers to the 3 main buffers:
;format-buffer, user-buffer, crt-buffer
;
ENTRY: ld a,(CLRFLG) ;test the
cp 0ffh ;clear key flag
jp z,CLRKY1 ;its set.
ld a,00h ;
ld bc,R0FLG ;
ld hl,25 ;
call INBUFF ;clear all the register flags
ld a,0ffh ;
ld (STRFLG),a ;set start of field flag
ld hl,(BFNO) ;get binary field number
ld bc,0h ;
and a ;
sbc hl,bc ;
jp nz,ENTRY8 ;
ld a,(DEMODE) ;
cp 05h ;format-data mode?
jp nz,FLDZRO ;ret to user if not.
ENTRY8: ld hl,(BFNO) ;
ld de,(VFCTR) ;
and a ;
ex de,hl ;
sbc hl,de ;compare with max.no of fields
jp m,ILLFNO ;illegal field number
ex de,hl ;
ld a,(DEMODE) ;
cp 02h ;update-mode?
jp z,UPDMV ;yes.
cp 05h ;format-data mode?
jp z,UPDM15 ;yes.
ENTRY6: dec hl ;align with fpt-entry zero
add hl,hl ;x2
add hl,hl ;x4
ld de,FPTTAB ;derive buffer
add hl,de ;addresses
ld c,(hl) ;
inc hl ;
ld b,(hl) ;
ld (SOFFBA),bc ;from
inc hl ;the
ld c,(hl) ;
inc hl ;field pointer table
ld b,(hl) ;
ld hl,0ffffh ;
and a ;
sbc hl,bc ;
jp z,ENDFLD ;end of format reached!
ld (SOFUBA),bc ;
ld de,(FBFADD) ;calculate
ld hl,(SOFFBA) ;crt - start
and a ;
sbc hl,de ;format buffer address
ld de,(CBFADD) ;
add hl,hl ;
add hl,de ;
ld (SOFCBA),hl ;
;
;the following will wether a record is to be displayed on the crt
;during update-mode before allowing entry.
;
ld a,(DEMODE) ;
cp 02h ;
jp z,UPDMV9 ;test for updatemode-move.
;
cp 05h ;
jp z,UPDMV9 ;go on format-data mode.
ld a,(CAVFLG) ;
cp 0ffh ;clear all var.flds flg set?
ret z ;ret if it is.
;
;the following will check for an FSB in the format
;this check will be bypassed if fieldstart is equal buffer-start.
;
ENTRY7: ld hl,(SOFFBA) ;
ld bc,(FBFADD) ;
and a ;
sbc hl,bc ;fieldstart = start of formatbuffer?
jp nz,ENTR11 ;go on not equal
ld a,00h ;
ld (ATTBYT),a ;set to normal attribute
jp ENTRY3 ;
ENTR11: ld hl,(SOFFBA) ;
dec hl ;
ld c,(hl) ;get FSB (if it is one)
call ATTCHK ;xlate attribute byte
ld c,(hl) ;
ld a,0fh ;
and c ;mask out upper 4 bits
cp 02h ;display-only field?
jp z,TSTFLD ;yes.
cp 04h ;no-display/no-modify field?
jp z,TSTFLD ;yes.
cp 03h ;
jp z,SETF03 ;update-only field.
cp 06h ;duplicate-format field?
jp nz,ENTRY4 ;bypass if not.
ld a,0ffh ;
ld (DFFLG),a ;set duplicate-format flag
ENTRY4: ld a,0h ;
ld (F03FLG),a ;clear the flag
;
;the following will test the bit-mask for the current field
;if bit set cursor movement will be allowed over the full
;field. if not the bit in the mask will be set.
;
ENTRY3: call TSBMSK ;test the field-mask bit
cp 0ffh ;
jp z,ENTRY1 ;go if bit set.
ld a,0ffh ;
ld (RESFLG),a ;
ld hl,0h ;
ld (BCPCTR),hl ;
call STBMSK ;
jp ENTRY2 ;
ENTRY1: ld a,0h ;
ld (RESFLG),a ;
ld (MTCFLG),a ;
ld hl,(BFNO) ;
ld bc,(RESSV1) ;
and a ;
sbc hl,bc ;
jp nz,ENTRY2 ;actual and saved fno dont match.
ld hl,(RESSV2) ;
ld (BCPCTR),hl ;
ld a,0ffh ;
ld (RESFLG),a ;
ld (MTCFLG),a ;
;
;the following presets and clears vaious flags
;
ENTRY2: ld a,0ffh ;
ld (ENTFLG),a ;set entry-mode flag
ld hl,0 ;clear the
ld (FILCTR),hl ;field length counter
ld (MXFLNG),hl ;
ld a,0 ;
ld (FBFLG),a ;clear the fwd-flag
ld (FFLG),a ;clear the fwd-flag
ld (CADFLG),a ;
ld (FNFLG),a ;clear function-key flag
ld (VRTCTR),a ;clear verify retry ctr
ld (MFFLG),a ;clear must fill flag
ld (EFRCHD),a ;clear end-of-field-reached flag
ld a,(DFFLG) ;
cp 0ffh ;
jp z,DFFLD ;go if duplicate format flag set.
;
;
;the following (thru to ENTRY5) will fill the field on crt with
;periods after it has been verify/field corrected in verify mode
;to allow succeding verifying of the corrected field
;
ld a,(VCRPSS) ;verify/field correction pass flag set?
cp 0ffh ;
jp nz,ENTRY5 ;
call SVEBFF ;save the buffers
ld a,0ffh ;
ld (INTFLG),a ;set intflag
ENTRY9: ld hl,(SOFCBA) ;
ld a,2eh ;
ld (hl),a ;display period
call NXTFDB ;
call GENFSB ;
cp 0ffh ;
jp z,ENTR10 ;end of field
cp 20h ;
jp z,ENTR10 ;end of field
jp ENTRY9 ;
ENTR10: call RSTBFF ;restore the buffers
ld a,00h ;
ld (INTFLG),a ;
;
;THE FOLLOWING WILL SET THE CURSOR TO START OF FIELD
;
ENTRY5: call INCCRS ;
;
;the following will read and test the field - start/continuation byte.
;
NXTLPE: call GENFSB ;
cp 0ffh ;FSB ?
jp z,EFT ;yes , means end of field.
cp 20h ;space?
jp z,EFT ;yes ,end of field
cp 55h ;00-1fh ?
jp z,ILLFRM ;format error.
cp 00h ;21-2f ?
jp z,CNTFDB ;could be field cont.character.
cp 01 ;could be a register (alpha range)
jp z,REGCHK ;
cp 02 ;Field start byte or register ?
jp z,TSTFDB ;
jp ILLFRM ;bad format !
SETMSG: ld a,85h ;
call DSPMSG ;set entry-ready message
;
;the following will read acharacter from the keyboard, unless
;the current field is a duplication-field.
;
GETCHR: ld a,0h ;
ld (CADFLG),a ;
ld a,(DUPFLG) ;
cp 0ffh ;dup-flag set?
jp z,DUPFLD ;yes.
call CHRRD ;get character from keyboard
;
;the following will analyse the class of character just received
;from the keyboard and branch to the respective routines.
;
GETCH1: call CHKBTE ;check range of character
cp 02h ;normal alpha ?
jp z,ALPCHR ;yes
cp 01h ;normal numeric ?
jp z,NUMCHR ;yes
cp 0ffh ;function key ?
jp z,FNKEY ;yes
CP 55H ;CTRL KEY FUNCTION ?
JP Z,FNKEY ;YES.
cp 20h ;space ?
jp z,ALPCHR ;yes
cp 00h ;special characters ?
jp z,ALPCHR ;yes
jp KEYERR ;anything else is an error.
;
;the following will increment the buffer pointers and branch
;for the processing of the next character.
;
NXTCHR: call NXTFDB ;step to next position.
JP NXTLPE ;LOOP FOR NEXT CHARACTER
;
;
;whenever the application programm addresses field zero (not existant)
;the following will set the cursor to the last position on the
;crt,set field-number to 1 and return to the user-interface.
;
FLDZRO: ld hl,ENDCRT ;
ld (SOFCBA),hl ;
call INCCRS ;
ld hl,1h ;
ld (BFNO),hl ;set field no. to 1.
jp ENTCPL ;
;
;
;the following will inc the field length ctr and dec the field backward
;position counter (if not zero)
;
ASCE14: ld a,(SKPFLG) ;
cp 0ffh ;skip flag set?
jp z,ASCE15 ;yes,bypass incr.the FILCTR
ld a,(EFRCHD) ;
cp 0ffh ;end of format flag set?
jp nz,ASCE25 ;bypass if end-of-field has been reachd
ld bc,(FILCTR) ;
ld hl,(MXFLNG) ;
and a ;
sbc hl,bc ;
jp z,ASCE15 ;bypass incrementing the Field length.
ASCE25: ld bc,(FILCTR) ;inc the
inc bc ;field length counter
ld (FILCTR),bc ;
ASCE15: ld hl,(BCPCTR) ;
ld de,0h ;
and a ;
sbc hl,de ;
ret z ;
dec hl ;dec bcpctr if not zero.
ld (BCPCTR),hl ;
ret ;
;
;
;depending on the mode in use , the following will update the
;statistical counters and write the entered character to the
;screen and user-buffer.
;
ASCENT: ld a,(DEMODE) ;
cp 01h ;verify mode?
jp z,ASCEN3 ;yes.
cp 00h ;entry mode?
jp nz,ASCE10 ;go, if not.
ld hl,(NKECTR) ;
inc hl ;inc
ld (NKECTR),hl ;the # of keys entered
ASCE10: ld hl,(SOFUBA) ;
ld (hl),c ;store character in user buffer
ASCEN5: ld hl,(SOFCBA) ;
ld a,(F03FLG) ;FSB03-flag set?
cp 0ffh ;
jp z,ASCEN2 ;yes.
call CHRCNV ;convert char and store to crt
ld a,(EFTFLG) ;
cp 0ffh ;
jp z,NXTCHR ;
call ASCE14 ;
jp NXTCHR ;
;
ASCEN2: ld c,2eh ;
call CHRCNV ;display period in place of character
ld a,(EFTFLG) ;
cp 0ffh ;
jp z,NXTCHR ;
call ASCE14 ;
jp NXTCHR ;
;
ASCEN3: ld a,00h ;
ld (MINFLG),a ;clear minus-flag
ld (POSFLG),a ;clear pos-flag
ld a,(F03FLG) ;
cp 0ffh ;no-display flg set?
jp z,EOFLD ;force end of field on verify mode.
ld hl,(SOFUBA) ;get char.from userbuffer.
ld a,(hl) ;to a-reg.
cp c ;compare with keyboard character.
jp nz,ASCEN4 ;go on no-match.
ASCE16: ld a,00h ;
ld (VRTCTR),a ;clear the verify-retry ctr.
ld hl,(NKVCTR) ;
inc hl ;
ld (NKVCTR),hl ;inc the # of keys verified.
jp ASCEN5 ;
;
;comes here on verify mismatch.
;checks for 4th retry.if it isnt will display the full field and
;display the error message.
;
ASCEN4: ld a,c ;
ld (SGNCHR),a ;save keyboard character
ld (KBCHR),a ;here too.
call RACHK ;
cp 0ffh ;right adjust field?
jp nz,ASCE13 ;
ld hl,(SOFUBA) ;
ld a,(hl) ;get character from user-buffer
ld hl,SGNCHR ;load address
ld c,a ;save user buffer char. to c-reg
call SGNSET ;get zoned equivalent character
ld a,(SGNCHR) ;to a-reg
cp c ;match with user buffer character?
jp nz,ASCE13 ;go if not.
ld a,0ffh ;
ld (MINFLG),a ;set minus flag
ld a,(KBCHR) ;
ld c,a ;
jp ASCE16 ;
ASCE13: ld a,(SKPFLG) ;
cp 0ffh ;
jp nz,ASCE22 ;
ld a,00h ;
ld (SKPFLG),a ;
jp ASCE23 ;
ASCE22: ld a,(VRTCTR) ;
cp 03h ;4th retry on same character?
jp z,ASCEN6 ;yes.
inc a ;
ld (VRTCTR),a ;inc the retry ctr
ASCE23: ld a,(MINFLG) ;
cp 0ffh ;
jp nz,ASCE17 ;
ld a,11 ;
call DSPMSG ;set 'sign-error ' msg
ld a,0ffh ;
ld (CFLAG),a ;set call flag
call KEYER3 ;handle error msg procedur
jp SETMSG ;and get next keyboard entry
ASCE17: call SVEBFF ;save the buffer-pointers.
ld a,01h ;
call DSPMSG ;set verify-error message
ASCEN8: ld a,0ffh ;
ld (INTFLG),a ;
ld de,(SOFUBA) ;
ld hl,(SOFCBA) ;
ld a,(de) ;move char. from user-buffer
ld c,a ;
call CHRCNV ;to the crt
call NXTFDB ;
call GENFSB ;
cp 0ffh ;
jp z,ASCEN9 ;end of field.
cp 20h ;
jp z,ASCEN9 ;end of field.
jp ASCEN8 ;
;
;this calls the keyerror routine followed by resetting the
;the field's display .
;
ASCEN9: ld a,0ffh ;
ld (CFLAG),a ;
call KEYER3 ;handle the verify-error
call RSTBFF ;restore the buffer pointers
ASCE12: ld a,0ffh ;
ld (INTFLG),a ;set int-flag
ld hl,(SOFCBA) ;fill up
ld c,2eh ;with period.
call CHRCNV ;
call NXTFDB ;
call GENFSB ;
cp 0ffh ;end of field?
jp z,ASCE11 ;yes.
cp 20h ;end of field?
jp z,ASCE11 ;yes.
jp ASCE12 ;
;
ASCE11: call RSTBFF ;restore the buffers
ld a,00h ;
ld (INTFLG),a ;
jp SETMSG ;and ret to the loop.
;
;comes here after the 3rd verify retry.
;
ASCEN6: ld a,(MINFLG) ;
cp 0ffh ;
jp z,ASCE18 ;handle minus to positive sign correct.
ld a,(POSFLG) ;
cp 0ffh ;
jp z,ASCE19 ;handle positive to minus sign correct.
ld hl,(SOFUBA) ;
ld a,(hl) ;get char. from user buffer
ld hl,SGNCHR ;
ld (hl),a ;
call SGNCHK ;check if character zoned.
ld a,(KBCHR) ;
ld c,a ;keyboard character to c-reg
ld a,(ZNSGN) ;
cp 0ffh ;user buffer char.zoned?
jp nz,ASCE21 ;go if not.
ld hl,KBCHR ;
call SGNSET ;xlate kb-char to zoned
ld c,(hl) ;
ld a,0ffh ;
ld (MINFLG),a ;set minus-flag
ASCE21: ld hl,(SOFUBA) ;
ld (hl),c ;write char. to user-buffer.
ld hl,(SOFCBA) ;
call CHRCNV ;xlate and store to the crt
ld a,0ffh ;
ld (VCRFLG),a ;set the verify correction flag
ld hl,(VCRCTR) ;
inc hl ;
ld (VCRCTR),hl ;inc the verify-corr.ctr
ld a,00h ;
ld (VRTCTR),a ;reste the verify-retry ctr.
call ASCE14 ;
jp NXTCHR ;and join the loop again.
;
;comes here to correct a zoned field to a positive field during
;verify mode.(only on right adjust fields)
;
ASCE18: ld hl,(SOFUBA) ;
call SGNCHK ;xløate zoned to non-zoned
ld c,(hl) ;
ld hl,(SOFCBA) ;
call CHRCNV ;also correct crt
ld a,00h ;
ld (MINFLG),a ;clear minus flag
jp ASCE20 ;
;
;comes here to correct a positive field to a zoned field as above.
;
ASCE19: ld hl,(SOFUBA) ;
call SGNSET ;xlate positive to zoned
ld c,(hl) ;
ld hl,(SOFCBA) ;
call CHRCNV ;correct also crt
ld a,00h ;
ld (POSFLG),a ;
;
ASCE20: ld a,0ffh ;
ld (VCRFLG),a ;set verify correction flag
ld hl,(VCRCTR) ;
inc hl ;
ld (VCRCTR),hl ;inc the verify corr. ctr.
jp EOFPRC ;
;
SGNCHR: db 00h ;
VCRFLG: db 00h ;verify correction flag
KBCHR: db 00h ;
;
;the following are used to save and restore the 3 buffer pointers
;for the userbuffer,formatbuffer,crtbuffer.
;
SVEBFF: ld (SVEBF0),hl ;save hl-reg
ld hl,(SOFUBA) ;
ld (SVEBF1),hl ;
ld hl,(SOFCBA) ;
ld (SVEBF2),hl ;
ld hl,(SOFFBA) ;
ld (SVEBF3),hl ;
ld hl,(SVEBF0) ;restore hl-reg
ret ;
;
RSTBFF: ld (SVEBF0),hl ;
ld hl,(SVEBF1) ;
ld (SOFUBA),hl ;
ld hl,(SVEBF2) ;
ld (SOFCBA),hl ;
ld hl,(SVEBF3) ;
ld (SOFFBA),hl ;
ld hl,(SVEBF0) ;
ret ;
;
SVEBF0: dw 0000h ;
SVEBF1: dw 0000h ;
SVEBF2: dw 0000h ;
SVEBF3: dw 0000h ;
;
;
;the following routine will be used whenever the end-of-format
;character was found.
;
ENDFLD: ld a,0ffh ;
ld (EFOFLG),a ;
ld a,(DEMODE) ;
cp 02h ;
jp z,ENDFL1 ;
ld a,(CAVFLG) ;
cp 0ffh ;
ret z ;
ENDFL2: ld a,0h ;clear flags and ctr's
ld (FFLG),a ;
ld (FBFLG),a ;
ld (CLRFLG),a ;
ld (CBWFLG),a ;
ld (F03FLG),a ;
ld (FTMFLG),a ;
ld a,0ffh ;
ld (UPDFLG),a ;
ld hl,0h ;
ld (BCPCTR),hl ;
ld (FILCTR),hl ;
jp ENDFRM ;return to user interf. on end of form.
;
ENDFL1: ld a,(UPDFLG) ;
cp 0ffh ;
ret z ;
jp ENDFL2 ;
;
;the following stops the user from leaving the field without
;without using a function key on all right-adjust fields.
;on all other fields the field will be exited.
;
EFT: ld a,(DEMODE) ;
cp 01h ;verify mode?
jp nz,EOFLD ;go if not
ld a,(MINFLG) ;
cp 0ffh ;minus-flag set?(Zoned)
jp nz,EOFLD ;go if not
call RACHK ;check for right adjust fields
cp 00h ;
jp z,EOFLD ;go if it isnt.
ld a,(EFRCHD) ;
cp 0ffh ;
jp z,EFT1 ;
ld hl,(FILCTR) ;
ld (MXFLNG),hl ;
EFT1: ld a,0ffh ;
ld (EFRCHD),a ;set end-of-field-reached flag
ld a,(CADFLG) ;
cp 0ffh ;
jp z,EOFLD ;
ld a,(CBWFLG) ;
cp 0ffh ;
jp z,EOFLD ;
ld a,0ffh ;
ld (EFTFLG),a ;
jp CBWD4 ;go character backward.
;
EFTFLG: db 00h ;
EFRCHD: db 00h ;end of field reached flag
MXFLNG: dw 00h ;max.-field-length counted up.
;
;the following handles the end of field .
;
EOFLD: ld a,(CADFLG) ;
cp 0ffh ;
jp z,FLADV ;
ld a,0ffh ;
ld (EFLFLG),a ;
ld a,(CBWFLG) ;
cp 0ffh ;char.backw.flag set?
jp z,CBWD2 ;yes.
ld a,0ffh ;
ld (FFLG),a ;
ld a,0h ;
ld (FBFLG),a ;
ld (DUPFLG),a ;
ld (INTFLG),a ;
ld (EFTFLG),a ;
ld (CFLAG),a ;
call FLDCHK ;
ld a,0h ;
ld (EFLFLG),a ;
ld a,(FLDERR) ;
cp 0ffh ;
jp nz,REGPRC ;
ld a,0 ;
ld (FLDERR),a ;
ld (EFTFLG),a ;
jp KEYERR ;
;
EFLFLG: db 0h ;
;
;
;the following handles the key-errors by setting a message and
;requesting a reset-key (ESC).
;
KEYERR: ld a,03h ;set the
KEYER7: call DSPMSG ;entry-error message.
KEYER3: ld c,07h ;beep the
call co ;user
call CHRRD ;
cp RSTCHR ;escape character
jp z,KEYER1 ;yes
ld a,0ffh ;
jp KEYER7 ;wait for it
KEYER1: ld a,(FNCFLG) ;
cp 0ffh ;function flag set?
jp z,KEYER6 ;yes,its set.
ld a,(DEMODE) ;
cp 00h ;entry mode?
jp z,KEYER4 ;yes.
cp 01h ;verify mode?
jp z,KEYER5 ;yes.
KEYER6: ld a,00h ;
ld (DUPFLG),a ;clear the dup-flag
ld (FNCFLG),a ;clear the function-flag
ld (INTFLG),a ;clear the Int-flg (preventive measure)
ld a,(CFLAG) ;test
cp 0ffh ;call flag
jp z,KEYER2 ;its set
jp SETMSG ;restore the entry-message and continue
KEYER2: ld a,0h ;
ld (CFLAG),a ;
ret ;
;
KEYER4: ld hl,(EERCTR) ;
inc hl ;
ld (EERCTR),hl ;inc the entry-error ctr.
jp KEYER6 ;
;
KEYER5: ld hl,(VERCTR) ;
inc hl ;
ld (VERCTR),hl ;inc the verify-error ctr.
jp KEYER6 ;
;
;
;
ENTFLG: ds 1 ;entry-mode flag
;
;the following will analyse the function-key received from
;the keyboard and branch off to the respective routine.
;
FNKEY: ld a,0ffh ;
ld (FNFLG),a ;set function key flag
ld a,c ;character to a
cp CHRADV ;character advance?
jp z,CADV ;yes
cp CHRBWD ;character backward?
jp z,CBWD ;yes.
cp CTRLQ ;quit?
jp z,USRABT ;yes
cp HOME ;home?
jp z,HME ;yes.
cp CLRKEY ;
jp z,CLRREC ;yes clear key.
cp FADV ;field advance?
jp z,FLADV ;yes.
cp FBWD ;field backward?
jp z,FLBWD ;yes
cp CARTN ;carriage return?
jp z,SKRRAC ;check for skip/right adjust
cp CTRLK ;modify format chain key?
jp z,FMTCHK ;yes.
cp CTRLD ;dup-field?
jp z,DUPFLD ;yes.
cp NUMDUP ;additional dup-key (pf1) ?
jp z,DUPFLD ;yes.
cp CTRLA ;override-dup function?
jp z,OVRDUP ;yes.
cp FLDCRR ;field correction?
jp z,FCORR ;yes.
cp CTRLFR ;record-advance?
jp z,RECFOB ;yes
cp CTRLBR ;record-backward?
jp z,RECFOB ;yes.
cp CTRLZ ;insert record ?
jp z,INSREC ;yes.
cp CTRLC ;send key?
jp z,SNDCHK ;yes.
cp DCD ;display check digit?
jp z,DSPCD ;yes.
cp RGDSP ;display register?
jp z,DSPREG ;yes.
ld a,0ffh ;
ld (FNCFLG),a ;set function flag.
ld a,00h ;
ld (FNFLG),a ;clear function key flag
jp KEYERR ;must be an illegal function
FNFLG: db 00h ;function key flag
;
;
;the following handles the character-advance function key.
;
CADV: ld a,0ffh ;
ld (CADFLG),a ;
ld a,(DEMODE) ;
cp 02h ;update mode?
jp nz,OTMODE ;no , other mode's
CHRAD1: jp CHRAD2 ;
OTMODE: ld a,(RESFLG) ;
cp 0h ;
jp z,CHRAD2 ;
ld hl,0h ;
ld bc,(BCPCTR) ;
and a ;
sbc hl,bc ;backward pos.ctr zero?
jp z,KEYERR ;yes it is,dont allow advance.
CHRAD2: ld hl,00h ;
ld bc,(BCPCTR) ;
and a ;
sbc hl,bc ;
jp z,CHRAD3 ;
ld bc,(BCPCTR) ;
dec bc ;
ld (BCPCTR),bc ;decr.backw.pos ctr
CHRAD3: ld bc,(FILCTR) ;
inc bc ;
ld (FILCTR),bc ;inc the field length counter
jp NXTCHR ;
;
CADFLG: db 00h ;
;
;the following handles the character-backward function key.
;
CBWD: ld a,(EFLFLG) ;
cp 0ffh ;
jp nz,CBWD7 ;
ld hl,01h ;
ld bc,(FILCTR) ;
and a ;
sbc hl,bc ;go only if end-of-field-reached
jp nz,CBWD7 ;bypass if not
jp CBWD1 ;
CBWD7: ld bc,(FILCTR) ;
ld hl,0h ;
and a ;
sbc hl,bc ;field pos.ctr = zero ?
jp z,CBWD1 ;field crossing needed
dec bc ;
ld (FILCTR),bc ;dec field pos. ctr.
ld a,00h ;
ld (EFLFLG),a ;
ld hl,00h ;
and a ;
sbc hl,bc ;
jp nz,CBWD6 ;
ld a,0ffh ;
ld (STRFLG),a ;set the field start flag again.
CBWD6: ld bc,(BCPCTR) ;
inc bc ;inc the backward pos.ctr.
ld (BCPCTR),bc ;
CBWD4: ld bc,(SOFCBA) ;
dec bc ;dec the
dec bc ;
dec bc ;
dec bc ;crt buffer by four
ld (SOFCBA),bc ;
ld bc,(SOFFBA) ;
dec bc ;dec the
dec bc ;format buffer address
ld (SOFFBA),bc ;by two.
ld bc,(SOFUBA) ;
dec bc ;dec the
dec bc ;user buffer address
ld (SOFUBA),bc ;by two.
jp NXTCHR ;
;
;this handles field-backward crossing on character backward.
;
CBWD1: ld hl,(BFNO) ;
ld bc,1h ;
and a ;
sbc hl,bc ;check for field 1/pos.1.
jp z,GETCHR ;ignore CBWD if it is.
ld a,0ffh ;
ld (CBWFLG),a ;set character backward flag
ld (INTFLG),a ;set int-flag to inhibit cursor movem.
ld a,00h ;
ld (EFLFLG),a ;clear the end of field flag
jp FLBWD ;exit via field backward.
;
;control comes back here after field-backward resulting from
;previous character-backward has been issued by the application
;program.
;
CBWD2: ld a,(EFLFLG) ;
cp 0ffh ;end of field flag set?
jp z,CBWD3 ;yes.
ld hl,(FILCTR) ;
inc hl ;
ld (FILCTR),hl ;inc the field pos. ctr.
ld a,(MTCFLG) ;
cp 0ffh ;
jp z,CBWD5 ;
ld a,0ffh ;
ld (INTFLG),a ;set int-flag again.
jp NXTCHR ;keep looping
;
CBWD5: ld bc,(BCPCTR) ;
ld hl,0h ;
and a ;
sbc hl,bc ;
jp z,CBWD3 ;
dec bc ;
ld (BCPCTR),bc ;
jp CBWD2 ;
;
CBWD3: ld a,0h ;reset
ld (CBWFLG),a ;the character backward flag
ld (INTFLG),a ;reset intflag
ld (STRFLG),a ;reset the start-of-field flag
ld (EFLFLG),a ;reset end of field flag
ld (EFRCHD),a ;reset end-of-field-reached flag
ld hl,(BCPCTR) ;
inc hl ;
ld (BCPCTR),hl ;inc the backw.pos.ctr.
ld hl,(FILCTR) ;
dec hl ;adjust the field length counter.
ld (FILCTR),hl ;
ld bc,00h ;
and a ;
sbc hl,bc ;
jp nz,CBWD4 ;go if not one-pos.field.
ld hl,00h ;
ld (BCPCTR),hl ;
ld a,0ffh ;
ld (STRFLG),a ;
jp CBWD4 ;join the backward code.
;
;the following allows clearing (spacing) of the record held
;in user-buffer during update-mode.
;
;
CLRREC: ld a,(DEMODE) ;
cp 02h ;update mode?
jp z,CLRRE1 ;
ld a,0ffh ;
ld (FNCFLG),a ;
jp KEYERR ;
CLRRE1: ld bc,(UBFADD) ;clear the
ld hl,(VFPCTR) ;user buffer
ld a,20h ;
call INBUFF ;
;
ld a,0h ;clear the
ld (ENTFLG),a ;entry-mode-flag
ld a,0ffh ;set the
ld (CLRFLG),a ;clear function flag
jp FMTINT ;
;
CLRKY1: ld a,0h ;
ld (CLRFLG),a ;clear the clear-flag
jp DELREC ;ret to user interface.
;
CLRFLG: ds 1 ;
;
;
;the following handles the field-advance function.
;
FLADV: ld a,0ffh ;
ld (FFLG),a ;
ld a,0h ;
ld (FBFLG),a ;
call FLDCHK ;
ld a,(FLDERR) ;
cp 0ffh ;
jp nz,FLDADV ;
ld a,0h ;
ld (FLDERR),a ;
ld a,(CADFLG) ;
cp 0ffh ;
jp nz,KEYERR ;
ld a,00h ;
ld (CADFLG),a ;
; ld a,(EFRCHD) ;
ld a,(EFLFLG) ;
cp 0ffh ;
jp nz,KEYERR ;
ld a,0ffh ;
ld (EFTFLG),a ;set end of field flag
jp CBWD4 ;
jp KEYERR ;
;
;
FFLG: db 0h ;
;
;
;the following handles the field-backward function.
;
FLBWD: ld hl,(BFNO) ;
ld bc,1 ;
and a ;
sbc hl,bc ;
jp z,GETCHR ;ignore it , already at fld 1
ld a,0ffh ;
ld (FBFLG),a ;
ld a,0h ;
ld (FFLG),a ;
call FLDCHK ;
ld a,(FLDERR) ;
cp 0ffh ;
jp nz,FLDBWD ;
ld a,0h ;
ld (CBWFLG),a ;
ld (FLDERR),a ;
jp KEYERR ;
FLBWD1: ld a,0ffh ;
ld (FBFLG),a ;set fld-backw.flg
ld a,00h ;
ld (EFTFLG),a ;
jp FLDBWD ;
;
FBFLG: db 00h ;
;
;the following allows positioning into the first variable
;field of the current format.
;
HME: ld a,0ffh ;
ld (HMEFLG),a ;
call FLDCHK ;
ld a,(FLDERR) ;
cp 0ffh ;
jp nz,ENTHME ;
ld a,0h ;
ld (FLDERR),a ;
jp KEYERR ;
;
HMEFLG: db 0h ;
;
;the following handles the change-format-chain-key function
;
FMTCHK: ld a,0h ;
ld (BTCNT),a ;
ld a,(ATTBYT) ;
ld (ATTSVE),a ;
ld bc,(SOFCBA) ;
ld (SVFMT1),bc ;save current crt buffer pointer
ld bc,FPTTAB ;calc. format buffer
ld hl,(VFCTR) ;for last field (E)
dec hl ;
add hl,hl ;x2
add hl,hl ;x4
add hl,bc ;
ld c,(hl) ;
inc hl ;
ld b,(hl) ;
inc bc ;
push bc ;move it to
pop hl ;the hl reg
ld (SVFMT2),hl ;and save it
ld de,FCKDSP ;load display area in line 25
ld (SOFCBA),de ;
ld bc,3h ;
call BLMVE ;and move the FCK to line 25
ld a,0ffh ;set
ld (MLNFLG),a ;message line flag
call INCCRS ;set cursor to line 25
FMTCH4: ld a,84h ;
call DSPMSG ;set form.chain.key message
FMTCH3: call CHRRD ;get keyboard character
call CHKBTE ;check the character
cp 01h ;is it a numeric ? (30-39h)
jp nz,FMTCH1 ;no .
ld hl,(SOFCBA) ;
call CHRCNV ;display the character
inc hl ;
ld (SOFCBA),hl ;inc the crt-buffer
ld a,(BTCNT) ;get byte-count
cp 02h ;3rd byte?
jp z,FMTCH5 ;yes.
inc a ;
ld (BTCNT),a ;inc the byte count
ld a,0ffh ;
ld (MLNFLG),a ;set the message line flag
call INCCRS ;inc the cursor
jp FMTCH3 ;loop for next character
FMTCH1: ld a,c ;
cp 0dh ;carriage return ?
jp z,FMTCH6 ;prepare exit to user interface
cp RSTCHR ;escape character ?
jp z,FMTCH2 ;yes time to ret to entry-level
FMTCH7: ld a,0ffh ;
ld (CFLAG),a ;set call-flag.
call KEYERR ;do keystroke error
jp FMTCH4 ;loop for next character
FMTCH2: ld bc,FCKDSP ;
ld hl,3h ;
ld a,20h ;
call BLINIT ;clear message area
ld a,0ffh ;
ld (MLNFLG),a ;
ld hl,(SVFMT1) ;
ld (SOFCBA),hl ;
call INCCRS ;
ld a,(ATTSVE) ;
ld (ATTBYT),a ;
jp SETMSG ;restore the cursor
FMTCH5: ld a,0h ;
ld (BTCNT),a ;
ld hl,FCKDSP ;
ld (SOFCBA),hl ;
ld a,0ffh ;
ld (MLNFLG),a ;
call INCCRS ;
jp FMTCH3 ;set cursor back to pos.1 os mesg.area
;
;
FMTCH6: ld hl,FCKDSP ;
FMTCH9: ld a,(hl) ;
cp 30h ;
jp z,FMTCH8 ;
ld a,0ffh ;
ld (ZROFLG),a ;
FMTC10: inc hl ;
ld a,l ;
cp 0beh ;
jp nz,FMTCH9 ;
ld a,(ZROFLG) ;
cp 00h ;
jp z,FMTCH7 ;error,FCK all zeroes.
ld a,00h ;
ld (ZROFLG),a ;
ld de,FRMCHN ;move
ld hl,FCKDSP ;updated
ld bc,3 ;FCK to
FMTC11: ldi ;to FRMCHN in the CCB
inc hl ;
jp pe,FMTC11 ;loop until done
jp XFMT ;exit to user interface
;
FMTCH8: ld a,(ZROFLG) ;
cp 0ffh ;
jp z,FMTC10 ;
ld a,00h ;
ld (ZROFLG),a ;
jp FMTC10 ;
;
BTCNT: ds 1 ;byte count for FCK Display (0-3)
SVFMT1: ds 2 ;crt bufferaddress savearea
SVFMT2: ds 2 ;msg area address save address
ZROFLG: db 00h ;
;
;
TSTFLD: ld a,(AUTFLG) ;
cp 0ffh ;authorized flag set?
jp z,ENTRY3 ;yes.
ld a,(FBFLG) ;
cp 0ffh ;
jp z,BFDIR ;back.field.
ld hl,(BFNO) ;
inc hl ;
ld (BFNO),hl ;
jp FLDADV ;
;
BFDIR: ld hl,(BFNO) ;
ld bc,1 ;
and a ;
sbc hl,bc ;
jp z,BFDIR1 ;fwd.fld if on fld 1
ld hl,(BFNO) ;
dec hl ;
ld (BFNO),hl ;
jp FLDBWD ;
BFDIR1: ld a,0h ;
ld (FBFLG),a ;
ld a,0ffh ;
ld (FFLG),a ;
ld hl,(BFNO) ;
inc hl ;
ld (BFNO),hl ;
jp FLDADV ;
;
;the following sets aflag on FSB03-fields.
;
SETF03: ld a,(AUTFLG) ;
cp 0ffh ;authorized flag set?
jp z,ENTRY4 ;yes,bypass.
ld a,0ffh ;
ld (F03FLG),a ;
jp ENTRY3 ;
;
F03FLG: db 0h ;
;
;
;
;the following are the routines that do the setting,testing and
;clearing of the field-bit-mask table . for each variable
;field there will be one bit in the bit-mask table.
;if the bit for a corresponding field is set , the cursor may
;be moved within the complete field as the must have been entered
;previously. if the bit is not set , which means the field has not
;been touched yet, the cursor may not be positioned beyond the
;current cursor-position.
;
;
;STBMSK can be called to set the bit.
;TSBMSK will test the bit and ret with FFh in a-reg if set,else
; with 00h .
;CLBMSK will clear the complete bit-table to all zeroes.
;
STBMSK: ld de,0h ;
ld (BMCNT),de ;clear byte ctr.
ld (BITCNT),de ;clear bitcnt.
ld hl,(BFNO) ;
dec hl ;
ld bc,8 ;
STBMS1: and a ;
ld (BITCNT),hl ;
sbc hl,bc ;divide into no.of bytes.
jp m,STBMS2 ;go if no. of bytes found.
ld de,(BMCNT) ;
inc de ;
ld (BMCNT),de ;
jp STBMS1 ;loop back
STBMS2: ld bc,BMTAB ;form
ld hl,(BMCNT) ;the
add hl,bc ;byte offset address
ld ix,(BITCNT) ;
ld a,(TSTFLG) ;
cp 0ffh ;
jp nz,STBMS6 ;test-bit flag not set.
ld a,0h ;
ld (TSTFLG),a ;reset the flag .
ld de,STBMS7 ;
jp STBMS5 ;
STBMS6: ld de,STBMS3 ;
STBMS5: push ix ;
add ix,ix ;
add ix,ix ;
pop bc ;
add ix,bc ;ix-reg now multiplied by 5.
add ix,de ;
ld a,(hl) ;get the byte to a-reg.
jp (ix) ;branch off to appropriate bit-funct.
;
STBMS3: set 0,a ;set bit 0
jp STBMS4 ;
set 1,a ;set bit 1
jp STBMS4 ;
set 2,a ;
jp STBMS4 ;
set 3,a ;
jp STBMS4 ;
set 4,a ;
jp STBMS4 ;
set 5,a ;
jp STBMS4 ;
set 6,a ;
jp STBMS4 ;
set 7,a ;
jp STBMS4 ;
;
STBMS4: ld (hl),a ;store the updated byte (bit)
ret ;and return.
;
STBMS7: bit 0,a ;
jp STBMS8 ;
bit 1,a ;
jp STBMS8 ;
bit 2,a ;
jp STBMS8 ;
bit 3,a ;
jp STBMS8 ;
bit 4,a ;
jp STBMS8 ;
bit 5,a ;
jp STBMS8 ;
bit 6,a ;
jp STBMS8 ;
bit 7,a ;
jp STBMS8 ;
;
STBMS8: ret ;ret to caller
;
;
;the following will test the bit for the fieldnumber given in (BFNO)
;
TSBMSK: ld a,0ffh ;
ld (TSTFLG),a ;
call STBMSK ;
jp z,TSBMS1 ;
ld a,0ffh ;
ret ;ret if bit was set.
TSBMS1: ld a,0h ;
ret ;ret if bit was not set
;
;
;the following will clear the complete bit-mask to zero.
;
CLBMSK: ld bc,BMTAB ;
ld hl,16 ;number 0f bytes.
ld a,00h ;
call INBUFF ;
ret ;
;
;
BMCNT: dw 0000h ;bit-mask byte counter
BITCNT: dw 0000h ;bit-mask bit counter
TSTFLG: db 00h ;testbit flag.
;
BMTAB: ds 16 ;bit-mask table ,currently 16 bytes.
;
;THE FOLLOWING WILL CHECK WETHER A GIVEN FIELD MAY BE USED FOR
;MANUAL ENTRY AND THE CURSOR POSITIONED IN THIS FIELD.
;THIS IS USED TO EXTEND A FIELD-ADVANCE OR FIELD-BACKWARD
;OVER A AUTOMATIC OR RESTRICTED FIELD.
;
;
FLDCHK: ld a,0 ;
ld (FLDERR),a ;
ld hl,(BFNO) ;
ld (RESSV4),hl ;save BFNO
FLDC13: ld a,(HMEFLG) ;
cp 0ffh ;home-flag set?
jp z,FLDC11 ;yes.
ld a,(FFLG) ;
cp 0ffh ;forward field flag set?
jp z,FLDC12 ;yes.
dec hl ;must be backward field.
FLDC10: ld (BFNO),hl ;keep BFNO updated
dec hl ;allign with field-entry zero.
add hl,hl ;x2
add hl,hl ;x4
ld de,FPTTAB ;load field ptr,table start address
add hl,de ;and get pointer address to hl
ld e,(hl) ;
inc hl ;
ld d,(hl) ;field start address in form.buff.in de
ld hl,(BFNO) ;
ld a,(FFLG) ;
cp 0ffh ;
jp z,FLDCH9 ;bypass on forward-field.
;
;the following checks for duplicate format fields , which have an
;fsb of x6.
;
ld hl,(FBFADD) ;
and a ;
sbc hl,de ;
jp z,FLDC20 ;
ld hl,(BFNO) ;
dec de ;
ld a,(de) ;
ld c,0fh ;
and c ;
cp 06h ;
jp z,FLDC13 ;yes its a fsb x6
inc de ;
;
FLDC20: ld hl,(BFNO) ;
ld a,(FTMFLG) ;
cp 0ffh ;first-time flag set?
jp z,FLDCH9 ;yes,dont check for dup-fdb's
ld a,(de) ;get fdb.
cp 'D' ;
jp z,FLDC13 ;yes.
cp 'U' ;
jp z,FLDC13 ;yes.
cp 'L' ;
jp z,FLDC13 ;yes.
cp 'M' ;
jp z,FLDC13 ;yes.
cp '+' ;
jp z,FLDC13 ;yes.
cp '(' ;
jp z,FLDC13 ;
FLDCH9: ld a,(FFLG) ;
cp 0ffh ;
jp z,FLDCH7 ;
ld a,(de) ;
cp 'B' ;
jp z,FLDC13 ;yes.
cp 'Q' ;
jp z,FLDC13 ;
cp 'T' ;
jp z,FLDC13 ;
ld a,(DEMODE) ;
cp 01h ;verify mode?
jp nz,FLDCH7 ;no,go.
ld a,(de) ;
cp 'V' ;
jp z,FLDC13 ;
cp 'W' ;
jp z,FLDC13 ;
cp 'X' ;
jp z,FLDC13 ;
cp 'Y' ;
jp z,FLDC13 ;
cp 'Z' ;
jp z,FLDC13 ;
FLDCH7: ld a,(AUTFLG) ;
cp 0ffh ;authorized-flag set?
jp z,FLDCH2 ;yes bypass FSB-check
dec de ;get address to FSB
ld a,(de) ;possible FSB now in A
ld c,0fh ;
and c ;mask out upprer 4 bits
cp 02h ;display only FSB?
jp z,FLDC13 ;yes.
cp 04h ;no-display/no-update FSB?
jp z,FLDC13 ;yes.
FLDCH2: ld a,(DEMODE) ;
cp 02h ;
ret z ;
ld a,(EFLFLG) ;
cp 0ffh ;is the end-of-field flag set?
ret z ;yes,ret uncondit.
call TSBMSK ;
cp 0ffh ;
jp z,FLDCH1 ;go,if bit set
ld a,0ffh ;
ld (FLDERR),a ;
ld hl,(RESSV4) ;
ld (BFNO),hl ;restore original BFNO
ret ;not allowed in this mode.
FLDCH1: ld a,(RESFLG) ;
cp 0ffh ;
ret nz ;
ld hl,(RESSV4) ;
ld (RESSV1),hl ;
FLDCH3: ld bc,(FILCTR) ;
ld hl,0h ;
and a ;
sbc hl,bc ;
jp z,FLDCH4 ;
dec bc ;
ld (FILCTR),bc ;
ld bc,(BCPCTR) ;
inc bc ;
ld (BCPCTR),bc ;
jp FLDCH3 ;
FLDCH4: ld hl,(BCPCTR) ;
ld (RESSV2),hl ;save backward field pos.ctr.
ld a,0h ;
ld (RESFLG),a ;clear resume-flag
ret ;
;
FLDC11: ld hl,1h ;
ld (BFNO),hl ;
ld a,0h ;
ld (HMEFLG),a ;
ld (FBFLG),a ;clear the flags
ld a,0ffh ;
ld (FFLG),a ;set the forward flag
jp FLDC10 ;
;
;
FLDC12: inc hl ;
jp FLDC10 ;
;
;
FLDERR: db 0h ;
RESFLG: db 0h ;
RESSV1: dw 0000h ;
RESSV2: dw 0000h ;
RESSV3: dw 0000h ;
RESSV4: dw 0000h ;
MTCFLG: db 00h ;matched field flag
;
;the following will handle the moving of the userbuffer to the
;crt-buffer on update-mode.after the move control will be
;handed to the entry-routine.
;this routine is also used to move the user-buffer to the format-buffer
;during format-data mode.
;
UPDMV: ld a,(UPDFLG) ;
cp 00h ;update-mode flag reset?
jp z,ENTRY6 ;yes,bypass.
UPDM15: ld hl,(BFNO) ;
ld (UPDSVE),hl ;save bfno
ld a,0ffh ;
ld (INTFLG),a ;
ld (ENTFLG),a ;
ld (UPDFLG),a ;
ld hl,1h ;
ld (BFNO),hl ;set field to 1
UPDMV5: ld hl,(BFNO) ;
call ENTRY6 ;load all buffer-addresses
ld hl,(SOFFBA) ;
ld de,(FBFADD) ;
and a ;
sbc hl,de ;
ld hl,(SOFFBA) ;
jp z,UPDM44 ;bypass if fieldaddress=bufferstart
dec hl ;
ld a,(hl) ;
ld c,0fh ;
and c ;
cp 06h ;
jp z,UPDM43 ;
UPDM44: ld a,(EFOFLG) ;
cp 0ffh ;
jp z,UPDM13 ;end of format.
ld hl,(SOFFBA) ;
ld de,(FBFADD) ;
and a ;
sbc hl,de ;
jp z,UPDMV1 ;start of field=start of buffer.
ld hl,(SOFFBA) ;
dec hl ;
ld c,(hl) ;
ld a,(DEMODE) ;
cp 05h ;format-data mode?
jp nz,UPDM18 ;go if not.
ld a,08h ;
call DSPMSG ;set 'printout message'
ld a,80h ;
and c ;test bit 8
jp z,UPDM18 ;no , not set
ld a,20h ;
ld (hl),a ;space the field security byte
UPDM18: ld a,0fh ;
and c ;
cp 03h ;no-display FSB?
jp z,UPDMV2 ;yes.
cp 04h ;no-display/no-update.
jp z,UPDMV2 ;
ld a,00h ;
ld (F03FLG),a ;
UPDMV1: ld a,(F03FLG) ;
cp 0ffh ;
jp z,UPDMV3 ;no-display field
UPDM11: ld a,(CAVFLG) ;
cp 0ffh ;is the 'clear all var.fields'flag set?
jp nz,UPDMV8 ;jp if not.
ld a,2eh ;load aperiod.
jp UPDM10 ;
UPDMV8: ld hl,(SOFUBA) ;
ld a,(hl) ;
UPDM10: call WRTCHR ;
UPDMV4: call NXTFDB ;
call GENFSB ;inc all buffers,get next fdb
cp 0ffh ;
jp z,UPDMV6 ;
cp 20h ;
jp z,UPDMV6 ;
ld a,(DEMODE) ;
cp 05h ;
jp nz,UPDMV1 ;bypass following code if not mode 05
call CONST ;
cp 0ffh ;
jp nz,UPDMV1 ;
call CHRRD ;read character if one is waiting
cp CTRLQ ;user abort?
jp z,USRABT ;yes.
ld a,09h ;
call DSPMSG ;set 'printout halted' message
UPDM30: call CONST ;
cp 0ffh ;
jp nz,UPDM30 ;wait for another character
call CHRRD ;
cp CTRLQ ;
jp z,USRABT ;user abort during print halted.
ld a,08h ;
call DSPMSG ;display 'printout' message again
jp UPDMV1 ;
;
UPDMV6: ld hl,(BFNO) ;
inc hl ;
ld (BFNO),hl ;update bfno
ld a,00h ;
ld (F03FLG),a ;
jp UPDMV5 ;
;
UPDMV3: ld a,(AUTFLG) ;
cp 0ffh ;
jp z,UPDM11 ;authorized flag set.
ld a,2eh ;
call WRTCHR ;
jp UPDMV4 ;
;
UPDMV2: ld a,0ffh ;
ld (F03FLG),a ;set FSB-03 flag
jp UPDMV1 ;
;
UPDM13: ld a,(DEMODE) ;
cp 05h ;format-data mode?
jp nz,UPDM17 ;no.
ld bc,(SOFFBA) ;
ld hl,4h ;
ld a,20h ;
call INBUFF ;space the 4-character end of format.
ld de,(FBFADD) ;
ld hl,00h ;
ld (VFPCTR),hl ;clear the variable pos ctr
UPDM19: ld hl,(SOFFBA) ;
and a ;
sbc hl,de ;
jp z,UPDM17 ;all done
ld a,(de) ;get character from format buffer
ld c,a ;
ld a,80h ;test bit 7
and c ;
jp z,UPDM20 ;go if not set
ld a,20h ;
ld (de),a ;space that character
UPDM20: inc de ;bump the buffer pointer
ld hl,(VFPCTR) ;
inc hl ;
ld (VFPCTR),hl ;
jp UPDM19 ;keep looping
UPDM17: ld a,(CAVFLG) ;
cp 0ffh ;
jp z,UPDM14 ;
UPDMV7: ld a,00h ;
ld (UPDFLG),a ;
UPDM16: ld a,00h ;
ld (INTFLG),a ;
ld (ENTFLG),a ;
ld (F03FLG),a ;
ld (EFOFLG),a ;
ld (CAVFLG),a ;
ld hl,(UPDSVE) ;
ld (BFNO),hl ;
ld a,(DEMODE) ;
cp 05h ;format data mode?
jp z,ENDFRM ;
jp ENTRY ;
;
UPDMV9: ld a,(UPDFLG) ;
cp 0ffh ;
ret z ;
jp ENTRY7 ;
;
UPDM14: call CLBMSK ;
ld hl,00h ;
ld (BCPCTR),hl ;
ld (FILCTR),hl ;
ld a,(DEMODE) ;
cp 00h ;
jp nz,UPDM16 ;
ld bc,(UBFADD) ;
ld hl,(VFPCTR) ;
ld a,20h ;
call INBUFF ;
jp UPDM16 ;
;
UPDM43: ld hl,(BFNO) ;
inc hl ;
ld (BFNO),hl ;
ld a,00h ;
ld (F03FLG),a ;
jp UPDMV5 ;
;
;the following is used by the previous routine (UPDMV) to write
;a character from the user buffer to the screen (update-mode)
;or to the format-buffer (format-data-mode).
;
WRTCHR: ld c,a ;save character
ld a,(DEMODE) ;
cp 05h ;format update mode?
jp z,WRTCH1 ;yes.
ld hl,(SOFCBA) ;
call CHRCNV ;
ret ;
WRTCH1: ld hl,(SOFFBA) ;
ld a,80h ;
and c ;test bit 8
jp z,WRTCH2 ;go if not set
ld a,20h ;
ld (hl),a ;space the field security byte
ret ;
WRTCH2: ld (hl),c ;
ret ;
;
UPDSVE: dw 0000h ;
UPDFLG: db 0ffh ;
CAVFLG: db 00h ;clear all variable fields flag.
;
;
;the following will test the field start byte and set the
;num/alpha flag.it also saves the field start byte.
;
TSTFDB: ld a,(STRFLG) ;
cp 00h ;start flag reset?
jp z,TSTFD5 ;yes,filter the character
TSTFD9: ld a,00h ;
ld (STRFLG),a ;reset the field start flag
ld a,c ;
ld (LFSTB),a ;save the field start byte
ld hl,FDBDSP ;
ld a,(ATTBYT) ;
ld (ATTSVE),a ;save attribute byte
ld a,00h ;
ld (ATTBYT),a ;set normat display
call CHRCNV ;write fdb to line 25
ld a,(ATTSVE) ;
ld (ATTBYT),a ;restore attribute byte
ld a,(LFSTB) ;get last-field-start-byte
cp '+' ;is it autoinc field?
jp z,TSTFD2 ;yes , go straight to set num-flag.
;
;the following is an addittion to the RRZ-KASSEL system
;and has been commented out.
;
; cp '<' ;range check1?
; jp z,TSTFD2 ;
; cp '?' ;date field?
; jp z,TSTFD2 ;
; cp '(' ;date/dup field?
; jp z,TSTFD2 ;
; cp '=' ;range check2?
; jp z,TSTFD2 ;
ld b,41h ;
sub b ;subtract offset
ld hl,FDBTAB ;get fdb/fcc table
ld c,a ;
ld b,0h ;
add hl,bc ;get adress into table
ld a,(hl) ;get fcc-code for current fsb
cp 01h ;alpha type?
jp z,TSTFD1 ;yes
cp 02h ;num.-type?
jp z,TSTFD2 ;yes.
cp 03 ;num-dup?
jp z,TSTFD2 ;yes
cp 04h ;alp-dup?
jp z,TSTFD1 ;yes.
jp ILLFRM ;anything else is illegal(format error)
;
TSTFD1: ld a,0ffh ;
ld (ALPFLG),a ;set alpha flag.
ld a,00h ;
ld (NUMFLG),a ;reset num flag.
jp TSTFD3 ;
;
TSTFD2: ld a,0ffh ;
ld (NUMFLG),a ;
ld a,00h ;
ld (ALPFLG),a ;
jp TSTFD3 ;
;
TSTFD3: ld a,(CBWFLG) ;
cp 0ffh ;
jp z,CBWD2 ;
ld a,(LFSTB) ;
cp 'B' ;uncond.branch field?
jp z,BRFLD ;
cp 'T' ;register readout with reg.clear?
jp z,TFLD ;yes go T-field.
cp 'Q' ;register readout?
jp z,QFLD ;yes go Q-field.
cp '?' ;date-field
jp nz,TSTF16 ;bypass if not.
ld a,0ffh ;
ld (DTEFLG),a ;set date-flag
jp TSTFD7 ;
TSTF16: cp '(' ;date/dup field?
jp nz,TSTF15 ;
ld a,(FTMFLG) ;
cp 0ffh ;
jp nz,DUPCHK ;
ld a,0ffh ;
ld (DTEFLG),a ;set date-flag
jp TSTFD7 ;
TSTF15: cp '<' ;range check 1 field?
jp nz,TSTF11 ;bypass if not.
ld a,0ffh ;
ld (RC1FLG),a ;set range-check 1 flag.
jp TSTFD7 ;
TSTF11: cp '=' ;range check 2 field?
jp nz,TSTF12 ;bypass if not.
ld a,0ffh ;
ld (RC2FLG),a ;
jp TSTFD7 ;
TSTF12: call RACHK ;test for right adjust field
cp 0ffh ;
jp nz,TSTFD6 ;no right adjust field
ld a,c ;
ld (RAFCHR),a ;save 'should be right adjust fill chr'
ld a,(DEMODE) ;
cp 01h ;verify mode
jp z,RAVER ;yes.
TSTFD6: ld a,(DEMODE) ;
cp 01h ;verify mode?
jp nz,TSTFD7 ;no.
ld a,(LFSTB) ;
cp 'V' ;numeric bypass on verify?
jp z,BRFLD ;yes.
cp 'W' ;alphanum bypass on verify?
jp z,BRFLD ;yes
cp '+' ;
jp z,BRFLD ;autoincrement field.
TSTFD7: ld a,(FTMFLG) ;
cp 00h ;
jp z,TSTFD4 ;first-time flag is reset..
call ASDOFF ;reset the autom.skip/dup message.
ld a,(DUPFLG) ;
cp 0ffh ;dup-flag set?
jp z,DUPCHK ;yes
jp SETMSG ;
;
TSTFD4: call ASDON ;set the autom.skip/dup msg.
ld a,(LFSTB) ;get fdb again.
cp 'D' ;D field?
jp z,DUPCHK ;yes.
cp 'U' ;U field?
jp z,DUPCHK ;yes.
cp 'L' ;L field?
jp z,DUPCHK ;
cp 'M' ;M field?
jp z,DUPCHK ;yes.
cp '+' ;auto inc field?
jp z,AUTINC ;yes.
cp 'S' ;num.skip?
jp z,NUMSKP ;yes.
cp 'K' ;alpha skip?
jp z,ALPSKP ;yes.
cp 'F' ;f-field?
jp z,NUMSKP ;yes.
cp 'G' ;G-field?
jp z,NUMSKP ;yes.
jp SETMSG ;
;
TSTFD5: ld a,(EFTFLG) ;
cp 0ffh ;
jp nz,TSTFD8 ;
ld hl,(FILCTR) ;
ld de,01h ;
and a ;
sbc hl,de ;
jp z,TSTFD9 ;go on 1-position field length
TSTFD8: ld a,(FNFLG) ;
cp 00h ;function key flag set?
jp z,TSTF10 ;go if not.
ld a,00h ;
ld (FNFLG),a ;clear the flag
ld hl,(FILCTR) ;
ld de,00h ;
and a ;
sbc hl,de ;filctr = 0 ?
jp z,TSTFD9 ;go and allow start of field.
; ld a,(EFRCHD) ;
ld a,(EFLFLG) ;
cp 0ffh ;
jp nz,TSTF10 ;
ld de,01h ;
ld hl,(FILCTR) ;
and a ;
sbc hl,de ;
jp z,TSTFD9 ;allow start of field
TSTF10: ld a,c ;
cp 3bh ;semicolon?
jp z,CNTFDB ;yes
cp 3ah ;colon?
jp z,CNTFDB ;yes.
cp '-' ;num fcc
jp z,CNTFDB ;
cp '.' ;alpha fcc?
jp z,CNTFDB ;
jp REGCHK ;no,must be a register
;
DTEFLG: db 00h ;date flag
RC1FLG: db 00h ;range check 1 flag
RC2FLG: db 00h ;range check 2 flag
;
;the following handles the verifying of the right adjust-fill charact.
;and checks first for right adjust bypass fsb's during verify
;
RAVER: ld a,(LFSTB) ;
cp 'X' ;
jp z,BRFLD ;
cp 'Y' ;
jp z,BRFLD ;
cp 'Z' ;
jp z,BRFLD ;
RAVER2: ld de,(SOFUBA) ;
ld hl,(SOFCBA) ;
ld a,(RAFCHR) ;get 'should-be' fill character
ld c,a ;to c-reg.
ld a,(de) ;get 'is' character to a-reg
cp c ;do they match?
jp z,RAVER1 ;yes.
;
;the following accepts blanks in a zero-fill field (type R) as
;legal fill characters during verify.
;
ld a,(LFSTB) ;
cp 'R' ;right adjust/zero fill type?
jp nz,SETMSG ;no.
ld a,(de) ;get 'is' character from user buffer
cp ' ' ;fill char. = blank?
jp nz,SETMSG ;go if it is not.
ld (RAFCHR),a ;set r/a fill character to blank
RAVER1: ld a,(RAFCHR) ;
ld c,a ;
call CHRCNV ;display the fill character
ld hl,(FILCTR) ;
inc hl ;
ld (FILCTR),hl ;
call NXTFDB ;
call GENFSB ;
cp 0ffh ;
jp z,NXTLPE ;end of field(only fill chars found)
cp 20h ;
jp z,NXTLPE ;end of field (only fill-characters)
ld a,0ffh ;
ld (CFLAG),a ;
call REGCHK ;
ld a,00h ;
ld (CFLAG),a ;
jp RAVER2 ;keep looping
;
RAFCHR: db 00h ;save for right-adjust fill character
;
;the following will check the register code (*,1-9,A-O) and
;set the respective flags.
;
REGCHK: ld a,(STRFLG) ;
cp 0ffh ;field start flag set?
jp z,REGC99 ;yes,illegal format.
ld a,(NUMFLG) ;
cp 00h ;num-flag reset?
jp z,REGC99 ;yes,illegal format.
ld a,c ;
cp '*' ;mul-reg?
jp z,REGCH0 ;yes.
cp '1' ;reg.1?
jp z,REGCH1 ;yes
cp '2' ;comment as before
jp z,REGCH2 ;
cp '3' ;
jp z,REGCH3 ;
cp '4' ;
jp z,REGCH4 ;
cp '5' ;
jp z,REGCH5 ;
cp '6' ;
jp z,REGCH6 ;
cp '7' ;
jp z,REGCH7 ;
cp '8' ;
jp z,REGCH8 ;
cp '9' ;
jp z,REGCH9 ;
cp 'A' ;
jp z,REGC10 ;
cp 'B' ;
jp z,REGC11 ;
cp 'C' ;
jp z,REGC12 ;
cp 'D' ;
jp z,REGC13 ;
cp 'E' ;
jp z,REGC14 ;
cp 'F' ;
jp z,REGC15 ;
cp 'G' ;
jp z,REGC16 ;
cp 'H' ;
jp z,REGC17 ;
cp 'I' ;
jp z,REGC18 ;
cp 'J' ;
jp z,REGC19 ;
cp 'K' ;
jp z,REGC20 ;
cp 'L' ;
jp z,REGC21 ;
cp 'M' ;
jp z,REGC22 ;
cp 'N' ;
jp z,REGC23 ;
cp 'O' ;
jp z,REGC24 ;
ld a,(CFLAG) ;
cp 0ffh ;
ret z ;return if call flag set
jp ILLFRM ;anything else is illegal format.
REGCH0: ld a,0ffh ;
ld (R0FLG),a ;
jp REGCK1 ;
REGCH1: ld a,0ffh ;
ld (R1FLG),a ;
jp REGCK1 ;
REGCH2: ld a,0ffh ;
ld (R2FLG),a ;
jp REGCK1 ;
REGCH3: ld a,0ffh ;
ld (R3FLG),a ;
jp REGCK1 ;
REGCH4: ld a,0ffh ;
ld (R4FLG),a ;
jp REGCK1 ;
REGCH5: ld a,0ffh ;
ld (R5FLG),a ;
jp REGCK1 ;
REGCH6: ld a,0ffh ;
ld (R6FLG),a ;
jp REGCK1 ;
REGCH7: ld a,0ffh ;
ld (R7FLG),a ;
jp REGCK1 ;
REGCH8: ld a,0ffh ;
ld (R8FLG),a ;
jp REGCK1 ;
REGCH9: ld a,0ffh ;
ld (R9FLG),a ;
jp REGCK1 ;
REGC10: ld a,0ffh ;
ld (R10FLG),a ;
jp REGCK1 ;
REGC11: ld A,0ffh ;
ld (R11FLG),a ;
jp REGCK1 ;
REGC12: ld a,0ffh ;
ld (R12FLG),a ;
jp REGCK1 ;
REGC13: ld a,0ffh ;
ld (R13FLG),a ;
jp REGCK1 ;
REGC14: ld a,0ffh ;
ld (R14FLG),a ;
jp REGCK1 ;
REGC15: ld a,0ffh ;
ld (R15FLG),a ;
jp REGCK1 ;
REGC16: ld a,0ffh ;
ld (R16FLG),a ;
jp REGCK1 ;
REGC17: ld a,0ffh ;
ld (R17FLG),a ;
jp REGCK1 ;
REGC18: ld a,0ffh ;
ld (R18FLG),a ;
jp REGCK1 ;
REGC19: ld a,0ffh ;
ld (R19FLG),a ;
jp REGCK1 ;
REGC20: ld a,0ffh ;
ld (R20FLG),a ;
jp REGCK1 ;
REGC21: ld a,0ffh ;
ld (R21FLG),a ;
jp REGCK1 ;
REGC22: ld a,0ffh ;
ld (R22FLG),a ;
jp REGCK1 ;
REGC23: ld a,0ffh ;
ld (R23FLG),a ;
jp REGCK1 ;
REGC24: ld a,0ffh ;
ld (R24FLG),a ;
jp REGCK1 ;
;
REGCK1: ld a,0ffh ;
ld (REGFLG),a ;
ld a,(CBWFLG) ;
cp 0ffh ;char.bwd set?
jp z,CBWD2 ;yes,return here.
ld a,(CFLAG) ;
cp 0ffh ;
ret z ;return if call flag set.
jp SETMSG ;
;
REGC99: ld a,(CFLAG) ;
cp 0ffh ;
ret z ;ret if call flag set
jp ILLFRM ;otherwise illegal format.
;
;
;the following checks the field start byte to field cont.byte
;relationship and set appropriate flags.
;
CNTFDB: ld a,c ;get fcc to a
cp '+' ;
jp z,TSTFDB ;filter out auto inc.start byte
cp '(' ;
jp z,TSTFDB ;
ld a,(STRFLG) ;
cp 0ffh ;
jp z,ILLFRM ;
ld a,c ;get fcc to a again
cp '*' ;
jp z,REGCHK ;
cp '-' ;
jp z,CNTFD5 ;numeric fcc
cp '.' ;
jp z,CNTFD2 ;alpha fcc.
cp ':' ;
jp z,CNTFD3 ;num. must-field
cp ';' ;
jp z,CNTFD4 ;alpha must-field
cp '?' ;
jp z,TSTFDB ;
cp '(' ;
jp z,TSTFDB ;
cp '<' ;
jp z,TSTFDB ;
cp '=' ;
jp z,TSTFDB ;
jp ILLFRM ;anything else is illegal format
CNTFD2: ld a,(ALPFLG) ;
cp 00h ;alpha-flag reset?
jp z,ILLFRM ;illegal: alpha fcc but non-alpha fsc
jp CNTFD5 ;
CNTFD3: ld a,0ffh ;
ld (MFFLG),a ;set must fill flag
jp CNTFD5 ;
CNTFD4: ld a,0ffh ;
ld (MFFLG),a ;set must fill flag
jp CNTFD2 ;
CNTFD5: ld a,(CBWFLG) ;
cp 0ffh ;char.bwd.flag set?
jp z,CBWD2 ;yes.
ld a,00h ;
ld (MFFLG),a ;reset the must fill flag
jp SETMSG ;
;
;
;the following will check the alpha-flag for every alpha-character
;
ALPCHR: ld a,(ALPFLG) ;
cp 00h ;
jp z,ALPCH1 ;
jp ASCENT ;
;
;
;the following allows blanks to be duped into a numeric field.
;it also allows the minus to be entered on numeric right adjust fields.
;
ALPCH1: ld a,(DUPFLG) ;
cp 0ffh ;dup-flag set.
jp z,ASCENT ;
ld a,c ;
cp '-' ;minus?
jp nz,KEYERR ;no must be an error.
ld (ALPSV),a ;
call RACHK ;check for right adjust.
cp 0ffh ;
jp nz,KEYERR ;error.
ld a,(DEMODE) ;
cp 01h ;
jp z,ALPCH2 ;
ld a,0ffh ;
ld (MINFLG),a ;set minus flag
jp EOFPRC ;process the right adjust
;
ALPCH2: ld a,(MINFLG) ;
cp 0ffh ;
jp z,EOFPRC ;
ld a,0ffh ;
ld (POSFLG),a ;
jp ASCE13 ;
;
MINFLG: db 00h ;
POSFLG: db 00h ;
ALPSV: db 00h ;
;
;the following will check the num.-flag for every numeric character
;
NUMCHR: ld a,(NUMFLG) ;
cp 00h ;
jp z,ALPCHR ;could be a numeric in an alpha field
jp ASCENT ;
;
;
MFFLG: db 00h ;must fill flag
ALPFLG: db 00h ;alpha-flag
NUMFLG: db 00h ;numeric flag
STRFLG: db 00h ;start of field flag
;
;the following allows manual entry into one autom. dup.-field
;of the current record by setting the 'first-time-flag'.
;
OVRDUP: ld a,0ffh ;
ld (FTMFLG),a ;set the first time flag
jp SETMSG ;
;
;
;the following prevents automatic duplication during update mode
;
DUPCHK: ld a,(DEMODE) ;
cp 02h ;
jp nz,DUPFLD ;allow duping on non-update mode
ld a,00h ;
ld (DUPFLG),a ;clear dupflag
jp SETMSG ;go to manual entry loop
;
;
;the following moves a character from the dup-buffer to the a-reg
;on all dup-fields or dup-functions. It kind of simulates a keyboard
;entry during such situations.
;
DUPFLD: ld a,(EFTFLG) ;
cp 0ffh ;
jp z,EOFLD ;go if end of field
call CONST ;read console status
cp 0ffh ;character waiting?
jp nz,DUPFL1 ;go if not.
call CHRRD ;get keyboard character
cp CTRLA ;reset auto-dup function?
jp z,OVRDUP ;yes.
DUPFL1: ld a,(DEMODE) ;
cp 00h ;entry mode?
jp nz,DUPFL9 ;
call RACHK ;
cp 00h ;right adjust field?
jp z,DUPFL9 ;no
ld hl,(FILCTR) ;
ld bc,00h ;
and a ;
sbc hl,bc ;
jp z,DUPFL9 ;allow dup in right adj.fld.on filctr=0
ld a,(DUPFLG) ;
cp 0ffh ;
jp z,DUPFL9 ;
ld a,0ffh ;
ld (FNCFLG),a ;set function flag
ld a,02h ;
call DSPMSG ;
jp KEYER3 ;
DUPFL9: ld a,0ffh ;
ld (DUPFLG),a ;
ld de,(UBFADD) ;
ld hl,(SOFUBA) ;
and a ;
sbc hl,de ;get user buffer offset to hl
ld de,DUPBFF ;
add hl,de ;start of field in dup-buffer now in hl
ld c,(hl) ;get character to c-reg
ld a,(hl) ;and to a-reg
jp GETCH1 ;and join the entry-loop again.
;
;the following 2048-byte definition defines the dup-buffer
;
DUPBFF: ds 2048 ;
;
;
;the following will handle the record forward/backward function.
;
RECFOB: ld c,a ;save a
ld a,(DEMODE) ;
cp 02h ;update-mode?
jp nz,RECFO1 ;no,dont allow it.
ld a,c ;
cp CTRLFR ;record-advance?
jp z,RECADV ;exit to user interface.
RECFO1: ld a,c ;
cp CTRLBR ;record-backward?
jp z,RECFO2 ;go and check mode.
jp SKIP1 ;function illegal for current mode.
;
RECFO2: ld a,(DEMODE) ;
cp 01 ;verify mode?
jp z,SKIP1 ;yes,dont allow backw.record.
jp RECBWD ;perform record backward.
;
;skip or right adjust check.
;
SKRRAC: call MFLCHK ;
cp 0ffh ;must fill situation?
jp z,SKRRA1 ;yes.
call RACHK ;
cp 00h ;
jp z,SKIP ;
ld a,(DEMODE) ;
cp 01h ;verify mode?
jp nz,EOFPRC ;no.
ld a,(MINFLG) ;
cp 0ffh ;
jp z,ASCE13 ;handle sign error
jp EOFPRC ;
;
;the following handles the error on must fill situations
;
SKRRA1: ld a,10 ;
call DSPMSG ;
ld a,0ffh ;
ld (FNCFLG),a ;
ld (CFLAG),a ;
call KEYER3 ;
ld a,00h ;
ld (FNCFLG),a ;
jp SETMSG ;
;
;the following handles the skip-field function.
;the routine will fill the remainder of the field with blanks
;and exit the field.
;
SKIP: ld a,(EFTFLG) ;
cp 0ffh ;
jp z,EOFLD ;
ld a,20h ;
ld (SKPCHR),a ;set skip character
SKIP99: ld a,0ffh ;
ld (INTFLG),a ;set INT flag
SKIP2: ld a,(SKPCHR) ;
ld hl,(SOFUBA) ;
cp 0ffh ;
jp z,SKIP3 ;must be uncond.branch skip
ld a,(DEMODE) ;
cp 01h ;verify mode?
jp z,SKIP5 ;yes
ld a,(SKPCHR) ;
ld (hl),a ;space user buffer
ld hl,(FILCTR) ;
inc hl ;
ld (FILCTR),hl ;
SKIP4: ld hl,(SOFCBA) ;
ld c,a ;
call CHRCNV ;
ld a,0ffh ;
ld (SKPFLG),a ;
call ASCE14 ;
ld a,00h ;
ld (SKPFLG),a ;
call NXTFDB ;
call GENFSB ;
cp 0ffh ;end of field?
jp z,EOFLD ;
cp 20h ;
jp z,EOFLD ;end of field?
ld a,0ffh ;
ld (CFLAG),a ;
call REGCHK ;
ld a,00h ;
ld (CFLAG),a ;
jp SKIP2 ;go for next character.
;
SKIP1: ld a,0ffh ;
ld (FNCFLG),a ;
jp KEYERR ;
;
SKIP3: ld a,(hl) ;get character from user buffer
jp SKIP4 ;
;
SKIP5: ld hl,(SOFUBA) ;get character from user buffer
ld a,(hl) ;to a-reg.
ld c,a ;
ld a,(SKPCHR) ;get skip-fill character
cp c ;
jp nz,SKIP6 ;dont match.
ld a,(SKPCHR) ;
jp SKIP4 ;no match.
SKIP6: ld a,00h ;
ld (INTFLG),a ;reset INTFLG
call INCCRS ;set the cursor
ld a,0ffh ;
ld (SKPFLG),a ;set skip-flag
jp ASCEN4 ;handle verify error.
;
SKPCHR: db 00h ;skip fill character
SKPFLG: db 00h ;skip flag,prevents increm. the FILCTR
;
;the following handles the unconditional branch (B) which fills
;the field with all blanks on all modes.
;
BRFLD: ld a,0ffh ;
ld (SKPCHR),a ;set skip fill chr. to bypass .
jp SKIP99 ;
;
;
;the following handles the insert record function
;
INSREC: ld a,(DEMODE) ;
cp 02h ;
jp z,INSRCD ;
ld a,0ffh ;
ld (FNCFLG),a ;
jp KEYERR ;
;
;this will allow skipping of fields with zero-filling of the field.
;
NUMSKP: ld a,30h ;
ld (SKPCHR),a ;
jp SKIP99 ;
;
;this allows skipping of field with blank-filling of field.
;
ALPSKP: ld a,20h ;
ld (SKPCHR),a ;
jp SKIP99 ;
;
;
;the following sets/resets the autom.skip/dup (ASD) message.
;
ASDON: LD A,(ATTBYT) ;
LD (ATTSVE),a ;
ld a,00h ;
ld (ATTBYT),a ;
ld de,ASDDSP ;
ld hl,ONMSG ;
ld bc,03h ;
call BLMVE ;
ld a,(ATTSVE) ;
ld (ATTBYT),a ;
ret ;
;
ONMSG: db 'ASD' ;
;
ASDOFF: ld a,(ATTBYT) ;
ld (ATTSVE),a ;
ld a,00h ;
ld (ATTBYT),a ;
ld de,ASDDSP ;
ld hl,OFFMSG ;
ld bc,03h ;
call BLMVE ;
ld a,(ATTSVE) ;
ld (ATTBYT),a ;
ret ;
;
OFFMSG: db ' ' ;
;
;
;the following will check for a must-fill situation and return with
;the a-reg set to 0ffh if it is , and with a-reg equal zero if not.
;
MFLCHK: ld a,(ATTBYT) ;
ld (ATTSVE),a ;
ld a,(EFTFLG) ;
cp 0ffh ;
jp z,MFLCH6 ;bypass check if end-of-format flag set
call SVEBFF ;save current buffers
MFLCH7: ld a,0ffh ;
ld (INTFLG),a ;set cursor inc inhibit flag
MFLCH3: call GENFSB ;
cp 20h ;end of format?
jp z,MFLCH1 ;yes
cp 0ffh ;end of format?
jp z,MFLCH1 ;yes
ld a,c ;
cp ';' ;alpha must fill
jp z,MFLCH2 ;yes.
cp ':' ;numeric must fill?
jp z,MFLCH2 ;yes.
call NXTFDB ;
jp MFLCH3 ;keep looping
;
MFLCH2: ld a,0ffh ;
ld (MFFLG),a ;set must fill flag
;
MFLCH1: call RSTBFF ;
ld a,00h ;
ld (INTFLG),a ;
ld a,(MFFLG) ;
cp 0ffh ;
jp z,MFLCH4 ;must fill flag set.
;
MFLCH5: ld a,(LFSTB) ;
cp 'H' ;
jp z,MFLCH2 ;
cp 'C' ;
jp z,MFLCH2 ;
cp 'F' ;
jp z,MFLCH2 ;
cp 'G' ;
jp z,MFLCH2 ;
cp 'L' ;
jp z,MFLCH2 ;
cp 'M' ;
jp z,MFLCH2 ;
cp 'O' ;single must fill field?
jp z,MFLCH8 ;
cp 'P' ;
jp z,MFLCH8 ;
ld a,(DEMODE) ;
cp 01h ;verify mode?
jp nz,MFLCH6 ;go 'no-must-fill
ld a,(LFSTB) ;
cp 'J' ;
jp z,MFLCH2 ;
cp 'R' ;
jp z,MFLCH2 ;
cp 'I' ;
jp z,MFLCH2 ;
MFLCH6: ld a,(ATTSVE) ;
ld (ATTBYT),a ;
ld a,00h ;
ret ;return on no must fill situation
;
MFLCH4: ld a,(ATTSVE) ;
ld (ATTBYT),a ;
ld a,0ffh ;
ret ;ret on must fill situation
;
MFLCH8: ld hl,(FILCTR) ;
ld de,00h ;
and a ;
sbc hl,de ;at least one character entered?
jp z,MFLCH2 ;go if not.
jp MFLCH6 ;yes,must fill satisfied.
;
;the following checks for must-fill fields before allowing a SEND-key
;to go thru. on update mode the check will be bypassed.
;
SNDCHK: ld a,(DEMODE) ;
cp 02h ;update mode?
jp z,ENTSND ;go straight thru
cp 01h ;verify mode?
jp z,ENTSND ;go to send (RRZ-KASSEL VERSION)
ld (SNDSV2),a ;
call SVEBFF ;save all buffer pointers
ld hl,(BFNO) ;
ld (SNDSV1),hl ;save current field number
call MFLCHK ;check rest of current field
cp 0ffh ;
jp z,SNDCH1 ;must-fill in current field
ld a,(MFFLG) ;
ld (SNDSV4),a ;save current state of must fill flag
ld a,02h ;
ld (DEMODE),a ;fake update mode
ld a,0ffh ;
ld (UPDFLG),a ;set update flag
ld a,(LFSTB) ;
ld (SNDSV3),a ;save current field start byte
SNDCH3: ld hl,(BFNO) ;
inc hl ;
ld (BFNO),hl ;inc the field number
call ENTRY6 ;calculate buffer pointers for nxt fld.
ld a,(EFOFLG) ;
cp 0ffh ;
jp z,SNDCH2 ;all fields checked
ld hl,(SOFFBA) ;
ld a,(hl) ;
ld (LFSTB),a ;
call MFLCH7 ;check next field
cp 0ffh ;
jp z,SNDCH1 ;go on must fill fields
jp SNDCH3 ;go for next field
SNDCH1: ld a,10 ;
call DSPMSG ;set 'must fill' msg
ld a,0ffh ;
ld (FNCFLG),a ;set function flag
ld (CFLAG),a ;set call flag
call KEYER3 ;handle the must-fill error
ld a,00h ;
ld (FNCFLG),a ;reset function flag
ld a,(SNDSV4) ;
ld (MFFLG),a ;restore must fill flag
call SNDRST ;restore all buffer pointers and flags
jp SETMSG ;and return to the entry-loop
;
SNDCH2: call SNDRST ;restore all bufferpointers and flags
jp ENTSND ;and return to user interface
;
SNDRST: call RSTBFF ;restore the buffer pointers
ld hl,(SNDSV1) ;
ld (BFNO),hl ;restore field number
ld a,(SNDSV2) ;
ld (DEMODE),a ;restore demode
ld a,00h ;
ld a,(SNDSV3) ;restore
ld (LFSTB),a ;field start byte
ld (UPDFLG),a ;reset update flag
ld (EFOFLG),a ;reset end of format flag
ret ;
;
SNDSV1: dw 0000h ;
SNDSV2: db 00h ;
SNDSV3: db 00h ;
SNDSV4: db 00h ;
;
;the following handles the duplication of format data on entry mode
;only.
;
DFFLD: ld hl,(BFNO) ;
inc hl ;
ld (BFNO),hl ;update to next field number
ld a,00h ;
ld (DFFLG),a ;clear the duplicate format flag.
ld a,(DEMODE) ;
cp 00h ;
jp nz,ENTCPL ;go end-of-field if not entry-mode.
DFFLD1: call GENFSB ;
cp 0ffh ;closing FSB found?
jp z,ENTCPL ;yes,go to end the field.
ld de,(UBFADD) ;
ld hl,(SOFUBA) ;
and a ;
sbc hl,de ;get userbuffer offset to hl-reg.
ld de,DUPBFF ;
add hl,de ;get start in dup-buffer to hl-reg.
ld a,(hl) ;
ld hl,(SOFUBA) ;
ld (hl),a ;move char. from dup-bff to usrbff
ld hl,(FILCTR) ;
inc hl ;
ld (FILCTR),hl ;inc the fld. length ctr.
call NXTFDB ;
jp DFFLD1 ;keep looping till end of field.
;
DFFLG: db 00h ;duplicate format flag.
;
end
«eof»