mirror of https://github.com/wwarthen/RomWBW.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
8111 lines
144 KiB
8111 lines
144 KiB
;Assembles with Al Hawley's ZMAC as is
|
|
;Rename to ZDE17.Z80 for ZASM (Cromemco ASMB)
|
|
; .Z80 ;Uncomment these two lines and rename
|
|
; ASEG ;to ZDE17.MAC for M80
|
|
;(use RELHEX to convert ZDE17.REL to ZDE17.HEX)
|
|
;
|
|
;*** ZDE assembly sequence
|
|
;
|
|
CR EQU 0DH ;ASCII stuff
|
|
LF EQU 0AH
|
|
FF EQU 0CH
|
|
BS EQU 08H
|
|
TAB EQU 09H
|
|
ESC EQU 1BH
|
|
DEL EQU 7FH
|
|
BEL EQU 07H
|
|
EOF EQU 1AH
|
|
X EQU 80H ;hibit
|
|
;
|
|
BDOSep EQU 0005h ;BDOS stuff
|
|
FCB EQU 005Ch
|
|
FCBt1 EQU FCB+9
|
|
FCBex EQU FCB+12
|
|
FCBs1 EQU FCB+13
|
|
FCBd0 EQU FCB+16
|
|
FCBcr EQU FCB+32
|
|
FCBr0 EQU FCB+33
|
|
FCBr1 EQU FCB+34
|
|
FCBr2 EQU FCB+35
|
|
DMA EQU 0080h
|
|
;
|
|
LSTO EQU 5
|
|
UCON EQU 6
|
|
CPMV EQU 12
|
|
RSTD EQU 13
|
|
SELD EQU 14
|
|
FOPN EQU 15
|
|
FCLO EQU 16
|
|
SRCH EQU 17
|
|
SRCN EQU 18
|
|
FDEL EQU 19
|
|
RSEQ EQU 20
|
|
WSEQ EQU 21
|
|
FMAK EQU 22
|
|
FREN EQU 23
|
|
GDRV EQU 25
|
|
SDMA EQU 26
|
|
USRN EQU 32
|
|
RSTV EQU 37
|
|
ERRM EQU 45
|
|
DOSV EQU 48
|
|
FTRU EQU 99
|
|
GETF EQU 100
|
|
SETF EQU 101
|
|
GETS EQU 102
|
|
SETS EQU 103
|
|
;
|
|
Z3NdrL EQU 16 ; length of NDR dir/pwdstring
|
|
Z3NdrM EQU 8 ; length of NDR name to match
|
|
Z3NDR EQU 0015H ; offset to NDR address in Z3ENV
|
|
Z3MSG EQU 0022H
|
|
MsgUsr EQU 64 ; User area offset in message buffer
|
|
MsgNmU EQU 16 ; # of user registers
|
|
TPAful EQU 12 ; Z33 TPA full error code
|
|
ErrBit EQU 00000010B
|
|
EcpBit EQU 00000100B
|
|
ExtBit EQU 00001000B
|
|
;
|
|
;ErrSta is the value to be returned in the Z33 Message Buffer command
|
|
;status to inform the command processor that an error has occurred in
|
|
;an external program and that the error handler should be invoked.
|
|
;
|
|
ErrSta EQU ErrBit+EcpBit+ExtBit
|
|
;
|
|
;*** ZDE.ASM - Z-System Display Editor
|
|
;*** Universal Version - (c)1988 Eric Meyer
|
|
;*** Z-System Version - (c)1989 Carson Wilson
|
|
; -------------------
|
|
; VDE,VDE-2 - 9-12/84 - Enhanced VDO, added functions
|
|
; VDE-OS,OX - 7/85-1/86 - Small additions and fixes
|
|
; VDE-PX - 7-9/85 - Epson Geneva terminal version
|
|
; VDE 1.2-3 - 9/85-1/86 - Generic terminal version
|
|
; VDE/M 2.0 - 4/86 - Generic memory map version; CP/M+ support; additions
|
|
; 2.1 - 6/86 - New Keys 0-9; window; undo; directory; new pagination,
|
|
; compression, block marker, scroll; etc.
|
|
; 2.2 - 8/86 - WS-like commands; left mrgn, hyphenation; macros
|
|
; 2.3 - 9/86 - VINSTALL; Print options; word fns; real ^QA; RstDrv
|
|
; 2.4 - 1/87 - vidRAM/window redone; "W" mode; ^OZ,^QP; block print
|
|
; 2.5 - 3/87 - User#s; "N" mode; ^OS, ^OV/+/-; new block fns; hard-CRs
|
|
; 2.6 - 7/87 - Allow blank filename; ^U abort; new toggles; ruler;
|
|
; ^O<u>; AltBit fixes; works w/o curpos; key buffer; faster
|
|
; scrolling; case insensitive searches; no fake "VIDRAM"
|
|
; 2.61 - 8/87 - Bug fixes (incl FastFi), improved hyphenation
|
|
; 2.62 - 11/87 - ^JKL synonyms; ^W prefix; ^OH; several small fixes
|
|
; 2.63 - 1/88 - ^KV; WS style ^W/^Z; chgs to ^OP, ^OI/N, word fns
|
|
; 2.64 - 3/88 - ^OQ,^QT,^QI; ^KD; ^QA fixes; dbl spc; top margin;
|
|
; backward find; ShoRCu
|
|
; 2.65 - 4/88 - ^OI/N args; Esc-TAB; ^OA; menu removal; minor fixes
|
|
; 2.66 - 6/24/88 - Printer margins; Minor fixes. LAST RELEASE!
|
|
; 2.67b - 10/14/88 - Minor fixes
|
|
; ZDE 1.0 - 3/10/89 - Z-System Display Editor
|
|
; 1.3 - 8/26/89
|
|
; 1.6 - 6/2/90
|
|
; 1.6 - 11/19/20 - ZDE 1.6 source reconstituted using VDE 2.67
|
|
; source as a guide
|
|
; 1.7 - 11/21/20 - Incorporated Al Hawley's timestamp fixes
|
|
; -------------------
|
|
;
|
|
ORG 0100H
|
|
;
|
|
JP Start ;Entry and exit vectors
|
|
DB 'Z3ENV'
|
|
DB 1
|
|
Z3Env: DW 0
|
|
Boot: JP 0
|
|
DW 0
|
|
;
|
|
;Following VINSTALL data MUST be at 0110-0121
|
|
;
|
|
DW 1006H ;Version compatibility
|
|
DW UsrPat
|
|
DB UPatL
|
|
DW PSTbl
|
|
DB PsL
|
|
DW MnuSt
|
|
DW KMnuSt
|
|
DW EMnuSt
|
|
DW OMnuSt
|
|
DW QMnuSt
|
|
;version message (28 chars, used in menu)
|
|
; [----5----10---15---20---25--]
|
|
VersID: DB 'ZDE 1.7, Copr. 1990 C.Wilson',0
|
|
;
|
|
;
|
|
;USER PATCHABLE VALUES
|
|
;
|
|
ORG 0140H
|
|
BAKFlg: DB 0FFH ;0140H - create BAK files (y/n)
|
|
DFMode: DB 'A' ;default file modem W/A/N
|
|
FDflt1: DB 'Z80N' ;1st default override
|
|
FDflt2: DB 'WS W' ;2nd
|
|
FDflt3: DB 'CMDN' ;3rd
|
|
FDflt4: DB 'LIBN' ;4th
|
|
InsFlg: DB 0FFH ;defulat insert on (y/n)
|
|
RulFlg: DB 0FFH ;default rules on (y/n)
|
|
HCDflt: DB 0FFH ;default HCR disp on (y/n)
|
|
HypFlg: DB 0FFH ;enable hyphenation (y/n)
|
|
PSFlg: DB 0 ;default proportional flag (y/n)
|
|
PSokFl: DB 0FFH ;default allow proportional flag (y/n)
|
|
DfltLM: DB 1 ;left margin column (1=OFF)
|
|
DfltRM: DB 65 ;right margin column (1=OFF)
|
|
Ovlap: DB 2 ;scroll overlap (0=none)
|
|
DirSys: DB 0 ;include SYS files (y/n)
|
|
FixDsk: DB '@@' ;fixed drives
|
|
Ring: DB 0FFH ;error ring bell (y/n)
|
|
Help: DB 0FFH ;use help menus (y/n)
|
|
AltHdr: DB 0FFH ;use alt video in header (y/n)
|
|
NoHdrF: DB 0 ;suppress header
|
|
MHz: DB 40H ;clock speed (40h=4MHz)
|
|
Timer: DB 38H ;horiz scroll delay (01..FF)
|
|
TabCnt: DB 7 ;hard tab cols -1 (1/3/7/15)
|
|
VTList: DB 6,11,16,21 ;variable tab columns (8)
|
|
DB 0,0,0,0
|
|
VTNum EQU $-VTList
|
|
WildCd: DB EOF ;wildcard character
|
|
BlkChr: DB 0 ;block characters (^@)
|
|
TogTbl: DB 02H,04H,13H,19H ;toggles ^B,^D[^T],^S,^Y
|
|
NTgTbl: DB 11H,17H,5,12H ;switches ^Q,^W,^E,^R (last 015C)
|
|
;
|
|
;INSTALLATION
|
|
;
|
|
ORG 180H
|
|
Z3tcap: DB 'Generic CRT ' ;ID
|
|
ORG 190H
|
|
View: DB 80 ;viewable columns (max 128)
|
|
AuWrap: DB 0FFH ;does autowrap cursor
|
|
Lines: DB 24 ;lines
|
|
UsrKys: DB 0FFH ;DEL key
|
|
DB 0FFH ;arrow up
|
|
DB 0FFH ;arrow down
|
|
DB 0FFH ;arrow right
|
|
DB 0FFH ;arrow left
|
|
DB 0
|
|
CIL: DB 0,0,0,0,0,0,0 ;clear to end of line, 6 bytes
|
|
TInit: DB 1,'Z'-40H,0,0,0,0,0,0 ;terminal init, 7 bytes
|
|
TUInit: DB 1,'Z'-40H,0,0,0,0,0,0 ;terminal uninit
|
|
AltOn: DB 0,0,0,0,0,0,0 ;alt video on, 6 bytes
|
|
AltOff: DB 0,0,0,0,0,0,0 ;alt video off
|
|
AltBit: DB 0 ;high bit gives alt video?
|
|
Filter: DB 7FH ;highest ASCII to send to screen
|
|
PosMod: DB 'N' ;curpos mode (Std/Rev/ANSI/None)
|
|
PCu: DB 1EH,0,0CH,0 ;position cursor to (0,0)
|
|
PosDly: DB 0 ;delay after curpos (00-FF)
|
|
InsL: DB 0,0,0,0,0,0,0 ;insert line [1], 6 bytes
|
|
DelL: DB 0,0,0,0,0,0,0 ;delete line [1], 6 byts
|
|
OddDel: DB 0 ;ins/del line specific?
|
|
CsrOff: DB 0,0,0,0,0,0,0 ;cursor off
|
|
CurOn: DB 0,0,0,0,0,0,0 ;cursor on
|
|
;
|
|
ORG 01F0H ;Printer codes
|
|
DB 'Teletype ' ;ID
|
|
ORG 0200H
|
|
UseLF: DB 0FFH ;use LF after CR in print?
|
|
FormL: DB 54 ;form length (0=no pag)
|
|
PTMarg: DB 0 ;top margin skip
|
|
DotPO: DB 0 ;left margin skip
|
|
PInit: ;printer init, 19 bytes
|
|
ORG 0218H
|
|
PUInit: ;printer uninit, 7 bytes
|
|
ORG 0220H
|
|
PCodes: DB 0,0,0,0,0,0,0,0 ;^B toggle on
|
|
DB 0,0,0,0,0,0,0,0 ;...and off
|
|
DB 0,0,0,0,0,0,0,0 ;^T [^D] toggle on
|
|
DB 0,0,0,0,0,0,0,0 ;...and off
|
|
DB 0,0,0,0,0,0,0,0 ;^S toggle on
|
|
DB 0,0,0,0,0,0,0,0 ;...and off
|
|
DB 0,0,0,0,0,0,0,0 ;^Y toggle on
|
|
DB 0,0,0,0,0,0,0,0 ;...and off
|
|
UCodes: DB 0,0,0,0,0,0,0,0 ;sw 1 (^Q)
|
|
DB 0,0,0,0,0,0,0,0 ;sw 2 (^W)
|
|
DB 0,0,0,0,0,0,0,0 ;sw 3 (^E)
|
|
DB 0,0,0,0,0,0,0,0 ;sw 4 (^R)
|
|
;
|
|
ORG 0280H
|
|
UsrPat: ;0280-02AFH - User Patch Area
|
|
;(Can extend back into UCodes section if fewer switches used)
|
|
;
|
|
ORG 02B0H ;02B0-030EH - Proportinal table
|
|
UPatL EQU $-UsrPat
|
|
PSTbl: DB 0,-12, 0, 0, 0, 6, 6,-12 ;" "-";"
|
|
DB -6, -6, 0, 0,-12, 0,-12, 0 ;"("-"/"
|
|
DB 0, 0, 0, 0, 0, 0, 0, 0 ;"0"-"7"
|
|
DB 0, 0,-12,-12, 0, 0, 0, 0 ;"8"-"?"
|
|
DB 6, 6, 6, 6, 6, 6, 6, 6 ;"@"-"G"
|
|
DB 6, -6, 0, 6, 6, 12, 6, 6 ;"H"-"O"
|
|
DB 6, 6, 6, 6, 6, 12, 6, 12 ;"P"-"W"
|
|
DB 6, 6, 0, -6, 0, -6, 0, 0 ;"X"-"_"
|
|
DB -12, 0, 6, 0, 6, 0, -6, 6 ;"'"-"g"
|
|
DB 6,-12, -6, 6,-12, 12, 6, 0 ;"h"-"o"
|
|
DB 6, 6, 0, 0, -6, 6, 6, 12 ;"p"-"w"
|
|
DB 0, 6, 0, -6,-12, -6, 0 ;"x"-"~"
|
|
PsL EQU $-PSTbl
|
|
;
|
|
ORG 0310H ;0310-04AFH - Macro keys
|
|
Keys: DS 2 ;free count (VDE does this)
|
|
DS 510
|
|
KT:
|
|
;
|
|
;
|
|
;----- EXECUTION BEGINS HERE -------
|
|
;
|
|
ORG 0510H
|
|
;
|
|
Start: SUB A ;check for Z80
|
|
RET PE
|
|
LD SP,Stack
|
|
LD HL,Data ;zero out data area
|
|
LD DE,Data+1
|
|
LD BC,DataLn-1
|
|
LD (HL),0
|
|
LDIR
|
|
LD C,CPMV
|
|
CALL BDOSep
|
|
LD (DOSVer+1),A ;CP/M version
|
|
CP 30H
|
|
JR NC,ItsCP3
|
|
LD C,DOSV
|
|
CALL BDOSep ; what kind of enhanced BDOS
|
|
LD A,H
|
|
CP 'S'
|
|
JR Z,ZxDOS
|
|
CP 'D'
|
|
JR NZ,ItsCP3
|
|
ZxDOS: LD (DOSVer+1),A ; store ZS/ZDDOS version
|
|
LD C,GETF ; get ZSDOS flags
|
|
CALL BDOSep
|
|
LD (ZDflgs+1),HL
|
|
EX DE,HL
|
|
RES 1,E ; public files are R/O
|
|
LD C,SETF
|
|
CALL BDOSep ; set ZSDOS flags
|
|
ItsCP3: CALL DOSVer
|
|
LD C,ERRM ; set action on hardware error
|
|
LD E,0FEH ; return error code to program
|
|
CALL NC,BDOSep ; for anything other than CP/M 2.2
|
|
LD C,GDRV
|
|
CALL BDOSep ;save logged drive
|
|
LD (CurDsk),A
|
|
INC A
|
|
LD (FCB),A ; store A=1..P=16 in FCB->drive
|
|
LD C,USRN ;and user
|
|
LD E,0FFH
|
|
CALL BDOSep
|
|
LD (CurUsr),A
|
|
LD (FCBU),A
|
|
LD A,(Lines)
|
|
LD (PhysLn),A
|
|
CALL AdjLns
|
|
LD A,(FormL)
|
|
LD (PgLen),A
|
|
LD HL,(DfltLM)
|
|
LD (LfMarg),HL
|
|
LD A,(BlkChr)
|
|
LD (BadTbl),A
|
|
LD A,(UseLF)
|
|
CPL
|
|
OR LF
|
|
LD (LFChr),A
|
|
LD HL,MacStr
|
|
DEC (HL) ;make a FF terminator
|
|
XOR A ;a bad load will exit and invoke Z33's
|
|
LD (BadLdX+1),A ;error handler
|
|
;
|
|
LD HL,DMA
|
|
LD A,(HL)
|
|
INC HL
|
|
CALL Parse ;parse command line
|
|
;
|
|
CALL VerKey ;verify keys
|
|
LD HL,TInit
|
|
CALL CtlStr ;Clear and home cursor
|
|
JR Edit ;start editing.
|
|
;
|
|
;Clear it all out and start over.
|
|
;
|
|
Restrt: LD A,1 ;a bad load will not exit and invoke
|
|
LD (BadLdX+1),A ;Z33's error handler
|
|
LD HL,LoadQ
|
|
CALL NewNam
|
|
LD A,(EdErr) ;bad name?
|
|
OR A
|
|
JR NZ,BadLdX
|
|
;
|
|
;Start editing a File
|
|
;
|
|
Edit: CALL IniRAM ;initialize memory
|
|
CALL DfltM ;adjust defaults
|
|
CALL DoHdr ;show header
|
|
CALL Top ;Start at TOF
|
|
CALL Error0 ;No errors
|
|
LD A,(FCB+1)
|
|
CP ' ' ;Filename blank?
|
|
JR Z,Edit1
|
|
CALL SavNam ;save it for LoadIt kludge
|
|
CALL LoadIt ;Get input file
|
|
LD A,(EdErr)
|
|
CP 1 ;is it too big?
|
|
JR NZ,Edit1
|
|
BadLdX: LD A,0 ;a non-zero value will set up Z33's message
|
|
OR A ;buffer to have the Z33 error handler handle
|
|
JR NZ,BadLd ;the 'TPA full' condition when we exit
|
|
LD BC,Z3MSG
|
|
CALL Z3EAdr
|
|
JR Z,BadLd
|
|
LD H,B
|
|
LD L,C
|
|
LD (HL),TPAful ; Z3MSG error byte: file too big
|
|
INC HL
|
|
INC HL
|
|
INC HL ; point HL at Z3MSG command status byte
|
|
LD (HL),ErrSta ; error, ECP running, external invocation
|
|
JP QuitY
|
|
BadLd: CALL DoErr ;Too big, or bad name
|
|
CALL BlkFCB ;(Other error means new file)
|
|
JR Edit
|
|
Edit1: LD A,(MSIFlg) ;set up BAKflag
|
|
LD HL,BAKFlg
|
|
AND (HL)
|
|
LD (FilFlg),A
|
|
XOR A
|
|
LD (Modify),A
|
|
;
|
|
Reset: LD SP,Stack ;recover from ^U prompt abort
|
|
CALL ShoLn1
|
|
;
|
|
;
|
|
;MAIN LOOP: SHOW TEXT, GET KEY
|
|
;
|
|
Ready: CALL Orient ;Get bearings
|
|
LD HL,(OldLin) ; ###
|
|
LD (SavLin),HL ; ###
|
|
LD A,(OldCol) ; ###
|
|
LD (SavCol),A ; ###
|
|
LD A,(MacFlg) ; ###
|
|
OR A ; ###
|
|
JR NZ,RdyMac ; ###
|
|
LD HL,(CurLin) ; ###
|
|
LD (OldLin),HL ; ###
|
|
LD A,(CurCol) ; ###
|
|
LD (OldCol),A ; ###
|
|
RdyMac: CALL ShoTx ; then show text as needed
|
|
CALL Cursr ;position cursor
|
|
CALL TRptKy ;Get input
|
|
PUSH AF
|
|
CALL Error0 ;Clear error indicator
|
|
CALL SetNo ;default NO redisp
|
|
POP AF
|
|
CALL AdjKey ;translate arrows/DEL
|
|
;
|
|
DoKey: CALL Case ;try to match control code?
|
|
DB MnuLn/3
|
|
DW IChar ;Default : Insert character
|
|
MnuSt EQU $
|
|
DB 0 ;(internal use: null key)
|
|
DW CKCan
|
|
DB 80H ;DEL
|
|
DW Delete
|
|
DB 81H ;Up arrow
|
|
DW Up
|
|
DB 82H ;Down
|
|
DW Down
|
|
DB 83H ;Right
|
|
DW Right
|
|
DB 84H ;Left
|
|
DW Left
|
|
DB ESC
|
|
DW Escape
|
|
DB '^'-40H
|
|
DW UpLow
|
|
DB '\'-40H
|
|
DW Repeat ;Synonym for ^L
|
|
DB 'A'-40H
|
|
DW WordLf
|
|
DB 'B'-40H
|
|
DW Reform
|
|
DB 'C'-40H
|
|
DW PageF
|
|
DB 'F'-40H
|
|
DW WordRt
|
|
DB 'G'-40H
|
|
DW EChar
|
|
DB 'I'-40H
|
|
DW TabKey
|
|
DB 'J'-40H
|
|
DW DoMnu
|
|
DB 'K'-40H
|
|
DW CKKey
|
|
DB 'L'-40H
|
|
DW Repeat
|
|
DB 'M'-40H
|
|
DW ICR
|
|
DB 'N'-40H
|
|
DW ICRA
|
|
DB 'O'-40H
|
|
DW Onscrn
|
|
DB 'P'-40H
|
|
DW CtlP
|
|
DB 'Q'-40H
|
|
DW Quick
|
|
DB 'R'-40H
|
|
DW PageB
|
|
DB 'T'-40H
|
|
DW WordDl
|
|
DB 'U'-40H
|
|
DW Undel
|
|
DB 'V'-40H
|
|
DW IToggl
|
|
DB 'W'-40H
|
|
DW Scr1LU
|
|
DB 'Y'-40H
|
|
DW Eline
|
|
DB 'Z'-40H
|
|
DW Scr1LD
|
|
MnuLn EQU $-MnuSt
|
|
;
|
|
Sk1Ed: LD A,(EdErr) ;Check for error, repeat main loop
|
|
OR A
|
|
CALL NZ,DoErr
|
|
JP Ready
|
|
;
|
|
;Block commands: ^K toggle is on
|
|
;
|
|
CKKey: LD HL,CKTog
|
|
CALL Prefix
|
|
CKSyn: CALL XCase ;Entry for ESC synonyms
|
|
CALL Case
|
|
DB KMnuLn/3
|
|
DW Error2 ;complain if unknown
|
|
KMnuSt EQU $
|
|
DB 'B'-40h
|
|
DW Block
|
|
DB 'C'-40h
|
|
DW Copy
|
|
DB 'D'-40h
|
|
DW Done
|
|
DB 'E'-40h
|
|
DW Era
|
|
DB 'F'-40h
|
|
DW Dir
|
|
DB 'H'-40h
|
|
DW DoMnu
|
|
DB 'I'-40h
|
|
DW Info
|
|
DB 'K'-40h
|
|
DW Termin
|
|
DB 'L'-40h
|
|
DW Load
|
|
DB 'N'-40h
|
|
DW ChgNam
|
|
DB 'P'-40h
|
|
DW Print
|
|
DB 'Q'-40h
|
|
DW Quit
|
|
DB 'R'-40h
|
|
DW Read
|
|
DB 'S'-40h
|
|
DW Save
|
|
DB 'U'-40h
|
|
DW Unmark
|
|
DB 'V'-40h
|
|
DW MovBlk
|
|
DB 'W'-40h
|
|
DW Write
|
|
DB 'X'-40h
|
|
DW Exit
|
|
DB 'Y'-40h
|
|
DW EBlock
|
|
DB ESC
|
|
DW CKCan
|
|
DB ' '
|
|
DW CKCan
|
|
KMnuLn EQU $-KMnuSt
|
|
CKCan: RET
|
|
;
|
|
;ESC commands: ESC toggle is on.
|
|
;
|
|
Escape: LD HL,ESCTog
|
|
CALL Prefix
|
|
CALL AdjKey
|
|
CALL UCase
|
|
CP '0'
|
|
JR C,Esc01 ;macro Keys: special case
|
|
CP '9'+1
|
|
JP C,UseKey
|
|
Esc01: CALL Case
|
|
DB EMnuLn/3
|
|
DW CKSyn ;default: ^K synonym
|
|
EMnuSt EQU $
|
|
DB 81H ;Up arrow
|
|
DW ShftU
|
|
DB 82H ;Down
|
|
DW ShftD
|
|
DB 83H ;Right
|
|
DW ShftR
|
|
DB 84H ;Left
|
|
DW ShftL
|
|
DB '[' ;ANSI cursor sequences
|
|
DW ANSIcu
|
|
DB TAB
|
|
DW TaBack
|
|
DB 'M'
|
|
DW DoMac
|
|
DB '#'
|
|
DW MacKey
|
|
DB '!' ;macro prog stmts
|
|
DW MacJmp
|
|
DB '='
|
|
DW MacTst
|
|
DB '~'
|
|
DW MacTsX
|
|
DB '+'
|
|
DW ChainK
|
|
DB ';'
|
|
DW Wait
|
|
EMnuLn EQU $-EMnuSt
|
|
RET
|
|
;
|
|
;Onscreen commands. ^O toggle is on.
|
|
;
|
|
Onscrn: LD HL,COTog
|
|
CALL Prefix
|
|
CALL XCase ;force to ctl
|
|
CALL AdjKUp ;adjust UP ARROW ONLY
|
|
CALL Case ;What function?
|
|
DB OMnuLn/3
|
|
DW Error2 ;complain if unknown
|
|
OMnuSt EQU $
|
|
DB 81H ;up
|
|
DW MakTop
|
|
DB 'A'-40h
|
|
DW AITog
|
|
DB 'C'-40h
|
|
DW Center
|
|
DB 'D'-40h
|
|
DW HCRTog
|
|
DB 'F'-40h
|
|
DW Center ;same fn as 'C'
|
|
DB 'H'-40h
|
|
DW HypTog
|
|
DB 'I'-40h
|
|
DW VTSet
|
|
DB 'J'-40h
|
|
DW PSTog
|
|
DB 'L'-40h
|
|
DW SetLM
|
|
DB 'N'-40h
|
|
DW VTClr
|
|
DB 'P'-40h
|
|
DW PgSet
|
|
DB 'Q'-40h
|
|
DW NoHdr
|
|
DB 'R'-40h
|
|
DW SetRM
|
|
DB 'S'-40h
|
|
DW DblTog
|
|
DB 'T'-40h
|
|
DW Ruler
|
|
DB 'V'-40h
|
|
DW VTTog
|
|
DB 'W'-40h
|
|
DW Window
|
|
DB 'X'-40h
|
|
DW RelM
|
|
DB 'Z'-40h
|
|
DW Blank
|
|
DB ESC
|
|
DW COCan
|
|
DB ' '
|
|
DW COCan
|
|
OMnuLn EQU $-OMnuSt
|
|
COCan: RET
|
|
;
|
|
;Quick commands. ^Q toggle is on.
|
|
;
|
|
Quick: LD HL,CQTog
|
|
CALL Prefix
|
|
CALL XCase
|
|
CALL AdjKey ;translate arrow/DEL
|
|
CALL Case ;What function?
|
|
DB QMnuLn/3
|
|
DW Error2 ;complain if unknown
|
|
QMnuSt EQU $
|
|
DB 80H ;DEL
|
|
DW EBLine
|
|
DB 81H ;Up arrow
|
|
DW QuikUp
|
|
DB 82H ;Down
|
|
DW QuikDn
|
|
DB 83H ;Right
|
|
DW QuikRt
|
|
DB 84H ;Left
|
|
DW QuikLf
|
|
DB 'A'-40h
|
|
DW Rplace
|
|
DB 'B'-40h
|
|
DW QikBlk
|
|
DB 'C'-40h
|
|
DW Bottom
|
|
DB 'F'-40h
|
|
DW Find
|
|
DB 'Q'-40h
|
|
DW Queue
|
|
DB 'I'-40h
|
|
DW ZipTo
|
|
DB 'P'-40h
|
|
DW QuikLc
|
|
DB 'R'-40h
|
|
DW Top
|
|
DB 'T'-40h
|
|
DW E2Char
|
|
DB 'U'-40h
|
|
DW UndlLn
|
|
DB 'Y'-40h
|
|
DW EOLine
|
|
DB 'Z'-40h
|
|
DW QuikMk
|
|
DB ESC
|
|
DW CQCan
|
|
DB ' '
|
|
DW CQCan
|
|
QMnuLn EQU $-QMnuSt
|
|
CQCan: RET
|
|
;
|
|
;
|
|
;
|
|
Prefix: PUSH HL ;show prefix, get suffix
|
|
LD DE,DspEsc
|
|
CALL GoTo
|
|
CALL MakAlt
|
|
POP HL
|
|
LD B,3
|
|
CALL BHLMsg
|
|
LD B,1
|
|
CALL BBlank
|
|
LD DE,DspEsQ ;position cursor
|
|
CALL GoTo
|
|
CALL RptKey ;get suffix
|
|
PUSH AF
|
|
LD A,(NoHdrF)
|
|
OR A
|
|
JR NZ,PrefNH
|
|
LD DE,DspEsc
|
|
CALL GoTo
|
|
LD B,4 ;clean up
|
|
CALL BBlank
|
|
CALL UnAlt
|
|
POP AF
|
|
RET
|
|
PrefNH: CALL UnAlt ;(if no header)
|
|
CALL ShoLn1
|
|
CALL RulFix
|
|
POP AF
|
|
RET
|
|
;
|
|
;
|
|
;Return to CP/M ... With or without saving
|
|
;
|
|
Exit: CALL Save ;Save the file
|
|
LD A,(EdErr) ;Was it ok?
|
|
OR A
|
|
RET NZ ;No, do not quit
|
|
JR QuitY1
|
|
;
|
|
Done: CALL Save ;Save, and load new
|
|
LD A,(EdErr)
|
|
OR A
|
|
RET NZ
|
|
JP Restrt
|
|
;
|
|
Quit: LD A,(Modify) ;Quit to CP/M
|
|
OR A
|
|
JR Z,QuitY1
|
|
LD HL,QuitQ
|
|
CALL Prompt
|
|
CALL Confrm ;warn if file changed...
|
|
JP NZ,ShoLn1
|
|
QuitY1: XOR A ;###
|
|
LD (WinFlg),A ;###
|
|
CALL AdjLns ;###
|
|
LD BC,Z3MSG ;###
|
|
CALL Z3EAdr ;###
|
|
JR Z,QuitY ;###
|
|
LD HL,MsgUsr ;### offset to user area in message buffers
|
|
ADD HL,BC ;###
|
|
LD DE,CurLin ;### store the current line# in the Z3
|
|
EX DE,HL ;###
|
|
LD BC,2 ;###
|
|
LDIR ;###
|
|
QuitY: LD HL,TUInit ;Clear screen
|
|
CALL CtlStr
|
|
LD A,(CurDsk) ;restore logged disk
|
|
LD E,A
|
|
LD C,SELD
|
|
CALL BDOS
|
|
LD A,(CurUsr) ;and user
|
|
LD E,A
|
|
LD C,USRN
|
|
CALL BDOSep
|
|
CALL DOSVer
|
|
JP C,Boot ;### restart if CP/M 2.2
|
|
CP 'S' ;###
|
|
JR Z,ZSErrR ;###
|
|
CP 'D' ;###
|
|
JR NZ,CPM3xt ;###
|
|
ZSErrR: LD C,SETF ;### restore ZxDOS flags
|
|
ZDflgs: LD DE,0 ;###
|
|
CALL BDOSep ;###
|
|
CPM3xt: LD C,ERRM ;### reset ZxDOS, CP/M 3 error mode
|
|
LD E,0 ;###
|
|
CALL BDOSep ;###
|
|
JP Boot ;### and restart
|
|
;
|
|
;Error handler
|
|
;
|
|
DoErr: CALL Loud ;Show error message, wait for ESC
|
|
CALL SetNo
|
|
LD A,(MacFlg)
|
|
OR A ;###
|
|
CALL NZ,RstI1x ;###
|
|
XOR A ;###
|
|
LD (MacFlg),A ;### kill any running macro
|
|
LD A,(EdErr)
|
|
CP 10
|
|
JP NC,SetAl ;error 10 does NOT show
|
|
LD A,(Ring)
|
|
OR A
|
|
LD E,BEL
|
|
CALL NZ,ShutUp ; ring bell
|
|
CALL MakAlt
|
|
CALL UpLft
|
|
CALL Dspl
|
|
DB X,31,'[[','['+X,0
|
|
LD A,(EdErr)
|
|
ADD A,A ;Double the code
|
|
LD L,A
|
|
LD H,0
|
|
LD DE,ErrTab
|
|
ADD HL,DE
|
|
LD E,(HL) ;Get msg addr from table
|
|
INC HL
|
|
LD D,(HL)
|
|
EX DE,HL
|
|
CALL DspLp ;show it
|
|
CALL DsplC
|
|
DB ' ]]]',CR,0
|
|
CALL UnAlt
|
|
CALL ESCLp
|
|
LD A,(EdErr)
|
|
CP 1
|
|
JR Z,DoErr2
|
|
CP 5
|
|
JR Z,DoErr2
|
|
CP 9
|
|
JP C,ShoLn1 ;(errors 2-8 need no redisp)
|
|
DoErr2: JP SetAl
|
|
ESCLp: CALL RptKey ;await ESC from console
|
|
CP ESC
|
|
RET Z
|
|
CP ' '
|
|
JR NZ,ESCLp
|
|
RET
|
|
;
|
|
Error0: LD A,0 ;clear error (don't change flags)
|
|
JR ErrSet
|
|
Error1: LD A,1 ;error set fns
|
|
JR ErrSet
|
|
Error2: LD A,2
|
|
JR ErrSet
|
|
Error3: LD A,3
|
|
JR ErrSet
|
|
Error4: LD A,4
|
|
JR ErrSet
|
|
Error5: LD A,5 ;6 currently not used
|
|
JR ErrSet
|
|
Error7: LD A,7
|
|
JR ErrSet
|
|
Error8: LD A,8
|
|
JR ErrSet
|
|
Error9: LD A,9
|
|
JR ErrSet
|
|
Eror10: LD A,10
|
|
ErrSet: LD (EdErr),A
|
|
RET
|
|
;
|
|
;
|
|
;INPUT ROUTINES
|
|
;
|
|
KeyIn: LD HL,(Timer) ;Get key, regardless
|
|
LD H,0
|
|
ADD HL,HL
|
|
ADD HL,HL
|
|
ADD HL,HL
|
|
ADD HL,HL
|
|
INC HL
|
|
KyIn1: PUSH HL
|
|
CALL KyStat
|
|
POP HL
|
|
DEC HL
|
|
JR NZ,Keybd ;read key if got one
|
|
LD A,(HorFlg)
|
|
LD E,A
|
|
LD A,(KeyFlg)
|
|
OR E
|
|
OR H
|
|
OR L ;allow redisp for horizontal scroll?
|
|
JR NZ,KyIn1
|
|
CPL
|
|
LD (HorFlg),A ;yep (just once)
|
|
CALL ShoAll
|
|
CALL Cursr
|
|
JR KyIn1
|
|
;
|
|
Keybd: CALL KyStat ;Get key, or 0 if none
|
|
RET Z
|
|
LD HL,ConBuf
|
|
DEC (HL) ;uncount it
|
|
INC HL
|
|
LD A,(HL) ;here it is
|
|
LD D,H
|
|
LD E,L
|
|
INC HL
|
|
LD BC,ConBufL-1
|
|
LDIR ;remove it
|
|
AND 7FH ;strip parity
|
|
RET
|
|
;
|
|
KyStat: CALL CONSt ;Console status with buffering
|
|
JR Z,ConChk ;all quiet
|
|
LD HL,ConBuf ;got key
|
|
INC (HL) ;ok, count it
|
|
LD E,(HL)
|
|
LD D,0
|
|
ADD HL,DE ;point there
|
|
LD (HL),A ;put it in
|
|
LD A,E
|
|
CP ConBufL ;buffer full?
|
|
JR C,ConChk
|
|
ConBsy: LD A,0C9H ;(RET)
|
|
LD (Plug),A ;plug up the console until buffer empty
|
|
ConChk: LD A,(ConBuf) ;check buffer (FAST)
|
|
OR A
|
|
RET NZ
|
|
LD (Plug),A ;buffer empty, unplug console
|
|
RET
|
|
;
|
|
CONSt: XOR A
|
|
Plug: NOP ;<--- RET plugs up console
|
|
LD E,0FFH ;console status/input
|
|
LD C,UCON
|
|
CALL BDOSep
|
|
OR A ;test for null
|
|
RET
|
|
;
|
|
KyPeek: CALL KyStat ;key available?
|
|
RET Z ;no
|
|
LD A,(ConBuf+1) ;return 1st char in buffer
|
|
AND 7FH ;strip parity
|
|
RET
|
|
;
|
|
;
|
|
Confrm: CALL RptKey ;get a Y/N answer
|
|
CALL UCase
|
|
CP 'Y' ;return Z if confirmed
|
|
RET Z
|
|
CP 'U'-40h
|
|
JR Z,IsCtlU
|
|
CP ESC ;allow this too
|
|
IsCtlU: JP Z,Reset
|
|
CP 'N'
|
|
JR NZ,Confrm
|
|
CnfNo: OR A
|
|
RET
|
|
;
|
|
;Translate four arrow keys and BS,DEL
|
|
;
|
|
AdjKey: CP BS ;First handle ^H (special case)
|
|
JR NZ,AdjK0
|
|
LD C,80h ;make it DEL
|
|
LD HL,UsrKys
|
|
CP (HL) ;Is it installed as DEL?
|
|
JR Z,AKret
|
|
LD C,84h ;no, then it's Left arrow
|
|
CP A
|
|
JR AKret
|
|
AdjK0: LD B,5 ;Not ^H, try the rest
|
|
JR AdjK1
|
|
AdjKUp: LD B,2 ;only do (DEL and) UP arrow
|
|
AdjK1: LD HL,UsrKys
|
|
LD DE,WSKys
|
|
LD C,7FH ;encode 80h=DEL, 81h=up, etc.
|
|
AKlp: INC C
|
|
CP (HL)
|
|
JR Z,AKret
|
|
EX DE,HL
|
|
INC DE
|
|
CP (HL)
|
|
JR Z,AKret
|
|
INC HL
|
|
DJNZ AKlp
|
|
CP C
|
|
LD C,A ;NO match: return NZ, char in A and C
|
|
AKret: LD B,A ;MATCH: return Z, code in A, char in C
|
|
LD A,C
|
|
LD C,B
|
|
RET
|
|
WSKys: DB DEL,'E'-40H,'X'-40H,'D'-40H,'S'-40H
|
|
;
|
|
;
|
|
ANSIcu: CALL RptKey ;Handle ANSI cursor keys ESC-[...
|
|
SUB 'A'
|
|
JP Z,Up
|
|
DEC A
|
|
JP Z,Down
|
|
DEC A
|
|
JP Z,Right
|
|
DEC A
|
|
JP Z,Left
|
|
JP Error2
|
|
;
|
|
;Get string input
|
|
;
|
|
GetStr: LD A,LinLen+1 ;string length +1
|
|
GSEnt: LD (GSlen+1),A ;(entry for GetNum and NewNam)
|
|
LD HL,DMA ;*** MUST be 0080h ***
|
|
Lp1GSx: EXX
|
|
POP HL ;word after call
|
|
PUSH HL
|
|
LD E,(HL) ;storage/recall buffer address
|
|
INC HL
|
|
LD D,(HL)
|
|
LD (GSbufA),DE
|
|
EXX
|
|
Lp1GSy: XOR A
|
|
LD (RclFlg),A
|
|
Lp1GS: LD A,L
|
|
SUB DMA ;length
|
|
GSlen: CP 0 ;<---- max length pastes in here
|
|
JR NC,GSBS ;full?
|
|
LD A,(RclFlg)
|
|
OR A
|
|
JR NZ,GSrcl
|
|
PUSH HL
|
|
CALL RptKey ;Get next input
|
|
CALL AdjKey ;translate key
|
|
POP HL
|
|
CP 80H ;corrections? DEL,
|
|
JR Z,GSBS
|
|
CP 84H ;left
|
|
JR Z,GSBS
|
|
CP 83H ;right
|
|
JR Z,GSrcl ;recall a char
|
|
CP CR ;CR ends
|
|
JR Z,GSCR
|
|
CP 'U'-40H ;^U aborts operation
|
|
JP Z,Reset
|
|
CP 'P'-40H ;^P for ctlcode
|
|
JR Z,GSctl
|
|
LD A,C ;restore orig char
|
|
CP 'X'-40H ;wipeout
|
|
JR Z,GSwipe
|
|
CP 'R'-40H
|
|
JR Z,GSrcl ;recall the last string
|
|
;
|
|
Sk1GS: LD (HL),A ;Store byte
|
|
INC HL ;Move along
|
|
CP 20H ; ctl char?
|
|
PUSH HL
|
|
JR NC,Sk2GS ;no, just a normal char
|
|
ADD A,40H ;ctls are hili letters
|
|
PUSH AF
|
|
CALL AltY
|
|
POP AF
|
|
CALL PutChA
|
|
CALL UnAltY
|
|
JR Sk3GS
|
|
Sk2GS: CALL PutChA ;show byte
|
|
Sk3GS: POP HL
|
|
JR Lp1GS
|
|
;
|
|
GSBS: CALL GSBSsb
|
|
JR Lp1GSy
|
|
GSwipe: CALL GSBSsb
|
|
JR NZ,GSwipe
|
|
JR Lp1GSx
|
|
GSBSsb: LD A,DMA ;Are we at start
|
|
CP L
|
|
RET Z ;return Z if so
|
|
DEC HL ;back up pointer
|
|
LD E,BS ;wipe out char
|
|
CALL PutCh
|
|
LD E,' '
|
|
CALL PutCh
|
|
LD E,BS
|
|
CALL PutCh
|
|
OR 1 ;clear flags
|
|
RET
|
|
;
|
|
GSrcl: EX AF,AF' ;save original char
|
|
EXX ;save HL
|
|
LD HL,(GSbufA) ;recall buffer ptr
|
|
LD A,H
|
|
OR L
|
|
EXX ;restore HL
|
|
JP Z,Lp1GS ;no recall buffer
|
|
EXX ;recall buffer ptr in HL
|
|
LD A,(HL) ;fetch char from recall buffer
|
|
EXX ;restore HL
|
|
OR A ;any char?
|
|
JP Z,Lp1GSx ;no, we're done, reset the ptr addr
|
|
CP 0FFH
|
|
JP Z,Lp1GSx ;no, we're done, reset the ptr addr
|
|
EXX ;recall buffer pre in HL
|
|
INC HL ;point to next char
|
|
LD (GSbufA),HL ;update recall buffer ptr
|
|
EXX ;restore HL
|
|
EX AF,AF' ;restore original char
|
|
CP 'R'-40h ;^R? (whole string)
|
|
JR NZ,GSrclX ;no, just a single char
|
|
LD (RclFlg),A
|
|
GSrclX: EX AF,AF' ;restore char from recall buffer
|
|
JR Sk1GS ;store char
|
|
;
|
|
GSCR: LD (HL),0 ;terminator
|
|
LD A,L
|
|
SUB DMA ;Compute input length (Z=zero)
|
|
POP DE ;skip over buffer address
|
|
INC DE
|
|
INC DE
|
|
PUSH DE
|
|
RET ;HL points past end of string
|
|
;
|
|
GSctl: PUSH HL
|
|
CALL RptKey
|
|
CALL XCase
|
|
POP HL
|
|
JP Sk1GS
|
|
;
|
|
;Get numeric input (0-65535 decimal), return C if bad
|
|
;
|
|
GetNbr: PUSH BC ;BC = default if no input
|
|
LD A,5+1
|
|
CALL GSEnt ;get up to 3 digits
|
|
DW 0
|
|
POP DE
|
|
JR NZ,GNyes
|
|
LD B,D
|
|
LD C,E
|
|
LD A,B ;no entry, use default
|
|
OR C
|
|
RET
|
|
GNyes: LD DE,DMA ;fall thru to GetNNN
|
|
;
|
|
GetNNN: PUSH HL ;gets decimal # pointed by DE
|
|
LD H,D
|
|
LD L,E
|
|
LD B,0
|
|
GNL: LD A,(HL)
|
|
CP '0'
|
|
JR C,GotN ;terminated by any nondigit.
|
|
CP '9'+1
|
|
JR NC,GotN
|
|
INC HL
|
|
INC B
|
|
LD A,B
|
|
CP 5+1
|
|
JR NC,GNErr ;5 digits max.
|
|
JR GNL
|
|
GotN: LD A,B ;okay, do them
|
|
LD BC,0
|
|
OR A ;digits?
|
|
JR Z,GNErr
|
|
CP 2
|
|
JR Z,Got2
|
|
JR C,Got1
|
|
CP 4
|
|
JR Z,Got4
|
|
JR C,Got3
|
|
CP 5
|
|
JR NZ,GNErr
|
|
Got5: LD HL,10000
|
|
CALL GNNdig
|
|
JR C,GNErr
|
|
Got4: LD HL,1000
|
|
CALL GNNdig
|
|
JR C,GNErr
|
|
Got3: LD HL,100
|
|
CALL GNNdig
|
|
JR C,GNErr
|
|
Got2: LD HL,10
|
|
CALL GNNdig
|
|
JR C,GNErr
|
|
Got1: LD HL,1
|
|
CALL GNNdig
|
|
JR C,GNErr
|
|
POP HL
|
|
LD A,B
|
|
OR C
|
|
RET
|
|
GNErr: POP HL
|
|
SCF ;error
|
|
RET
|
|
;
|
|
GNNdig: LD A,(DE) ;do a digit: HL=power of 10
|
|
INC DE
|
|
GNNLp: CP '0'
|
|
RET Z
|
|
DEC A
|
|
PUSH HL
|
|
ADD HL,BC
|
|
LD B,H
|
|
LD C,L
|
|
POP HL
|
|
RET C ;overflow
|
|
JR GNNLp
|
|
;
|
|
;Versions of above for 0...255 only: GetNum, GetNN take # in A
|
|
;
|
|
GetNum: LD C,A
|
|
LD B,0
|
|
CALL GetNbr
|
|
JR GetNN1
|
|
GetNN: CALL GetNNN
|
|
GetNN1: RET C
|
|
XOR A
|
|
OR B
|
|
JR NZ,GetNNX
|
|
OR C ;result in A, OK
|
|
RET
|
|
GetNNX: SCF ;oops, too big
|
|
RET
|
|
;
|
|
;
|
|
;Convert 16-bit number in HL to a one to five
|
|
;digit decimal number in the area pointed to by DE
|
|
;
|
|
BCDCon: LD IX,P10Tab ;Point at table
|
|
PUSH DE ;Save output pointer
|
|
BCDlp1: LD B,(IX+1)
|
|
LD C,(IX)
|
|
LD A,C ;low byte
|
|
CP 1 ;Clear carry flag
|
|
JR Z,BCDend
|
|
SBC HL,BC ;Subtract from input
|
|
JR NC,BCDok ;Got one in range
|
|
ADD HL,BC ;Restore it
|
|
INC IX
|
|
INC IX
|
|
JR BCDlp1 ;Try next one
|
|
;
|
|
BCDok: LD A,'1'
|
|
LD (DE),A ;Set initial digit
|
|
BCDlp2: SBC HL,BC ;Subtract again
|
|
JR C,BCDsk1 ;Went negative
|
|
EX DE,HL
|
|
INC (HL) ;Increment digit
|
|
EX DE,HL
|
|
JR BCDlp2
|
|
;
|
|
BCDsk1: ADD HL,BC ;Restore it
|
|
INC DE ;Bump output
|
|
INC IX
|
|
INC IX
|
|
LD C,(IX)
|
|
LD B,(IX+1)
|
|
LD A,C
|
|
CP 1 ;Is this last entry
|
|
JR Z,BCDend
|
|
LD A,'0'
|
|
LD (DE),A
|
|
JR BCDlp2
|
|
;
|
|
BCDend: LD A,L
|
|
OR '0'
|
|
LD (DE),A
|
|
INC DE
|
|
EX DE,HL
|
|
POP BC
|
|
SBC HL,BC ;Number filled
|
|
LD A,5 ; needed
|
|
SUB L ; to do
|
|
RET Z
|
|
ADD HL,BC ;Restore pointer
|
|
BCDlp3: LD (HL),' ' ;Clear field
|
|
INC HL
|
|
DEC A
|
|
JR NZ,BCDlp3
|
|
RET
|
|
;
|
|
P10Tab: DW 10000,1000,100,10,1
|
|
;
|
|
;
|
|
;
|
|
;PRINT text from memory
|
|
;
|
|
Print: LD HL,PgLen ;set defaults
|
|
XOR A
|
|
CP (HL)
|
|
JR NZ,Pr00
|
|
INC A ;bit 0 set if no pagn
|
|
Pr00: LD (POByt),A
|
|
XOR A
|
|
LD (HdrLen),A
|
|
LD (POff),A
|
|
CPL
|
|
LD (PNum),A
|
|
LD (PrFlg),A
|
|
LD A,1
|
|
LD (Copies),A
|
|
LD (PBeg),A
|
|
LD A,(DotPO)
|
|
LD (PrLMrg),A
|
|
LD A,(PTMarg)
|
|
LD (PrTMrg),A
|
|
LD HL,PrtQ ;options?
|
|
CALL Prompt
|
|
CALL GetStr ;get string into 80
|
|
DW 0
|
|
PO1st: LD DE,DMA ;point to option string
|
|
PrOlp: LD A,(DE)
|
|
INC DE
|
|
LD HL,POByt ;set up bit flags
|
|
LD BC,PrOlp
|
|
PUSH BC ;(return)
|
|
CALL UCase
|
|
CP ' ' ;eat spaces
|
|
RET Z
|
|
CP 'B'
|
|
JR Z,POBlk
|
|
CP 'D'
|
|
JR Z,PODblS
|
|
CP 'P'
|
|
JR Z,POPau
|
|
CP 'L'
|
|
JR Z,POLMrg
|
|
CP 'T'
|
|
JR Z,POTMrg
|
|
CP '*'
|
|
JR Z,POCpy
|
|
CP '^'
|
|
JR Z,POCtl
|
|
CP '@'
|
|
JR Z,POBeg
|
|
CP '#'
|
|
JR Z,PONum
|
|
CP '='
|
|
JP Z,POPgS
|
|
CP '"'
|
|
JP Z,POHdrT
|
|
POP BC ;kill return
|
|
OR A
|
|
JP NZ,Error7 ;unexpected char
|
|
LD A,(PrFlg)
|
|
LD B,A
|
|
XOR A ;zero PrFlg
|
|
LD (PrFlg),A
|
|
OR B
|
|
JR NZ,PO1st
|
|
JP PORdy
|
|
;
|
|
PrFlg: DB 0
|
|
;
|
|
POCpy: CALL GetNN ;"*" sets copy count
|
|
JP C,POBad
|
|
LD (Copies),A
|
|
RET
|
|
POLMrg: CALL GetNN ;"Lnn" sets left margin
|
|
JP C,POBad
|
|
LD (PrLMrg),A
|
|
RET
|
|
POTMrg: CALL GetNN ;"Tnn" sets top margin
|
|
JR C,POBad
|
|
LD (PrTMrg),A
|
|
RET
|
|
POPau: SET 4,(HL) ;bit 4 is for "P"
|
|
RET
|
|
PODblS: SET 3,(HL) ;bit 3 is for "D"
|
|
RET
|
|
POCtl: SET 2,(HL) ;bit 2 is for "^"
|
|
RET
|
|
POBlk: LD A,(HL)
|
|
AND 11000010B ;bits 1,6,7 must be clear
|
|
JR NZ,POBad
|
|
SET 5,(HL) ;set bit 5 (BLOCK)
|
|
RET
|
|
POBeg: BIT 0,(HL) ;must be paginating
|
|
JR NZ,POBad
|
|
CALL GetNN ;"@" page beginning
|
|
JR C,POBad
|
|
OR A
|
|
JR Z,POBad
|
|
LD (PBeg),A
|
|
SET 6,(HL) ;bit 6 is for "@" (suppresses output)
|
|
SET 7,(HL) ;so is bit 7 (multicopy)
|
|
INC A
|
|
NEG ;255-@ is most # can be
|
|
LD B,A
|
|
LD A,(PNum)
|
|
CP B
|
|
RET C ;okay, less
|
|
LD A,B
|
|
LD (PNum),A
|
|
RET
|
|
PONum: BIT 0,(HL) ;must be paginating
|
|
JR NZ,POBad
|
|
CALL GetNN ;"#" page count
|
|
JR C,POBad
|
|
OR A
|
|
JR Z,POBad
|
|
LD B,A
|
|
LD A,(PBeg)
|
|
ADD A,B ;@ + # cannot exceed 255
|
|
JR C,POBad
|
|
LD A,B
|
|
LD (PNum),A
|
|
RET
|
|
POPgS: BIT 0,(HL) ;must be paginating
|
|
JR NZ,POBad
|
|
CALL GetNN ;"=" starting pagination
|
|
JR C,POBad
|
|
OR A
|
|
JR Z,POBad
|
|
LD (POff),A ;offset beginning page
|
|
RET
|
|
POHdrT: BIT 0,(HL) ;must be paginating
|
|
JR NZ,POBad
|
|
SET 1,(HL) ;bit 1 requests header
|
|
LD (HdrPtr),DE ;point to header text
|
|
LD B,50 ;and figure its length
|
|
POHlp: LD A,(DE)
|
|
INC DE
|
|
CP '"'
|
|
JR Z,POHlpF
|
|
DJNZ POHlp
|
|
JR POBad ;too long
|
|
POHlpF: LD A,50
|
|
SUB B ;length
|
|
LD (HdrLen),A
|
|
RET
|
|
POBad: POP HL ;eat return
|
|
JP Error7
|
|
;
|
|
PORdy: CALL IOon ;say Wait
|
|
LD HL,PInit ;init string?
|
|
LD B,(HL)
|
|
INC HL
|
|
CALL LSTStr
|
|
LD HL,(AftCu)
|
|
LD (LastCu),HL ;save position
|
|
LD HL,(BegTx)
|
|
CALL MoveL ;move to top of file
|
|
LD A,(POff)
|
|
OR A
|
|
JR NZ,PORdy0
|
|
LD A,(PBeg)
|
|
PORdy0: LD HL,PBeg
|
|
SUB (HL) ;adjust starting page offset
|
|
LD (POff),A
|
|
LD HL,POByt
|
|
BIT 5,(HL)
|
|
JR Z,PORdy1
|
|
CALL IsBlk ;block print requested
|
|
BIT 1,A ; must be marked
|
|
JP Z,PrOops
|
|
INC DE
|
|
PUSH HL
|
|
SBC HL,DE
|
|
POP HL
|
|
RET Z ;block empty
|
|
DEC HL
|
|
EX DE,HL
|
|
JR PORdy2
|
|
PORdy1: CALL NdCnt ;print whole file
|
|
JP C,PrDone ;file empty
|
|
LD HL,(AftCu)
|
|
LD DE,(EndTx)
|
|
PORdy2: LD (StPrt),HL
|
|
LD (EndPr),DE
|
|
CALL PCR ;###
|
|
;
|
|
RePrt: LD HL,POByt ;[reprint reentry]
|
|
BIT 7,(HL)
|
|
JR Z,PRP0
|
|
SET 6,(HL) ;remember if "@" was used
|
|
PRP0: XOR A
|
|
LD (PageN),A
|
|
INC A
|
|
LD (IgnFlg),A ;TOF is start of line (DotChk)
|
|
LD A,(PgLen) ;start first page
|
|
LD B,A
|
|
OR A
|
|
PUSH AF ;###
|
|
CALL Z,DoPOf ;###
|
|
POP AF ;###
|
|
CALL NZ,PgBrk
|
|
JR C,Sk4Pr
|
|
LD HL,(StPrt) ;Point at first one
|
|
LD C,0 ;Initialize GetNx
|
|
Lp1Pr: CALL GetNx ;Get a character
|
|
CALL DotChk ;(maybe ignore dot command lines)
|
|
CP CR
|
|
JR NZ,Sk2Pr
|
|
CALL PrOut ;It's a CR
|
|
PUSH BC
|
|
PUSH HL
|
|
CALL Keybd
|
|
CP ESC ;Abort request?
|
|
POP HL
|
|
POP BC
|
|
JR Z,Sk1Pr
|
|
LD A,(POByt)
|
|
BIT 3,A ;doublespacing? do extra CR(LFCR)LF
|
|
JR Z,Sk0Pr
|
|
CALL PLF
|
|
CALL PCR
|
|
LD A,B ;count it (if paginating)
|
|
OR A
|
|
JR Z,Sk0Pr
|
|
DEC B
|
|
JR Z,Sk01Pr
|
|
Sk0Pr: LD A,B
|
|
OR A ;Not paginating? B is and stays 0
|
|
LD A,(LFChr) ;Add usual line feed
|
|
JR Z,Sk2Pr
|
|
DJNZ Sk2Pr
|
|
Sk01Pr: CALL PgBrk ;time for NEW PAGE
|
|
JR C,Sk4Pr ;done?
|
|
JR Sk2aPr
|
|
Sk1Pr: LD A,1 ;abort
|
|
LD (Copies),A
|
|
JR Sk3Pr
|
|
Sk2Pr: CALL ChekC ;Check for masking
|
|
CALL PrOut ;Output char
|
|
XOR A
|
|
CP C ;Hidden space waiting?
|
|
JR NZ,Lp1Pr
|
|
Sk2aPr: LD DE,(EndPr) ;At end?
|
|
LD A,E
|
|
SUB L
|
|
LD A,D
|
|
SBC A,H
|
|
JR NC,Lp1Pr ;Loop if more to go
|
|
Sk3Pr: CALL PCR ;last CRLF for some matrix printers
|
|
LD A,(LFChr)
|
|
LD C,A
|
|
LD A,(PgLen)
|
|
OR A ;Finish page?
|
|
JR Z,Sk3aPr
|
|
LD C,FF
|
|
Sk3aPr: LD A,C
|
|
CALL PrOut
|
|
Sk4Pr: LD HL,PCodes ;undo toggles if on
|
|
LD DE,16
|
|
LD B,4
|
|
Lp2Pr: BIT 7,(HL)
|
|
JR Z,Lp2PrF
|
|
RES 7,(HL)
|
|
PUSH BC
|
|
PUSH DE
|
|
PUSH HL
|
|
LD DE,8
|
|
ADD HL,DE
|
|
LD B,(HL)
|
|
INC HL
|
|
CALL LSTStr
|
|
POP HL
|
|
POP DE
|
|
POP BC
|
|
Lp2PrF: ADD HL,DE
|
|
DJNZ Lp2Pr
|
|
LD HL,Copies ;more copies?
|
|
DEC (HL)
|
|
JP NZ,RePrt
|
|
LD HL,PUInit ;uninit string?
|
|
LD B,(HL)
|
|
INC HL
|
|
CALL LSTStr
|
|
JR PrDone
|
|
PrOops: CALL Error7
|
|
PrDone: LD HL,(LastCu) ;all finished
|
|
DEC HL
|
|
CALL MoveR ;go back to position
|
|
CALL IOoff
|
|
JP ShoLn1
|
|
;
|
|
PgBrk: PUSH BC ;call this for new page (returns C for EOP)
|
|
PUSH HL
|
|
LD A,(PageN)
|
|
OR A
|
|
LD A,FF ;start new sheet IF not 1
|
|
CALL NZ,PrOut
|
|
LD A,(POByt)
|
|
BIT 4,A ;pause requested?
|
|
JR Z,NP00
|
|
CALL IOoff ;do it
|
|
LD HL,RdyQ
|
|
CALL Prefix
|
|
CP ESC
|
|
JP Z,NPquit
|
|
CALL IOon
|
|
NP00: LD HL,PageN
|
|
INC (HL)
|
|
JP Z,NPquit ;255 page limit.
|
|
LD C,(HL) ;check "#" limit?
|
|
LD A,(PBeg)
|
|
LD E,A
|
|
LD A,(PNum) ;Pnum+Pbeg-1 = Lastpage#
|
|
DEC A
|
|
ADD A,E
|
|
JP C,NPquit ;255 page limit
|
|
CP C
|
|
JP C,NPquit ;"#" pages printed... quit.
|
|
LD A,(PBeg)
|
|
LD C,A
|
|
LD A,(PageN)
|
|
CP C
|
|
LD HL,POByt
|
|
JR C,NP10 ;are we "@" yet?
|
|
RES 6,(HL) ;yes (start) printing
|
|
LD A,0C9H ;begin with margin offset
|
|
LD (DoPOf),A
|
|
NP10: LD A,(PrTMrg)
|
|
OR A
|
|
JR Z,NP20
|
|
LD B,A
|
|
NP11Lp: CALL PCRLF ;top margin?
|
|
DJNZ NP11Lp
|
|
NP20: LD HL,POByt
|
|
BIT 1,(HL)
|
|
JR Z,NPnoh ;want header?
|
|
LD A,(HdrLen)
|
|
ADD A,6
|
|
LD B,A
|
|
LD A,(RtMarg) ;column for page no.
|
|
SUB B
|
|
JR NC,NPlp
|
|
LD A,70 ;default if margin unusable
|
|
SUB B
|
|
NPlp: PUSH AF ;space over to right justify header
|
|
CALL PrSpc
|
|
POP AF
|
|
DEC A
|
|
JR NZ,NPlp
|
|
LD HL,(HdrPtr) ;put out header
|
|
LD A,(HdrLen)
|
|
LD B,A
|
|
CALL POStr
|
|
CALL PrSpc
|
|
LD A,(PageN) ;put out page
|
|
LD HL,POff
|
|
ADD A,(HL) ;adjust for "=" option
|
|
LD L,A
|
|
LD H,0
|
|
LD DE,PNBuf
|
|
CALL BCDCon
|
|
LD HL,PNBuf
|
|
LD B,5
|
|
CALL POStr
|
|
CALL PCRLF
|
|
CALL PCRLF ;two blank lines
|
|
CALL PCRLF
|
|
NPnoh: XOR A
|
|
LD (DoPOf),A
|
|
CALL DoPOf
|
|
POP HL
|
|
POP BC
|
|
LD A,(PgLen) ;reset TOP
|
|
LD B,A
|
|
OR A
|
|
RET
|
|
NPquit: POP HL
|
|
POP BC
|
|
SCF
|
|
RET
|
|
PNBuf: DB 'nnnnn',0 ;(also used elsewhere)
|
|
;
|
|
DotChk: CP CR ;may ignore dot commands
|
|
JR Z,DotCCR
|
|
CP '.'
|
|
JR Z,DotCDt
|
|
DtC01: EX AF,AF' ;ordinary char
|
|
LD A,(IgnFlg)
|
|
CP 0FFh ;ignoring chars?
|
|
RET Z ;(returns 0FFh, nonprinting)
|
|
XOR A
|
|
LD (IgnFlg),A ;nope, clear dot search
|
|
DtCRet: EX AF,AF' ;no action, accept char
|
|
RET ;leave it 0FFh (ignore)
|
|
DotCCR: CALL DtC01
|
|
EX AF,AF'
|
|
LD A,1 ;1 = ready to ignore if next char dot
|
|
LD (IgnFlg),A
|
|
EX AF,AF'
|
|
RET
|
|
DotCDt: EX AF,AF'
|
|
LD A,(FMode) ;Only ignore dotcmds in "W" mode
|
|
CP 'W'
|
|
JR NZ,DtCRet
|
|
LD A,(IgnFlg)
|
|
OR A
|
|
JR Z,DtCRet
|
|
LD A,0FFh ;FF = dot seen, ignore
|
|
LD (IgnFlg),A
|
|
RET
|
|
;
|
|
ChekC: CP ' ' ;may mask ctl chars
|
|
RET NC
|
|
CP CR ;exceptions: CR,LF,BadTbl
|
|
RET Z
|
|
CP LF
|
|
RET Z
|
|
PUSH HL
|
|
PUSH BC
|
|
LD HL,BadTbl
|
|
LD BC,BadLen
|
|
CPIR
|
|
POP BC
|
|
POP HL
|
|
RET Z
|
|
PUSH AF
|
|
LD A,(POByt)
|
|
BIT 2,A
|
|
JR NZ,CMask
|
|
POP AF
|
|
RET
|
|
CMask: LD A,'^' ;mask: print "^",
|
|
CALL PrOut
|
|
POP AF
|
|
OR 40H ;turn ^A into A, etc.
|
|
RET
|
|
;
|
|
PCR: LD A,CR
|
|
JR PrOut
|
|
PrSpc: LD A,' '
|
|
PrOut: CP 0FFH ;(FF=dummy code, ignore)
|
|
RET Z
|
|
PUSH BC ;Print byte
|
|
PUSH DE
|
|
PUSH HL
|
|
LD HL,POByt ;printing yet?
|
|
BIT 6,(HL)
|
|
JR NZ,Sk2PO
|
|
CP ' '
|
|
JR NC,Sk1PO ;non-ctl
|
|
LD HL,BadTbl
|
|
LD BC,BadLen
|
|
CPIR
|
|
JR Z,Sk2PO ;ILLEGAL
|
|
LD HL,TogTbl
|
|
LD BC,4
|
|
CPIR ;toggle?
|
|
JR Z,Sk3PO
|
|
LD BC,4
|
|
CPIR ;switch?
|
|
JR NZ,Sk1PO ;arbitrary ctl-code
|
|
LD A,4-1
|
|
SUB C ;nontog# (0..n)
|
|
ADD A,A
|
|
ADD A,A
|
|
ADD A,A ;*8
|
|
LD E,A
|
|
LD D,0
|
|
LD HL,UCodes
|
|
ADD HL,DE
|
|
Sk00PO: LD B,(HL)
|
|
INC HL ;string to send
|
|
Sk0PO: CALL LSTStr
|
|
JR Sk2PO
|
|
Sk3PO: LD A,4-1
|
|
SUB C ;tog# (0..n)
|
|
ADD A,A
|
|
ADD A,A
|
|
ADD A,A
|
|
ADD A,A ;*16
|
|
LD E,A
|
|
LD D,0
|
|
LD HL,PCodes
|
|
ADD HL,DE
|
|
BIT 7,(HL) ;toggle status?
|
|
JR NZ,Sk3aPO
|
|
LD B,(HL) ;off, turn on
|
|
SET 7,(HL)
|
|
INC HL
|
|
JR Sk0PO
|
|
Sk3aPO: RES 7,(HL) ;on, turn off
|
|
LD DE,8
|
|
ADD HL,DE
|
|
JR Sk00PO
|
|
Sk1PO: LD E,A ;byte to send
|
|
PUSH AF
|
|
CALL LSTOut
|
|
POP AF
|
|
LD HL,LFChr
|
|
CP (HL)
|
|
CALL Z,DoPOf ;LF? need margin skip
|
|
Sk2PO: POP HL
|
|
POP DE
|
|
POP BC
|
|
RET
|
|
;
|
|
DoPOf: NOP
|
|
LD A,(PrLMrg) ;do printer margin offset
|
|
OR A
|
|
RET Z
|
|
LD B,A
|
|
DoPOfL: CALL PrSpc
|
|
DJNZ DoPOfL
|
|
RET
|
|
;
|
|
PCRLF: CALL PCR ;do CR(LF?)
|
|
PLF: LD A,(LFChr)
|
|
JP PrOut
|
|
;
|
|
POStr: LD A,B ;send B chars at (HL) to PrOut
|
|
OR A
|
|
RET Z
|
|
LD A,(HL)
|
|
CALL PrOut
|
|
INC HL
|
|
DJNZ POStr
|
|
RET
|
|
;
|
|
LSTStr: LD A,B ;send B chars at (HL) to LST directly
|
|
OR A
|
|
RET Z
|
|
LD E,(HL)
|
|
PUSH BC
|
|
PUSH HL
|
|
CALL LSTOut
|
|
POP HL
|
|
POP BC
|
|
INC HL
|
|
DJNZ LSTStr
|
|
RET
|
|
;
|
|
LSTOut: LD C,LSTO ;print char in E
|
|
JP BDOSep
|
|
;
|
|
;
|
|
;
|
|
; ASSORTED SUPPORT ROUTINES
|
|
;
|
|
;RAM initialization functions
|
|
;
|
|
IniRAM: LD HL,MnuEnd ;Figure what used to be TxtOrg
|
|
LD A,(Help) ;help menus disabled?
|
|
OR A
|
|
JR NZ,IniR02
|
|
LD HL,HelpY ;yes, use that memory for editing
|
|
IniR02: LD (BegTx),HL
|
|
LD HL,(BDOSep+1) ;BDOS origin (xx06)
|
|
LD L,-4 ;a few bytes room
|
|
DEC H ;back a page
|
|
LD (EndTx),HL
|
|
XOR A ;initialize screen
|
|
LD (NSkip),A
|
|
INC A
|
|
LD (Horiz),A
|
|
LD (Vert),A
|
|
LD (CurCol),A
|
|
LD (OldCol),A ;###
|
|
LD HL,1
|
|
LD (CurPg),HL
|
|
LD (CurPgL),HL
|
|
LD (CurLin),HL
|
|
LD (OldLin),HL ;###
|
|
LD HL,(BegTx) ;set up cursor gap, mark CRs at ends
|
|
DEC HL
|
|
LD (BefCu),HL
|
|
LD (HL),CR
|
|
LD HL,(EndTx)
|
|
INC HL
|
|
LD (AftCu),HL
|
|
LD (HL),CR
|
|
RET
|
|
;
|
|
;Case selection subroutine
|
|
; CALL Case
|
|
; DB # of entries in list
|
|
; DW Default subroutine if no match
|
|
; DB value1
|
|
; DW subroutine1....
|
|
; <return point>
|
|
;
|
|
Case: POP HL
|
|
LD B,(HL) ;entries
|
|
INC HL
|
|
LD E,(HL) ;DE=default sbr
|
|
INC HL
|
|
LD D,(HL)
|
|
INC HL
|
|
Lp1Ca: CP (HL) ;Value matches?
|
|
INC HL
|
|
JR NZ,Sk2Ca
|
|
LD E,(HL) ;yes, get address
|
|
INC HL
|
|
LD D,(HL)
|
|
JR Sk3Ca ;finish up
|
|
;
|
|
Sk2Ca: INC HL ;No match, skip ahead
|
|
Sk3Ca: INC HL
|
|
DJNZ Lp1Ca ;Try again
|
|
EX DE,HL ;Swap sbr and return
|
|
PUSH DE ;Store return (end of list)
|
|
JP (HL) ;Go do sbr (LAST match)
|
|
;
|
|
;
|
|
XCase: CALL UCase ;force A to ctl-codes
|
|
CP '@'
|
|
RET C
|
|
CP '_'+1
|
|
RET NC
|
|
AND 1FH
|
|
RET
|
|
UXCase: CP ESC ;uppercase A if letter OR ctl-code
|
|
JR NC,UCase
|
|
ADD A,40H
|
|
RET
|
|
UCase: CP 'a'
|
|
RET C ;uppercase A if letter
|
|
CP 'z'+1
|
|
RET NC
|
|
AND 5FH
|
|
RET
|
|
;
|
|
;
|
|
Wait: LD A,(MacFlg) ;Macro Pause function
|
|
OR A
|
|
JP Z,Error2
|
|
LD A,3 ;Wait about 3/2 sec
|
|
JR Dly0
|
|
;
|
|
Delay: LD B,A ;Delay about A/2 sec
|
|
LD A,(MacFlg) ;but NOT if Macro going
|
|
OR A
|
|
RET NZ
|
|
LD A,B
|
|
Dly0: ADD A,A
|
|
ADD A,A
|
|
Dly1: PUSH AF
|
|
CALL BDly
|
|
POP AF
|
|
DEC A
|
|
JR NZ,Dly1
|
|
RET
|
|
BDly: LD A,(MHz)
|
|
LD B,A
|
|
LD C,0
|
|
BDlyLp: DEC BC
|
|
LD A,B
|
|
OR C
|
|
JR NZ,BDlyLp
|
|
RET
|
|
;
|
|
;
|
|
; UR-ROUTINES
|
|
;
|
|
Fill: LD (DE),A ;fill B bytes at DE with A
|
|
INC DE
|
|
DJNZ Fill
|
|
RET
|
|
;
|
|
GpCnt: LD BC,(BefCu) ;Count cursor gap size
|
|
LD HL,(AftCu)
|
|
DEC HL
|
|
DEC HL
|
|
SubDP: PUSH HL ;Double precision subtract
|
|
OR A ;BC = HL - BC + 1
|
|
SBC HL,BC
|
|
LD B,H
|
|
LD C,L
|
|
INC BC
|
|
POP HL
|
|
RET
|
|
;
|
|
BgCnt: LD HL,(BegTx) ;Count bytes before cursor
|
|
LCnt: LD B,H
|
|
LD C,L
|
|
PUSH HL
|
|
LD HL,(BefCu)
|
|
CALL SubDP
|
|
POP HL
|
|
RET
|
|
NdCnt: LD HL,(EndTx) ;Count bytes after cursor
|
|
RCnt: LD BC,(AftCu)
|
|
JR SubDP
|
|
;
|
|
;Move bytes across cursor gap so the gap moves left.
|
|
;HL points to what will become BefCu.
|
|
;
|
|
MoveL: CALL LCnt ;bytes to move
|
|
RET C
|
|
LD DE,(AftCu)
|
|
DEC DE
|
|
LD HL,(BefCu)
|
|
LDDR
|
|
LD (BefCu),HL
|
|
INC DE
|
|
LD (AftCu),DE
|
|
RET
|
|
;
|
|
;MoveR - Moves gap right. HL will become BefCu.
|
|
;
|
|
MoveR: CALL RCnt
|
|
RET C
|
|
LD DE,(BefCu)
|
|
INC DE
|
|
LD HL,(AftCu)
|
|
LDIR
|
|
LD (AftCu),HL
|
|
DEC DE
|
|
LD (BefCu),DE
|
|
RET
|
|
;
|
|
;CrLft - Find CRs to left of cursor (up to E)
|
|
;
|
|
CrLft: CALL BgCnt
|
|
JR NC,Sk1Lf
|
|
XOR A ;no bytes, return with C and no Z
|
|
SUB 1
|
|
RET
|
|
Sk1Lf: CALL FetchB
|
|
CP CR ;Is cursor on a CR
|
|
JR NZ,Sk2Lf
|
|
LD A,1
|
|
CP E
|
|
JR NZ,Sk2Lf
|
|
SCF ;Asked for 1, and already there: ret C and Z
|
|
RET
|
|
Sk2Lf: LD A,CR
|
|
Lp3Lf: CPDR ;find a CR
|
|
JP PO,Sk4Lf ;count exhausted?
|
|
DEC E
|
|
JR NZ,Lp3Lf ;Do more?
|
|
INC HL ;Back up to before CR
|
|
INC HL
|
|
XOR A ;Found AOK, ret Z and no C
|
|
RET
|
|
Sk4Lf: INC HL ;Back to first byte
|
|
SCF
|
|
CCF ;Clear C
|
|
JR Z,Sk5Lf ;Was first byte CR
|
|
DEC E ;No, reduce count
|
|
RET
|
|
Sk5Lf: INC HL ;Back after CR
|
|
DEC E ;the one we wanted?
|
|
RET Z
|
|
DEC HL ;No, back in front of it
|
|
DEC E
|
|
RET
|
|
;
|
|
;CrRit - same, to right.
|
|
;
|
|
CrRit: CALL NdCnt
|
|
JR NC,Sk1Ri
|
|
XOR A
|
|
SUB 1 ;no bytes, return C and no Z
|
|
RET
|
|
Sk1Ri: LD D,E
|
|
LD A,CR
|
|
LD HL,(AftCu)
|
|
Lp2Ri: CPIR
|
|
JP PO,Sk3Ri
|
|
DEC E
|
|
JR NZ,Lp2Ri
|
|
SCF
|
|
CCF ;found AOK, ret Z and no C
|
|
RET
|
|
Sk3Ri: LD A,D
|
|
CP E
|
|
JR NZ,Sk4Ri
|
|
SCF ;none found, return C and Z
|
|
RET
|
|
Sk4Ri: LD HL,(EndTx)
|
|
DEC HL
|
|
LD A,CR
|
|
LD BC,0FFFFh
|
|
CPDR
|
|
INC HL
|
|
INC HL
|
|
OR 1 ;some but not enough, ret no C and no Z
|
|
RET
|
|
;
|
|
;cursor positioning subroutines
|
|
;
|
|
TopV: LD A,1
|
|
JR LoadV
|
|
MidV: LD A,(TxtLns)
|
|
SRL A
|
|
JR LoadV
|
|
DecV: EXX
|
|
LD HL,(CurLin)
|
|
DEC HL
|
|
LD (CurLin),HL
|
|
EXX
|
|
DecVO: LD A,(Vert) ;returns Z if cannot Dec
|
|
CP 1
|
|
JR Z,LoadV
|
|
DEC A
|
|
JR LoadV
|
|
IncV: EXX
|
|
LD HL,(CurLin)
|
|
INC HL
|
|
LD (CurLin),HL
|
|
EXX
|
|
IncVO: LD A,(Vert) ;returns Z if cannot Inc
|
|
EXX
|
|
LD HL,TxtLns
|
|
CP (HL)
|
|
EXX
|
|
JR Z,LoadV
|
|
INC A
|
|
JR LoadV
|
|
BotV: LD A,(TxtLns)
|
|
LoadV: LD (Vert),A
|
|
RET
|
|
LftH: LD A,1
|
|
JR LoadH
|
|
LTabH: LD A,(Horiz)
|
|
DEC A
|
|
JR Z,RitH
|
|
CALL WhatC ;ouch, got to calculate
|
|
LD HL,NSkip ;Horiz = CurCol-NSkip
|
|
SUB (HL)
|
|
JR C,RitH
|
|
JR LoadH
|
|
DecH: LD A,(Horiz)
|
|
DEC A
|
|
RET Z
|
|
JR LoadH
|
|
TabH: LD A,(Horiz)
|
|
DEC A
|
|
EXX
|
|
LD HL,TabCnt
|
|
OR (HL)
|
|
EXX
|
|
INC A
|
|
JR IncT
|
|
IncH: LD A,(Horiz)
|
|
IncT: EXX
|
|
LD HL,View
|
|
CP (HL)
|
|
EXX
|
|
RET NC
|
|
INC A
|
|
JR LoadH
|
|
RitH: LD A,(View)
|
|
LoadH: EX AF,AF' ;###
|
|
LD A,(CurCol) ;###
|
|
INC A ;###
|
|
JR NZ,LoadH2 ;###
|
|
EX AF,AF' ;###
|
|
RET ;###
|
|
LoadH2: EX AF,AF' ;###
|
|
LD (Horiz),A
|
|
RET
|
|
;
|
|
;
|
|
;Get next text character from memory
|
|
;(HL and C keep track across repeated calls)
|
|
;
|
|
GetNx: XOR A
|
|
CP C ;Have we a hidden space?
|
|
JR NZ,Sk1Gt
|
|
LD A,(HL) ;No, get next byte
|
|
INC HL
|
|
CP 80H ;Does it have hidden space?
|
|
JR NC,Sk2Gt ;Yes, note and remove
|
|
CP CR
|
|
RET
|
|
Sk1Gt: DEC C ;Fetch hidden space
|
|
LD A,' '
|
|
CP CR ;Set Z flag if CR
|
|
RET
|
|
Sk2Gt: AND 7FH
|
|
INC C
|
|
CP CR ;Set Z flag if CR
|
|
RET
|
|
;
|
|
;Hide any hideable spaces. (NEW ALGORITHM)
|
|
;
|
|
Cmprs: CALL BgCnt ;bytes to left
|
|
JR C,Sk2Cm ;none?
|
|
LD D,H
|
|
LD E,L
|
|
DEC DE
|
|
Lp1Cm: LD A,(HL) ;Get a byte
|
|
CP ' ' ;Nonspace? fine
|
|
JR NZ,Sk1Cm
|
|
LD A,(DE) ;Last byte CTL? fine
|
|
CP 20H
|
|
LD A,' '
|
|
JR C,Sk1Cm
|
|
LD A,(DE) ;Hidden space already? fine
|
|
BIT 7,A
|
|
LD A,' '
|
|
JR NZ,Sk1Cm
|
|
LD A,(DE)
|
|
OR 80h ;Got to hide the space.
|
|
DEC DE
|
|
Sk1Cm: INC DE ;Store byte
|
|
LD (DE),A
|
|
INC HL ;Bump input
|
|
DEC BC
|
|
LD A,B
|
|
OR C ;more to do?
|
|
JR NZ,Lp1Cm
|
|
LD (BefCu),DE ;This is now BefCu
|
|
;
|
|
Sk2Cm: CALL NdCnt ;How many after cursor?
|
|
RET C
|
|
LD HL,(EndTx) ;work back from end
|
|
LD D,H
|
|
LD E,L
|
|
INC DE
|
|
Lp3Cm: LD A,(DE)
|
|
CP ' ' ;Last byte space?
|
|
JR NZ,Sk3Cm
|
|
LD A,1FH ;This byte CTL?
|
|
CP (HL)
|
|
JR NC,Sk3Cm
|
|
BIT 7,(HL) ;This byte already hiding?
|
|
JR NZ,Sk3Cm
|
|
SET 7,(HL) ;Got to hide that space
|
|
INC DE
|
|
Sk3Cm: DEC DE
|
|
LDD ;Store byte, Bump input
|
|
INC DE
|
|
JP PE,Lp3Cm ;more to do?
|
|
LD (AftCu),DE ;This is now AftCu
|
|
RET
|
|
;
|
|
;Set BC to gap size (make room if needed, or set EdErr)
|
|
;
|
|
Space: LD L,A ;Save A
|
|
PUSH HL
|
|
CALL GpCnt ;Count gap size
|
|
CALL C,Cmprs ;No room? Hide spaces
|
|
CALL GpCnt ;Room now?
|
|
CALL C,Error1 ;out of memory
|
|
POP HL
|
|
LD A,L
|
|
RET
|
|
;
|
|
InsSpc: LD A,' '
|
|
;
|
|
;Put ordinary byte in A into text at cursor.
|
|
;
|
|
Insrt: CALL Space ;Insert Before cursor
|
|
RET C
|
|
CP EOF
|
|
JR Z,Insrt1
|
|
LD HL,BlkChr
|
|
CP (HL)
|
|
JR Z,Insrt1
|
|
LD HL,Modify
|
|
LD (HL),0FFh
|
|
Insrt1: LD HL,(BefCu) ;Bump pointer
|
|
INC HL
|
|
LD (HL),A ;Store byte
|
|
LD (BefCu),HL
|
|
OR A ;Clear flags
|
|
RET
|
|
InsrtA: CALL Space ;same, but After cursor
|
|
RET C
|
|
LD HL,Modify
|
|
LD (HL),0FFh
|
|
InsrA1: LD HL,(AftCu)
|
|
DEC HL
|
|
LD (HL),A
|
|
LD (AftCu),HL
|
|
OR A
|
|
RET
|
|
;
|
|
;Compute absolute line number
|
|
;
|
|
CountS: LD HL,1 ;Hard way: from start
|
|
LD (CurLin),HL
|
|
CALL BgCnt
|
|
JR Sk0CL
|
|
CountL: LD HL,(LastCu) ;same but faster, using LastCu
|
|
INC HL
|
|
CALL LCnt
|
|
Sk0CL: RET C ;(At start, or have not moved)
|
|
LD DE,0
|
|
LD A,CR
|
|
LD HL,(BefCu)
|
|
Lp1CL: CPDR
|
|
JR NZ,Sk1CL
|
|
INC DE
|
|
JP PE,Lp1CL
|
|
Sk1CL: LD HL,(CurLin)
|
|
ADD HL,DE
|
|
LD (CurLin),HL
|
|
RET
|
|
CountR: LD HL,(LastCu) ;same, but for backward move
|
|
DEC HL
|
|
CALL RCnt
|
|
RET C ;(have not moved)
|
|
LD DE,0
|
|
LD A,CR
|
|
LD HL,(AftCu)
|
|
Lp1CR: CPIR
|
|
JR NZ,Sk1CR ;(have not moved)
|
|
INC DE
|
|
JP PE,Lp1CR
|
|
Sk1CR: LD HL,(CurLin)
|
|
OR A
|
|
SBC HL,DE
|
|
LD (CurLin),HL
|
|
RET
|
|
;
|
|
;
|
|
;MACRO functions
|
|
;
|
|
MacKey: LD HL,KeyQ
|
|
CALL Prompt
|
|
CALL RptKey ;which key?
|
|
CALL UCase
|
|
LD (MKsav),A
|
|
CP 'N' ;no-rpt request?
|
|
JR Z,MK0
|
|
CP 'Q' ;no-rpt & macro request?
|
|
JR NZ,MK00
|
|
MK0: CALL Echo ;show N or Q, get next
|
|
CALL RptKey
|
|
MK00: SUB '0'
|
|
JP C,Error7
|
|
CP 10
|
|
JP NC,Error7
|
|
LD D,A ;save key
|
|
LD A,0FFH
|
|
LD HL,MacStr
|
|
LD BC,StrSiz+1 ;find end
|
|
CPIR
|
|
LD A,StrSiz
|
|
SUB C ;figure length
|
|
LD E,A ;save it
|
|
LD HL,Keys+2
|
|
LD A,D
|
|
OR A
|
|
JR Z,MKlp1F
|
|
MKlp1: LD C,(HL)
|
|
LD B,0 ;find key in list
|
|
ADD HL,BC
|
|
INC HL
|
|
DEC A
|
|
JR NZ,MKlp1
|
|
MKlp1F: LD A,(HL) ;old length
|
|
OR A
|
|
JR Z,MK1
|
|
PUSH DE
|
|
PUSH HL ;delete old one
|
|
LD E,(HL)
|
|
LD D,0
|
|
LD (HL),0
|
|
INC HL
|
|
EX DE,HL
|
|
ADD HL,DE
|
|
LD B,H
|
|
LD C,L
|
|
PUSH HL
|
|
LD HL,Keys+200H
|
|
OR A
|
|
SBC HL,BC ;bytes to move
|
|
LD B,H
|
|
LD C,L
|
|
POP HL
|
|
LDIR
|
|
CALL VerKey
|
|
POP HL
|
|
POP DE
|
|
MK1: LD A,E ;anything to add?
|
|
OR A
|
|
JR Z,MKDone
|
|
LD A,(Keys+1) ;will it fit
|
|
OR A
|
|
JR NZ,MK1a
|
|
LD A,(Keys)
|
|
SUB E
|
|
JP C,Error1 ;out of memory
|
|
MK1a: LD (HL),E ;yes
|
|
INC HL
|
|
LD C,E
|
|
LD B,0
|
|
PUSH HL
|
|
LD HL,Keys+200H-1
|
|
LD D,H
|
|
LD E,L
|
|
OR A
|
|
SBC HL,BC ;from here
|
|
POP BC
|
|
PUSH HL
|
|
SBC HL,BC ;bytes to move
|
|
LD B,H
|
|
LD C,L
|
|
INC BC ;inclusive
|
|
POP HL
|
|
LDDR ;make room
|
|
LD C,(HL)
|
|
LD B,0
|
|
INC HL
|
|
EX DE,HL
|
|
LD HL,MacStr
|
|
PUSH DE
|
|
LDIR ;insert new one
|
|
POP HL
|
|
LD A,(MKsav)
|
|
CP 'N' ;take care of N/Q request
|
|
JR Z,MK2
|
|
CP 'Q'
|
|
JR NZ,MKDone
|
|
DEC HL
|
|
LD A,(HL) ;Q only works if length >1
|
|
CP 2
|
|
INC HL
|
|
JR C,MK2
|
|
INC HL
|
|
SET 7,(HL) ;indicate quiet
|
|
DEC HL
|
|
MK2: SET 7,(HL) ;indicate no-rpt
|
|
MKDone: CALL VerKey
|
|
JP ShoLn1
|
|
;
|
|
;
|
|
VerKey: LD B,10 ;verify key area
|
|
LD HL,200H-12
|
|
LD D,0
|
|
LD IX,Keys+2
|
|
VKlp: LD A,StrSiz ;check size
|
|
CP (IX)
|
|
JR C,VKwipe
|
|
LD E,(IX)
|
|
SBC HL,DE ;decrement
|
|
JR C,VKwipe
|
|
ADD IX,DE ;move to next
|
|
INC IX
|
|
DJNZ VKlp
|
|
LD (Keys),HL ;free bytes
|
|
LD A,H
|
|
OR L
|
|
RET Z ;full?
|
|
VKlp2: LD (IX),0
|
|
INC IX ;zero fill
|
|
DEC HL
|
|
LD A,H
|
|
OR L
|
|
JR NZ,VKlp2
|
|
RET
|
|
VKwipe: LD HL,200H-12 ;oops, bad
|
|
LD (Keys),HL
|
|
LD IX,Keys+2
|
|
LD HL,200H-2
|
|
JR VKlp2
|
|
;
|
|
ChainK: LD HL,MacFlg ;chain to new macro
|
|
BIT 0,(HL) ;(used only if macro going)
|
|
RET Z
|
|
CALL RstI1x ;reset INS to saved state
|
|
CALL RptKey ;get key #
|
|
CP '0'
|
|
JP C,Error8
|
|
CP '9'+1
|
|
JP NC,Error8
|
|
PUSH AF
|
|
CALL Loud
|
|
XOR A
|
|
LD (MacFlg),A
|
|
POP AF
|
|
JR UK0
|
|
;
|
|
UseKey: LD HL,MacFlg ;macro going already?
|
|
BIT 0,(HL)
|
|
RET NZ ;YES, this is just a label
|
|
UK0: SUB '0' ;NO, retrieve key 0-9
|
|
LD B,A
|
|
LD HL,Keys+2
|
|
JR Z,UKlp1F
|
|
UKlp1: LD E,(HL)
|
|
LD D,0 ;find it
|
|
ADD HL,DE
|
|
INC HL
|
|
DJNZ UKlp1
|
|
UKlp1F: LD A,(HL) ;length
|
|
INC HL
|
|
OR A
|
|
JP Z,Error7 ;none?
|
|
LD C,A
|
|
LD B,0
|
|
PUSH BC ;on stack for Mac00 entry
|
|
LD DE,DMA
|
|
PUSH DE
|
|
LDIR ;fetch it in
|
|
POP HL ;point to it
|
|
BIT 7,(HL)
|
|
RES 7,(HL)
|
|
JR Z,Mac00 ;not no-rpt? go ask, etc.
|
|
INC HL
|
|
BIT 7,(HL)
|
|
RES 7,(HL)
|
|
CALL NZ,Quiet ;quiet?
|
|
LD A,'1'
|
|
JR Mac0 ;go do just once
|
|
;
|
|
DoMac: LD HL,MacroQ ;get Macro defn
|
|
CALL Prompt
|
|
CALL GetStr
|
|
DW MacStr ;###
|
|
OR A
|
|
JR Z,MacDel ;none? delete
|
|
LD C,A ;save count
|
|
LD B,0
|
|
PUSH BC
|
|
Mac00: LD HL,RptcQ ;(entry for normal Key)
|
|
CALL Prompt
|
|
CALL RptKey
|
|
CALL UCase
|
|
CP 'Q'
|
|
JR NZ,Mac0
|
|
CALL Echo
|
|
CALL Quiet ;Q? do quiet, get rpt cnt
|
|
CALL RptKey
|
|
Mac0: POP BC ;string cnt (entry for no-rpt Key)
|
|
PUSH AF ;save rpt cnt
|
|
LD A,C
|
|
OR A ;null string?
|
|
JR Z,Mac1
|
|
LD HL,DMA ;move in string
|
|
LD DE,MacStr
|
|
LDIR
|
|
EX DE,HL
|
|
LD (HL),0FFh ;terminator
|
|
Mac1: CALL ShoLn1
|
|
POP AF
|
|
LD B,255
|
|
CP '*' ;figure rpt cnt
|
|
JR Z,Mac2 ;(* is maximal)
|
|
LD B,0 ;(0 is default)
|
|
SUB '0'
|
|
JR C,Mac2
|
|
CP 9+1
|
|
JR NC,Mac2
|
|
LD B,A
|
|
Mac2: LD A,B ;set rpt cnt
|
|
LD (RptCnt),A
|
|
OR A
|
|
JP Z,Loud ;oops, rpt=0
|
|
Mac3: LD HL,MacStr ;Point to it
|
|
LD (CmdPtr),HL
|
|
LD A,0FFH ;Okay, here goes
|
|
LD (MacFlg),A
|
|
LD HL,InsFlg ;save INSERT toggle
|
|
LD A,(HL)
|
|
LD (SavIns),A ;turn INSERT off if on
|
|
BIT 7,(HL)
|
|
CALL NZ,ToggHL
|
|
RET
|
|
MacDel: LD A,0FFH
|
|
LD (MacStr),A
|
|
JP ShoLn1
|
|
;
|
|
;"Macro Programming Language"
|
|
;
|
|
MacJmp: LD A,(MacFlg) ;jump to a label
|
|
OR A
|
|
JP Z,Error8 ;macro must be going
|
|
LD (JmpFlg),A ;say Jump in progress
|
|
CALL RptKey
|
|
LD HL,JmpFlg
|
|
LD (HL),0
|
|
CP '[' ;TOF/EOF?
|
|
JR Z,MJtop
|
|
CP ']'
|
|
JR Z,MJend
|
|
CP '>' ;move/loops?
|
|
JR Z,MJRt
|
|
CP '<'
|
|
JR Z,MJLf
|
|
LD E,A ;key to find
|
|
LD HL,MacStr
|
|
LD B,StrSiz
|
|
MJlp: LD A,(HL) ;search along
|
|
INC HL
|
|
CP 0FFH
|
|
JP Z,Error8
|
|
CP ESC
|
|
JR Z,MJlp01
|
|
DJNZ MJlp
|
|
JP Error8
|
|
MJlp01: LD A,E ;found ESC... right one?
|
|
CP (HL)
|
|
JR NZ,MJlp
|
|
INC HL ;yep
|
|
LD (CmdPtr),HL
|
|
RET
|
|
;
|
|
MJtop: LD HL,MacStr ;redo it from the top
|
|
LD (CmdPtr),HL
|
|
RET
|
|
MJend: XOR A ;quit
|
|
LD (MacFlg),A
|
|
LD E,A
|
|
CALL RstI1x
|
|
JP Loud
|
|
MJRt: CALL NdCnt ;right/left jump loops
|
|
JP C,Error7 ;stop at EOF
|
|
CALL Right
|
|
JR MJredo
|
|
MJLf: CALL BgCnt
|
|
JP C,Error7
|
|
CALL Left
|
|
MJredo: LD HL,(CmdPtr)
|
|
DEC HL ;back up to the ESC to repeat
|
|
DEC HL
|
|
DEC HL
|
|
DEC HL
|
|
LD (CmdPtr),HL
|
|
RET
|
|
;
|
|
MacTst: LD A,0CAH ;(JP Z)
|
|
JR MacT1
|
|
MacTsX: LD A,0C2H ;(JP NZ)
|
|
MacT1: LD (MacT),A
|
|
LD A,(MacFlg)
|
|
OR A ;macro must be going
|
|
JP Z,Error8
|
|
CALL RptKey ;get char to match
|
|
LD E,A
|
|
CALL Fetch ;char at cursor
|
|
CP E
|
|
MacT: JP Z,MacJmp ;yes? jump <--- can be JP NZ too
|
|
JP RptKey ;no, just eat label
|
|
;
|
|
;Get the next key stroke (check Macro first.)
|
|
;
|
|
TRptKy: XOR A ;enable redisp Timer
|
|
JR RK0
|
|
RptKey: LD A,0FFH
|
|
RK0: LD (KeyFlg),A
|
|
LD A,(MacFlg)
|
|
OR A ;macro waiting?
|
|
JP Z,KeyIn ;no.
|
|
MacIn: CALL Keybd ;YES, check keyboard for abort
|
|
CP ESC
|
|
JR NZ,MacIn1
|
|
LD HL,(CmdPtr) ;abort, make this last char
|
|
LD E,(HL)
|
|
LD HL,MacFF+1 ;###
|
|
LD (CmdPtr),HL ;###
|
|
JR MacIn3
|
|
MacIn1: LD HL,(CmdPtr) ;OK, take waiting char
|
|
LD A,(HL)
|
|
INC HL ;bump pointer
|
|
LD (CmdPtr),HL
|
|
MacFF: CP 0FFH ;###
|
|
JR Z,MacFFx ;###
|
|
LD E,A ;###
|
|
LD A,(HL) ;end of macro now? (FF)
|
|
INC A
|
|
JR NZ,MacIn2 ;NO, return char
|
|
LD A,(JmpFlg) ;jump in progress?
|
|
OR A
|
|
JR NZ,MacIn2
|
|
LD HL,RptCnt ;need to repeat?
|
|
LD A,(HL)
|
|
INC A
|
|
JR Z,McIn1a
|
|
DEC (HL)
|
|
JR Z,MacIn3
|
|
McIn1a: LD HL,MacStr ;repeat: reset pointer
|
|
LD (CmdPtr),HL
|
|
JR MacIn2
|
|
MacIn3: CALL Loud
|
|
MacIn2: LD A,E
|
|
AND 7FH ;strip parity, return char
|
|
RET
|
|
MacFFx: XOR A ;NO, stop macro execution
|
|
LD (MacFlg),A
|
|
CALL RstI1x ;restore saved INS state
|
|
JP KeyIn
|
|
;
|
|
;
|
|
;Unconditional Q/L for Macros
|
|
;
|
|
Quiet: LD HL,ShutUp
|
|
LD (HL),0C9H ;(RET)
|
|
RET
|
|
Loud: LD HL,ShutUp
|
|
XOR A ;(NOP)
|
|
CP (HL)
|
|
RET Z
|
|
LD (HL),A
|
|
JP HoldSc ;gotta see...
|
|
;
|
|
RstI1x: LD A,(SavIns)
|
|
LD HL,InsFlg
|
|
CP (HL)
|
|
CALL NZ,ToggHL ;switch INS to match the saved state
|
|
RET
|
|
;
|
|
;Conditional Q/L for formatting etc.
|
|
;
|
|
;
|
|
XQuiet: LD HL,ShutUp
|
|
LD A,(HL)
|
|
LD (HL),0C9H ;(RET)
|
|
LD (SavQ),A
|
|
RET
|
|
XLoud: LD A,(SavQ)
|
|
OR A ;(NOP)
|
|
RET NZ
|
|
LD (ShutUp),A
|
|
RET ;do NOT need redisp here
|
|
;
|
|
;Force loud for header display
|
|
;
|
|
Force: LD HL,ShutUp
|
|
LD A,(HL)
|
|
LD (HL),00H ;(NOP)
|
|
LD (SavQ2),A
|
|
RET
|
|
UForce: LD A,(SavQ2)
|
|
CP 0C9H ;(RET)
|
|
RET NZ
|
|
LD (ShutUp),A
|
|
RET
|
|
;
|
|
;
|
|
; VDE EDITING FUNCTIONS
|
|
;
|
|
;
|
|
;Show information
|
|
;
|
|
Info: CALL MakAlt ;show this first for entertainment
|
|
CALL UndrHd
|
|
CALL Dspl
|
|
DB X,26,0
|
|
LD HL,VersID
|
|
CALL DspLp
|
|
CALL Cmprs ;pack spaces
|
|
CALL GpCnt ;count gap size
|
|
PUSH BC
|
|
LD H,B
|
|
LD L,C
|
|
LD DE,FreNNN ;show it as "free space"
|
|
CALL BCDCon
|
|
LD HL,(EndTx)
|
|
INC HL
|
|
LD DE,(BegTx)
|
|
OR A
|
|
SBC HL,DE
|
|
POP BC
|
|
SBC HL,BC ;memory used
|
|
LD DE,UsdNNN
|
|
CALL BCDCon ;show it as "used"
|
|
LD HL,(BegTx)
|
|
LD DE,(BefCu)
|
|
CALL FSzSbr ;figure actual disk file size
|
|
PUSH BC
|
|
LD HL,(AftCu)
|
|
LD DE,(EndTx)
|
|
CALL FSzSbr
|
|
POP HL
|
|
ADD HL,BC
|
|
LD DE,SizNNN ;show it as "file size"
|
|
CALL BCDCon
|
|
LD A,(Modify)
|
|
OR A ;file changed?
|
|
LD A,'Y'
|
|
JR NZ,Info2
|
|
LD A,'N'
|
|
Info2: LD (ModQQQ),A
|
|
LD HL,InfMsg ;now display the data
|
|
CALL DspLp
|
|
CALL UnAlt
|
|
CALL ESCLp
|
|
JP SetAl
|
|
;
|
|
FSzSbr: LD BC,0 ;count a block
|
|
FSzLp: LD A,E ;done?
|
|
SUB L
|
|
LD A,D
|
|
SBC A,H
|
|
RET C
|
|
LD A,(HL)
|
|
INC HL
|
|
INC BC ;count character
|
|
CP CR
|
|
JR Z,FSz1 ;and (missing) LF?
|
|
CP X
|
|
JR C,FSzLp ;and (hidden) space?
|
|
FSz1: INC BC
|
|
JR FSzLp
|
|
;
|
|
;
|
|
; Blank the screen
|
|
;
|
|
Blank: LD A,(WinFlg) ;window off first (will lose text)
|
|
OR A
|
|
CALL NZ,Window
|
|
LD HL,CsrOff ;###
|
|
CALL CtlStr ;###
|
|
LD HL,TInit
|
|
CALL CtlStr
|
|
CALL ESCLp
|
|
CALL DoHdr
|
|
JP SetAl
|
|
;
|
|
;
|
|
;Move cursor to the beginning of text
|
|
;
|
|
Top: LD HL,(BegTx)
|
|
CALL MoveL ;Move
|
|
CALL TopV ;Adjust cursor
|
|
CALL LftH
|
|
LD HL,1
|
|
LD (CurLin),HL
|
|
JP SetAl
|
|
;
|
|
;
|
|
;Move cursor to the last character of text
|
|
;
|
|
Bottom: LD HL,(BefCu) ;for CountL
|
|
LD (LastCu),HL
|
|
LD HL,(EndTx)
|
|
CALL MoveR ;Move
|
|
CALL BotV ;Adjust cursor
|
|
CALL RitH
|
|
CALL CountL
|
|
JP SetAl
|
|
;
|
|
;
|
|
; Queue: move to next line in ZCPR queue
|
|
;
|
|
Queue: LD BC,Z3MSG
|
|
CALL Z3EAdr
|
|
JP Z,Error7 ; no Z3 message buffers
|
|
LD D,B ; addr of Z3MSG to DE
|
|
LD E,C
|
|
LD HL,RegNum+1 ; current register addr
|
|
LD A,(HL)
|
|
CP MsgUsr-2+MsgNmU ; time to wrap around?
|
|
JR NZ,QueNxt
|
|
QueWrp: LD A,MsgUsr-2 ; yes
|
|
LD (HL),A ; update it
|
|
QueNxt: INC (HL) ; next register
|
|
INC (HL)
|
|
RegNum: LD HL,MsgUsr-2
|
|
ADD HL,DE ; point to next line #
|
|
LD C,(HL)
|
|
INC HL
|
|
LD B,(HL) ; line # to BC
|
|
LD A,B
|
|
OR C
|
|
JP NZ,ZipTo2 ; go to it
|
|
LD HL,RegNum+1 ; is first register empty?
|
|
LD A,(HL)
|
|
CP MsgUsr
|
|
JP Z,Error7 ; yes, error
|
|
JR QueWrp ; no, wrap around
|
|
;
|
|
;
|
|
;QUICK cursor movements
|
|
;
|
|
QuikMk: CALL NdCnt ;look for next place marker
|
|
JR C,QkMk1
|
|
LD HL,(AftCu)
|
|
LD A,EOF ;marker
|
|
CPIR
|
|
JP Z,QikB1 ;found? rest same as ^QB
|
|
QkMk1: CALL BgCnt ;not? try from top
|
|
JR C,QkMk2
|
|
LD HL,(BegTx)
|
|
LD A,EOF
|
|
CPIR
|
|
JP Z,QikB0 ;found? rest same as ^QB
|
|
QkMk2: JP Error7 ;not? error.
|
|
;
|
|
QuikLf: LD E,1 ;move left to start of line
|
|
CALL CrLft
|
|
RET C
|
|
LD A,1
|
|
LD (CurCol),A ;(useful for format subroutines)
|
|
CALL MoveL
|
|
CALL LftH
|
|
JP IfScl
|
|
;
|
|
QuikRt: CALL NdCnt ;move right to end of line
|
|
JP C,ColCnt
|
|
CALL Fetch
|
|
JP Z,ColCnt
|
|
CALL Right
|
|
RET C
|
|
JR QuikRt
|
|
;
|
|
QuikUp: LD A,(Vert) ;move up to top of screen
|
|
DEC A
|
|
RET Z
|
|
LD B,A
|
|
LD A,(CurCol)
|
|
PUSH AF
|
|
QUlp: PUSH BC
|
|
CALL Up
|
|
POP BC
|
|
DJNZ QUlp
|
|
CALL SetNo
|
|
POP AF ;restore col
|
|
JP SkQUD
|
|
;
|
|
QuikDn: LD A,(TxtLns) ;move down to end of screen
|
|
LD HL,Vert
|
|
SUB (HL)
|
|
RET Z
|
|
LD B,A
|
|
LD A,(CurCol)
|
|
PUSH AF
|
|
QDlp: PUSH BC
|
|
CALL Down
|
|
POP BC
|
|
DJNZ QDlp
|
|
CALL SetNo
|
|
POP AF
|
|
JP SkQUD
|
|
;
|
|
ZipTo: LD HL,PageQ ;zip to given page
|
|
LD A,(PgLen)
|
|
OR A
|
|
JR Z,ZipTo0
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
JR NZ,ZipTo1
|
|
ZipTo0: LD HL,LineQ ;or line, in N mode
|
|
ZipTo1: CALL Prompt
|
|
LD BC,1
|
|
CALL GetNbr
|
|
JP C,Error7
|
|
JP Z,Error7
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
JR Z,ZipTo2
|
|
LD A,(PgLen) ;(calculate line)
|
|
OR A
|
|
JR Z,ZipTo2
|
|
LD D,0
|
|
LD E,A
|
|
LD L,D
|
|
LD H,D
|
|
DEC BC
|
|
ZipMul: LD A,B
|
|
OR C
|
|
JR Z,ZipMF
|
|
ADD HL,DE
|
|
DEC BC
|
|
JR ZipMul
|
|
ZipMF: INC HL
|
|
ZipMF2: LD B,H
|
|
LD C,L
|
|
ZipTo2: PUSH BC
|
|
CALL Top
|
|
POP DE ;desired line
|
|
LD A,D
|
|
OR E
|
|
JR Z,ZipXit
|
|
DEC DE ;lines to move down
|
|
XOR A
|
|
OR D
|
|
JR Z,ZipLpF
|
|
ZipLp: PUSH DE ;do multiples of 256
|
|
LD E,0 ;(256)
|
|
CALL CrRit
|
|
DEC HL
|
|
CALL MoveR
|
|
POP DE
|
|
DEC D
|
|
JR NZ,ZipLp
|
|
ZipLpF: XOR A
|
|
OR E
|
|
JR Z,ZipTo3
|
|
CALL CrRit ;do remainder
|
|
DEC HL
|
|
CALL MoveR
|
|
ZipTo3: CALL MidV
|
|
CALL RitH
|
|
CALL CountS
|
|
ZipXit: JP SetAl
|
|
;
|
|
;
|
|
;Move cursor up.
|
|
;
|
|
Up: CALL TestCu ;no delays here
|
|
CALL NZ,ShoCu1
|
|
LD E,2 ;start of last line
|
|
CALL CrLft
|
|
RET NZ ;TOF? quit
|
|
PUSH HL
|
|
CALL EdgeU
|
|
CALL DecV
|
|
POP HL
|
|
CALL MoveL
|
|
SkUpDn: LD A,(CurCol) ;where we were
|
|
SkQUD: CALL GoCol
|
|
RET Z ;exact?
|
|
JP IfScl ;may need to scroll
|
|
;
|
|
;
|
|
;Move cursor down.
|
|
;
|
|
Down: CALL TestCu ;no delays here
|
|
CALL NZ,ShoCu1
|
|
LD E,1 ;start of next line
|
|
CALL CrRit
|
|
DEC HL
|
|
JR NC,Sk1Dn ;was there one?
|
|
RET NZ ;EOF? quit
|
|
LD HL,(EndTx)
|
|
LD A,(HL) ;Get that last byte
|
|
CP CR
|
|
RET NZ ;no next line
|
|
Sk1Dn: PUSH HL
|
|
CALL EdgeD
|
|
CALL IncV
|
|
POP HL
|
|
CALL MoveR
|
|
JR SkUpDn
|
|
;
|
|
QuikLc: LD HL,(SavLin)
|
|
CALL ZipMF2
|
|
LD A,(SavCol)
|
|
;
|
|
;
|
|
GoCol: DEC A ;restore cursor to column A
|
|
RET Z
|
|
LD HL,(HorFlg) ;don't change show status
|
|
PUSH HL
|
|
PUSH AF
|
|
CALL ColCnt ;where are we?
|
|
LD IY,CurCol
|
|
JR GRCent
|
|
GRCLp: CALL NdCnt
|
|
JR C,GRCF ;stop at EOF
|
|
CALL Fetch
|
|
JR Z,GRCF ;stop at CR
|
|
CP TAB ;tabs are special
|
|
JR NZ,GRC1
|
|
LD A,(IY)
|
|
DEC A
|
|
LD HL,TabCnt
|
|
OR (HL) ;round up
|
|
INC A
|
|
LD (IY),A
|
|
GRC1: INC (IY) ;Keep CurCol updated
|
|
CALL Right
|
|
GRCent: POP AF
|
|
PUSH AF
|
|
CP (IY) ;there yet?
|
|
JR NC,GRCLp
|
|
GRCF: POP AF
|
|
POP HL
|
|
LD (HorFlg),HL
|
|
INC A
|
|
SUB (IY) ;set Z if exact
|
|
RET
|
|
;
|
|
;
|
|
;Move cursor one to the left (C=cannot)
|
|
;
|
|
Left: CALL Space ;Any space left?
|
|
RET C
|
|
CALL BgCnt ;Are we at front?
|
|
RET C
|
|
CALL EdgeL
|
|
LD HL,(BefCu) ;Look back
|
|
LD A,(HL)
|
|
BIT 7,(HL) ;Hidden space?
|
|
JR Z,Sk1Lt ;No, just move
|
|
RES 7,(HL) ;Yes, unhide it
|
|
LD A,' '
|
|
INC HL
|
|
Sk1Lt: DEC HL ;Back up
|
|
LD (BefCu),HL
|
|
CALL InsrA1 ;store byte ahead
|
|
CP TAB ;Was a TAB moved
|
|
JR Z,LftTab
|
|
CP CR ;Was a CR moved?
|
|
JR Z,LftCR
|
|
CALL DecH ;no
|
|
OR A
|
|
RET NZ
|
|
JP IfScl ;at left mgn...scroll?
|
|
;
|
|
LftCR: CALL RitH ;special cases - scrolling
|
|
CALL DecV
|
|
CALL ColCnt
|
|
DEC A
|
|
LD HL,View
|
|
CP (HL)
|
|
CALL NC,HorScl
|
|
OR A
|
|
RET
|
|
LftTab: LD A,(Horiz)
|
|
DEC A
|
|
CALL Z,HorScl ;need to scroll if at left
|
|
CALL LTabH
|
|
OR A
|
|
RET
|
|
;
|
|
;
|
|
;Move cursor one to the right
|
|
;(return C if can't, char passed in A)
|
|
;
|
|
Right: CALL Space ;Any room left?
|
|
RET C
|
|
CALL NdCnt ;Already at end?
|
|
RET C
|
|
CALL EdgeR
|
|
CALL Fetch
|
|
JR NZ,Sk0Rt
|
|
PUSH HL
|
|
CALL TestCu ;change of line: no delays
|
|
CALL NZ,ShoCu1
|
|
POP HL
|
|
Sk0Rt: LD A,(HL)
|
|
BIT 7,A ;Hidden space?
|
|
JR Z,Sk1Rt ;No, just move
|
|
LD (HL),' ' ;Yes, unhide it
|
|
AND 7FH
|
|
DEC HL
|
|
Sk1Rt: INC HL ;Bump pointer
|
|
LD (AftCu),HL
|
|
CALL Insrt1 ;put byte in behind
|
|
OR A ;and return it
|
|
PUSH AF
|
|
CP TAB ;TAB and CR are special
|
|
JR Z,RtTab
|
|
CP CR
|
|
JR Z,RtCR
|
|
CALL IncH ;no, just move
|
|
POP AF
|
|
RET
|
|
;
|
|
RtCR: CALL IfScl ;may have to scroll
|
|
CALL IncV ;adjust
|
|
CALL LftH
|
|
LD A,1
|
|
LD (CurCol),A
|
|
POP AF
|
|
RET
|
|
;
|
|
RtTab: LD A,(View)
|
|
DEC A
|
|
LD HL,TabCnt
|
|
SUB (HL)
|
|
LD HL,Horiz
|
|
SUB (HL)
|
|
CALL C,HorScl ;at right, need to scroll
|
|
CALL TabH
|
|
POP AF
|
|
RET
|
|
;
|
|
;
|
|
;Word tab, delete
|
|
;
|
|
WdMxCh EQU 255 ;max chars to loop
|
|
;
|
|
WordRt: CALL Fetch ;Word tab right
|
|
JP Z,Right ;at EOL? special case
|
|
CALL IsBlnk ;on break? just find nonbreak
|
|
JR Z,WRlpF
|
|
LD B,WdMxCh
|
|
WRlp: CALL WRfBrk
|
|
JR Z,WRlpF
|
|
CP CR ;quit at CR
|
|
RET Z
|
|
DJNZ WRlp
|
|
WRlpF: LD B,WdMxCh
|
|
WRlp2: CALL WRfBrk
|
|
RET NZ
|
|
DJNZ WRlp2
|
|
RET
|
|
WRfBrk: PUSH BC
|
|
CALL Right
|
|
JR C,WRfBrX
|
|
CALL IsBlnk ;then nonbreak
|
|
CALL NZ,IsPunc
|
|
PUSH BC
|
|
WRfBrX: POP BC
|
|
POP BC
|
|
RET
|
|
;
|
|
WordLf: CALL FetchB ;Word tab left
|
|
CP CR ;at BOL? Special case
|
|
JP Z,Left
|
|
LD B,WdMxCh
|
|
WLlp: CALL IsParB ;find a nonbreak
|
|
CALL NZ,IsPunB
|
|
JR NZ,WLlpF
|
|
CP CR ;quit at CR
|
|
RET Z
|
|
PUSH BC
|
|
CALL Left
|
|
POP BC
|
|
RET C
|
|
DJNZ WLlp
|
|
WLlpF: CALL Left
|
|
LD B,WdMxCh
|
|
WLlp2: CALL IsParB ;then a break
|
|
CALL NZ,IsPunB
|
|
RET Z
|
|
PUSH BC
|
|
CALL Left
|
|
POP BC
|
|
RET C
|
|
DJNZ WLlp2
|
|
RET
|
|
;
|
|
WordDl: CALL Fetch ;Word Delete
|
|
JP Z,EChar ;at BOL? special case
|
|
CALL IsPaPu ;combined CALL IsPara/CALL NZ,IsPunc
|
|
JR Z,WDlNB ;on break? delete till nonbreak
|
|
CALL IsParB
|
|
CALL NZ,IsPunB
|
|
PUSH AF
|
|
CALL WDlB ;nonbreak? delete till break
|
|
POP AF
|
|
RET NZ ;BOW? delete till nonbreak too
|
|
WDlNB: LD B,WdMxCh
|
|
WDlp2: CALL IsPaPu ;combined CALL IsPara/CALL NZ,IsPunc
|
|
RET NZ ;delete till nonbreak
|
|
CP CR ;but quit at CR
|
|
RET Z
|
|
PUSH BC
|
|
CALL EChar
|
|
POP BC
|
|
DJNZ WDlp2
|
|
RET
|
|
WDlB: LD B,WdMxCh
|
|
WDlp: CALL IsPaPu ;combined CALL IsPara/CALL NZ,IsPunc
|
|
RET Z ;delete till reak
|
|
PUSH BC
|
|
CALL EChar
|
|
POP BC
|
|
DJNZ WDlp
|
|
RET
|
|
;
|
|
Join: CALL IsPaPu ;combined CALL IsPara/CALL NZ,IsPunc
|
|
JR Z,WDlNBx ;on break? delete till nonbreak
|
|
CALL IsParB
|
|
CALL NZ,IsPunB
|
|
PUSH AF
|
|
CALL WDlB ;nonbreak? delete till break
|
|
POP AF
|
|
RET NZ ;BOW? delete till nonbreak too
|
|
WDlNBx: LD B,WdMxCh
|
|
WDlp2x: CALL IsPaPu ;combined CALL IsPara/CALL NZ,IsPunc
|
|
RET NZ ;delete till nonbreak (including CRs)
|
|
PUSH BC
|
|
CALL EChar
|
|
POP BC
|
|
DJNZ WDlp2x
|
|
RET
|
|
;
|
|
IsPaPu: CALL IsPara
|
|
CALL NZ,IsPunc
|
|
RET
|
|
;
|
|
;
|
|
;Move cursor ahead one page
|
|
;
|
|
PageF: CALL SetAl
|
|
LD A,(TxtLns)
|
|
DEC A
|
|
LD E,A ;default scroll
|
|
LD HL,Ovlap
|
|
SUB (HL)
|
|
JR C,PgF1
|
|
INC A
|
|
LD E,A
|
|
PgF1: CALL CrRit ;Point that many CRs down
|
|
DEC HL ;Back off one byte
|
|
JP C,Bottom
|
|
JP NZ,Bottom
|
|
LD DE,(BefCu) ;Prepare Count
|
|
LD (LastCu),DE
|
|
CALL MoveR ;Move cursor gap
|
|
CALL CountL
|
|
JR LDaGoC ;relocate cursor
|
|
;
|
|
;
|
|
;Move cursor back one page
|
|
;
|
|
PageB: CALL SetAl
|
|
LD A,(TxtLns)
|
|
LD E,A
|
|
DEC A ;default scroll
|
|
LD HL,Ovlap
|
|
SUB (HL)
|
|
JR C,PgB1
|
|
ADD A,2
|
|
LD E,A
|
|
PgB1: CALL CrLft ;Point that many CRs back
|
|
JP C,Top
|
|
JP NZ,Top
|
|
LD DE,(AftCu) ;Prepare Count
|
|
LD (LastCu),DE
|
|
CALL MoveL ;Move cursor gap
|
|
CALL CountR
|
|
LDaGoC: LD A,(CurCol)
|
|
JP GoCol ;relocate cursor
|
|
;
|
|
;
|
|
;Scroll screen 1/4 vertically
|
|
;
|
|
ShftD: LD A,(TxtLns) ;Down
|
|
SRL A
|
|
SRL A
|
|
INC A
|
|
LD B,A
|
|
LDLp: PUSH BC
|
|
CALL DecVO
|
|
JR NZ,LDLpF
|
|
CALL Down ;oops, cursor already on top
|
|
CALL DecVO
|
|
LDLpF: POP BC
|
|
DJNZ LDLp
|
|
JP SetAl
|
|
;
|
|
ShftU: LD A,(TxtLns) ;same, up
|
|
SRL A
|
|
SRL A
|
|
INC A
|
|
LD B,A
|
|
LULp: PUSH BC
|
|
CALL IncVO
|
|
JR NZ,LULpF
|
|
CALL Up ;oops, cursr already on bottom
|
|
CALL IncVO
|
|
LULpF: POP BC
|
|
DJNZ LULp
|
|
JP SetAl
|
|
;
|
|
Scr1LD: CALL DecVO ;FAST one-line scrolls
|
|
JR NZ,ScLD1
|
|
CALL Down ;oops, already on top
|
|
CALL DecVO
|
|
ScLD1: LD HL,DelL
|
|
CALL ScrlUD
|
|
JP C,SetAl ; no scroll
|
|
CALL SmlDly
|
|
LD A,(TxtLns)
|
|
LD B,A
|
|
JP ShoLn ;re-show last line
|
|
;
|
|
Scr1LU: LD HL,(CurLin)
|
|
LD DE,(Vert)
|
|
LD D,0
|
|
OR A
|
|
SBC HL,DE
|
|
RET Z ;oops, nowhere to go
|
|
CALL IncVO
|
|
JR NZ,ScLU1
|
|
CALL Up ;oops, already on bottom
|
|
CALL IncVO
|
|
ScLU1: LD HL,InsL
|
|
CALL ScrlUD
|
|
JP C,SetAl ; no scroll
|
|
CALL SmlDly
|
|
JP ShoLn1
|
|
;
|
|
;Scroll screen 32 cols horizontally
|
|
;
|
|
ShftR: LD HL,Horiz ;INcrease screen scroll (right)
|
|
LD A,(HL)
|
|
SUB 32+1
|
|
RET C
|
|
INC A
|
|
LD (HL),A
|
|
LD HL,NSkip
|
|
LD A,(HL)
|
|
ADD A,32
|
|
JR ShftX
|
|
;
|
|
ShftL: LD A,(Horiz) ;DEcrease scroll (left)
|
|
ADD A,32
|
|
LD HL,View
|
|
CP (HL)
|
|
RET NC
|
|
LD (Horiz),A
|
|
LD HL,NSkip
|
|
LD A,(HL)
|
|
SUB 32
|
|
RET C
|
|
;
|
|
;Make current line top
|
|
;
|
|
ShftX: LD (HL),A
|
|
JP SetAl
|
|
;
|
|
MakTop: CALL TopV ;gee boss, that was easy, huh?
|
|
JP SetAl
|
|
;
|
|
;
|
|
;FIND/REPLACE
|
|
;
|
|
;Find next occurance of a given string.
|
|
;
|
|
Find: CALL FndSub
|
|
JP C,Error7
|
|
CALL ShoLn1
|
|
;
|
|
LD A,(FGlobl)
|
|
OR A
|
|
JR Z,RpFind
|
|
LD A,(FBackw) ;global search: backwards?
|
|
OR A
|
|
JR Z,FndBck
|
|
CALL Bottom ;...yes, goto bottom of file
|
|
JR RpFind
|
|
FndBck: CALL Top ;...no, goto top of file
|
|
RpFind: LD A,(FndStr) ;length
|
|
OR A
|
|
RET Z ;no string, quit
|
|
LD A,(FBackw)
|
|
OR A ;backward?
|
|
JR NZ,RpF5
|
|
CALL NdCnt ;number to scan
|
|
JP C,Err4x
|
|
LD HL,(EndTx)
|
|
LD DE,(FndStr) ;string length
|
|
XOR A
|
|
LD D,A ;extend to 16 bits
|
|
SBC HL,DE
|
|
RpSsLp: INC HL
|
|
BIT 7,(HL) ;soft space?
|
|
JR Z,RpSsNo ;nope
|
|
INC A ;count soft spaces?
|
|
RpSsNo: DEC E ;decrement string length
|
|
JR NZ,RpSsLp
|
|
ADC A,C
|
|
LD C,A
|
|
LD A,B
|
|
ADC A,0
|
|
LD B,A
|
|
LD HL,FndStr
|
|
LD A,C
|
|
SUB (HL)
|
|
LD C,A ;less string length
|
|
LD A,B
|
|
SBC A,0
|
|
LD B,A
|
|
JR C,Err4x
|
|
INC BC ;in case last
|
|
LD HL,(BefCu)
|
|
LD (LastCu),HL ;Mark position
|
|
LD HL,(AftCu)
|
|
LD A,(ChgFlg) ;was last operation change?
|
|
OR A
|
|
JR NZ,RpF1
|
|
INC HL ;NO, start at next byte
|
|
DEC BC ;YES, start at this byte
|
|
RpF1: LD A,B
|
|
OR C
|
|
JR Z,Err4x ;gotta have bytes
|
|
LD A,(FUCase)
|
|
CP 0C3H ;ucase? (groan)
|
|
JR Z,SlowFi
|
|
LD A,(FndStr) ;only one char? (groan)
|
|
DEC A
|
|
JR Z,SlowFi
|
|
LD DE,(FndStr+1) ;space in char 1 or 2? (groan)
|
|
LD A,' '
|
|
CP D
|
|
JR Z,SlowFi
|
|
CP E
|
|
JR Z,SlowFi
|
|
JR FastFi
|
|
;
|
|
Err4x: LD A,(FGlobl)
|
|
OR A
|
|
JP Z,Error4 ;not found
|
|
LD HL,(OldLin)
|
|
CALL ZipMF2
|
|
LD A,(OldCol)
|
|
CALL GoCol
|
|
JP Error5
|
|
;
|
|
RpF5: CALL BgCnt ;backward: number to scan
|
|
JR C,Err4x ;EOF?
|
|
LD HL,(AftCu)
|
|
LD (LastCu),HL ;Mark position
|
|
LD HL,(BefCu)
|
|
JR BackFi
|
|
;
|
|
FastFi: LD A,B ;find lead char FAST with CPIR
|
|
OR C
|
|
JR Z,Err4x
|
|
LD A,(FndStr+1)
|
|
CPIR
|
|
JP PE,FstFi1 ;jump if P/V=1 (BC-1 is not 0)
|
|
JR NZ,Err4x ;NOT found
|
|
FstFi1: PUSH BC
|
|
PUSH HL
|
|
LD C,0 ;no hidden spaces involved
|
|
CALL FndChk ;rest of string?
|
|
POP HL
|
|
POP BC
|
|
JR NZ,FastFi ;no match, keep going
|
|
LD C,0
|
|
JP Found
|
|
;
|
|
SlowFi: LD A,(FndStr+1) ;find lead char the slow way
|
|
LD (LdChar+1),A ;(spaces or upcase involved)
|
|
LD D,H
|
|
LD E,L
|
|
ADD HL,BC
|
|
EX DE,HL
|
|
LD C,0
|
|
Lp1Fi: LD (FindSv),BC ;save hidden space status
|
|
CALL GetNx
|
|
CALL FUCase
|
|
LdChar: CP 0 ;<----
|
|
JR Z,Lp1Fi1 ;got one
|
|
Lp1Fi0: LD A,H
|
|
XOR D
|
|
JR NZ,Lp1Fi
|
|
LD A,L
|
|
XOR E
|
|
JR NZ,Lp1Fi
|
|
JR Err4x
|
|
Lp1Fi1: PUSH BC
|
|
PUSH DE
|
|
PUSH HL
|
|
CALL FndChk ;rest of string?
|
|
POP HL
|
|
POP DE
|
|
POP BC
|
|
JR NZ,Lp1Fi0 ;no, keep trying
|
|
LD BC,(FindSv) ;YES, indicate whether lead is hidden
|
|
JR Found
|
|
;
|
|
BackFi: LD A,(FndStr+1) ;find lead char backwards
|
|
LD (LdChr2+1),A
|
|
PUSH HL
|
|
OR A
|
|
SBC HL,BC
|
|
PUSH HL
|
|
POP DE
|
|
POP HL
|
|
INC HL
|
|
INC HL ;adjust for kludge below
|
|
LD C,0
|
|
Lp1BF: LD A,C
|
|
LD (FindSv),A ;clear hidden space status
|
|
OR A
|
|
JR Z,Lp1BFa
|
|
DEC C
|
|
LD A,' '
|
|
JR Lp1BFb
|
|
Lp1BFa: DEC HL ;back up
|
|
DEC HL
|
|
LD A,(HL)
|
|
INC HL ;simulate GetNx in reverse
|
|
BIT 7,A
|
|
JR Z,Lp1BFb
|
|
INC C
|
|
Lp1BFb: AND 7Fh
|
|
CALL FUCase
|
|
LdChr2: CP 0 ;<-----
|
|
JR Z,Lp1BF1 ;got one
|
|
Lp1BF0: LD A,H
|
|
XOR D
|
|
JR NZ,Lp1BF
|
|
LD A,L
|
|
XOR E
|
|
JR NZ,Lp1BF
|
|
JP Err4x
|
|
Lp1BF1: PUSH HL
|
|
PUSH DE
|
|
PUSH BC
|
|
CALL FndChk ;rest of string?
|
|
POP BC
|
|
POP DE
|
|
POP HL
|
|
JR NZ,Lp1BF0 ;no, keep trying
|
|
LD BC,(FindSv) ;YES, indicate whether lead is hidden
|
|
JR FoundB
|
|
;
|
|
FndChk: LD A,(FndStr) ;is (HL) a hit?
|
|
DEC A
|
|
RET Z ;just one char: already matched
|
|
LD B,A
|
|
LD DE,FndStr+2 ;start at char2
|
|
Lp1FC: CALL GetNx
|
|
CALL FUCase
|
|
EX DE,HL
|
|
CP (HL)
|
|
EX DE,HL
|
|
JR Z,Sk1FC
|
|
LD A,(DE) ;hmm, no match
|
|
PUSH HL
|
|
LD HL,WildCd ;consider wildcard
|
|
CP (HL)
|
|
POP HL
|
|
RET NZ ;NOPE.
|
|
Sk1FC: INC DE ;match, keep on
|
|
DJNZ Lp1FC
|
|
RET ;YES.
|
|
;
|
|
;
|
|
Found: LD A,C ;(note C=1 if began with hidden space)
|
|
DEC HL ;point back to char1
|
|
DEC HL ;put cursor BEFORE char1
|
|
CALL MoveR
|
|
LD HL,(AftCu) ;Hidden space there?
|
|
BIT 7,(HL)
|
|
JR Z,Found1
|
|
OR A ;need to be on it?
|
|
JR Z,Found1
|
|
LD A,(HL)
|
|
AND 7FH ;Yep, unhide it
|
|
LD (HL),' '
|
|
CALL Insrt1
|
|
Found1: CALL MidV ;Center on screen
|
|
Chged0: CALL CountL ;Adjust line number
|
|
Chged: CALL RitH ;Adjust cursor
|
|
LD HL,ChgFlg
|
|
BIT 0,(HL)
|
|
JP Z,SetAl ;find? redisplay
|
|
LD HL,FndStr
|
|
XOR A
|
|
ADD A,(HL)
|
|
JR Z,Chgd1
|
|
LD C,A ;change: CR involved?
|
|
LD B,0
|
|
INC HL
|
|
LD A,CR
|
|
CPIR
|
|
JP Z,SetAl ;yes
|
|
Chgd1: LD HL,ChgStr
|
|
XOR A
|
|
ADD A,(HL)
|
|
JP Z,SetCu ;no
|
|
LD C,A
|
|
LD B,0
|
|
INC HL
|
|
LD A,CR
|
|
CPIR
|
|
JP Z,SetAl
|
|
JP SetCu
|
|
;
|
|
FoundB: LD A,C ;(note C=1 if began with hidden space)
|
|
DEC HL ;point back before char1
|
|
CALL MoveL ;Move to found string
|
|
LD HL,(AftCu) ;hidden space there?
|
|
BIT 7,(HL)
|
|
JR Z,FounB1
|
|
OR A ;yes, need to be on it?
|
|
JR Z,FounB1
|
|
LD A,(HL) ;Yes, unhide it
|
|
AND 7Fh
|
|
LD (HL),' '
|
|
CALL Insrt1
|
|
FounB1: CALL MidV ;Center on screen
|
|
CALL RitH ;Adjust cursor
|
|
CALL CountR ;Adjust line number
|
|
JP SetAl
|
|
;
|
|
FndSub: LD HL,FindQ ;Get Find string
|
|
CALL Prompt
|
|
CALL GetStr ;Put string in 80
|
|
DW FndStr+1
|
|
LD DE,FndStr
|
|
LD (DE),A
|
|
RET Z ;no string
|
|
INC DE
|
|
XOR A
|
|
LD (ChgFlg),A ;find, not change
|
|
LD (FBackw),A ;not (yet) backwards
|
|
LD (FGlobl),A ;not (yet) global
|
|
LD A,0C3H ;(JP)
|
|
LD (FUCase),A ;ignore case
|
|
LD HL,DMA
|
|
LD A,(HL)
|
|
CP '/'
|
|
JR NZ,FndSb2
|
|
INC HL
|
|
FndSL1: LD A,(HL)
|
|
INC HL
|
|
OR A
|
|
RET Z
|
|
CP '/' ;do /options/
|
|
JR Z,FndSb2
|
|
CALL UCase
|
|
CP 'C'
|
|
JR Z,FOptC
|
|
CP 'B'
|
|
JR Z,FOptB
|
|
CP 'G'
|
|
JR Z,FOptG
|
|
SCF
|
|
RET
|
|
FOptC: LD A,0C9H ;(RET) respect case
|
|
LD (FUCase),A
|
|
JR FndSL1
|
|
FOptB: LD (FBackw),A ;backward
|
|
JR FndSL1
|
|
FOptG: LD A,0FFH
|
|
LD (FGlobl),A
|
|
JR FndSL1
|
|
FndSb2: LD B,0
|
|
FndSL2: LD A,(HL) ;move string in
|
|
INC HL
|
|
CALL FUCase
|
|
OR A
|
|
LD (DE),A
|
|
JR Z,FndSLF
|
|
INC DE
|
|
INC B
|
|
JR FndSL2
|
|
FndSLF: LD A,B ;count
|
|
LD (FndStr),A
|
|
RET
|
|
;
|
|
FUCase: JP UCase ;<--- becomes RET
|
|
;
|
|
;Change found string [this entry NOT currently in use]
|
|
;
|
|
;Change: CALL ChgSub ;get string
|
|
;
|
|
RepChg: LD HL,(BefCu) ;mark position
|
|
LD (LastCu),HL
|
|
LD A,(FndStr)
|
|
OR A
|
|
JR Z,RpCh1F ;no string
|
|
LD B,A ;count to erase
|
|
RpCh1: PUSH BC
|
|
CALL EChar
|
|
POP BC
|
|
JP C,Error7
|
|
DJNZ RpCh1
|
|
RpCh1F: LD HL,ChgStr ;point to string
|
|
LD A,(HL) ;count to replace
|
|
OR A
|
|
JR Z,RpCh3 ;quit if no new string
|
|
LD B,A
|
|
PUSH BC
|
|
RpCh2: INC HL
|
|
PUSH BC
|
|
PUSH HL
|
|
LD A,(HL)
|
|
CALL Insrt
|
|
POP HL
|
|
POP BC
|
|
CALL C,Error1 ;out of memory
|
|
DJNZ RpCh2
|
|
POP BC
|
|
LD A,(FBackw)
|
|
OR A
|
|
RpCh3: JP Z,Chged0
|
|
RpCh4l: PUSH BC
|
|
CALL Left
|
|
POP BC
|
|
RET C
|
|
DJNZ RpCh4l
|
|
CALL CountR
|
|
JP Chged
|
|
;
|
|
ChgSub: LD A,0FFH ;say we've done a change
|
|
LD (ChgFlg),A
|
|
LD HL,ChgQ
|
|
CALL Prompt
|
|
CALL GetStr ;Put string in 80
|
|
DW ChgStr+1
|
|
PUSH AF
|
|
CALL ShoLn1 ;may need this later
|
|
POP AF
|
|
LD DE,ChgStr
|
|
LD (DE),A
|
|
RET Z ;do not LDIR with B=0
|
|
INC DE
|
|
LD C,A
|
|
LD B,0
|
|
LD HL,DMA
|
|
LDIR ;Move string in
|
|
XOR A
|
|
LD (DE),A ;zero terminate it
|
|
RET
|
|
;
|
|
;Global replace
|
|
;
|
|
Rplace: LD A,0FFH
|
|
LD (YNFlg),A
|
|
CALL FndSub
|
|
JP C,Error7
|
|
LD A,(FndStr)
|
|
OR A
|
|
JP Z,ShoLn1 ;no string?
|
|
LD A,(FGlobl) ;global replace?
|
|
OR A
|
|
JR Z,RplcGo
|
|
LD A,(FBackw) ;backward?
|
|
OR A
|
|
JR Z,RplTop
|
|
CALL Bottom ;goto end
|
|
JR RplcGo
|
|
RplTop: CALL Top ;goto start
|
|
RplcGo: LD A,(MacFlg)
|
|
PUSH AF ;(got to do this before Chg Input)
|
|
CALL ChgSub
|
|
POP AF
|
|
OR A
|
|
CALL NZ,Global ;within Macro: force Global
|
|
CALL RepFCh ;do first one
|
|
JR C,RplLpQ ;none found?
|
|
RplLp: CALL Keybd
|
|
CP ESC ;abort?
|
|
JR Z,RplLpX
|
|
XOR A
|
|
LD (FGlobl),A ;turn off global
|
|
CALL RepFCh
|
|
JR NC,RplLp
|
|
RplLpX: LD A,(EdErr)
|
|
CP 4 ;suppress "not found" error
|
|
CALL Z,Error0
|
|
RplLpQ: CALL XLoud ;turn CONOut back on
|
|
JP SetAl
|
|
;
|
|
;Repeat last find/replace
|
|
;
|
|
Repeat: LD A,0FFH
|
|
LD (YNFlg),A
|
|
CALL RepFCh
|
|
LD A,(YNFlg)
|
|
OR A
|
|
JR Z,RplLp
|
|
RET
|
|
;
|
|
RepFCh: CALL RpFind ;[entry from Replace]
|
|
LD A,(EdErr) ;return Carry if not found or error
|
|
OR A
|
|
SCF
|
|
RET NZ ;not found
|
|
LD A,(ChgFlg)
|
|
OR A
|
|
RET Z ;find only, all done
|
|
CALL ShoAll ;replace, gotta show it
|
|
CALL YesNo ;..and ask
|
|
JR C,RepFC0
|
|
JR Z,RepFC1
|
|
LD A,(FBackw) ;NC,NZ = No
|
|
OR A
|
|
LD A,(FndStr)
|
|
CALL Z,GoRtA ;skip ahead
|
|
OR A
|
|
RET
|
|
RepFC0: RET NZ ;C,NZ means Esc: abort
|
|
RepFC1: CALL RepChg ;Z (C or NC) means Yes
|
|
LD A,(EdErr)
|
|
CP 1 ;error? set carry
|
|
CCF
|
|
RET
|
|
;
|
|
YesNo: LD A,(YNFlg) ;return C=abort, Z=yes
|
|
OR A
|
|
SCF
|
|
RET Z ;"*" mode? Z,C = yes,global
|
|
CALL Loud ;MUST see this
|
|
YesNo1: LD DE,DspEsc ;entry for hyphenation Y/N
|
|
CALL GoTo
|
|
CALL MakAlt
|
|
LD HL,YNMsg ;say "Y/N/*"
|
|
LD B,4
|
|
CALL BHLMsg
|
|
CALL UnAlt
|
|
CALL Cursr
|
|
CALL KeyIn ;MUST come from keyboard
|
|
PUSH AF
|
|
LD DE,DspEsc ;clean up
|
|
CALL GoTo
|
|
LD A,(NoHdrF)
|
|
OR A
|
|
CALL Z,MakAlt
|
|
LD B,4
|
|
CALL BBlank
|
|
CALL UnAlt
|
|
POP AF
|
|
CP ESC ;abort?
|
|
JR NZ,YN1
|
|
OR A
|
|
SCF ;C, NZ = yes
|
|
RET
|
|
YN1: CP '*'
|
|
JR NZ,YN2
|
|
Global: CALL XQuiet
|
|
XOR A
|
|
LD (YNFlg),A ;set global flag
|
|
SCF
|
|
RET ;Z,C = yes,globally
|
|
YN2: AND 5FH ; upper case
|
|
CP 'Y'
|
|
RET Z ;Z,NC = yes,once
|
|
CP 'N'
|
|
JR NZ,YesNo1
|
|
OR A
|
|
RET ;NZ,NC = no
|
|
;
|
|
;
|
|
;Variable Tabs.
|
|
;"VTList" is a list of settings, increasing order, zero fill
|
|
;
|
|
VTTog: LD HL,VTFlg ;toggle variable on/off
|
|
CALL ToggHL
|
|
CALL RulFix
|
|
VTshow: LD A,(VTFlg) ;requires header display
|
|
OR A
|
|
LD HL,VTon
|
|
JR NZ,VTsho1
|
|
LD HL,TogOff
|
|
VTsho1: LD DE,DspTab
|
|
JP TogSho
|
|
;
|
|
;
|
|
VarTab: CALL ColCnt ;advance to next VT setting
|
|
LD B,VTNum
|
|
LD HL,VTList
|
|
VTlp1: CP (HL) ;find it
|
|
JR C,VTb2
|
|
INC HL
|
|
DJNZ VTlp1
|
|
RET ;none, no action.
|
|
VTb2: LD A,(HL)
|
|
PUSH HL
|
|
DEC A
|
|
LD HL,View
|
|
CP (HL)
|
|
CALL NC,HorScl ;may need to scroll
|
|
POP HL
|
|
LD A,(InsFlg)
|
|
OR A ;is insert on?
|
|
LD A,(HL) ;column to move to
|
|
JP Z,MvCol
|
|
JP MvColI ;move by inserting spaces
|
|
;
|
|
TaBack: CALL ColCnt ;retreat to last tab setting
|
|
DEC B
|
|
RET Z
|
|
LD A,(VTFlg)
|
|
OR A
|
|
JR Z,BThard
|
|
LD C,B
|
|
XOR A
|
|
LD B,VTNum
|
|
LD HL,VTList+VTNum-1
|
|
BTlp1: CP (HL) ;skip 0s
|
|
JR NZ,BTb1
|
|
DEC HL
|
|
DJNZ BTlp1
|
|
RET ;no tabs at all, no action
|
|
BTb1: LD A,C
|
|
BTlp2: CP (HL) ;find it
|
|
JR NC,BTb2
|
|
DEC HL
|
|
DJNZ BTlp2
|
|
JP QuikLf ;no more left, go to col 1
|
|
BTb2: LD A,(HL) ;that's it
|
|
JR BTabX
|
|
BThard: LD A,(TabCnt) ;back to last multiple
|
|
CPL
|
|
DEC B
|
|
AND B
|
|
INC A
|
|
BTabX: PUSH AF
|
|
CALL QuikLf ;go all the way back
|
|
POP AF
|
|
JP MvCol ;then go there
|
|
;
|
|
;
|
|
VTSet: LD HL,ColQ ;Set tab(s)
|
|
CALL Prompt
|
|
CALL GetStr
|
|
DW 0
|
|
LD A,(CurCol) ;default is Here
|
|
JR Z,VTSt01 ;nothing entered?
|
|
LD HL,DMA
|
|
LD A,(HL)
|
|
CP '@'
|
|
JR Z,VTSInt ;interval specified?
|
|
CP '#'
|
|
JR Z,VTSGrp ;group?
|
|
EX DE,HL
|
|
CALL GetNN ;nope, single tab set
|
|
JR Z,VTErr
|
|
VTSt01: CALL VTStCl
|
|
JR C,VTErr
|
|
JR VTStX
|
|
VTStCl: LD E,A ;[sbr: set VT here]
|
|
LD A,(VTList+VTNum-1)
|
|
OR A
|
|
SCF
|
|
RET NZ ;must be room in list
|
|
LD BC,VTNum
|
|
LD HL,VTList
|
|
VTSlp1: LD A,(HL) ;find it
|
|
OR A
|
|
JR Z,VTSt1
|
|
CP E
|
|
RET Z ;(quit if already set)
|
|
JR NC,VTSt2
|
|
INC HL
|
|
DEC C
|
|
JR NZ,VTSlp1
|
|
DEC HL ;last place
|
|
VTSt1: LD (HL),E ;add at end
|
|
OR A
|
|
RET
|
|
VTSt2: LD A,E
|
|
LD HL,VTList+VTNum-2 ;make room here
|
|
LD DE,VTList+VTNum-1
|
|
DEC BC
|
|
LDDR
|
|
LD (DE),A ;put it in
|
|
OR A
|
|
RET
|
|
VTErr: JP Error7
|
|
;
|
|
VTSInt: LD DE,VTList ;"@" interval specified
|
|
LD B,VTNum
|
|
XOR A
|
|
CALL Fill ;clear all existing tabs
|
|
EX DE,HL
|
|
INC DE
|
|
CALL GetNN
|
|
OR A
|
|
JR Z,VTStX
|
|
LD C,A
|
|
INC A ;"@n" means n+1, 2n+1 etc
|
|
LD DE,VTList
|
|
LD B,VTNum
|
|
VTSlp2: LD (DE),A
|
|
INC DE
|
|
ADD A,C
|
|
JR C,VTStX
|
|
DJNZ VTSlp2
|
|
JR VTStX
|
|
VTSGrp: LD DE,VTList ;'#' group specivied
|
|
LD B,VTNum
|
|
XOR A
|
|
CALL Fill ;clear all existing tabs
|
|
EX DE,HL
|
|
VTGlp: INC DE
|
|
CALL GetNN ;get one from list
|
|
OR A
|
|
PUSH DE
|
|
CALL NZ,VTStCl ;set it?
|
|
POP DE
|
|
JR C,VTErr
|
|
LD A,(DE)
|
|
OR A
|
|
JR NZ,VTGlp
|
|
VTClX:
|
|
VTStX: CALL ShoLn1 ;all done
|
|
JP RulFix
|
|
;
|
|
;
|
|
VTClr: LD HL,ColQ ;clear a tab
|
|
CALL Prompt
|
|
LD A,(CurCol) ;default is Here
|
|
CALL GetNum
|
|
JR C,VTErr
|
|
JR Z,VTErr
|
|
LD B,VTNum
|
|
LD HL,VTList
|
|
VTClp1: CP (HL) ;find it
|
|
JR Z,VTCl2
|
|
INC HL
|
|
DJNZ VTClp1
|
|
JR VTErr ;wasn't set
|
|
VTCl2: LD (HL),0
|
|
DEC B
|
|
JR Z,VTClX ;was last, all done
|
|
LD D,H
|
|
LD E,L
|
|
INC HL
|
|
LD C,B
|
|
LD B,0
|
|
LDIR ;delete it
|
|
XOR A
|
|
LD (DE),A ;zero fill
|
|
JR VTClX
|
|
;
|
|
;
|
|
; INSERTION FUNCTIONS
|
|
;
|
|
;Store a ctl-code in text
|
|
;
|
|
CtlP: LD HL,CPTog ;say "^P-_", get key
|
|
CALL Prefix
|
|
CALL XCase
|
|
CP DEL
|
|
JR Z,CtlP1
|
|
CP ' ' ;error if not now ctl-char
|
|
RET Z ;(space cancels)
|
|
JP NC,Error2 ;invalid key
|
|
CtlP1: LD HL,BlkChr
|
|
CP (HL) ;don't allow block char
|
|
JP Z,Error2 ;invalid key
|
|
CP TAB ;tabs are special
|
|
JR Z,ITab
|
|
CP CR ;so are CRs
|
|
JP Z,ICRB1
|
|
JR Sk2IC
|
|
;
|
|
IChar: CP ' ' ;Main menu entry: no control codes allowed
|
|
RET C
|
|
Sk2IC: PUSH AF
|
|
CALL ChkLM ;Check for left margin
|
|
JR NC,Sk2aIC
|
|
CALL UpToLM
|
|
CALL SetCu
|
|
Sk2aIC: POP AF
|
|
LD E,A
|
|
CP 7FH ;redo line if DEL/ctl
|
|
CCF
|
|
JR C,Sk3IC
|
|
CP ' '
|
|
Sk3IC: CALL C,SetRCu
|
|
PUSH DE
|
|
CALL NC,XPutCh ;just show nice chars
|
|
POP DE
|
|
PUSH DE
|
|
LD A,E
|
|
CALL Insrt ;Put byte in
|
|
POP DE
|
|
RET C ;Full?
|
|
PUSH DE
|
|
LD A,(Horiz)
|
|
LD HL,View
|
|
CP (HL)
|
|
CALL NC,HorScl ;scroll if at edge
|
|
CALL IncH ;Move cursor
|
|
CALL ChkIns ;adjust for insert mode
|
|
POP DE
|
|
LD A,E
|
|
CP ' '
|
|
RET Z ;if not space
|
|
CP EOF
|
|
RET Z
|
|
LD HL,BlkChr
|
|
CP (HL)
|
|
RET Z
|
|
JP WdWrap ;check wordwrap
|
|
;
|
|
TabKey: LD A,(VTFlg)
|
|
OR A
|
|
JP NZ,VarTab ;maybe variable tabbing
|
|
ITab: LD A,TAB
|
|
CALL Insrt
|
|
RET C
|
|
CALL SetCu
|
|
CALL ChkIns
|
|
LD A,(Horiz)
|
|
LD HL,TabCnt
|
|
ADD A,(HL)
|
|
LD HL,View
|
|
CP (HL)
|
|
CALL NC,HorScl ;scroll if needed
|
|
JP TabH
|
|
;
|
|
;Do a carriage return
|
|
;
|
|
ICR: LD A,(DSFlg)
|
|
OR A
|
|
CALL NZ,ICR1
|
|
ICR1: LD A,(InsFlg)
|
|
BIT 7,A ;Is insert flag on?
|
|
JR NZ,ICRB1
|
|
CALL QuikRt ;noo...
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
JR Z,ICR01
|
|
ICR00: CALL FetchB ;<CR> in Document: make HCR
|
|
CP ' '
|
|
JR NZ,ICR01
|
|
CALL Delete
|
|
JR ICR00
|
|
ICR01: CALL Cursr ;may need to show new HCR
|
|
CALL NdCnt ;Are we at end?
|
|
JR C,ICRB1 ;Yes, add a new line
|
|
CALL IfScl ;no, just move cursor
|
|
CALL Right
|
|
JP ChkAI
|
|
ICRB: CALL ICRB1
|
|
ICRB0: LD A,(DSFlg)
|
|
OR A
|
|
RET Z
|
|
CALL InsSpc ;doublespace? add soft CRLF
|
|
ICRB1: XOR A
|
|
LD (NumTab),A
|
|
CALL IfScl
|
|
LD A,CR
|
|
CALL Insrt ;Put it in
|
|
RET C
|
|
LD A,(Vert)
|
|
LD HL,TxtLns
|
|
CP (HL)
|
|
CALL Z,ScrlU2 ;end of screen? scroll
|
|
CALL SetDn
|
|
CALL IncV ;Move cursor down
|
|
CALL LftH ;Move to start of line
|
|
JR ChkAI
|
|
ICRA: CALL ICRA1
|
|
LD A,(DSFlg)
|
|
OR A
|
|
RET Z
|
|
LD A,' ' ;doublespace? add soft CRLF
|
|
CALL InsrtA
|
|
ICRA1: LD A,CR ;Used as ^N routine only
|
|
CALL InsrtA
|
|
RET C
|
|
CALL FetchB
|
|
CP CR
|
|
JR NZ,ICRAx
|
|
LD HL,InsL
|
|
CALL ScrUDx
|
|
RET NC
|
|
ICRAx: JP SetDn
|
|
;
|
|
;
|
|
;Check for insert mode
|
|
;
|
|
ChkIns: LD A,(InsFlg)
|
|
OR A ;INSERT on?
|
|
JP NZ,SetRCu ;Yes, all done
|
|
LD HL,(BefCu)
|
|
LD A,(HL)
|
|
CP EOF
|
|
JP Z,SetRCu
|
|
LD HL,BlkChr
|
|
CP (HL)
|
|
JP Z,SetRCu
|
|
LD HL,(AftCu) ;No, Look at the character
|
|
LD A,CR
|
|
CP (HL) ;Is it a CR?
|
|
RET Z ;Yes, leave it
|
|
LD A,TAB
|
|
CP (HL) ;TAB? redo line
|
|
CALL Z,SetCu
|
|
LD A,(ShoFlg)
|
|
PUSH AF
|
|
CALL EChar ;overwrite character
|
|
POP AF
|
|
LD (ShoFlg),A
|
|
RET
|
|
;
|
|
;Check for auto indent mode
|
|
;
|
|
ChkAI: LD A,(AIFlg) ;AI on?
|
|
OR A
|
|
RET Z
|
|
LD A,(DSFlg)
|
|
OR A
|
|
RET NZ ;done if doublespacing
|
|
CALL NdCnt ;add text at cmd?
|
|
JR C,ChkAll
|
|
LD A,(InsFlg) ;insert on?
|
|
OR A
|
|
JR Z,ChkALp
|
|
ChkAll: CALL QuikLf ;#inline version of IndPL
|
|
CALL BgCnt ;# /
|
|
RET C ;# /
|
|
CALL Up ;#/
|
|
CALL CntSpc ;get indentation
|
|
PUSH BC ;back to this line
|
|
CALL QuikRt ;#inline version of IndNL
|
|
CALL Right ;#these are just like RfmNL/PL,
|
|
POP BC ;#except they DON'T skip over blank lines
|
|
LD A,B
|
|
CP TAB
|
|
LD A,(NumTab)
|
|
JR Z,ChkAtb
|
|
INC A
|
|
JP MvColI ;do it
|
|
ChkALp: CALL Fetch ;NO, just move to first nonspace
|
|
CP ' '
|
|
JR Z,ChkAI1
|
|
CP TAB
|
|
RET NZ
|
|
ChkAI1: CALL Right
|
|
JR ChkALp
|
|
ChkAtb: OR A
|
|
RET Z
|
|
DEC A
|
|
PUSH AF
|
|
CALL ITab
|
|
POP AF
|
|
JR ChkAtb
|
|
;
|
|
;
|
|
; DELETION FUNCTIONS
|
|
;
|
|
;UNdelete a character
|
|
;
|
|
Undel: CALL GpCnt ;Anything to undelete?
|
|
RET C
|
|
CALL ELret2
|
|
LD HL,(AftCu)
|
|
DEC HL ;here goes
|
|
LD (AftCu),HL
|
|
LD A,(HL)
|
|
CP CR ;was it a CR?
|
|
JP Z,SetDn
|
|
JP SetRCu
|
|
;
|
|
UndlLn: CALL GpCnt ;Do a whole line
|
|
RET C
|
|
CALL ELret2
|
|
LD A,B
|
|
OR A ;max 256 chars
|
|
JR Z,UdLn1
|
|
LD BC,256
|
|
UdLn1: LD HL,(AftCu)
|
|
DEC HL
|
|
DEC HL
|
|
LD A,CR
|
|
CPDR ;look for CR
|
|
RET NZ
|
|
INC HL
|
|
INC HL ;start of line
|
|
LD (AftCu),HL
|
|
JP SetDn
|
|
;
|
|
;
|
|
;Erase character to left of cursor (C=error)
|
|
;
|
|
Delete: CALL Left
|
|
RET C ;Fall through to EChar
|
|
;
|
|
;
|
|
;Erase character to right of cursor (C=error)
|
|
;
|
|
EChar: CALL NdCnt ;Anything to erase?
|
|
RET C
|
|
CALL ELret2
|
|
CALL SetRCu
|
|
LD HL,(AftCu)
|
|
BIT 7,(HL) ;Hidden space?
|
|
JR Z,Sk1EC
|
|
CALL GpShft ;unhide it
|
|
LD HL,(AftCu)
|
|
LD A,(HL)
|
|
LD (HL),' '
|
|
AND 7FH
|
|
DEC HL
|
|
LD (HL),A
|
|
RET
|
|
Sk1EC: LD A,(HL)
|
|
INC HL ;Move up, past character
|
|
LD (AftCu),HL ;Store updated value
|
|
CP CR
|
|
CALL Z,SetDn ;ate a CR?
|
|
OR A
|
|
RET
|
|
;
|
|
GpShft: CALL GpCnt ;Shift gap contents left (for Undel sake)
|
|
RET C
|
|
DEC BC
|
|
LD A,B
|
|
OR C
|
|
SCF
|
|
RET Z
|
|
LD HL,(BefCu)
|
|
INC HL
|
|
LD A,B
|
|
SUB 08H ;Maximum 2k worth
|
|
JR C,GpS1
|
|
LD B,08H
|
|
ADD A,H
|
|
LD H,A
|
|
GpS1: LD D,H
|
|
LD E,L
|
|
INC HL
|
|
LDIR
|
|
OR A
|
|
RET
|
|
GpCR: CALL GpShft ;mark BOL for ^QU
|
|
RET C
|
|
LD A,CR
|
|
LD (DE),A
|
|
RET
|
|
;
|
|
;
|
|
;Line erase functions
|
|
;
|
|
Eline: LD HL,(AftCu) ;first left end
|
|
PUSH HL
|
|
CALL QuikLf
|
|
POP HL
|
|
LD (AftCu),HL
|
|
LD E,1 ;now right end
|
|
CALL CrRit
|
|
JR NC,Eline1 ;found CR? good
|
|
JR NZ,Eline2 ;EOF? return
|
|
LD HL,(EndTx) ;Cursor is in last line
|
|
INC HL
|
|
Eline1: LD (AftCu),HL
|
|
Eline2: CALL ELret2
|
|
LD HL,DelL
|
|
CALL ScrUDx
|
|
JP C,SetDn
|
|
LD A,(TxtLns)
|
|
LD B,A
|
|
JP ShoLn
|
|
;
|
|
EOLine: LD E,1 ;Erase to EOL
|
|
CALL CrRit
|
|
JR NC,Sk1EO ;Found CR? good
|
|
RET NZ ;EOF? return
|
|
LD HL,(EndTx) ;cursor is in last line
|
|
LD A,(HL)
|
|
CP CR ;Is last byte a CR?
|
|
INC HL
|
|
JR NZ,Sk2EO ;No
|
|
Sk1EO: DEC HL ;Point at trailing CR
|
|
Sk2EO: PUSH HL
|
|
JR EBLret ;delete to there
|
|
;
|
|
EBLine: LD HL,(AftCu) ;Erase to BOL
|
|
PUSH HL
|
|
CALL QuikLf
|
|
EBLret: CALL GpCR ;delete to there
|
|
POP HL
|
|
CALL SetRCu
|
|
ELret: LD (AftCu),HL
|
|
ELret2: LD A,0FFh
|
|
LD (Modify),A
|
|
RET
|
|
;
|
|
E2Char: LD HL,CQTTog ;Erase to character
|
|
CALL Prefix
|
|
CP ESC
|
|
RET Z
|
|
CP 'U'-40h ;^U?
|
|
RET Z
|
|
LD (PrevCh),A
|
|
E2CLp: CALL EChar ;always eat first char
|
|
CALL NdCnt
|
|
RET C
|
|
CALL Keybd
|
|
CP ESC
|
|
RET Z
|
|
CALL Fetch
|
|
LD HL,PrevCh
|
|
CP (HL)
|
|
JR Z,E2CLpF
|
|
LD (PrvCh2),A
|
|
JR E2CLp
|
|
E2CLpF: CP CR
|
|
RET NZ
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
RET Z
|
|
LD HL,PrvCh2 ;CR means HARD CR in Doc modes
|
|
LD A,(HL)
|
|
CP ' '
|
|
RET NZ
|
|
LD (HL),CR
|
|
JR E2CLp
|
|
;
|
|
;
|
|
; BLOCK FUNCTIONS
|
|
;
|
|
;MARK Block start and termination
|
|
;
|
|
Block: CALL UnBlAb ;Remove any markers above
|
|
CALL UnBlB1 ;Remove all but last marker below
|
|
Blk01: LD A,(BlkChr) ;mark it now
|
|
JP Sk2IC
|
|
;
|
|
Termin: CALL UnBlA1 ;Remove all but first marker above
|
|
CALL UnBlBl ;Remove any markers below
|
|
JR Blk01
|
|
;
|
|
Unmark: CALL UnBlAb ;Remove all block markers
|
|
CALL UnBlBl
|
|
RET
|
|
;
|
|
;Move cursor to block start
|
|
;
|
|
QikBlk: CALL IsBlk
|
|
EX DE,HL
|
|
INC HL
|
|
BIT 0,A
|
|
JP Z,Error7 ;must be marked
|
|
BIT 6,A
|
|
JR NZ,QikB1
|
|
QikB0: CALL MoveL ;before cursor (entries from QuikMk)
|
|
JR QikB2
|
|
QikB1: DEC HL ;after cursor
|
|
CALL MoveR
|
|
QikB2: CALL CountS ;Adjust count
|
|
CALL RitH ;Adjust cursor
|
|
CALL MidV
|
|
JP SetAl
|
|
;
|
|
;Basic query returns:
|
|
; A= {bit 7=gap in block; 6=start after gap; 1=block marked; 0=start marked}
|
|
; DE,HL= start, end (if marked)
|
|
;
|
|
IsBlk: LD IX,IsBVal
|
|
LD (IX),0 ;result byte
|
|
CALL BgCnt
|
|
JR C,IsB1
|
|
LD A,(BlkChr) ;look before cursor
|
|
CPIR
|
|
JR NZ,IsB1
|
|
SET 0,(IX) ;found start
|
|
LD D,H
|
|
LD E,L
|
|
DEC DE
|
|
JP PO,IsB0
|
|
CPIR
|
|
JR NZ,IsB0
|
|
SET 1,(IX) ;found end
|
|
DEC HL
|
|
IsB5: LD A,(IX) ;exit
|
|
RET
|
|
IsB0: SET 7,(IX) ;straddle
|
|
JR IsB1a
|
|
IsB1: SET 6,(IX) ;block after cursor
|
|
IsB1a: CALL NdCnt ;now look after cursor
|
|
JR C,IsB5
|
|
LD HL,(AftCu)
|
|
IsB3: LD A,(BlkChr) ;search loop
|
|
CPIR
|
|
JR NZ,IsB5
|
|
BIT 0,(IX)
|
|
JR NZ,IsB2
|
|
SET 0,(IX) ;found start
|
|
LD D,H
|
|
LD E,L
|
|
DEC DE
|
|
LD A,B
|
|
OR C
|
|
JR Z,IsB5
|
|
JR IsB3
|
|
IsB2: SET 1,(IX) ;found end
|
|
DEC HL
|
|
JR IsB5
|
|
;
|
|
;
|
|
UnBlA1: CALL BgCnt ;undo all but 1st marker above
|
|
RET C
|
|
LD A,(BlkChr)
|
|
CPIR
|
|
JP PE,UnBA01 ;one? leave and look for more
|
|
RET ;no more, finished
|
|
UnBlAb: CALL BgCnt ;undo all markers above
|
|
RET C
|
|
UnBA01: LD A,(BlkChr)
|
|
CPIR
|
|
RET NZ ;none, finished
|
|
CALL SetAl
|
|
PUSH BC
|
|
PUSH HL
|
|
LD D,H
|
|
LD E,L
|
|
DEC DE
|
|
CALL LCnt
|
|
JR C,UnBA02
|
|
LDIR ;remove it
|
|
UnBA02: DEC DE
|
|
LD (BefCu),DE
|
|
POP HL
|
|
DEC HL
|
|
POP BC
|
|
LD A,B
|
|
OR C
|
|
JR NZ,UnBA01
|
|
RET
|
|
;
|
|
UnBlB1: CALL NdCnt ;undo all but 1st marker below
|
|
RET C
|
|
LD HL,(EndTx)
|
|
LD A,(BlkChr)
|
|
CPDR
|
|
JP PE,UnBB01 ;one, leave and continue
|
|
RET ;none, finished
|
|
UnBlBl: CALL NdCnt ;undo all markers below
|
|
RET C
|
|
LD HL,(EndTx)
|
|
UnBB01: LD A,(BlkChr)
|
|
CPDR
|
|
RET NZ ;none, finished
|
|
CALL SetDn
|
|
PUSH BC
|
|
PUSH HL
|
|
LD D,H
|
|
LD E,L
|
|
INC DE
|
|
CALL RCnt
|
|
JR C,UnBB02
|
|
LDDR ;remove it
|
|
UnBB02: INC DE
|
|
LD (AftCu),DE
|
|
POP HL
|
|
INC HL
|
|
POP BC
|
|
LD A,B
|
|
OR C
|
|
JR NZ,UnBB01
|
|
RET
|
|
;
|
|
;Erase Block
|
|
;
|
|
EBlock: CALL IsBlk
|
|
BIT 1,A ;must be marked
|
|
JP Z,Error7
|
|
BIT 7,A
|
|
JR NZ,EPrt3 ;straddles cursor?
|
|
BIT 6,A ;is it after cursor?
|
|
JR NZ,EPrt2
|
|
LD B,H ;no, before cursor
|
|
LD C,L
|
|
LD HL,(BefCu)
|
|
SBC HL,BC ;bytes to move
|
|
PUSH HL
|
|
LD H,B
|
|
LD L,C
|
|
POP BC
|
|
JR Z,EPrt1a
|
|
INC HL
|
|
LDIR
|
|
EPrt1a: DEC DE
|
|
LD (BefCu),DE
|
|
JR EPrtRt
|
|
EPrt2: EX DE,HL ;it's after cursor
|
|
LD BC,(AftCu)
|
|
PUSH HL
|
|
SBC HL,BC
|
|
LD B,H
|
|
LD C,L
|
|
POP HL
|
|
JR Z,EPrt2a
|
|
DEC HL
|
|
LDDR
|
|
EPrt2a: INC DE
|
|
LD (AftCu),DE
|
|
JR EPrtRt
|
|
EPrt3: DEC DE ;cursor straddles it
|
|
LD (BefCu),DE
|
|
INC HL
|
|
LD (AftCu),HL
|
|
EPrtRt: CALL RitH ;Adjust cursor
|
|
CALL CountS
|
|
CALL ELret2
|
|
JP SetAl
|
|
;
|
|
;Block Copy
|
|
;
|
|
Copy: CALL IsBlk
|
|
AND 82H ;must be marked, not straddled
|
|
CP 2 ;(bit 1 set, 7 clear)
|
|
JP NZ,Error7
|
|
CALL CmpLng ;compute length
|
|
RET Z ;was empty
|
|
CALL CpSafe
|
|
JR NC,Copy02 ;okay, go do it
|
|
CALL Cmprs ;try to get more room
|
|
CALL IsBlk
|
|
CALL CmpLng ;compute length now
|
|
CALL CpSafe ;well?
|
|
JP C,Error1 ;REALLY won't fit
|
|
Copy02: LDDR
|
|
INC DE
|
|
LD (AftCu),DE
|
|
CALL RitH ;adjust cursor
|
|
CALL CountS
|
|
CALL ELret2
|
|
JP SetDn
|
|
;
|
|
CmpLng: DEC HL
|
|
INC DE
|
|
PUSH HL
|
|
INC HL
|
|
SBC HL,DE ;compute length now
|
|
LD B,H
|
|
LD C,L
|
|
POP HL
|
|
LD DE,(AftCu)
|
|
DEC DE
|
|
RET
|
|
;
|
|
CpSafe: PUSH HL ;Set C if BC bigger than gap
|
|
PUSH BC
|
|
CALL GpCnt
|
|
LD H,B
|
|
LD L,C
|
|
POP BC
|
|
SCF ;(just to be safe)
|
|
SBC HL,BC
|
|
POP HL
|
|
RET
|
|
;
|
|
;Block Move
|
|
;
|
|
MovBlk: CALL Copy ;first copy
|
|
LD A,(EdErr)
|
|
OR A
|
|
RET NZ
|
|
JP EBlock ;then delete
|
|
;
|
|
;
|
|
; DISK FUNCTIONS
|
|
;
|
|
;View Directory
|
|
;
|
|
Dir: LD HL,DirQ
|
|
CALL Prompt
|
|
LD A,8+1 ;ask for Duu: or NDR name (8 chars max)
|
|
CALL GSEnt
|
|
DW 0
|
|
PUSH AF
|
|
LD A,(FCB) ;defaults
|
|
LD B,A
|
|
LD A,(FCBU)
|
|
LD C,A
|
|
POP AF
|
|
JR Z,Dir00
|
|
LD B,A
|
|
LD HL,DMA
|
|
DirULp: LD A,(HL)
|
|
CALL UCase ;new D (?)
|
|
LD (HL),A
|
|
INC HL
|
|
DJNZ DirULp
|
|
CP ':'
|
|
JR NZ,Dir0x ;jump if not a ":"
|
|
DEC HL
|
|
LD (HL),0
|
|
Dir0x: LD DE,DMA
|
|
CALL NdrChk
|
|
JR NZ,Dir00 ;is an NDR name
|
|
LD A,(DE) ;new D (?)
|
|
CP '0'
|
|
JP C,Error7 ;<'0', not even a user #
|
|
CP '9'+1
|
|
JR C,Dir0 ;jump is just a user #
|
|
SUB 'A'-1
|
|
CP 17 ;drive letter > 'P'?
|
|
JP NC,Error7 ;yep.. a no no
|
|
LD B,A
|
|
INC DE
|
|
Dir0: PUSH BC
|
|
CALL GetNN ;new uu
|
|
POP BC
|
|
JR NC,Dir0a
|
|
LD A,(FCBU) ; fetch user #
|
|
JR Dir0y
|
|
Dir0a: CP 32 ;0-31 ok
|
|
JP NC,Error7
|
|
Dir0y: LD C,A
|
|
Dir00: PUSH BC
|
|
LD E,C
|
|
LD C,USRN
|
|
CALL BDOSep ;set user
|
|
POP BC
|
|
LD HL,FCBBuf
|
|
LD (HL),B ;and drive
|
|
INC HL
|
|
LD (HL),'?' ;set up *.* FCB
|
|
LD DE,FCBBuf+2
|
|
LD BC,10+1
|
|
LDIR ; wildcard filename, type and extent
|
|
LD (HL),0
|
|
LD BC,19
|
|
LDIR ; zero out S1, S2, RC and alloc. map
|
|
CALL MakAlt
|
|
LD DE,010Fh ;position to col 2
|
|
LD A,(RulFlg)
|
|
OR A
|
|
JR Z,Dir1
|
|
INC D ;move down a line to preserve the ruler
|
|
Dir1: CALL GoTo
|
|
LD A,(View) ;initialize
|
|
SUB 14
|
|
LD (HPos),A
|
|
LD A,(TxtLns) ;lines free on screen
|
|
DEC A
|
|
LD (DirLns),A
|
|
LD A,(View) ;columns free
|
|
LD HL,DirCls
|
|
LD (HL),A
|
|
XOR A
|
|
RRD ;cols=view/16
|
|
LD C,(HL)
|
|
DEC C
|
|
PUSH BC
|
|
LD DE,FCBBuf ;first file?
|
|
LD C,SRCH
|
|
CALL BDOS ; search for first matching file
|
|
POP BC
|
|
CP 0FFH
|
|
JR NZ,Sk1Dir
|
|
CALL DsplC
|
|
DB 'N','o'+X,'File',CR,0
|
|
JP Sk3Dir
|
|
;
|
|
Lp3Dir: PUSH BC
|
|
LD DE,FCBBuf ;next one...
|
|
LD C,SRCN
|
|
CALL BDOS ; search for next matching file
|
|
POP BC
|
|
CP 0FFH
|
|
JP Z,DirEnd ;all done?
|
|
Sk1Dir: ADD A,A
|
|
ADD A,A
|
|
ADD A,A
|
|
ADD A,A
|
|
ADD A,A ;desired FCB is at 32*A + DMA
|
|
LD E,A
|
|
LD D,0
|
|
LD HL,DMA
|
|
ADD HL,DE
|
|
INC HL ;point to filename
|
|
EX DE,HL
|
|
LD HL,9
|
|
ADD HL,DE ;test SYS attribute
|
|
BIT 7,(HL)
|
|
JR Z,Sk2Dir
|
|
LD A,(DirSys) ;yes, include?
|
|
OR A
|
|
JR Z,Lp3Dir ;no
|
|
Sk2Dir: EX DE,HL
|
|
PUSH HL
|
|
LD B,11
|
|
Lp4Dir: RES 7,(HL) ;strip flags
|
|
INC HL
|
|
DJNZ Lp4Dir
|
|
LD DE,4
|
|
ADD HL,DE
|
|
LD (HL),0 ;terminator
|
|
DEC HL
|
|
LD A,' ' ;separator
|
|
LD (HL),A
|
|
DEC HL
|
|
LD (HL),A
|
|
DEC HL
|
|
LD (HL),A
|
|
DEC HL
|
|
LD D,H
|
|
LD E,L
|
|
DEC HL
|
|
LD A,C ;save DirCls
|
|
LD BC,3 ;move TYP
|
|
LDDR
|
|
EX DE,HL
|
|
LD (HL),'.' ;punctuate
|
|
POP HL
|
|
LD C,A ;save DirCls
|
|
PUSH BC
|
|
CALL DspLp ;SHOW IT
|
|
POP BC
|
|
DEC C
|
|
JR NZ,Lp3Dir ;finish line?
|
|
LD HL,DirLns
|
|
DEC (HL)
|
|
JR Z,DirFul ;out of room?
|
|
LD A,CR
|
|
CALL DsByt ;okay, new line
|
|
LD A,(DirCls)
|
|
LD C,A
|
|
JR Lp3Dir
|
|
;
|
|
DirFul: CALL DsplC ;ran out of lines
|
|
DB '...',CR,0
|
|
JR Sk3Dir
|
|
DirEnd: LD A,C ;done, need CR?
|
|
LD HL,DirCls
|
|
CP (HL)
|
|
JR Z,Sk3Dir
|
|
LD A,CR
|
|
CALL DsByt
|
|
Sk3Dir: CALL UnAlt
|
|
CALL IfSpLn
|
|
LD A,(FCBU)
|
|
LD E,A
|
|
LD C,USRN ;reset user
|
|
CALL BDOSep
|
|
CALL SetAl
|
|
JP ESCLp ;wait for ESC to clear
|
|
;
|
|
;Load a new file.
|
|
;
|
|
Load: LD A,(Modify)
|
|
OR A
|
|
JR Z,LoadY
|
|
LD HL,QuitQ ;warn if old file was changed
|
|
CALL Prompt
|
|
CALL Confrm
|
|
JP NZ,ShoLn1
|
|
LoadY: JP Restrt ;go do it
|
|
;
|
|
;Erase a disk file.
|
|
;
|
|
Era: CALL SavNam ;save old FCB
|
|
LD HL,EraQ
|
|
CALL NewNam
|
|
LD A,(EdErr)
|
|
OR A
|
|
JR NZ,EraDon
|
|
LD (FCBs1),A ;zero S1
|
|
CALL DOSVer
|
|
LD A,(FCB)
|
|
CALL C,RstDrv ;reset drive
|
|
LD C,FDEL
|
|
CALL BDOSfc
|
|
INC A
|
|
CALL Z,Error7
|
|
EraDon: CALL GetNam ;restore FCB
|
|
JP ShoLn1
|
|
;
|
|
;
|
|
;Read text from disk file to cursor location.
|
|
;
|
|
Read: CALL SavNam ;save old FCB
|
|
LD HL,ReadQ
|
|
CALL NewNam
|
|
LD A,(EdErr) ;check entry error
|
|
OR A
|
|
JR NZ,RdDone
|
|
;
|
|
LoadIt: CALL IOon ;say wait
|
|
CALL Cmprs ;need all our room
|
|
CALL GpCnt
|
|
JR C,Sk1Rd ;No room?
|
|
LD HL,(BefCu) ;Start here
|
|
CALL MSIn ;Read it in
|
|
JR NZ,Sk2Rd ;Worked?
|
|
Sk1Rd: CALL Error1 ;no, out of room
|
|
JR RdDone
|
|
Sk2Rd: JR NC,Sk3Rd ;Okay?
|
|
CALL Error3 ;no, I/O error
|
|
JR RdDone
|
|
Sk3Rd: LD DE,(BefCu) ;Get old BefCu
|
|
LD (BefCu),HL ;Set new one
|
|
EX DE,HL
|
|
INC HL ;Point at first byte loaded
|
|
CALL MoveL ;Move the cursor
|
|
RdDone: CALL GetNam ;restore FCB
|
|
CALL IOoff
|
|
CALL ELret2
|
|
JP SetAl
|
|
;
|
|
;
|
|
;Write the whole file out to disk.
|
|
;
|
|
Save: LD A,(FCB+1) ;must have filename
|
|
CP ' '
|
|
JR NZ,Save00
|
|
CALL ChgNam
|
|
LD A,(EdErr)
|
|
OR A
|
|
RET NZ
|
|
Save00: LD A,(Modify)
|
|
OR A
|
|
JR NZ,Save01
|
|
LD HL,UnchgQ ;hey, no changes!
|
|
CALL Prompt
|
|
CALL Confrm
|
|
PUSH AF
|
|
CALL ShoLn1
|
|
POP AF
|
|
RET NZ
|
|
Save01: CALL IOon ;say wait
|
|
LD HL,(AftCu)
|
|
LD (LastCu),HL ;save position
|
|
LD HL,(BegTx)
|
|
CALL MoveL ;go to top of file
|
|
CALL NdCnt ;count number of bytes
|
|
JR NC,Save02
|
|
LD BC,0
|
|
Save02: LD HL,(AftCu) ;point at first byte
|
|
CALL MSOut ;write it out
|
|
JR NC,Save03
|
|
CALL Error3 ;I/O error
|
|
JR Save04
|
|
Save03: XOR A
|
|
LD (Modify),A ;clean slate
|
|
Save04: LD HL,(LastCu)
|
|
DEC HL
|
|
CALL MoveR ;go back
|
|
JP IOoff
|
|
;
|
|
;
|
|
;Write block text to a disk file.
|
|
;
|
|
Write: CALL SavNam ;save orig FCB
|
|
LD HL,WritQ
|
|
CALL NewNam
|
|
LD A,(EdErr) ;check entry error
|
|
OR A
|
|
JR NZ,WrXit
|
|
CALL IOon ;say wait
|
|
LD HL,(AftCu) ;save position
|
|
LD (LastCu),HL
|
|
LD HL,(BegTx)
|
|
CALL MoveL ;go to top of file
|
|
CALL IsBlk
|
|
BIT 1,A ;must be marked
|
|
JR Z,WrOops
|
|
INC DE ;point to it
|
|
SBC HL,DE ;size of block
|
|
EX DE,HL
|
|
LD B,D
|
|
LD C,E
|
|
CALL MSOut
|
|
JR NC,WrDone
|
|
WrOops: CALL Error7
|
|
WrDone: LD HL,(LastCu)
|
|
DEC HL
|
|
CALL MoveR ;go back
|
|
CALL IOoff
|
|
WrXit: CALL GetNam ;restore orig FCB
|
|
JP ShoLn1
|
|
;
|
|
;
|
|
SavNam: LD HL,FCB ;Preserve main filename
|
|
LD DE,FCBBuf
|
|
LD BC,12
|
|
LDIR ; copy drive, file name and type
|
|
XOR A
|
|
LD (FCBd0),A
|
|
LD A,(FCBU) ;and user, W/A, FilFlg
|
|
LD (DE),A ; set user number in FCBBuf+13
|
|
INC DE
|
|
LD A,(FMode)
|
|
LD (DE),A ; set S1
|
|
INC DE
|
|
LD A,(FilFlg)
|
|
LD (DE),A ; set S2
|
|
RET
|
|
GetNam: LD HL,FCBBuf ;And restore them
|
|
LD DE,FCB
|
|
LD BC,12
|
|
LDIR
|
|
XOR A
|
|
LD (FCBd0),A
|
|
LD A,(HL)
|
|
LD (FCBU),A
|
|
LD E,A
|
|
INC HL
|
|
LD A,(HL)
|
|
LD (FMode),A
|
|
INC HL
|
|
LD A,(HL)
|
|
LD (FilFlg),A
|
|
LD C,USRN
|
|
JP BDOSep
|
|
;
|
|
;
|
|
;Accept a new file name to be used for disk i/o.
|
|
;
|
|
ChgNam: CALL SavNam
|
|
LD HL,NameQ
|
|
CALL NewNam
|
|
LD A,(EdErr)
|
|
OR A
|
|
CALL NZ,GetNam ;bad? restore
|
|
CALL DfltM ;may have changed modes
|
|
CALL DoHdr
|
|
CALL ELret2
|
|
JP ShoLn1
|
|
;
|
|
NewNam: CALL Prompt ;subroutine entry
|
|
LD A,24+1
|
|
CALL GSEnt ;Ask for input
|
|
DW FNamBf
|
|
JP Z,Error7 ;Error if no input
|
|
LD B,A
|
|
PUSH BC
|
|
LD HL,DMA ;uppercase it
|
|
NNUlp: LD A,(HL)
|
|
CALL UCase
|
|
LD (HL),A
|
|
INC HL
|
|
DJNZ NNUlp
|
|
POP BC ;restore length
|
|
LD HL,DMA
|
|
LD A,(HL)
|
|
CP '/' ;watch for mode only
|
|
JR NZ,NNMod
|
|
INC HL
|
|
CP (HL) ;second '/'
|
|
DEC HL
|
|
JR NZ,NNMod2
|
|
NNMod: LD A,B
|
|
CALL Parse ;parse DU:FN.T /O
|
|
JP C,Error7 ;check bad entry
|
|
XOR A
|
|
LD (FilFlg),A ;kill fileflg
|
|
RET
|
|
NNMod2: INC HL
|
|
LD A,(HL) ;do mode only
|
|
CP 'W' ;WordStar
|
|
JR Z,NNMdOK
|
|
CP 'A' ;ASCII
|
|
JR Z,NNMdOK
|
|
CP 'N' ;non document
|
|
JP NZ,Error7
|
|
NNMdOK: LD (FMode),A
|
|
RET
|
|
;
|
|
DfltM: LD HL,0101H
|
|
LD (LMSav),HL ;margins set
|
|
LD A,(FMode) ;doc or nondoc mode?
|
|
SUB 'N'
|
|
JR Z,Dflt2
|
|
XOR A
|
|
LD (AIFlg),A
|
|
DEC A
|
|
LD (VTFlg),A
|
|
LD A,(HCDflt)
|
|
LD (HCRFlg),A ;HCR display?
|
|
LD A,(RtMarg) ;If RM set, avoid wierd WW/AI conflict
|
|
DEC A
|
|
JR NZ,DfltX
|
|
LD HL,(DfltLM) ;from NONdoc: reset margins
|
|
LD (LfMarg),HL
|
|
DfltX: LD A,';' ;punctation chars: , ; : - . ? !
|
|
JR DfltX2
|
|
Dflt2: LD (LfMarg),HL ;NONdocument mode
|
|
LD (VTFlg),A ;varitabs off
|
|
LD (HCRFlg),A ;HCR display off
|
|
DEC A
|
|
LD (AIFlg),A ;auto indent ON
|
|
LD A,':' ;punctation chars: , : - . ? ! (NOT ;)
|
|
DfltX2: LD (PunTbl+1),A
|
|
JP RulFix
|
|
;
|
|
;
|
|
;Toggle case of character at cursor
|
|
;
|
|
UpLow: CALL Fetch ;also points to byte with (HL)
|
|
AND 5FH ;strip off both hidden space and case
|
|
CP 'A'
|
|
JR C,UpLo1 ;leave alone if not letter
|
|
CP 'Z'+1
|
|
JR NC,UpLo1
|
|
BIT 5,(HL) ;toggle case
|
|
RES 5,(HL)
|
|
JR NZ,UpLo0 ;was lower, now up
|
|
SET 5,(HL) ;was upper, now low
|
|
UpLo0: CALL ELret2
|
|
UpLo1: CALL Right ;move right for next(?)
|
|
JP SetRCu
|
|
;
|
|
;
|
|
;Set page length
|
|
;
|
|
PgSet: LD HL,PgLnQ
|
|
CALL Prompt
|
|
LD A,(FormL) ;default value
|
|
CALL GetNum
|
|
JP C,Error7
|
|
LD (PgLen),A
|
|
CALL DoHdr
|
|
JP ShoLn1
|
|
;
|
|
;
|
|
;VARIOUS TOGGLES
|
|
;
|
|
;Simple on/off toggles
|
|
;
|
|
HCRTog: CALL SetAl ;HCR display
|
|
LD HL,HCRFlg
|
|
ToggHL: LD A,(HL)
|
|
CPL
|
|
LD (HL),A
|
|
RET
|
|
;
|
|
;These require header display
|
|
;
|
|
HypTog: LD HL,HypFlg ;hyphenation
|
|
CALL ToggHL
|
|
HYshow: LD HL,HYon
|
|
LD A,(FMode)
|
|
CP 'N' ;irrelevant in N mode
|
|
JR Z,HYsho0
|
|
LD A,(HypFlg)
|
|
OR A
|
|
JR NZ,HYsho1
|
|
HYsho0: LD HL,TogOff
|
|
HYsho1: LD DE,DspHyp
|
|
JP TogSho
|
|
;
|
|
IToggl: LD HL,InsFlg ;INSERT
|
|
CALL ToggHL
|
|
ITshow: LD A,(InsFlg)
|
|
LD HL,MacFlg
|
|
BIT 7,(HL)
|
|
JR Z,ITsho0
|
|
LD A,(SavIns)
|
|
ITsho0: OR A
|
|
LD HL,INSon
|
|
JR NZ,ITsho1
|
|
LD HL,TogOff
|
|
ITsho1: LD DE,DspIns
|
|
JP TogSho
|
|
;
|
|
DblTog: LD HL,DSFlg ;double spacing
|
|
CALL ToggHL
|
|
OR A
|
|
CALL NZ,AIoff ;turn off auto ident if double spacing
|
|
DblSho: LD A,(DSFlg)
|
|
OR A
|
|
LD HL,DSon
|
|
JR NZ,DSsho1
|
|
LD HL,TogOff
|
|
DSsho1: LD DE,DspSpc
|
|
JP TogSho
|
|
;
|
|
AIoff: LD HL,AIFlg
|
|
INC (HL)
|
|
DEC (HL)
|
|
RET Z ;fall thru to turn off auto indent if it's on
|
|
;
|
|
AITog: LD HL,AIFlg ;auto indentation
|
|
CALL ToggHL
|
|
OR A
|
|
JR Z,AIshow
|
|
LD HL,DSFlg ;is double spacing on?
|
|
INC (HL)
|
|
DEC (HL)
|
|
CALL NZ,ToggHL ;turn it off if so
|
|
CALL NZ,DblSho ;turn off the old DS display
|
|
LD A,1
|
|
CALL SLM1 ;reset left margin to 1
|
|
AIshow: LD A,(AIFlg)
|
|
OR A
|
|
LD HL,AIon
|
|
JR NZ,AIsho1
|
|
LD HL,TogOff
|
|
AIsho1: LD DE,DspInd
|
|
JP TogSho
|
|
;
|
|
PSTog: LD A,(PSokFl)
|
|
OR A
|
|
JP Z,Error2 ;invalid key
|
|
LD HL,PSFlg
|
|
CALL ToggHL
|
|
LD A,(RMSav)
|
|
DEC A
|
|
RET NZ ;margins released? then we're done
|
|
PSDisp: LD A,(FMode)
|
|
CP 'N'
|
|
JR Z,PSTogU ;no PS in nondocument mode
|
|
LD A,(PSFlg)
|
|
OR A
|
|
LD HL,PSon ;proportional spacing on
|
|
JR NZ,PSTogX
|
|
PSTogU: LD HL,TogOff ;turn off margin release
|
|
PSTogX: LD DE,DspMrg
|
|
JP TogSho
|
|
;
|
|
;
|
|
;TEXT FORMAT functions
|
|
;
|
|
SetRM: CALL StMrCm ;Same for left and right
|
|
LD C,A
|
|
LD A,(LfMarg)
|
|
CP C
|
|
JR C,SRM1 ;inside LM?
|
|
LD A,1
|
|
LD (LfMarg),A ;if so, reset LM
|
|
SRM1: LD A,C
|
|
LD (RtMarg),A
|
|
JR StMgEn
|
|
;
|
|
SetLM: CALL StMrCm ;Same for left and right
|
|
LD HL,RtMarg
|
|
CP (HL)
|
|
JR NC,MrgErr
|
|
SLM1: LD (LfMarg),A
|
|
DEC A
|
|
CALL NZ,AIoff
|
|
StMgEn: CALL RulFix
|
|
JP ShoLn1
|
|
;
|
|
StMrCm: LD A,(FMode) ;Set right margin
|
|
CP 'N' ;(must be Document mode)
|
|
JR Z,MrgErr
|
|
LD A,(RMSav) ;okay, do it
|
|
DEC A
|
|
CALL NZ,RelM ;(undo Margin Release)
|
|
LD HL,ColQ
|
|
CALL Prompt
|
|
LD A,(CurCol) ;default: cursor column
|
|
CALL GetNum
|
|
JR Z,MrgErr
|
|
RET NC
|
|
MrgErr: POP HL
|
|
JP Error7
|
|
;
|
|
RelM: CALL RelLM ;release both margins (Toggle)
|
|
LD HL,RtMarg
|
|
LD DE,RMSav
|
|
CALL RelSb
|
|
CALL MRshow
|
|
JP RulFix
|
|
;
|
|
RelLM: LD HL,LfMarg ;SBR: release left only
|
|
LD DE,LMSav
|
|
RelSb: LD A,(HL) ;common subroutine
|
|
CP 1
|
|
JR Z,Rel1
|
|
LD (DE),A ;note: if RMSav>1, margins released
|
|
LD (HL),1
|
|
RET
|
|
Rel1: LD A,(DE)
|
|
LD (HL),A
|
|
LD A,1
|
|
LD (DE),A
|
|
RET
|
|
;
|
|
;Check the right margin
|
|
;
|
|
ChkRM: LD A,(CurCol) ;be sure this is up to date
|
|
LD B,A
|
|
LD A,(RtMarg)
|
|
INC A
|
|
LD C,A
|
|
SUB B ;set C if over
|
|
RET NC
|
|
CALL IgnCtl ;yes, ignore ctlchars
|
|
LD A,C ;try arithmetic once again
|
|
ADD A,E
|
|
SUB B
|
|
RET ;now C set if really over
|
|
;
|
|
IgnCtl: CALL Fetch ;count ctlchars to be ignored
|
|
LD E,0 ;(up to present cursor)
|
|
LD HL,(BefCu)
|
|
JR NZ,IgnC1
|
|
IgnCLp: LD A,(HL) ;count em
|
|
DEC HL
|
|
CP CR ;quit at BOL
|
|
RET Z
|
|
IgnC1: CP TAB ;tabs don't count
|
|
JR Z,IgnCLp
|
|
CP 20H
|
|
JR NC,IgnCLp
|
|
INC E ;others do
|
|
JR IgnCLp
|
|
;
|
|
;Check left margin, space over if needed
|
|
;
|
|
ChkLM: LD A,(LfMarg)
|
|
LD B,A
|
|
LD A,(CurCol)
|
|
SUB B ;be sure this is uptodate
|
|
RET ;ret Z if at, C if over
|
|
;
|
|
UpToLM: LD A,(LfMarg) ;git on over to the LM column
|
|
;
|
|
MvCol: PUSH AF ;move to col A saving any existing text
|
|
CALL GoCol
|
|
POP AF
|
|
MvColI: LD HL,CurCol ;move to col A inserting spaces
|
|
SUB (HL)
|
|
RET C ;we're past already
|
|
RET Z ;we're there
|
|
LD B,A
|
|
CALL SetCu ;this is going to hurt
|
|
MvClp: PUSH BC ;insert B spaces
|
|
CALL InsSpc
|
|
POP BC
|
|
RET C ;quit if out of space
|
|
CALL IncH
|
|
DJNZ MvClp
|
|
RET
|
|
;
|
|
DoLM: LD A,(LfMarg) ;create whole left margin
|
|
DEC A
|
|
RET Z
|
|
LD B,A
|
|
JR MvClp
|
|
;
|
|
;Handle former margin for reformat
|
|
;
|
|
CntSpc: CALL QuikLf ;count lead spaces/tabs on line
|
|
CALL Fetch
|
|
LD B,A
|
|
EXX
|
|
XOR A
|
|
CSpLp: LD (NumTab),A
|
|
PUSH AF
|
|
CALL Fetch
|
|
CP ' '
|
|
JR Z,CSpL1
|
|
CP TAB
|
|
JR NZ,CSpLpF
|
|
CSpL1: EXX
|
|
CP B
|
|
EXX
|
|
JR NZ,CSpLpF
|
|
CALL Right ;move 1 char right
|
|
POP AF
|
|
INC A ;incr # tabs
|
|
JR CSpLp
|
|
CSpLpF: CALL QuikLf ;back to start
|
|
EXX
|
|
CntSpX: POP AF
|
|
RET
|
|
;
|
|
EatSpc: OR A ;eat up to A lead spaces on line
|
|
RET Z
|
|
ESpLp: PUSH AF
|
|
CALL Fetch
|
|
CP TAB
|
|
JR Z,ESpLpF
|
|
CP ' '
|
|
JR NZ,CntSpX
|
|
ESpLpF: CALL EChar
|
|
POP AF
|
|
DEC A
|
|
JR NZ,ESpLp
|
|
RET
|
|
;
|
|
;
|
|
;Update CurCol and return it in A and B
|
|
;(NOTE: slow. When possible, LDA CurCol.)
|
|
;
|
|
ColCnt: CALL WhatC
|
|
LD (CurCol),A
|
|
RET
|
|
;
|
|
WhatC: CALL FetchB ;col 1 is spcl case
|
|
CP CR
|
|
LD A,1
|
|
LD B,A
|
|
RET Z
|
|
LD E,1
|
|
CALL CrLft ;start of line
|
|
LD BC,0
|
|
;
|
|
CCLp: CALL GetNx ;get a char
|
|
CP TAB
|
|
JR NZ,CC1
|
|
LD A,B ;tabs are special
|
|
PUSH HL
|
|
LD HL,TabCnt
|
|
OR (HL) ;round up
|
|
POP HL
|
|
LD B,A
|
|
CC1: INC B ;count char
|
|
LD A,B
|
|
CP 254
|
|
JR Z,CC2 ;too long? return column 255 forever
|
|
XOR A
|
|
CP C
|
|
JR NZ,CCLp ;get hidden space?
|
|
PUSH BC
|
|
CALL LCnt ;compare HL to BefCu
|
|
POP BC
|
|
JR NC,CCLp ;get another, if more exist
|
|
CC2: INC B
|
|
LD A,B ;that is curcol.
|
|
RET
|
|
;
|
|
;
|
|
;Do wordwrap if needed
|
|
;
|
|
WdWrap: LD A,(RtMarg) ;WW off if RM=1
|
|
DEC A
|
|
RET Z
|
|
LD IY,CurCol
|
|
INC (IY) ;count the char you just put in
|
|
CALL ChkRM
|
|
RET NC
|
|
LD B,0 ;past margin...
|
|
WWLp: INC B ;count moves
|
|
PUSH BC
|
|
CALL Left
|
|
DEC (IY)
|
|
POP BC
|
|
CALL FetchB
|
|
CP CR ;oh no Uncle Bill
|
|
JP Z,Error9
|
|
CP '-' ;hyphenation
|
|
JR NZ,WW1
|
|
LD A,(HypFlg)
|
|
OR A
|
|
JR Z,WW1
|
|
CALL Fetch
|
|
CP ' '
|
|
JR Z,WW1a
|
|
INC B
|
|
PUSH BC
|
|
CALL InsSpc ;tuck in a space if there isn't one
|
|
JR WW2
|
|
WW1: CALL Fetch
|
|
CP ' '
|
|
JR NZ,WWLp
|
|
WW1a: PUSH BC
|
|
CALL Right ;leave it if there is
|
|
INC (IY)
|
|
WW2: CALL ChkLM
|
|
JR Z,WWerr
|
|
JR C,WWerr
|
|
CALL ICRB ;break line
|
|
CALL QuikLf
|
|
CALL DoLM
|
|
POP BC
|
|
LD A,(NumTab)
|
|
ADD A,B
|
|
JP C,WWerr
|
|
DEC A ;one spc gone
|
|
GoRtA: OR A ;Go right A chars - used by wordwrap etc
|
|
RET Z
|
|
PUSH AF
|
|
CALL Right
|
|
POP AF
|
|
DEC A
|
|
JR GoRtA
|
|
;
|
|
WWerr: POP BC
|
|
JP Error9
|
|
;
|
|
;Reform a paragraph
|
|
;
|
|
Reform: LD A,(RtMarg) ;is RM set?
|
|
DEC A
|
|
RET Z
|
|
CALL QuikLf
|
|
CALL NdCnt
|
|
JP C,RfmE10
|
|
CALL Fetch ;empty line?
|
|
JP Z,Down
|
|
CALL XQuiet
|
|
LD A,(AIFlg)
|
|
OR A
|
|
JR NZ,RfmBg
|
|
CALL RfmNL ;figure out indentation
|
|
JR C,RfmBg
|
|
CALL CntSpc
|
|
PUSH AF
|
|
CALL RfmPL
|
|
POP AF
|
|
CALL EatSpc ;remove spaces acc. to NEXT line indent
|
|
CALL DoLM ;and add current margin
|
|
RfmBg: CALL QuikLf
|
|
CALL KyPeek ;peek for a keypress
|
|
CP ESC ;check for abort
|
|
JR NZ,RfmBg1 ;no... keep going
|
|
CALL Keybd ;eat the ESC
|
|
JP RfmEnd ;and quit
|
|
RfmBg1: CALL ColCnt ;only once per line (slow)
|
|
LD IY,CurCol
|
|
LD A,63
|
|
LD (PScnt),A
|
|
;
|
|
RfmLp: CALL NdCnt
|
|
JP C,RfmE10 ;check for EOF
|
|
CALL Fetch
|
|
JP Z,Rfm7 ;and EOL
|
|
CP TAB ;tabs are special
|
|
JR NZ,RfmTab
|
|
LD A,(IY)
|
|
DEC A
|
|
LD HL,TabCnt
|
|
OR (HL) ;round up
|
|
INC A
|
|
LD (IY),A
|
|
JR Rfm3
|
|
RfmTab: LD HL,PSFlg
|
|
DEC (HL)
|
|
INC (HL)
|
|
JR Z,Rfm3
|
|
LD HL,PSTbl-32
|
|
ADD A,L
|
|
LD L,A
|
|
LD A,0
|
|
ADC A,H
|
|
LD H,A
|
|
LD A,(PScnt)
|
|
ADD A,(HL)
|
|
CP 63+30
|
|
JR NC,RfmTb1
|
|
CP 63-30+1
|
|
JR NC,Rfm3
|
|
ADD A,30
|
|
JR Rfm3a
|
|
RfmTb1: ADD A,-30
|
|
INC (IY)
|
|
Rfm3: INC (IY) ;Keep CurCol updated
|
|
Rfm3a: LD (PScnt),A
|
|
CALL Right
|
|
CALL ChkRM
|
|
JR NC,RfmLp
|
|
;
|
|
Rfm4: CALL FetchB ;just the right length?
|
|
CP ' '
|
|
JR NZ,Rfm4a
|
|
CALL Fetch
|
|
JR Z,Rfm7
|
|
Rfm4a: CALL Left ;oops, too long.
|
|
CALL FetchB
|
|
CP CR
|
|
JP Z,RfmErr
|
|
CALL Fetch
|
|
CP '-'
|
|
JR NZ,Rfm4b
|
|
LD A,(HypFlg)
|
|
OR A
|
|
JR Z,Rfm4b
|
|
CALL Right
|
|
CALL ColCnt ;##
|
|
CALL ChkRM ;##
|
|
JR NC,Rfm4a2 ;##
|
|
CALL Left ;##
|
|
JR Rfm4 ;##
|
|
;
|
|
Rfm4a2: CALL InsSpc
|
|
JR Rfm4c
|
|
Rfm4b: CALL IsBlnk ;break after blank
|
|
JR NZ,Rfm4
|
|
CALL Right
|
|
Rfm4c: CALL ColCnt
|
|
CALL ChkLM ;watch out for left mgn
|
|
JP Z,RfmErr
|
|
JP C,RfmErr
|
|
CALL ICRB
|
|
Rfm5: CALL Fetch ;avoid spurious para
|
|
JR Z,Rfm6a ;(stop after CR)
|
|
CP ' '
|
|
JR NZ,Rfm6b
|
|
CALL EChar
|
|
JR Rfm5
|
|
Rfm6a: CALL EChar
|
|
JR RfmBg2
|
|
Rfm6b: CALL DoLM
|
|
JR RfmBg2
|
|
;
|
|
Rfm7: CALL FetchB ;is the CR soft or hard?
|
|
CP ' '
|
|
JR NZ,Rfm9 ;hard, quit
|
|
CALL Left ;soft, delete any other spaces
|
|
Rfm7a: CALL FetchB
|
|
CP ' '
|
|
JR NZ,Rfm7b
|
|
CALL Delete
|
|
JR Rfm7a
|
|
Rfm7b: CP '-' ;unhyphenate?
|
|
JR Z,Rfm20
|
|
Rfm8: CALL Right ;and now the CR itself
|
|
CALL EChar
|
|
CALL RfmSD ;and any soft CR following
|
|
LD A,255
|
|
CALL EatSpc ;and any leading spaces
|
|
CALL Fetch
|
|
JR NZ,Rfm8a ;hit bald CR?
|
|
CALL Delete ;yep, kill space and quit
|
|
JR Rfm9
|
|
Rfm8a: CALL Left
|
|
CALL Left
|
|
CALL IsEndS ;(extra spc for punc)
|
|
JR NZ,RfmBg2
|
|
CALL Right
|
|
CALL InsSpc
|
|
RfmBg2: JP RfmBg
|
|
Rfm9: CALL Right ;hard CR (check following soft?)
|
|
CALL RfmSD ;delete, if there
|
|
CALL ICRB0 ;may need to separate paras
|
|
RfmEnd: CALL XLoud
|
|
JP SetAl
|
|
RfmErr: CALL XLoud
|
|
JP Error9
|
|
RfmE10: CALL XLoud
|
|
JP Eror10
|
|
;
|
|
Rfm20: LD A,(HypFlg) ;unhyphenation
|
|
OR A
|
|
JR Z,Rfm8 ;not allowed, continue
|
|
Rfm21: CALL Loud
|
|
CALL ShoAll
|
|
CALL YesNo1
|
|
PUSH AF
|
|
CALL XQuiet
|
|
POP AF
|
|
JR NC,Rfm22
|
|
JR Z,Rfm21 ;C,Z means "*": unacceptable
|
|
JR Rfm8 ;C,NZ means ESC: don't join at all
|
|
Rfm22: CALL Z,Delete ;kill hyphen if it was "Yes"
|
|
CALL Join ;join lines (whether "Yes or No")
|
|
JR RfmBg2
|
|
;
|
|
RfmNL: CALL QuikRt ;go to next line of text
|
|
CALL NdCnt
|
|
JR NC,RfmNL0
|
|
CALL QuikLf ;oops, none
|
|
SCF
|
|
RET
|
|
RfmNL0: CALL Right
|
|
CALL Fetch ;(may be blank)
|
|
JR NZ,RfmNL1 ;bald CR next? also give up
|
|
CALL Up
|
|
SCF
|
|
RET
|
|
RfmNL1: CP ' '
|
|
JR Z,RfmNL2
|
|
CALL QuikLf ;no, fine, we're here
|
|
OR A
|
|
RET
|
|
RfmNL2: CALL Right
|
|
CALL Fetch
|
|
JR NZ,RfmNL1 ;just spaces and CR? doublespacing,
|
|
CALL Right ; go on to next line
|
|
JR RfmNL1
|
|
RfmPL: CALL QuikLf ;return to previous line of text
|
|
RfmPL0: CALL Left
|
|
CALL FetchB ;(may be blank)
|
|
CP CR
|
|
JP Z,RfmPLx ;yes, take next
|
|
CP ' '
|
|
JR Z,RfmPL0
|
|
JP QuikLf ;no, fine
|
|
RfmPLx: CALL Left
|
|
JP QuikLf
|
|
;
|
|
RfmSD: CALL Fetch ;delete a soft CR if present
|
|
CP ' '
|
|
RET NZ
|
|
CALL Right
|
|
CALL Fetch
|
|
PUSH AF
|
|
CALL Left
|
|
POP AF
|
|
RET NZ
|
|
CALL EChar
|
|
JP EChar
|
|
;
|
|
;
|
|
;Center or flush a line
|
|
;
|
|
Center: LD E,1FH ;(RRA) if Center
|
|
CP 'F'-40H
|
|
JR NZ,Ctr0
|
|
LD E,0C9H ;(RET) if Flush
|
|
Ctr0: LD A,E
|
|
LD (Flush),A
|
|
LD A,(RtMarg)
|
|
CP 1
|
|
RET Z ;not if no margin
|
|
CALL QuikLf ;start of line
|
|
CtrL1: CALL Fetch
|
|
JR Z,CtrXit ;end? done
|
|
CALL IsBlnk
|
|
JR NZ,CtrL1F
|
|
CALL EChar ;delete spaces
|
|
JP C,Error9
|
|
JR CtrL1
|
|
CtrL1F: CALL QuikRt ;end of line
|
|
CtrL2: CALL Left
|
|
CALL IsBlnk
|
|
JR NZ,CtrL2F
|
|
CALL EChar ;delete spaces
|
|
JR CtrL2
|
|
CtrL2F: CALL ColCnt ;where are we?
|
|
CALL IgnCtl ;ignore ctlchars
|
|
LD HL,CurCol
|
|
LD A,(LfMarg)
|
|
DEC A
|
|
LD B,A
|
|
LD A,(RtMarg)
|
|
ADD A,E ;(ctlchars)
|
|
SUB B
|
|
SUB (HL)
|
|
JP C,Error9 ;error
|
|
CALL Flush
|
|
JR Z,CtrXit
|
|
PUSH AF
|
|
CALL QuikLf ;start again
|
|
CALL DoLM
|
|
POP BC
|
|
CtrL3: PUSH BC ;insert spaces to center
|
|
CALL InsSpc
|
|
POP BC
|
|
DJNZ CtrL3
|
|
CtrXit: CALL QuikLf
|
|
CALL ShoCu
|
|
CALL QuikRt ;to next line(?)
|
|
JP Right
|
|
;
|
|
Flush: RRA ;<--- goes to RET if Flush
|
|
AND 7FH ;take half the difference for Center
|
|
RET
|
|
;
|
|
;
|
|
;Fetch character at (or before) cursor
|
|
;
|
|
Fetch: LD HL,(AftCu)
|
|
LD A,(HL)
|
|
AND 7FH ;ignore any hidden space
|
|
CP CR
|
|
RET
|
|
FetchB: LD HL,(BefCu)
|
|
LD A,(HL)
|
|
BIT 7,A
|
|
RET Z ;ordinary byte
|
|
LD A,' '
|
|
RET ;hidden space
|
|
;
|
|
;Tests on char at cursor (use only A,HL)
|
|
;
|
|
IsBlnk: LD HL,BlkTbl ;point to tbl
|
|
JR IsTest
|
|
IsPara: LD HL,ParTbl
|
|
JR IsTest
|
|
IsParB: LD HL,ParTbl
|
|
JR IsTstB
|
|
IsPunc: LD HL,PunTbl
|
|
JR IsTest
|
|
IsPunB: LD HL,PunTbl
|
|
JR IsTstB
|
|
IsEndS: LD HL,EndTbl
|
|
;
|
|
IsTest: PUSH HL
|
|
CALL Fetch
|
|
POP HL
|
|
JR IsTLp
|
|
IsTstB: PUSH HL
|
|
CALL FetchB
|
|
POP HL
|
|
IsTLp: BIT 7,(HL)
|
|
JR NZ,IsTst1 ;at end of tbl?
|
|
CP (HL)
|
|
RET Z ;Z set if match
|
|
INC HL
|
|
JR IsTLp
|
|
IsTst1: OR A ;clear Z if none
|
|
RET ;ret char in A
|
|
;
|
|
PunTbl: DB ',;:-' ;fall thru...
|
|
EndTbl: DB '.?!',0FFh ;end with 0FFh
|
|
ParTbl: DB CR ;fall thru...
|
|
BadTbl: DB 0,EOF ;characters not "part" of file text
|
|
BadLen EQU $-BadTbl ;(<--BlkChr patches in here)
|
|
BlkTbl: DB ' ',TAB,0FFh ;end with 0FFh
|
|
;
|
|
;DISK I/O
|
|
;
|
|
IOon: LD DE,DspEsc ;show Wait....
|
|
CALL GoTo
|
|
CALL MakAlt
|
|
LD HL,IOmsg
|
|
LD B,4
|
|
CALL BHLMsg
|
|
CALL UnAlt
|
|
RET
|
|
;
|
|
BDOSfc: LD DE,FCB
|
|
;
|
|
;Enter BDOS, but latch onto warm start for
|
|
;recovery purposes. (CP/M 2 ONLY)
|
|
;
|
|
BDOS: CALL DOSVer
|
|
JP NC,BDOSep ; just do the BDOS call for CP/M 3.0
|
|
LD A,(DE) ; grab drive #
|
|
LD (FcbDrv+1),A ; and stuff it into code
|
|
PUSH DE
|
|
LD HL,(0001H)
|
|
INC HL ;trap warm boot vector in BIOS JP table
|
|
LD E,(HL)
|
|
INC HL
|
|
LD D,(HL)
|
|
LD (BIOSws+1),DE
|
|
LD DE,BIOSws
|
|
LD (HL),D
|
|
DEC HL
|
|
LD (HL),E
|
|
POP DE
|
|
CALL BDOSep ;DO IT
|
|
PUSH HL
|
|
LD DE,(BIOSws+1) ;Restore real warm boot
|
|
LD HL,(0001H)
|
|
INC HL
|
|
LD (HL),E
|
|
INC HL
|
|
LD (HL),D
|
|
POP HL
|
|
RET
|
|
BIOSws: LD DE,0 ;<--- Warm boot vector
|
|
LD HL,(0001H)
|
|
INC HL
|
|
LD (HL),E ;restore it
|
|
INC HL
|
|
LD (HL),D
|
|
FcbDrv: LD A,0 ;<-----
|
|
LD (FCB),A ;restore drive
|
|
LD SP,Stack ;restore stack
|
|
CALL RDlog ;and disks
|
|
CALL Error3 ;Give I/O message
|
|
JP Sk1Ed ;Continue editing
|
|
;
|
|
DOSVer: LD A,0 ;<---- Version
|
|
CP 30H ;(Carry set if 2.2, reset if CP/M3, ZxDOS)
|
|
RET
|
|
;
|
|
RstDrv: OR A ;CP/M 2 drive reset (A=1 etc)
|
|
JR Z,RDlog
|
|
LD HL,FixDsk
|
|
RES 6,(HL) ;(have to adjust from ASCII)
|
|
CP (HL) ;one of 2 fixed drives? ignore
|
|
RET Z
|
|
INC HL
|
|
RES 6,(HL)
|
|
CP (HL)
|
|
RET Z
|
|
PUSH AF
|
|
LD C,GDRV
|
|
CALL BDOSep
|
|
POP BC
|
|
INC A
|
|
CP B ;is it logged drive?
|
|
JR Z,RDlog
|
|
LD HL,1 ;if NOT, can be selective
|
|
RDlp: DEC B
|
|
JR Z,RDok
|
|
ADD HL,HL
|
|
JR RDlp
|
|
RDok: EX DE,HL
|
|
LD C,RSTV ;reset single drive
|
|
JR RDxit
|
|
RDlog: LD C,RSTD ;sigh, whole system
|
|
RDxit: JP BDOSep
|
|
;
|
|
;
|
|
Parse: PUSH AF ;parse FCB w/Duu: and [A/W (NO WILDCARDS)
|
|
LD A,(DFMode)
|
|
LD (FMode),A
|
|
PUSH HL ;Entry: HL=string, A=length
|
|
CALL BlkFCB ;Exit: set FCB, FCBU, FMode
|
|
POP HL ;...now checks filetypes too
|
|
LD D,H
|
|
LD E,L
|
|
POP AF
|
|
OR A
|
|
JP Z,PNODRV
|
|
LD C,A
|
|
LD B,0 ;chars there
|
|
LD A,':'
|
|
CPIR ;find drivespec?
|
|
JR NZ,PNODRV
|
|
DEC HL ;yep...NDR?
|
|
LD (HL),0
|
|
CALL NdrChk
|
|
LD (HL),':'
|
|
JR Z,Parse1 ;not an NDR name
|
|
INC HL
|
|
LD A,B
|
|
LD (FCB),A ;store drive
|
|
LD A,C
|
|
LD (FCBU),A ;store user number
|
|
LD E,A
|
|
LD C,USRN
|
|
PUSH HL
|
|
CALL BDOSep ;set user number
|
|
POP HL
|
|
JR PNAME
|
|
Parse1: DEC HL ;yep...User number?
|
|
LD A,(HL)
|
|
CP '0'
|
|
JR C,PDRV
|
|
CP '9'+1
|
|
JR NC,PDRV
|
|
;
|
|
PUSR: SUB '0'
|
|
LD E,A ;Got user... figure units
|
|
DEC HL
|
|
LD A,(HL)
|
|
CP '0'
|
|
JR C,ZPAR1 ;thats all?
|
|
CP '9'+1
|
|
JR NC,ZPAR1
|
|
SUB '0'
|
|
LD D,A ;nope, tens too
|
|
ADD A,A
|
|
ADD A,A
|
|
ADD A,A ;*8
|
|
ADD A,D
|
|
ADD A,D
|
|
ADD A,E ;*(8+2)+units = user
|
|
LD E,A
|
|
DEC HL
|
|
CP 32
|
|
JR NC,ZPBAD ;illegal?
|
|
ZPAR1: LD A,E
|
|
LD (FCBU),A ;set user
|
|
LD C,USRN
|
|
PUSH HL
|
|
CALL BDOSep
|
|
POP HL
|
|
;
|
|
PDRV: BIT 7,L ;now, parse FCB (start with drive)
|
|
JR Z,ZPAR2B ;(Kludge: stay above 0080h)
|
|
LD A,(HL)
|
|
CP ' ' ;oops, was it there?
|
|
JR Z,ZPAR2B
|
|
ZPAR2: SUB 'A'
|
|
JR C,ZPBAD ;make sure it's legal
|
|
LD E,A
|
|
LD A,15
|
|
CP E
|
|
JR C,ZPBAD
|
|
DEC HL
|
|
BIT 7,L
|
|
JR Z,ZPAR2A ;kludge again (stay about 0080H)
|
|
LD A,(HL)
|
|
CP ' '
|
|
JR NZ,ZPBAD
|
|
ZPAR2A: INC HL
|
|
LD A,E
|
|
INC A
|
|
LD (FCB),A
|
|
ZPAR2B: LD BC,4
|
|
LD A,':'
|
|
CPIR ;skip over user, to filename
|
|
JR PNAME
|
|
PNODRV: LD A,' ' ;no du: at all
|
|
EX DE,HL
|
|
DEC HL ;find filename
|
|
PNDL: INC HL
|
|
CP (HL)
|
|
JR Z,PNDL ;(first nonblank)
|
|
;
|
|
PNAME: LD B,8
|
|
LD DE,FCB+1 ;do filename at (HL)
|
|
EXX
|
|
LD DE,FNamBf
|
|
LD H,D
|
|
LD L,E
|
|
LD B,13
|
|
XOR A
|
|
CALL Fill
|
|
EXX
|
|
ZPRL1: XOR A
|
|
ADD A,(HL)
|
|
INC HL
|
|
JR Z,ZPARX
|
|
CP '.'
|
|
JR Z,ZPRL1X
|
|
CP ' '
|
|
JR Z,ZPRL2F
|
|
RET C
|
|
CP '/'
|
|
JR NZ,ZRLP1A
|
|
CP (HL)
|
|
JR NZ,POPT
|
|
INC HL
|
|
ZRLP1A: CALL ZPBADC
|
|
JR Z,ZPBAD
|
|
LD (DE),A
|
|
INC DE
|
|
EXX
|
|
LD (HL),A
|
|
INC HL
|
|
EXX
|
|
DJNZ ZPRL1
|
|
JR ZPRL1F
|
|
ZPRL1X: LD A,' ' ;fill with " "
|
|
CALL Fill
|
|
JR PTYP
|
|
ZPBAD: CALL BlkFCB ;bad entry
|
|
SCF
|
|
RET
|
|
ZPRL1F: XOR A
|
|
ADD A,(HL)
|
|
JR Z,ZPARX
|
|
CP '.'
|
|
JR NZ,ZPRL2F ;no "."? leave type blank
|
|
INC HL
|
|
;
|
|
PTYP: LD B,3 ;fill type at (HL)
|
|
EXX
|
|
LD A,'.'
|
|
LD (HL),A
|
|
INC HL
|
|
EXX
|
|
ZPRL2: XOR A
|
|
ADD A,(HL)
|
|
INC HL
|
|
JR Z,ZPARX
|
|
CP ' '
|
|
JR Z,ZPRL2F
|
|
RET C
|
|
CP '/'
|
|
JR NZ,ZPRL2A
|
|
CP (HL)
|
|
JR NZ,POPT
|
|
INC HL
|
|
ZPRL2A: CALL ZPBADC
|
|
JR Z,ZPBAD
|
|
LD (DE),A
|
|
INC DE
|
|
EXX
|
|
LD (HL),A
|
|
INC HL
|
|
EXX
|
|
DJNZ ZPRL2
|
|
ZPRL2F: LD A,(HL) ;(eat spaces)
|
|
CP ' '
|
|
JR NZ,POPT
|
|
INC HL
|
|
JR ZPRL2F
|
|
;
|
|
POPT: LD A,(HL) ;process W/A/N option
|
|
CP '/'
|
|
JR NZ,POPT1
|
|
INC HL
|
|
LD A,(HL) ;process W/A/N option
|
|
POPT1: OR A
|
|
JR Z,ZPARX
|
|
CALL VerOpt ;verify legality
|
|
JR NZ,ZPBAD
|
|
LD (FMode),A
|
|
JR ZPARX2 ;any specification overrides defaults
|
|
;
|
|
ZPARX: LD HL,FCBt1 ;check filetype mode defaults
|
|
LD DE,FDflt1
|
|
CALL TypDfl
|
|
LD DE,FDflt2
|
|
CALL TypDfl
|
|
LD DE,FDflt3
|
|
CALL TypDfl
|
|
LD DE,FDflt4
|
|
CALL TypDfl
|
|
ZPARX2: LD A,(FCB+1)
|
|
CP ' '
|
|
JR Z,ZPBAD
|
|
OR A ;DONE.
|
|
RET
|
|
;
|
|
ZPBADC: PUSH HL ;check bad chars
|
|
PUSH BC
|
|
LD HL,ZPBLST
|
|
LD BC,ZPBLEN
|
|
CPIR ;Z set if bad
|
|
POP BC
|
|
POP HL
|
|
RET
|
|
ZPBLST: DB ' .,;:?*=' ;illegal chars
|
|
ZPBLEN EQU $-ZPBLST
|
|
;
|
|
TypDfl: PUSH HL
|
|
LD B,3 ;Set mode from filetype if (HL),(DE) MATCH
|
|
TypDLp: LD A,(DE)
|
|
CP '?'
|
|
JR Z,TypD2
|
|
CP (HL)
|
|
JR NZ,TypDex ;no match, quit
|
|
TypD2: INC DE
|
|
INC HL
|
|
DJNZ TypDLp
|
|
LD A,(DE) ;match, here's your mode
|
|
CALL VerOpt
|
|
TypDex: POP HL
|
|
RET NZ
|
|
LD (FMode),A
|
|
RET
|
|
;
|
|
;
|
|
VerOpt: CP 'A' ;verify mode option legal
|
|
RET Z
|
|
CP 'N'
|
|
RET Z
|
|
CP 'W'
|
|
RET
|
|
;
|
|
;
|
|
;IN: DE=string to match
|
|
;OUT: Z=0,B=drive,C=user# (if NDR match found)
|
|
; Z=1 if no NDR match
|
|
;
|
|
NdrChk: PUSH HL
|
|
PUSH DE
|
|
EX DE,HL ;string addr to HL
|
|
LD A,' '
|
|
DEC HL
|
|
NdrSpc: INC HL ;skip over spaces
|
|
CP (HL)
|
|
JR Z,NdrSpc
|
|
LD D,H ;addr of 1st non blank to DE
|
|
LD E,L
|
|
LD B,Z3NdrM+1 ;# chars to allow before
|
|
XOR A ;we MUST see a NUL
|
|
NdrEos: CP (HL) ;find terminating NUL
|
|
JR Z,NdrNul
|
|
INC HL
|
|
DJNZ NdrEos
|
|
JR NoNdr ;more than 8 chars, not an NDR
|
|
NdrNul: LD BC,Z3NDR
|
|
CALL Z3EAdr
|
|
JR Z,NoNdr ;no NDR block
|
|
EX DE,HL ;start of string to HL
|
|
LD D,B ;NDR addr to DE
|
|
LD E,C
|
|
NxtNdr: LD A,(DE) ;end of NDRs?
|
|
OR A
|
|
JR Z,NoNdr ;yep, no match
|
|
INC DE
|
|
INC DE ;DE points to NDR string
|
|
PUSH HL ;save start of string
|
|
PUSH DE ;save NDR string addr
|
|
LD B,Z3NdrM
|
|
NdrNxC: LD A,(DE)
|
|
CP ' ' ;end of NDR name string?
|
|
JR NZ,NdrChC ;not yet
|
|
INC (HL) ;did we hit the NUL
|
|
DEC (HL) ;at the end of string
|
|
JR NdrMis ;(i.e. was it a full match?)
|
|
NdrChC: CP (HL)
|
|
JR NZ,NdrMis
|
|
INC HL ;next char in string
|
|
INC DE ;next char in NDR entry
|
|
DJNZ NdrNxC
|
|
NdrMis: POP DE ;restore start of NDR string
|
|
POP HL ;restore start of string
|
|
JR Z,NdrMtc ;all chars match, got an NDR
|
|
EX DE,HL ;start of NDR string to HL
|
|
LD BC,Z3NdrL
|
|
ADD HL,BC ;next NDR entry to HL
|
|
EX DE,HL ;and now to DE
|
|
JR NxtNdr
|
|
NdrMtc: EX DE,HL ;NDR matched
|
|
DEC HL
|
|
LD C,(HL) ;fetch user number
|
|
DEC HL
|
|
LD B,(HL) ;fetch drive
|
|
OR 0FFh ;Z=0H
|
|
NoNdr: POP DE
|
|
POP HL
|
|
RET
|
|
;
|
|
;Read in a word from the Z3ENV block.
|
|
;IN: offset in BC
|
|
;OUT: addr in BC
|
|
; Z=1 if addr is invalid
|
|
;
|
|
Z3EAdr: PUSH HL
|
|
LD HL,(Z3Env)
|
|
LD A,H
|
|
OR L
|
|
JR Z,NoZEnv ;no Z3ENV: Z=1
|
|
ADD HL,BC
|
|
LD C,(HL)
|
|
INC HL
|
|
LD B,(HL)
|
|
LD A,B
|
|
OR C ;Z=1 if no address at offset
|
|
NoZEnv: POP HL
|
|
RET
|
|
;
|
|
;
|
|
;Read in the file. (HL=prev byte, BC=max size)
|
|
;Return with HL=last byte, Z=out of room, C=input error.
|
|
;
|
|
MSIn: PUSH HL ;Initialize FCBex thru FCBrc and FCBcr
|
|
PUSH BC
|
|
XOR A
|
|
LD DE,FCBex
|
|
LD B,4+16+1
|
|
CALL Fill
|
|
LD (MSIFlg),A
|
|
CPL
|
|
LD (SftFlg),A
|
|
LD C,FOPN
|
|
CALL BDOSfc
|
|
INC A ;Not found?
|
|
JR NZ,MSIfnd
|
|
MSIerr: POP BC ;Error...
|
|
POP BC
|
|
OR 1 ;Clear Z
|
|
SCF ;Set C
|
|
RET
|
|
MSIfnd: LD DE,DMA
|
|
LD C,SDMA
|
|
CALL BDOS
|
|
;
|
|
MSIlp1: LD C,RSEQ
|
|
CALL BDOSfc
|
|
CP 1 ;No more reocrds?
|
|
JP Z,MSIefX
|
|
JR NC,MSIerr ;Other error?
|
|
LD IX,DMA
|
|
POP DE ;target count
|
|
LD B,128 ;1 record
|
|
POP HL ;target address
|
|
MSIlp2: LD A,(FMode)
|
|
CP 'W'
|
|
JR NZ,MSIlp3
|
|
LD A,(IX) ;Wordstar: handle soft hyphens
|
|
CP 1Fh
|
|
JR NZ,MSIl2x
|
|
LD A,'-'
|
|
LD (IX),A
|
|
MSIl2x: CP 1Eh ;remove dead soft hyphens
|
|
JR Z,MSIlf
|
|
CP ' '+080H ;remove soft spaces
|
|
JR NZ,MSIl2a
|
|
LD A,(SftFlg)
|
|
OR A ;(unless at beginning of line)
|
|
JR Z,MSIlf
|
|
JR MSIlp3
|
|
MSIl2a: XOR A
|
|
LD (SftFlg),A
|
|
LD A,(IX) ;and keep hard/soft CRs straight
|
|
CP CR+80H
|
|
JR NZ,MSIl2b
|
|
LD A,(HL) ;SCR must have space before...
|
|
CP ' '
|
|
JR Z,MSIlp3
|
|
SET 7,(HL)
|
|
JR NC,MSIlp3
|
|
RES 7,(HL) ;can't set hi bit on ctlcodes
|
|
LD A,' '
|
|
INC HL ;Bump output
|
|
LD (HL),A ;Insert byte
|
|
DEC DE ;Room left?
|
|
LD A,D
|
|
OR E
|
|
RET Z
|
|
JR MSIlp3
|
|
MSIl2b: CP CR
|
|
JR NZ,MSIlp3
|
|
MSIl2c: RES 7,(HL) ;...and HCR must not have space
|
|
LD A,(HL)
|
|
CP ' '
|
|
JR NZ,MSIlp3
|
|
DEC HL
|
|
INC DE
|
|
JR MSIl2c
|
|
MSIlp3: LD A,(IX) ;take the byte
|
|
AND 7Fh ;Mask parity
|
|
CP EOF ;EOF?
|
|
JR Z,MSIeof
|
|
CP LF ;toss line feeds
|
|
JR NZ,MSIl3a
|
|
LD (SftFlg),A ;but record them
|
|
JR MSIlf
|
|
MSIl3a: LD IY,BlkChr
|
|
CP (IY) ;toss block chars
|
|
JR Z,MSIlf
|
|
CP ' ' ;take non-spaces
|
|
JR NZ,MSIok
|
|
LD A,(HL)
|
|
CP 20H ;Last one CTL? take space
|
|
JR C,MSIsp
|
|
BIT 7,(HL) ;Already hidden space? take space
|
|
JR NZ,MSIsp
|
|
SET 7,(HL) ;Hide space
|
|
JR MSIlf
|
|
;
|
|
MSIsp: LD A,' '
|
|
MSIok: INC HL ;Bump output
|
|
LD (HL),A ;Insert byte
|
|
DEC DE ;Room left?
|
|
LD A,D
|
|
OR E
|
|
RET Z
|
|
MSIlf: INC IX ;Bump input
|
|
DEC B ;Go through record
|
|
JP NZ,MSIlp2
|
|
PUSH HL
|
|
PUSH DE
|
|
JP MSIlp1 ;Get next block
|
|
;
|
|
MSIefX: POP DE ;(for last rec bug fix)
|
|
POP HL
|
|
MSIeof: OR 1 ;clear Z/C
|
|
LD (MSIFlg),A ;Show load OK
|
|
RET
|
|
;
|
|
;
|
|
;Write out BC characters at HL to file FCB (C=error)
|
|
;
|
|
MSOut: PUSH BC
|
|
PUSH HL
|
|
ADD HL,BC ;ending address
|
|
PUSH HL
|
|
CALL DOSVer
|
|
LD A,(FCB)
|
|
CALL C,RstDrv ;reset drive
|
|
LD HL,FCB+1 ;strip attributes
|
|
LD B,11
|
|
MSOlp0: RES 7,(HL)
|
|
INC HL
|
|
DJNZ MSOlp0
|
|
LD B,4
|
|
XOR A
|
|
MSOlp1: LD (HL),A ; zero out FCBex, FCBs1, FCBs2, FCBrc
|
|
INC HL
|
|
DJNZ MSOlp1
|
|
LD DE,tStamp ; set the buffer for the
|
|
LD C,SDMA ; file timestamp
|
|
CALL BDOSep
|
|
LD C,GETS ; get the file timestamp
|
|
CALL BDOSfc
|
|
LD (tsFlg),A ; A=1 if we got a stamp
|
|
LD A,(FilFlg) ; make a backup file?
|
|
OR A
|
|
JR Z,MSOdel ; no backup needed
|
|
LD HL,FCB ; copy original filename and extension
|
|
LD DE,DMA
|
|
LD BC,16 ;FCB length
|
|
LDIR ;copy it
|
|
LD BC,8+1 ;copy original filename only
|
|
LD HL,FCB
|
|
LDIR ;again
|
|
LD BC,3 ;extension of BAK
|
|
LD HL,Bak
|
|
LDIR
|
|
LD DE,DMA+16 ;delete BAKfil
|
|
LD C,FDEL
|
|
CALL BDOS
|
|
INC A
|
|
JR NZ,MSOren
|
|
OR H ;no BAK deleted, h/w error?
|
|
JP NZ,MSOer2 ;yep...
|
|
MSOren: LD DE,DMA ;rename old file to BAK
|
|
LD C,FREN
|
|
CALL BDOS
|
|
JR MSOmak
|
|
;
|
|
MSOdel: CALL DOSVer
|
|
JR C,MSOdl2 ; skip if plain CP/M
|
|
CP 'S'
|
|
JR Z,MSOdl2 ; skip if ZSDOS
|
|
CP 'D'
|
|
JR Z,MSOdl2 ; skip if ZDDOS
|
|
LD C,ERRM ; ... we get here, we're CP/M 3.0
|
|
LD E,0FFH ; return error, no print
|
|
CALL BDOS
|
|
XOR A
|
|
LD (SftFlg),A
|
|
LD (FCBex),A
|
|
LD (FCBcr),A
|
|
LD C,FMAK ;make a new file
|
|
CALL BDOSfc
|
|
PUSH AF
|
|
PUSH HL
|
|
LD C,ERRM ; return error, print
|
|
LD E,0FEH
|
|
CALL BDOS
|
|
POP HL
|
|
POP AF
|
|
PUSH AF
|
|
OR A
|
|
JR Z,MSOnSt
|
|
POP AF
|
|
LD A,H
|
|
CP 8
|
|
JR NZ,MSOmak
|
|
LD C,FTRU ; truncate file to 0 bytes
|
|
XOR A
|
|
LD (FCBr0),A
|
|
LD (FCBr1),A
|
|
LD (FCBr2),A
|
|
CALL BDOSfc
|
|
OR A
|
|
JP NZ,MSOer2
|
|
LD C,FOPN
|
|
CALL BDOSfc ; open the file
|
|
PUSH AF
|
|
JR MSOnSt ; --- end of CP/M3 specific open code
|
|
;
|
|
MSOdl2: LD C,FDEL ; +++ CP/M2.2, ZxDOS specific
|
|
CALL BDOSfc ; delete any old BAK file
|
|
INC A
|
|
JR NZ,MSOmak ; jump if all good
|
|
OR H ; hardware error code?
|
|
JP NZ,MSOer2 ; ...yep
|
|
;
|
|
MSOmak: XOR A ;Initialize FCB
|
|
LD (SftFlg),A
|
|
LD (FCBex),A
|
|
LD (FCBcr),A
|
|
LD C,FMAK
|
|
CALL BDOSfc
|
|
PUSH AF
|
|
LD A,(tsFlg) ;+++ timestamp code start
|
|
DEC A ;do we have a timestamp?
|
|
JR NZ,MSOnSt ;no, don't update the timestamp
|
|
LD C,SETS ;set create timestamp of new file
|
|
CALL BDOSfc ;to the same as existing file
|
|
MSOnSt: LD C,SDMA
|
|
LD DE,DMA
|
|
CALL BDOSep
|
|
POP AF ;restore result of FMAK
|
|
POP DE ;end
|
|
POP HL ;start
|
|
POP BC ;(bytes)
|
|
INC A
|
|
JP Z,MSOerr ;make file failed
|
|
LD A,B
|
|
OR C ;any bytes?
|
|
JP Z,MSOcls
|
|
LD C,0 ;Initialize GetNx
|
|
LD B,128 ;1 record
|
|
LD IX,DMA
|
|
MSOlp2: CALL GetNx
|
|
EXX
|
|
LD HL,BadTbl ;skip illegal chars
|
|
LD BC,BadLen
|
|
CPIR
|
|
EXX
|
|
JR Z,MSOsk1 ;0 or EOF
|
|
MSOlp3: LD (IX),A ;put it out
|
|
LD A,(FMode)
|
|
CP 'W' ;Wordstar mode?
|
|
JR NZ,MSOWSx
|
|
LD A,(IX)
|
|
CP ' '
|
|
JR NZ,MSOWSa
|
|
LD A,(IX-1) ;add microjustification bits
|
|
CP 21h
|
|
JR C,MSOWS2
|
|
SET 7,(IX-1)
|
|
JR MSOWS2
|
|
MSOWSa: CP CR
|
|
JR Z,MSOWS1
|
|
CP LF
|
|
JR Z,MSOWSx
|
|
MSOWS0: XOR A
|
|
LD (SftFlg),A
|
|
JR MSOWSx
|
|
MSOWS1: LD A,(IX-1) ;soften CRs after spaces
|
|
AND 7FH
|
|
CP ' '
|
|
JR NZ,MSOWS0
|
|
MSOW1a: SET 7,(IX)
|
|
LD A,0FFH
|
|
LD (SftFlg),A
|
|
JR MSOWSx
|
|
MSOWS2: LD A,(SftFlg) ;and spaces after soft CRs
|
|
OR A
|
|
JR NZ,MSOW1a
|
|
MSOWSx: LD A,(IX)
|
|
INC IX ;bump pointer
|
|
DJNZ MSOsk1 ;Skip if buffer not full
|
|
PUSH BC
|
|
PUSH DE
|
|
PUSH HL
|
|
LD C,WSEQ
|
|
CALL BDOSfc
|
|
POP HL
|
|
POP DE
|
|
POP BC
|
|
OR A
|
|
JR Z,MSOook
|
|
CALL MSOcls ;output error
|
|
JR MSOerr
|
|
MSOook: LD B,128
|
|
LD IX,DMA
|
|
LD A,(DMA+127)
|
|
LD (IX-1),A
|
|
MSOsk1: AND 7FH
|
|
CP CR ;Add LF after CR
|
|
LD A,LF
|
|
JR Z,MSOlp3
|
|
LD A,H
|
|
XOR D ;At end yet?
|
|
JP NZ,MSOlp2
|
|
LD A,L
|
|
XOR E
|
|
JP NZ,MSOlp2
|
|
OR C ;Still got hidden space?
|
|
JP NZ,MSOlp2
|
|
OR B ;need EOF?
|
|
JR Z,MSOsk2
|
|
MSOefL: LD (IX),EOF ;yes
|
|
INC IX
|
|
DJNZ MSOefL
|
|
MSOsk2: LD C,WSEQ
|
|
CALL BDOSfc
|
|
OR A
|
|
JR Z,MSOcls
|
|
CALL MSOcls
|
|
JR MSOerr
|
|
MSOcls: LD C,FCLO ;all done, close up
|
|
CALL BDOSfc
|
|
INC A
|
|
OR A ;bug fix 2.67
|
|
RET NZ
|
|
MSOerr: SCF
|
|
RET
|
|
MSOer2: POP HL ;discard start,
|
|
POP HL ;end,
|
|
POP HL ;(bytes)
|
|
LD C,SDMA
|
|
LD DE,DMA
|
|
CALL BDOSep ;reset DMA buffer
|
|
JR MSOerr
|
|
;
|
|
;
|
|
;
|
|
;
|
|
; DISPLAY FUNCTIONS
|
|
;
|
|
;(Re)initialize screen to begin editing
|
|
;
|
|
DoHdr: LD A,(NoHdrF)
|
|
OR A
|
|
RET NZ
|
|
LD DE,0
|
|
CALL GoTo
|
|
LD HL,Header
|
|
CALL AltDsp
|
|
CALL ShoFnm ;Show file name
|
|
LD HL,OPoff
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
JR NZ,DoHdr1 ;show "Pg " if document
|
|
LD A,(PgLen)
|
|
OR A
|
|
JR NZ,DoHdrT
|
|
LD HL,OPon ;show "OP" if ^OP in nondoc
|
|
DoHdr1: LD DE,DspOP
|
|
CALL TogSho
|
|
DoHdrT: CALL ITshow ;show toggles
|
|
CALL VTshow
|
|
CALL HYshow
|
|
CALL AIshow
|
|
CALL DblSho
|
|
MRshow: LD A,(RMSav) ;requires header display
|
|
DEC A
|
|
LD HL,MRon
|
|
JP Z,PSDisp
|
|
LD DE,DspMrg
|
|
JP TogSho
|
|
;
|
|
TogSho: LD A,(NoHdrF)
|
|
OR A
|
|
RET NZ
|
|
PUSH HL ;toggle show subroutine
|
|
CALL GoTo
|
|
CALL MakAlt
|
|
POP HL
|
|
LD B,3
|
|
CALL BHLMsg
|
|
JP UnAlt
|
|
;
|
|
;
|
|
UpLft: LD DE,0100H ;go to "top of text"
|
|
LD A,(RulFlg)
|
|
OR A
|
|
JR Z,UndrX
|
|
INC D
|
|
JR UndrX
|
|
UndrHd: LD DE,0100H ;go below header regardless
|
|
UndrX: JP GoTo
|
|
;
|
|
;
|
|
NoHdr: LD HL,NoHdrF ;toggles on/off
|
|
CALL ToggHL
|
|
OR A
|
|
JR Z,HdrOn
|
|
HdrOff: CALL AdjLns ;that's one more line
|
|
CALL IncVO
|
|
JP SetAl
|
|
HdrOn: CALL AdjLns
|
|
CALL DecVO
|
|
CALL DoHdr ;let's see it again
|
|
JP SetAl
|
|
;
|
|
;
|
|
;Show current file data in the heading
|
|
;
|
|
ShoFnm: CALL MakAlt
|
|
LD DE,DspFnm+8 ;blank out old stuff
|
|
CALL GoTo
|
|
LD B,19
|
|
CALL BBlank
|
|
LD DE,DspFnm
|
|
CALL GoTo
|
|
LD A,(FCB)
|
|
ADD A,'A'-1 ;drive letter
|
|
CALL PutChA
|
|
LD A,(FCBU) ;user number 0-15
|
|
LD C,A
|
|
LD B,'3' ;user 30+?
|
|
SUB 30
|
|
JR NC,ShoFn1
|
|
LD B,'2' ;user 20+?
|
|
LD A,C
|
|
SUB 20
|
|
JR NC,ShoFn1
|
|
LD B,'1' ;user 10+?
|
|
LD A,C
|
|
SUB 10
|
|
ShoFn1: PUSH AF
|
|
LD A,B
|
|
CALL NC,PutChA
|
|
POP AF
|
|
JR NC,ShoFn2
|
|
LD A,C
|
|
ShoFn2: ADD A,'0' ;show LSD of user number
|
|
CALL PutChA
|
|
LD BC,Z3NDR
|
|
CALL Z3EAdr
|
|
JR Z,ShoFnN ;skip if no NDR
|
|
LD H,B
|
|
LD L,C
|
|
ShFnNl: LD B,(HL) ;drive of this NDR entry
|
|
INC B
|
|
DEC B
|
|
JR Z,ShoFnN ;0 means no more entries
|
|
LD A,(FCB)
|
|
CP B ;drive match?
|
|
INC HL
|
|
JR NZ,ShFnNx
|
|
LD C,(HL)
|
|
LD A,(FCBU)
|
|
CP C ;user # match?
|
|
JR Z,ShFnNn ;yes, display NDR name
|
|
ShFnNx: LD DE,Z3NdrL+1 ;skip over NDR
|
|
ADD HL,DE
|
|
JR ShFnNl ;try next NDR
|
|
ShFnNn: LD A,'/'
|
|
CALL PutChA
|
|
LD B,8 ;show up to first 8 chars of NDR
|
|
ShFdLp: INC HL
|
|
LD A,(HL)
|
|
CP ' '
|
|
CALL NZ,PutChA
|
|
DJNZ ShFdLp
|
|
ShoFnN: LD A,':'
|
|
CALL PutChA ;punctuate
|
|
LD HL,FCB+1
|
|
LD B,8 ;Name
|
|
ShFnLp: LD A,(HL)
|
|
RES 7,A
|
|
CP ' ' ;Quit on blank
|
|
JR Z,ShFnLF
|
|
CALL PutChA
|
|
INC HL
|
|
DJNZ ShFnLp ;Loop for 8
|
|
ShFnLF: LD A,'.' ;punctuate
|
|
CALL PutChA
|
|
LD HL,FCBt1
|
|
LD B,3 ;Type
|
|
ShFnL2: LD A,(HL)
|
|
CALL PutChA
|
|
INC HL
|
|
DJNZ ShFnL2
|
|
CALL PutSpc
|
|
LD A,'/' ;option
|
|
CALL PutChA
|
|
LD A,(FMode)
|
|
CALL PutChA
|
|
JP UnAlt
|
|
;
|
|
;
|
|
Ruler: LD HL,RulFlg ;toggle ruler on/off
|
|
CALL ToggHL
|
|
OR A
|
|
JP Z,RulOff
|
|
;
|
|
RulOn: CALL AdjLns ;readjust screen length
|
|
CALL DecVO
|
|
CALL Z,SetAl ;maybe on line 1?
|
|
JR RuShow
|
|
;
|
|
RulFix: LD A,(RulFlg) ;update ruler if on
|
|
OR A
|
|
RET Z
|
|
RuShow: LD IY,RulBuf ;build ruler here
|
|
LD A,(NSkip) ;starting column
|
|
INC A
|
|
LD C,A
|
|
LD A,(View) ;length
|
|
LD B,A
|
|
RuLp: LD E,'-' ;default char is "-"
|
|
LD A,(VTFlg) ;which tab mode?
|
|
OR A
|
|
JR Z,RuLpH
|
|
PUSH BC ;"T" if varitab stop
|
|
LD A,C
|
|
LD HL,VTList
|
|
LD BC,VTNum
|
|
CPIR
|
|
POP BC
|
|
JR Z,RuVtab
|
|
JR RuNtab
|
|
RuLpH: LD HL,TabCnt ;"I" if hardtab stop
|
|
LD A,C
|
|
DEC A
|
|
AND (HL)
|
|
JR Z,RuHtab
|
|
RuNtab: LD A,(RtMarg) ;"R" if right margin
|
|
CP C
|
|
JR Z,RuRM
|
|
JR C,RuDot ;or dot if outside
|
|
LD A,(LfMarg)
|
|
CP C
|
|
JR Z,RuLM ;or "L" if left margin
|
|
DEC A
|
|
CP C
|
|
JR NC,RuDot
|
|
RuLpF: LD (IY),E ;okay, show it
|
|
INC IY
|
|
INC C
|
|
DJNZ RuLp
|
|
LD (IY),0
|
|
CALL UndrHd
|
|
LD HL,RulBuf
|
|
JP AltDsp
|
|
RuLM: LD E,'L'
|
|
JR RuLpF
|
|
RuRM: LD E,'R'
|
|
JR RuLpF
|
|
RuDot: LD E,'.'
|
|
JR RuLpF
|
|
RuVtab: LD E,'!'
|
|
JR RuLpF
|
|
RuHtab: LD E,'I'
|
|
JR RuLpF
|
|
;
|
|
RulOff: CALL AdjLns ;adjust screen size
|
|
CALL IncVO
|
|
LD E,A
|
|
CALL CrLft ;oops, may be near top
|
|
XOR A
|
|
ADD A,E
|
|
JP Z,ShoLn1
|
|
JP SetAl
|
|
;
|
|
;
|
|
;Display one byte on the screen for messages rather than text.
|
|
;Hi bit set = following space.
|
|
;
|
|
DsByt: CP CR ;Is it a CR
|
|
JR Z,Sk1DB ;Yes, skip
|
|
CP X ;compressed space?
|
|
JR NC,Sk3DB
|
|
DsBy1: LD E,A ;normal character
|
|
LD HL,HPos ;room?
|
|
DEC (HL)
|
|
JP NZ,PutCh ;put it out
|
|
INC (HL) ;EOL
|
|
RET
|
|
Sk1DB: LD A,(HPos) ;Fill out spaces for CR
|
|
LD E,A ;(needed for attributes, etc)
|
|
CALL SpEOL
|
|
LD A,(AuWrap) ;does autowrap occur?
|
|
OR A
|
|
JR NZ,Sk1aDB
|
|
LD E,CR ;NO, put out a CRLF
|
|
CALL PutCh
|
|
LD E,LF
|
|
CALL PutCh
|
|
Sk1aDB: LD A,(View)
|
|
INC A
|
|
LD (HPos),A ;new line
|
|
RET
|
|
Sk3DB: AND 7FH ;compressed space
|
|
CALL DsByt
|
|
DsSpc: LD A,' '
|
|
JR DsBy1
|
|
;
|
|
;
|
|
;Display message pointed to by HL. 00h is end.
|
|
;80H,nn = skip count.
|
|
;
|
|
Dspla: LD A,(View) ;initialize
|
|
INC A
|
|
LD (HPos),A
|
|
DspLp: LD A,(HPos) ;or continue, here
|
|
LD E,A
|
|
LD A,(HL) ;get byte
|
|
INC HL
|
|
OR A ;All done?
|
|
RET Z
|
|
CP X ;hidden spaces?
|
|
JR NZ,Dsp10
|
|
LD A,(HL) ;get space count
|
|
INC HL
|
|
LD B,A
|
|
Dsp01: PUSH BC
|
|
PUSH HL
|
|
CALL DsSpc
|
|
POP HL
|
|
POP BC
|
|
DJNZ Dsp01
|
|
JR DspLp
|
|
Dsp10: PUSH HL
|
|
CALL DsByt ;Put it out
|
|
POP HL
|
|
JR DspLp ;Do next one
|
|
;
|
|
;Display message which immediatly follows the CALL
|
|
;
|
|
Dspl: POP HL
|
|
CALL Dspla
|
|
JP (HL)
|
|
DsplC: POP HL ;same, but continued
|
|
CALL DspLp
|
|
JP (HL)
|
|
;
|
|
;
|
|
;Make a text "window" at screen bottom
|
|
;
|
|
Window: LD A,(PhysLn) ;requires 16 lines or more
|
|
CP 16
|
|
JP C,Error7
|
|
LD HL,WinFlg ;toggles on/off
|
|
CALL ToggHL
|
|
OR A
|
|
JR Z,WinOff
|
|
;
|
|
WinOn: CALL AdjLns ;adjust counts
|
|
LD A,(PhysLn)
|
|
AND 1
|
|
CALL NZ,ClLast ;clear odd line?
|
|
CALL TopV ;put chosen text on top
|
|
LD A,0FFh
|
|
LD (BelowF),A ;go below
|
|
CALL ShoSc ;show text
|
|
LD A,(NoHdrF)
|
|
OR A
|
|
JR NZ,WinOn2
|
|
LD DE,0000h ;separator needed?
|
|
CALL GoTo
|
|
CALL SepLin
|
|
CALL ShoFnm ;with name
|
|
WinOn2: XOR A
|
|
LD (BelowF),A
|
|
JP SetAl
|
|
;
|
|
WinOff: CALL AdjLns
|
|
JP SetAl
|
|
;
|
|
;
|
|
AdjLns: LD A,(PhysLn) ;KEEP screen counts consistent
|
|
LD HL,WinFlg
|
|
BIT 0,(HL)
|
|
JR Z,AdjL1
|
|
SRL A
|
|
AdjL1: LD (Lines),A ;physical window size
|
|
LD HL,NoHdrF
|
|
BIT 0,(HL)
|
|
JR NZ,AdjL2
|
|
DEC A ;adjust for header if present
|
|
AdjL2: LD HL,RulFlg
|
|
ADD A,(HL) ;adjust for ruler if present
|
|
LD (TxtLns),A
|
|
RET
|
|
;
|
|
;
|
|
; SCREEN I/O ROUTINES
|
|
;
|
|
;Do screen control code strings (return Carry if none)
|
|
;
|
|
CtlStr: XOR A
|
|
ADD A,(HL) ;HL points to #,bytes (# may be 0)
|
|
SCF
|
|
RET Z
|
|
LD B,A
|
|
INC HL ;set up count
|
|
BHLMsg:
|
|
CtlSLp: LD E,(HL)
|
|
INC HL
|
|
PUSH BC
|
|
PUSH HL
|
|
CALL ShutUp ;do NOT filter
|
|
POP HL
|
|
POP BC
|
|
DJNZ CtlSLp
|
|
OR A
|
|
RET
|
|
;
|
|
BlkFCB: LD B,11 ;blank out FCB name,typ
|
|
LD DE,FCB+1
|
|
BlkFil: LD A,' ' ;blank out B bytes at DE
|
|
LD (DE),A
|
|
INC DE
|
|
DJNZ BlkFil
|
|
RET
|
|
BBlank: PUSH BC ;blank out B spaces
|
|
LD E,' '
|
|
CALL ShutUp
|
|
POP BC
|
|
DJNZ BBlank
|
|
RET
|
|
;
|
|
;Show messages and prompts
|
|
;
|
|
MsgDsp: PUSH HL ;must start at "top"
|
|
CALL UpLft
|
|
POP HL
|
|
AltDsp: PUSH HL ;display message in alt video
|
|
CALL MakAlt
|
|
POP HL
|
|
CALL Dspla
|
|
JR UnAlt
|
|
;
|
|
Prompt: PUSH HL ;Prompt: blank first line
|
|
CALL UpLft ;(with attribute)
|
|
CALL MakAlt
|
|
LD A,(View)
|
|
INC A
|
|
LD E,A
|
|
CALL SpEOL
|
|
CALL UnAlt
|
|
POP HL
|
|
JR MsgDsp ;then show prompt message
|
|
;
|
|
;Handle alternate video
|
|
;
|
|
MakAlt: LD A,(AltHdr) ;optional for messages and prompts
|
|
OR A
|
|
RET Z
|
|
AltY: LD HL,AltOn ;mandatory for ctl-chars
|
|
LD A,(AltBit) ;ram always uses hi bit
|
|
OR A
|
|
JP Z,CtlStr
|
|
LD A,X
|
|
LD (AltMsk),A
|
|
RET
|
|
UnAlt: LD A,(AltHdr)
|
|
OR A
|
|
RET Z
|
|
UnAltY: LD HL,AltOff
|
|
LD A,(AltBit)
|
|
OR A
|
|
JP Z,CtlStr
|
|
XOR A
|
|
LD (AltMsk),A
|
|
RET
|
|
;
|
|
;Character output
|
|
;
|
|
XPutCh: LD A,(Horiz) ;show character in E
|
|
LD HL,View ;UNLESS in lower rt corner
|
|
CP (HL)
|
|
JR NZ,PutCh
|
|
LD A,(Vert)
|
|
LD HL,TxtLns
|
|
CP (HL)
|
|
RET Z
|
|
PutCh: PUSH HL ;show char in E
|
|
PUSH DE
|
|
PUSH BC
|
|
LD A,(Filter) ;filtered
|
|
CP E
|
|
JR C,PutChQ ;'?' if char >= Filter (07FH)
|
|
PutCh1: LD A,(AltMsk)
|
|
OR E
|
|
CALL CONOut
|
|
POP BC
|
|
POP DE
|
|
POP HL
|
|
RET
|
|
PutChQ: LD E,'?'
|
|
JR PutCh1
|
|
;
|
|
PutSpc: LD A,' '
|
|
Echo: CP 20H ;echo typed char, IF nice
|
|
RET C ; (used for one-char input)
|
|
PutChA: PUSH DE ;show char in A
|
|
PUSH AF ; save it too (for Echo)
|
|
LD E,A
|
|
CALL PutCh
|
|
POP AF
|
|
POP DE
|
|
RET
|
|
;
|
|
CONOut: LD E,A
|
|
ShutUp: NOP ;<--- goes to RET for Quiet
|
|
LD C,UCON ;put byte to console (mostly ctls)
|
|
JP BDOSep
|
|
;
|
|
PosCur: LD A,(Horiz)
|
|
LD E,A
|
|
DEC E
|
|
LD A,(RulFlg)
|
|
AND 1
|
|
LD HL,Vert
|
|
ADD A,(HL)
|
|
LD D,A
|
|
;
|
|
;Position cursor to row D column E
|
|
;
|
|
GoTo: LD A,(NoHdrF) ;lie for lack of header
|
|
AND D ;(decrement row if >0)
|
|
JR Z,GoTo01
|
|
DEC D
|
|
GoTo01: LD A,(BelowF) ;implement window below
|
|
OR A
|
|
JR Z,GoToIt
|
|
LD A,(Lines)
|
|
ADD A,D
|
|
LD D,A
|
|
GoToIt: LD A,D
|
|
LD (CurRow),A
|
|
LD A,(PosMod)
|
|
CP 'N'
|
|
JR NZ,GoYPos
|
|
LD HL,PCu ;use Down,Right method (gaak)
|
|
CALL Go2Byt ;home first
|
|
LD A,D
|
|
OR A
|
|
JR Z,Go2RwF
|
|
Go2Row: PUSH DE ;move down to desired row
|
|
LD E,LF
|
|
CALL ShutUp
|
|
POP DE
|
|
DEC D
|
|
JR NZ,Go2Row
|
|
Go2RwF: LD A,E
|
|
OR A
|
|
RET Z
|
|
Go2Col: LD HL,PCu+2
|
|
CALL Go2Byt ;now across to desired col
|
|
DEC E
|
|
JR NZ,Go2Col
|
|
RET
|
|
GoYPos: CP 'A' ;Okay, can be more sophisticated...
|
|
JR Z,GoANSI
|
|
LD HL,PCu ;use ESC = sequence
|
|
CALL Go2Byt ;leadin byte(s)
|
|
LD HL,PCu+2
|
|
PUSH DE ;now coordinates
|
|
PUSH HL
|
|
LD A,(PosMod) ;which order?
|
|
CP 'R'
|
|
JR Z,GoToX ;(backwards)
|
|
LD A,D
|
|
ADD A,(HL)
|
|
CALL CONOut
|
|
POP HL
|
|
POP DE
|
|
INC HL
|
|
LD A,E
|
|
ADD A,(HL)
|
|
CALL CONOut
|
|
JR GoToDl
|
|
GoToX: LD A,E
|
|
ADD A,(HL)
|
|
CALL CONOut
|
|
POP HL
|
|
POP DE
|
|
INC HL
|
|
LD A,D
|
|
ADD A,(HL)
|
|
CALL CONOut
|
|
GoToDl: LD A,(PosDly) ;optional delay for some terminals
|
|
OR A
|
|
RET Z
|
|
LD B,A
|
|
LD C,0
|
|
JP BDlyLp
|
|
GoANSI: LD HL,ANSIms+3 ;use ANSI sequence
|
|
LD A,D
|
|
INC A ;origin 1,1
|
|
CALL GoASub
|
|
LD HL,ANSIms+6
|
|
LD A,E
|
|
INC A
|
|
CALL GoASub
|
|
LD HL,ANSIms
|
|
CALL CtlStr
|
|
JR GoToDl
|
|
GoASub: LD (HL),'0' ;tens digit
|
|
GASl1: CP 10
|
|
JR C,GAS2
|
|
INC (HL)
|
|
SUB 10
|
|
JR GASl1
|
|
GAS2: INC HL
|
|
ADD A,'0' ;units
|
|
LD (HL),A
|
|
RET
|
|
Go2Byt: CALL Go1Byt ;show one or two bytes at HL
|
|
LD A,(HL)
|
|
OR A
|
|
RET Z
|
|
Go1Byt: PUSH DE
|
|
LD B,1 ;just do one byte
|
|
CALL CtlSLp
|
|
POP DE
|
|
RET
|
|
ANSIms: DB 8,ESC,'[00;00H' ;for use with CtlStr
|
|
;
|
|
;
|
|
IfSpLn: LD A,(AltHdr) ;draw sep line IF headers not alt
|
|
OR A
|
|
RET NZ
|
|
SepLin: CALL MakAlt ;draw separator line
|
|
LD A,(View)
|
|
LD D,A
|
|
LD E,'-'
|
|
SLDlp: PUSH DE
|
|
CALL PutCh
|
|
POP DE
|
|
DEC D
|
|
JR NZ,SLDlp
|
|
JP UnAlt
|
|
;
|
|
;
|
|
;SHOW SCREEN ROUTINES
|
|
;
|
|
; | +------------------------
|
|
; |HELLO! | ^
|
|
; |This is your |text file, which is seen Vert
|
|
; |on the screen| just like this._ v
|
|
; | | \
|
|
; |<---NSkip---> <-----Horiz-----> \
|
|
; |<-----------CurCol------------> \Cursor at (H,V)
|
|
;
|
|
;Recheck current position on screen
|
|
;
|
|
Orient: LD A,(Vert) ;Adjust Horiz and Vert
|
|
LD E,A
|
|
CALL CrLft ;Start of first screen line
|
|
JR NC,Ornt1
|
|
CALL TopV ;At top, set Vert to 1
|
|
JR Ornt2
|
|
Ornt1: LD A,(Vert) ;Decrement Vert if needed
|
|
SUB E ; to avoid whitespace at top
|
|
LD (Vert),A
|
|
Ornt2: CALL ColCnt ;Update columen (in A,B,CurCol)
|
|
INC A
|
|
JR NZ,Ornt3
|
|
LD B,0FEH
|
|
Ornt3: LD A,(Horiz) ;Compute cursor offset in line
|
|
LD C,A
|
|
LD A,B
|
|
SUB C ;CurCol-Horiz is minimum offset
|
|
JR NC,Ornt4a
|
|
XOR A ;set 0 if negative
|
|
Ornt4a: LD E,A
|
|
LD A,(NSkip) ;present offset < min?
|
|
CP E
|
|
JR C,Ornt4b ;if so, change
|
|
CP B ;bigger than CurCol-1?
|
|
JR C,Ornt4c ;if not, OK
|
|
LD A,B ;round down to small enough
|
|
DEC A
|
|
AND 0C0H ;multiple of 32
|
|
JR Ornt4c
|
|
Ornt4b: LD A,E ;round up to big enough
|
|
OR 1FH
|
|
JR Z,Ornt4c
|
|
INC A
|
|
Ornt4c: LD (NSkip),A ;set (new?) offset
|
|
SUB B
|
|
NEG
|
|
LD (Horiz),A
|
|
LD HL,(CurLin) ;Figure line, page
|
|
LD (CurPgL),HL
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
LD A,(PgLen)
|
|
JR NZ,Ornt5
|
|
XOR A ;don't SHOW pagination for nondocs
|
|
Ornt5: LD E,A
|
|
LD D,0
|
|
DEC HL
|
|
LD B,D
|
|
LD C,D
|
|
OR A ;not paginating?
|
|
JR Z,OrnLpF
|
|
INC BC
|
|
OrntLp: SBC HL,DE
|
|
JR C,OrnLpF
|
|
INC BC
|
|
JR OrntLp
|
|
OrnLpF: ADD HL,DE
|
|
INC HL
|
|
LD (CurPgL),HL
|
|
LD (CurPg),BC
|
|
RET
|
|
;
|
|
;Show (just) as much of the text as necessary
|
|
;
|
|
ShoTx: CALL KyStat ;check keybd
|
|
JR NZ,ShoTx1
|
|
CALL TestSc ;check postponed screen disp
|
|
JP NZ,ShoAll ;do it!
|
|
CALL ShoPos ;quiet? update header
|
|
CALL TestCu ;check postponed line disp
|
|
JR NZ,DoPost ;do it (or more, if requested)
|
|
ShoTx1: LD A,(ShoFlg) ;busy...
|
|
OR A ;nothing (0)
|
|
RET Z
|
|
DEC A
|
|
JP Z,ShoRCu ;just one line (1,2) - can be postponed
|
|
DEC A
|
|
JP Z,ShoCu
|
|
DEC A
|
|
JP Z,ShoDn ;bottom part (3)
|
|
JP ShoSc ;or whole screen
|
|
DoPost: LD A,(ShoFlg)
|
|
CP 3
|
|
JP C,ShoCu ;at LEAST this
|
|
JP Z,ShoDn
|
|
JP ShoSc
|
|
;
|
|
;Show position in file, no matter what
|
|
;
|
|
ShoPos: LD A,(NoHdrF)
|
|
OR A
|
|
RET NZ
|
|
CALL Force ;must see this
|
|
LD DE,DspPg ;Update header
|
|
CALL GoTo
|
|
CALL MakAlt ;C128 bug fix requires GoTo first
|
|
LD HL,(CurPg)
|
|
LD A,(FMode)
|
|
CP 'N'
|
|
CALL NZ,ShPSb1
|
|
LD DE,DspLin
|
|
LD HL,(CurPgL)
|
|
CALL ShPoSb
|
|
LD DE,DspCol
|
|
LD A,(CurCol)
|
|
LD L,A
|
|
LD H,0
|
|
CALL ShPoSb
|
|
CALL UnAlt
|
|
JP UForce
|
|
ShPoSb: PUSH HL ;show a number
|
|
CALL GoTo
|
|
POP HL
|
|
ShPSb1: LD DE,PNBuf
|
|
CALL BCDCon
|
|
LD HL,PNBuf
|
|
LD B,5
|
|
JP BHLMsg
|
|
;
|
|
;Show current line only (fast)
|
|
;
|
|
ShoCu: CALL ConChk ;(postpone if busy!)
|
|
JP NZ,HoldCu
|
|
ShoCu1: LD A,(Vert)
|
|
LD B,A
|
|
JP ShoLn
|
|
;
|
|
ShoRCu: CALL ConChk ;(postpone if busy!)
|
|
JP NZ,HoldCu
|
|
CALL FetchB
|
|
CP TAB ;can't do this with tab at left
|
|
JP Z,ShoCu
|
|
LD A,(Vert) ;special routine: only RIGHT of cursor
|
|
LD D,A ;...modeled on ShoLCu
|
|
LD A,(RulFlg)
|
|
AND 1
|
|
ADD A,D
|
|
LD D,A ;current row
|
|
LD A,(Horiz)
|
|
DEC A
|
|
LD E,A
|
|
JP Z,ShoCu ;can't do this at left of screen
|
|
DEC E
|
|
CALL GoTo ;position to start
|
|
LD E,1 ;find start of line
|
|
CALL CrLft
|
|
PUSH HL
|
|
LD HL,Horiz
|
|
LD A,(NSkip)
|
|
ADD A,(HL)
|
|
DEC A
|
|
LD D,A
|
|
DEC A
|
|
LD B,A ;skip till just before cursor
|
|
LD A,(View)
|
|
INC A
|
|
SUB (HL)
|
|
LD E,A
|
|
INC E
|
|
POP HL
|
|
CALL ShoLSb ;do part (char!) left of cursor
|
|
INC E ;(DON'T ask me why this INC is needed)
|
|
LD D,E
|
|
DEC D
|
|
LD A,(Vert)
|
|
LD HL,TxtLns
|
|
CP (HL) ;avoid last line, col
|
|
JR NZ,ShRCu3
|
|
DEC D
|
|
ShRCu3: LD HL,(AftCu)
|
|
JP ShoLSb
|
|
;
|
|
;Display from Cursor line-1 down
|
|
;
|
|
ShoDn: CALL ConChk ;(postpone if busy!)
|
|
JP NZ,HoldSc
|
|
LD HL,CsrOff
|
|
CALL CtlStr
|
|
LD A,(DSFlg) ;(or line-2 if DS)
|
|
LD HL,Vert
|
|
ADD A,(HL)
|
|
JR Z,ShoSc0
|
|
LD B,A
|
|
DJNZ ShScLp
|
|
JR ShoSc0
|
|
;
|
|
;Show everything on emerging from macros etc
|
|
;
|
|
ShoAll: CALL Orient
|
|
CALL DoHdr
|
|
CALL ShoPos
|
|
JR ShoScX
|
|
;
|
|
;Display whole text screen (sigh)
|
|
;
|
|
ShoSc: CALL ConChk ;(Postpone if busy!)
|
|
JP NZ,HoldSc
|
|
ShoScX: LD HL,CsrOff
|
|
CALL CtlStr
|
|
ShoSc0: CALL RulFix
|
|
CALL SetNo ;kill any pending redisps
|
|
XOR A
|
|
LD (CuFlg),A
|
|
CPL
|
|
LD (HorFlg),A
|
|
LD B,1 ;Simple method if not memory mapped
|
|
ShScLp: PUSH BC
|
|
CALL ShoLn
|
|
POP BC
|
|
INC B
|
|
LD A,(TxtLns)
|
|
INC A
|
|
SUB B
|
|
JR NZ,ShScLp
|
|
LD HL,CurOn
|
|
CALL CtlStr
|
|
RET
|
|
;
|
|
IOoff1: LD DE,DspEsc ;header: blank prompt
|
|
CALL GoTo
|
|
CALL MakAlt
|
|
LD B,4+1 ;(cursor)
|
|
CALL BBlank
|
|
JP UnAlt
|
|
;
|
|
IOoff: LD A,(NoHdrF) ;headerless? redo top line
|
|
OR A
|
|
JR Z,IOoff1
|
|
LD A,(RulFlg)
|
|
OR A
|
|
JP NZ,RuShow
|
|
;
|
|
;Show line 1 (to wipe out msgs)
|
|
;
|
|
ShoLn1: LD B,1 ;fall thru...
|
|
;
|
|
;Show line number B (=1...TxtLns)
|
|
;
|
|
ShoLn: LD A,(ShutUp)
|
|
OR A
|
|
RET NZ
|
|
PUSH BC
|
|
CALL KyStat ;(helps buffering for slow keyboards)
|
|
POP BC
|
|
LD A,(RulFlg)
|
|
AND 1
|
|
ADD A,B
|
|
LD D,A ;position cursor on screen
|
|
LD E,0
|
|
PUSH BC
|
|
CALL GoTo
|
|
POP BC
|
|
LD A,(Vert) ;is line before or after cursor?
|
|
SUB B
|
|
JR Z,ShoLCu ;ouch, it's cursor line
|
|
JR C,ShoLAf
|
|
ShoLBf: LD E,A ;okay, before
|
|
INC E
|
|
CALL CrLft
|
|
LD A,(View)
|
|
INC A
|
|
LD E,A
|
|
LD A,(NSkip)
|
|
LD B,A
|
|
LD D,255
|
|
JR ShoLSb
|
|
ShoLAf: NEG ;okay, after
|
|
PUSH BC ;save line#
|
|
LD E,A
|
|
CALL CrRit
|
|
POP BC
|
|
PUSH AF
|
|
LD A,(View)
|
|
LD D,A
|
|
INC A
|
|
LD E,A
|
|
LD A,(TxtLns)
|
|
CP B ;last line? avoid last column
|
|
JR NZ,ShLAf0
|
|
DEC D
|
|
ShLAf0: POP AF
|
|
JR C,ShLAf1
|
|
JR Z,ShLAf2
|
|
ShLAf1: JP ClEOL ;no line!
|
|
ShLAf2: LD A,(NSkip)
|
|
LD B,A
|
|
ADD A,D
|
|
LD D,A
|
|
JR ShoLSb
|
|
ShoLCu: LD E,1 ;hmm, right on cursor
|
|
PUSH BC ;save line#
|
|
CALL CrLft
|
|
LD A,(NSkip)
|
|
LD B,A
|
|
LD A,(CurCol) ;do part to left
|
|
DEC A
|
|
LD D,A
|
|
LD A,(View)
|
|
INC A
|
|
LD E,A
|
|
CALL ShoLSb
|
|
LD D,E
|
|
DEC D
|
|
POP AF ;line#
|
|
LD HL,TxtLns
|
|
CP (HL) ;avoid last line, col
|
|
JR NZ,ShLCu1
|
|
DEC D
|
|
ShLCu1: LD HL,(AftCu)
|
|
;
|
|
ShoLSb: LD A,D ;Show up to column D of text starting at HL
|
|
OR A ;E=room+1, B=Cols to skip (if any)
|
|
RET Z
|
|
XOR A
|
|
EXX
|
|
LD B,A ;B',C' keep track of previous chars
|
|
LD C,A
|
|
LD E,A ;E' is count skipped
|
|
EXX
|
|
LD C,A ;initialize GetNx
|
|
ADD A,B
|
|
JR Z,ShLSL2
|
|
ShLSL1: CALL GetNx ;eat skipped columns
|
|
JP Z,ClEOL ;end of line?
|
|
CP TAB
|
|
JR Z,ShLS1T
|
|
EXX
|
|
INC E ;E'
|
|
EXX
|
|
DEC D
|
|
DJNZ ShLSL1
|
|
CALL ShSvCh
|
|
INC D
|
|
DEC D
|
|
RET Z
|
|
JR ShLSL2
|
|
ShLS1T: EXX ;count for tabs
|
|
LD A,E
|
|
LD HL,TabCnt
|
|
AND (HL)
|
|
XOR (HL) ;extra spaces
|
|
INC A ;plus usual one
|
|
PUSH AF
|
|
ADD A,E
|
|
LD E,A
|
|
POP AF
|
|
EXX
|
|
PUSH AF
|
|
SUB D
|
|
NEG
|
|
LD D,A
|
|
POP AF
|
|
SUB B
|
|
NEG
|
|
LD B,A
|
|
JR NZ,ShLSL1
|
|
LD A,TAB
|
|
CALL ShSvCh
|
|
INC D
|
|
DEC D
|
|
RET Z
|
|
ShLSL2: CALL GetNx ;show the rest
|
|
EXX
|
|
LD C,B
|
|
LD B,A
|
|
EXX
|
|
JR Z,ShLSCr ;take care of CR,TAB
|
|
CP ' '
|
|
JR C,ShCtl
|
|
PUSH DE
|
|
LD E,A
|
|
CALL PutCh
|
|
POP DE
|
|
ShLSL3: DEC E
|
|
DEC D
|
|
RET Z
|
|
LD A,E
|
|
DEC A
|
|
RET Z
|
|
JR ShLSL2
|
|
ShCtl: PUSH HL
|
|
PUSH BC
|
|
PUSH DE
|
|
CP TAB
|
|
JR Z,ShLSTb
|
|
ADD A,40H ;other ctls are hili letters
|
|
EX AF,AF'
|
|
CALL AltY ;(mandatory)
|
|
EX AF,AF'
|
|
CALL PutChA
|
|
CALL UnAltY
|
|
JR ShLRet
|
|
ShLSCr: PUSH HL
|
|
PUSH BC
|
|
PUSH DE
|
|
EXX
|
|
LD A,C ;last char
|
|
EXX
|
|
CP ' '
|
|
JR Z,ShLCrF ;SCR doesn't show
|
|
LD A,(HCRFlg)
|
|
OR A
|
|
JR Z,ShLCrF ;HCRs also MAY not...
|
|
LD E,'<'
|
|
CALL PutCh
|
|
POP DE
|
|
DEC D
|
|
DEC E
|
|
PUSH DE
|
|
LD A,E ;don't ClEOL if now in last col
|
|
CP 2
|
|
ShLCrF: CALL NC,ClEOL
|
|
POP DE ;end of line
|
|
POP BC
|
|
POP HL
|
|
RET
|
|
ShLSTb: LD A,(View) ;hit a tab...
|
|
INC A
|
|
SUB E ;column
|
|
LD HL,TabCnt
|
|
AND (HL)
|
|
XOR (HL) ;figure extra spaces
|
|
LD B,A
|
|
JR Z,ShLTLF
|
|
ShLTbL: CALL PutSpc ;do them
|
|
POP DE
|
|
DEC E
|
|
DEC D
|
|
PUSH DE
|
|
JR Z,ShLRet
|
|
DJNZ ShLTbL ;then one last
|
|
ShLTLF: CALL PutSpc
|
|
ShLRet: POP DE
|
|
POP BC
|
|
POP HL
|
|
JR ShLSL3
|
|
ShSvCh: EXX ;keep track of prev chars
|
|
LD C,B
|
|
LD B,A
|
|
EXX
|
|
RET
|
|
;
|
|
;
|
|
ClEOL: LD HL,CIL ;clear to EOL (quickly if possible)
|
|
CALL CtlStr
|
|
RET NC
|
|
SpEOL: DEC E ;this always SPACES (for attributes)
|
|
RET Z
|
|
ClELp: LD A,(CurRow)
|
|
INC A
|
|
LD HL,PhysLn
|
|
CP (HL)
|
|
JR NZ,ClEL3
|
|
DEC E ;avoid last char on last line
|
|
RET Z
|
|
ClEL3: CALL PutSpc
|
|
DEC E
|
|
JR NZ,ClEL3
|
|
RET
|
|
;
|
|
ClLast: LD A,(PhysLn) ;clear last line on screen
|
|
DEC A
|
|
LD D,A
|
|
LD E,0
|
|
CALL GoToIt
|
|
LD A,(View)
|
|
LD E,A ;do NOT INC this, it's last line
|
|
JR ClEOL
|
|
;
|
|
;
|
|
;Set level of display required
|
|
;
|
|
SetAl: LD A,0FFH ;routines to set it
|
|
JR Set1 ;(must preserve ALL REGS and FLAGS)
|
|
SetDn: LD A,3
|
|
JR Set1
|
|
SetCu: LD A,2
|
|
JR Set1
|
|
SetRCu: LD A,1
|
|
JR Set1
|
|
SetNo: XOR A ;this one WILL shut it up...
|
|
JR Set2
|
|
Set1: PUSH AF ;...otherwise, do not DEcrease previous requests
|
|
EX (SP),HL
|
|
LD A,(ShoFlg)
|
|
CP H
|
|
EX (SP),HL
|
|
JR NC,Set3
|
|
POP AF
|
|
Set2: LD (ShoFlg),A
|
|
RET
|
|
Set3: POP AF
|
|
RET
|
|
;
|
|
SmlDly: LD A,(Timer)
|
|
LD B,A
|
|
LD C,1
|
|
JP BDlyLp
|
|
;
|
|
ScrUDx: LD A,0C9H ;(RET)
|
|
LD (UpLft),A
|
|
CALL ScrlUD
|
|
CALL NC,SmlDly ; delay if scrolled
|
|
LD A,11H ;(LD DE,nnnn)
|
|
LD (UpLft),A
|
|
RET
|
|
;
|
|
ScrlU2: LD HL,DelL
|
|
CALL ScrlUD
|
|
JR C,SetAl ; no scroll
|
|
JR SetCu
|
|
;
|
|
ScrlU: LD HL,DelL
|
|
JR ScrlX
|
|
;
|
|
EdgeU: LD A,(Vert)
|
|
DEC A ;first line: scroll
|
|
RET NZ
|
|
ScrlD: LD HL,InsL
|
|
ScrlX: CALL ScrlUD
|
|
JR C,SetAl ; no scroll
|
|
CALL SmlDly
|
|
JR SetCu
|
|
ScrlUD: PUSH HL ;[common sbr, used in one-liners too]
|
|
CALL TestCu
|
|
CALL NZ,ShoCu1
|
|
LD A,(NoHdrF) ;canNOT do this if header is suppressed
|
|
LD HL,OddDel ; and ins/del specific to ln 1.
|
|
AND (HL)
|
|
LD HL,WinFlg ; or if Windowing (in any event)
|
|
OR (HL)
|
|
POP HL
|
|
JR NZ,NoScrl
|
|
PUSH HL
|
|
CALL UpLft
|
|
POP HL
|
|
CALL CtlStr ;do it
|
|
RET C ;(maybe couldn't)
|
|
LD A,(OddDel)
|
|
OR A
|
|
CALL NZ,RulFix
|
|
RET
|
|
NoScrl: SCF ; didn't scroll
|
|
RET
|
|
;
|
|
; Set flag for redisplay due to arrow keys
|
|
;
|
|
EdgeL: LD A,(Vert)
|
|
DEC A
|
|
RET NZ
|
|
LD A,(CurCol)
|
|
DEC A
|
|
RET NZ
|
|
JR ScrlD ;scroll if at top left
|
|
EdgeR: CALL Fetch
|
|
JR Z,ER01
|
|
LD A,(Horiz) ;not CR: if off right edge, scroll
|
|
LD HL,View
|
|
CP (HL)
|
|
JR Z,HorScl
|
|
RET
|
|
ER01: LD A,(Vert) ;CR: if at bot right, scroll
|
|
LD HL,TxtLns
|
|
CP (HL)
|
|
JP Z,ScrlU
|
|
EdgeD: LD A,(Vert)
|
|
LD HL,TxtLns
|
|
CP (HL)
|
|
JP Z,ScrlU ;last line: scroll
|
|
RET
|
|
;
|
|
;Watch for horizontal scroll
|
|
;
|
|
IfScl: LD A,(NSkip) ;request scroll if already scrolled
|
|
OR A
|
|
RET Z
|
|
HorScl: CALL SetCu ;request scroll
|
|
XOR A
|
|
LD (HorFlg),A
|
|
RET
|
|
;
|
|
;Postpone display for speed
|
|
;
|
|
HoldCu: LD A,0FFH ;save if busy
|
|
LD (CuFlg),A
|
|
RET
|
|
HoldSc: LD A,0FFH
|
|
LD (ScFlg),A
|
|
RET
|
|
TestSc: LD HL,ScFlg ;test & reset postponement
|
|
JR TestX
|
|
TestCu: LD HL,CuFlg
|
|
TestX: XOR A ;(ret with Z if none)
|
|
ADD A,(HL)
|
|
LD (HL),0
|
|
RET
|
|
;
|
|
; Position cursor for input
|
|
;
|
|
Cursr: CALL PosCur ;turn on cursor
|
|
CALL Fetch
|
|
RET NZ
|
|
LD A,(HCRFlg) ;oops, on a CR
|
|
OR A ;HCRs showing?
|
|
RET Z
|
|
CALL FetchB ;got to fix HCR flag
|
|
LD E,' ' ;kludge to " " or "<"
|
|
CP E
|
|
JR Z,Csr01
|
|
CALL NdCnt
|
|
JR C,Csr01
|
|
LD E,'<'
|
|
Csr01: CALL XPutCh
|
|
LD E,BS
|
|
JP PutCh
|
|
;
|
|
;
|
|
; MESSAGES
|
|
;
|
|
ErrTab: DW 0,MSG1,MSG2,MSG3,MSG4,MSG4,MSG7,MSG7,MSG8,MSG9
|
|
;
|
|
MSG1: DB 'Ou','t'+X,'o','f'+X,'Memory',0
|
|
MSG2: DB 'Invali','d'+X,'Key',0
|
|
MSG3: DB 'I/','O'+X ;(fall through to 7)
|
|
MSG7: DB 'Error',0
|
|
MSG4: DB 'No','t'+X,'Found',0
|
|
MSG8: DB 'Synta','x'+X,'Error',0 ;(note 5,6 not used)
|
|
MSG9: DB 'Canno','t'+X,'Reformat',0 ;(note error 10 has no MSG)
|
|
;
|
|
NameQ: DB 'Name',':'+X,0
|
|
ReadQ: DB 'Read',':'+X,0
|
|
WritQ: DB 'Write',':'+X,0
|
|
EraQ: DB 'Erase',':'+X,0
|
|
LoadQ: DB 'Load',':'+X,0
|
|
FindQ: DB 'Find',':'+X,0
|
|
ChgQ: DB 'Chang','e'+X,'to',':'+X,0
|
|
DirQ: DB 'Dir',':'+X,0
|
|
PrtQ: DB 'Options',':'+X,0
|
|
PgLnQ: DB 'Length',':'+X,0
|
|
ColQ: DB 'Column',':'+X,0
|
|
PageQ: DB 'Page',':'+X,0
|
|
LineQ: DB 'Line',':'+X,0
|
|
MacroQ: DB 'Macro',':'+X,0
|
|
RptcQ: DB 'Repea','t'+X,'coun','t'+X,'([Q],0-9/*)',':'+X,0
|
|
KeyQ: DB 'Ke','y'+X,'numbe','r'+X,'([N/Q],0-9)',':'+X,0
|
|
QuitQ: DB 'Abando','n'+X,'changes','?'+X,'(Y/N)',':'+X,0
|
|
UnchgQ: DB 'Unchanged',';'+X,'save','?'+X,'(Y/N)',':'+X,0
|
|
;
|
|
; Changed: Q File size: NNNNN Memory used: NNNNN Free: NNNNN
|
|
InfMsg: DB CR
|
|
DB ' '+X,'Changed',':'+X
|
|
ModQQQ: DB 'Q',X,7,'Fil','e'+X,'size',':'+X
|
|
SizNNN: DB 'NNNNN',X,5,'Memor','y'+X,'used',':'+X
|
|
UsdNNN: DB 'NNNNN',X,5,'Free',':'+X
|
|
FreNNN: DB 'NNNNN',CR,0
|
|
;
|
|
; [Menus disabled; see VDE.DOC or .QRF]
|
|
; [See VDE.DOC and .QRF for help]
|
|
;
|
|
HlpMsg: DB X,26,'[Menu','s'+X,'disabled',';'+X,'se','e'+X
|
|
DB 'Manual]',CR,0
|
|
;
|
|
;A4/DOC:FILENAME.TYP /A Pg 1 Ln 1 Cl 51 INS vt by AO DS <R ^Q_
|
|
;
|
|
Header: DB X,39,'L','n'+X,X,5,'Cl',CR,0
|
|
DspFnm EQU 1 ;offsets for display
|
|
DspOP EQU DspFnm+30 ;31
|
|
DspPg EQU DspOP+3 ;34
|
|
DspLin EQU DspPg+8 ;42
|
|
DspCol EQU DspLin+8 ;50
|
|
DspIns EQU DspCol+5 ;55
|
|
DspTab EQU DspIns+4 ;59
|
|
DspHyp EQU DspTab+3 ;62
|
|
DspInd EQU DspHyp+3 ;65
|
|
DspSpc EQU DspInd+3 ;68
|
|
DspMrg EQU DspSpc+3 ;71
|
|
DspEsc EQU DspMrg+3 ;74
|
|
DspEsQ EQU DspEsc+3 ;74
|
|
;
|
|
TogOff: DB ' '
|
|
CQTog: DB ' ^Q'
|
|
COTog: DB ' ^O'
|
|
CPTog: DB ' ^P'
|
|
CKTog: DB ' ^K'
|
|
ESCTog: DB 'ESC'
|
|
YNMsg: DB 'Chg?'
|
|
IOmsg: DB 'Wait'
|
|
RdyQ: DB 'Rdy'
|
|
CQTTog: DB '^QT'
|
|
OPon: DB 'OP '
|
|
OPoff: DB 'Pg '
|
|
INSon: DB 'INS'
|
|
VTon: DB 'vt '
|
|
HYon: DB 'hy '
|
|
AIon: DB 'AI '
|
|
DSon: DB 'DS '
|
|
MRon: DB 'MR '
|
|
PSon: DB 'PS '
|
|
;
|
|
Bak: DB 'BAK'
|
|
Data: ;zeroed out at initialization...
|
|
;any other values that matter must be set by Start:.
|
|
;
|
|
;FLAGS
|
|
;
|
|
FilFlg: DS 1 ;make BAK file?
|
|
MSIFlg: DS 1 ;file loaded?
|
|
Modify: DS 1 ;file modified?
|
|
WinFlg: DS 1 ;windowing?
|
|
BelowF: DS 1 ;in window?
|
|
MacFlg: DS 1 ;macro going?
|
|
ChgFlg: DS 1 ;change followed last find?
|
|
FBackw: DS 1 ;find backward?
|
|
FGlobl: DS 1 ;find global?
|
|
AIFlg: DS 1 ;auto indent?
|
|
DSFlg: DS 1 ;doublespace?
|
|
VTFlg: DS 1 ;varitab?
|
|
KeyFlg: DS 1 ;allow redisp?
|
|
HorFlg: DS 1 ;horiz scroll? (must be next to ShoFlg)
|
|
ShoFlg: DS 1 ;redisp code
|
|
CuFlg: DS 1 ;postponed line redisp?
|
|
ScFlg: DS 1 ;postponed screen redisp?
|
|
JmpFlg: DS 1 ;jump in progress?
|
|
YNFlg: DS 1 ;"*" specified?
|
|
SftFlg: DS 1 ;handle space softening
|
|
HCRFlg: DS 1 ;showing hard CRs?
|
|
IgnFlg: DS 1 ;ignoring dot commands?
|
|
;
|
|
;STORAGE
|
|
;
|
|
FMode: DS 1
|
|
EdErr: DS 1
|
|
CurDsk: DS 1
|
|
CurUsr: DS 1
|
|
FCBU: DS 1
|
|
FindSv: DS 2
|
|
MKsav: DS 1
|
|
Copies: DS 1
|
|
POByt: DS 1
|
|
StPrt: DS 2
|
|
EndPr: DS 2
|
|
PageN: DS 1
|
|
PBeg: DS 1
|
|
PNum: DS 1
|
|
POff: DS 1
|
|
PrTMrg: DS 1
|
|
PrLMrg: DS 1
|
|
HdrPtr: DS 2
|
|
HdrLen: DS 1
|
|
PgLen: DS 1
|
|
LfMarg: DS 1 ;L,R order
|
|
RtMarg: DS 1
|
|
LMSav: DS 1 ;ditto
|
|
RMSav: DS 1
|
|
PhysLn: DS 1
|
|
DirLns: DS 1
|
|
DirCls: DS 1
|
|
CmdPtr: DS 2
|
|
RptCnt: DS 1
|
|
LFChr: DS 1
|
|
SavQ: DS 1
|
|
SavQ2: DS 1
|
|
SavIns: DS 1
|
|
AltMsk: DS 1
|
|
CurRow: DS 1
|
|
DspFlg: DS 1
|
|
IsBVal: DS 1
|
|
PrevCh: DS 1
|
|
PrvCh2: DS 1
|
|
PScnt: DS 1
|
|
NumTab: DS 1
|
|
GSbufA: DS 2 ;GetStr buffer address
|
|
RclFlg: DS 1 ;recall previous string flag
|
|
;
|
|
;SCREEN DATA AREA
|
|
;
|
|
TxtLns: DS 1 ;text screen size
|
|
Horiz: DS 1 ;virtual screen position
|
|
Vert: DS 1
|
|
NSkip: DS 1 ;virtual screen offset
|
|
HPos: DS 1 ;room left on line
|
|
CurCol: DS 1 ;column
|
|
CurLin: DS 2 ;line
|
|
CurPg: DS 2 ;page
|
|
CurPgL: DS 2 ;line on page
|
|
;
|
|
SavLin: DS 2
|
|
OldLin: DS 2
|
|
SavCol: DS 1
|
|
OldCol: DS 1
|
|
;
|
|
BegTx: DS 2 ;text boundaries
|
|
BefCu: DS 2
|
|
AftCu: DS 2
|
|
EndTx: DS 2
|
|
LastCu: DS 2
|
|
;
|
|
;BUFFERS
|
|
;
|
|
FNamBf: DS 8+1+3+1 ;filename store/recall buffer
|
|
tStamp: DS 15 ;file timestamp
|
|
tsFlg: DS 1 ;have timestamp
|
|
;
|
|
;BUFFERS
|
|
;
|
|
ConBufL EQU 30
|
|
ConBuf: DS ConBufL+1 ;console buffer
|
|
;
|
|
FCBBuf: DS 32 ;for SavNam, Dir
|
|
RulBuf: DS 128 ;for RulFix
|
|
;
|
|
StrSiz EQU 128 ;size of Macro strings
|
|
LinLen EQU 65 ;max length of ZDE input line
|
|
FndStr: DS LinLen+1 ;string buffers
|
|
ChgStr: DS LinLen+1
|
|
MacStr: DS StrSiz+1
|
|
;
|
|
DataLn EQU $-Data ;end of DATA segment
|
|
;
|
|
DS 48
|
|
Stack: DS 4
|
|
;
|
|
;Show the menu
|
|
;
|
|
DoMnu: LD A,(Help) ;menus enabled?
|
|
OR A
|
|
JR NZ,HelpY
|
|
LD HL,HlpMsg ;no, it's just a one-line msg now
|
|
CALL MsgDsp
|
|
CALL ESCLp
|
|
JP ShoLn1
|
|
;
|
|
DB 0
|
|
DB 0,0,0
|
|
;
|
|
HelpY: LD A,(TxtLns)
|
|
CP 7
|
|
JP C,Error7 ;menu takes 7 lines
|
|
LD HL,Menu
|
|
CALL MsgDsp
|
|
CALL IfSpLn
|
|
DoMnuI: CALL RptKey ;request submenu?
|
|
CALL XCase
|
|
CP ' '
|
|
JR Z,DoMnuX
|
|
LD HL,KMenu
|
|
CP 'K'-40h
|
|
JR Z,DoMnu2
|
|
CP ESC
|
|
JR Z,DoMnu2
|
|
LD HL,OMenu
|
|
CP 'O'-40h
|
|
JR Z,DoMnu2
|
|
LD HL,QMenu
|
|
CP 'Q'-40h
|
|
JR NZ,DoMnuI
|
|
DoMnu2: CALL MsgDsp
|
|
CALL ESCLp ;wait for ESC
|
|
DoMnuX: JP SetAl
|
|
;
|
|
;^E csr up ^F word rt ^W line up ^G delete ^U UNdelete ^P prt code
|
|
;^X down ^A word lf ^Z line dn DEL del left ^B reform ^PZ place mark
|
|
;^S left ^R page up ^V insert ^T del word ^^ case toggle
|
|
;^D right ^C page dn ^N insrt CR ^Y del line ^L(^\) rpt find
|
|
; (PRESS ^K/ESC, ^O, ^Q FOR SUBMENUS)
|
|
;
|
|
Menu: DB '^','E'+X,'cs','r'+X,'up',' '+X,'^','F'+X,'wor','d'+X,'rt',X,3
|
|
DB '^','W'+X,'lin','e'+X,'up',X,3,'^','G'+X,'delete',X,4
|
|
DB '^','U'+X,'UNdelete',X,3,'^P',' '+X,'Pt','r'+X,'code',CR
|
|
DB '^','X'+X,'down',X,4,'^','A'+X,'wor','d'+X,'lf',X,3
|
|
DB '^','Z'+X,'lin','e'+X,'dn',' '+X,'DE','L'+X,'de','l'+X,'left',' '+X
|
|
DB '^','B'+X,'reform',X,5,'^P','Z'+X,'plac','e'+X,'mark',CR
|
|
DB '^','S'+X,'left',X,4,'^','R'+X,'pag','e'+X,'up',X,3
|
|
DB '^','V'+X,'insert',X,4,'^','T'+X,'de','l'+X,'word',' '+X
|
|
DB '^','^'+X,'cas','e'+X,'toggle',CR
|
|
DB '^','D'+X,'right',X,3,'^','C'+X,'pag','e'+X,'dn',X,3
|
|
DB '^','N'+X,'insr','t'+X,'CR',' '+X,'^','Y'+X,'de','l'+X,'line',' '+X
|
|
DB '^L(^\',')'+X,'rp','t'+X,'find',CR
|
|
DB X,24,'(PRES','S'+X,'^K/ESC',','+X,'^O',','+X,'^','Q'+X
|
|
DB 'FO','R'+X,'SUBMENUS)',CR,0
|
|
;
|
|
;^KB Begin block ^KW block Write ^KL Load new ^KN Name EscM Macro def
|
|
;^KK end block ^KY delete block ^KS Save ^KI Info Esc# store key
|
|
;^KU Unmark blk ^KR Read file ^KD save+load ^KP Print Esc0..9 use ky
|
|
;^KC Copy block ^KF File list ^KX save+eXit Esc-TAB tab back
|
|
;^KV moVe block ^KE Erase file ^KQ Quit Esc-Arrows shift screen
|
|
;
|
|
KMenu: DB '^K','B'+X,'Begi','n'+X,'block',' '+X,'^K','W'+X,'bloc','k'+X,'Write'
|
|
DB X,3,'^K','L'+X,'Loa','d'+X,'new',X,5,'^K','N'+X,'Name',X,4
|
|
DB 'Esc','M'+X,'Macr','o'+X,'def',CR
|
|
DB '^K','K'+X,'en','d'+X,'block',X,4,'^K','Y'+X,'delet','e'+X,'block'
|
|
DB ' '+X,'^K','S'+X,'Save',X,9,'^K','I'+X,'Info',X,4
|
|
DB 'Esc','#'+X,'stor','e'+X,'key',CR
|
|
DB '^K','U'+X,'Unmar','k'+X,'blk',X,3,'^K','R'+X,'Rea','d'+X,'file'
|
|
DB X,5,'^K','D'+X,'save+load',X,4,'^K','P'+X,'Print',X,3
|
|
DB 'Esc0..','9'+X,'us','e'+X,'ky',CR
|
|
DB '^K','C'+X,'Cop','y'+X,'block',X,3,'^K','F'+X,'Fil','e'+X,'list'
|
|
DB X,5,'^K','X'+X,'save+eXit',X,4,'Esc-TA','B'+X,'ta','b'+X,'back',CR
|
|
DB '^K','V'+X,'moV','e'+X,'block',X,3,'^K','E'+X,'Eras','e'+X,'file'
|
|
DB X,4,'^K','Q'+X,'Quit',X,9,'Esc-Arrow','s'+X,'shif','t'+X,'screen',CR
|
|
DB 0
|
|
;
|
|
; ^QB goto Block ^Q<u> scr top ^QY del to EOL ^QF Find
|
|
; ^QP to Place mk ^Q<d> scr bot ^QDel " to BOL ^QA replAce
|
|
; ^QR goto TOF ^Q<l> ln start ^QT del to char ^QP to last cursor
|
|
; ^QC goto EOF ^Q<r> ln end ^QU UNdel line ^QI goto pg/ln
|
|
; ^QQ goto ZCPR queue line
|
|
;
|
|
QMenu: DB X,4,'^Q','B'+X,'got','o'+X,'Block',X,4,'^Q<u','>'+X,'sc','r'+X,'top'
|
|
DB X,5,'^Q','Y'+X,'de','l'+X,'t','o'+X,'EOL',X,4,'^Q','F'+X,'Find',CR
|
|
DB X,4,'^Q','Z'+X,'t','o'+X,'plac','e'+X,'mk',X,3,'^Q<d','>'+X,'sc'
|
|
DB 'r'+X,'bot',X,5,'^QDe','l'+X,'"'+X,'t','o'+X,'BOL',X,4,'^Q','A'+X
|
|
DB 'replAce',CR
|
|
DB X,4,'^Q','R'+X,'got','o'+X,'TOF',X,6,'^Q<l','>'+X,'l','n'+X,'start'
|
|
DB X,4,'^Q','T'+X,'de','l'+X,'t','o'+X,'char',X,3,'^Q','P'+X,'t','o'+X
|
|
DB 'las','t'+X,'cursor',CR
|
|
DB X,4,'^Q','C'+X,'got','o'+X,'EOF',X,6,'^Q<r','>'+X,'l','n'+X,'end'
|
|
DB X,6,'^Q','U'+X,'UNde','l'+X,'line',X,4,'^Q','I'+X,'got','o'+X
|
|
DB 'Pg/Ln',CR
|
|
DB X,'(^Q','Q'+X,'got','o'+X,'ZCP','R'+X,'queu','e'+X,'line',CR,0
|
|
;
|
|
;^OL,R marg set ^OI tab set ^OP Page length ^O<u> make top ln ^OA Auto-in
|
|
; ^OX marg rel ^ON tab clr ^OS dbl Spacing ^OW Window ^OQ Quiet
|
|
; ^OC Center ^OV Vari tabs ^OH Hyphenation ^OJ proportional
|
|
; ^OF Flush rt ^OT ruler ^OD Display CRs ^OZ Zap screen
|
|
;
|
|
OMenu: DB '^OL,','R'+X,'mar','g'+X,'set',X,2,'^O','I'+X,'ta','b'+X,'set'
|
|
DB X,4,'^O','P'+X,'Pag','e'+X,'length',X,2
|
|
DB '^O<u','>'+X,'mak','e'+X,'to','p'+X,'ln',X,2,'^O','A'+X,'Auto-in',CR
|
|
DB X,2,'^O','X'+X,'mar','g'+X,'rel',X,2,'^O','N'+X,'ta','b'+X,'clr'
|
|
DB X,4,'^O','S'+X,'db','l'+X,'Spacing',X,4,'^O','W'+X,'Window',X,7
|
|
DB '^O','Q'+X,'Quiet',CR
|
|
DB X,2,'^O','C'+X,'Center',X,4,'^O','V'+X,'Var','i'+X,'tabs'
|
|
DB X,2,'^O','H'+X,'Hyphenation',X,4,'^O','J'+X,'proportional',CR
|
|
DB X,2,'^O','F'+X,'Flus','h'+X,'rt',X,2,'^O','T'+X,'ruler'
|
|
DB X,6,'^O','D'+X,'Displa','y'+X,'CRs'
|
|
DB X,4,'^O','Z'+X,'Za','p'+X,'screen',CR,' ',CR,0
|
|
;
|
|
DS 4
|
|
MnuEnd: ;menus end here, text can begin
|
|
END
|
|
|