*
*----------------------------------------*
*  Initialize the MEDIT pointers.        *
*----------------------------------------*
*
INIT LHLD BFSTT  Initialize the pointers
 SHLD SCHLOC
*
INIT0 SHLD MEMLNE
 SHLD MEMPNT
 XCHG .
 LXI H,SCREEN+7
 SHLD SCRPNT
*
INIT1 XRA A  Initialize the screen
 OUT 0FEH
 OUT 0C8H
*
 LXI SP,STACK  Initialize the stack
*
*----------------------------------------*
*  This is the main loop of MEDIT        *
*----------------------------------------*
*
MAIN LHLD MEMLNE  Get the memory address
 XCHG .  Pointer must be in DE
 CALL PRVDM  Put on a new screen of data
*
MN0 CALL CURON  Put on the cursor
*
 PUSH D  Go update the information
 PUSH H
 CALL PRINFO  Do it now
 POP H  Retrieve values
 POP D
*
*----------------------------------------*
*  Check for input of wanted characters. *
*----------------------------------------*
*
MN1 CALL INPUT  Wait for a character
 ANI 7FH
*
*----------------------------------------*
*  We've got a character.  Find out what *
*  it does (if anything)                 *
*----------------------------------------*
*
LOOK LXI B,MN0  Push this on the stack as a return address
 PUSH B
*
 LXI H,CHTBL  Point to the lookup table
*
LOOK1 CMP M  Is this the character?
*
 MOV B,M  Save the table character
*
 INX H  Get a jump address before acting
 MOV E,M
 INX H
 MOV D,M
*
 JZ LOOK2  Finally, Yes! go to the routine
*
*----------------------------------------*
*  Not this time, check for end of table *
*----------------------------------------*
*
 MOV C,A  Are we at the table end?
 MOV A,B
 ORA A
 MOV A,C
 JM CNVRT  Yes, so input must be changing a memory byte
*
 MOV A,C  Get the input character back
*
 INX H  Keep looping
 JMP LOOK1
*
*----------------------------------------*
*  We know the routine address, jump!    *
*----------------------------------------*
*
LOOK2 XCHG .  Clean up the registers
 PCHL .  Now, execute the routine
*
*----------------------------------------*
*  Convert the input to usable binary    *
*  and store it in the proper place.     *
*----------------------------------------*
*
CNVRT LHLD SCRPNT
*
 MOV B,A  Save the character
 LDA HXASC  Are we in the hex mode?
 ORA A
 MOV A,B
 JM CNVR3  Minus says no
*
*----------------------------------------*
*  The hex mode with "window" input.     *
*----------------------------------------*
*
 CALL CKHEX  Check and see if character is legal hex
 RC .  Return now if not
*
CNVR2 PUSH PSW  Save the character
*
 INX H  Create a "window" effect
 MOV A,M  Move the right cursor byte left one byte
 DCX H
 MOV M,A  All done
*
 POP PSW  Now, put the new byte in the others old place
 ORI 80H  Inverse it first though
*
 INX H  Put it to the screen
 MOV M,A
 DCX H  Adjust for binary conversion
*
 CALL BINARY  Convert the cursor byte for us
 LHLD MEMPNT
 MOV M,B  Now, save it in memory
*
 LDA CURCHK  Is it time to move the cursor?
 INR A  Increment the digit counter
 ANI 1  If it is greater than one (i.e. two) then move it
 STA CURCHK
 JZ ADVCUR  Go move it if necessary
*
 RET .
*
*----------------------------------------*
*  ASCII mode with minus input allowed.  *
*----------------------------------------*
*
CNVR3 CPI 20H  We don't want CTRL characters
 RC .
*
 MOV B,A  Save the character
*
 INX H  Now, check for minus input
 MOV A,M  Get the old character
 ANI 7FH  Clean it up
 CPI '-'  Is it a minus?
 DCX H
 MOV A,B  If so, then "window" the minus sign
 JZ CNVR2
*
CNVR4 INX H  If not, then clear the display
 MVI M,0A0H  This does it
 DCX H  Now, "window" nothing
*
 CPI '-'  Minus input is special
 JZ CNVR2
*
 PUSH PSW
 LDA CURCHK  In the ASCII mode, only one letter allowed
 ORA A  before advancing the cursor
 JNZ CNVR2+1  The exception is minus ("-") input,
 INR A  then two characters are allowed
 STA CURCHK
*
 JMP CNVR2+1
*
*----------------------------------------*
*  Change ASCII to HEX and vice versa.   *
*----------------------------------------*
*
RASHX LDA HXASC  Change the mode
 CMA .
 STA HXASC
*
 LHLD MEMLNE  Now, reprint the screen
 XCHG .
*
 JMP PRVDM  Print the new screenful of data
*
*----------------------------------------*
*  All necessary scroll routines.        *
*----------------------------------------*
*
*  Scroll up one line on the screen.
*
RSUOL LXI B,16  Scroll forward 16 bytes
 MVI A,1  Do it one time
 JMP SCROLL
*
*  Scroll down one line on the screen.
*
RSDOL LXI B,-16  Scroll backwards 16 bytes
 JMP RSUOL+3
*
*  Scroll down one full screen
*
RSDS LXI B,-16  Scroll backwards 16 bytes
 MVI A,16  Do it 16 times
 JMP SCROLL
*
*  Scroll up one full screen.
*
RSUS LXI B,16  Scroll forward 16 bytes
 JMP RSDS+3
*
*----------------------------------------*
*  Home the cursor on the screen.        *
*----------------------------------------*
*
RCULC LHLD SCRPNT  Erase the cursor
 CALL CURSW
*
 LXI H,SCREEN+7  Initialize the screen pointer
 SHLD SCRPNT
*
 LHLD MEMLNE  Re-initialize the memory pointer
 SHLD MEMPNT
*
 RET .
*
*----------------------------------------*
*  Put cursor at beginning of next line. *
*----------------------------------------*
*
RCBNL CALL RCEOL  Erase the cursor
 JMP ADVCUR
*
*----------------------------------------*
*  Move cursor to the end of the line    *
*----------------------------------------*
*
RCEOL LHLD SCRPNT  Erase the cursor
 CALL CURSW
*
 MOV A,L  Ajust the screen pointer
 ANI 0C0H
 ORI 7
 MOV L,A
 SHLD SCRPNT  Save it for later
 CALL CURSW
*
 LHLD MEMPNT  Now, adjust the memory pointer
 MOV A,L
 ANI 0F0H  This does it properly
 MOV L,A
 SHLD MEMPNT  Save this also
*
 CALL RCLFT  Move everything down a line now
*
 RET .
*
*----------------------------------------*
*  Insert one NOP into the file.         *
*----------------------------------------*
*
RINSRT LDA INMDE  Is the insert mode on?
 ORA A
 RZ .  Say bye if not
*
 LHLD SCRPNT  Turn off the cursor
 CALL CURSW
*
 LHLD BFFNS  Get the end of the file address
 XCHG .
 LHLD MEMPNT  Get the cursor location
*
 PUSH H  Are we at the end of the file?
 PUSH D
 INX D
 LHLD FREE  If the buffer end exceeds the highest
 DCX H  available memory location, then cannot insert
 CALL SBTRCT
 MOV A,H
 POP D
 POP H
 ORA A
 JP RINS1  Everything is okay, insert the NOP
*
 CALL CLEAR  Go print the error message
 LXI H,BUFUL
 JMP SBBDER+3
*
RINS1 PUSH D  Save these pointers
 PUSH H
 MOV B,H  Destination of block move is HL+1
 MOV C,L
 INX B  Add the one
 CALL MOVE  Move the block
*
 POP H  Get back the pointers
 POP D
*
 MVI M,0  Put the NOP in place
 INX D  Add one to the end address
*
 LXI H,0  Disallow use of the "RE" subcommand
 SHLD LSTEND
*
 XCHG .
 SHLD BFFNS  Save the value
*
 JMP SBEN1  Go reprint the screen
*
*  The error message
*
BUFUL ASCZ "No room for insert"
*
*----------------------------------------*
*  Delete on byte from the file.         *
*----------------------------------------*
*
RDELT LDA DEMDE  Is the delete mode on?
 ORA A
 RZ .  Leave if not
*
 LHLD SCRPNT  Turn off the cursor
 CALL CURSW
*
 LHLD BFFNS  Get the current end of file location
 XCHG .
*
 LHLD MEMPNT  Is the current location the last byte of the file?
 XCHG .
 INX D
 PUSH H
 CALL BFEND  Go check it out
 POP H
 DCX D
 JC INIT1  Exit if so
 XCHG .
*
 MOV B,H  BC has destination address of block move
 MOV C,L
 INX H
*
 PUSH D  Go move the block
 CALL MOVE
 POP D
 CALL BFBEG
 JNC INIT1
*
 XCHG .
 DCX H  Save the new end address
 SHLD BFFNS
*
 JMP SBEN1  Go reprint the screen
*
*----------------------------------------*
*  Advance the cursor one byte.          *
*----------------------------------------*
*
ADVCUR CALL RCRGT  Move the cursor right one byte
*
 LHLD SCRPNT  Has it wrapped around?
 MOV A,L  Check it
 ANI 3FH
 CPI 7
 RNZ .  Return now if not
*
 MOV A,L  Yes, move the cursor down a line now
 CPI 0C7H  Is it at the bottom of the screen?
 JNZ RCDWN  If not, then exit with the cursor-down movement
*
 MOV A,H  Otherwise, scroll one line
 CPI <SCREEN+300H
 JNZ RCDWN  No, don't scroll yet
*
 JMP RSUOL  Yes, scroll now
*
*----------------------------------------*
*  Position the cursor on the byte       *
*  pointed to by HL.  The line contain-  *
*  the byte will be on the top line.     *
*----------------------------------------*
*
POSCUR SHLD MEMPNT  Save the memory pointer
*
 MOV A,L  Save the memory line value
 PUSH PSW  It must in the form of HHH0,
 ANI 0F0H  so make the last nibble zero
 MOV L,A
 SHLD MEMLNE  And save the value
 POP PSW
*
 ANI 0FH  Now, position the cursor over the proper byte
 LXI H,SCREEN+7  Determine where it is on the screen
 LXI D,3
*
PSCR SHLD SCRPNT  Do it now
 DCR A
 JM INIT1  Exit when done
 DAD D
 JMP PSCR  Keep looping
*
*
*----------------------------------------*
* Write file to disk; return to PTDOS    *
*----------------------------------------*
*
REXIT CALL CLEAR  Wipe out the screen
*
*
 CALL LNGTH  Calculate the file length
*
 LXI H,SGNOFF  Print the sign off message
 CALL LNEOUT
 LHLD OUTFIL
 CALL LNEOUT
 LXI H,QUESTN
 CALL LNEOUT
*
 CALL INPUT  Verify signing off
 ANI 5FH  Convert to upper case
 CPI 'Y'
 JNZ INIT1  Ignore request if the answer is not "Yes"
*
*----------------------------------------*
*  Rewind the output file before writing *
*----------------------------------------*
*
WRITE CALL OUTPUT  Send out the answer for looks
 LDA FILEN  Rewind the file pointer
 LXI D,0
 CALL SYS
 DB SPAOP
 JMP ERROR  If something is wrong, say so
*
*----------------------------------------*
*  Write the buffer out to the file.     *
*----------------------------------------*
*
 LDA FILEN  Get the file number
*
 LHLD FLNGTH  Get the buffer length
 MOV B,H  Put it in BC
 MOV C,L
*
 LHLD BFSTT  Get the buffer start address
 XCHG .
 CALL SYS  Go write it out
 DB WBLOP
 JMP ERROR  Report any errors
*
 LDA FILEN  End-file the file
 CALL SYS
 DB EOFOP
 JMP ERROR
 JMP RABT1+3  Go close the file and abort
*
*
*----------------------------------------*
*  Abort the edit mode; return to PTDOS  *
*----------------------------------------*
*
RABRT CALL CLEAR  Wipe the screen
*
*
 LXI H,ABORT  Print the abort verify message
 CALL LNEOUT
*
 CALL INPUT  Wait for verification
 ANI 5FH  Convert to upper case
 CPI 'Y'
 JNZ INIT1  No, he doesn't want to abort, ignore request
*
RABT1 CALL OUTPUT  Put out the answer
 CALL CLOSE  Go close the file
*
*
 CALL SYS  To a PTDOS system reset
 DB RETOP
*
*----------------------------------------*
*  Cursor up, down, left, right routines.*
*----------------------------------------*
*
RCUP LXI B,-16  Move the cursor up one line
 MVI E,<SCREEN+300H
 MVI D,4
 JMP CURMV
*
RCDWN LXI B,16  Move the cursor down one line
 MVI E,<SCREEN
 JMP RCUP+5
*
RCLFT LXI B,-1  Move the cursor left one byte
 MVI E,34H
 JMP RCRGT+5
*
RCRGT LXI B,1  Move the cursor right one byte
 MVI E,7
 MVI D,3
*
*----------------------------------------*
*  CURMV moves the cursor properly and   *
*  also adjusts the memory pointer.      *
*                                        *
*  On Entry:  BC = offset (-16=u,16=d)   *
*                         ( -1=l, 1=r)   *
*             D  = # times to add offset *
*             E  = correction value      *
*                                        *
*----------------------------------------*
*
CURMV LHLD SCRPNT  Erase the cursor
 CALL CURSW
*
CRMV0 MOV A,D  Now, move up or down
 DAD B
 DCR A
 JNZ CRMV0+1  Add the offset "D" times
*
 MOV A,H  Are we out of range? (top or bottom)
 CPI <SCREEN-100H
 JZ CRMV1
 CPI <SCREEN+400H
 JNZ CRMV2  No, we are okay
*
CRMV1 MOV H,E  Put in the new high byte
*
 PUSH B
 PUSH H  Now, we must adjust the memory pointer
 CALL COMPB  Oops, we must correct the problem
 MVI A,16
 LHLD MEMPNT  Add the two's complement 16 times to the pointer
CRLP DAD B
 DCR A
 JNZ CRLP  Loop until done
 SHLD MEMPNT  Now, save the value
 POP H
 POP B
*
* All done with the corrections
*
CRMV2 MOV A,L  Are we out of range? (left or right edge)
 ANI 3FH
 CPI 7
 JC CRMV3
 CPI 35H
 JC CRMV4  No, we are okay
*
*  Adjust all the pointers correctly
*
CRMV3 MOV A,L  Fix the screen pointer
 ANI 0C0H
 ORA E
 MOV L,A  This does it
 JMP CRMV1+1
*
CRMV4 PUSH H
 LHLD MEMPNT  Do it now
 DAD B
 SHLD MEMPNT  Save it again
*
 PUSH D
 XCHG .
 CALL BFEND  Over end of buffer?
 POP D
 POP H
 JC CRMV0  Loop back if so
*
 SHLD SCRPNT
 RET .
*
*----------------------------------------*
*  RSRCH searches the buffer for a match *
*  of a string of data entered by the    *
*  user.  If it is an ASCII character,   *
*  toggling to the hex mode will find    *
*  it if the high bit is set. A Wildcard *
*  will match any byte in the hex mode   *
*----------------------------------------*
*
RSRCH CALL CLEAR  Clear the screen
 MVI A,CHCR  Return the cursor to column one
 CALL OUTPUT
*
 LXI H,WILDB  Point to wild card buffer
 MVI B,7FH
WBZ MVI M,0  Zero it out
 INX H
 DCR B
 JNZ WBZ
*
 CALL SRSET  Get prompt letter
 CALL OUTPUT  Send out the letter
*
 MVI A,':'  Now, put out the colon
 CALL OUTPUT
 CALL GETLN  Get the input line
*
 MVI A,CHCR  Put out a C/R to show string acceptance
 CALL OUTPUT
*
 LXI H,BUFFER  Start search at beginning of buffer
 SHLD SCHLOC
*
 LDA HXASC  If in ASCII mode, no conversion needed
 ORA A
 JNZ RCSR0  Go start searching
*
*----------------------------------------*
*  Convert the ASCII hex in the buffer   *
*  to binary and store it for searching. *
*  Put a copy in the wild card buffer    *
*----------------------------------------*
*
 LXI H,LINE  Point to the ASCII hex
 LXI D,LINE  Show where to put the converted value
RSR1 CALL SKPBLK  Skip over blanks
 JZ RSR2  If last character is a C/R, then abort
 INR D  Point DE to wild card buffer
 STAX D  Store a copy of line
 DCR D  Put DE back
 CALL BNYHEX  Convert the value
 CPI CHCR  Is the last character a C/R?
 MOV A,B  Let's save the byte before deciding
 STAX D
 INX D  Adjust the pointer also
 JNZ RSR1  No, we're not done yet
*
RSR2 MVI A,CHCR  Poke in the carriage return
 STAX D
 INX D
*
 XCHG .  All done, save the last location
 SHLD ENDLNE
 JMP RCSR0
*
*----------------------------------------*
*  RCSRCH -- continue search routine.    *
*----------------------------------------*
*
RCSRCH LHLD SCRPNT  Erase the cursor
 CALL CURSW
*
RCSR0 LHLD ENDLNE  Get the last address of string
 LXI D,LINE  Point to the beginning
 PUSH D
 CALL SBTRCT  Subtract the latter from the former...
 POP D
 MOV B,L  To get the length of the string
*
 MOV A,L  If the length is zero,
 ORA A  Send out an error message
 JZ STNEER
*
 CALL SRSET  Set search mode data
*
 LHLD SCHLOC  Get search address
*
RCSR1 PUSH D  Are we at the end of the buffer?
 PUSH H
 XCHG .
 LHLD BFFNS  Get the end address for checking
 CALL SBTRCT  Subtract the pointer from the end address
 MOV A,H  If the answer is zero, then all done
 POP H  Get the pointer back in case it's not
 POP D
 ORA A  If the answer is negative, then no string
 JM STNFER  Abort if so
*
 CALL COMPS  Otherwise, go compare the strings
*
 INX H  Set up for next byte to check
 SHLD SCHLOC
 JNZ RCSR1  Loop back if the strings are unequal
*
 DCX H  Subtract for the increment above
RCSR2 EQU $  Go paint the screen
 JMP POSCUR  With the cursor over the byte
*
SRSET LDA HXASC  Get the mode flag
 ORA A  Check it
 MVI A,0FFH  Move in hex stripper
 STA SRMOD  Store it
 MVI A,'H'  Move in prompt
 RZ .  If it is zero its hex
 MVI A,7FH  Must be Ascii
 STA SRMOD  Store it
 MVI A,'A'  Now the prompt
 RET
*
*----------------------------------------*
*  String search/continue error routines *
*----------------------------------------*
*
STNEER CALL CLEAR
 LXI H,STGNEN  String not entered error
 JMP SBBDER+3
*
STNFER CALL CLEAR
 LXI H,STGNF  String not found error
 CALL LNEOUT
 LXI H,CRCNT  C/R to continue message
 CALL LNEOUT
*
STNF1 CALL INPUT  Wait for the carriage return
 CPI CHCR
 JNZ STNF1
 JMP INIT
*