;======================================================================
; ENVEDIT 1.00 * Copyright (c) 1992, Robert L. Hummel
; PC Magazine Assembly Language Lab Notes
;
; ENVEDIT -- an editor that allows changes to be made to the DOS master
; environment interactively.
;======================================================================
CSEG		SEGMENT	PARA	PUBLIC	'CODE'
	ASSUME	CS:CSEG, DS:CSEG, ES:CSEG, SS:CSEG
		ORG	100H			;Starting offset

ENTPT:		JMP	MAIN			;Jump over data
;----------------------------------------------------------------------
; Some common equates.
;----------------------------------------------------------------------
CR		EQU	13			;Common equates
LF		EQU	10

INSKEY		EQU	52H			;Extended ASCII values
DEL		EQU	53H
F7KEY		EQU	41H
F9KEY		EQU	43H
HOME		EQU	47H
ENDKEY		EQU	4FH
RARROW		EQU	4DH
LARROW		EQU	4BH
UARROW		EQU	48H
DARROW		EQU	50H
BS		EQU	0E08H			;Scan/Ascii code
;----------------------------------------------------------------------
; Text messages.
;----------------------------------------------------------------------
COPYRIGHT$	DB	CR,"ENVEDIT 1.00 ",254," Copyright (c) 1992,"
		DB	" Robert L. Hummel",CR,LF
		DB	"PC Magazine Assembly Language Lab Notes"
		DB	CR,LF,"$"

NOENV$		DB	"Can't Find The Environment",LF,"$"
MEMSIZ$		DB	"Not Enough Memory",LF,"$"
MEMERR$		DB	"Error Allocating Memory",LF,"$"
BADMODE$	DB	"Can't Use This Video Mode",LF,"$"
SAVE$		DB	"Save Changes? (Y/N) $"
;----------------------------------------------------------------------
; Video parameters.
;----------------------------------------------------------------------
NUM_COLS	DB	0			;Number cols on screen
COL_MAX		DB	0			;Rightmost column
VPAGE		DB	0			;Active page

ATTR		DB	1FH			;Default is color
BW_ATTR		EQU	07H			;May switch to mono
;----------------------------------------------------------------------
; Environment parameters.
;----------------------------------------------------------------------
ENV_SEG		DW	0			;Segment of master env
STR_COUNT	DW	0			;Number strings in Env
ENV_FREE	DW	0			;Free space in bytes
ENV_USED	DW	0			;Len of strings in Env
STR_LEN		DW	0			;Len of current str

;======================================================================
; MAIN (Near)
;
; This procedure invokes the subroutines and defines program operation.
;----------------------------------------------------------------------
MAIN		PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:CSEG, SS:CSEG

		CLD				;Default moves forward
;----------------------------------------------------------------------
; Editing requires that we be in a mode with at least 80 columns on
; the screen. If the mode isn't okay, terminate with an error.
;----------------------------------------------------------------------
		CALL	VIDEO_SETUP		;Examine video hardware
		JNC	M_0

		MOV	DX,OFFSET BADMODE$
		JMP	M_ERR
M_0:
;----------------------------------------------------------------------
; Relocate the stack downward in the segment. Then shrink the program's
; allocated memory to hold just the program code and the stack.
;----------------------------------------------------------------------
		CLI				;Disable interrupts
		MOV	SP,OFFSET STACK_TOP	; and Re-position stack
		STI				;Allow interrupts

		MOV	AH,4AH			;Modify memory block
		MOV	BX,(OFFSET STACK_TOP - CSEG + 15) SHR 4
		INT	21H			; Thru DOS
		JNC	M_1

		MOV	DX,OFFSET MEMERR$	;Unspecified error
		JMP	M_ERR
M_1:
;----------------------------------------------------------------------
; Locate the master environment. By our definition, the master
; environment is the environment owned by the first copy of COMMAND.
; Note: if a new, permanent copy of COMMAND has been loaded with /P,
; this technique won't work.
;----------------------------------------------------------------------
		MOV	AH,52H			;Undocumented function
		INT	21H			; returns ES:BX
	ASSUME	ES:NOTHING

		MOV	AX,ES:[BX-2]		;First MCB block adr
;----------------------------------------------------------------------
; Find the first PSP block in the chain that claims to be its own
; parent. Subject to disclaimer, this is the first copy of COMMAND.
;----------------------------------------------------------------------
M_2A:
		MOV	ES,AX			;Address MCB
	ASSUME	ES:NOTHING
		INC	AX			;Address of PSP

		CMP	AX,ES:[1]		;MCB = owner?
		JNE	M_2B
;----------------------------------------------------------------------
; This block owns itself, and so is a PSP.
; If it is also its own parent, we have the first copy of COMMAND.
;----------------------------------------------------------------------
		CMP	AX,ES:[16H+10H]		;Parent = MCB?
		JE	M_2D
;----------------------------------------------------------------------
; Didn't own itself. Move to the next block.
;----------------------------------------------------------------------
M_2B:
		CMP	BYTE PTR ES:[0],"Z"	;Is this last block?
		JE	M_2C

		ADD	AX,ES:[3]		;Go to next block
		JMP	M_2A
M_2C:
		MOV	DX,OFFSET NOENV$	;Couldn't find it
		JMP	SHORT M_ERR
M_2D:
;----------------------------------------------------------------------
; We have located the first copy of COMMAND. In DOS versions 3.30+, the
; word at PSP:2C contains the segment address of the env. In earlier
; versions, the environment point is 0; use the following MCB.
;----------------------------------------------------------------------
		MOV	CX,WORD PTR ES:[3CH]	;Get env segment
		JCXZ	M_3A			;If 0, use next MCB

		DEC	CX			;Point to env's MCB
		JMP	SHORT M_3B
M_3A:
		MOV	CX,AX			;Block adr +
		ADD	CX,ES:[3]		; length = next MCB
M_3B:
		MOV	ES,CX			;Put env's MCB in ES
	ASSUME	ES:NOTHING
;----------------------------------------------------------------------
; Verify that this block is owned by COMMAND's PSP.
;----------------------------------------------------------------------
		CMP	AX,ES:[1]		;Proper ownership?
		JNE	M_2C
;----------------------------------------------------------------------
; Now, CX = ES -> MCB of what we'll call the master environment.
; From the MCB, get the length (<32k) of the block, and save it.
;----------------------------------------------------------------------
		MOV	BX,CX			;Put MCB in BX
		MOV	AX,ES:[3]		;Get length in paras
		MOV	DX,AX			;(Save for later use)
		MOV	CL,4			; SHL 4 = *16
		SHL	AX,CL			; convert to bytes
		MOV	[ENV_FREE],AX		;Say its all free
;----------------------------------------------------------------------
; Now scan the entire environment and count the number of strings.
;----------------------------------------------------------------------
		INC	BX			;Point to env adr
		MOV	[ENV_SEG],BX		;Save for update/exit

		MOV	DS,BX			;Point ES and DS
	ASSUME	DS:NOTHING
		MOV	ES,BX			; to Master env
	ASSUME	ES:NOTHING
;----------------------------------------------------------------------
; Initialize the counter and the pointer. Jump to middle of loop.
;----------------------------------------------------------------------
		SUB	DI,DI			;DI = count of strings
		SUB	SI,SI			;SI = offset into env
;----------------------------------------------------------------------
; A zero byte indicates the end of a string.
;----------------------------------------------------------------------
M_4A:
		LODSB				;Get a char
		OR	AL,AL			;If not 0, scan again
		JNZ	M_4A

		INC	DI			;Increase string count
;----------------------------------------------------------------------
; If a double-zero, that was the last string.
;----------------------------------------------------------------------
M_4B:
		LODSB				;Get char
		OR	AL,AL			;If not 0, keep going
		JNZ	M_4A
;----------------------------------------------------------------------
; Save the string count and calculate space used and free.
;----------------------------------------------------------------------
		PUSH	CS			;Point DS to CSEG
		POP	DS
	ASSUME	DS:CSEG

		DEC	DI			;Make count 0-based

		MOV	[STR_COUNT],DI		;  0 = 1 empty string
		MOV	[ENV_USED],SI		;  1 = empty
		SUB	[ENV_FREE],SI		;    = amount left
;----------------------------------------------------------------------
; Allocate a block of memory large enough to hold a full copy of this
; environment.
;----------------------------------------------------------------------
		MOV	BX,DX			;Get back size in paras
		MOV	DX,OFFSET MEMSIZ$	;Assume an error

		MOV	AH,48H			;Allocate memory fn
		INT	21H			; Thru DOS
		JNC	M_5
;----------------------------------------------------------------------
; Common exit to display an error message.
;----------------------------------------------------------------------
M_ERR:
		MOV	AH,9			;Display string
		INT	21H			; Thru DOS
;----------------------------------------------------------------------
; Common exit.
;----------------------------------------------------------------------
M_EXIT:
		MOV	DX,OFFSET COPYRIGHT$	;Say who we are
		MOV	AH,9			;Display string fn
		INT	21H			; Thru DOS

		MOV	AH,4CH			;Terminate
		INT	21H			; Thru DOS
;----------------------------------------------------------------------
; Make a scratch copy of this environment.  Move from DS:SI to ES:DI.
;----------------------------------------------------------------------
M_5:
		MOV	CX,[ENV_USED]		;Move just strings

		SUB	SI,SI			;From DS:SI
		PUSH	ES
		POP	DS
	ASSUME	DS:NOTHING

		SUB	DI,DI			;To ES:DI
		MOV	ES,AX
	ASSUME	ES:NOTHING

		REP	MOVSB			;Transfer

		PUSH	CS			;Restore segment
		POP	DS
	ASSUME	DS:CSEG
;----------------------------------------------------------------------
; Draw the edit window.
;----------------------------------------------------------------------
		CALL	CLR_BOX			;Draw the window
;----------------------------------------------------------------------
; Invoke the string editor.  Returns when F7 is pressed.
;----------------------------------------------------------------------
		CALL	EDIT			;String editor
;----------------------------------------------------------------------
; Ask if changes should be copied to the environment.
;----------------------------------------------------------------------
		MOV	BYTE PTR [CURSOR_COL],0	   ;Reposition cursor
		MOV	BYTE PTR [CURSOR_ROW],NROW ; for message
		CALL	CUR_SET

		MOV	DX,OFFSET SAVE$		;Clone the changes?
		MOV	AH,9			;Display string fn
		INT	21H			; Thru DOS
M_6:
		MOV	AH,8			;Get a key
		INT	21H			; Thru DOS
		AND	AL,NOT 20H		;Capitalize it

		CMP	AL,"N"			;If No...
		JE	M_7

		CMP	AL,"Y"			;If not Yes, try again
		JNE	M_6
;----------------------------------------------------------------------
; Copy the strings down to the master block.  DS:SI TO ED:DI
;----------------------------------------------------------------------
		MOV	CX,[ENV_USED]		;New length of block

		SUB	SI,SI
		PUSH	ES			;Point DS:SI to copy
		POP	DS
	ASSUME	DS:NOTHING

		SUB	DI,DI
		MOV	AX,[ENV_SEG]		;ES:DI to master
		MOV	ES,AX
	ASSUME	ES:NOTHING

		REP	MOVSB			;Transfer

		PUSH	CS			;Restore segment
		POP	DS
	ASSUME	DS:CSEG
;----------------------------------------------------------------------
; Exit the program.
;----------------------------------------------------------------------
M_7:
		JMP	M_EXIT

MAIN		ENDP

;======================================================================
; VIDEO_SETUP (Near)
;
; This procedure ensures that the number of columns on the screen is 80
; or greater and gets the current video page. It also adjusts the
; screen attribute for monochrome screens. It will allow the program to
; run in graphics mode, but won't guarantee a pretty screen. Return
; with carry set if display is in an incompatible mode.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC = Video mode is okay
;	CY = Can't use this video mode
;----------------------------------------------------------------------
; Changes: AX BX DX
;----------------------------------------------------------------------
VIDEO_SETUP	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

;----------------------------------------------------------------------
; The Get Video Mode function returns the number of columns (not the
; max col number) on screen in AH. We require at least 80 characters.
;----------------------------------------------------------------------
		MOV	AH,0FH			;Get video mode
		INT	10H			; Thru BIOS

		CMP	AH,80			;Enough columns?
		JAE	VS_1
;----------------------------------------------------------------------
; Note: We get here if AH is below 80; the carry flag is set by CMP.
;----------------------------------------------------------------------
		JMP	SHORT VS_EXIT
;----------------------------------------------------------------------
; Save the number of columns and the active video page.
; Change the display attribute for monochrome display modes.
;----------------------------------------------------------------------
VS_1:
		MOV	[VPAGE],BH		;Save current page
		MOV	[NUM_COLS],AH		;Save cols
		SUB	AH,(2+1)		;Indent 2 (1-based)
		MOV	[COL_MAX],AH		;Is rightmost column

		CMP	AL,7			;Normal mono
		JE	VS_2
		CMP	AL,15			;EGA mono
		JNE	VS_3
VS_2:
		MOV	[ATTR],BW_ATTR		;Assume mono
VS_3:
		CLC				;Indicate success
VS_EXIT:
		RET

VIDEO_SETUP	ENDP

;======================================================================
; CLR_BOX (Near)
;
; Clear a window (box) for our information on the screen.
; Add a border for a nice touch.
;----------------------------------------------------------------------
; Entry: None
; Exit:  None
;----------------------------------------------------------------------
; Changes: AX BX CX DX SI
;----------------------------------------------------------------------
TITLEZ		DB	181,"ENVEDIT 1.00",198,0
TITLE_LEN	EQU	$-TITLEZ

HELPZ		DB	"STRING: ",27,32,26," INS DEL ",24,32,25
		DB	"  F7 = Exit/Save  F9=Add String",0

BOX_CHARS	DB	201,205,187	;Describes left, middle, and
		DB	186, 32,186	; right chars for each row
		DB	199,196,182
		DB	186, 32,186
		DB	199,196,182
		DB	186, 32,186
		DB	200,205,188
NROW		EQU	($-OFFSET BOX_CHARS)/3	;Number of rows

CLR_BOX		PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
;----------------------------------------------------------------------
; Clear the box area to set the attribute for the characters.
;----------------------------------------------------------------------
		MOV	AX,0700H		;Scroll window fn
		MOV	BH,[ATTR]		; clear to this color
		SUB	CX,CX			;Start row,col

		MOV	DH,NROW+3		;3 lines below box
		MOV	DL,[NUM_COLS]		;Max column
		DEC	DL
		INT	10H			;Thru BIOS
;----------------------------------------------------------------------
; Draw the edit window row by row.
;----------------------------------------------------------------------
		MOV	BH,[VPAGE]		;Get active page
		MOV	SI,OFFSET BOX_CHARS	;Edit window chars
		MOV	CX,NROW			;Number of rows to draw
		SUB	DH,DH			;Starting row
CB_1:
		PUSH	CX			;Save counter

		SUB	DL,DL			;Column=0
		MOV	AH,2			;Mov to DH,DL
		INT	10H			; Thru BIOS

		LODSB				;Get leftmost char
		MOV	AH,0EH			;Write char TTY
		INT	10H			; Thru BIOS

		LODSB				;Get middle char
		MOV	AH,0AH			;Write repeated char
		MOV	CL,[NUM_COLS]		;Width of box
		SUB	CH,CH			; into CX
		DEC	CX			;Minus left side
		DEC	CX			;Minus right side
		INT	10H			; Thru BIOS

		MOV	AH,2			;Position cursor
		MOV	DL,[NUM_COLS]		; to far right
		DEC	DL			; column
		INT	10H			; Thru BIOS

		LODSB				;Get rightmost char
		MOV	AH,0AH			;Write char
		MOV	CX,1			;1 copy
		INT	10H			; Thru BIOS

		INC	DH			;Next row
		POP	CX			;Restore counter
		LOOP	CB_1
;----------------------------------------------------------------------
; Embed the program name and version in the border.
;----------------------------------------------------------------------
		SUB	BH,BH
		MOV	BL,[COL_MAX]		;Rightmost column
		SUB	BL,TITLE_LEN+2		;Backup
		MOV	SI,OFFSET TITLEZ	;Program name
		CALL	WRITE_MSG
;----------------------------------------------------------------------
; Display the help prompts.
;----------------------------------------------------------------------
		MOV	BX,0102H		;Row/col
		MOV	SI,OFFSET HELPZ		;Instructions
		CALL	WRITE_MSG

		RET

CLR_BOX		ENDP

;======================================================================
; WRITE_MSG (Near)
;
; Write an ASCIIZ string to the screen at the indicated row and column.
;----------------------------------------------------------------------
; Entry:
;	BH = screen row
;	BL = screen column
;	DS:SI = Offset of ASCII string to display
;----------------------------------------------------------------------
; Changes: AX BX
;----------------------------------------------------------------------
WRITE_MSG	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		XCHG	BX,[CURSOR_POS]		;Set requested position
		PUSH	BX			;Save old one
		CALL	CUR_SET			;Position cursor
WM_1:
		MOV	BH,[VPAGE]
		LODSB
		OR	AL,AL
		JZ	WM_2

		MOV	AH,0EH
		INT	10H
		JMP	WM_1
WM_2:
		POP	[CURSOR_POS]		;Restore prev cursor
		CALL	CUR_SET

		RET

WRITE_MSG	ENDP

;======================================================================
; EDIT (Near)
;
; The EDIT procedure handles all the editing. It keeps track of the
; environment strings and displays them on the screen as they change.
;----------------------------------------------------------------------
; Changes:
;----------------------------------------------------------------------
STR_NUMBER	DW	0			;Number of env string
STR_START	DW	0			; and offset into seg

STR_LEFT	DW	0			;Offset leftmost char
						; displayed on screen
CURSOR_POS	LABEL	WORD
CURSOR_COL	DB	0			;Current cursor
CURSOR_ROW	DB	0			; position on screen

INS_STATE	DB	0			;0=INS FF=TYPEOVER

FAR_LEFT	EQU	2			;Leftmost column
DISPLAY_ROW	EQU	5			;Strings appear here

EDIT		PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
;----------------------------------------------------------------------
; Initialize the pointer to point to the current string.
; Display the selected string on the screen as read from memory.
;----------------------------------------------------------------------
		MOV	[STR_NUMBER],0			;First string
		MOV	[CURSOR_ROW],DISPLAY_ROW	; goes here
;----------------------------------------------------------------------
; If environment is empty,insert an empty string to work on.
;----------------------------------------------------------------------
EDIT_1A:
		CMP	[STR_COUNT],-1		;-1=no strings
		JNE	EDIT_1B
		CALL	ADD_STRING		;Add an empty string
EDIT_1B:
		CALL	GET_START		;Point to it
		MOV	[CURSOR_COL],FAR_LEFT	;Init cursor
		CALL	UPDATE
;----------------------------------------------------------------------
; Display the current string in the window.
;----------------------------------------------------------------------
EDIT_2:
        CALL    DISPLAYX        ;Show the string
;----------------------------------------------------------------------
;  Get a key from the keyboard and act on it.
;----------------------------------------------------------------------
EDIT_3A:
		SUB	AH,AH			;Fetch a key
		INT	16H			; Thru BIOS

		OR	AL,AL			;If AL=0, is extended
		JZ	EDIT_5A			; which means command

		CMP	AX,BS			;If not actual BS key
		JNE	EDIT_4A			;Process as char
;----------------------------------------------------------------------
;  The backspace key is the only key that requires special handling.
;  Treat BS as a CURSOR-LEFT/DELETE combination.
;----------------------------------------------------------------------
		CALL	CURSOR_LEFT
		JC	EDIT_3A
EDIT_3B:
		CALL	STRING_DEL		;Delete char at cursor
		JC	EDIT_3A
		JMP	EDIT_2
;----------------------------------------------------------------------
; Put the character on the screen and in the string.
;----------------------------------------------------------------------
EDIT_4A:
		CMP	[INS_STATE],0		;If insert
		JE	EDIT_4B			; jump
;----------------------------------------------------------------------
; If we're at the end of the string, typeover works just like insert.
;----------------------------------------------------------------------
		CALL	LOCATE_SI		;If char isn't 0
		CMP	BYTE PTR ES:[SI],0	; goto overwrite
		JNZ	EDIT_4C
;----------------------------------------------------------------------
; Move chars to the right, add the new character.
;----------------------------------------------------------------------
EDIT_4B:
		CALL	STRING_INS		;Create hole at cursor
		JC	EDIT_3A
EDIT_4C:
		CALL	LOCATE_SI		;Point to cursor loc
		MOV	ES:[SI],AL		; and pop in char
        CALL    DISPLAYX        ;Show changes
;----------------------------------------------------------------------
; -> Move the cursor to the right one space.
;----------------------------------------------------------------------
EDIT_4D:
		CALL	CURSOR_RIGHT		;Move cursor along
		JMP	EDIT_3A
;----------------------------------------------------------------------
; Key is an extended key.  Must be an instruction.
;----------------------------------------------------------------------
EDIT_5A:
		CMP	AH,F9KEY		;F9=make new string
		JNE	EDIT_5B

		CALL	PURGE_STR		;Del string if empty
		CALL	ADD_STRING		;Add an empty string
		JMP	EDIT_1B
EDIT_5B:
		CMP	AH,F7KEY		;F7 is the exit key
		JNE	EDIT_6

		CALL	PURGE_STR		;Del string if empty
		CMP	[STR_COUNT],-1		;Env totally empty?
		JNE	EDIT_5C

		CALL	ADD_STRING		;Min is one empty str
EDIT_5C:
		RET				; and the only way out
;----------------------------------------------------------------------
;  All remaining key dispatch done from here.
;----------------------------------------------------------------------
EDIT_6:
		CMP	AH,DEL			;Kill char at cursor
		JE	EDIT_3B

		CMP	AH,RARROW		;Move right 1 char
		JE	EDIT_4D

		CMP	AH,LARROW		;Move left
		JE	EDIT_9A

		CMP	AH,UARROW		;Move up
		JE	EDIT_7A

		CMP	AH,DARROW		;Move down
		JE	EDIT_8A

		CMP	AH,INSKEY		;Use Insert mode
		JE	EDIT_10

		CMP	AH,ENDKEY		;Move to end of string
		JE	EDIT_11

		CMP	AH,HOME			;Move to start of str
		JE	EDIT_12

		JMP	EDIT_3A			;Didn't recognize it
;----------------------------------------------------------------------
;  ^:  Move to the previous string.
;----------------------------------------------------------------------
EDIT_7A:
		CALL	PURGE_STR		;Clean up empties
		DEC	[STR_NUMBER]
		JNS	EDIT_7C

		MOV	BX,[STR_COUNT]		; reset to end
EDIT_7B:
		MOV	[STR_NUMBER],BX		;Update pointer
EDIT_7C:
		CLC
		JMP	EDIT_1A			;Start over
;----------------------------------------------------------------------
;  v:  Move to the next string.
;----------------------------------------------------------------------
EDIT_8A:
		CALL	PURGE_STR		;Delete if empty
		MOV	BX,[STR_NUMBER]		;Get current string
		JC	EDIT_8B			;If del, don't adjust

		INC	BX			; otherwise go to next
EDIT_8B:
		CMP	BX,[STR_COUNT]		;Okay if in range
		JBE	EDIT_7B

		SUB	BX,BX			;Reset to zero
		JMP	EDIT_7B
;----------------------------------------------------------------------
;  <-  Move the cursor to the left one space.
;----------------------------------------------------------------------
EDIT_9A:
		CALL	CURSOR_LEFT		;Move cursor left
EDIT_9B:
		JMP	EDIT_3A			;Failed, ignore it
;----------------------------------------------------------------------
;  Toggle the insert/typeover state.
;----------------------------------------------------------------------
EDIT_10:
		NOT	[INS_STATE]		;Toggle the flag
		JMP	EDIT_3A
;----------------------------------------------------------------------
;  Move to end of string.
;----------------------------------------------------------------------
EDIT_11:
		CALL	CURSOR_RIGHT		;Move to the right
		JNC	EDIT_11			; as long as successful
		JMP	EDIT_3A
;----------------------------------------------------------------------
;  Move to start of string.
;----------------------------------------------------------------------
EDIT_12:
		CALL	CURSOR_LEFT		;Move to the left
		JNC	EDIT_12			; as long as successful
		JMP	EDIT_3A

EDIT		ENDP

;======================================================================
; UPDATE (Near)
;
; Update the string size and environment free numbers in the status
; line and display on the screen.
;----------------------------------------------------------------------
; Entry: None
; Exit:  None
;----------------------------------------------------------------------
; Changes: BX CX DX SI
;----------------------------------------------------------------------
STATUSZ		DB	"String Size: "
US_SIZE		DB	"00000   Env Free: "
US_FREE		DB	"00000",0

UPDATE		PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		MOV	SI,OFFSET US_SIZE+4	;Point to end of size
		MOV	BX,[STR_LEN]		;Length in bytes
		CALL	US_1			;Make denary/ASCII

		MOV	SI,OFFSET US_FREE+4	;Repeat for free bytes
		MOV	BX,[ENV_FREE]
;----------------------------------------------------------------------
; Get the string size and convert to an ASCII denary number.
;----------------------------------------------------------------------
US_1:
		PUSH	AX			;Preserve register

		MOV	AX,BX			;Size in AX
		MOV	BX,10			;Base is 10
		MOV	CX,5			;Digits to convert
US_2:
		SUB	DX,DX			;32-bit in DX:AX
		DIV	BX			;Remainder in DX
		ADD	DL,30H			;Make into ASCII
		MOV	[SI],DL			;Store in string
		DEC	SI			;Move to higher digit
		LOOP	US_2
;----------------------------------------------------------------------
; Display the static text in the size status line.
;----------------------------------------------------------------------
		MOV	BX,0302H		;Row/col
		MOV	SI,OFFSET STATUSZ	;Status line text
		CALL	WRITE_MSG		;Put on screen

		POP	AX			;Restore register
		RET

UPDATE		ENDP

;======================================================================
; DISPLAYX (Near)
;
; This procedure will write the active string to the screen from the
; current cursor position forward. It is called only when a char is
; added to the string, the window is pushed, or to show a new string.
;----------------------------------------------------------------------
; Entry: None
; Exit:  None
;----------------------------------------------------------------------
; Changes: AX BX CX SI
;----------------------------------------------------------------------
DISPLAYX    PROC    NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		CALL	CUR_SET			;Position the cursor
		CALL	LOCATE_SI		;Point SI to string

		MOV	CH,[CURSOR_COL]		;Cursor column
		MOV	CL,[COL_MAX]		;Rightmost column
;----------------------------------------------------------------------
; Read the string and display on the screen.
;----------------------------------------------------------------------
DISPLAY_0:
		LODS	BYTE PTR ES:[SI]	;Get string char
		OR	AL,AL			;0 = end of string
		JNZ	DISPLAY_1
;----------------------------------------------------------------------
; If at the end of the string, display a space, then keep looping until
; the entire line has been overwritten.
;----------------------------------------------------------------------
		DEC	SI			;Back up to zero
		MOV	AL,20H			;Display a space
;----------------------------------------------------------------------
; Write the char in AL to the screen.
;----------------------------------------------------------------------
DISPLAY_1:
		CALL	CUR_SET			;Position the cursor

		PUSH	CX			;Save cursor position

		MOV	AH,0AH			;Write Char in AL
		MOV	BH,[VPAGE]		; on active page
		MOV	CX,1			; 1 copy
		INT	10H			; Thru BIOS

		POP	CX			;Restore cursor pos

		INC	[CURSOR_COL]		;Move to next column

		CMP	CL,[CURSOR_COL]		;Is col <= end?
		JAE	DISPLAY_0		;Yes, continue
;----------------------------------------------------------------------
;  Past the end of the window - done with display.
;----------------------------------------------------------------------
		MOV	[CURSOR_COL],CH		;Return to old spot
		CALL	CUR_SET			; do it

		RET

DISPLAYX    ENDP

;======================================================================
; PURGE_STR (Near)
;
; Examine the current string. If it's an empty string, remove it from
; the environment. If not, change the environment variable to all CAPS.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC - string is valid
;	CY - string was empty and was deleted
;----------------------------------------------------------------------
; Changes: AX SI
;----------------------------------------------------------------------
PURGE_STR	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		MOV	SI,[STR_START]		;Point to start of str

		CMP	BYTE PTR ES:[SI],0	;Is first char 0?
		JNE	PS_0
;----------------------------------------------------------------------
; Remove the string from the environment.
;----------------------------------------------------------------------
		DEC	[STR_COUNT]		;Reduce string count
		CALL	CHAR_KILL		;Remove 0
		STC				;CY = str empty
		JMP	SHORT PS_EXIT
;----------------------------------------------------------------------
; Scan the string, capitalizing all chars to the left of the "=".
;----------------------------------------------------------------------
PS_0:
		MOV	AL,BYTE PTR ES:[SI]	;Is first char 0?

		CMP	AL,"="			;= ends scan
		JE	PS_2

		OR	AL,AL			;0 ends scan
		JZ	PS_2

		CMP	AL,"a"			;If lower case...
		JB	PS_1

		CMP	AL,"z"			;...alphabetic
		JA	PS_1

		AND	BYTE PTR ES:[SI],NOT(20H)	;Capitalize
PS_1:
		INC	SI			;Move to next char
		JMP	PS_0
PS_2:
		CLC				;Carry off
PS_EXIT:
		RET

PURGE_STR	ENDP

;======================================================================
; ADD_STRING (Near)
;
; Adds an empty string to the environment.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC - string added okay
;	CY - string not added, no room in environment
;----------------------------------------------------------------------
; Changes: AX SI
;----------------------------------------------------------------------
ADD_STRING	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		CALL	STRING_INS		;Add empty string
		JC	AS_EXIT

		MOV	[CURSOR_COL],FAR_LEFT	;Reposition cursor
		MOV	SI,[STR_START]		;Point to 1st char
		MOV	BYTE PTR ES:[SI],0	;Make it null
		INC	[STR_COUNT]		;Up string count
		CLC				;Success
AS_EXIT:
		RET

ADD_STRING	ENDP

;======================================================================
; GET_START (Near)
;
; Find the starting offset of the current string into the environment
; segment and the length of that string.
;----------------------------------------------------------------------
; Entry: None
; Exit:  None
;----------------------------------------------------------------------
; Changes: AX BX SI DI
;----------------------------------------------------------------------
GET_START	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		MOV	BX,[STR_NUMBER]		;String to look for

		SUB	SI,SI			;Start at offset zero
		SUB	DI,DI			;String counter
		JMP	SHORT GS_3
;----------------------------------------------------------------------
; Scan to the end of the string. Increment the count.
;----------------------------------------------------------------------
GS_1:
		LODS	BYTE PTR ES:[SI]	;Get char
		OR	AL,AL			;Scan for 0
		JNZ	GS_1
GS_2:
		INC	DI			;Increase string count
;----------------------------------------------------------------------
; If this is the string we're looking for, we're done.
;----------------------------------------------------------------------
GS_3:
		CMP	BX,DI			;Right string?
		JNE	GS_1
;----------------------------------------------------------------------
; Set edit pointers and count the length of the string.
;----------------------------------------------------------------------
		MOV	[STR_START],SI		;Save offset
		MOV	[STR_LEFT],SI

		SUB	DI,DI			;String length counter
GS_4:
		LODS	BYTE PTR ES:[SI]	;Get char
		INC	DI			;Count it
		OR	AL,AL			;It is 0?
		JNZ	GS_4

		DEC	DI			;Don't count the 0
		MOV	[STR_LEN],DI

		RET

GET_START	ENDP

;======================================================================
; LOCATE_SI (Near)
;
; Point SI to the same char in the string that is currently above the
; cursor on the screen.
;----------------------------------------------------------------------
; Entry: None
; Exit:  None
;----------------------------------------------------------------------
; Changes: CX SI
;----------------------------------------------------------------------
LOCATE_SI	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		MOV	SI,[STR_LEFT]		;Leftmost char position
		SUB	CH,CH			;Adjust the start of
		MOV	CL,[CURSOR_COL]		; the string to point
		SUB	CL,FAR_LEFT		; to the char at the
		ADD	SI,CX			; cursor

		RET

LOCATE_SI	ENDP

;======================================================================
; STRING_INS (Near)
;
; Create a hole in the string by moving all chars to the right of the
; current char one place to the right.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC - hole created okay
;	CY - no room left in environment
;----------------------------------------------------------------------
; Changes: CX SI DI
;----------------------------------------------------------------------
STRING_INS	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		CMP	[ENV_FREE],0		;Any free space?
		JNE	SI_1

		STC				;Failure
		JMP	SHORT SI_EXIT
;----------------------------------------------------------------------
; There's room, so perform the insertion.
;----------------------------------------------------------------------
SI_1:
		CALL	LOCATE_SI		;Point SI=current char

		MOV	CX,[ENV_USED]		;End of strings offset
		MOV	DI,CX			;Is target for move
		SUB	CX,SI			;Bytes to move
		MOV	SI,DI			;Copy to src register
		DEC	SI			;Copy from prev byte

		PUSH	ES			;Both same segment
		POP	DS
	ASSUME	DS:NOTHING

		STD				;Move backwards
		REP	MOVSB			; whole string
		CLD				;Restore direction

		PUSH	CS			;Restore DS
		POP	DS
	ASSUME	DS:CSEG

		INC	[ENV_USED]		;File is longer
		INC	[STR_LEN]		; so is string
		DEC	[ENV_FREE]		; less left

		CALL	UPDATE			;Display new counts
		CLC				;Success
SI_EXIT:
		RET

STRING_INS	ENDP

;======================================================================
; STRING_DEL (Near)
;
; Delete the char at the cursor.  Close up the string.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC = char was removed
;	CY = no char to kill
;----------------------------------------------------------------------
; Changes: SI
;----------------------------------------------------------------------
STRING_DEL	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		CALL	LOCATE_SI		;Point to current char
		CMP	BYTE PTR ES:[SI],0	;If 0, don't delete
		JNE	SD_1

		STC				;No char to kill
		JMP	SHORT SD_EXIT
SD_1:
		CALL	CHAR_KILL		;Always returns NC
SD_EXIT:
		RET

STRING_DEL	ENDP

;======================================================================
; CHAR_KILL (Near)
;
; Closes up the string to eliminate the current character.
;----------------------------------------------------------------------
; Entry:
;	SI = offset of char to kill
;	ES = segment of char
; Exit:
;	CF = NC -- always cleared
;----------------------------------------------------------------------
; Changes: CX SI DI
;----------------------------------------------------------------------
CHAR_KILL	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		MOV	CX,[ENV_USED]		;End of strings offset
		SUB	CX,SI			;Bytes to move
		DEC	CX			;Is one less
		JZ	CK_1

		MOV	DI,SI			;ES:DI is dest

		INC	SI			;Copy from next byte
		PUSH	ES			;Point DS:SI to src
		POP	DS
	ASSUME	DS:NOTHING

		REP	MOVSB			;Move all env

		PUSH	CS			;Restore DS
		POP	DS
	ASSUME	DS:CSEG

		DEC	[ENV_USED]		;File gets shorter
		DEC	[STR_LEN]		; as does string
		INC	[ENV_FREE]		; with more to spare
		CALL	UPDATE			;Freshen counts
CK_1:
		CLC				;Success!
		RET

CHAR_KILL	ENDP

;======================================================================
; CURSOR_RIGHT (Near)
;
; Move the cursor right 1 char.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC = success
;	CY = failed
;----------------------------------------------------------------------
; Changes: CX SI
;----------------------------------------------------------------------
CURSOR_RIGHT	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		CALL	LOCATE_SI		;Point to current char
		CMP	BYTE PTR ES:[SI],0	;Are we on last char
		JNE	CR_0			;of string? jmp if yes
;----------------------------------------------------------------------
; Exit with CF=1:failure.
;----------------------------------------------------------------------
CR_A:
		STC				;Signal failure
		JMP	SHORT CR_EXIT
;----------------------------------------------------------------------
; If we're at the end of the line, we've got to scroll.
;----------------------------------------------------------------------
CR_0:
		MOV	CL,[CURSOR_COL]		;Is cursor positioned
		CMP	CL,[COL_MAX]		; at screen edge?
		JE	CR_2
;----------------------------------------------------------------------
; Cursor can move on-screen. Scrolling isn't required.
;----------------------------------------------------------------------
		INC	CL			;Move to next col
CR_1:
		MOV	[CURSOR_COL],CL		;Save column...
CR_1B:
		CALL	CUR_SET			;...move cursor
		CLC				;Signal success
CR_EXIT:
		RET
;----------------------------------------------------------------------
; Slide to the right and redraw the entire string.
;----------------------------------------------------------------------
CR_2:
		INC	[STR_LEFT]		;Move the start

		PUSH	[CURSOR_POS]		;Save current cursor

		MOV	[CURSOR_COL],FAR_LEFT	;Redo from left side
		CALL	CUR_SET			;Set cursor
        CALL    DISPLAYX        ;Draw string

		POP	[CURSOR_POS]		;Reset old cursor
		JMP	CR_1B

;======================================================================
; CURSOR_LEFT  (Near) [NESTED PROC]
;
; Move the cursor left 1 char.
;----------------------------------------------------------------------
; Entry: None
; Exit:
;	NC = cursor was moved left
;	CY = cursor was at far left of string - not moved
;----------------------------------------------------------------------
; Changes: CX SI
;----------------------------------------------------------------------
CURSOR_LEFT	PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		MOV	CL,[CURSOR_COL]		;Is cursor
		CMP	CL,FAR_LEFT		; at 1st column?
		JE	CL_1			;Yes, jump

		DEC	CL			;Back up cursor
		JMP	CR_1
CL_1:
		MOV	SI,[STR_LEFT]		;Start of window
		CMP	SI,[STR_START]		;Past start of string?
		JE	CR_A			;Yes, jump

		DEC	SI
		MOV	[STR_LEFT],SI
        CALL    DISPLAYX
		CLC				;Indicate success
		JMP	CR_EXIT

CURSOR_LEFT	ENDP
CURSOR_RIGHT	ENDP

;======================================================================
; CUR_SET (Near)
;
; Position the cursor to the screen row and column stored in 
; [CURSOR_POS]. Row, col values are not checked.
;----------------------------------------------------------------------
; Entry: None
; Exit:  None
;----------------------------------------------------------------------
; Changes: BX DX
;----------------------------------------------------------------------
CUR_SET		PROC	NEAR
	ASSUME	CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG

		PUSH	AX			;Save used register

		MOV	AH,2			;Position cursor fn
		MOV	BH,[VPAGE]		; current page
		MOV	DX,[CURSOR_POS]		; new cursor position
		INT	10H			; Thru BIOS

		POP	AX			;Restore register
		RET

CUR_SET		ENDP

;======================================================================
; Allocated after program loads.
;----------------------------------------------------------------------
PC		=	$

PC		=	PC + 256
STACK_TOP	=	PC

CSEG		ENDS
		END	ENTPT