Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-1


					PAGE	90,132			;A2
					TITLE	fastp.asm - fastopen SYSTEM COMMAND LINE PARSER
				;****************** START OF SPECIFICATIONS *****************************
				; MODULE NAME: fastp.asm
				;
				; DESCRIPTIVE NAME: Include the DOS system PARSER in the SEGMENT
				;		    configuration expected by the modules of fastopen.
				;
				;FUNCTION: The common code of the DOS command line PARSER is optimized by
				;	   the setting of certain switches that cause the conditional
				;	   assembly of only the required portions of the common PARSER.
				;
				; ENTRY POINT: SYSPARSE, near
				;
				; INPUT:
				;	ES - has seg id of the SEGMENT
				;	     that contains the input control blocks,
				;	     defined below.
				;
				;	DI - offset into ES of the PARMS INPUT BLOCK
				;
				;	DS - has seg id of the SEGMENT
				;	     that contains the DOS input COMMAND
				;	     string, which is originally presented at 81h
				;	     in the PSP.
				;
				;	SI - offset into DS of the text of the DOS input COMMAND string
				;	     as originally presented at 81H in the PSP.
				;
				;	DX - zero
				;
				;	CX - ordinal value, intially zero, updated on each subsequent call
				;	     to the value returned in CX on the previous call.
				;
				;	CS - points to the segment containing the
				;	     INCLUDE PARSE.ASM statement
				;
				;	DS - also points to the segment containing the INCLUDE
				;	     PARSE.ASM statement.
				;
				; EXIT-NORMAL:	Output registers:
				;	 AX - return code:
				;	    RC_No_Error     equ     0	 ; No error
				;	    RC_EOL	    equ     -1	 ; End of command line
				;
				;	 DX - Offset into ES of the selected RESULT BLOCK.
				;	 BL - terminated delimiter code
				;	 CX - new operand ordinal
				;	 SI - set past scanned operand
				;
				; EXIT-ERROR: Output registers:
				;	 AX - return code:
				;	    RC_Too_Many     equ     1	 ; Too many operands
				;	    RC_Op_Missing   equ     2	 ; Required operand missing
				;	    RC_Not_In_SW    equ     3	 ; Not in switch list provided
				;	    RC_Not_In_Key   equ     4	 ; Not in keyword list provided
				;	    RC_Out_Of_Range equ     6	 ; Out of range specified
				;	    RC_Not_In_Val   equ     7	 ; Not in value list provided
				;	    RC_Not_In_Str   equ     8	 ; Not in string list provided
				;	    RC_Syntax	    equ     9	 ; Syntax error
				;
				; INTERNAL REFERENCES:
				;    ROUTINES: SYSPARSE:near (INCLUDEd in PARSE.ASM)
				;
				;    DATA AREAS: none
				;
				; EXTERNAL REFERENCES:
				;    ROUTINES: none
				;
				;    DATA AREAS: control blocks pointed to by input registers.
				;
				; NOTES:
				;
				;	 For LINK instructions, refer to the PROLOG of the main module,
				;	 fastopen.asm.
				;
				; REVISION HISTORY: A000 Version 4.00: add PARSER, System Message Handler,
				;
				; COPYRIGHT: "MS DOS FASTOPEN Utility"
				;	     "Version 4.00 (C)Copyright 1988 Microsoft  "
				;	     "Licensed Material - Property of Microsoft  "
				;
				;PROGRAM AUTHOR: DOS 4.00 P L
				;
				;****************** END OF SPECIFICATIONS *****************************
				; =  =	=  =  =  =  =  =  =  =	=  =
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-2


					HEADER	<MACRO DEFINITION>	;					;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-3
MACRO DEFINITION                                            

				; =  =	=  =  =  =  =  =  =  =	=  =
				
				HEADER	MACRO	TEXT			;;					;AN000;
				.XLIST
					SUBTTL	TEXT
				.LIST
					PAGE				;;					;AN000;
					ENDM				;;					;AN000;
				
				; =  =	=  =  =  =  =  =  =  =	=  =
					HEADER	<SYSPARSE - SYSTEM COMMAND LINE PARSER> ;			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-4
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 0000				CSEG_INIT    SEGMENT PARA PUBLIC 'CODE'      ;
					ASSUME	CS:CSEG_INIT,DS:CSEG_INIT,ES:CSEG_INIT
				
					PUBLIC	SYSPARSE		;SUBROUTINE ENTRY POINT 		;AN000;
				
				
 = 0001				INCSW	EQU	1			;INCLUDE PSDATA.INC			;AN000;
 = 0000				FARSW	EQU	0			;CALL THE PARSER BY NEAR CALL
 = 0000				DATESW	EQU	0			;SUPPRESS DATE CHECKING 		;AN000;
 = 0000				TIMESW	EQU	0			;SUPPRESS TIME CHECKING 		;AN000;
 = 0000				FILESW	EQU	0			;SUPPRESS CHECKING FILE SPECIFICATION	;AN000;
 = 0000				CAPSW	EQU	0			;SUPPRESS FILE TABLE CAPS		;AN000;
 = 0001				CMPXSW	EQU	1			;SUPPRESS CHECKING COMPLEX LIST
 = 0001				DRVSW	EQU	1			;SUPPRESS SUPPORT OF DRIVE ONLY FORMAT
 = 0000				QUSSW	EQU	0			;SUPPRESS SUPPORT OF QUOTED STRING FORMAT ;AN000;
 = 0001				NUMSW	EQU	1			;SUPPRESS CHECKING NUMERIC VALUE
 = 0000				KEYSW	EQU	0			;SUPPRESS KEYWORD SUPPORT		;AN000;
 = 0001				SWSW	EQU	1			;DO SUPPORT SWITCHES			;AN000;
 = 0000				VAL1SW	EQU	0			;SUPPRESS SUPPORT OF VALUE DEFINITION 1 ;AN000;
 = 0000				VAL2SW	EQU	0			;SUPPRESS SUPPORT OF VALUE DEFINITION 2 ;AN000;
 = 0000				VAL3SW	EQU	0			;DO SUPPORT VALUE DEFINITION 3
				
				
					INCLUDE PARSE.ASM		;					;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-5
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C		PAGE				;AN000;
			     C	;  $SALUT (4,4,8,41)
			     C	;(deleted).XLIST
			     C	;(deleted)INCLUDE   STRUC.INC ;AN020;structured macro definitions for .IF,.ELSE etc.
			     C	;(deleted).LIST
			     C	;
			     C	; NOTE:   basesw must be set properly to allow the PARSER to access psdata.
			     C	;	   - basesw undefined	 means	 CS seg. override for psdata access.
			     C	;	   - basesw = 1 	 means	 DS seg. override for psdata access &
			     C	;					 DS must point to psdata.
			     C	;	   - basesw = 0 	 means	 ES seg. override for psdata access &
			     C	;					 ES must point to psdata.
			     C	;
			     C	;
			     C	IFNDEF basesw				;AN022;
 =                           C	   psdata_seg EQU   CS			;AN022;
			     C	ENDIF					;AN022;
			     C	
			     C	if incsw				;AN000; If incsw = 1 then (tm03)
			     C	   include psdata.inc			;AN000;    include psdata.inc (tm03)
			     C	;*******************************************************************
			     C	; Parser include file
			     C	;*******************************************************************
			     C	;
			     C	;**** Default assemble switches definition *************************
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	
			     C	;**** Equation field
			     C	;-------- Character code definition
			     C	
 = 0081                      C	$P_DBSP1	   equ	81h		;AN000; 1st byte of DBCS blank
 = 0040                      C	$P_DBSP2	   equ	40h		;AN000; 2nd byte of DBCS blank
 = 002E                      C	$P_Period	   equ	"."             ;AN020;
 = 002F                      C	$P_Slash	   equ	"/"             ;AN020;
 = 0020                      C	$P_Space	   equ	" "             ;AN000; SBCS blank
 = 002C                      C	$P_Comma	   equ	","             ;AN000;
 = 002F                      C	$P_Switch	   equ	"/"             ;AN000;
 = 003D                      C	$P_Keyword	   equ	"="             ;AN000;
 = 003A                      C	$P_Colon	   equ	":"             ;AN000;
 = 002B                      C	$P_Plus 	   equ	"+"             ;AN000;
 = 002D                      C	$P_Minus	   equ	"-"             ;AN000;
 = 0029                      C	$P_Rparen	   equ	")"             ;AN000;
 = 0028                      C	$P_Lparen	   equ	"("             ;AN000;
			     C	;(deleted ;AN025;) $P_SQuote	      equ  "'"
 = 0022                      C	$P_DQuote	   equ	'"'             ;AN000;
 = 0000                      C	$P_NULL 	   equ	0		;AN000;
 = 0009                      C	$P_TAB		   equ	9		;AN000;
 = 000D                      C	$P_CR		   equ	0Dh		;AN000;
 = 000A                      C	$P_LF		   equ	0Ah		;AN000;
 = 0080                      C	$P_ASCII80	   equ	80h		;AN000; ASCII 80h character code
			     C	
			     C	;-------- Masks
 = 0020                      C	$P_Make_Lower	   equ	20h		;AN000; make lower case character
 = 00DF                      C	$P_Make_Upper	   equ	0ffh-$P_Make_Lower ;AN000; make upper case character
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-6
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C			   PAGE 		   ;AN000;
			     C	;-------- DOS function call related equs
			     C	
 = 3800                      C	$P_DOS_Get_CDI	   equ	3800h		;AN000; get country dependent information
			     C						; by this call, following information
			     C	$P_CDI		   struc		;AN000; is returned.
 0000  0000                  C	$P_CDI_DateF	   dw	0		;AN000;
 0002  00 00 00 00 00        C	$P_CDI_Money	   db	0,0,0,0,0	;AN000;
 0007  00 00                 C	$P_CDI_1000	   db	0,0		;AN000;
 0009  00 00                 C	$P_CDI_Dec	   db	0,0		;AN000;
 000B  00 00                 C	$P_CDI_DateS	   db	0,0		;AN000;
 000D  00 00                 C	$P_CDI_TimeS	   db	0,0		;AN000;
 000F  00                    C			   db	0		;AN000;
 0010  00                    C			   db	0		;AN000;
 0011  00                    C	$P_CDI_TimeF	   db	0		;AN000;
 0012  0000 0000             C			   dw	0,0		;AN000;
 0016  00 00                 C			   db	0,0		;AN000;
 0018  0005[                 C			   dw	5 dup(0)	;AN000;
	   0000              C	
			 ]   C	
			     C	
 0022                        C	$P_CDI		   ends 		;AN000;
			     C	
 = 0000                      C	$P_Date_MDY	   equ	0		;AN000;
 = 0001                      C	$P_Date_DMY	   equ	1		;AN000;
 = 0002                      C	$P_Date_YMD	   equ	2		;AN000;
			     C	;-------------
 = 6300                      C	$P_DOS_GetEV	   equ	6300h		;AN000; get DBCS EV call
			     C						;AN000; DS:SI will points to DBCS EV
			     C	;-------------
 = 0065                      C	$P_DOS_Get_TBL	   equ	65h		;AN000; get uppercase table call
			     C						;AN000; following parameters are set
			     C						;AN000; to get casemap table.
 =-0001                      C	$P_DOSTBL_Def	   equ	-1		;AN000; get default
 = 0005                      C	$P_DOSTBL_BL	   equ	5		;AN000; buffer length for Tbl pointer
 = 0004                      C	$P_DOSTBL_File	   equ	4		;AN000; get file uppercase table
 = 0002                      C	$P_DOSTBL_Char	   equ	2		;AN000; get character uppercase table
			     C						; By this call following information
			     C						; is returned.
			     C	$P_DOS_TBL	   struc		;AN000;
 0000  00                    C	$P_DOS_InfoID	   db	0		;AN000; information id for the table
 0001  0000                  C	$P_DOS_TBL_Off	   dw	0		;AN000; offset address of the table
 0003  0000                  C	$P_DOS_TBL_Seg	   dw	0		;AN000; segment address of the table
 0005                        C	$P_DOS_TBL	   ends 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-7
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C			   PAGE 		;AN000;
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	; PARMS 	LABEL	BYTE
			     C	;		DW	PARMSX
			     C	;		DB	2			; NUMBER OF STRINGS (0, 1, 2)
			     C	;		DB	length			; LENGTH OF THE NEXT LIST, 0 IF NONE
			     C	;		DB	" .. "                  ; EXTRA DELIMITER LIST,
			     C	;						; TYPICAL ARE ";", "="
			     C	;						; "," & WHITESPACE ALWAYS
			     C	;		DB	length			; LENGTH OF THE NEXT LIST, 0 IF NONE
			     C	;		DB	" .. "                  ; EXTRA END OF LINE LIST, CR, LF OR 0 ALWAYS
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	
			     C	;-------------------------------- PARMS block structure
			     C	$P_PARMS_Blk	   struc		;AN000;
 0000  0000                  C	$P_PARMSX_Address  dw	0		;AN000; Address of PARMSX
 0002  00                    C	$P_Num_Extra	   db	0		;AN000; Number of extra stuff
 0003  00                    C	$P_Len_Extra_Delim db	0		;AN000; Length of extra delimiter
 0004                        C	$P_PARMS_Blk	   ends 		;AN000;
			     C	
 = 0004                      C	$P_Len_PARMS	   equ	4		;AN000;
 = 0000                      C	$P_I_Use_Default   equ	0		;AN000; no extra stuff specified
 = 0001                      C	$P_I_Have_Delim    equ	1		;AN000; extra delimiter specified
 = 0002                      C	$P_I_Have_EOL	   equ	2		;AN000; extra EOL specified
			     C	
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	; PARMSX	LABEL	BYTE
			     C	;		DB	minp,maxp		; MIN, MAX POSITIONAL OPERANDS ALLOWED
			     C	;		DW	CONTROL 		; DESCRIPTION OF POSITIONAL 1
			     C	;		:				; REPEATS maxp-1 TIMES
			     C	;		DB	maxs			; # OF SWITCHES
			     C	;		DW	CONTROL 		; DESCRIPTION OF SWITCH 1
			     C	;		:				; REPEATS maxs-1 TIMES
			     C	;		DB	maxk			; # OF KEYWORD
			     C	;		DW	CONTROL 		; DESCRIPTION OF KEYWORD 1
			     C	;		:				; REPEATS maxk-1 TIMES
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	
			     C	;-------------------------------- PARMSX block structure
			     C	$P_PARMSX_Blk	   struc		;AN000;
 0000  00                    C	$P_MinP 	   db	0		;AN000; Minimum positional number
 0001  00                    C	$P_Maxp 	   db	0		;AN000; Maximum positional number
 0002  0000                  C	$P_1st_Control	   dw	0		;AN000; Address of the 1st CONTROL block
 0004                        C	$P_PARMSX_Blk	   ends 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-8
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C			   PAGE 		;AN000;
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	; << Control field definition  >>
			     C	;
			     C	;
			     C	;CONTROL   LABEL   BYTE
			     C	;	   DW	   MATCH_FLAGS	   ; CONTROLS TYPE MATCHED
			     C	;				   ; 8000H=NUMERIC VALUE, (VALUE LIST WILL BE CHECKED)
			     C	;				   ; 4000H=SIGNED NUMERIC VALUE (VALUE LIST WILL BE CHECKED)
			     C	;				   ; 2000H=SIMPLE STRING(VALUE LIST WILL BE CHECKED)
			     C	;				   ; 1000H=DATE STRING (VALUE LIST WON'T BE CHECKED)
			     C	;				   ; 0800H=TIME STRING (VALUE LIST WON'T BE CHECKED)
			     C	;				   ; 0400H=COMPLEX LIST (VALUE LIST WON'T BE CHECKED)
			     C	;				   ; 0200H=FILE SPEC (VALUE LIST WON'T BE CHECKED)
			     C	;				   ; 0100H=DRIVE ONLY (VALUE LIST WON'T BE CHECKED)
			     C	;				   ; 0080H=QUOTED STRING (VALUE LIST WON'T BE CHECKED)
			     C	;				   ; 0010H=IGNORE ":" AT END IN MATCH
			     C	;				   ; 0002H=REPEATS ALLOWED
			     C	;				   ; 0001H=OPTIONAL
			     C	;	   DW	   FUNCTION_FLAGS
			     C	;				   ; 0001H=CAP RESULT BY FILE TABLE
			     C	;				   ; 0002H=CAP RESULT BY CHAR TABLE
			     C	;				   ; 0010H=REMOVE ":" AT END
			     C	; (tm10)			   ; 0020H=colon is not necessary for switch
			     C	;	   DW	   RESULT	   ; RESULT BUFFER
			     C	;	   DW	   VALUES	   ; VALUE LISTS
			     C	;	   DB	   nid		   ; NUMBER OF KEYWORD/SWITCH SYNONYMS IN FOLLOWING LIST
			     C	;	   DB	   "...",0         ; IF n >0, KEYWORD 1
			     C	;	   :
			     C	;
			     C	;Note:
			     C	;    - The MATCH_FLAG is bit significant. You can set, for example, TIME bit and
			     C	;      DATE bit simalteniously.
			     C	;
			     C	;      The parser examins each bit along with the following priority.
			     C	;
			     C	;      COMPLEX -> DATE -> TIME -> NUMERIC VAL -> SIGNED NUMERIC VAL -> DRIVE ->
			     C	;      FILE SPEC -> SIMPLE STRING.
			     C	;
			     C	;
			     C	;    - When the FUNCTION_FLAG is 0001 or 0002, the STRING pointed to by a pointer
			     C	;      in the result buffer is capitalized.
			     C	;
			     C	;    - Match_Flags 0001H and 0002H have meaning only for the positional.
			     C	;
			     C	;
			     C	;    - The "...",0 (bottom most line) does require '=' or '/'. When you need a
			     C	;      switch, for example, '/A', then STRING points to;
			     C	;
			     C	;			DB    1 	; number of following synonyms
			     C	;			DB   '/A',0
			     C	;
			     C	;      When you need a keyword, for example, 'CODEPAGE=', then "...",0 will be;
			     C	;
			     C	;			DB    1 	; number of following synonyms
			     C	;			DB   'CODEPAGE=',0
			     C	;
			     C	;
			     C	;    - "..." must consist of upper case characters only because the parser
			     C	;      performs pattern matching after converting input to upper case (by
			     C	;      using the current country upper case table)
			     C	;
			     C	;
			     C	;    - One "..." can contain only one switch or keyword. If you need, for
			     C	;      example /A and /B, the format will be;
			     C	;
			     C	;			DB    2 	; number of following synonyms
			     C	;			DB    '/A',0
			     C	;			DB    '/B',0
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	
			     C	;**** Match_Flags
			     C	
 = 8000                      C	$P_Num_Val	   equ	8000h		;AN000; Numeric Value
 = 4000                      C	$P_SNum_Val	   equ	4000h		;AN000; Signed numeric value
 = 2000                      C	$P_Simple_S	   equ	2000h		;AN000; Simple string
 = 1000                      C	$P_Date_S	   equ	1000h		;AN000; Date string
 = 0800                      C	$P_Time_S	   equ	0800h		;AN000; Time string
 = 0400                      C	$P_Cmpx_S	   equ	0400h		;AN000; Complex string
 = 0200                      C	$P_File_Spc	   equ	0200h		;AN000; File Spec
 = 0100                      C	$P_Drv_Only	   equ	0100h		;AN000; Drive Only
 = 0080                      C	$P_Qu_String	   equ	0080h		;AN000; Quoted string
 = 0010                      C	$P_Ig_Colon	   equ	0010h		;AN000; Ignore colon at end in match
 = 0002                      C	$P_Repeat	   equ	0002h		;AN000; Repeat allowed
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-9
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 = 0001                      C	$P_Optional	   equ	0001h		;AN000; Optional
			     C	
			     C	;**** Function flags
			     C	
 = 0001                      C	$P_CAP_File	   equ	0001h		;AN000; CAP result by file table
 = 0002                      C	$P_CAP_Char	   equ	0002h		;AN000; CAP result by character table
 = 0010                      C	$P_Rm_Colon	   equ	0010h		;AN000; Remove ":" at the end
 = 0020                      C	$P_colon_is_not_necessary equ 0020h	;AN000;(tm10) /+10 and /+:10
			     C	
			     C	;-------------------------------- Control block structure
			     C	$P_Control_Blk	   struc		;AN000;
 0000  0000                  C	$P_Match_Flag	   dw	0		;AN000; Controls type matched
 0002  0000                  C	$P_Function_Flag   dw	0		;AN000; Function should be taken
 0004  0000                  C	$P_Result_Buf	   dw	0		;AN000; Result buffer address
 0006  0000                  C	$P_Value_List	   dw	0		;AN000; Value list address
 0008  00                    C	$P_nid		   db	0		;AN000; # of keyword/SW synonyms
 0009  00                    C	$P_KeyorSW	   db	0		;AN000; keyword or sw
 000A                        C	$P_Control_Blk	   ends 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-10
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C			   PAGE 		;AN000;
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	; << Value List Definition >>
			     C	;
			     C	;VALUES 	LABEL	BYTE
			     C	;		DB	nval			; NUMBER OF VALUE DEFINITIONS (0 - 3)
			     C	;	     Ú
			     C	;	     ³	DB	nrng			; NUMBER OF RANGES
			     C	;	     ³ ÚDB	ITEM_TAG		; RETURN VALUE IF RANGE MATCHED
			     C	;	     ³ ÀDD	X,Y			; RANGE OF VALUES
			     C	;	     ³	:
			     C	;	     ³	DB	nnval			; NUMBER OF CHOICES
			     C	;	     ³ ÚDB	ITEM_TAG		; RETURN VALUE IF NUMBER CHOICE MATCHED
			     C	;	     ³ ÀDD	VALUE			; SPECIFIC CHOICE IF NUMBER
			     C	;	     ³	:
			     C	;	     ³	DB	nstrval 		; NUMBER OF CHOICES
			     C	;	     ³ ÚDB	ITEM_TAG		; RETURN VALUE IF STRING CHOICE MATCHED
			     C	;	     ³ ÀDW	STRING			; SPECIFIC CHOICE IF STING
			     C	;	     À	:
			     C	;
			     C	;STRING 	DB	"...",0                 ; ASCIIZ STRING IMAGE
			     C	;
			     C	;Note:
			     C	;    - ITEM_TAG must not be 0FFH, which will be used in the result buffer
			     C	;      when no choice lists are provided.
			     C	;
			     C	;    - STRING must consist of upper case characters only because the parser
			     C	;      performs pattern matching after converting input to upper case (by
			     C	;      using the current country upper case table)
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	
 = 0000                      C	$P_nval_None	   equ	0		;AN000; no value list ID
 = 0001                      C	$P_nval_Range	   equ	1		;AN000; range list ID
 = 0002                      C	$P_nval_Value	   equ	2		;AN000; value list ID
 = 0003                      C	$P_nval_String	   equ	3		;AN000; string list ID
 = 0009                      C	$P_Len_Range	   equ	9		;AN000; Length of a range choice(two DD plus one DB)
 = 0005                      C	$P_Len_Value	   equ	5		;AN000; Length of a value choice(one DD plus one DB)
 = 0003                      C	$P_Len_String	   equ	3		;AN000; Length of a string choice(one DW plus one DB)
 = 0000                      C	$P_No_nrng	   equ	0		;AN000; (tm07) no nrng. nnval must not be 0.
			     C	
			     C	$P_Val_List	   struc		;AN000;
 0000  00                    C	$P_NumofList	   db	0		;AN000; number of following choice
 0001  0000                  C	$P_Val_XL	   dw	0		;AN000; lower word of value
 0003  0000                  C	$P_Val_XH	   dw	0		;AN000; higher word of value
 0005  0000                  C	$P_Val_YL	   dw	0		;AN000; lower word of another value
 0007  0000                  C	$P_Val_YH	   dw	0		;AN000; higher word of another value
 0009                        C	$P_Val_List	   ends 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-11
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C			   PAGE 		;AN000;
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	; << Result Buffer Definition  >>
			     C	;
			     C	;RESULT 	LABEL	BYTE			; BELOW FILLED IN FOR DEFAULTS
			     C	;		DB	type			; TYPE RETURNED: 0=RESERVED,
			     C	;						;	1=NUMBER, 2=LIST INDEX,
			     C	;						;	3=STRING, 4=COMPLEX,
			     C	;						;	5=FILESPEC, 6=DRIVE
			     C	;						;	7=DATE, 8=TIME
			     C	;						;	9=QUOTED STRING
			     C	;		DB	ITEM_TAG		; MATCHED ITEM TAG
			     C	;
			     C	;		dw	synonym@		; es:@ points to found SYNONYM if provided.
			     C	;
			     C	;
			     C	;	    Ú	DD	n			; VALUE IF NUMBER
			     C	;	    ³ or
			     C	;	    ³	DW	i			; INDEX (OFFSET) INTO VALUE LIST
			     C	;	    ³					; (ES presents Segment address)
			     C	;	    ³ or
			     C	;	    ³	DD	STRING			; OFFSET OF STRING VALUE
			     C	;	    ³ or
			     C	;	    ³	DB	drv			; DRIVE NUMBER (1-A, 2-B,..., 26-Z)
			     C	;	    ³ or
			     C	;	    ³	DW	YEAR	   ;(1980-2099)  IN CASE OF DATE
			     C	;	    ³	DB	MONTH	   ;(1-12)	 Note: Range check is not performed.
			     C	;	    ³	DB	DATE	   ;(1-31)	       0 is filled when the corresponding field was 
				not specified.
			     C	;	    ³ or
			     C	;	    ³	DB	HOUR	   ;(0-23)	  IN CASE OF TIME
			     C	;	    ³	DB	MINUTES    ;(0-59)	  Note: Range check is not performed .
			     C	;	    ³	DB	SECONDS    ;(0-59)		0 is filled when the corresponding field was
				 not specified .
			     C	;	    ³	DB	HUNDREDTHS ;(0-99)
			     C	;	    À
			     C	;
			     C	;
			     C	;Note: ITEM_TAG is 0FFH when the caller does not specify the choice
			     C	;      list.
			     C	;
			     C	;      YEAR: If the input value for the year is less than 100, parser
			     C	;	     adds 1900 to it.  For example, when 87 is input to parser for
			     C	;	     the year value, he returns 1987.
			     C	;---------------------------------------------------------------------------------------------------
				------
			     C	
			     C	;-------------------------------- Result block structure
			     C	$P_Result_Blk	   struc		;AN000;
 0000  00                    C	$P_Type 	   db	0		;AN000; Type returned
 0001  00                    C	$P_Item_Tag	   db	0		;AN000; Matched item tag
 0002  0000                  C	$P_SYNONYM_Ptr	   dw	0		;AN000; pointer to Synonym list returned
 0004  00 00 00 00           C	$P_Picked_Val	   db	0,0,0,0 	;AN000; value
 0008                        C	$P_Result_Blk	   ends 		;AN000;
			     C	;--------------------------------
			     C	;**** values for the type field in the result block
			     C	
 = 0000                      C	$P_EOL		   equ	0		;AN000; End of line
 = 0001                      C	$P_Number	   equ	1		;AN000; Number
 = 0002                      C	$P_List_Idx	   equ	2		;AN000; List Index
 = 0003                      C	$P_String	   equ	3		;AN000; String
 = 0004                      C	$P_Complex	   equ	4		;AN000; Complex
 = 0005                      C	$P_File_Spec	   equ	5		;AN000; File Spec
 = 0006                      C	$P_Drive	   equ	6		;AN000; Drive
 = 0007                      C	$P_Date_F	   equ	7		;AN000; Date
 = 0008                      C	$P_Time_F	   equ	8		;AN000; Time
 = 0009                      C	$P_Quoted_String   equ	9		;AN000; Quoted String
			     C	
 = 00FF                      C	$P_No_Tag	   equ	0FFH		;AN000; No ITEM_TAG found
			     C	;**** Return code
			     C	;
			     C	; following return code will be returned in the AX register.
			     C	
 = 0000                      C	$P_No_Error	   equ	0		;AN000; No error
 = 0001                      C	$P_Too_Many	   equ	1		;AN000; Too many operands
 = 0002                      C	$P_Op_Missing	   equ	2		;AN000; Required operand missing
 = 0003                      C	$P_Not_In_SW	   equ	3		;AN000; Not in switch list provided
 = 0004                      C	$P_Not_In_Key	   equ	4		;AN000; Not in keyword list provided
 = 0006                      C	$P_Out_Of_Range    equ	6		;AN000; Out of range specified
 = 0007                      C	$P_Not_In_Val	   equ	7		;AN000; Not in value list provided
 = 0008                      C	$P_Not_In_Str	   equ	8		;AN000; Not in string list provided
 = 0009                      C	$P_Syntax	   equ	9		;AN000; Syntax error
 =-0001                      C	$P_RC_EOL	   equ	-1		;AN000; End of command line
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-12
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C			   PAGE 		;AN000;
			     C	;********************** Local Data *************************************
 0000  0000                  C	$P_ORDINAL	   dw	0		;AN000; Operand ordinal save area
 0002  0000                  C	$P_RC		   dw	0		;AN000; Return code from parser
 0004  0000                  C	$P_SI_Save	   dw	0		;AN000; Pointer of command buffer
 0006  0000                  C	$P_DX		   dw	0		;AN000; Return result buffer address
 0008  00                    C	$P_Terminator	   db	0		;AN000; Terminator code (ASCII)
 0009  0000                  C	$P_DBCSEV_OFF	   dw	0		;AN000; Offset of DBCS EV
 000B  0000                  C	$P_DBCSEV_SEG	   dw	0		;AN000; Segment of DBCS EV
 000D  0000                  C	$P_Flags	   dw	0		;AN000; Parser internal flags
 = 000D                      C	$P_Flags1	   equ	byte ptr $P_Flags ;AN038; to reference first byte flags
 = 000E                      C	$P_Flags2	   equ	byte ptr $P_Flags+1 ;AN038; to reference second byte flags only
			     C	
			     C	;in second byte of $P_Flags, referenced as $P_Flags2:
 = 0001                      C	$P_equ		   equ	01h	      ;AN000; "=" packed in string buffet
 = 0002                      C	$P_Neg		   equ	02h	      ;AN000; Negative value
 = 0004                      C	$P_Time12	   equ	04h	      ;AN000; set when PM is specified
 = 0008                      C	$P_Key_Cmp	   equ	08h	      ;AN000; set when keyword compare
 = 0010                      C	$P_SW_Cmp	   equ	10h	      ;AN000; set when switch compare
 = 0020                      C	$P_Extra	   equ	20h	      ;AN000; set when extra delimiter found
 = 0040                      C	$P_SW		   equ	40h	      ;AN000; set when switch found (tm08)
 = 0080                      C	$P_Signed	   equ	80h	      ;AN000; signed numeric specified
			     C	
			     C	;in first byte of $P_Flags, referenced as $P_Flags1:
 = 0001                      C	$P_time12am	   equ	01h	      ;AN038; set when AM is specified on time
 = 0002                      C	$P_TIME_AGAIN	   EQU	02H	      ;AN039; SET WHEN READY TO RE-PARSE TIME
			     C	
 000F  0000                  C	$P_SaveSI_Cmpx	   dw	0		;AN000; save si for later use by complex
 0011  0000                  C	$P_KEYorSW_Ptr	   dw	0		;AN000; points next to "=" or ":" code
 0013  0000                  C	$P_Save_EOB	   dw	0		;AN000; save pointer to EOB
 0015  0000                  C	$P_Found_SYNONYM   dw	0		;AN000; es:@ points to found synonym
			     C	
 0017  0080[                 C	$P_STRING_BUF	   db	128 dup(0)	;AN000; Pick a operand from command line
	   00                C	
			 ]   C	
			     C	
 = 0097                      C	$P_STRING_BUF_END  equ	$		;AN000;
 0097  FF                    C	$P_Char_CAP_Ptr    db	0ffh		;AN000; info id
 0098  0000                  C			   dw	0		;AN000; offset	of char case map table
 009A  0000                  C			   dw	0		;AN000; segment of char case map table
			     C	; (tm06) IF	   FileSW		;AN000;(Check if file spec is supported)
			     C	IF		   FileSW+DrvSW 	;AN000;(Check if file spec is supported)
 009C  5B 5D 7C 3C 3E 2B     C	$P_FileSp_Char	   db	'[]|<>+=;"'     ;AN000; delimitter of file spec
       3D 3B 22              C	
 = 0009                      C	$P_FileSp_Len	   equ	$-$P_FileSp_Char ;AN000;
			     C	ENDIF					;AN000;(of FileSW)
			     C	; (tm05) IF	   QusSW		;AN000;(Check if quoted string is supported)
			     C	;(deleted ;AN025;) IF		      QusSW+CmpxSW	   ; (tm05) ;AN000;(Check if quoted string i
				s supported)
			     C	;(deleted ;AN025;) $P_SorD_Quote      db   0		   ;AN000; keep double or single quote
			     C	;(deleted ;AN025;) ENDIF				   ;AN000;(of QueSW)
			     C	
			     C	; delimiter parsing
 = 0001                      C	$P_colon_period    equ	01		;AN032; check for colon & period
 = 0002                      C	$P_period_only	   equ	02		;AN032; check only for period
			     C	
			     C	;filespec error flag
 00A5  00                    C	$P_err_flag	   db	00		;AN033; flag set if filespec parsing error
			     C						;AN033;  was detected.
 = 0001                      C	$P_error_filespec  equ	01		;AN033; mask to set flag
			     C	;***********************************************************************
			     C	endif					;AN000; endif		  (tm03)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-13
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	   PAGE 				;AN000;
			     C	;***********************************************************************
			     C	; SysParse;
			     C	;
			     C	;  Function : Parser Entry
			     C	;
			     C	;  Input: DS:SI -> command line
			     C	;	  ES:DI -> parameter block
			     C	;	  psdata_seg -> psdata.inc
			     C	;	  CX = operand ordinal
			     C	;
			     C	;	  Note:  ES is the segment containing all the control blocks defined
			     C	;		 by the caller, except for the DOS COMMAND line parms, which
			     C	;		 is in DS.
			     C	;
			     C	;  Output: CY = 1   error of caller, means invalid parameter block or
			     C	;		    invalid value list. But this parser does NOT implement
			     C	;		    this feature. Therefore CY always zero.
			     C	;
			     C	;	   CY = 0   AX = return code
			     C	;		    BL = terminated delimiter code
			     C	;		    CX = new operand ordinal
			     C	;		    SI = set past scaned operand
			     C	;		    DX = selected result buffer
			     C	;
			     C	; Use:	$P_Skip_Delim, $P_Chk_EOL, $P_Chk_Delim, $P_Chk_DBCS
			     C	;	$P_Chk_Swtch, $P_Chk_Pos_Control, $P_Chk_Key_Control
			     C	;	$P_Chk_Sw_Control, $P_Fill_Result
			     C	;
			     C	; Vars: $P_Ordinal(RW), $P_RC(RW), $P_SI_Save(RW), $P_DX(R), $P_Terminator(R)
			     C	;	$P_SaveSI_Cmpx(W), $P_Flags(RW), $P_Found_SYNONYM(R), $P_Save_EOB(W)
			     C	;
			     C	;-------- Modification History -----------------------------------------
			     C	;
			     C	;  4/04/87 : Created by K. K,
			     C	;  4/28/87 : $P_Val_YH assemble error (tm01)
			     C	;	   : JMP SHORT assemble error (tm02)
			     C	;  5/14/87 : Someone doesn't want to include psdata (tm03)
			     C	;  6/12/87 : $P_Bridge is missing when TimeSw equ 0 and (CmpxSw equ 1 or
			     C	;	     DateSW equ 1)	      (tm04)
			     C	;  6/12/87 : $P_SorD_Quote is missing when QusSw equ 0 and CmpxSW equ 1
			     C	;				      (tm05) in PSDATA.INC
			     C	;  6/12/87 : $P_FileSp_Char and $P_FileSP_Len are missing
			     C	;	     when FileSW equ 0 and DrvSW equ 1 (tm06) in PSDATA.INC
			     C	;  6/18/87 : $VAL1 and $VAL3, $VAL2 and $VAL3 can be used in the same
			     C	;	     value-list block	      (tm07)
			     C	;  6/20/87 : Add $P_SW to check if there's an omiting parameter after
			     C	;	     switch (keyword) or not. If there is, backup si for next call
			     C	;	     (tm08)
			     C	;  6/24/87 : Complex Item checking does not work correctly when CmpSW equ 1
			     C	;	     and DateSW equ 0 and TimeSW equ 0 (tm09)
			     C	;  6/24/87 : New function flag $P_colon_is_not_necessary for switch
			     C	;	     /+15 and /+:15 are allowed for user (tm10)
			     C	;  6/29/87 : ECS call changes DS register but it causes the address problem
			     C	;	     in user's routines. $P_Chk_DBCS (tm11)
			     C	;  7/10/87 : Switch with no_match flag (0x0000H) does not work correctly
			     C	;					  (tm12)
			     C	;  7/10/87 : Invalid switch/keyword does not work correctly
			     C	;					  (tm13)
			     C	;  7/10/87 : Drive_only breaks 3 bytes after the result buffer
			     C	;					  (tm14)
			     C	;  7/12/87 : Too_Many_Operands sets DX=0 as the PARSE result
			     C	;					  (tm15)
			     C	;  7/24/87 : Negative lower bound on numeric ranges cause trouble
			     C	
			     C	;  7/24/87 : Quoted strings being returned with quotes.
			     C	
			     C	;  7/28/87 : Kerry S (;AN018;)
			     C	;	     Non optional value on switch (match flags<>0 and <>1) not flagged
			     C	;	     as an error when missing.	Solution: return error 2.  Modules
			     C	;	     affected: $P_Chk_SW_Control.
			     C	
			     C	;  7/29/87 : Kerry S (;AN019;)
			     C	;	     Now allow the optional bit in match flags for switches.  This
			     C	;	     allows the switch to be encountered with a value or without a
			     C	;	     value and no error is returned.
			     C	;
			     C	
			     C	;  8/28/87 : Ed K, Kerry S (;AN020;)
			     C	;  9/14/87   In PROC $P_Get_DecNum, when checking for field separators
			     C	;	     within a date response, instead of checking just for the one
			     C	;	     character defined by the COUNTRY DEPENDENT INFO, check for
			     C	;	     all three chars, "-", "/", and ".". Change $P_Chk_Switch to allow
			     C	;	     slashes in date strings when DateSw (assembler switch) is set.
			     C	
			     C	;  9/1/87  : Kerry S (;AN021)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-14
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	;	     In PROC $P_String_Comp, when comparing the switch or keyword on
			     C	;	     the command line with the string in the control block the
			     C	;	     comparing was stopping at a colon (switch) or equal (keyword)
			     C	;	     on the command line and assuming a match.	This allowed a shorter
			     C	;	     string on the command line than in the synonym list in the control
			     C	;	     block.  I put in a test for a null in the control block so the
			     C	;	     string in the control block must be the same length as the string
			     C	;	     preceeding the colon or equal on the command line.
			     C	
			     C	;  8/28/87 : Kerry S (;AN022;)
			     C	;	     All references to data in PSDATA.INC had CS overrides.  This caused
			     C	;	     problems for people who included it themselves in a segment other
			     C	;	     than CS.  Added switch to allow including PSDATA.INC in any
			     C	;	     segment.
			     C	
			     C	;  9/16/87 : Ed K (;AN023;) PTM1040
			     C	;	     in $p_set_cdi PROC, it assumes CS points to psdata. Change Push CS
			     C	;	     into PUSH PSDATA_SEG.  In $P_Get_DecNum PROC, fix AN020
			     C	;	     forced both TIME and DATE to use the delims, "-","/",".".
			     C	;	     Created FLag, in $P_time_Format PROC, to request the delim in
			     C	;	     BL be used if TIME is being parsed.
			     C	
			     C	;  9/24/87 : Ed K
			     C	;	     Removed the include to STRUC.INC.	Replaced the STRUC macro
			     C	;	     invocations with their normally expanded code; made comments
			     C	;	     out of the STRUC macro invocation statements to maintain readability.
			     C	
			     C	;  9/24/87 : Ed K (;AN024;) PTM1222
			     C	;	     When no CONTROL for a keyword found, tried to fill in RESULT
			     C	;	     pointed to by non-existant CONTROL.
			     C	
			     C	; 10/15/87 : Ed K (;AN025;) PTM1672
			     C	;	     A quoted text string can be framed only by double quote.  Remove
			     C	;	     support to frame quoted text string with single quote.
			     C	;	     (apostrophe) $P_SorD_Quote is removed from PSDATA.INC.
			     C	;	     $P_SQuote EQU also removed from PSDATA.INC.  Any references to
			     C	;	     single quote in PROC prologues are left as is for history reasons.
			     C	
			     C	;	     This fixes another bug, not mentioned in p1672, in that two
			     C	;	     quote chars within a quoted string is supposed to be reported as
			     C	;	     one quote character, but is reported as two quotes.  This changed
			     C	;	     two instructions in PROC $P_Quoted_Str.
			     C	
			     C	;	     Also fixed are several JMP that caused a NOP, these changed to
			     C	;	     have the SHORT operator to avoid the unneeded NOP.
			     C	
			     C	;	     The code and PSDATA.INC have been aligned for ease of reading.
			     C	
			     C	; 10/26/87 : Ed K (;AN026;) PTM2041, DATE within SWITCH, BX reference to
			     C	;	     psdata buffer should have psdata_seg.
			     C	
			     C	; 10/27/87 : Ed K (;AN027;) PTM2042 comma between keywords implies
			     C	;	     positional missing.
			     C	
			     C	; 11/06/87 : Ed K (;AN028;) PTM 2315 Parser should not use line feed
			     C	;	     as a line delimiter, should use carriage return.
			     C	;	     Define switch: LFEOLSW, if on, accept LF as end of line char.
			     C	
			     C	; 11/11/87 : Ed K (;AN029;) PTM 1651 GET RID OF WHITESPACE AROUND "=".
			     C	
			     C	; 11/18/87 : Ed K (;AN030;) PTM 2551 If filename is just "", then
			     C	;	     endless loop since SI is returned still pointing to start
			     C	;	     of that parm.
			     C	
			     C	; 11/19/87 : Ed K (;AN031;) PTM 2585 date & time getting bad values.
			     C	;	     Vector to returned string has CS instead of Psdata_Seg, but
			     C	;	     when tried to fix it on previous version, changed similar
			     C	;	     but wrong place.
			     C	
			     C	; 12/09/87 : Bill L (;AN032;) PTM 2772 colon and period are now valid
			     C	;	     delimiters between hours, minutes, seconds for time. And period
			     C	;	     and comma are valid delimiters between seconds and 100th second.
			     C	
			     C	; 12/14/87 : Bill L (;AN033;) PTM 2722 if illegal delimiter characters
			     C	;	     in a filespec, then flag an error.
			     C	
			     C	; 12/22/87 : Bill L (;AN034;)	    All local data to parser is now
			     C	;	     indexed off of the psdata_seg equate instead of the DS register.
			     C	;	     Using this method, DS can point to the segment of PSP or to psdata
			     C	;  -->	     local parser data. Why were some references to local data changed
			     C	;	     to do this before, but not all ?????
			     C	
			     C	; 02/02/88 : Ed K (;AC035;) INSPECT utility, suggests optimizations.
			     C	
			     C	; 02/05/88 : Ed K (;AN036;) P3372-UPPERCASE TRANSLATION, PSDATA_SEG HOSED.
			     C	;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-15
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	; 02/08/88 : Ed K (;AN037;) P3410-AVOID POP OF CS, CHECK BASESW FIRST.
			     C	
			     C	; 02/19/88 : Ed K (;AN038;) p3524 above noon and "am" should be error
			     C	
			     C	; 02/23/88 : Ed K (;AN039;) p3518 accept "comma" and "period" as decimal
			     C	;	     separator in TIME before hundredths field.
			     C	;
			     C	;***********************************************************************
			     C	ELSE					;AN000;
 00A6                        C	SysParse proc near			;AN000;
			     C	ENDIF					;AN000;(of FarSW)
			     C	;	$SALUT	(4,9,17,41)
 00A6  2E: C7 06 000D R 0000 C		mov	psdata_seg:$P_Flags,0	;AC034; Clear all internal flags
 00AD  FC                    C		cld				      ;AN000; confirm forward direction
 00AE  2E: 89 0E 0000 R      C		mov	psdata_seg:$P_ordinal,cx      ;AC034; save operand ordinal
 00B3  2E: C7 06 0002 R 0000 C		mov	psdata_seg:$P_RC,$P_No_Error  ;AC034; Assume no error
 00BA  2E: C7 06 0015 R 0000 C		mov	psdata_seg:$P_Found_SYNONYM,0 ;AC034; initalize synonym pointer
			     C	
 00C1  2E: C7 06 0006 R 0000 C		mov	word ptr psdata_seg:$P_DX,0   ;AC034; (tm15)
 00C8  E8 079D R             C		call	$P_Skip_Delim		;AN000; Move si to 1st non white space
 00CB  73 13                 C		jnc	$P_Start		;AN000; If EOL is not encountered, do parse
			     C	
			     C	;--------------------------- End of Line
 00CD  B8 FFFF               C		mov	ax,$P_RC_EOL		;AN000; set exit code to -1
 00D0  53                    C		push	bx			;AN000;
 00D1  26: 8B 1D             C		mov	bx,es:[di].$P_PARMSX_Address ;AN000; Get the PARMSX address to
 00D4  26: 3A 0F             C		cmp	cl,es:[bx].$P_MinP	;AN000; check ORDINAL to see if the minimum
 00D7  73 03                 C		jae	$P_Fin			;AN000; positional found.
			     C	
 00D9  B8 0002               C		mov	ax,$P_Op_Missing	;AN000; If no, set exit code to missing operand
 00DC                        C	$P_Fin: 				;AN000;
 00DC  5B                    C		pop	bx			;AN000;
 00DD  E9 01FD R             C		jmp	$P_Single_Exit		;AN000; return to the caller
			     C	
			     C	;---------------------------
 00E0                        C	$P_Start:				;AN000;
 00E0  2E: 89 36 000F R      C		mov	psdata_seg:$P_SaveSI_Cmpx,si ;AN000;AC034;  save ptr to command line for later use b
				y complex,
 00E5  53                    C		push	bx			;AN000; quoted string or file spec.
 00E6  57                    C		push	di			;AN000;
 00E7  55                    C		push	bp			;AN000;
 00E8  8D 1E 0017 R          C		lea	bx,psdata_seg:$P_STRING_BUF ;AC034; set buffer to copy from command string
 00EC  2E: F6 06 000E R 20   C		test	psdata_seg:$P_Flags2,$P_Extra ;AC034; 3/9 extra delimiter encountered ?
 00F2  75 43                 C		jne	$P_Pack_End		;AN000; 3/9 if yes, no need to copy
			     C	
 00F4                        C	$P_Pack_Loop:				;AN000;
 00F4  AC                    C		lodsb				;AN000; Pick a operand from buffer
 00F5  E8 085A R             C		call	$P_Chk_Switch		;AN000; Check switch character
 00F8  72 3C                 C		jc	$P_Pack_End_BY_EOL	;AN020; if carry set found delimiter type slash, need backup
				 si, else continue
			     C	
 00FA  E8 07C3 R             C		call	$P_Chk_EOL		;AN000; Check EOL character
 00FD  74 37                 C		je	$P_Pack_End_BY_EOL	;AN000; need backup si
			     C	
 00FF  E8 07F9 R             C		call	$P_Chk_Delim		;AN000; Check delimiter
 0102  75 18                 C		jne	$P_PL01 		;AN000; If no, process next byte
			     C	
 0104  2E: F6 06 000E R 20   C		test	psdata_seg:$P_Flags2,$P_Extra ;AC034; 3/9 If yes and white spec,
			     C	; (tm08)jne	$P_Pack_End		;AN000; 3/9 then
 010A  75 05                 C		jne	$P_Pack_End_backup_si	;AN000; (tm08)
			     C	
 010C  E8 079D R             C		call	$P_Skip_Delim		;AN000; skip subsequent white space,too
 010F  EB 26                 C		jmp	short $P_Pack_End	;AN000; finish copy by placing NUL at end
			     C	
 0111                        C	$P_PAck_End_backup_si:			;AN000; (tm08)
 0111  2E: F6 06 000E R 41   C		test	psdata_seg:$P_Flags2,$P_SW+$P_equ ;AN000;AC034;  (tm08)
 0117  74 1E                 C		je	$P_Pack_End		;AN000; (tm08)
			     C	
 0119  4E                    C		dec	si			;AN000; (tm08)
 011A  EB 1B                 C		jmp	short $P_Pack_End	;AN025; (tm08)
			     C	
 011C                        C	$P_PL01:				;AN000;
 011C  2E: 88 07             C		mov	psdata_seg:[bx],al	;AN000; move byte to STRING_BUF
 011F  3C 3D                 C		cmp	al,$P_Keyword		;AN000; if it is equal character,
 0121  75 06                 C		jne	$P_PL00 		;AN000; then
			     C	
 0123  2E: 80 0E 000E R 01   C		or	psdata_seg:$P_Flags2,$P_equ ;AC034; remember it in flag
 0129                        C	$P_PL00:				;AN000;
 0129  43                    C		inc	bx			;AN000; ready to see next byte
 012A  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; was it 1st byte of DBCS ?
 012D  73 C5                 C		jnc	$P_Pack_Loop		;AN000; if no, process to next byte
			     C	
 012F  AC                    C		lodsb				;AN000; if yes, store
 0130  2E: 88 07             C		mov	psdata_seg:[bx],al	;AN000;    2nd byte of DBCS
 0133  43                    C		inc	bx			;AN000; update pointer
 0134  EB BE                 C		jmp	short $P_Pack_Loop	;AN000; process to next byte
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-16
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	
 0136                        C	$P_Pack_End_BY_EOL:			;AN000;
 0136  4E                    C		dec	si			;AN000; backup si pointer
 0137                        C	$P_Pack_End:				;AN000;
 0137  2E: 89 36 0004 R      C		mov	psdata_seg:$P_SI_Save,si     ;AC034; save next pointer, SI
 013C  2E: C6 07 00          C		mov	byte ptr psdata_seg:[bx],$P_NULL ;AN000; put NULL at the end
 0140  2E: 89 1E 0013 R      C		mov	psdata_seg:$P_Save_EOB,bx    ;AC034; 3/17/87 keep the address for later use of compl
				ex
 0145  26: 8B 1D             C		mov	bx,es:[di].$P_PARMSX_Address ;AN000; get PARMSX address
 0148  8D 36 0017 R          C		lea	si,psdata_seg:$P_STRING_BUF  ;AC034;
 014C  2E: 80 3C 2F          C		cmp	byte ptr psdata_seg:[si],$P_Switch ;AN000; the operand begins w/ switch char ?
 0150  74 30                 C		je	$P_SW_Manager		     ;AN000; if yes, process as switch
			     C	
 0152  2E: F6 06 000E R 01   C		test	psdata_seg:$P_Flags2,$P_equ   ;AC034; the operand includes equal char ?
 0158  75 54                 C		jne	$P_Key_manager		     ;AN000; if yes, process as keyword
			     C	
 015A                        C	$P_Positional_Manager:			;AN000; else process as positional
 015A  26: 8A 47 01          C		mov	al,es:[bx].$P_MaxP	;AN000; get maxp
 015E  32 E4                 C		xor	ah,ah			;AN000; ax = maxp
 0160  2E: 39 06 0000 R      C		cmp	psdata_seg:$P_ORDINAL,ax ;AC034; too many positional ?
 0165  73 12                 C		jae	$P_Too_Many_Error	;AN000; if yes, set exit code to too many
			     C	
 0167  2E: A1 0000 R         C		mov	ax,psdata_seg:$P_ORDINAL ;AC034; see what the current ordinal
 016B  D1 E0                 C		shl	ax,1			;AN000; ax = ax*2
 016D  43                    C		inc	bx			;AC035; add '2' to
 016E  43                    C		inc	bx			;AC035;  BX reg
			     C						;AN000; now bx points to 1st CONTROL
			     C	;(changed ;AC035;) add	   bx,2 	;AN000; now bx points to 1st CONTROL
 016F  03 D8                 C		add	bx,ax			;AN000; now bx points to specified CONTROL address
 0171  26: 8B 1F             C		mov	bx,es:[bx]		;AN000; now bx points to specified CONTROL itself
 0174  E8 01FF R             C		call	$P_Chk_Pos_Control	;AN000; Do process for positional
 0177  EB 69                 C		jmp	short $P_Return_to_Caller ;AN000; and return to the caller
			     C	
 0179                        C	$P_Too_Many_Error:			;AN000;
 0179  2E: C7 06 0002 R 0001 C		mov	psdata_seg:$P_RC,$P_Too_Many ;AC034; set exit code
 0180  EB 60                 C		jmp	short $P_Return_to_Caller ;AN000; and return to the caller
			     C	;
 0182                        C	$P_SW_Manager:				;AN000;
 0182  26: 8A 47 01          C		mov	al,es:[bx].$P_MaxP	;AN000; get maxp
 0186  32 E4                 C		xor	ah,ah			;AN000; ax = maxp
 0188  40                    C		inc	ax			;AN000;
 0189  D1 E0                 C		shl	ax,1			;AN000; ax = (ax+1)*2
 018B  03 D8                 C		add	bx,ax			;AN000; now bx points to maxs
 018D  26: 8A 0F             C		mov	cl,es:[bx]		;AN000;
 0190  32 ED                 C		xor	ch,ch			;AN000; cx = maxs
 0192  0B C9                 C		or	cx,cx			;AN000; at least one switch ?
 0194  74 0F                 C		je	$P_SW_Not_Found 	;AN000;
			     C	
 0196  43                    C		inc	bx			;AN000; now bx points to 1st CONTROL address
			     C	
 0197                        C	$P_SW_Mgr_Loop: 			;AN000;
 0197  53                    C		push	bx			;AN000;
 0198  26: 8B 1F             C		mov	bx,es:[bx]		;AN000; bx points to Switch CONTROL itself
 019B  E8 0264 R             C		call	$P_Chk_SW_Control	;AN000; do process for switch
 019E  5B                    C		pop	bx			;AN000;
 019F  73 41                 C		jnc	$P_Return_to_Caller	;AN000; if the CONTROL is for the switch, exit
			     C	
 01A1  43                    C		inc	bx			;AC035; add '2' to
 01A2  43                    C		inc	bx			;AC035;  BX reg
			     C						;AN000; else bx points to the next CONTROL
			     C	;(changed ;AC035;)  add     bx,2	;AN000; else bx points to the next CONTROL
 01A3  E2 F2                 C		loop	$P_SW_Mgr_Loop		;AN000; and loop
			     C	
 01A5                        C	$P_SW_Not_Found:			;AN000;
 01A5  2E: C7 06 0002 R 0003 C		mov	psdata_seg:$P_RC,$P_Not_In_SW ;AC034; here no CONTROL for the switch has
 01AC  EB 34                 C		jmp	short $P_Return_to_Caller0    ;AN000; not been found, means error.
			     C	;
 01AE                        C	$P_Key_Manager: 			;AN000;
 01AE  26: 8A 47 01          C		mov	al,es:[bx].$P_MaxP	;AN000; get maxp
 01B2  32 E4                 C		xor	ah,ah			;AN000; ax = maxp
 01B4  40                    C		inc	ax			;AN000;
 01B5  D1 E0                 C		shl	ax,1			;AN000; ax = (ax+1)*2
 01B7  03 D8                 C		add	bx,ax			;AN000; now bx points to maxs
 01B9  26: 8A 07             C		mov	al,es:[bx]		;AN000;
 01BC  32 E4                 C		xor	ah,ah			;AN000; ax = maxs
 01BE  D1 E0                 C		shl	ax,1			;AN000;
 01C0  40                    C		inc	ax			;AN000; ax = ax*2+1
 01C1  03 D8                 C		add	bx,ax			;AN000; now bx points to maxk
 01C3  26: 8A 0F             C		mov	cl,es:[bx]		;AN000;
 01C6  32 ED                 C		xor	ch,ch			;AN000; cx = maxk
 01C8  0B C9                 C		or	cx,cx			;AN000; at least one keyword ?
 01CA  74 0F                 C		je	$P_Key_Not_Found	;AN000;
			     C	
 01CC  43                    C		inc	bx			;AN000; now bx points to 1st CONTROL
			     C	
 01CD                        C	$P_Key_Mgr_Loop:			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-17
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 01CD  53                    C		push	bx			;AN000;
 01CE  26: 8B 1F             C		mov	bx,es:[bx]		;AN000; bx points to keyword CONTROL itself
 01D1  E8 0231 R             C		call	$P_Chk_Key_Control	;AN000; do process for keyword
 01D4  5B                    C		pop	bx			;AN000;
 01D5  73 0B                 C		jnc	$P_Return_to_Caller	;AN000; if the CONTROL is for the keyword, exit
			     C	
 01D7  43                    C		inc	bx			;AC035; add '2' to
 01D8  43                    C		inc	bx			;AC035;  BX reg
			     C						;AN000; else bx points to the next CONTROL
			     C	;(changed ;AC035;)  add     bx,2	;AN000; else bx points to the next CONTROL
 01D9  E2 F2                 C		loop	$P_Key_Mgr_Loop 	;AN000; and loop
			     C	
 01DB                        C	$P_Key_Not_Found:			;AN000;
 01DB  2E: C7 06 0002 R 0004 C		mov	psdata_seg:$P_RC,$P_Not_In_Key ;AC034; here no CONTROL for the keyword has
 01E2                        C	$P_Return_to_Caller0:			;AN000; not been found, means error.
			     C	
			     C	;(deleted ;AN024;)	 mov	 bx,es:[bx-2]		 ;AN000; (tm13) backup bx
			     C	
			     C	;(deleted ;AN024;)	 mov	 al,$P_String		 ;AN000; Set
			     C	;(deleted ;AN024;)	 mov	 ah,$P_No_Tag		 ;AN000;     result
			     C	;(deleted ;AN024;)	 call	 $P_Fill_Result 	 ;AN000;	    buffer
			     C	
 01E2                        C	$P_Return_to_Caller:			;AN000;
 01E2  5D                    C		pop	bp			;AN000;
 01E3  5F                    C		pop	di			;AN000;
 01E4  5B                    C		pop	bx			;AN000;
 01E5  2E: 8B 0E 0000 R      C		mov	cx,psdata_seg:$P_Ordinal    ;AC034; return next ordinal
 01EA  2E: A1 0002 R         C		mov	ax,psdata_seg:$P_RC	    ;AC034; return exit code
 01EE  2E: 8B 36 0004 R      C		mov	si,psdata_seg:$P_SI_Save    ;AC034; return next operand pointer
 01F3  2E: 8B 16 0006 R      C		mov	dx,psdata_seg:$P_DX	    ;AC034; return result buffer address
 01F8  2E: 8A 1E 0008 R      C		mov	bl,psdata_seg:$P_Terminator ;AC034; return delimiter code found
 01FD                        C	$P_Single_Exit: 			;AN000;
 01FD  F8                    C		clc				;AN000;
 01FE  C3                    C		ret				;AN000;
 01FF                        C	SysParse endp				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-18
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_Pos_Control
			     C	;
			     C	; Function: Parse CONTROL block for a positional
			     C	;
			     C	; Input:     ES:BX -> CONTROL block
			     C	;	     psdata_seg:SI -> $P_STRING_BUF
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	 $P_Fill_Result, $P_Check_Match_Flags
			     C	;
			     C	; Vars: $P_Ordinal(W), $P_RC(W)
			     C	;***********************************************************************
 01FF                        C	$P_Chk_Pos_Control proc 		;AN000;
 01FF  50                    C		push	ax			;AN000;
 0200  26: 8B 07             C		mov	ax,es:[bx].$P_Match_Flag ;AN000;
 0203  A9 0002               C		test	ax,$P_Repeat		;AN000; repeat allowed ?
 0206  75 05                 C		jne	$P_CPC00		;AN000; then do not increment ORDINAL
			     C	
 0208  2E: FF 06 0000 R      C		inc	psdata_seg:$P_ORDINAL	;AC034; update the ordinal
 020D                        C	$P_CPC00:				;AN000;
 020D  2E: 80 3C 00          C		cmp	byte ptr psdata_seg:[si],$P_NULL ;AN000; no data ?
 0211  75 19                 C		jne	$P_CPC01		;AN000;
			     C	
 0213  A9 0001               C		test	ax,$P_Optional		;AN000; yes, then is it optional ?
 0216  75 09                 C		jne	$P_CPC02		;AN000;
			     C	
 0218  2E: C7 06 0002 R 0002 C		mov	psdata_seg:$P_RC,$P_Op_Missing ;AC034; no, then error	     3/17/87
 021F  EB 0E                 C		jmp	short $P_CPC_Exit	;AN000;
			     C	
 0221                        C	$P_CPC02:				;AN000;
 0221  50                    C		push	ax			;AN000;
 0222  B0 03                 C		mov	al,$P_String		;AN000; if it is optional return NULL
 0224  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; no item tag indication
 0226  E8 02C7 R             C		call	$P_Fill_Result		;AN000;
 0229  58                    C		pop	ax			;AN000;
 022A  EB 03                 C		jmp	short $P_CPC_Exit	;AN000;
			     C	
 022C                        C	$P_CPC01:				;AN000;
 022C  E8 034C R             C		call	$P_Check_Match_Flags	;AN000;
 022F                        C	$P_CPC_Exit:				;AN000;
 022F  58                    C		pop	ax			;AN000;
 0230  C3                    C		ret				;AN000;
 0231                        C	$P_Chk_Pos_Control endp 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-19
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_Key_Control
			     C	;
			     C	; Function: Parse CONTROL block for a keyword
			     C	;
			     C	; Input:     ES:BX -> CONTROL block
			     C	;	     psdata_seg:SI -> $P_STRING_BUF
			     C	;
			     C	; Output:    CY = 1 : not match
			     C	;
			     C	; Use:	 $P_Fill_Result, $P_Search_KEYorSW, $P_Check_Match_Flags
			     C	;
			     C	; Vars: $P_RC(W), $P_SaveSI_Cmpx(W), $P_KEYorSW_Ptr(R), $P_Flags(W)
			     C	;***********************************************************************
 0231                        C	$P_Chk_Key_Control proc 		;AN000;
			     C	ELSE					;AN000;(of IF KeySW)
 0231  F9                    C		stc				;AN000;this logic works when the KeySW
 0232  C3                    C		ret				;AN000;is reset.
			     C	ENDIF					;AN000;(of KeySW)
 0233                        C	$P_Chk_Key_Control endp 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-20
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	KeySW+SwSW			;AN000;(Check if keyword or switch is supported)
			     C	; $P_Search_KEYorSW:
			     C	;
			     C	; Function: Seach specified keyword or switch from CONTROL
			     C	;
			     C	; Input:     ES:BX -> CONTROL block
			     C	;	     psdata_seg:SI -> $P_STRING_BUF
			     C	;
			     C	; Output:    CY = 1 : not match
			     C	;
			     C	; Use:	 $P_String_Comp, $P_MoveBP_NUL, $P_Found_SYNONYM
			     C	;***********************************************************************
 0233                        C	$P_Search_KEYorSW proc			;AN000;
 0233  55                    C		push	bp			;AN000;
 0234  51                    C		push	cx			;AN000;
 0235  26: 8A 4F 08          C		mov	cl,es:[bx].$P_nid	;AN000; Get synonym count
 0239  32 ED                 C		xor	ch,ch			;AN000; and set it to cx
 023B  0B C9                 C		or	cx,cx			;AN000; No synonyms specified ?
 023D  74 0D                 C		je	$P_KEYorSW_Not_Found	;AN000; then indicate not found by CY
			     C	
 023F  8D 6F 09              C		lea	bp,es:[bx].$P_KEYorSW	;AN000; BP points to the 1st synonym
 0242                        C	$P_KEYorSW_Loop:			;AN000;
 0242  E8 057C R             C		call	$P_String_Comp		;AN000; compare string in buffer w/ the synonym
 0245  73 08                 C		jnc	$P_KEYorSW_Found	;AN000; If match, set it to synonym pointer
			     C	
 0247  E8 0258 R             C		call	$P_MoveBP_NUL		;AN000; else, bp points to the next string
 024A  E2 F6                 C		loop	$P_KEYorSW_Loop 	;AN000; loop nid times
 024C                        C	$P_KEYorSW_Not_Found:			;AN000;
 024C  F9                    C		stc				;AN000; indicate not found in synonym list
 024D  EB 06                 C		jmp	short $P_KEYorSW_Exit	;AN000; and exit
			     C	
 024F                        C	$P_KEYorSW_Found:			;AN000;
 024F  2E: 89 2E 0015 R      C		mov	psdata_seg:$P_Found_SYNONYM,bp ;AC034; set synonym pointer
 0254  F8                    C		clc				;AN000; indicate found
 0255                        C	$P_KEYorSW_Exit:			;AN000;
 0255  59                    C		pop	cx			;AN000;
 0256  5D                    C		pop	bp			;AN000;
 0257  C3                    C		ret				;AN000;
 0258                        C	$P_Search_KEYorSW endp			;AN000;
			     C	;***********************************************************************
			     C	; $P_MoveBP_NUL
			     C	;***********************************************************************
 0258                        C	$P_MoveBP_NUL proc			;AN000;
 0258                        C	$P_MBP_Loop:				;AN000;
 0258  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN000; Increment BP that points
 025D  74 03                 C		je	$P_MBP_Exit		;AN000; to the synomym list
			     C	
 025F  45                    C		inc	bp			;AN000; until
 0260  EB F6                 C		jmp	short $P_MBP_Loop	;AN000; NULL encountered.
			     C	
 0262                        C	$P_MBP_Exit:				;AN000;
 0262  45                    C		inc	bp			;AN000; bp points to next to NULL
 0263  C3                    C		ret				;AN000;
 0264                        C	$P_MoveBP_NUL endp			;AN000;
			     C	ENDIF					;AN000;(of KeySW+SwSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-21
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_SW_Control
			     C	;
			     C	; Function: Parse CONTROL block for a switch
			     C	;
			     C	; Input:     ES:BX -> CONTROL block
			     C	;	     psdata_seg:SI -> $P_STRING_BUF
			     C	;
			     C	; Output:    CY = 1 : not match
			     C	;
			     C	; Use:	 $P_Fill_Result, $P_Search_KEYorSW, $P_Check_Match_Flags
			     C	;
			     C	; Vars:  $P_SaveSI_Cmpx(W), $P_KEYorSW_Ptr(R), $P_Flags(W)
			     C	;***********************************************************************
 0264                        C	$P_Chk_SW_Control proc			;AN000;
			     C	
			     C	
			     C	IF	SwSW				;AN000;(Check if switch is supported)
 0264  2E: 80 0E 000E R 10   C		or	psdata_seg:$P_Flags2,$P_Sw_Cmp ;AC034; Indicate switch for later string comparison
 026A  E8 0233 R             C		call	$P_Search_KEYorSW	;AN000; Search the switch in the CONTROL block
 026D  72 4A                 C		jc	$P_Chk_SW_Err0		;AN000; not found, then try next CONTROL
			     C	
 026F  2E: 80 26 000E R EF   C		and	psdata_seg:$P_Flags2,0ffh-$P_Sw_Cmp ;AC034; reset the indicator previously set
			     C	;
 0275  50                    C		push	ax			;AN000; 	      /switch:
 0276  2E: A1 0011 R         C		mov	ax,psdata_seg:$P_KEYorSW_Ptr ;AC034;	      ^       ^
 027A  2B C6                 C		sub	ax,si			;AN000;  SI	KEYorSW
 027C  2E: 01 06 000F R      C		add	psdata_seg:$P_SaveSI_Cmpx,ax ;AC034; update for complex list
 0281  58                    C		pop	ax			;AN000;
			     C	;
 0282  2E: 8B 36 0011 R      C		mov	si,psdata_seg:$P_KEYorSW_Ptr ;AC034; set si at the end or colon
 0287  2E: 80 3C 00          C		cmp	byte ptr psdata_seg:[si],$P_NULL ;AN000; any data after colon
 028B  75 26                 C		jne	$P_CSW00		;AN000; if yes, process match flags
			     C	
 028D  2E: 80 7C FF 3A       C		cmp	byte ptr psdata_seg:[si-1],$P_Colon ;AN000; if no, the switch terminated by colon ?
 0292  75 09                 C		jne	$P_Chk_if_data_required ;AN000; if yes,
			     C	
 0294  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034; return syntax error
 029B  EB 1F                 C		jmp	short $P_Chk_SW_Exit	;AN000;
			     C	
 029D                        C	$P_Chk_if_data_required:		;AN018; no data, no colon
 029D  26: 83 3F 00          C		cmp	es:[bx].$P_Match_Flag,0 ;AN018; should have data? zero match flag means switch follo
				wed by nothing is OK
 02A1  74 19                 C		je	$P_Chk_SW_Exit		;AN018; match flags not zero so should have something if opt
				ional bit is not on
			     C	
 02A3  26: F7 07 0001        C		test	es:[bx].$P_Match_Flag,$P_Optional ;AN019; see if no value is valid
 02A8  75 12                 C		jnz	$P_Chk_SW_Exit		;AN019; if so, then leave, else yell
			     C	
 02AA  2E: C7 06 0002 R 0002 C		mov	psdata_seg:$P_RC,$P_Op_Missing ;AC034; return required operand missing
 02B1  EB 09                 C		jmp	short $P_Chk_SW_Exit	;AN018;
			     C	
 02B3                        C	$P_CSW00:				;AN000;
 02B3  E8 034C R             C		call	$P_Check_Match_Flags	;AN000; process match flag
 02B6  F8                    C		clc				;AN000; indicate match
 02B7  EB 0D                 C		jmp	short $P_Chk_SW_Single_Exit ;AN000;
			     C	
 02B9                        C	$P_Chk_SW_Err0: 			;AN000;
 02B9  F9                    C		stc				;AN000; not found in switch synonym list
 02BA  EB 0A                 C		jmp	short $P_Chk_SW_Single_Exit ;AN000;
			     C	
 02BC                        C	$P_Chk_SW_Exit: 			;AN000;
 02BC  50                    C		push	ax			;AN000;
 02BD  B0 03                 C		mov	al,$P_String		;AN000; set
 02BF  B4 FF                 C		mov	ah,$P_No_Tag		;AN000;    result
 02C1  E8 02C7 R             C		call	$P_Fill_Result		;AN000; 	 buffer
 02C4  58                    C		pop	ax			;AN000;
 02C5  F8                    C		clc				;AN000;
 02C6                        C	$P_Chk_SW_Single_Exit:			;AN000;
 02C6  C3                    C		ret				;AN000;
			     C	ENDIF					;AN000;(of SwSW)
 02C7                        C	$P_Chk_SW_Control endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-22
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Fill_Result
			     C	;
			     C	; Function: Fill the result buffer
			     C	;
			     C	; Input:    AH = Item tag
			     C	;	    AL = type
			     C	;		  AL = 1: CX,DX has 32bit number (CX = high)
			     C	;		  AL = 2: DX has index(offset) into value list
			     C	;		  AL = 6: DL has driver # (1-A, 2-B, ... , 26 - Z)
			     C	;		  AL = 7: DX has year, CL has month and CH has date
			     C	;		  AL = 8: DL has hours, DH has minutes, CL has secondsn,
			     C	;			  amd CH has hundredths
			     C	;		  AL = else: psdata_seg:SI points to returned string buffer
			     C	;	    ES:BX -> CONTROL block
			     C	;
			     C	; Output:   None
			     C	;
			     C	; Use:	$P_Do_CAPS_String, $P_Remove_Colon, $P_Found_SYNONYM
			     C	;
			     C	; Vars: $P_DX(W)
			     C	;***********************************************************************
 02C7                        C	$P_Fill_Result proc			;AN000;
 02C7  57                    C		push	di			;AN000;
 02C8  26: 8B 7F 04          C		mov	di,es:[bx].$P_Result_Buf ;AN000; di points to result buffer
 02CC  2E: 89 3E 0006 R      C		mov	psdata_seg:$P_DX,di	;AC034; set returned result address
 02D1  26: 88 05             C		mov	es:[di].$P_Type,al	;AN000; store type
 02D4  26: 88 65 01          C		mov	es:[di].$P_Item_Tag,ah	;AN000; store item tag
 02D8  50                    C		push	ax			;AN000;
 02D9  2E: A1 0015 R         C		mov	ax,psdata_seg:$P_Found_SYNONYM ;AC034; if yes,
 02DD  26: 89 45 02          C		mov	es:[di].$P_SYNONYM_Ptr,ax ;AN000;   then set it to the result
 02E1  58                    C		pop	ax			;AN000;
 02E2                        C	$P_RLT04:				;AN000;
 02E2  3C 01                 C		cmp	al,$P_Number		;AN000; if number
 02E4  75 0A                 C		jne	$P_RLT00		;AN000;
			     C	
 02E6                        C	$P_RLT02:				;AN000;
 02E6  26: 89 55 04          C		mov	word ptr es:[di].$P_Picked_Val,dx ;AN000; then store 32bit
 02EA  26: 89 4D 06          C		mov	word ptr es:[di+2].$P_Picked_Val,cx ;AN000;	number
 02EE  EB 5A                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 02F0                        C	$P_RLT00:				;AN000;
 02F0  3C 02                 C		cmp	al,$P_List_Idx		;AN000; if list index
 02F2  75 06                 C		jne	$P_RLT01		;AN000;
			     C	
 02F4  26: 89 55 04          C		mov	word ptr es:[di].$P_Picked_Val,dx ;AN000; then store list index
 02F8  EB 50                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 02FA                        C	$P_RLT01:				;AN000;
 02FA  3C 07                 C		cmp	al,$P_Date_F		;AN000; Date format ?
 02FC  74 E8                 C		je	$P_RLT02		;AN000;
			     C	
 02FE  3C 08                 C		cmp	al,$P_Time_F		;AN000; Time format ?
 0300  74 E4                 C		je	$P_RLT02		;AN000;
			     C	;
 0302  3C 06                 C		cmp	al,$P_Drive		;AN000; drive format ?
 0304  75 06                 C		jne	$P_RLT03		;AN000;
			     C	
 0306  26: 88 55 04          C		mov	byte ptr es:[di].$P_Picked_Val,dl ;AN000; store drive number
 030A  EB 3E                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 030C                        C	$P_RLT03:				;AN000;
 030C  3C 04                 C		cmp	al,$P_Complex		;AN000; complex format ?
 030E  75 0F                 C		jne	$P_RLT05		;AN000;
			     C	
 0310  2E: A1 000F R         C		mov	ax,psdata_seg:$P_SaveSI_Cmpx ;AC034; then get pointer in command buffer
 0314  40                    C		inc	ax			;AN000; skip left Parentheses
 0315  26: 89 45 04          C		mov	word ptr es:[di].$P_Picked_Val,ax ;AN000; store offset
 0319  26: 8C 5D 06          C		mov	word ptr es:[di+2].$P_Picked_Val,ds ;AN000; store segment
 031D  EB 2B                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 031F                        C	$P_RLT05:				;AN000;
			     C	;------------------------  AL = 3, 5, or 9
 031F  26: 89 75 04          C		mov	word ptr es:[di].$P_Picked_Val,si ;AN000; store offset of STRING_BUF
			     C	;(replaced ;AN031;)  mov word ptr es:[di+word].$P_Picked_Val,cs ;AN000; store segment of STRING_BUF
 0323  26: 8C 4D 06          C		mov	word ptr es:[di+2].$P_Picked_Val,Psdata_Seg ;AN031; store segment of STRING_BUF
			     C	;
 0327  50                    C		push	ax			;AN000;
 0328  26: F6 47 02 01       C		test	byte ptr es:[bx].$P_Function_Flag,$P_CAP_File ;AN000; need CAPS by file table?
 032D  74 04                 C		je	$P_RLT_CAP00		;AN000;
			     C	
 032F  B0 04                 C		mov	al,$P_DOSTBL_File	;AN000; use file upper case table
 0331  EB 09                 C		jmp	short $P_RLT_CAP02	;AN000;
			     C	
 0333                        C	$P_RLT_CAP00:				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-23
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 0333  26: F6 47 02 02       C		test	byte ptr es:[bx].$P_Function_Flag,$P_CAP_Char ;AN000; need CAPS by char table ?
 0338  74 05                 C		je	$P_RLT_CAP01		;AN000;
			     C	
 033A  B0 02                 C		mov	al,$P_DOSTBL_Char	;AN000; use character upper case table
 033C                        C	$P_RLT_CAP02:				;AN000;
 033C  E8 0424 R             C		call	$P_Do_CAPS_String	;AN000;  process CAPS along the table
 033F                        C	$P_RLT_CAP01:				;AN000;
 033F  58                    C		pop	ax			;AN000;
 0340  26: F6 47 02 10       C		test	byte ptr es:[bx].$P_Function_Flag,$P_Rm_Colon ;AN000; removing colon at end ?
 0345  74 03                 C		je	$P_RLT_Exit		;AN000;
			     C	
 0347  E8 03FE R             C		call	$P_Remove_Colon 	;AN000; then process it.
 034A                        C	$P_RLT_Exit:				;AN000;
 034A  5F                    C		pop	di			;AN000;
 034B  C3                    C		ret				;AN000;
 034C                        C	$P_Fill_Result endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-24
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Check_Match_Flags
			     C	;
			     C	; Function:  Check the mutch_flags and make the exit code and set the
			     C	;	     result buffer
			     C	;
			     C	;	    Check for types in this order:
			     C	;		Complex
			     C	;		Date
			     C	;		Time
			     C	;		Drive
			     C	;		Filespec
			     C	;		Quoted String
			     C	;		Simple String
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	     $P_Value, P$_SValue, $P_Simple_String, $P_Date_Format
			     C	;	     $P_Time_Format, $P_Complex_Format, $P_File_Foemat
			     C	;	     $P_Drive_Format
			     C	;***********************************************************************
 034C                        C	$P_Check_Match_Flags proc		;AN000;
 034C  2E: C6 06 00A5 R 00   C		mov	psdata_seg:$P_err_flag,$P_NULL ;AN033;AC034;; clear filespec error flag.
 0352  50                    C		push	ax			;AN000;
 0353  26: 8B 07             C		mov	ax,es:[bx].$P_Match_Flag ;AN000; load match flag(16bit) to ax
			     C	
 0356  0B C0                 C		or	ax,ax			;AC035; test ax for zero
			     C	;(changed ;AC035;)  cmp     ax,0	;AN000; (tm12)
 0358  75 18                 C		jne	$P_Mat			;AN000; (tm12)
			     C	
 035A  50                    C		push	ax			;AN000; (tm12)
 035B  53                    C		push	bx			;AN000; (tm12)
 035C  52                    C		push	dx			;AN000; (tm12)
 035D  57                    C		push	di			;AN000; (tm12)
 035E  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034; (tm12)
 0365  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; (tm12)
 0367  B0 03                 C		mov	al,$P_String		;AN000; (tm12)
 0369  E8 02C7 R             C		call	$P_Fill_Result		;AN000; (tm12)
 036C  5F                    C		pop	di			;AN000; (tm12)
 036D  5A                    C		pop	dx			;AN000; (tm12)
 036E  5B                    C		pop	bx			;AN000; (tm12)
 036F  58                    C		pop	ax			;AN000; (tm12)
 0370  EB 19                 C		jmp	short $P_Bridge 	;AC035; (tm12)
			     C	
 0372                        C	$P_Mat: 				;AN000; (tm12)
			     C	
			     C	IF	CmpxSW				;AN000;(Check if complex item is supported)
 0372  A9 0400               C		test	ax,$P_Cmpx_S		;AN000; Complex string
 0375  74 12                 C		je	$P_Match01		;AN000;
			     C	
 0377  2E: C7 06 0002 R 0000 C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 037E  E8 061F R             C		call	$P_Complex_Format	;AN000; do process
 0381  2E: 83 3E 0002 R 09   C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examine the next type
 0387  75 02                 C		jne	$P_Bridge		;AN000;
			     C	
 0389                        C	$P_Match01:				;AN000;
			     C	ENDIF					;AN000;(of CmpxSW)
 0389  EB 03                 C		jmp	short $P_Match03	;AN025; (tm09)
			     C	
 038B                        C	$P_Bridge:				;AN000;
			     C	;	jmp	short $P_Match_Exit (tm02)
			     C	
 038B  EB 58 90              C		jmp	$P_Match_Exit		;AN000; (tm02)
			     C	
 038E                        C	$P_Match03:				;AN000;
			     C	; ENDIF ;AN000;(of TimeSW) (tm04)
			     C	IF	NumSW				;AN000;(Check if numeric value is supported)
 038E  A9 8000               C		test	ax,$P_Num_Val		;AN000; Numeric value
 0391  74 12                 C		je	$P_Match04		;AN000;
			     C	
 0393  2E: C7 06 0002 R 0000 C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 039A  E8 04AC R             C		call	$P_Value		;AN000; do process
 039D  2E: 83 3E 0002 R 09   C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examine the next type
 03A3  75 40                 C		jne	$P_Match_Exit		;AN000;
			     C	
 03A5                        C	$P_Match04:				;AN000;
 03A5  A9 4000               C		test	ax,$P_SNUM_Val		;AN000; Signed numeric value
 03A8  74 12                 C		je	$P_Match05		;AN000;
			     C	
 03AA  2E: C7 06 0002 R 0000 C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 03B1  E8 0488 R             C		call	$P_SValue		;AN000; do process
 03B4  2E: 83 3E 0002 R 09   C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examine the next type
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-25
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 03BA  75 29                 C		jne	$P_Match_Exit		;AN000;
			     C	
 03BC                        C	$P_Match05:				;AN000;
			     C	ENDIF					;AN000;(of NumSW)
			     C	IF	DrvSW				;AN000;(Check if drive only is supported)
 03BC  A9 0100               C		test	ax,$P_Drv_Only		;AN000; Drive only
 03BF  74 15                 C		je	$P_Match06		;AN000;
			     C	
 03C1  2E: C7 06 0002 R 0000 C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 03C8  E8 06D3 R             C		call	$P_File_Format		;AN000; 1st, call file format
 03CB  E8 0759 R             C		call	$P_Drive_Format 	;AN000; check drive format, next
 03CE  2E: 83 3E 0002 R 09   C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examinee the next type
 03D4  75 0F                 C		jne	$P_Match_Exit		;AN000;
			     C	
 03D6                        C	$P_Match06:				;AN000;
			     C	ENDIF					;AN000;(of DrvSW)
 03D6  A9 2000               C		test	ax,$P_Simple_S		;AN000; Simple string
 03D9  74 0A                 C		je	$P_Match09		;AN000;
			     C	
 03DB  2E: C7 06 0002 R 0000 C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 03E2  E8 0556 R             C		call	$P_Simple_String	;AN000; do process
			     C	;;;;	cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; These two lines will be alive
			     C	;;;;	jne	$P_Match_Exit			   ;when extending the match_flags.
 03E5                        C	$P_Match09:				;AN000;
 03E5                        C	$P_Match_Exit:				;AN000;
 03E5  2E: 80 3E 00A5 R 01   C		cmp	psdata_seg:$P_err_flag,$P_error_filespec ;AC034; bad filespec ?
 03EB  75 0F                 C		jne	$P_Match2_Exit		;AN033; no, continue
 03ED  2E: 83 3E 0002 R 00   C		cmp	psdata_seg:$P_RC,$P_No_Error ;AN033;AC034;; check for other errors ?
 03F3  75 07                 C		jne	$P_Match2_Exit		;AN033; no, continue
 03F5  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AN033;AC034;; set error flag
 03FC                        C	$P_Match2_Exit: 			;AN033;
 03FC  58                    C		pop	ax			;AN000;
 03FD  C3                    C		ret				;AN000;
 03FE                        C	$P_Check_Match_Flags endp		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-26
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Remove_Colon;
			     C	;
			     C	; Function: Remove colon at end
			     C	;
			     C	; Input:    psdata_seg:SI points to string buffer to be examineed
			     C	;
			     C	; Output:   None
			     C	;
			     C	; Use:	$P_Chk_DBCS
			     C	;***********************************************************************
 03FE                        C	$P_Remove_Colon proc			;AN000;
 03FE  50                    C		push	ax			;AN000;
 03FF  56                    C		push	si			;AN000;
 0400                        C	$P_RCOL_Loop:				;AN000;
 0400  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; get character
 0403  0A C0                 C		or	al,al			;AN000; end of string ?
 0405  74 1A                 C		je	$P_RCOL_Exit		;AN000; if yes, just exit
			     C	
 0407  3C 3A                 C		cmp	al,$P_Colon		;AN000; is it colon ?
 0409  75 0D                 C		jne	$P_RCOL00		;AN000;
			     C	
 040B  2E: 80 7C 01 00       C		cmp	byte ptr psdata_seg:[si+byte],$P_NULL ;AN000; if so, next is NULL ?
 0410  75 06                 C		jne	$P_RCOL00		;AN000; no, then next char
			     C	
 0412  2E: C6 04 00          C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN000; yes, remove colon
 0416  EB 09                 C		jmp	short $P_RCOL_Exit	;AN000; and exit.
			     C	
 0418                        C	$P_RCOL00:				;AN000;
 0418  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; if not colon, then check if
 041B  73 01                 C		jnc	$P_RCOL01		;AN000; DBCS leading byte.
			     C	
 041D  46                    C		inc	si			;AN000; if yes, skip trailing byte
 041E                        C	$P_RCOL01:				;AN000;
 041E  46                    C		inc	si			;AN000; si points to next byte
 041F  EB DF                 C		jmp	short $P_RCOL_Loop	;AN000; loop until NULL encountered
			     C	
 0421                        C	$P_RCOL_Exit:				;AN000;
 0421  5E                    C		pop	si			;AN000;
 0422  58                    C		pop	ax			;AN000;
 0423  C3                    C		ret				;AN000;
 0424                        C	$P_Remove_Colon endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-27
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Do_CAPS_String;
			     C	;
			     C	; Function: Perform capitalization along with the file case map table
			     C	;	    or character case map table.
			     C	;
			     C	; Input:    AL = 2 : Use character table
			     C	;	    AL = 4 : Use file table
			     C	;	    psdata_seg:SI points to string buffer to be capitalized
			     C	;
			     C	; Output:   None
			     C	;
			     C	; Use:	$P_Do_CAPS_Char, $P_Chk_DBCS
			     C	;***********************************************************************
 0424                        C	$P_Do_CAPS_String proc			;AN000;
 0424  56                    C		push	si			;AN000;
 0425  52                    C		push	dx			;AN000;
 0426  8A D0                 C		mov	dl,al			;AN000; save info id
			     C	
 0428                        C	$P_DCS_Loop:				;AN000;
 0428  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; load charater and
 042B  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; check if DBCS leading byte
 042E  72 0C                 C		jc	$P_DCS00		;AN000; if yes, do not need CAPS
			     C	
 0430  0A C0                 C		or	al,al			;AN000; end of string ?
 0432  74 0C                 C		je	$P_DCS_Exit		;AN000; then exit.
			     C	
 0434  E8 0443 R             C		call	$P_Do_CAPS_Char 	;AN000; Here a SBCS char need to be CAPS
 0437  2E: 88 04             C		mov	psdata_seg:[si],al	;AN000; stored upper case char to buffer
 043A  EB 01                 C		jmp	short $P_DCS01		;AN000; process nexit
 043C                        C	$P_DCS00:				;AN000;
 043C  46                    C		inc	si			;AN000; skip DBCS leading and trailing byte
 043D                        C	$P_DCS01:				;AN000;
 043D  46                    C		inc	si			;AN000; si point to next byte
 043E  EB E8                 C		jmp	short $P_DCS_Loop	;AN000; loop until NULL encountered
 0440                        C	$P_DCS_Exit:				;AN000;
 0440  5A                    C		pop	dx			;AN000;
 0441  5E                    C		pop	si			;AN000;
 0442  C3                    C		ret				;AN000;
 0443                        C	$P_Do_CAPS_String endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-28
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Do_CAPS_Char;
			     C	;
			     C	; Function: Perform capitalization along with the file case map table
			     C	;	    or character case map table.
			     C	;
			     C	; Input:    DL = 2 : Use character table
			     C	;	    DL = 4 : Use file table
			     C	;	    AL = character to be capitalized
			     C	;
			     C	; Output:   None
			     C	;
			     C	; Use:	INT 21h /w AH=65h
			     C	;***********************************************************************
 0443                        C	$P_Do_CAPS_Char proc			;AN000;
 0443  3C 80                 C		cmp	al,$P_ASCII80		;AN000; need upper case table ?
 0445  73 0C                 C		jae	$P_DCC_Go		;AN000;
			     C	
 0447  3C 61                 C		cmp	al,"a"                  ;AN000; if no,
 0449  72 3C                 C		jb	$P_CAPS_Ret		;AN000;   check if  "a" <= AL <= "z"
			     C	
 044B  3C 7A                 C		cmp	al,"z"                  ;AN000;
 044D  77 38                 C		ja	$P_CAPS_Ret		;AN000;   if yes, make CAPS
			     C	
 044F  24 DF                 C		and	al,$P_Make_Upper	;AN000;   else do nothing.
 0451  EB 34                 C		jmp	short $P_CAPS_Ret	;AN000;
			     C	
 0453                        C	$P_DCC_Go:				;AN000;
 0453  53                    C		push	bx			;AN000;
 0454  06                    C		push	es			;AN000;
 0455  57                    C		push	di			;AN000;
 0456  8D 3E 0097 R          C		lea	di,psdata_seg:$P_Char_CAP_Ptr ;AC034; or use char CAPS table ?
 045A                        C	$P_DCC00:				;AN000;
 045A  2E: 38 15             C		cmp	psdata_seg:[di],dl	;AN000; already got table address ?
 045D  74 17                 C		je	$P_DCC01		;AN000; if no,
			     C	
			     C	;In this next section, ES will be used to pass a 5 byte workarea to INT 21h,
			     C	; the GET COUNTYRY INFO call.  This usage of ES is required by the function
			     C	; call, regardless of what base register is currently be defined as PSDATA_SEG.
			     C	;BASESW EQU 0 means that ES is the psdata_seg reg.
			     C	
			     C	
 045F  50                    C		push	ax			;AN000; get CAPS table thru DOS call
 0460  51                    C		push	cx			;AN000;
 0461  52                    C		push	dx			;AN000;
			     C	
			     C	
 0462  0E                    C		push	PSDATA_SEG		;AC036; pass current base seg into
			     C						;(Note: this used to push CS.  BUG...
 0463  07                    C		pop	es			;AN000;   ES reg, required for
			     C						;get extended country information
 0464  B4 65                 C		mov	ah,$P_DOS_Get_TBL	;AN000; get extended CDI
 0466  8A C2                 C		mov	al,dl			;AN000; upper case table
 0468  BB FFFF               C		mov	bx,$P_DOSTBL_Def	;AN000; get active CON
 046B  B9 0005               C		mov	cx,$P_DOSTBL_BL 	;AN000; buffer length
 046E  BA FFFF               C		mov	dx,$P_DOSTBL_Def	;AN000; get for default code page
			     C						;DI already set to point to buffer
 0471  CD 21                 C		int	21h			;AN000; es:di point to buffer that
			     C						;now has been filled in with info
 0473  5A                    C		pop	dx			;AN000;
 0474  59                    C		pop	cx			;AN000;
 0475  58                    C		pop	ax			;AN000;
 0476                        C	$P_DCC01:				;AN000;
			     C	
			     C	;In this next section, ES will be used as the base of the XLAT table, provided
			     C	; by the previous GET COUNTRY INFO DOS call.  This usage of ES is made
			     C	; regardless of which base reg is currently the PSDATA_SEG reg.
			     C	
 0476  2E: 8B 5D 01          C		mov	bx,psdata_seg:[di+$P_DOS_TBL_Off] ;AN000; get offset of table
 047A  2E: 8E 45 03          C		mov	es,psdata_seg:[di+$P_DOS_TBL_Seg] ;AN000; get segment of table
 047E  43                    C		inc	bx			;AC035; add '2' to
 047F  43                    C		inc	bx			;AC035;  BX reg
			     C						;AN000; skip length field
			     C	;(changed ;AN035;) add	   bx,word	;AN000; skip length field
 0480  2C 80                 C		sub	al,$P_ASCII80		;AN000; make char to index
 0482  26: D7                C		xlat	es:[bx] 		;AN000; perform case map
			     C	
 0484  5F                    C		pop	di			;AN000;
 0485  07                    C		pop	es			;AN000;
 0486  5B                    C		pop	bx			;AN000;
 0487                        C	$P_CAPS_Ret:				;AN000;
 0487  C3                    C		ret				;AN000;
 0488                        C	$P_Do_CAPS_Char endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-29
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	NumSW				;AN000;(Check if numeric value is supported)
			     C	; $P_Value / $P_SValue
			     C	;
			     C	; Function:  Make 32bit value from psdata_seg:SI and see value list
			     C	;	     and make result buffer.
			     C	;	     $P_SValue is an entry point for the signed value
			     C	;	     and this will simply call $P_Value after the handling
			     C	;	     of the sign character, "+" or "-"
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	$P_Fill_Result, $P_Check_OVF
			     C	;
			     C	; Vars: $P_RC(W), $P_Flags(RW)
			     C	;***********************************************************************
 0488                        C	$P_SValue proc				;AN000; when signed value here
 0488  50                    C		push	ax			;AN000;
 0489  2E: 80 0E 000E R 80   C		or	psdata_seg:$P_Flags2,$P_Signed	    ;AC034; indicate a signed numeric
 048F  2E: 80 26 000E R FD   C		and	psdata_seg:$P_Flags2,0ffh-$P_Neg  ;AC034; assume positive value
 0495  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; get sign
 0498  3C 2B                 C		cmp	al,$P_Plus		;AN000; "+" ?
 049A  74 0A                 C		je	$P_SVal00		;AN000;
			     C	
 049C  3C 2D                 C		cmp	al,$P_Minus		;AN000; "-" ?
 049E  75 07                 C		jne	$P_Sval01		;AN000; else
			     C	
 04A0  2E: 80 0E 000E R 02   C		or	psdata_seg:$P_Flags2,$P_Neg ;AC034; set this is negative value
 04A6                        C	$P_SVal00:				;AN000;
 04A6  46                    C		inc	si			;AN000; skip sign char
 04A7                        C	$P_Sval01:				;AN000;
 04A7  E8 04AC R             C		call	$P_Value		;AN000; and process value
 04AA  58                    C		pop	ax			;AN000;
 04AB  C3                    C		ret				;AN000;
 04AC                        C	$P_SValue endp				;AN000;
			     C	;***********************************************************************
 04AC                        C	$P_Value proc				;AN000;
 04AC  50                    C		push	ax			;AN000;
 04AD  51                    C		push	cx			;AN000;
 04AE  52                    C		push	dx			;AN000;
 04AF  56                    C		push	si			;AN000;
 04B0  33 C9                 C		xor	cx,cx			;AN000; cx = higher 16 bits
 04B2  33 D2                 C		xor	dx,dx			;AN000; dx = lower 16 bits
 04B4  53                    C		push	bx			;AN000; save control pointer
 04B5                        C	$P_Value_Loop:				;AN000;
 04B5  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; get character
 04B8  0A C0                 C		or	al,al			;AN000; end of line ?
 04BA  74 42                 C		je	$P_Value00		;AN000;
			     C	
 04BC  E8 0548 R             C		call	$P_0099 		;AN000; make asc(0..9) to bin(0..9)
 04BF  72 39                 C		jc	$P_Value_Err0		;AN000;
			     C	
 04C1  32 E4                 C		xor	ah,ah			;AN000;
 04C3  8B E8                 C		mov	bp,ax			;AN000; save binary number
 04C5  D1 E2                 C		shl	dx,1			;AN000; to have 2*x
 04C7  D1 D1                 C		rcl	cx,1			;AN000; shift left w/ carry
 04C9  E8 0536 R             C		call	$P_Check_OVF		;AN000; Overflow occurred ?
 04CC  72 2C                 C		jc	$P_Value_Err0		;AN000; then error, exit
			     C	
 04CE  8B DA                 C		mov	bx,dx			;AN000; save low(2*x)
 04D0  8B C1                 C		mov	ax,cx			;AN000; save high(2*x)
 04D2  D1 E2                 C		shl	dx,1			;AN000; to have 4*x
 04D4  D1 D1                 C		rcl	cx,1			;AN000; shift left w/ carry
 04D6  E8 0536 R             C		call	$P_Check_OVF		;AN000; Overflow occurred ?
 04D9  72 1F                 C		jc	$P_Value_Err0		;AN000; then error, exit
			     C	
 04DB  D1 E2                 C		shl	dx,1			;AN000; to have 8*x
 04DD  D1 D1                 C		rcl	cx,1			;AN000; shift left w/ carry
 04DF  E8 0536 R             C		call	$P_Check_OVF		;AN000; Overflow occurred ?
 04E2  72 16                 C		jc	$P_Value_Err0		;AN000; then error, exit
			     C	
 04E4  03 D3                 C		add	dx,bx			;AN000; now have 10*x
 04E6  13 C8                 C		adc	cx,ax			;AN000; 32bit ADD
 04E8  E8 0536 R             C		call	$P_Check_OVF		;AN000; Overflow occurred ?
 04EB  72 0D                 C		jc	$P_Value_Err0		;AN000; then error, exit
			     C	
 04ED  03 D5                 C		add	dx,bp			;AN000; Add the current one degree decimal
 04EF  83 D1 00              C		adc	cx,0			;AN000; if carry, add 1 to high 16bit
 04F2  E8 0536 R             C		call	$P_Check_OVF		;AN000; Overflow occurred ?
 04F5  72 03                 C		jc	$P_Value_Err0		;AN000; then error, exit
			     C	
 04F7  46                    C		inc	si			;AN000; update pointer
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-30
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 04F8  EB BB                 C		jmp	short $P_Value_Loop	;AN000; loop until NULL encountered
			     C	;
 04FA                        C	$P_Value_Err0:				;AN000;
 04FA  5B                    C		pop	bx			;AN000;
 04FB  EB 26 90              C		jmp	$P_Value_Err		;AN000; Bridge
			     C	;
 04FE                        C	$P_Value00:				;AN000;
 04FE  5B                    C		pop	bx			;AN000; restore control pointer
 04FF  2E: F6 06 000E R 02   C		test	psdata_seg:$P_Flags2,$P_Neg ;AC034; here cx,dx = 32bit value
 0505  74 0A                 C		je	$P_Value01		;AN000; was it negative ?
			     C	
 0507  F7 D1                 C		not	cx			;AN000; +
 0509  F7 D2                 C		not	dx			;AN000; |- Make 2's complement
 050B  83 C2 01              C		add	dx,1			;AN000; |
 050E  83 D1 00              C		adc	cx,0			;AN000; +
 0511                        C	$P_Value01:				;AN000; / nval =0
 0511  26: 8B 77 06          C		mov	si,es:[bx].$P_Value_List ;AN000; si points to value list
 0515  26: 8A 04             C		mov	al,es:[si]		;AN000; get nval
 0518  3C 00                 C		cmp	al,$P_nval_None 	;AN000; no value list ?
 051A  75 07                 C		jne	$P_Value02		;AN000;
			     C	
 051C  B0 01                 C		mov	al,$P_Number		;AN000; Set type
 051E  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; No ITEM_TAG set
 0520  EB 0C 90              C		jmp	$P_Value_Exit		;AN000;
			     C	
 0523                        C	$P_Value02:				;AN000; / nval = 1
 0523                        C	$P_Value03:				;AN000; / nval = 2
 0523                        C	$P_Value04:				;AN000; / nval = 3 or else
 0523                        C	$P_Value_Err:				;AN000;
 0523  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034;
 052A  B0 03                 C		mov	al,$P_String		;AN000; Set type
 052C  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; No ITEM_TAG set
 052E                        C	$P_Value_Exit:				;AN000;
 052E  E8 02C7 R             C		call	$P_Fill_Result		;AN000;
 0531  5E                    C		pop	si			;AN000;
 0532  5A                    C		pop	dx			;AN000;
 0533  59                    C		pop	cx			;AN000;
 0534  58                    C		pop	ax			;AN000;
 0535  C3                    C		ret				;AN000;
 0536                        C	$P_Value endp				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-31
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Check_OVF
			     C	;
			     C	; Function:  Check if overflow is occurred with consideration of
			     C	;	     signed or un-signed numeric value
			     C	;
			     C	; Input:     Flag register
			     C	;
			     C	; Output:    CY = 1  :	Overflow
			     C	;
			     C	; Vars:     $P_Flags(R)
			     C	;***********************************************************************
 0536                        C	$P_Check_OVF proc			;AN000;
 0536  9C                    C		pushf				;AN000;
 0537  2E: F6 06 000E R 02   C		test	psdata_seg:$P_Flags2,$P_Neg ;AC034; is it negative value ?
 053D  75 02                 C		jne	$P_COVF 		;AN000; if no, check overflow
			     C	
 053F  9D                    C		popf				;AN000; by the CY bit
 0540  C3                    C		ret				;AN000;
			     C	
 0541                        C	$P_COVF:				;AN000;
 0541  9D                    C		popf				;AN000; else,
 0542  70 02                 C		jo	$P_COVF00		;AN000; check overflow by the OF
			     C	
 0544  F8                    C		clc				;AN000; indicate it with CY bit
 0545  C3                    C		ret				;AN000; CY=0 means no overflow
			     C	
 0546                        C	$P_COVF00:				;AN000;
 0546  F9                    C		stc				;AN000; and CY=1 means overflow
 0547  C3                    C		ret				;AN000;
 0548                        C	$P_Check_OVF endp			;AN000;
			     C	ENDIF					;AN000;(of FarSW)
			     C	;***********************************************************************
			     C	; $P_0099;
			     C	;
			     C	; Function:  Make ASCII 0-9 to Binary 0-9
			     C	;
			     C	; Input:     AL = character code
			     C	;
			     C	; Output:    CY = 1 : AL is not number
			     C	;	     CY = 0 : AL contains binary value
			     C	;***********************************************************************
 0548                        C	$P_0099 proc				;AN000;
 0548  3C 30                 C		cmp	al,"0"                  ;AN000;
 054A  72 08                 C		jb	$P_0099Err		;AN000;  must be 0 =< al =< 9
			     C	
 054C  3C 39                 C		cmp	al,"9"                  ;AN000;
 054E  77 04                 C		ja	$P_0099Err		;AN000;  must be 0 =< al =< 9
			     C	
 0550  2C 30                 C		sub	al,"0"                  ;AN000; make char -> bin
 0552  F8                    C		clc				;AN000; indicate no error
 0553  C3                    C		ret				;AN000;
			     C	
 0554                        C	$P_0099Err:				;AN000;
 0554  F9                    C		stc				;AN000; indicate error
 0555  C3                    C		ret				;AN000;
 0556                        C	$P_0099 endp				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-32
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Simple_String
			     C	;
			     C	; Function:  See value list for the simple string
			     C	;	     and make result buffer.
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	$P_Fill_Result, $P_String_Comp
			     C	;
			     C	; Vars: $P_RC(W)
			     C	;***********************************************************************
 0556                        C	$P_Simple_String proc			;AN000;
 0556  50                    C		push	ax			;AN000;
 0557  53                    C		push	bx			;AN000;
 0558  52                    C		push	dx			;AN000;
 0559  57                    C		push	di			;AN000;
 055A  26: 8B 7F 06          C		mov	di,es:[bx].$P_Value_List ;AN000; di points to value list
 055E  26: 8A 05             C		mov	al,es:[di]		;AN000; get nval
 0561  0A C0                 C		or	al,al			;AN000; no value list ?
 0563  75 04                 C		jne	$P_Sim00		;AN000; then
			     C	
 0565  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; No ITEM_TAG set
 0567  EB 09                 C		jmp	short $P_Sim_Exit	;AN000; and set result buffer
			     C	
 0569                        C	$P_Sim00:				;AN000;
 0569                        C	$P_Sim01:				;AN000;
 0569  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034;
 0570  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; No ITEM_TAG set
 0572                        C	$P_Sim_Exit:				;AN000;
 0572  B0 03                 C		mov	al,$P_String		;AN000; Set type
 0574                        C	$P_Sim_Exit0:				;AN000;
 0574  E8 02C7 R             C		call	$P_Fill_Result		;AN000;
 0577  5F                    C		pop	di			;AN000;
 0578  5A                    C		pop	dx			;AN000;
 0579  5B                    C		pop	bx			;AN000;
 057A  58                    C		pop	ax			;AN000;
 057B  C3                    C		ret				;AN000;
 057C                        C	$P_Simple_String endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-33
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_String_Comp:
			     C	;
			     C	; Function:  Compare two string
			     C	;
			     C	; Input:     psdata_seg:SI -> 1st string
			     C	;	     ES:BP -> 2nd string  (Must be upper case)
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    CY = 1 if not match
			     C	;
			     C	; Use:	$P_Chk_DBCS, $P_Do_CAPS_Char
			     C	;
			     C	; Vars: $P_KEYor_SW_Ptr(W), $P_Flags(R). $P_KEYorSW_Ptr
			     C	;***********************************************************************
 057C                        C	$P_String_Comp proc			;AN000;
 057C  50                    C		push	ax			;AN000;
 057D  55                    C		push	bp			;AN000;
 057E  52                    C		push	dx			;AN000;
 057F  56                    C		push	si			;AN000;
 0580  B2 02                 C		mov	dl,$P_DOSTBL_Char	;AN000; use character case map table
 0582                        C	$P_SCOM_Loop:				;AN000;
 0582  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; get command character
 0585  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; DBCS ?
 0588  72 3C                 C		jc	$P_SCOM00		;AN000; yes,DBCS
			     C	
 058A  E8 0443 R             C		call	$P_Do_CAPS_Char 	;AN000; else, upper case map before comparison
			     C	IF	KeySW+SwSW			;AN000;(Check if keyword or switch is supported)
 058D  2E: F6 06 000E R 08   C		test	psdata_seg:$P_Flags2,$P_Key_Cmp ;AC034; keyword search ?
 0593  74 0D                 C		je	$P_SCOM04		;AN000;
			     C	
 0595  3C 3D                 C		cmp	al,$P_Keyword		;AN000; "=" is delimiter
 0597  75 1F                 C		jne	$P_SCOM03		;AN000;IF "=" on command line AND  (bp+1=> char after the "=
				" in synonym list)
			     C	
 0599  26: 80 7E 01 00       C		cmp	byte ptr es:[bp+1],$P_NULL ;AN021;   at end of keyword string in the control block T
				HEN
 059E  75 71                 C		jne	$P_SCOM_DIFFER		;AN021;
			     C	
 05A0  EB 13                 C		jmp	short $P_SCOM05 	;AN000;   keyword found in synonym list
			     C	
 05A2                        C	$P_SCOM04:				;AN000;
 05A2  2E: F6 06 000E R 10   C		test	psdata_seg:$P_Flags2,$P_SW_Cmp ;AC034; switch search ?
 05A8  74 0E                 C		je	$P_SCOM03		;AN000;
			     C	
 05AA  3C 3A                 C		cmp	al,$P_Colon		;AN000; ":" is delimiter, at end of switch on command line
 05AC  75 0A                 C		jne	$P_SCOM03		;AN000; continue compares
			     C	
 05AE  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN021; IF at end of switch on command AND
 05B3  75 5C                 C		jne	$P_SCOM_DIFFER		;AN021;   at end of switch string in the control block THEN
			     C	
 05B5                        C	$P_SCOM05:				;AN000;   found a match
 05B5  46                    C		inc	si			;AN000; si points to just after "=" or ":"
 05B6  EB 5C                 C		jmp	short $P_SCOM_Same	;AN000; exit
			     C	
 05B8                        C	$P_SCOM03:				;AN000;
			     C	ENDIF					;AN000;(of KeySW+SwSW)
 05B8  26: 3A 46 00          C		cmp	al,es:[bp]		;AN000; compare operand w/ a synonym
 05BC  75 1D                 C		jne	$P_SCOM_Differ0 	;AN000; if different, check ignore colon option
			     C	
 05BE  0A C0                 C		or	al,al			;AN000; end of line
 05C0  74 52                 C		je	$P_SCOM_Same		;AN000; if so, exit
			     C	
 05C2  46                    C		inc	si			;AN000; update operand pointer
 05C3  45                    C		inc	bp			;AN000; 	   and synonym pointer
 05C4  EB 13                 C		jmp	short $P_SCOM01 	;AN000; loop until NULL or "=" or ":" found in case
			     C	
 05C6                        C	$P_SCOM00:				;AN000; Here al is DBCS leading byte
 05C6  26: 3A 46 00          C		cmp	al,es:[bp]		;AN000; compare leading byte
 05CA  75 45                 C		jne	$P_SCOM_Differ		;AN000; if not match, say different
			     C	
 05CC  46                    C		inc	si			;AN000; else, load next byte
 05CD  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; and
 05D0  45                    C		inc	bp			;AN000;
 05D1  26: 3A 46 00          C		cmp	al,es:[bp]		;AN000; compare 2nd byte
 05D5  75 3A                 C		jne	$P_SCOM_Differ		;AN000; if not match, say different, too
			     C	
 05D7  46                    C		inc	si			;AN000; else update operand pointer
 05D8  45                    C		inc	bp			;AN000; 		and synonym pointer
 05D9                        C	$P_SCOM01:				;AN000;
 05D9  EB A7                 C		jmp	short $P_SCOM_Loop	;AN000; loop until NULL or "=" or "/" found in case
			     C	
 05DB                        C	$P_SCOM_Differ0:			;AN000;
			     C	
			     C	IF	SwSW				;AN000;(tm10)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-34
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 05DB  2E: F6 06 000E R 40   C		test	psdata_seg:$P_Flags2,$P_SW ;AC034;(tm10)
 05E1  74 0F                 C		je	$P_not_applicable	;AN000;(tm10)
			     C	
 05E3  26: F7 47 02 0020     C		test	es:[bx].$P_Function_Flag,$P_colon_is_not_necessary ;AN000;(tm10)
 05E9  74 07                 C		je	$P_not_applicable	;AN000;(tm10)
			     C	
 05EB  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN000;(tm10)
			     C	;(deleted ;AN025;) jne $P_not_applicable ;AN000;(tm10)
 05F0  74 22                 C		je	$P_SCOM_Same		;AN025;(tm10)
			     C	
 05F2                        C	$P_not_applicable:			;AN000;(tm10)
			     C	ENDIF					;AN000;(tm10)
			     C	
 05F2  26: F7 07 0010        C		test	es:[bx].$P_Match_Flag,$P_Ig_Colon ;AN000; ignore colon option specified ?
 05F7  74 18                 C		je	$P_SCOM_Differ		;AN000; if no, say different.
			     C	
 05F9  3C 3A                 C		cmp	al,$P_Colon		;AN000; End up with ":" and
 05FB  75 09                 C		jne	$P_SCOM02		;AN000;    subseqently
			     C	
 05FD  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN000;       NULL ?
 0602  75 0D                 C		jne	$P_SCOM_Differ		;AN000; if no, say different
			     C	
 0604  EB 0E                 C		jmp	short $p_SCOM_Same	;AN000; else, say same
			     C	
 0606                        C	$P_SCOM02:				;AN000;
 0606  3C 00                 C		cmp	al,$P_NULL		;AN000; end up NULL and :
 0608  75 07                 C		jne	$P_SCOM_Differ		;AN000;
			     C	
 060A  26: 80 7E 00 3A       C		cmp	byte ptr es:[bp],$P_Colon ;AN000; if no, say different
 060F  74 03                 C		je	$p_SCOM_Same		;AN000; else, say same
			     C	
 0611                        C	$P_SCOM_Differ: 			;AN000;
 0611  F9                    C		stc				;AN000; indicate not found
 0612  EB 06                 C		jmp	short $P_SCOM_Exit	;AN000;
			     C	
 0614                        C	$P_SCOM_Same:				;AN000;
 0614  2E: 89 36 0011 R      C		mov	psdata_seg:$P_KEYorSW_Ptr,si ;AC034; for later use by keyword or switch
 0619  F8                    C		clc				;AN000; indicate found
 061A                        C	$P_SCOM_Exit:				;AN000;
 061A  5E                    C		pop	si			;AN000;
 061B  5A                    C		pop	dx			;AN000;
 061C  5D                    C		pop	bp			;AN000;
 061D  58                    C		pop	ax			;AN000;
 061E  C3                    C		ret				;AN000;
 061F                        C	$P_String_Comp endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-35
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-36
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-37
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-38
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	CmpxSW				;AN000;(Check if complex item is supported)
			     C	; $P_Complex_Format:
			     C	;
			     C	; Function:  Check if the input string is valid complex format.
			     C	;	     And set the result buffer.
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	$P_Fill_Result, $P_Chk_DBCS, $P_Chk_EOL, $P_Skip_Delim
			     C	;	$P_Quoted_str, $P_Chk_DSQuote
			     C	;
			     C	; Vars: $P_RC(W), $P_SI_Save(W), $P_SaveSI_Cmpx(R), $P_Save_EOB(R)
			     C	;***********************************************************************
 061F                        C	$P_Complex_Format proc			;AN000;
 061F  50                    C		push	ax			;AN000;
 0620  53                    C		push	bx			;AN000;
 0621  56                    C		push	si			;AN000;
 0622  2E: 8B 1E 000F R      C		mov	bx,psdata_seg:$P_SaveSI_Cmpx ;AC034; bx points to user buffer
 0627  80 3F 28              C		cmp	byte ptr [bx],$P_Lparen ;AN000; 1st char = left parentheses
 062A  75 5F                 C		jne	$P_Cmpx_Err		;AN000;
			     C	
 062C  32 E4                 C		xor	ah,ah			;AN000; ah = parentheses counter
 062E                        C	$P_Cmpx_Loop:				;AN000;
 062E  8A 07                 C		mov	al,[bx] 		;AN000; load character from command buffer
 0630  E8 07C3 R             C		call	$P_Chk_EOL		;AN000; if it is one of EOL
 0633  74 4D                 C		je	$P_CmpxErr0		;AN000; then error exit.
			     C	
 0635  3C 28                 C		cmp	al,$P_Lparen		;AN000; left parentheses ?
 0637  75 04                 C		jne	$P_Cmpx00		;AN000; then
			     C	
 0639  FE C4                 C		inc	ah			;AC035; add '1' to AH reg
			     C						;AN000; increment parentheses counter
			     C	;(replaced ;AC035;) add     ah,1	;AN000; increment parentheses counter
 063B  72 45                 C		jc	$P_CmpxErr0		;AN000; if overflow, error
 063D                        C	$P_Cmpx00:				;AN000;
 063D  3C 29                 C		cmp	al,$P_Rparen		;AN000; right parentheses ?
 063F  75 06                 C		jne	$P_Cmpx01		;AN000; then
			     C	
 0641  FE CC                 C		dec	ah			;AC035; subtract '1' from AH reg
			     C						;AN000; decrement parentheses counter
			     C	;(changed ;AC035;) sub	   ah,1 	;AN000; decrement parentheses counter
 0643  72 3D                 C		jc	$P_CmpxErr0		;AN000; if overflow error
			     C	
 0645  74 23                 C		je	$P_Cmpx03		;AN000; ok, valid complex
			     C	
 0647                        C	$P_Cmpx01:				;AN000;
			     C	;(deleted ;AN025;) call $P_Chk_DSQuote	;AN000; double or single quotation mark ? 3/17/KK
 0647  3C 22                 C		cmp	al,$P_DQuote		;AN025; double quotation mark?
 0649  75 0C                 C		jne	$P_Cmpx04		;AN000; 3/17/KK
			     C	
 064B  2E: 88 04             C		mov	psdata_seg:[si],al	;AN000; here quoted string is found in the complex list.
 064E  46                    C		inc	si			;AN000;
 064F  43                    C		inc	bx			;AN000; bx points to 2nd character
 0650  E8 069D R             C		call	$P_Quoted_Str		;AN000; skip pointers until closing of quoted string
 0653  72 2D                 C		jc	$P_CmpxErr0		;AN000; if error in quoted string syntax then exit
			     C	
 0655  EB 0F                 C		jmp	short $P_Cmpx05 	;AN000;
			     C	
 0657                        C	$P_Cmpx04:				;AN000;
 0657  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; was it a lead byte of DBCS ?
 065A  73 07                 C		jnc	$P_Cmpx02		;AN000;
			     C	
 065C  2E: 88 04             C		mov	psdata_seg:[si],al	;AN000; then store 1st byte
 065F  46                    C		inc	si			;AN000;
 0660  43                    C		inc	bx			;AN000;
 0661  8A 07                 C		mov	al,[bx] 		;AN000; load 2nd byte
 0663                        C	$P_Cmpx02:				;AN000;
 0663  2E: 88 04             C		mov	psdata_seg:[si],al	;AN000; store SBCS or 2nd byte of DBCS
 0666                        C	$P_Cmpx05:				;AN000;
 0666  46                    C		inc	si			;AN000;
 0667  43                    C		inc	bx			;AN000;
 0668  EB C4                 C		jmp	short $P_Cmpx_Loop	;AN000; loop
			     C	;----					;AN000;
 066A                        C	$P_Cmpx03:				;AN000;
 066A  2E: 88 04             C		mov	byte ptr psdata_seg:[si],al ;AN000;
 066D  2E: C6 44 01 00       C		mov	byte ptr psdata_seg:[si+byte],$P_NULL ;AN000;
 0672  C6 07 00              C		mov	byte ptr [bx],$P_NULL	;AN000; replace right parentheses with NULL
 0675  8B F3                 C		mov	si,bx			;AN000; skip whitespaces
 0677  46                    C		inc	si			;AN000;     after
 0678  E8 079D R             C		call	$P_Skip_Delim		;AN000;        right parentheses
 067B  2E: 89 36 0004 R      C		mov	psdata_seg:$P_SI_Save,si ;AC034; save next pointer, SI
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-39
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 0680  EB 10                 C		jmp	short $P_Cmpx_Exit	;AN000;
			     C	
 0682                        C	$P_CmpxErr0:				;AN000;
 0682  2E: 8B 36 0013 R      C		mov	si,psdata_seg:$P_Save_EOB ;AC034; if EOF encountered, restore
 0687  2E: C6 04 00          C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN000; EOB mark
 068B                        C	$P_Cmpx_Err:				;AN000;
 068B  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034;
 0692                        C	$P_Cmpx_Exit:				;AN000;
 0692  B4 FF                 C		mov	ah,$P_No_Tag		;AN000;
 0694  B0 04                 C		mov	al,$P_Complex		;AN000;
 0696  5E                    C		pop	si			;AN000;
 0697  5B                    C		pop	bx			;AN000;
 0698  E8 02C7 R             C		call	$P_Fill_Result		;AN000;
 069B  58                    C		pop	ax			;AN000;
 069C  C3                    C		ret				;AN000;
 069D                        C	$P_Complex_Format endp			;AN000;
			     C	ENDIF					;AN000;(of CpmxSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-40
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-41
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_DSQuote;
			     C	;
			     C	; Function: Check if AL is double quotation or single quotation
			     C	;
			     C	; Input:    AL = byte to be examineed
			     C	;
			     C	; Output:   ZF on if AL is single or double quotetaion
			     C	;
			     C	; Vars:  $P_SorD_Quote(W)
			     C	;***********************************************************************
			     C	IF	QusSW+CmpxSW			;AN000;(Check if quoted string or complex item is supported)
			     C	;(deleted ;AN025;) $P_Chk_DSQuote proc			   ;
			     C	;(deleted ;AN025;)	   mov	   $P_SorD_Quote,$P_SQuote ; 3/17/87   assume single quote
			     C	;(deleted ;AN025;)	   cmp	   al,$P_DQuote 	   ; 1st char = double quotation ?
			     C	;(deleted ;AN025;)	   jne	   $P_CDSQ00		   ; 3/17/87
			     C	;(deleted ;AN025;)	   mov	   $P_SorD_Quote,al	   ; 3/17/87 set bigning w/ double quote
			     C	;(deleted ;AN025;)	   ret				   ; 3/17/87
			     C	;(deleted ;AN025;) $P_CDSQ00:				   ; 3/17/87
			     C	;(deleted ;AN025;)	   cmp	   al,$P_SQuote 	   ; 1st char = single quotation ?
			     C	;(deleted ;AN025;)	   ret				   ;
			     C	;(deleted ;AN025;) $P_Chk_DSQuote endp			   ;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-42
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	    PAGE				;AN000;
			     C	;***********************************************************************
			     C	; $P_Quoted_Str:
			     C	;
			     C	; Function:  Copy chracacter from ES:BX to psdata_seg:SI until closing single
			     C	;	     (double) quotation found.
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> Operand in command buffer
			     C	;
			     C	; Output:    CY on indicates EOF encounterd before closing quotation
			     C	;	     BX and SI
			     C	;
			     C	;
			     C	; Vars: $P_SorD_Quote(R)
			     C	;***********************************************************************
 069D                        C	$P_Quoted_Str proc			;AN000;
 069D  50                    C		push	ax			;AN000;
 069E                        C	$P_Qus_Loop:				;AN000;
 069E  8B 07                 C		mov	ax,[bx] 		;AN000; 3/17/87
 06A0  E8 07C3 R             C		call	$P_Chk_EOL		;AN000;
 06A3  74 24                 C		je	$P_Qustr_Err0		;AN000;
			     C	
			     C	;(deleted ;AN025;) cmp al,$P_SorD_Quote ;AN000; quotation ?   3/17/87
 06A5  3C 22                 C		cmp	al,$P_DQuote		;AN025; double quote?
 06A7  75 0D                 C		jne	$P_Qus00		;AN000;
			     C	
			     C	;(deleted ;AN025;) cmp ah,$P_SorD_Quote ;AN000; contiguous quotation 3/17/87
 06A9  80 FC 22              C		cmp	ah,$P_DQuote		;AN025; double quote?
 06AC  75 1E                 C		jne	$P_Qus02		;AN000;
			     C	
			     C	;(deleted ;AN025:) mov word ptr psdata_seg:[si],ax ;AN000; 3/17/87
 06AE  2E: 88 04             C		mov	byte ptr psdata_seg:[si],al ;AN025; save one of the quotes
			     C	;(deleted ;AN025:) add si,2		;AN000;
			     C	
 06B1  46                    C		inc	si			;AC035; add '1' to SI reg
			     C						;AN025; adjust target index
			     C	;(changed ;AC035;) add	   si,1 	;AN025; adjust target index
 06B2  43                    C		inc	bx			;AC035; add '2' to
 06B3  43                    C		inc	bx			;AC035;  BX reg
			     C						;AN000; adjust source index by 2 to skip extra quote
			     C	;(changed ;AC035;) add	   bx,2 	;AN000; adjust source index by 2 to skip extra quote
 06B4  EB E8                 C		jmp	short $P_Qus_Loop	;AN000;
			     C	
 06B6                        C	$P_Qus00:				;AN000;
 06B6  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; was it a lead byte of DBCS ?
 06B9  73 07                 C		jnc	$P_Qus01		;AN000;
			     C	
 06BB  2E: 88 04             C		mov	psdata_seg:[si],al	;AN000; store 1st byte
 06BE  46                    C		inc	si			;AN000;
 06BF  43                    C		inc	bx			;AN000;
 06C0  8A 07                 C		mov	al,[bx] 		;AN000; load 2nd byte
 06C2                        C	$P_Qus01:				;AN000;
 06C2  2E: 88 04             C		mov	psdata_seg:[si],al	;AN000; store SBCS or 2nd byte of DBCS
 06C5  46                    C		inc	si			;AN000;
 06C6  43                    C		inc	bx			;AN000;
 06C7  EB D5                 C		jmp	short $P_Qus_Loop	;AN000;
			     C	
 06C9                        C	$P_Qustr_Err0:				;AN000;
 06C9  F9                    C		stc				;AN000; indicate error
 06CA  EB 05                 C		jmp	short $P_Quoted_Str_Exit ;AN000;
			     C	
 06CC                        C	$P_Qus02:				;AN000;
 06CC  2E: C6 04 00          C		mov	byte ptr psdata_seg:[si],0 ;AN000;
 06D0  F8                    C		clc				;AN000; indicate no error
 06D1                        C	$P_Quoted_Str_Exit:			;AN000;
 06D1  58                    C		pop	ax			;AN000;
 06D2  C3                    C		ret				;AN000;
 06D3                        C	$P_Quoted_Str endp			;AN000;
			     C	ENDIF					;AN000;(of QusSW+CmpxSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-43
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	FileSW+DrvSW			;AN000;(Check if file spec or drive only is supported)
			     C	; $P_File_Format;
			     C	;
			     C	; Function:  Check if the input string is valid file spec format.
			     C	;	     And set the result buffer.
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	$P_Fill_Result, $P_Chk_DBCS, $P_FileSp_Chk
			     C	;
			     C	; Vars: $P_RC(W), $P_SI_Save(W), $P_Terminator(W), $P_SaveSI_Cmpx(R)
			     C	;	$P_SaveSI_Cmpx(R)
			     C	;***********************************************************************
 06D3                        C	$P_File_Format proc			;AN000;
 06D3  50                    C		push	ax			;AN000;
 06D4  57                    C		push	di			;AN000;
 06D5  56                    C		push	si			;AN000;
 06D6  2E: 8B 3E 000F R      C		mov	di,psdata_seg:$P_SaveSI_cmpx ;AC034; get user buffer address
 06DB                        C	$P_FileF_Loop0: 			;AN000; / skip special characters
 06DB  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; load character
 06DE  0A C0                 C		or	al,al			;AN000; end of line ?
 06E0  74 13                 C		je	$P_FileF_Err		;AN000; if yes, error exit
			     C	
 06E2  E8 0744 R             C		call	$P_FileSp_Chk		;AN000; else, check if file special character
 06E5  75 24                 C		jne	$P_FileF03		;AN000; if yes,
			     C	
			     C	;AN033; deleted   inc	  di			  ;skip
			     C	;AN033; deleted   inc	  si			  ;   the
			     C	;AN033; deleted   jmp	  short $P_FileF_Loop0	  ;	  character
 06E7  2E: C6 06 00A5 R 01   C		mov	psdata_seg:$P_err_flag,$P_error_filespec ;AN033;AC034;; set error flag- bad char.
 06ED  5E                    C		pop	si			;AN033;
 06EE  2E: C6 04 00          C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN033;
 06F2  5F                    C		pop	di			;AN033;
 06F3  EB 3F                 C		jmp	short $P_FileF02	;AN033;
			     C	
			     C	
 06F5                        C	$P_FileF_Err:				;AN000;
 06F5  5E                    C		pop	si			;AN000;
 06F6  2E: C6 04 00          C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN000;
			     C	;(deleted ;AN030;) mov di,$P_SaveSI_cmpx ;AN000; get user buffer address
			     C	;(deleted ;AN030;) mov $P_SI_Save,di	 ;AN000; update pointer to user buffer
 06FA  5F                    C		pop	di			;AN000;
 06FB  26: F7 07 0001        C		test	es:[bx].$P_Match_Flag,$P_Optional ;AN000; is it optional ?
 0700  75 32                 C		jne	$P_FileF02		;AN000;
			     C	
 0702  2E: C7 06 0002 R 0002 C		mov	psdata_seg:$P_RC,$P_Op_Missing ;AC034; 3/17/87
 0709  EB 29                 C		jmp	short $P_FileF02	;AN000;
			     C	
 070B                        C	$P_FileF03:				;AN000;
 070B  58                    C		pop	ax			;AN000; discard save si
 070C  56                    C		push	si			;AN000; save new si
 070D                        C	$P_FileF_Loop1: 			;AN000;
 070D  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000; load character (not special char)
 0710  0A C0                 C		or	al,al			;AN000; end of line ?
 0712  74 1E                 C		je	$P_FileF_RLT		;AN000;
			     C	
 0714  E8 0744 R             C		call	$P_FileSp_Chk		;AN000; File special character ?
 0717  74 0B                 C		je	$P_FileF00		;AN000;
			     C	
 0719  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; no, then DBCS ?
 071C  73 02                 C		jnc	$P_FileF01		;AN000;
 071E  47                    C		inc	di			;AN000; if yes, skip next byte
 071F  46                    C		inc	si			;AN000;
 0720                        C	$P_FileF01:				;AN000;
 0720  47                    C		inc	di			;AN000;
 0721  46                    C		inc	si			;AN000;
 0722  EB E9                 C		jmp	short $P_FileF_Loop1	;AN000;
			     C	;
 0724                        C	$P_FileF00:				;AN000;
 0724  2E: A2 0008 R         C		mov	psdata_seg:$P_Terminator,al ;AC034;
 0728  2E: C6 04 00          C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN000; update end of string
 072C  47                    C		inc	di			;AN000;
 072D  2E: 89 3E 0004 R      C		mov	psdata_seg:$P_SI_Save,di ;AC034; update next pointer in command line
 0732                        C	$P_FileF_RLT:				;AN000;
 0732  5E                    C		pop	si			;AN000;
 0733  5F                    C		pop	di			;AN000;
 0734                        C	$P_FileF02:				;AN000;
			     C	
 0734  58                    C		pop	ax			;AN000; (tm14)
 0735  A9 0200               C		test	ax,$P_File_Spc		;AN000; (tm14)
 0738  74 09                 C		je	$P_Drv_Only_Exit	;AN000; (tm14)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-44
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	
 073A  50                    C		push	ax			;AN000;  (tm14)
			     C	
 073B  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; set
 073D  B0 05                 C		mov	al,$P_File_Spec 	;AN000;    result
 073F  E8 02C7 R             C		call	$P_Fill_Result		;AN000; 	 buffer to file spec
 0742  58                    C		pop	ax			;AN000;
			     C	
 0743                        C	$P_Drv_Only_Exit:			;AN000; (tm14)
			     C	
 0743  C3                    C		ret				;AN000;
 0744                        C	$P_File_Format endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-45
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_FileSp_Chk
			     C	;
			     C	; Function:  Check if the input byte is one of file special characters
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     AL = character code to be examineed
			     C	;
			     C	; Output:    ZF = 1 , AL is one of special characters
			     C	;***********************************************************************
 0744                        C	$P_FileSp_Chk proc			;AN000;
 0744  53                    C		push	bx			;AN000;
 0745  51                    C		push	cx			;AN000;
 0746  8D 1E 009C R          C		lea	bx,psdata_seg:$P_FileSp_Char ;AC034; special character table
 074A  B9 0009               C		mov	cx,$P_FileSp_Len	;AN000; load length of it
 074D                        C	$P_FileSp_Loop: 			;AN000;
 074D  2E: 3A 07             C		cmp	al,psdata_seg:[bx]	;AN000; is it one of special character ?
 0750  74 04                 C		je	$P_FileSp_Exit		;AN000;
			     C	
 0752  43                    C		inc	bx			;AN000;
 0753  E2 F8                 C		loop	$P_FileSp_Loop		;AN000;
			     C	
 0755  41                    C		inc	cx			;AN000; reset ZF
 0756                        C	$P_FileSp_Exit: 			;AN000;
 0756  59                    C		pop	cx			;AN000;
 0757  5B                    C		pop	bx			;AN000;
 0758  C3                    C		ret				;AN000;
 0759                        C	$P_FileSp_Chk endp			;AN000;
			     C	ENDIF					;AN000;(of FileSW+DrvSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-46
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	DrvSW				;AN000;(Check if drive only is supported)
			     C	; $P_Drive_Format;
			     C	;
			     C	; Function:  Check if the input string is valid drive only format.
			     C	;	     And set the result buffer.
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;	     ES:BX -> CONTROL block
			     C	;
			     C	; Output:    None
			     C	;
			     C	; Use:	$P_Fill_Result, $P_Chk_DBCS
			     C	;
			     C	; Vars: $P_RC(W)
			     C	;***********************************************************************
 0759                        C	$P_Drive_Format proc			;AN000;
 0759  50                    C		push	ax			;AN000;
 075A  52                    C		push	dx			;AN000;
 075B  2E: 8A 04             C		mov	al,psdata_seg:[si]	;AN000;
 075E  0A C0                 C		or	al,al			;AN000; if null string
 0760  74 38                 C		je	$P_Drv_Exit		;AN000; do nothing
			     C	
 0762  E8 0878 R             C		call	$P_Chk_DBCS		;AN000; is it leading byte ?
 0765  72 2C                 C		jc	$P_Drv_Err		;AN000;
			     C	
 0767  2E: 83 7C 01 3A       C		cmp	word ptr psdata_seg:[si+byte],$P_Colon ;AN000; "d", ":", 0  ?
 076C  74 0E                 C		je	$P_DrvF00		;AN000;
			     C	
 076E  26: F7 07 0010        C		test	es:[bx].$P_Match_Flag,$P_Ig_Colon ;AN000; colon can be ignored?
 0773  74 1E                 C		je	$P_Drv_Err		;AN000;
			     C	
 0775  2E: 80 7C 01 00       C		cmp	byte ptr psdata_seg:[si+byte],$P_NULL ;AN000; "d", 0  ?
 077A  75 17                 C		jne	$P_Drv_Err		;AN000;
			     C	
 077C                        C	$P_DrvF00:				;AN000;
 077C  0C 20                 C		or	al,$P_Make_Lower	;AN000; lower case
 077E  3C 61                 C		cmp	al,"a"                  ;AN000; drive letter must
 0780  72 11                 C		jb	$P_Drv_Err		;AN000; in range of
			     C	
 0782  3C 7A                 C		cmp	al,"z"                  ;AN000; "a" - "z"
 0784  77 0D                 C		ja	$P_Drv_Err		;AN000; if no, error
			     C	
 0786  2C 60                 C		sub	al,"a"-1                ;AN000; make text drive to binary drive
 0788  8A D0                 C		mov	dl,al			;AN000; set
 078A  B4 FF                 C		mov	ah,$P_No_Tag		;AN000;    result
 078C  B0 06                 C		mov	al,$P_Drive		;AN000; 	 buffer
 078E  E8 02C7 R             C		call	$P_Fill_Result		;AN000; 	       to drive
 0791  EB 07                 C		jmp	short $P_Drv_Exit	;AN000;
			     C	
 0793                        C	$P_Drv_Err:				;AN000;
 0793  2E: C7 06 0002 R 0009 C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034;
 079A                        C	$P_Drv_Exit:				;AN000;
 079A  5A                    C		pop	dx			;AN000;
 079B  58                    C		pop	ax			;AN000;
 079C  C3                    C		ret				;AN000;
 079D                        C	$P_Drive_Format endp			;AN000;
			     C	ENDIF					;AN000;(of DrvSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-47
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Skip_Delim;
			     C	;
			     C	; Function: Skip delimiters specified in the PARMS list, white space
			     C	;	    and comma.
			     C	;
			     C	; Input:    DS:SI -> Command String
			     C	;	    ES:DI -> Parameter List
			     C	;
			     C	; Output:   CY = 1 if the end of line encounterd
			     C	;	    CY = 0 then SI move to 1st non-delimiter character
			     C	;	    AL = Last examineed character
			     C	;
			     C	; Use:	    $P_Chk_EOL, $P_Chk_Delim,
			     C	;
			     C	; Vars:     $P_Flags(R)
			     C	;***********************************************************************
 079D                        C	$P_Skip_Delim proc			;AN000;
 079D                        C	$P_Skip_Delim_Loop:			;AN000;
 079D  AC                    C		LODSB				;AN000;
 079E  E8 07C3 R             C		call	$P_Chk_EOL		;AN000; is it EOL character ?
 07A1  74 18                 C		je	$P_Skip_Delim_CY	;AN000; if yes, exit w/ CY on
			     C	
 07A3  E8 07F9 R             C		call	$P_Chk_Delim		;AN000; is it one of delimiters ?
 07A6  75 16                 C		jne	$P_Skip_Delim_NCY	;AN000; if no, exit w/ CY off
			     C	
 07A8  2E: F6 06 000E R 20   C		test	psdata_seg:$P_Flags2,$P_Extra ;AC034; extra delim or comma found ?
 07AE  74 ED                 C		je	$P_Skip_Delim_Loop	;AN000; if no, loop
			     C	
 07B0  2E: F6 06 000E R 41   C		test	psdata_seg:$P_Flags2,$P_SW+$P_equ ;AC034; /x , or xxx=zzz , (tm08)
 07B6  74 09                 C		je	short $P_Exit_At_Extra	;AN000; no switch, no keyword (tm08)
			     C	
 07B8  4E                    C		dec	si			;AN000; backup si for next call (tm08)
 07B9  EB 06                 C		jmp	short $P_Exit_At_Extra	;AN000; else exit w/ CY off
			     C	
 07BB                        C	$P_Skip_Delim_CY:			;AN000;
 07BB  F9                    C		stc				;AN000; indicate EOL
 07BC  EB 01                 C		jmp	short $P_Skip_Delim_Exit ;AN000;
			     C	
 07BE                        C	$P_Skip_Delim_NCY:			;AN000;
 07BE  F8                    C		clc				;AN000; indicate non delim
 07BF                        C	$P_Skip_Delim_Exit:			;AN000; in this case, need
 07BF  4E                    C		dec	si			;AN000;  backup index pointer
 07C0  C3                    C		ret				;AN000;
			     C	
 07C1                        C	$P_Exit_At_Extra:			;AN000;
 07C1  F8                    C		clc				;AN000; indicate extra delim
 07C2  C3                    C		ret				;AN000;
 07C3                        C	$P_Skip_Delim endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-48
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_EOL;
			     C	;
			     C	; Function: Check if AL is one of End of Line characters.
			     C	;
			     C	; Input:    AL = character code
			     C	;	    ES:DI -> Parameter List
			     C	;
			     C	; Output:   ZF = 1 if one of End of Line characters
			     C	;**********************************************************************
 07C3                        C	$P_Chk_EOL proc 			;AN000;
 07C3  53                    C		push	bx			;AN000;
 07C4  51                    C		push	cx			;AN000;
 07C5  3C 0D                 C		cmp	al,$P_CR		;AN000; Carriage return ?
 07C7  74 2D                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	
 07C9  3C 00                 C		cmp	al,$P_NULL		;AN000; zero ?
 07CB  74 29                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	
			     C	IF LFEOLSW				;AN028; IF LF TO BE ACCEPTED AS EOL
 07CD  3C 0A                 C		cmp	al,$P_LF		;AN000; Line feed ?
 07CF  74 25                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	ENDIF					;AN028;
			     C	
 07D1  26: 80 7D 02 02       C		cmp	byte ptr es:[di].$P_Num_Extra,$P_I_Have_EOL ;AN000; EOL character specified ?
 07D6  72 1E                 C		jb	$P_Chk_EOL_Exit 	;AN000;
			     C	
 07D8  33 DB                 C		xor	bx,bx			;AN000;
 07DA  26: 8A 5D 03          C		mov	bl,es:[di].$P_Len_Extra_Delim ;AN000; get length of delimiter list
 07DE  83 C3 04              C		add	bx,$P_Len_PARMS 	;AN000; skip it
 07E1  26: 80 39 00          C		cmp	byte ptr es:[bx+di],$P_I_Use_Default ;AN000; No extra EOL character ?
 07E5  74 0D                 C		je	$P_Chk_EOL_NZ		;AN000;
			     C	
 07E7  33 C9                 C		xor	cx,cx			;AN000; Get number of extra chcracter
 07E9  26: 8A 09             C		mov	cl,es:[bx+di]		;AN000;
 07EC                        C	$P_Chk_EOL_Loop:			;AN000;
 07EC  43                    C		inc	bx			;AN000;
 07ED  26: 3A 01             C		cmp	al,es:[bx+di]		;AN000; Check extra EOL character
 07F0  74 04                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	
 07F2  E2 F8                 C		loop	$P_Chk_EOL_Loop 	;AN000;
			     C	
 07F4                        C	$P_Chk_EOL_NZ:				;AN000;
 07F4  3C 0D                 C		cmp	al,$P_CR		;AN000; reset ZF
 07F6                        C	$P_Chk_EOL_Exit:			;AN000;
 07F6  59                    C		pop	cx			;AN000;
 07F7  5B                    C		pop	bx			;AN000;
 07F8  C3                    C		ret				;AN000;
 07F9                        C	$P_Chk_EOL endp 			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-49
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_Delim;
			     C	;
			     C	; Function: Check if AL is one of delimiter characters.
			     C	;	    if AL+[si] is DBCS blank, it is replaced with two SBCS
			     C	;	    blanks.
			     C	;
			     C	; Input:    AL = character code
			     C	;	    DS:SI -> Next Character
			     C	;	    ES:DI -> Parameter List
			     C	;
			     C	; Output:   ZF = 1 if one of delimiter characters
			     C	;	    SI points to the next character
			     C	; Vars:  $P_Terminator(W), $P_Flags(W)
			     C	;***********************************************************************
 07F9                        C	$P_Chk_Delim proc			;AN000;
 07F9  53                    C		push	bx			;AN000;
 07FA  51                    C		push	cx			;AN000;
 07FB  2E: C6 06 0008 R 20   C		mov	psdata_seg:$P_Terminator,$P_Space   ;AC034; Assume terminated by space
 0801  2E: 80 26 000E R DF   C		and	psdata_seg:$P_Flags2,0ffh-$P_Extra ;AC034;
 0807  3C 20                 C		cmp	al,$P_Space		;AN000; Space ?
 0809  74 36                 C		je	$P_Chk_Delim_Exit	;AN000;
			     C	
 080B  3C 09                 C		cmp	al,$P_TAB		;AN000; TAB ?
 080D  74 32                 C		je	$P_Chk_Delim_Exit	;AN000;
			     C	
 080F  3C 2C                 C		cmp	al,$P_Comma		;AN000; Comma ?
 0811  74 31                 C		je	$P_Chk_Delim_Exit0	;AN000;
			     C	
 0813                        C	$P_Chk_Delim00: 			;AN000;
 0813  3C 81                 C		cmp	al,$P_DBSP1		;AN000; 1st byte of DBCS Space ?
 0815  75 0C                 C		jne	$P_Chk_Delim01		;AN000;
			     C	
 0817  80 3C 40              C		cmp	byte ptr [si],$P_DBSP2	;AN000; 2nd byte of DBCS Space ?
 081A  75 07                 C		jne	$P_Chk_Delim01		;AN000;
			     C	
 081C  B0 20                 C		mov	al,$P_Space		;AN000;
 081E  46                    C		inc	si			;AN000; make si point to next character
 081F  3A C0                 C		cmp	al,al			;AN000; Set ZF
 0821  EB 1E                 C		jmp	short $P_Chk_Delim_Exit ;AN000;
			     C	
 0823                        C	$P_Chk_Delim01: 			;AN000;
 0823  26: 80 7D 02 01       C		cmp	byte ptr es:[di].$P_Num_Extra,$P_I_Have_Delim ;AN000; delimiter character specified 
				?
 0828  72 17                 C		jb	$P_Chk_Delim_Exit	;AN000;
			     C	
 082A  33 C9                 C		xor	cx,cx			;AN000;
 082C  26: 8A 4D 03          C		mov	cl,es:[di].$P_Len_Extra_Delim ;AN000; get length of delimiter list
 0830  0B C9                 C		or	cx,cx			;AN000; No extra Delim character ?
 0832  74 0B                 C		je	$P_Chk_Delim_NZ 	;AN000;
			     C	
 0834  BB 0003               C		mov	bx,$P_Len_PARMS-1	;AN000; set bx to 1st extra delimiter
 0837                        C	$P_Chk_Delim_Loop:			;AN000;
 0837  43                    C		inc	bx			;AN000;
 0838  26: 3A 01             C		cmp	al,es:[bx+di]		;AN000; Check extra Delim character
 083B  74 07                 C		je	$P_Chk_Delim_Exit0	;AN000;
			     C	
 083D  E2 F8                 C		loop	$P_Chk_Delim_Loop	;AN000; examine all extra delimiter
			     C	
 083F                        C	$P_Chk_Delim_NZ:			;AN000;
 083F  3C 20                 C		cmp	al,$P_Space		;AN000; reset ZF
 0841                        C	$P_Chk_Delim_Exit:			;AN000;
			     C	;;;;	jne	$P_ChkDfin
			     C	;;;;	mov	psdata_seg:$P_Terminator,al ;AN034;
 0841                        C	$P_ChkDfin:				;AN000;
 0841  59                    C		pop	cx			;AN000;
 0842  5B                    C		pop	bx			;AN000;
 0843  C3                    C		ret				;AN000;
			     C	
 0844                        C	$P_Chk_Delim_Exit0:			;AN000;
 0844  2E: A2 0008 R         C		mov	psdata_seg:$P_Terminator,al ;AC034; keep terminated delimiter
 0848  2E: F6 06 000E R 01   C		test	psdata_seg:$P_Flags2,$P_Equ  ;AN027;AC034;; if terminating a key=
 084E  75 06                 C		jnz	$P_No_Set_Extra 	;AN027; then do not set the EXTRA bit
			     C	
 0850  2E: 80 0E 000E R 20   C		or	psdata_seg:$P_Flags2,$P_Extra ;AC034; flag terminated extra delimiter or comma
 0856                        C	$P_No_Set_Extra:			;AN027;
 0856  3A C0                 C		cmp	al,al			;AN000; set ZF
 0858  EB E7                 C		jmp	short $P_Chk_Delim_Exit ;AN000;
			     C	
 085A                        C	$P_Chk_Delim endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-50
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Chk_Switch;
			     C	;
			     C	; Function: Check if AL is the switch character not in first position of
			     C	;	    $P_STRING_BUF
			     C	;
			     C	; Input:    AL = character code
			     C	;	    BX = current pointer within $P_String_Buf
			     C	;	    SI =>next char on command line (following the one in AL)
			     C	;
			     C	; Output:   CF = 1 (set)if AL is switch character, and not in first
			     C	;		 position, and has no chance of being part of a date string,
			     C	;		 i.e. should be treated as a delimiter.
			     C	
			     C	;	    CF = 0 (reset, cleared) if AL is not a switch char, is in the first
			     C	;		 position, or is a slash but may be part of a date string, i.e.
			     C	;		 should not be treated as a delimiter.
			     C	;
			     C	; Vars:  $P_Terminator(W)
			     C	
			     C	; Use:	 $P_0099
			     C	;***********************************************************************
 085A                        C	$P_Chk_Switch proc			;AN000;
			     C	
			     C	;AN020;; Function: Check if AL is the switch character from 2nd position of $P_STRING_BUF
			     C	;AN020;; Output:   ZF = 1 if switch character
			     C	;AN020;;	lea	bp,$P_STRING_BUF ;AN000;
			     C	;AN020;;	cmp	bx,bp		 ;AN000; 1st position ?
			     C	;AN020;;	je	$P_Chk_S_Exit_1  ;AN000;
			     C	;AN020;;	cmp	al,$P_Switch	 ;AN000;
			     C	;AN020;;	jmp	short $P_Chk_S_Exit_0  ;AN000;
			     C	;AN020;;$P_Chk_S_Exit_1:		       ;AN000;
			     C	;AN020;;	cmp	al,$P_Switch	 ;AN000; (tm08)
			     C	;AN020;;	jne	$P_Nop		;AN000; (tm08)
			     C	;AN020;;	or	$P_Flags2,$P_SW  ;AN000; (tm08) It could be valid switch
			     C	;AN020;;$P_Nop: 			;AN000; (tm08)
			     C	;AN020;;	inc	bp		       ;AN000;
			     C	;AN020;;	cmp	bx,bp		       ;AN000; reset ZF
			     C	;AN020;;$P_Chk_S_Exit_0:		       ;AN000;
			     C	;AN020;;	jne	$P_Chk_S_Exit	       ;AN000;
			     C	;AN020;;	mov	   $P_Terminator,al    ;AN000; store switch character
			     C	;AN020;;$P_Chk_S_Exit:			       ;AN000;
			     C	
 085A  8D 2E 0017 R          C		LEA	BP,psdata_seg:$P_String_Buf ;AN020;AC034; BP=OFFSET of $P_String_Buf even in group a
				ddressing
			     C	;	.IF <BX NE BP> THEN		;AN020;IF not first char THEN
 085E  3B DD                 C		cmp	BX,BP			;AN000;
 0860  74 0A                 C		je	$P_STRUC_L2		;AN000;
			     C	
			     C	;	    .IF <AL EQ $P_Switch> THEN	;AN020;otherwise see if a slash
 0862  3C 2F                 C		    cmp     AL,$P_Switch	;AN000;
 0864  75 03                 C		    jne     $P_STRUC_L5 	;AN000;
			     C	
 0866  F9                    C			STC			;AN020;not in first position and is slash, now see if might 
				be in date string
			     C	;	    .ELSE			;AN020;
 0867  EB 0E                 C		    jmp     short $P_STRUC_L1	;AN000;
			     C	
 0869                        C	$P_STRUC_L5:				;AN000;
 0869  F8                    C			CLC			;AN020;not a slash
			     C	;	    .ENDIF			;AN020;
			     C	;	.ELSE				;AN020;is first char in the buffer, ZF=0
 086A  EB 0B                 C		jmp	short $P_STRUC_L1	;AN000;
			     C	
 086C                        C	$P_STRUC_L2:				;AN000;
			     C	;	    .IF <AL EQ $P_Switch> THEN	;AN020;
 086C  3C 2F                 C		    cmp     AL,$P_Switch	;AN000;
 086E  75 06                 C		    jne     $P_STRUC_L12	;AN000;
			     C	
 0870  2E: 80 0E 000E R 40   C			OR	psdata_seg:$P_Flags2,$P_SW ;AN020;AC034;;could be valid switch, first char a
				nd is slash
			     C	;	    .ENDIF			;AN020;
 0876                        C	$P_STRUC_L12:				;AN000;
 0876  F8                    C		    CLC 			;AN020;CF=0 indicating first char
			     C	;	.ENDIF				;AN020;
 0877                        C	$P_STRUC_L1:				;AN000;
			     C	
 0877  C3                    C		ret				;AN000;
 0878                        C	$P_Chk_Switch endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-51
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

			     C		PAGE				;AN000;
			     C	;**************************************************************************
			     C	; $P_Chk_DBCS:
			     C	;
			     C	;  Function: Check if a specified byte is in ranges of the DBCS lead bytes
			     C	;
			     C	;  Input:
			     C	;	  AL	= Code to be examineed
			     C	;
			     C	;  Output:
			     C	;	  If CF is on then a lead byte of DBCS
			     C	;
			     C	; Use: INT 21h w/AH=63
			     C	;
			     C	; Vars:  $P_DBCSEV_Seg(RW), $P_DBCSEV_Off(RW)
			     C	;***************************************************************************
 0878                        C	$P_Chk_DBCS PROC			;AN000;
			     C	;
 0878  1E                    C		PUSH	DS			;AN000;
 0879  56                    C		PUSH	SI			;AN000;
 087A  53                    C		PUSH	bx			;AN000; (tm11)
 087B  2E: 83 3E 000B R 00   C		CMP	psdata_seg:$P_DBCSEV_SEG,0 ;AC034; ALREADY SET ?
 0881  75 27                 C		JNE	$P_DBCS00		;AN000;
			     C	
 0883  50                    C		PUSH	AX			;AN000;
			     C	;	PUSH	BX			;AN000; (tm11)
 0884  1E                    C		PUSH	ds			;AN000; (tm11)
 0885  51                    C		PUSH	CX			;AN000;
 0886  52                    C		PUSH	DX			;AN000;
 0887  57                    C		PUSH	DI			;AN000;
 0888  55                    C		PUSH	BP			;AN000;
 0889  06                    C		PUSH	ES			;AN000;
 088A  33 F6                 C		XOR	SI,SI			;AN000;
 088C  8E DE                 C		MOV	DS,SI			;AN000;
 088E  B8 6300               C		MOV	AX,$P_DOS_GetEV 	;AN000; GET DBCS EV CALL
 0891  CD 21                 C		INT	21H			;AN000;
			     C	
			     C	;	MOV	AX,DS			;AN000; (tm11)
			     C	;	OR	AX,AX			;AN000; (tm11)
 0893  8C DB                 C		MOV	bx,DS			;AN000; (tm11)
 0895  0B DB                 C		OR	bx,bx			;AN000; (tm11)
 0897  07                    C		POP	ES			;AN000;
 0898  5D                    C		POP	BP			;AN000;
 0899  5F                    C		POP	DI			;AN000;
 089A  5A                    C		POP	DX			;AN000;
 089B  59                    C		POP	CX			;AN000;
			     C	;	POP	BX			;AN000; (tm11)
 089C  1F                    C		POP	ds			;AN000; (tm11)
 089D  58                    C		POP	AX			;AN000;
 089E  74 29                 C		JE	$P_NON_DBCS		;AN000;
			     C	
 08A0                        C	$P_DBCS02:				;AN000;
 08A0  2E: 89 36 0009 R      C		MOV	psdata_seg:$P_DBCSEV_OFF,SI ;AC034; save EV offset
			     C	;	MOV	psdata_seg:$P_DBCSEV_SEG,DS ;AC034; save EV segment
 08A5  2E: 89 1E 000B R      C		MOV	psdata_seg:$P_DBCSEV_SEG,bx ;AC034; save EV segment (tm11)
 08AA                        C	$P_DBCS00:				;AN000;
 08AA  2E: 8B 36 0009 R      C		MOV	SI,psdata_seg:$P_DBCSEV_OFF ;AC034; load EV offset
 08AF  2E: 8E 1E 000B R      C		MOV	DS,psdata_seg:$P_DBCSEV_SEG ;AC034; and segment
			     C	
 08B4                        C	$P_DBCS_LOOP:				;AN000;
 08B4  83 3C 00              C		CMP	WORD PTR [SI],0 	;AN000; zero vector ?
 08B7  74 10                 C		JE	$P_NON_DBCS		;AN000; then exit
			     C	
 08B9  3A 04                 C		CMP	AL,[SI] 		;AN000;
 08BB  72 08                 C		JB	$P_DBCS01		;AN000; Check if AL is in
			     C	
 08BD  3A 44 01              C		CMP	AL,[SI+BYTE]		;AN000;   range of
 08C0  77 03                 C		JA	$P_DBCS01		;AN000;      the vector
			     C	
 08C2  F9                    C		STC				;AN000; if yes, indicate DBCS and exit
 08C3  EB 05                 C		JMP	short $P_DBCS_EXIT	;AN000;
			     C	
 08C5                        C	$P_DBCS01:				;AN000;
 08C5  46                    C		INC	SI			;AC035; add '2' to
 08C6  46                    C		INC	SI			;AC035;  SI reg
			     C						;AN000; get next vector
			     C	;(changed ;AC035;) ADD	   SI,2 	;AN000; get next vector
 08C7  EB EB                 C		JMP	short $P_DBCS_LOOP	;AN000; loop until zero vector found
			     C	
 08C9                        C	$P_NON_DBCS:				;AN000;
 08C9  F8                    C		CLC				;AN000; indicate SBCS
 08CA                        C	$P_DBCS_EXIT:				;AN000;
 08CA  5B                    C		POP	bx			;AN000; (tm11)
 08CB  5E                    C		POP	SI			;AN000;
 08CC  1F                    C		POP	DS			;AN000;
 08CD  C3                    C		RET				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Page     1-52
SYSPARSE - SYSTEM COMMAND LINE PARSER                       

 08CE                        C	$P_Chk_DBCS ENDP			;AN000;
 08CE				CSEG_INIT  ENDS 			   ;
					END				;					;AN000;

Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Symbols-1


Macros:

		N a m e			Lines

HEADER . . . . . . . . . . . . .  	   4

Structures and Records:

                N a m e                 Width   # fields
                                        Shift   Width   Mask    Initial

$P_CDI . . . . . . . . . . . . .  	0022	000C
  $P_CDI_DATEF . . . . . . . . .  	0000
  $P_CDI_MONEY . . . . . . . . .  	0002
  $P_CDI_1000  . . . . . . . . .  	0007
  $P_CDI_DEC . . . . . . . . . .  	0009
  $P_CDI_DATES . . . . . . . . .  	000B
  $P_CDI_TIMES . . . . . . . . .  	000D
  $P_CDI_TIMEF . . . . . . . . .  	0011
$P_CONTROL_BLK . . . . . . . . .  	000A	0006
  $P_MATCH_FLAG  . . . . . . . .  	0000
  $P_FUNCTION_FLAG . . . . . . .  	0002
  $P_RESULT_BUF  . . . . . . . .  	0004
  $P_VALUE_LIST  . . . . . . . .  	0006
  $P_NID . . . . . . . . . . . .  	0008
  $P_KEYORSW . . . . . . . . . .  	0009
$P_DOS_TBL . . . . . . . . . . .  	0005	0003
  $P_DOS_INFOID  . . . . . . . .  	0000
  $P_DOS_TBL_OFF . . . . . . . .  	0001
  $P_DOS_TBL_SEG . . . . . . . .  	0003
$P_PARMSX_BLK  . . . . . . . . .  	0004	0003
  $P_MINP  . . . . . . . . . . .  	0000
  $P_MAXP  . . . . . . . . . . .  	0001
  $P_1ST_CONTROL . . . . . . . .  	0002
$P_PARMS_BLK . . . . . . . . . .  	0004	0003
  $P_PARMSX_ADDRESS  . . . . . .  	0000
  $P_NUM_EXTRA . . . . . . . . .  	0002
  $P_LEN_EXTRA_DELIM . . . . . .  	0003
$P_RESULT_BLK  . . . . . . . . .  	0008	0004
  $P_TYPE  . . . . . . . . . . .  	0000
  $P_ITEM_TAG  . . . . . . . . .  	0001
  $P_SYNONYM_PTR . . . . . . . .  	0002
  $P_PICKED_VAL  . . . . . . . .  	0004
$P_VAL_LIST  . . . . . . . . . .  	0009	0005
  $P_NUMOFLIST . . . . . . . . .  	0000
  $P_VAL_XL  . . . . . . . . . .  	0001
  $P_VAL_XH  . . . . . . . . . .  	0003
  $P_VAL_YL  . . . . . . . . . .  	0005
  $P_VAL_YH  . . . . . . . . . .  	0007

Segments and Groups:

                N a m e         	Length	 Align	Combine Class

CSEG_INIT  . . . . . . . . . . .  	08CE	PARA	PUBLIC	'CODE'

Symbols:            

                N a m e         	Type	 Value	 Attr

CAPSW  . . . . . . . . . . . . .  	NUMBER	0000	
CMPXSW . . . . . . . . . . . . .  	NUMBER	0001	

DATESW . . . . . . . . . . . . .  	NUMBER	0000	
DRVSW  . . . . . . . . . . . . .  	NUMBER	0001	

FARSW  . . . . . . . . . . . . .  	NUMBER	0000	
FILESW . . . . . . . . . . . . .  	NUMBER	0000	

INCSW  . . . . . . . . . . . . .  	NUMBER	0001	

KEYSW  . . . . . . . . . . . . .  	NUMBER	0000	

LFEOLSW  . . . . . . . . . . . .  	NUMBER	0001	

NUMSW  . . . . . . . . . . . . .  	NUMBER	0001	

PSDATA_SEG . . . . . . . . . . .  	ALIAS	 CS		

QUSSW  . . . . . . . . . . . . .  	NUMBER	0000	

SWSW . . . . . . . . . . . . . .  	NUMBER	0001	
SYSPARSE . . . . . . . . . . . .  	N PROC	00A6	CSEG_INIT	Global	Length = 0159

TIMESW . . . . . . . . . . . . .  	NUMBER	0000	

Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Symbols-2


VAL1SW . . . . . . . . . . . . .  	NUMBER	0000	
VAL2SW . . . . . . . . . . . . .  	NUMBER	0000	
VAL3SW . . . . . . . . . . . . .  	NUMBER	0000	

$P_0099  . . . . . . . . . . . .  	N PROC	0548	CSEG_INIT	Length = 000E
$P_0099ERR . . . . . . . . . . .  	L NEAR	0554	CSEG_INIT
$P_ASCII80 . . . . . . . . . . .  	NUMBER	0080	
$P_BRIDGE  . . . . . . . . . . .  	L NEAR	038B	CSEG_INIT
$P_CAPS_RET  . . . . . . . . . .  	L NEAR	0487	CSEG_INIT
$P_CAP_CHAR  . . . . . . . . . .  	NUMBER	0002	
$P_CAP_FILE  . . . . . . . . . .  	NUMBER	0001	
$P_CHAR_CAP_PTR  . . . . . . . .  	L BYTE	0097	CSEG_INIT
$P_CHECK_MATCH_FLAGS . . . . . .  	N PROC	034C	CSEG_INIT	Length = 00B2
$P_CHECK_OVF . . . . . . . . . .  	N PROC	0536	CSEG_INIT	Length = 0012
$P_CHKDFIN . . . . . . . . . . .  	L NEAR	0841	CSEG_INIT
$P_CHK_DBCS  . . . . . . . . . .  	N PROC	0878	CSEG_INIT	Length = 0056
$P_CHK_DELIM . . . . . . . . . .  	N PROC	07F9	CSEG_INIT	Length = 0061
$P_CHK_DELIM00 . . . . . . . . .  	L NEAR	0813	CSEG_INIT
$P_CHK_DELIM01 . . . . . . . . .  	L NEAR	0823	CSEG_INIT
$P_CHK_DELIM_EXIT  . . . . . . .  	L NEAR	0841	CSEG_INIT
$P_CHK_DELIM_EXIT0 . . . . . . .  	L NEAR	0844	CSEG_INIT
$P_CHK_DELIM_LOOP  . . . . . . .  	L NEAR	0837	CSEG_INIT
$P_CHK_DELIM_NZ  . . . . . . . .  	L NEAR	083F	CSEG_INIT
$P_CHK_EOL . . . . . . . . . . .  	N PROC	07C3	CSEG_INIT	Length = 0036
$P_CHK_EOL_EXIT  . . . . . . . .  	L NEAR	07F6	CSEG_INIT
$P_CHK_EOL_LOOP  . . . . . . . .  	L NEAR	07EC	CSEG_INIT
$P_CHK_EOL_NZ  . . . . . . . . .  	L NEAR	07F4	CSEG_INIT
$P_CHK_IF_DATA_REQUIRED  . . . .  	L NEAR	029D	CSEG_INIT
$P_CHK_KEY_CONTROL . . . . . . .  	N PROC	0231	CSEG_INIT	Length = 0002
$P_CHK_POS_CONTROL . . . . . . .  	N PROC	01FF	CSEG_INIT	Length = 0032
$P_CHK_SWITCH  . . . . . . . . .  	N PROC	085A	CSEG_INIT	Length = 001E
$P_CHK_SW_CONTROL  . . . . . . .  	N PROC	0264	CSEG_INIT	Length = 0063
$P_CHK_SW_ERR0 . . . . . . . . .  	L NEAR	02B9	CSEG_INIT
$P_CHK_SW_EXIT . . . . . . . . .  	L NEAR	02BC	CSEG_INIT
$P_CHK_SW_SINGLE_EXIT  . . . . .  	L NEAR	02C6	CSEG_INIT
$P_CMPX00  . . . . . . . . . . .  	L NEAR	063D	CSEG_INIT
$P_CMPX01  . . . . . . . . . . .  	L NEAR	0647	CSEG_INIT
$P_CMPX02  . . . . . . . . . . .  	L NEAR	0663	CSEG_INIT
$P_CMPX03  . . . . . . . . . . .  	L NEAR	066A	CSEG_INIT
$P_CMPX04  . . . . . . . . . . .  	L NEAR	0657	CSEG_INIT
$P_CMPX05  . . . . . . . . . . .  	L NEAR	0666	CSEG_INIT
$P_CMPXERR0  . . . . . . . . . .  	L NEAR	0682	CSEG_INIT
$P_CMPX_ERR  . . . . . . . . . .  	L NEAR	068B	CSEG_INIT
$P_CMPX_EXIT . . . . . . . . . .  	L NEAR	0692	CSEG_INIT
$P_CMPX_LOOP . . . . . . . . . .  	L NEAR	062E	CSEG_INIT
$P_CMPX_S  . . . . . . . . . . .  	NUMBER	0400	
$P_COLON . . . . . . . . . . . .  	NUMBER	003A	
$P_COLON_IS_NOT_NECESSARY  . . .  	NUMBER	0020	
$P_COLON_PERIOD  . . . . . . . .  	NUMBER	0001	
$P_COMMA . . . . . . . . . . . .  	NUMBER	002C	
$P_COMPLEX . . . . . . . . . . .  	NUMBER	0004	
$P_COMPLEX_FORMAT  . . . . . . .  	N PROC	061F	CSEG_INIT	Length = 007E
$P_COVF  . . . . . . . . . . . .  	L NEAR	0541	CSEG_INIT
$P_COVF00  . . . . . . . . . . .  	L NEAR	0546	CSEG_INIT
$P_CPC00 . . . . . . . . . . . .  	L NEAR	020D	CSEG_INIT
$P_CPC01 . . . . . . . . . . . .  	L NEAR	022C	CSEG_INIT
$P_CPC02 . . . . . . . . . . . .  	L NEAR	0221	CSEG_INIT
$P_CPC_EXIT  . . . . . . . . . .  	L NEAR	022F	CSEG_INIT
$P_CR  . . . . . . . . . . . . .  	NUMBER	000D	
$P_CSW00 . . . . . . . . . . . .  	L NEAR	02B3	CSEG_INIT
$P_DATE_DMY  . . . . . . . . . .  	NUMBER	0001	
$P_DATE_F  . . . . . . . . . . .  	NUMBER	0007	
$P_DATE_MDY  . . . . . . . . . .  	NUMBER	0000	
$P_DATE_S  . . . . . . . . . . .  	NUMBER	1000	
$P_DATE_YMD  . . . . . . . . . .  	NUMBER	0002	
$P_DBCS00  . . . . . . . . . . .  	L NEAR	08AA	CSEG_INIT
$P_DBCS01  . . . . . . . . . . .  	L NEAR	08C5	CSEG_INIT
$P_DBCS02  . . . . . . . . . . .  	L NEAR	08A0	CSEG_INIT
$P_DBCSEV_OFF  . . . . . . . . .  	L WORD	0009	CSEG_INIT
$P_DBCSEV_SEG  . . . . . . . . .  	L WORD	000B	CSEG_INIT
$P_DBCS_EXIT . . . . . . . . . .  	L NEAR	08CA	CSEG_INIT
$P_DBCS_LOOP . . . . . . . . . .  	L NEAR	08B4	CSEG_INIT
$P_DBSP1 . . . . . . . . . . . .  	NUMBER	0081	
$P_DBSP2 . . . . . . . . . . . .  	NUMBER	0040	
$P_DCC00 . . . . . . . . . . . .  	L NEAR	045A	CSEG_INIT
$P_DCC01 . . . . . . . . . . . .  	L NEAR	0476	CSEG_INIT
$P_DCC_GO  . . . . . . . . . . .  	L NEAR	0453	CSEG_INIT
$P_DCS00 . . . . . . . . . . . .  	L NEAR	043C	CSEG_INIT
$P_DCS01 . . . . . . . . . . . .  	L NEAR	043D	CSEG_INIT
$P_DCS_EXIT  . . . . . . . . . .  	L NEAR	0440	CSEG_INIT
$P_DCS_LOOP  . . . . . . . . . .  	L NEAR	0428	CSEG_INIT
$P_DOSTBL_BL . . . . . . . . . .  	NUMBER	0005	
$P_DOSTBL_CHAR . . . . . . . . .  	NUMBER	0002	
$P_DOSTBL_DEF  . . . . . . . . .  	NUMBER	-0001	
$P_DOSTBL_FILE . . . . . . . . .  	NUMBER	0004	
$P_DOS_GETEV . . . . . . . . . .  	NUMBER	6300	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Symbols-3


$P_DOS_GET_CDI . . . . . . . . .  	NUMBER	3800	
$P_DOS_GET_TBL . . . . . . . . .  	NUMBER	0065	
$P_DO_CAPS_CHAR  . . . . . . . .  	N PROC	0443	CSEG_INIT	Length = 0045
$P_DO_CAPS_STRING  . . . . . . .  	N PROC	0424	CSEG_INIT	Length = 001F
$P_DQUOTE  . . . . . . . . . . .  	NUMBER	0022	
$P_DRIVE . . . . . . . . . . . .  	NUMBER	0006	
$P_DRIVE_FORMAT  . . . . . . . .  	N PROC	0759	CSEG_INIT	Length = 0044
$P_DRVF00  . . . . . . . . . . .  	L NEAR	077C	CSEG_INIT
$P_DRV_ERR . . . . . . . . . . .  	L NEAR	0793	CSEG_INIT
$P_DRV_EXIT  . . . . . . . . . .  	L NEAR	079A	CSEG_INIT
$P_DRV_ONLY  . . . . . . . . . .  	NUMBER	0100	
$P_DRV_ONLY_EXIT . . . . . . . .  	L NEAR	0743	CSEG_INIT
$P_DX  . . . . . . . . . . . . .  	L WORD	0006	CSEG_INIT
$P_EOL . . . . . . . . . . . . .  	NUMBER	0000	
$P_EQU . . . . . . . . . . . . .  	NUMBER	0001	
$P_ERROR_FILESPEC  . . . . . . .  	NUMBER	0001	
$P_ERR_FLAG  . . . . . . . . . .  	L BYTE	00A5	CSEG_INIT
$P_EXIT_AT_EXTRA . . . . . . . .  	L NEAR	07C1	CSEG_INIT
$P_EXTRA . . . . . . . . . . . .  	NUMBER	0020	
$P_FILEF00 . . . . . . . . . . .  	L NEAR	0724	CSEG_INIT
$P_FILEF01 . . . . . . . . . . .  	L NEAR	0720	CSEG_INIT
$P_FILEF02 . . . . . . . . . . .  	L NEAR	0734	CSEG_INIT
$P_FILEF03 . . . . . . . . . . .  	L NEAR	070B	CSEG_INIT
$P_FILEF_ERR . . . . . . . . . .  	L NEAR	06F5	CSEG_INIT
$P_FILEF_LOOP0 . . . . . . . . .  	L NEAR	06DB	CSEG_INIT
$P_FILEF_LOOP1 . . . . . . . . .  	L NEAR	070D	CSEG_INIT
$P_FILEF_RLT . . . . . . . . . .  	L NEAR	0732	CSEG_INIT
$P_FILESP_CHAR . . . . . . . . .  	L BYTE	009C	CSEG_INIT
$P_FILESP_CHK  . . . . . . . . .  	N PROC	0744	CSEG_INIT	Length = 0015
$P_FILESP_EXIT . . . . . . . . .  	L NEAR	0756	CSEG_INIT
$P_FILESP_LEN  . . . . . . . . .  	NUMBER	0009	
$P_FILESP_LOOP . . . . . . . . .  	L NEAR	074D	CSEG_INIT
$P_FILE_FORMAT . . . . . . . . .  	N PROC	06D3	CSEG_INIT	Length = 0071
$P_FILE_SPC  . . . . . . . . . .  	NUMBER	0200	
$P_FILE_SPEC . . . . . . . . . .  	NUMBER	0005	
$P_FILL_RESULT . . . . . . . . .  	N PROC	02C7	CSEG_INIT	Length = 0085
$P_FIN . . . . . . . . . . . . .  	L NEAR	00DC	CSEG_INIT
$P_FLAGS . . . . . . . . . . . .  	L WORD	000D	CSEG_INIT
$P_FLAGS1  . . . . . . . . . . .  	BYTE	000D	CSEG_INIT
$P_FLAGS2  . . . . . . . . . . .  	BYTE	000E	CSEG_INIT
$P_FOUND_SYNONYM . . . . . . . .  	L WORD	0015	CSEG_INIT
$P_IG_COLON  . . . . . . . . . .  	NUMBER	0010	
$P_I_HAVE_DELIM  . . . . . . . .  	NUMBER	0001	
$P_I_HAVE_EOL  . . . . . . . . .  	NUMBER	0002	
$P_I_USE_DEFAULT . . . . . . . .  	NUMBER	0000	
$P_KEYORSW_EXIT  . . . . . . . .  	L NEAR	0255	CSEG_INIT
$P_KEYORSW_FOUND . . . . . . . .  	L NEAR	024F	CSEG_INIT
$P_KEYORSW_LOOP  . . . . . . . .  	L NEAR	0242	CSEG_INIT
$P_KEYORSW_NOT_FOUND . . . . . .  	L NEAR	024C	CSEG_INIT
$P_KEYORSW_PTR . . . . . . . . .  	L WORD	0011	CSEG_INIT
$P_KEYWORD . . . . . . . . . . .  	NUMBER	003D	
$P_KEY_CMP . . . . . . . . . . .  	NUMBER	0008	
$P_KEY_MANAGER . . . . . . . . .  	L NEAR	01AE	CSEG_INIT
$P_KEY_MGR_LOOP  . . . . . . . .  	L NEAR	01CD	CSEG_INIT
$P_KEY_NOT_FOUND . . . . . . . .  	L NEAR	01DB	CSEG_INIT
$P_LEN_PARMS . . . . . . . . . .  	NUMBER	0004	
$P_LEN_RANGE . . . . . . . . . .  	NUMBER	0009	
$P_LEN_STRING  . . . . . . . . .  	NUMBER	0003	
$P_LEN_VALUE . . . . . . . . . .  	NUMBER	0005	
$P_LF  . . . . . . . . . . . . .  	NUMBER	000A	
$P_LIST_IDX  . . . . . . . . . .  	NUMBER	0002	
$P_LPAREN  . . . . . . . . . . .  	NUMBER	0028	
$P_MAKE_LOWER  . . . . . . . . .  	NUMBER	0020	
$P_MAKE_UPPER  . . . . . . . . .  	NUMBER	00DF	
$P_MAT . . . . . . . . . . . . .  	L NEAR	0372	CSEG_INIT
$P_MATCH01 . . . . . . . . . . .  	L NEAR	0389	CSEG_INIT
$P_MATCH03 . . . . . . . . . . .  	L NEAR	038E	CSEG_INIT
$P_MATCH04 . . . . . . . . . . .  	L NEAR	03A5	CSEG_INIT
$P_MATCH05 . . . . . . . . . . .  	L NEAR	03BC	CSEG_INIT
$P_MATCH06 . . . . . . . . . . .  	L NEAR	03D6	CSEG_INIT
$P_MATCH09 . . . . . . . . . . .  	L NEAR	03E5	CSEG_INIT
$P_MATCH2_EXIT . . . . . . . . .  	L NEAR	03FC	CSEG_INIT
$P_MATCH_EXIT  . . . . . . . . .  	L NEAR	03E5	CSEG_INIT
$P_MBP_EXIT  . . . . . . . . . .  	L NEAR	0262	CSEG_INIT
$P_MBP_LOOP  . . . . . . . . . .  	L NEAR	0258	CSEG_INIT
$P_MINUS . . . . . . . . . . . .  	NUMBER	002D	
$P_MOVEBP_NUL  . . . . . . . . .  	N PROC	0258	CSEG_INIT	Length = 000C
$P_NEG . . . . . . . . . . . . .  	NUMBER	0002	
$P_NON_DBCS  . . . . . . . . . .  	L NEAR	08C9	CSEG_INIT
$P_NOT_APPLICABLE  . . . . . . .  	L NEAR	05F2	CSEG_INIT
$P_NOT_IN_KEY  . . . . . . . . .  	NUMBER	0004	
$P_NOT_IN_STR  . . . . . . . . .  	NUMBER	0008	
$P_NOT_IN_SW . . . . . . . . . .  	NUMBER	0003	
$P_NOT_IN_VAL  . . . . . . . . .  	NUMBER	0007	
$P_NO_ERROR  . . . . . . . . . .  	NUMBER	0000	
$P_NO_NRNG . . . . . . . . . . .  	NUMBER	0000	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Symbols-4


$P_NO_SET_EXTRA  . . . . . . . .  	L NEAR	0856	CSEG_INIT
$P_NO_TAG  . . . . . . . . . . .  	NUMBER	00FF	
$P_NULL  . . . . . . . . . . . .  	NUMBER	0000	
$P_NUMBER  . . . . . . . . . . .  	NUMBER	0001	
$P_NUM_VAL . . . . . . . . . . .  	NUMBER	8000	
$P_NVAL_NONE . . . . . . . . . .  	NUMBER	0000	
$P_NVAL_RANGE  . . . . . . . . .  	NUMBER	0001	
$P_NVAL_STRING . . . . . . . . .  	NUMBER	0003	
$P_NVAL_VALUE  . . . . . . . . .  	NUMBER	0002	
$P_OPTIONAL  . . . . . . . . . .  	NUMBER	0001	
$P_OP_MISSING  . . . . . . . . .  	NUMBER	0002	
$P_ORDINAL . . . . . . . . . . .  	L WORD	0000	CSEG_INIT
$P_OUT_OF_RANGE  . . . . . . . .  	NUMBER	0006	
$P_PACK_END  . . . . . . . . . .  	L NEAR	0137	CSEG_INIT
$P_PACK_END_BACKUP_SI  . . . . .  	L NEAR	0111	CSEG_INIT
$P_PACK_END_BY_EOL . . . . . . .  	L NEAR	0136	CSEG_INIT
$P_PACK_LOOP . . . . . . . . . .  	L NEAR	00F4	CSEG_INIT
$P_PERIOD  . . . . . . . . . . .  	NUMBER	002E	
$P_PERIOD_ONLY . . . . . . . . .  	NUMBER	0002	
$P_PL00  . . . . . . . . . . . .  	L NEAR	0129	CSEG_INIT
$P_PL01  . . . . . . . . . . . .  	L NEAR	011C	CSEG_INIT
$P_PLUS  . . . . . . . . . . . .  	NUMBER	002B	
$P_POSITIONAL_MANAGER  . . . . .  	L NEAR	015A	CSEG_INIT
$P_QUOTED_STR  . . . . . . . . .  	N PROC	069D	CSEG_INIT	Length = 0036
$P_QUOTED_STRING . . . . . . . .  	NUMBER	0009	
$P_QUOTED_STR_EXIT . . . . . . .  	L NEAR	06D1	CSEG_INIT
$P_QUS00 . . . . . . . . . . . .  	L NEAR	06B6	CSEG_INIT
$P_QUS01 . . . . . . . . . . . .  	L NEAR	06C2	CSEG_INIT
$P_QUS02 . . . . . . . . . . . .  	L NEAR	06CC	CSEG_INIT
$P_QUSTR_ERR0  . . . . . . . . .  	L NEAR	06C9	CSEG_INIT
$P_QUS_LOOP  . . . . . . . . . .  	L NEAR	069E	CSEG_INIT
$P_QU_STRING . . . . . . . . . .  	NUMBER	0080	
$P_RC  . . . . . . . . . . . . .  	L WORD	0002	CSEG_INIT
$P_RCOL00  . . . . . . . . . . .  	L NEAR	0418	CSEG_INIT
$P_RCOL01  . . . . . . . . . . .  	L NEAR	041E	CSEG_INIT
$P_RCOL_EXIT . . . . . . . . . .  	L NEAR	0421	CSEG_INIT
$P_RCOL_LOOP . . . . . . . . . .  	L NEAR	0400	CSEG_INIT
$P_RC_EOL  . . . . . . . . . . .  	NUMBER	-0001	
$P_REMOVE_COLON  . . . . . . . .  	N PROC	03FE	CSEG_INIT	Length = 0026
$P_REPEAT  . . . . . . . . . . .  	NUMBER	0002	
$P_RETURN_TO_CALLER  . . . . . .  	L NEAR	01E2	CSEG_INIT
$P_RETURN_TO_CALLER0 . . . . . .  	L NEAR	01E2	CSEG_INIT
$P_RLT00 . . . . . . . . . . . .  	L NEAR	02F0	CSEG_INIT
$P_RLT01 . . . . . . . . . . . .  	L NEAR	02FA	CSEG_INIT
$P_RLT02 . . . . . . . . . . . .  	L NEAR	02E6	CSEG_INIT
$P_RLT03 . . . . . . . . . . . .  	L NEAR	030C	CSEG_INIT
$P_RLT04 . . . . . . . . . . . .  	L NEAR	02E2	CSEG_INIT
$P_RLT05 . . . . . . . . . . . .  	L NEAR	031F	CSEG_INIT
$P_RLT_CAP00 . . . . . . . . . .  	L NEAR	0333	CSEG_INIT
$P_RLT_CAP01 . . . . . . . . . .  	L NEAR	033F	CSEG_INIT
$P_RLT_CAP02 . . . . . . . . . .  	L NEAR	033C	CSEG_INIT
$P_RLT_EXIT  . . . . . . . . . .  	L NEAR	034A	CSEG_INIT
$P_RM_COLON  . . . . . . . . . .  	NUMBER	0010	
$P_RPAREN  . . . . . . . . . . .  	NUMBER	0029	
$P_SAVESI_CMPX . . . . . . . . .  	L WORD	000F	CSEG_INIT
$P_SAVE_EOB  . . . . . . . . . .  	L WORD	0013	CSEG_INIT
$P_SCOM00  . . . . . . . . . . .  	L NEAR	05C6	CSEG_INIT
$P_SCOM01  . . . . . . . . . . .  	L NEAR	05D9	CSEG_INIT
$P_SCOM02  . . . . . . . . . . .  	L NEAR	0606	CSEG_INIT
$P_SCOM03  . . . . . . . . . . .  	L NEAR	05B8	CSEG_INIT
$P_SCOM04  . . . . . . . . . . .  	L NEAR	05A2	CSEG_INIT
$P_SCOM05  . . . . . . . . . . .  	L NEAR	05B5	CSEG_INIT
$P_SCOM_DIFFER . . . . . . . . .  	L NEAR	0611	CSEG_INIT
$P_SCOM_DIFFER0  . . . . . . . .  	L NEAR	05DB	CSEG_INIT
$P_SCOM_EXIT . . . . . . . . . .  	L NEAR	061A	CSEG_INIT
$P_SCOM_LOOP . . . . . . . . . .  	L NEAR	0582	CSEG_INIT
$P_SCOM_SAME . . . . . . . . . .  	L NEAR	0614	CSEG_INIT
$P_SEARCH_KEYORSW  . . . . . . .  	N PROC	0233	CSEG_INIT	Length = 0025
$P_SIGNED  . . . . . . . . . . .  	NUMBER	0080	
$P_SIM00 . . . . . . . . . . . .  	L NEAR	0569	CSEG_INIT
$P_SIM01 . . . . . . . . . . . .  	L NEAR	0569	CSEG_INIT
$P_SIMPLE_S  . . . . . . . . . .  	NUMBER	2000	
$P_SIMPLE_STRING . . . . . . . .  	N PROC	0556	CSEG_INIT	Length = 0026
$P_SIM_EXIT  . . . . . . . . . .  	L NEAR	0572	CSEG_INIT
$P_SIM_EXIT0 . . . . . . . . . .  	L NEAR	0574	CSEG_INIT
$P_SINGLE_EXIT . . . . . . . . .  	L NEAR	01FD	CSEG_INIT
$P_SI_SAVE . . . . . . . . . . .  	L WORD	0004	CSEG_INIT
$P_SKIP_DELIM  . . . . . . . . .  	N PROC	079D	CSEG_INIT	Length = 0026
$P_SKIP_DELIM_CY . . . . . . . .  	L NEAR	07BB	CSEG_INIT
$P_SKIP_DELIM_EXIT . . . . . . .  	L NEAR	07BF	CSEG_INIT
$P_SKIP_DELIM_LOOP . . . . . . .  	L NEAR	079D	CSEG_INIT
$P_SKIP_DELIM_NCY  . . . . . . .  	L NEAR	07BE	CSEG_INIT
$P_SLASH . . . . . . . . . . . .  	NUMBER	002F	
$P_SNUM_VAL  . . . . . . . . . .  	NUMBER	4000	
$P_SPACE . . . . . . . . . . . .  	NUMBER	0020	
$P_START . . . . . . . . . . . .  	L NEAR	00E0	CSEG_INIT
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:45:32
fastp.asm - fastopen SYSTEM COMMAND LINE PARSER             Symbols-5


$P_STRING  . . . . . . . . . . .  	NUMBER	0003	
$P_STRING_BUF  . . . . . . . . .  	L BYTE	0017	CSEG_INIT	Length = 0080
$P_STRING_BUF_END  . . . . . . .  	NEAR	0097	CSEG_INIT
$P_STRING_COMP . . . . . . . . .  	N PROC	057C	CSEG_INIT	Length = 00A3
$P_STRUC_L1  . . . . . . . . . .  	L NEAR	0877	CSEG_INIT
$P_STRUC_L12 . . . . . . . . . .  	L NEAR	0876	CSEG_INIT
$P_STRUC_L2  . . . . . . . . . .  	L NEAR	086C	CSEG_INIT
$P_STRUC_L5  . . . . . . . . . .  	L NEAR	0869	CSEG_INIT
$P_SVAL00  . . . . . . . . . . .  	L NEAR	04A6	CSEG_INIT
$P_SVAL01  . . . . . . . . . . .  	L NEAR	04A7	CSEG_INIT
$P_SVALUE  . . . . . . . . . . .  	N PROC	0488	CSEG_INIT	Length = 0024
$P_SW  . . . . . . . . . . . . .  	NUMBER	0040	
$P_SWITCH  . . . . . . . . . . .  	NUMBER	002F	
$P_SW_CMP  . . . . . . . . . . .  	NUMBER	0010	
$P_SW_MANAGER  . . . . . . . . .  	L NEAR	0182	CSEG_INIT
$P_SW_MGR_LOOP . . . . . . . . .  	L NEAR	0197	CSEG_INIT
$P_SW_NOT_FOUND  . . . . . . . .  	L NEAR	01A5	CSEG_INIT
$P_SYNTAX  . . . . . . . . . . .  	NUMBER	0009	
$P_TAB . . . . . . . . . . . . .  	NUMBER	0009	
$P_TERMINATOR  . . . . . . . . .  	L BYTE	0008	CSEG_INIT
$P_TIME12  . . . . . . . . . . .  	NUMBER	0004	
$P_TIME12AM  . . . . . . . . . .  	NUMBER	0001	
$P_TIME_AGAIN  . . . . . . . . .  	NUMBER	0002	
$P_TIME_F  . . . . . . . . . . .  	NUMBER	0008	
$P_TIME_S  . . . . . . . . . . .  	NUMBER	0800	
$P_TOO_MANY  . . . . . . . . . .  	NUMBER	0001	
$P_TOO_MANY_ERROR  . . . . . . .  	L NEAR	0179	CSEG_INIT
$P_VALUE . . . . . . . . . . . .  	N PROC	04AC	CSEG_INIT	Length = 008A
$P_VALUE00 . . . . . . . . . . .  	L NEAR	04FE	CSEG_INIT
$P_VALUE01 . . . . . . . . . . .  	L NEAR	0511	CSEG_INIT
$P_VALUE02 . . . . . . . . . . .  	L NEAR	0523	CSEG_INIT
$P_VALUE03 . . . . . . . . . . .  	L NEAR	0523	CSEG_INIT
$P_VALUE04 . . . . . . . . . . .  	L NEAR	0523	CSEG_INIT
$P_VALUE_ERR . . . . . . . . . .  	L NEAR	0523	CSEG_INIT
$P_VALUE_ERR0  . . . . . . . . .  	L NEAR	04FA	CSEG_INIT
$P_VALUE_EXIT  . . . . . . . . .  	L NEAR	052E	CSEG_INIT
$P_VALUE_LOOP  . . . . . . . . .  	L NEAR	04B5	CSEG_INIT
@CPU . . . . . . . . . . . . . .  	TEXT  0101h		
@FILENAME  . . . . . . . . . . .  	TEXT  fastp		
@VERSION . . . . . . . . . . . .  	TEXT  510		


   3609 Source  Lines
   3617 Total   Lines
    355 Symbols

  46344 + 210928 Bytes symbol space free

      0 Warning Errors
      0 Severe  Errors
