;======================================================================
;  MAKEBAR: read a bar-definition-file (.BDF) and produce a tokenized
;  .BAR file to be read by the TSR interpreter.
;----------------------------------------------------------------------
CSEG	SEGMENT	PUBLIC	PARA	'CODE'
	ASSUME	CS:CSEG, DS:CSEG, ES:CSEG, SS:CSEG
		ORG	100H
ENTPT:		JMP	MAIN

COPYRIGHT  DB  "MAKEBAR 1.0 (c) 1987, Ziff-Davis Publishing Corp",CR,LF,'$'
AUTHOR	   DB  1AH,"Robert L. Hummel"

;======================================================================
;  EQUATES
;----------------------------------------------------------------------
SPACE		EQU	20H			;Some keys
CR		EQU	0DH
LF		EQU	0AH
QUOTE		EQU	22H
TAB		EQU	09H

INPUT_BUF_LEN	EQU	4000			;Size constants
OUTPUT_BUF_LEN	EQU	46000
MENU_BUF_LEN	EQU	4000
MENU_TBL_LEN	EQU	4000
BUF_TOTAL = INPUT_BUF_LEN + OUTPUT_BUF_LEN + MENU_BUF_LEN + MENU_TBL_LEN

_SHIFT		EQU	1			;Internal shift flags
_CTRL		EQU	2
_ALT		EQU	4


;----------------------------------------------------------------------
;  BUFFERS AND POINTERS
;----------------------------------------------------------------------
INPUT_HNDL	DW	0			;Handle of source file
INPUT_HNDL_PTR	DW	0			;Pointer to source file
INPUT_BUF_END	DW	0FFFFH			;Used by GET_CHAR
OUTPUT_HNDL	DW	0			;Handle of output file
MENU_HEAD	DW	0			;Pointer to current menu
SHIFT_FLAGS	DB	0			;Hold current shift state

;----------------------------------------------------------------------
;  COUNTERS
;----------------------------------------------------------------------
SOURCE_LINE	DW	0			;For error messages
NEW_REF		DB	-1			;Two counters track menu
OLD_REF		DB	0			; references

;----------------------------------------------------------------------
;  TABLES
;----------------------------------------------------------------------
CMD_TABLE	LABEL	BYTE			;All commands names
_ASK		EQU	0			; and their token values
A_CMD		DB	'ASK',0
_CR		EQU	1
C_CMD		DB	'CR',0
_EXECUTE	EQU	2
E_CMD		DB	'EXECUTE',0
_INPUT		EQU	3
I_CMD		DB	'INPUT',0
_MENU		EQU	4
M_CMD		DB	'MENU',0
_OPTION		EQU	5
O_CMD		DB	'OPTION',0
_PROGRAM	EQU	6
P_CMD		DB	'PROGRAM',0
_TYPE		EQU	7
_CMD		DB	'TYPE',0
_MEND		EQU	8
		DB	'MEND',0
_END		EQU	9
		DB	'END',0
_SEND		EQU	10
		DB	0			;End-of-table byte
;----------------------------------------------------------------------
KEY_NAME_TBL	LABEL	BYTE			;Special key names
		DB	"S",0,"C",0,"A",0

		DB	"F1",0,"F2",0,"F3",0,"F4",0,"F5",0
		DB	"F6",0,"F7",0,"F8",0,"F9",0,"F10",0

		DB	"ESC",0,"TAB",0,"ENTER",0,"BS",0

		DB	"HOME",0,"PGUP",0,"END",0,"PGDN",0,"INS",0
		DB	"DEL",0,"U",0,"D",0,"L",0,"R",0,0
;----------------------------------------------------------------------
;  These keys may be combined with the CRTL and ALT keys
;----------------------------------------------------------------------
KEY_TBL_1	DB	"ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890-=\[]",0

;----------------------------------------------------------------------
;  CTRL combinations for 1234567890-= (use {c}1 for ; {c}3 for ")
;----------------------------------------------------------------------
KEY_TBL_2	DW	003BH,0FE03H,0022H,0,0,001EH,0,0,0,0,001FH,0
		DW	001CH, 001BH, 001DH
;----------------------------------------------------------------------
;  Scan codes for alpha keys a-z (used for ALT-alpha)
;----------------------------------------------------------------------
KEY_TBL_3	DB	01EH,30H,2EH,20H,12H,21H,22H,23H,17H,24H,25H,26H
		DB	32H,31H,18H,19H,10H,13H,1FH,14H,16H,2FH,11H,2DH
		DB	15H,2CH

;----------------------------------------------------------------------
;  SHIFT,CTRL for enter,bs,home,pgup,end,pgdn,ins,del,up,down,left,right
;----------------------------------------------------------------------
KEY_TBL_4	DB	0DH,0FEH, 8,7FH, 47H,77H, 49H,84H, 4FH,75H
		DB	51H,76H, 52H,0, 53H,0, 48H,0, 50H,0, 4BH,73H,4DH,74H

;----------------------------------------------------------------------
;  FLAGS
;----------------------------------------------------------------------
MENU_FLAG	DB	0		;Non-zero when open menu blk
OPTION_FLAG	DB	0		;Non-zero when open option blk
PROGRAM_NAME_FLAG DB	0		;Non-zero when PROGRAM cmd read

;----------------------------------------------------------------------
;  MESSAGES
;----------------------------------------------------------------------
USAGE_MSG	DB	"Usage: MAKEBAR [path]input_file [path]output_file$"
BAD_FILE_MSG	DB	"Can't Open File$"
READ_MSG	DB	"Error Reading File$"

DUP_CMD_MSG	DB	"Duplicate Cmd$"
CMD_ORDER_MSG	DB	"Cmd Out Of Order$"
UNK_CMD_MSG	DB	"Unknown Cmd$"

NEST_MSG	DB	"MENU Without MEND$"
SYNTAX_MSG	DB	"Syntax Error$"
NO_NAME_MSG	DB	"Missing Name$"
REF_MSG		DB	"Bad MENU Reference$"
EOF_MSG		DB	"Missing END$"
DEAD_KEY_MSG	DB	"Dead-Key or Bad Key$"
LINE_MSG	DB	CR,LF,"Error At Line #       $"
LINE_NUM_BUF	EQU	$-2

;======================================================================
;  MENU FILE TOKENIZER - MAIN PROCEDURE
;----------------------------------------------------------------------
MAIN		PROC	NEAR

		MOV	AH,9			;Display string fn
		MOV	DX,OFFSET COPYRIGHT	;Say who we are
		INT	21H			; Thru DOS

		CLD				;Strings moves forward
;----------------------------------------------------------------------
;  Check the file specs given on the command line.  Open the files and
;  save the file handles.
;----------------------------------------------------------------------
		CALL	OPEN_FILES

;----------------------------------------------------------------------
;  Read in the Menu-Definition-File and tokenize.  Write the output to
;  the new .BAR file for use with the resident interpreter.
;----------------------------------------------------------------------
		CALL	TOKENIZE

;----------------------------------------------------------------------
;  Close and update any open files.  Terminate gracefully.
;----------------------------------------------------------------------
		CALL	CLOSE_FILES
		MOV	AX,4C00H		;Terminate process
		INT	21H			; Thru DOS

MAIN		ENDP

;======================================================================
;  OPEN_FILES - Open the file given on the command line and the working
;  files needed during operation of the tokenizer.
;----------------------------------------------------------------------
OPEN_FILES	PROC	NEAR

		MOV	SI,81H			;Command line parameters
		CALL	OPEN_A_FILE		;Open source
		MOV	INPUT_HNDL,AX		;Save handle

		CALL	OPEN_A_FILE		;Open destination file
		MOV	OUTPUT_HNDL,AX		;Save handle

		MOV	INPUT_BUF_END,0		;Make refresh occur
		RET

OPEN_FILES	ENDP

;======================================================================
; OPEN_A_FILE - Read a string from the command line and attempt to open
;  it as a file.
;----------------------------------------------------------------------
OPEN_CNT	DB	0			;Switch for open function

OPEN_A_FILE	PROC	NEAR

		CALL	NON_WHITE		;Point SI to 1st nonwhite
		CMP	AL,CR			;If not carriage return
		JNE	HAVE_ARGS		; go parse arguments
NO_SPECS:
		MOV	DX,OFFSET USAGE_MSG	;Say how we are used
OPEN_ERR:
		JMP	ERROR_EXIT		;Exit thru error procedure
HAVE_ARGS:
		PUSH	SI			;Save start of string
		CALL	WHITE			;Point past end
		MOV	CX,SI			;End of string
		POP	SI			;Restore start
		SUB	CX,SI			;Get length of string
		OR	CX,CX			;If zero
		JZ	NO_SPECS		; no file names
		MOV	DI,OFFSET PATH_BUF	;Copy string here
		REP	MOVSB			; do it
		XOR	AL,AL			;Make ASCIIZ
		STOSB				; put in buffer

;----------------------------------------------------------------------
;  Attempt to open the file.
;----------------------------------------------------------------------
		MOV	AX,3D00H		;Open file for reading
		CMP	OPEN_CNT,0		; if first file
		JE	FILE_OPEN
		DEC	AH			;Create file if second
FILE_OPEN:
		MOV	DX,OFFSET PATH_BUF	;Pathname of file
		INT	21H			;Handle in AX
		JNC	SOURCE_OPEN		;No carry if open OK
		MOV	DX,OFFSET BAD_FILE_MSG
		JMP	OPEN_ERR
SOURCE_OPEN:
		INC	OPEN_CNT		;Change switch
		RET

OPEN_A_FILE	ENDP

;======================================================================
;  Close the files to update the length.
;----------------------------------------------------------------------
CLOSE_FILES	PROC	NEAR

		MOV	AH,3EH			;Close file function
		MOV	BX,INPUT_HNDL		; first file
		INT	21H			; Thru DOS

		MOV	AH,3EH			;Close file function
		MOV	BX,OUTPUT_HNDL		; second file
		INT	21H			; Thru DOS
		RET

CLOSE_FILES	ENDP

;======================================================================
; TOKENIZE - Read and process the Bar Definition File (BDF).
;----------------------------------------------------------------------
TOKENIZE	PROC	NEAR

;----------------------------------------------------------------------
;  Clear flags and reset source line counter.
;----------------------------------------------------------------------
		XOR	AX,AX			;Zero
		MOV	PROGRAM_NAME_FLAG,AL	;No program name
		MOV	MENU_FLAG,AL		;Not inside MENU block
		MOV	SOURCE_LINE,AX		;Source line counter

		MOV	DI,OFFSET MENU_NAME_TBL	;Fill the table with zeros
		MOV	CX,MENU_TBL_LEN		;Entire length
		REP	STOSB			; do it

		CALL	REFRESH_BUFFER		;Load some chars into buf
		MOV	DI,OFFSET OUTPUT_BUF	;Init output buffer pointer

;----------------------------------------------------------------------
;  Parse the input file to find commands and arguments.
;----------------------------------------------------------------------
FIND_WORD:
		CALL	NON_WHITE		;Find non-white char
		CMP	AL,CR			;Ignore blank lines
		JNE	TKN_1
		CALL	NEXT_LINE		;Skip to next line
		JMP	FIND_WORD		;Continue search
TKN_1:
;----------------------------------------------------------------------
;  SI points to word.  Compare with known commands.  Return token in AL
;  or 0FFh if not recognized.
;----------------------------------------------------------------------
		CALL	MAKEZ			;Copy word at SI to buffer
						; and make ASCIIZ
		PUSH	SI			;Preserve SI
		MOV	SI,OFFSET CMD_TABLE	;Look up word in this table
		CALL	TABLE_LOOKUP		;Compare cmd in buffer
		POP	SI			;AL = CMD # or FFh
		CMP	AL,0FFH			;Is error?
		JNE	TKN_1A			;No, valid CMD found
		MOV	DX,OFFSET UNK_CMD_MSG
		JMP	SHORT TKN_ERR
TKN_1A:
;----------------------------------------------------------------------
;  If this is a PROGRAM statement, load the name of the program into the
;  buffer.  Must be the first command in the file.
;----------------------------------------------------------------------
		CMP	PROGRAM_NAME_FLAG,0	;Test if already had PROGRAM
		PUSHF				;Save result

		CMP	AL,_PROGRAM		;Is this PROGRAM?
		JE	TKN_2			; yes, jump

		POPF				;Did we have one?
		JNZ	TKN_4			; yes, try next cmd
		JMP	TKN_7A			; no, error
TKN_2:
		POPF				; yes, Did we have one?
		JZ	TKN_3			;  No, this is first
		MOV	DX,OFFSET DUP_CMD_MSG	;  Yes, indicate error
		JMP	SHORT TKN_ERR
TKN_3:
;----------------------------------------------------------------------
;  Copy the name of the program to the output buffer.
;----------------------------------------------------------------------
		MOV	BX,DI			;Point BX to start of buf
		MOV	AL,SPACE		;Fill name with spaces
		MOV	CX,10			;10 chars
		REP	STOSB			;do it

		CALL	NEXT_WORD
		CALL	TKN_STRING		;Copy quoted string

		INC	PROGRAM_NAME_FLAG	;Make flag non-zero
		JMP	FIND_WORD		;Get next command
TKN_4:
;----------------------------------------------------------------------
;  END command terminates processing.
;----------------------------------------------------------------------
		CMP	AL,_END			;If not END, jump
		JNE	TKN_4A

		MOV	AL,MENU_FLAG		;If no open menus
		OR	AL,OPTION_FLAG		; or options
		JZ	NO_OPENS		; then clean up
TKN_4AA:
		MOV	DX,OFFSET NEST_MSG	;Else, nesting error
		JMP	SHORT TKN_ERR
NO_OPENS:
		MOV	AL,NEW_REF		;If no unbalanced menu
		OR	AL,OLD_REF		; references
		JZ	REFS_OK			; write the results
		MOV	DX,OFFSET REF_MSG	;Else, error
TKN_ERR:
		JMP	ERROR_EXIT
REFS_OK:
;----------------------------------------------------------------------
;  Flush the output buffer.
;----------------------------------------------------------------------
		MOV	DX,OFFSET OUTPUT_BUF	;Source buffer
		MOV	CX,DI			;End of buf
		SUB	CX,DX			; minus start = length
		MOV	AH,40H			;Write to file
		MOV	BX,OUTPUT_HNDL		; this handle
		INT	21H			;Thru DOS
		RET				;Return to top level

;----------------------------------------------------------------------
;  Is this a command to start a MENU block?
;----------------------------------------------------------------------
TKN_4A:
		CMP	AL,_MENU
		JNE	TKN_6			;Jump if not MENU

;----------------------------------------------------------------------
;  If we are already inside an active menu block, either an MEND is
;  missing or the menus are nested (both are errors).
;----------------------------------------------------------------------
		CMP	MENU_FLAG,0
		JNE	TKN_4AA			;Jump if in block

;----------------------------------------------------------------------
;  Execute MENU block startup code.  Point BX to a buffer where the
;  tokenized output will be temporarily stored.  When then menu block is
;  closed, the addresses in the menu header will be adjusted by the length
;  of the header.
;----------------------------------------------------------------------
TKN_5:
		MOV	BX,OFFSET MENU_BUF	;Buffer for menu tokens
		MOV	MENU_HEAD,DI		;Location of menu header
		XOR	AX,AX			;Number of OPTIONS = 0
		STOSW				; placed in header (at DI)
		INC	MENU_FLAG		;Say we're inside menu

;----------------------------------------------------------------------
;  Make sure the MENU command is followed by a name
;----------------------------------------------------------------------
		CALL	NEXT_WORD		;Point SI to next word
		CMP	AL,CR			;If CR, no name = error
		JE	TKN_8A
;----------------------------------------------------------------------
;  If Menu name is in table, it was referenced by an earlier menu and
;  the address must be put back into that command line.  If it's not in
;  the table, add it and point to it's address.
;----------------------------------------------------------------------
		CALL	MAKEZ			;Change menu name to ASCIIZ
		MOV	AX,MENU_HEAD		;Signal says posting
		SUB	AX,OFFSET OUTPUT_BUF	;Make into offset
		CALL	SEARCH_MENU_TABLE	;Enter in table or resolve
						; reference or error
		CALL	NEXT_LINE		;Skip to next line
		JMP	FIND_WORD		;Continue parsing

;----------------------------------------------------------------------
;  If not a MENU command, must be inside a block to be valid.
;----------------------------------------------------------------------
TKN_6:
		CMP	MENU_FLAG,0
		JE	TKN_7A			;Jump if outside block
TKN_7:
;----------------------------------------------------------------------
;  Inside a MENU block must reside a series of OPTION blocks.
;----------------------------------------------------------------------
		CMP	OPTION_FLAG,0		;Test if in option block
		PUSHF				; save result

		CMP	AL,_OPTION
		JE	TKN_8			;Jump if OPTION
		POPF				;Inside option block?
		JNE	TKN_12			;Jump if yes
TKN_7A:
		MOV	DX,OFFSET CMD_ORDER_MSG
		JMP	TKN_ERR
TKN_8:
		POPF				;Inside option block?
		JE	NEW_OPTION_BLOCK	;Jump if not

;----------------------------------------------------------------------
;  Close this option block by adding the SEND command.
;----------------------------------------------------------------------
		MOV	AL,_SEND		;Send token
		CALL	PUT_MENUBUF		; to buffer

;----------------------------------------------------------------------
;  To start new option block, increase the option counter.
;  Parse name and help line and point the pointers at them.
;----------------------------------------------------------------------
NEW_OPTION_BLOCK:
		INC	OPTION_FLAG		;Inside option block
		MOV	BP,MENU_HEAD		;Number options this MENU
		INC	WORD PTR [BP]		; increase by 1

;----------------------------------------------------------------------
;  Save the option name
;----------------------------------------------------------------------
		CALL	NEXT_WORD		;Point to OPTION NAME
		CMP	AL,CR			;Option must have name
		JNE	TKN_9			;Jump if name
TKN_8A:
		MOV	DX,OFFSET NO_NAME_MSG
		JMP	TKN_ERR
TKN_9:
		CALL	MAKEZ			;Make name at SI into ASCIIZ
		MOV	AX,BX			;Address where name is stored
		SUB	AX,OFFSET MENU_BUF	; from start of buffer
		STOSW				; is saved in menu header

;----------------------------------------------------------------------
;  Copy the option name from the asciiz buffer to the menu buffer
;----------------------------------------------------------------------
		PUSH	SI			;Save register
		MOV	SI,OFFSET PATH_BUF	;Source for copy
COPY_NAME:
		LODSB				;Get char
		CALL	PUT_MENUBUF
		OR	AL,AL			;If not last byte
		JNZ	COPY_NAME		;continue copy
		POP	SI			;Restore register
		CALL	NEXT_WORD		;Look for help line

;----------------------------------------------------------------------
;  HELP line is quoted string
;----------------------------------------------------------------------
TKN_11:
		MOV	AX,BX			;Offset from start of buf
		SUB	AX,OFFSET MENU_BUF	; is location to put
		STOSW				; in header
		CALL	TKN_STRING

;----------------------------------------------------------------------
;  Put the offset where the tokenized commands will start into the header.
;----------------------------------------------------------------------
		MOV	AX,BX			;Current location
		SUB	AX,OFFSET MENU_BUF	; minus start is offset
		STOSW				;Put word
		JMP	FIND_WORD

;----------------------------------------------------------------------
;  The MEND command requires some cleanup to be performed.
;  The length of the header is calculated and added to the offsets in
;  the header.  Then the menu_buf is appended to the output_buf.
;----------------------------------------------------------------------
TKN_12:
		CMP	AL,_MEND
		JNE	TKN_12AA		;If not MEND, move on
;----------------------------------------------------------------------
;  Close out the option block (if there was one).
;----------------------------------------------------------------------
		MOV	AL,_SEND		;Write send token
		CALL	PUT_MENUBUF
;----------------------------------------------------------------------
;  Flush the buffers.
;----------------------------------------------------------------------
		PUSH	SI			;Save register
		MOV	SI,MENU_HEAD		;Address of start of menu
						; in the output file
		LODSW				;Number of entries in menu

		MOV	CX,AX			;#Words = # entries * 3
		SHL	CX,1			; *2
		ADD	CX,AX			; +1 is same as *3

		JCXZ	APPEND_TOKENS		;NULL menu bailout
		PUSH	CX			;Save number words to update
		MOV	AX,CX			;Length of offset
		INC	AX			; plus one
		SHL	AX,1			; times two

		MOV	CX,MENU_HEAD		;Offset of start of menu
		SUB	CX,OFFSET OUTPUT_BUF	; from start of buf
		ADD	AX,CX			; plus length of header
		POP	CX
UPDATE_POINTERS:
		ADD	WORD PTR [SI],AX	; makes pointers correct
		INC	SI			;Skip to next pointer
		INC	SI
		LOOP	UPDATE_POINTERS

;----------------------------------------------------------------------
;  Append the tokenized menu.
;----------------------------------------------------------------------
APPEND_TOKENS:
		MOV	CX,BX			;End of menu buf
		MOV	SI,OFFSET MENU_BUF	;start of menu buf
		SUB	CX,SI			;# bytes to transfer
		REP	MOVSB			;do it
		POP	SI			;restore register

;----------------------------------------------------------------------
;  Reset the flags.
;----------------------------------------------------------------------
		MOV	MENU_FLAG,0
		MOV	OPTION_FLAG,0
		JMP	FIND_WORD		;get next command

;----------------------------------------------------------------------
;  Deal with commands other than PROGRAM, MENU, and OPTION
;----------------------------------------------------------------------
TKN_12AA:
		CALL	PUT_MENUBUF		;Put the token in the file
		CMP	AL,_EXECUTE		;If not execute
		JNE	TKN_13			; move on

;----------------------------------------------------------------------
;  EXECUTE command references another menu.  Let the SEARCH_MENU_TABLE
;  routine satisfy the reference, or leave a "wanted" message.
;----------------------------------------------------------------------
		CALL	NEXT_WORD		;Point to named menu
		CMP	AL,CR			;End of line?
		JNE	TKN_12A
		JMP	TKN_8A			;(out of range jump)
TKN_12A:
		CALL	MAKEZ			;Put name in buffer
		MOV	AX,0FFFFH		;= want address
		CALL	SEARCH_MENU_TABLE	;Try and resolve
		JMP	FIND_WORD

;----------------------------------------------------------------------
;  Separate out commands that take arguments.
;----------------------------------------------------------------------
TKN_13:
		CMP	AL,_ASK			;Ask takes string
		JE	TKN_17
		CMP	AL,_TYPE		;So does type
		JE	TKN_17
		JMP	FIND_WORD		;Token already in, so go

;----------------------------------------------------------------------
;  These commads require the quoted string following them to be included
;  as an ASCIIZ string following the command byte.
;----------------------------------------------------------------------
TKN_17:
		CALL	NEXT_WORD		;Point to string
		CALL	TKN_STRING		;Copy it
		JMP	FIND_WORD

TOKENIZE	ENDP

;======================================================================
;  AX points to an ASCIIZ string.  Look up that string in table pointed
;  to by SI to see if we can find a match.
;----------------------------------------------------------------------
TABLE_LOOKUP	PROC	NEAR

		PUSH	DI			;Save registers
		PUSH	CX
		PUSH	DX

		XOR	CL,CL			;Command counter
CL_0:
		CMP	BYTE PTR [SI],0		;End of table?
		JNZ	CL_2			; jump if not
		MOV	CL,0FFH			;Signal error
CL_1:
		MOV	AL,CL			;Return cmd number
		POP	DX			;Restore registers
		POP	CX
		POP	DI
		RET
CL_2:
		MOV	DI,AX			;Pointer to unknown command
		CALL	STR_CMP			;NC if matched
		JNC	CL_1
		INC	CL			;Point to next
		JMP	CL_0			;Test for table end

TABLE_LOOKUP	ENDP

;======================================================================
;  Compare strings at DI,SI where SI is a table.
;----------------------------------------------------------------------
STR_CMP		PROC	NEAR
STR_1:
		MOV	DL,[DI]			;Get char from string
		INC	DI			;Point to next
		MOV	DH,[SI]			;Get char from table
		INC	SI			;Point to next
		CMP	DH,DL			;If equal
		JE	STR_3			; jump
		DEC	SI			;Backup in table
STR_2:
		MOV	DH,[SI]			;Examine char in table
		INC	SI			;Goto next char
		OR	DH,DH			;Is it end of entry?
		JNZ	STR_2			; no, continue scanning
		STC				; return with failure
		RET
STR_3:
		OR	DX,DX			;If both not 0
		JNZ	STR_1			; continue compare
		CLC				; else, they match
		RET

STR_CMP		ENDP

;======================================================================
;  This procedure prints an error message and indicates the source line
;  number on which it occured.
;----------------------------------------------------------------------
ERROR_EXIT	PROC	NEAR

		MOV	AH,9			;Print the error message
		INT	21H			; Thru DOS

		MOV	DI,OFFSET LINE_NUM_BUF	;Put line number here
		MOV	AX,SOURCE_LINE		;Contains line number
		MOV	BX,10			;Base 10 numbers
LINE_LOOP:
		XOR	DX,DX			;Divide DX:AX by BX
		DIV	BX
		ADD	DL,30H			;Make number into ASCII
		MOV	[DI],DL			;Save it
		DEC	DI			;Move toward more significant
		OR	AX,AX			;If remainder not 0
		JNZ	LINE_LOOP		; continue

		MOV	DX,OFFSET LINE_MSG	;Write message
		MOV	AH,9			;Display string fn
		INT	21H			; Thru DOS

		CALL	CLOSE_FILES		;Close files and terminate
		MOV	AX,4CFFH		; with error=255
		INT	21H			; Thru DOS

ERROR_EXIT	ENDP

;======================================================================
;  Position SI to the begining of the next word.
;----------------------------------------------------------------------
NEXT_WORD	PROC	NEAR

		CALL	IS_WHITE		;Is current char white?
		JNC	NW_1			; yes, jump
		CALL	WHITE			; no, find first white
NW_1:
		CALL	NON_WHITE		;Scan for first non-white
		RET

NEXT_WORD	ENDP

;======================================================================
;  Enter with SI pointing to string.  Position so SI points at first
;  delimiter character AFTER the present char.  Return char in AL.
;  AL changed, SI moved by file routines.
;----------------------------------------------------------------------
WHITE		PROC	NEAR

		MOV	AL,[SI]			;Check current char
		CMP	AL,CR			; for EOL
		JE	W_RET			; and leave
W_LOOP:
		CALL	GET_CHAR		;Get the next char
		CMP	AL,CR			;If EOL
		JE	W_RET			; return
		CALL	IS_WHITE		;Returns NC if white
		JC	W_LOOP
W_RET:
		RET
WHITE		ENDP

;======================================================================
;  Enter with SI pointing to string.  Position so SI points at first
;  non-delimiter character AFTER the present char.  Return char in AL.
;  AL changed, SI moved by file routines.
;----------------------------------------------------------------------
NON_WHITE	PROC	NEAR

		MOV	AL,[SI]			;Check current char
		CMP	AL,CR			; for EOL
		JE	NW_RET			; and leave
NW_LOOP:
		CALL	GET_CHAR		;Get the next char
		CMP	AL,CR			;If EOL
		JE	NW_RET			; return
		CALL	IS_WHITE		;Returns NC if white
		JNC	NW_LOOP
NW_RET:
		RET
NON_WHITE	ENDP

;======================================================================
;  Examine Char at SI and return CY if non-white, NC if delimiter
;  Only flags changed.
;----------------------------------------------------------------------
DELIMS		DB	" ,:",LF,TAB		;White chars

IS_WHITE	PROC	NEAR

		PUSH	AX			;Save registers
		PUSH	CX
		PUSH	DI

		MOV	AL,[SI]			;Examine current char
		MOV	CX,5			;Number delims to compare
		MOV	DI,OFFSET DELIMS	;Here they are
		REPNE	SCASB			;Compare them
		CLC				;NC if delimiter
		JZ	IW_1			;ZR indicates match found
		STC				; else CY
IW_1:
		POP	DI			;Restore registers
		POP	CX
		POP	AX
		RET

IS_WHITE	ENDP

;======================================================================
;  Make the character in AL UPPER case.
;----------------------------------------------------------------------
MAKE_UC		PROC	NEAR

		CMP	AL,'a'			;If between a and z
		JB	UC_1
		CMP	AL,'z'
		JA	UC_1
		SUB	AL,20H			;Make upper case
UC_1:
		RET
MAKE_UC		ENDP

;======================================================================
;  Position SI to the next char after a CR.  Start search with current
;  char.
;----------------------------------------------------------------------
NEXT_LINE	PROC	NEAR

		MOV	AL,[SI]			;Examine current char
NL_1:
		CMP	AL,CR			;Is it CR?
		JE	NL_2			; yes, jump
		CALL	GET_CHAR		; no, get next char
		JMP	NL_1			;  and try again
NL_2:
		CALL	GET_CHAR		;Go to first char after CR
		RET

NEXT_LINE	ENDP

;======================================================================
;	This proc helps resolve references to other menus made with
;  EXECUTE commands.  If entered with AX=FFFF, the calling procedure has
;  a reference it needs to satisfy.  If an address has been entered in
;  the table for that name, the address is returned and the reference is
;  satisfied.  If not, a "IOU" is inserted in the table.
;	If entered with AX != FFFFh, the calling procedure is supplying the
;  starting address of the MENU named at PATH_BUF, and asking that these
;  be entered into the table to satisfy a reference.  If the name is found
;  in the table, left in a previous bookmark, the reference is satisfied
;  and the entry is marked "USED". Any further use of that name generates
;  an error.
;	For a forward reference, the structure is:
;		ASCIIZ string
;		WORD - Address of the start of the menu that
;			contains the reference (menu_head)
;		WORD - Offset from the end of menu header that
;			is the destination for the fix-up
;	For a POST:
;		ASCIIZ string
;		WORD - Address in output file of menu
;		WORD - 0FFFFh
;  Possibilities:
;	1) Post a MENU not previously requested
;	2) Post a MENU previously requested
;	3) Request a MENU previously posted
;	4) Ask for a MENU not previously posted
;----------------------------------------------------------------------
SEARCH_MENU_TABLE	PROC	NEAR

		PUSH	SI			;Save used registers
		PUSH	DI
		PUSH	DX
		PUSH	CX

;----------------------------------------------------------------------
;  AX=FFFF if request.  AX != FFFF, then post the MENU address.
;----------------------------------------------------------------------
		CMP	AX,0FFFFH		;Switch = FFFF if request
		JE	WANT_ADR		; to satisfy reference

;----------------------------------------------------------------------
;  AX contains the output file offset of a menu to post in this table.
;  If the name is in the table, it was referenced earlier and we can go
;  back and fix it up.  If the name is NOT in the table, post it.
;----------------------------------------------------------------------
		CALL	MENU_LOOK		;Changes SI
		JNC	SMT_7			;Match was found if NC

;----------------------------------------------------------------------
;  1) Post a menu not previously requested. No match found.  Create a
;  new entry for this menu.  SI points to end of table.
;  Copy the name from the buffer to the menu table.
;----------------------------------------------------------------------
		INC	NEW_REF			;Add a new reference
		MOV	CX,0FFFFH		;POST code
SMT_1:
		MOV	DI,OFFSET PATH_BUF	;Name of MENU is here
;----------------------------------------------------------------------
;  Copy menu name to menu_name_table
;----------------------------------------------------------------------
SMT_5:
		MOV	DL,[DI]			;Get char in DL
		INC	DI			;Point to next
		MOV	[SI],DL			;Save this char in table
		INC	SI			;next destination
		OR	DL,DL			;Was that last byte?
		JNZ	SMT_5			; no, get more

;----------------------------------------------------------------------
;  Make AX into offset from buffer start.  Save in menu table.
;  CX contains either offset from menu_buf of reference or FFFF (POST).
;----------------------------------------------------------------------
		MOV	WORD PTR [SI],AX	;Menu at this address
		MOV	WORD PTR [SI][2],CX
		JMP	SHORT SMT_EXIT		;clean up

;----------------------------------------------------------------------
;  2) Post a MENU previously requested.  SI points past the ASCIIZ name
;  in the table to the location of the forward reference.
;----------------------------------------------------------------------
SMT_7:
		INC	OLD_REF			;Add an old reference
		MOV	DX,WORD PTR [SI][2]	;2nd word
		CMP	DX,0FFFFH		; if POST, two menus have
		JE	SMT_7B			; the same name (error)
		CMP	DX,0FFFEH		;Already referenced
		JNE	SMT_8			; is also an error
SMT_7B:
		MOV	DX,OFFSET REF_MSG	;error
		JMP	ERROR_EXIT
SMT_8:
;----------------------------------------------------------------------
;  SI points to address of menu as offset from start of buffer.
;  SI+2 points to additional offset from end of header.
;  Address of reference is [si] + 2 + 3 * 2 * [[si]] + [si+2] !
;----------------------------------------------------------------------
		MOV	DI,WORD PTR [SI]	;Offset into output_buf
		ADD	DI,OFFSET OUTPUT_BUF	;Absolute memory location
		MOV	CX,WORD PTR [DI]	;Number of entries in header
		SHL	CX,1			; 2 bytes per word
		ADD	DI,CX
		INC	CX			; 2 for first word
		SHL	CX,1
		ADD	DI,CX

		ADD	DI,WORD PTR [SI][2]
		MOV	[DI],AX			; reference satisfied
		MOV	WORD PTR [SI][2],0FFFEH	;Mark this entry USED
		JMP	SHORT SMT_EXIT		;Clean up

;----------------------------------------------------------------------
;  Try and satisfy a reference.
;----------------------------------------------------------------------
WANT_ADR:
		CALL	MENU_LOOK		;CY if no match
		JC	SMT_9

;----------------------------------------------------------------------
;  3) Request a MENU previously posted.  Entry name was in table.
;----------------------------------------------------------------------
		DEC	NEW_REF
		MOV	DX,WORD PTR [SI][2]	;Second word
		CMP	DX,0FFFFH		; should contain POST code
		JNE	SMT_7B			;if not, ERROR!

		MOV	AX,[SI]			;Get address of menu
		CALL	PUT_MENUBUF		;Put lower byte
		MOV	AL,AH
		CALL	PUT_MENUBUF		;Put upper byte

		MOV	WORD PTR [SI][2],0FFFEH	;Mark entry used
		JMP	SHORT SMT_EXIT

;----------------------------------------------------------------------
;  4) Ask for a MENU not previously posted.  Put an IOU in the table.
;----------------------------------------------------------------------
SMT_9:
		DEC	OLD_REF
		MOV	AX,MENU_HEAD		;First entry is offset of
		SUB	AX,OFFSET OUTPUT_BUF	; requesting menu

		MOV	CX,BX			;Second entry is offset past
		SUB	CX,OFFSET MENU_BUF	; the menu header

		ADD	BX,2			;Leave room for address
		JMP	SMT_1			;Go create table entry
SMT_EXIT:
		POP	CX			;Restore registers
		POP	DX
		POP	DI
		POP	SI
		RET

SEARCH_MENU_TABLE	ENDP

;======================================================================
;  Look for a name in the menu.  If carry is set, no match was found
;  and SI points to the end of the table.  If carry is clear, match was
;  found and SI points to address word after entry.
;  SI is changed.
;----------------------------------------------------------------------
MENU_LOOK	PROC	NEAR

		PUSH	DI			;Save registers
		PUSH	DX

		MOV	SI,OFFSET MENU_NAME_TBL	;Known names
ML_1:
		CMP	BYTE PTR [SI],0		;If 0, end of table
		JNE	ML_3			; else compare entry
		STC				;signal error
ML_2:
		POP	DX			;Restore registers
		POP	DI
		RET
ML_3:
		MOV	DI,OFFSET PATH_BUF	;Name to find
		CALL	STR_CMP			;CY if no match
		JNC	ML_2			;Return result
		ADD	SI,4			;Skip past addresses
		JMP	ML_1			;Check next table entry

MENU_LOOK	ENDP

;======================================================================
;  Interpret the contents of the quoted string and write to output buffer.
;  Entered with SI pointing to the beginning quote.  An illegal character
;  or combination produces an error and terminates processing.
;----------------------------------------------------------------------
TKN_STRING	PROC	NEAR

		CMP	BYTE PTR [SI],QUOTE	;Must point to quoted string
		JNE	TS_ERR			; or syntax error.

		PUSH	DI			;Save used register
TS_1:
		MOV	SHIFT_FLAGS,0		;Clear shift flags
TS_1AA:
		CALL	GET_CHAR		;Get next char
		CMP	AL,CR			;If not CR
		JNE	TS_QUOTE		; go to next test
TS_ERR:
		JMP	SC_ERR			;Report a syntax error
TS_QUOTE:
		CMP	AL,QUOTE		;If quote
		JNE	TS_1A
TS_EXIT:
		XOR	AL,AL			; make string asciiz
		CALL	PUT_MENUBUF		; and write to buffer

		CALL	NEXT_LINE		;Position to next line
		POP	DI			;Restore register
		RET				; and leave
TS_1A:
		CMP	AL,"{"			;Key name follows
		JE	SPEC_CHAR		;Go snif it out

		CMP	SHIFT_FLAGS,0		;If any shift keys on
		JNE	DO_XLAT			; do translation
		XOR	AH,AH			;Else, ASCII output of AL

;----------------------------------------------------------------------
;  If AH=0, output the code in AL; If AH != 0, output AH, then AL.
;----------------------------------------------------------------------
OUTPUT_CODE:
		OR	AH,AH			;If AH=0
		JZ	OC_1			; output AL only
		XCHG	AH,AL			;Switch
		CALL	PUT_MENUBUF		;Write the high byte
		XCHG	AH,AL			;restore AL
OC_1:
		CALL	PUT_MENUBUF		;Put AL in buffer
		JMP	TS_1			;Get another character

;----------------------------------------------------------------------
;  These keys may be valid with CTRL and ALT, but not SHIFT
;----------------------------------------------------------------------
DO_XLAT:
		CMP	SHIFT_FLAGS,_SHIFT	;Is SHIFT on?
		JNE	TS_1B
DEAD_KEY_ERROR:
		MOV	DX,OFFSET DEAD_KEY_MSG	;Invalid key combo
		JMP	ERROR_EXIT
TS_1B:
;----------------------------------------------------------------------
;  See if the key is in the table.
;----------------------------------------------------------------------
		CALL	MAKE_UC			;Make upper case

		MOV	AH,AL			;Save original char
		MOV	DI,OFFSET KEY_TBL_1	;Source for compare
		MOV	CX,DI			;Save start of table
TS_2:
		MOV	AL,[DI]			;Get char from table
		INC	DI			;Point to next
		OR	AL,AL			;If 0, AL was illegal char
		JE	DEAD_KEY_ERROR
		CMP	AL,AH			;Do we have a match?
		JNE	TS_2			;No, try again
		DEC	DI			;Backup pointer
		MOV	AX,DI			;Have a match if here
		SUB	AX,CX			;Offset into table

;----------------------------------------------------------------------
; Found a match.  Tediously calculate output byte.
;----------------------------------------------------------------------
		CMP	AL,25			;If A-Z
		JBE	IS_ALPHA		; process as alpha keys
		SUB	AL,26			;Remove alpha bias

		CMP	SHIFT_FLAGS,_CTRL	;Go perform CTRL combos
		JE	TS_4
						;These are ALT combos
		CMP	AL,11
		JA	DEAD_KEY_ERROR		;Too high
		ADD	AX,0FE78H		;Output 2 bytes
		JMP	OUTPUT_CODE
TS_4:						;CTRL combos
		SHL	AL,1			;multiply by 2
		MOV	DI,OFFSET KEY_TBL_2
		ADD	DI,AX			;Find word in table
		MOV	AX,[DI]			;Load into AX
		OR	AX,AX			;If zero
		JZ	DEAD_KEY_ERROR		; this combo not allowed
		JMP	OUTPUT_CODE		; else write it

;----------------------------------------------------------------------
;  CTRL/ALT alphabet combinations.
;----------------------------------------------------------------------
IS_ALPHA:
		CMP	SHIFT_FLAGS,_ALT
		JE	TS_5
		INC	AL			;ALT is simple, add 1
		JMP	OUTPUT_CODE
TS_5:
		MOV	DI,OFFSET KEY_TBL_3	;CTRL keys combos
		ADD	DI,AX			;Add offset to
		MOV	AL,[DI]			; get char code
		MOV	AH,0FEH			;Signal extended ASCII
		JMP	OUTPUT_CODE		;Send it to buffer

;----------------------------------------------------------------------
;  Here the {strings} are translated to their equivalent keystrokes.
;  Move the key name into the ASCIIZ buffer.
;----------------------------------------------------------------------
SPEC_CHAR:
		MOV	DI,OFFSET PATH_BUF
SC_1:
		CALL	GET_CHAR		;Get char inside brace

		CMP	AL,'{'			;If doubled, use {
		JNE	SC_2			;Jump for other chars
		CMP	DI,OFFSET PATH_BUF	;If = no chars have been
		JE	OC_1			; processed yet. {{
SC_ERR:
		MOV	DX,OFFSET SYNTAX_MSG
		JMP	ERROR_EXIT
SC_2:
		CMP	AL,QUOTE		;If char is quote
		JE	SC_ERR

		CMP	AL,'}'			;Close brace?
		JE	SC_3			; go search table
		CALL	MAKE_UC			;Make Upper case
		STOSB				;Put char in buffer
		JMP	SC_1			;Continue to copy key name
SC_3:
		XOR	AL,AL			;Make asciiz
		STOSB
		PUSH	SI			;Save register
		MOV	SI,OFFSET KEY_NAME_TBL	;Search this table
		MOV	AX,OFFSET PATH_BUF	; for this entry
		CALL	TABLE_LOOKUP
		POP	SI			;Restore register

;----------------------------------------------------------------------
;  Return # of entry in table or FFh if not found.
;----------------------------------------------------------------------
		CMP	AL,0FFH
		JE	SC_ERR

		OR	AL,AL			;0 = Turn SHIFT on
		JNZ	SC_4
		MOV	SHIFT_FLAGS,_SHIFT
		JMP	TS_1AA
SC_4:
		DEC	AL			;0 = Turn CTRL on
		JNZ	SC_5
		MOV	SHIFT_FLAGS,_CTRL
		JMP	TS_1AA
SC_5:
		DEC	AL			;0 = Turn ALT on
		JNZ	SC_6
		MOV	SHIFT_FLAGS,_ALT
		JMP	TS_1AA

;----------------------------------------------------------------------
;  Test for the Function keys (40 combinations).
;----------------------------------------------------------------------
SC_6:
		DEC	AL			;Adjust key number
		CMP	AL,9			;Keys 0-9
		JA	SC_10			;Can't be function key
		ADD	AL,3BH			;Key code
		MOV	AH,SHIFT_FLAGS		;Test for shift states
		CMP	AH,_SHIFT		;For shift
		JNE	SC_7
		ADD	AL,19H			;Add 19h
SC_7:
		CMP	AH,_CTRL		;For CTRL
		JNE	SC_8
		ADD	AL,23H			;Add 23h
SC_8:
		CMP	AH,_ALT			;For ALT
		JNE	SC_9
		ADD	AL,2DH			;Add 2dh
SC_9:
		MOV	AH,0FEH			;Say this is extended ascii
		JMP	OUTPUT_CODE		;Dump the bytes

;----------------------------------------------------------------------
;  ALT is not allowed for these keys.
;----------------------------------------------------------------------
SC_10:
		CMP	SHIFT_FLAGS,_ALT	;If Alt's not on
		JNE	SC_10B			; jump
SC_10A:
		JMP	DEAD_KEY_ERROR		; else, error
SC_10B:
		SUB	AL,10			;Eliminate BIAS
		JNZ	SC_11
		MOV	AL,01BH			;ESC key
		JMP	OC_1
SC_11:
		DEC	AL			;TAB key
		JNZ	SC_13
		CMP	SHIFT_FLAGS,0		;Any shift keys on?
		JE	SC_12			; no, jump
		CMP	SHIFT_FLAGS,_SHIFT	;SHIFT only is allowed
		JNE	SC_10A			; else error
		MOV	AX,0FE0FH		;SHIFT-TAB
		JMP	OUTPUT_CODE		;to output
SC_12:
		MOV	AL,9			;Normal TAB
SC_12A:
		JMP	OC_1

;----------------------------------------------------------------------
;  These keys are the same alone or with SHIFT, but CTRL is different.
;----------------------------------------------------------------------
SC_13:
		DEC	AL			;Remove bias
		XOR	AH,AH			;Zero AH
		MOV	DI,OFFSET KEY_TBL_4	;Table of SHIFT/CTRL values
		SHL	AX,1			;Make into offset
		ADD	DI,AX			; from start of table
		MOV	DH,SHIFT_FLAGS		;If CTRL
		CMP	DH,_CTRL
		JNE	SC_14
		INC	DI			; move one byte further
SC_14:
		MOV	DL,[DI]			;Get char from table
		OR	DL,DL			; =0 if illegal
		JZ	SC_10A
		XCHG	AL,DL			;Put offset in DL
		CMP	DL,2			;What key?
		JE	SC_12A			;If BS, all ascii
		JA	SC_15			;above, all extended
		CMP	DH,_CTRL		;CTRL-ENTER is special
		JNE	SC_12A
SC_15:
		MOV	AH,0FEH			;Add extended code
		JMP	OUTPUT_CODE

TKN_STRING	ENDP

;======================================================================
;  Read from the BDF file into a buffer.  If an EOF is found, perform
;  the final cleanup and return to the main procedure.
; (must also keep track of file pointer and signal when EOF)
;----------------------------------------------------------------------
REFRESH_BUFFER	PROC	NEAR

		PUSH	BX
		PUSH	CX
		PUSH	DX

		MOV	AH,42H			;Move file pointer
		XOR	AL,AL			; offset from begining
		MOV	BX,INPUT_HNDL		;File handle
		XOR	CX,CX			;Offset CX:DX
		MOV	DX,INPUT_HNDL_PTR
		INT	21H			;Thru DOS
		JC	READ_ERR

;----------------------------------------------------------------------
;  Fill buffer.
;----------------------------------------------------------------------
		MOV	AH,3FH			;Read from handle fn
		MOV	BX,INPUT_HNDL
		MOV	CX,INPUT_BUF_LEN	;Number bytes to read
		MOV	SI,OFFSET INPUT_BUF
		MOV	DX,SI			;DS:DX destination

		CMP	[INPUT_HNDL_PTR],0	;If start of file
		JNE	NOT_FIRST_READ
		MOV	BYTE PTR [SI],20H	;Make a current char
		DEC	CX			;Read one less byte
		INC	DX			;New destination
NOT_FIRST_READ:
		INT	21H			;Thru DOS
		JNC	READ_OK
READ_ERR:
		MOV	DX,OFFSET READ_MSG
		JMP	ERROR_EXIT
READ_OK:
		ADD	INPUT_HNDL_PTR,AX	;Add bytes read
		SUB	DX,SI			;Calculate ending address
		ADD	AX,DX			; of our buffer
		MOV	INPUT_BUF_END,AX	; and save it

		POP	DX			;Restore registers
		POP	CX
		POP	BX
		RET

REFRESH_BUFFER	ENDP

;======================================================================
;  Copy the word at SI into a buffer and make it asciiz
;----------------------------------------------------------------------  
MAKEZ		PROC	NEAR

		PUSH	DI
		MOV	DI,OFFSET PATH_BUF	;Destination
		PUSH	DI
MZ_1:
		CALL	IS_WHITE		;Examine char at SI
		JNC	MZ_2

		MOV	AL,[SI]			;Get the char
		CMP	AL,CR			;Is it CR?
		JE	MZ_2			; yes, terminate string
		CALL	MAKE_UC			; else, change to lower case
		STOSB				;  save at DI
		CALL	GET_CHAR		;Get next char
		JMP	MZ_1
MZ_2:
		XOR	AL,AL			;Make ASCIIZ
		STOSB

		POP	AX			;Return buffer address
		POP	DI			;Restore pointer
		RET

MAKEZ		ENDP

;======================================================================
;  Get a char from the input buffer.  If past the end of the buffer,
;  refresh the buffer.  Check for EOF (SI = INPUT_BUF_END != BUF_LEN)
;  If comments are detected, they are weeded out.
;----------------------------------------------------------------------
COMMENT_FLAG	DB	0			;=1 if inside comment

GET_CHAR	PROC	NEAR
;----------------------------------------------------------------------
;  Check buffer for pointer past end.
;----------------------------------------------------------------------
		PUSH	AX			;Save register
		INC	SI			;Advance pointer
		MOV	AX,SI			;Current location
		SUB	AX,OFFSET INPUT_BUF	; minus start
		CMP	AX,INPUT_BUF_END	; longer than allowed
		POP	AX			;(restore pointer)
		JB	GC_1			; no need to refresh
		CALL	REFRESH_BUFFER		;Attempt to load buffer

;----------------------------------------------------------------------
;  AX contains the number of chars read.  If AX=0, unexpected EOF.
;----------------------------------------------------------------------
		OR	AX,AX			;# chars read
		JNZ	GC_1			;jump if not 0
		MOV	DX,OFFSET EOF_MSG
		JMP	ERROR_EXIT

;----------------------------------------------------------------------
;  check for, and eliminate comments
;----------------------------------------------------------------------
GC_1:
		MOV	AL,[SI]			;Get new char
		CMP	AL,CR			;If new line
		JNE	GC_3
		MOV	COMMENT_FLAG,0		; reset comment
		INC	SOURCE_LINE		; next line
GC_2:
		CMP	COMMENT_FLAG,0		;If inside comment
		JNE	GET_CHAR		; read until CR
		RET
GC_3:
		CMP	AL,';'			;If this isn't a comment
		JNE	GC_2			; then continue
		INC	COMMENT_FLAG		;else read until CR
		JMP	GET_CHAR

GET_CHAR	ENDP

;======================================================================
PUT_MENUBUF	PROC	NEAR

		MOV	[BX],AL			;Write byte to [bx]
		INC	BX			;Move pointer
		RET

PUT_MENUBUF	ENDP

;======================================================================
;  Buffer Allocation area
;----------------------------------------------------------------------
PC		=	$
LAST_BYTE	=	PC

PATH_BUF	=	PC			;DB 64 DUP (?)
PC		=	PC + 64

INPUT_BUF	=	PC			;DB INPUT_BUF_LEN DUP(?)
PC		=	PC + INPUT_BUF_LEN

OUTPUT_BUF	=	PC			;DB OUTPUT_BUF_LEN DUP(?)
PC		=	PC + OUTPUT_BUF_LEN

MENU_BUF	=	PC			;DB MENU_BUF_LEN DUP(?)
PC		=	PC + MENU_BUF_LEN

MENU_NAME_TBL	=	PC			;DB MENU_TBL_ELN DUP(?)
PC		=	PC + MENU_TBL_LEN

;----------------------------------------------------------------------
CSEG	ENDS
	END	ENTPT