Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-1


				page	60,132
				name	_parse
				title	C	to PARSER interface
				;-------------------------------------------------------------------
				;
				;	MODULE: 	_parse
				;
				;	PURPOSE:	Supplies an interface between C programs and
				;			the DOS 3.3 parser
				;
				;		      **(Customized for the JOIN utility)
				;
				;	CALLING FORMAT:
				;			parse(&inregs,&outregs);
				;
				;	DATE:		5-21-87
				;
				;-------------------------------------------------------------------
				
				;	extrn	sysparse:far
				
					public	_parse								;AN000;
				
				;-------------------------------------------------------------------
				
				; set for JOIN
				; -------------
				
 = 0000				FarSW	equ	0			; make sysparse be a NEAR proc		;AN000;
 = 0000				TimeSW	equ	0			; Check time format			;AN000;
 = 0001				FileSW	equ	1			; Check file specification		;AN000;
 = 0001				CAPSW	equ	1			; Perform CAPS if specified		;AN000;
 = 0000				CmpxSW	equ	0			; Check complex list			;AN000;
 = 0000				NumSW	equ	0			; Check numeric value			;AN000;
 = 0000				KeySW	equ	0			; Support keywords			;AN000;
 = 0001				SwSW	equ	1			; Support switches			;AN000;
 = 0000				Val1SW	equ	0			; Support value definition 1		;AN000;
 = 0000				Val2SW	equ	0			; Support value definition 2		;AN000;
 = 0000				Val3SW	equ	0			; Support value definition 3		;AN000;
 = 0001				DrvSW	equ	1			; Support drive only format		;AN000;
 = 0000				QusSW	equ	0			; Support quoted string format		;AN000;
				;-------------------------------------------------------------------
				
				DGROUP	GROUP	_DATA
				PGROUP	GROUP	_TEXT
				
 0000				_DATA	segment byte public 'DATA'	;AN000;
 = 0001				BASESW	=	1			;SPECIFY, PSDATA POINTED TO BY "DS"
 = 0000				INCSW	=	0			;PSDATA.INC IS ALREADY INCLUDED
					INCLUDE PSDATA.INC		;PARSER'S WORK SPACE
			     C	;*******************************************************************
			     C	; Parser include file
			     C	;*******************************************************************
			     C	;
			     C	;**** Default assemble switches definition *************************
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-2


			     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:44:30
C	to PARSER interface                                       Page     1-3


			     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:44:30
C	to PARSER interface                                       Page     1-4


			     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:44:30
C	to PARSER interface                                       Page     1-5


			     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
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-6


			     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
 = 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:44:30
C	to PARSER interface                                       Page     1-7


			     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:44:30
C	to PARSER interface                                       Page     1-8


			     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	;--------------------------------
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-9


			     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:44:30
C	to PARSER interface                                       Page     1-10


			     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;
			     C	IF		   DateSw+TimeSw	;AN000;(Check if date or time format is supported)
			     C	;------------------------------
			     C	;
 0097  00                    C	$P_Got_Time	   db	0		;AN023; if 1, use Time delimiters
 = FFFF                      C	$P_NeedToBeRead    equ	0ffffh		;AN000;
			     C	
 0098  FFFF                  C	$P_COUNTRY_INFO    $P_CDI <$P_NeedToBeRead> ;AN000;
 009A  0001[                 C	
	   00                C	
	   00                C	
	   00                C	
	   00                C	
	   00                C	
			 ]   C	
 009F  0001[                 C	
	   00                C	
	   00                C	
			 ]   C	
 00A1  0001[                 C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-11


	   00                C	
	   00                C	
			 ]   C	
 00A3  0001[                 C	
	   00                C	
	   00                C	
			 ]   C	
 00A5  0001[                 C	
	   00                C	
	   00                C	
			 ]   C	
 00A7  00                    C	
 00A8  00                    C	
 00A9  00                    C	
 00AA  0001[                 C	
	   0000              C	
	   0000              C	
			 ]   C	
 00AE  0001[                 C	
	   00                C	
	   00                C	
			 ]   C	
 00B0  0005[                 C	
	   0000              C	
			 ]   C	
			     C	
			     C	;
 00BA  0000                  C	$P_1st_Val	   dw	0		;AN000; used when process date or time
 00BC  0000                  C	$P_2nd_Val	   dw	0		;AN000; used when process date or time
 00BE  0000                  C	$P_3rd_Val	   dw	0		;AN000; used when process date or time
 00C0  0000                  C	$P_4th_Val	   dw	0		;AN000; used when process date or time
			     C	;------------------------------
			     C	ENDIF					;AN000;(of DateSW+TimeSW)
 00C2  FF                    C	$P_Char_CAP_Ptr    db	0ffh		;AN000; info id
 00C3  0000                  C			   dw	0		;AN000; offset	of char case map table
 00C5  0000                  C			   dw	0		;AN000; segment of char case map table
			     C	IF		   CAPSW		;AN000;(Check if uppercase conversion is supported)
 00C7  FF                    C	$P_File_CAP_Ptr    db	0ffh		;AN000; info id
 00C8  0000                  C			   dw	0		;AN000; offset	of file case map table
 00CA  0000                  C			   dw	0		;AN000; segment of file case map table
			     C	ENDIF					;AN000;(of CAPSW)
			     C	; (tm06) IF	   FileSW		;AN000;(Check if file spec is supported)
			     C	IF		   FileSW+DrvSW 	;AN000;(Check if file spec is supported)
 00CC  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
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-12


			     C	
			     C	;filespec error flag
 00D5  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	;***********************************************************************
 00D6				_DATA	ends				;AN000;
				
 0000				_TEXT	segment byte public 'CODE'	;AN000;
				
					ASSUME	CS: PGROUP		;AN000;
					ASSUME	DS: DGROUP		;AN000;
				
				;-------------------------------------------------------------------
				include parse.asm			; include the parser			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-13


			     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	ELSE					;AN022;
			     C	   IF  basesw				;AN022;IF "basesw  EQU  1" specified by caller THEN
 =                           C	       psdata_seg EQU	DS		;AN022;
			     C	   ENDIF				;AN022;
			     C	ENDIF					;AN022;
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-14


			     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
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-15


			     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)
			     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.
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-16


			     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	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-17


			     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	;
			     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;
 0000                        C	SysParse proc near			;AN000;
			     C	ENDIF					;AN000;(of FarSW)
			     C	;	$SALUT	(4,9,17,41)
 0000  C7 06 000D R 0000     C		mov	psdata_seg:$P_Flags,0	;AC034; Clear all internal flags
 0006  FC                    C		cld				      ;AN000; confirm forward direction
 0007  89 0E 0000 R          C		mov	psdata_seg:$P_ordinal,cx      ;AC034; save operand ordinal
 000B  C7 06 0002 R 0000     C		mov	psdata_seg:$P_RC,$P_No_Error  ;AC034; Assume no error
 0011  C7 06 0015 R 0000     C		mov	psdata_seg:$P_Found_SYNONYM,0 ;AC034; initalize synonym pointer
			     C	
 0017  C7 06 0006 R 0000     C		mov	word ptr psdata_seg:$P_DX,0   ;AC034; (tm15)
 001D  E8 0634 R             C		call	$P_Skip_Delim		;AN000; Move si to 1st non white space
 0020  73 13                 C		jnc	$P_Start		;AN000; If EOL is not encountered, do parse
			     C	
			     C	;--------------------------- End of Line
 0022  B8 FFFF               C		mov	ax,$P_RC_EOL		;AN000; set exit code to -1
 0025  53                    C		push	bx			;AN000;
 0026  26: 8B 1D             C		mov	bx,es:[di].$P_PARMSX_Address ;AN000; Get the PARMSX address to
 0029  26: 3A 0F             C		cmp	cl,es:[bx].$P_MinP	;AN000; check ORDINAL to see if the minimum
 002C  73 03                 C		jae	$P_Fin			;AN000; positional found.
			     C	
 002E  B8 0002               C		mov	ax,$P_Op_Missing	;AN000; If no, set exit code to missing operand
 0031                        C	$P_Fin: 				;AN000;
 0031  5B                    C		pop	bx			;AN000;
 0032  E9 013C R             C		jmp	$P_Single_Exit		;AN000; return to the caller
			     C	
			     C	;---------------------------
 0035                        C	$P_Start:				;AN000;
 0035  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,
 0039  53                    C		push	bx			;AN000; quoted string or file spec.
 003A  57                    C		push	di			;AN000;
 003B  55                    C		push	bp			;AN000;
 003C  8D 1E 0017 R          C		lea	bx,psdata_seg:$P_STRING_BUF ;AC034; set buffer to copy from command string
 0040  F6 06 000E R 20       C		test	psdata_seg:$P_Flags2,$P_Extra ;AC034; 3/9 extra delimiter encountered ?
 0045  75 3E                 C		jne	$P_Pack_End		;AN000; 3/9 if yes, no need to copy
			     C	
 0047                        C	$P_Pack_Loop:				;AN000;
 0047  AC                    C		lodsb				;AN000; Pick a operand from buffer
 0048  E8 06EA R             C		call	$P_Chk_Switch		;AN000; Check switch character
 004B  72 37                 C		jc	$P_Pack_End_BY_EOL	;AN020; if carry set found delimiter type slash, need backup
				 si, else continue
			     C	
 004D  E8 0658 R             C		call	$P_Chk_EOL		;AN000; Check EOL character
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-18


 0050  74 32                 C		je	$P_Pack_End_BY_EOL	;AN000; need backup si
			     C	
 0052  E8 068E R             C		call	$P_Chk_Delim		;AN000; Check delimiter
 0055  75 16                 C		jne	$P_PL01 		;AN000; If no, process next byte
			     C	
 0057  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
 005C  75 05                 C		jne	$P_Pack_End_backup_si	;AN000; (tm08)
			     C	
 005E  E8 0634 R             C		call	$P_Skip_Delim		;AN000; skip subsequent white space,too
 0061  EB 22                 C		jmp	short $P_Pack_End	;AN000; finish copy by placing NUL at end
			     C	
 0063                        C	$P_PAck_End_backup_si:			;AN000; (tm08)
 0063  F6 06 000E R 41       C		test	psdata_seg:$P_Flags2,$P_SW+$P_equ ;AN000;AC034;  (tm08)
 0068  74 1B                 C		je	$P_Pack_End		;AN000; (tm08)
			     C	
 006A  4E                    C		dec	si			;AN000; (tm08)
 006B  EB 18                 C		jmp	short $P_Pack_End	;AN025; (tm08)
			     C	
 006D                        C	$P_PL01:				;AN000;
 006D  88 07                 C		mov	psdata_seg:[bx],al	;AN000; move byte to STRING_BUF
 006F  3C 3D                 C		cmp	al,$P_Keyword		;AN000; if it is equal character,
 0071  75 05                 C		jne	$P_PL00 		;AN000; then
			     C	
 0073  80 0E 000E R 01       C		or	psdata_seg:$P_Flags2,$P_equ ;AC034; remember it in flag
 0078                        C	$P_PL00:				;AN000;
 0078  43                    C		inc	bx			;AN000; ready to see next byte
 0079  E8 0716 R             C		call	$P_Chk_DBCS		;AN000; was it 1st byte of DBCS ?
 007C  73 C9                 C		jnc	$P_Pack_Loop		;AN000; if no, process to next byte
			     C	
 007E  AC                    C		lodsb				;AN000; if yes, store
 007F  88 07                 C		mov	psdata_seg:[bx],al	;AN000;    2nd byte of DBCS
 0081  43                    C		inc	bx			;AN000; update pointer
 0082  EB C3                 C		jmp	short $P_Pack_Loop	;AN000; process to next byte
			     C	
 0084                        C	$P_Pack_End_BY_EOL:			;AN000;
 0084  4E                    C		dec	si			;AN000; backup si pointer
 0085                        C	$P_Pack_End:				;AN000;
 0085  89 36 0004 R          C		mov	psdata_seg:$P_SI_Save,si     ;AC034; save next pointer, SI
 0089  C6 07 00              C		mov	byte ptr psdata_seg:[bx],$P_NULL ;AN000; put NULL at the end
 008C  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
 0090  26: 8B 1D             C		mov	bx,es:[di].$P_PARMSX_Address ;AN000; get PARMSX address
 0093  8D 36 0017 R          C		lea	si,psdata_seg:$P_STRING_BUF  ;AC034;
 0097  80 3C 2F              C		cmp	byte ptr psdata_seg:[si],$P_Switch ;AN000; the operand begins w/ switch char ?
 009A  74 2C                 C		je	$P_SW_Manager		     ;AN000; if yes, process as switch
			     C	
 009C  F6 06 000E R 01       C		test	psdata_seg:$P_Flags2,$P_equ   ;AC034; the operand includes equal char ?
 00A1  75 50                 C		jne	$P_Key_manager		     ;AN000; if yes, process as keyword
			     C	
 00A3                        C	$P_Positional_Manager:			;AN000; else process as positional
 00A3  26: 8A 47 01          C		mov	al,es:[bx].$P_MaxP	;AN000; get maxp
 00A7  32 E4                 C		xor	ah,ah			;AN000; ax = maxp
 00A9  39 06 0000 R          C		cmp	psdata_seg:$P_ORDINAL,ax ;AC034; too many positional ?
 00AD  73 11                 C		jae	$P_Too_Many_Error	;AN000; if yes, set exit code to too many
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-19


 00AF  A1 0000 R             C		mov	ax,psdata_seg:$P_ORDINAL ;AC034; see what the current ordinal
 00B2  D1 E0                 C		shl	ax,1			;AN000; ax = ax*2
 00B4  43                    C		inc	bx			;AC035; add '2' to
 00B5  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
 00B6  03 D8                 C		add	bx,ax			;AN000; now bx points to specified CONTROL address
 00B8  26: 8B 1F             C		mov	bx,es:[bx]		;AN000; now bx points to specified CONTROL itself
 00BB  E8 013E R             C		call	$P_Chk_Pos_Control	;AN000; Do process for positional
 00BE  EB 66                 C		jmp	short $P_Return_to_Caller ;AN000; and return to the caller
			     C	
 00C0                        C	$P_Too_Many_Error:			;AN000;
 00C0  C7 06 0002 R 0001     C		mov	psdata_seg:$P_RC,$P_Too_Many ;AC034; set exit code
 00C6  EB 5E                 C		jmp	short $P_Return_to_Caller ;AN000; and return to the caller
			     C	;
 00C8                        C	$P_SW_Manager:				;AN000;
 00C8  26: 8A 47 01          C		mov	al,es:[bx].$P_MaxP	;AN000; get maxp
 00CC  32 E4                 C		xor	ah,ah			;AN000; ax = maxp
 00CE  40                    C		inc	ax			;AN000;
 00CF  D1 E0                 C		shl	ax,1			;AN000; ax = (ax+1)*2
 00D1  03 D8                 C		add	bx,ax			;AN000; now bx points to maxs
 00D3  26: 8A 0F             C		mov	cl,es:[bx]		;AN000;
 00D6  32 ED                 C		xor	ch,ch			;AN000; cx = maxs
 00D8  0B C9                 C		or	cx,cx			;AN000; at least one switch ?
 00DA  74 0F                 C		je	$P_SW_Not_Found 	;AN000;
			     C	
 00DC  43                    C		inc	bx			;AN000; now bx points to 1st CONTROL address
			     C	
 00DD                        C	$P_SW_Mgr_Loop: 			;AN000;
 00DD  53                    C		push	bx			;AN000;
 00DE  26: 8B 1F             C		mov	bx,es:[bx]		;AN000; bx points to Switch CONTROL itself
 00E1  E8 019F R             C		call	$P_Chk_SW_Control	;AN000; do process for switch
 00E4  5B                    C		pop	bx			;AN000;
 00E5  73 3F                 C		jnc	$P_Return_to_Caller	;AN000; if the CONTROL is for the switch, exit
			     C	
 00E7  43                    C		inc	bx			;AC035; add '2' to
 00E8  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
 00E9  E2 F2                 C		loop	$P_SW_Mgr_Loop		;AN000; and loop
			     C	
 00EB                        C	$P_SW_Not_Found:			;AN000;
 00EB  C7 06 0002 R 0003     C		mov	psdata_seg:$P_RC,$P_Not_In_SW ;AC034; here no CONTROL for the switch has
 00F1  EB 33                 C		jmp	short $P_Return_to_Caller0    ;AN000; not been found, means error.
			     C	;
 00F3                        C	$P_Key_Manager: 			;AN000;
 00F3  26: 8A 47 01          C		mov	al,es:[bx].$P_MaxP	;AN000; get maxp
 00F7  32 E4                 C		xor	ah,ah			;AN000; ax = maxp
 00F9  40                    C		inc	ax			;AN000;
 00FA  D1 E0                 C		shl	ax,1			;AN000; ax = (ax+1)*2
 00FC  03 D8                 C		add	bx,ax			;AN000; now bx points to maxs
 00FE  26: 8A 07             C		mov	al,es:[bx]		;AN000;
 0101  32 E4                 C		xor	ah,ah			;AN000; ax = maxs
 0103  D1 E0                 C		shl	ax,1			;AN000;
 0105  40                    C		inc	ax			;AN000; ax = ax*2+1
 0106  03 D8                 C		add	bx,ax			;AN000; now bx points to maxk
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-20


 0108  26: 8A 0F             C		mov	cl,es:[bx]		;AN000;
 010B  32 ED                 C		xor	ch,ch			;AN000; cx = maxk
 010D  0B C9                 C		or	cx,cx			;AN000; at least one keyword ?
 010F  74 0F                 C		je	$P_Key_Not_Found	;AN000;
			     C	
 0111  43                    C		inc	bx			;AN000; now bx points to 1st CONTROL
			     C	
 0112                        C	$P_Key_Mgr_Loop:			;AN000;
 0112  53                    C		push	bx			;AN000;
 0113  26: 8B 1F             C		mov	bx,es:[bx]		;AN000; bx points to keyword CONTROL itself
 0116  E8 016D R             C		call	$P_Chk_Key_Control	;AN000; do process for keyword
 0119  5B                    C		pop	bx			;AN000;
 011A  73 0A                 C		jnc	$P_Return_to_Caller	;AN000; if the CONTROL is for the keyword, exit
			     C	
 011C  43                    C		inc	bx			;AC035; add '2' to
 011D  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
 011E  E2 F2                 C		loop	$P_Key_Mgr_Loop 	;AN000; and loop
			     C	
 0120                        C	$P_Key_Not_Found:			;AN000;
 0120  C7 06 0002 R 0004     C		mov	psdata_seg:$P_RC,$P_Not_In_Key ;AC034; here no CONTROL for the keyword has
 0126                        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	
 0126                        C	$P_Return_to_Caller:			;AN000;
 0126  5D                    C		pop	bp			;AN000;
 0127  5F                    C		pop	di			;AN000;
 0128  5B                    C		pop	bx			;AN000;
 0129  8B 0E 0000 R          C		mov	cx,psdata_seg:$P_Ordinal    ;AC034; return next ordinal
 012D  A1 0002 R             C		mov	ax,psdata_seg:$P_RC	    ;AC034; return exit code
 0130  8B 36 0004 R          C		mov	si,psdata_seg:$P_SI_Save    ;AC034; return next operand pointer
 0134  8B 16 0006 R          C		mov	dx,psdata_seg:$P_DX	    ;AC034; return result buffer address
 0138  8A 1E 0008 R          C		mov	bl,psdata_seg:$P_Terminator ;AC034; return delimiter code found
 013C                        C	$P_Single_Exit: 			;AN000;
 013C  F8                    C		clc				;AN000;
 013D  C3                    C		ret				;AN000;
 013E                        C	SysParse endp				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-21


			     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	;***********************************************************************
 013E                        C	$P_Chk_Pos_Control proc 		;AN000;
 013E  50                    C		push	ax			;AN000;
 013F  26: 8B 07             C		mov	ax,es:[bx].$P_Match_Flag ;AN000;
 0142  A9 0002               C		test	ax,$P_Repeat		;AN000; repeat allowed ?
 0145  75 04                 C		jne	$P_CPC00		;AN000; then do not increment ORDINAL
			     C	
 0147  FF 06 0000 R          C		inc	psdata_seg:$P_ORDINAL	;AC034; update the ordinal
 014B                        C	$P_CPC00:				;AN000;
 014B  80 3C 00              C		cmp	byte ptr psdata_seg:[si],$P_NULL ;AN000; no data ?
 014E  75 18                 C		jne	$P_CPC01		;AN000;
			     C	
 0150  A9 0001               C		test	ax,$P_Optional		;AN000; yes, then is it optional ?
 0153  75 08                 C		jne	$P_CPC02		;AN000;
			     C	
 0155  C7 06 0002 R 0002     C		mov	psdata_seg:$P_RC,$P_Op_Missing ;AC034; no, then error	     3/17/87
 015B  EB 0E                 C		jmp	short $P_CPC_Exit	;AN000;
			     C	
 015D                        C	$P_CPC02:				;AN000;
 015D  50                    C		push	ax			;AN000;
 015E  B0 03                 C		mov	al,$P_String		;AN000; if it is optional return NULL
 0160  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; no item tag indication
 0162  E8 01F9 R             C		call	$P_Fill_Result		;AN000;
 0165  58                    C		pop	ax			;AN000;
 0166  EB 03                 C		jmp	short $P_CPC_Exit	;AN000;
			     C	
 0168                        C	$P_CPC01:				;AN000;
 0168  E8 027B R             C		call	$P_Check_Match_Flags	;AN000;
 016B                        C	$P_CPC_Exit:				;AN000;
 016B  58                    C		pop	ax			;AN000;
 016C  C3                    C		ret				;AN000;
 016D                        C	$P_Chk_Pos_Control endp 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-22


			     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	;***********************************************************************
 016D                        C	$P_Chk_Key_Control proc 		;AN000;
			     C	ELSE					;AN000;(of IF KeySW)
 016D  F9                    C		stc				;AN000;this logic works when the KeySW
 016E  C3                    C		ret				;AN000;is reset.
			     C	ENDIF					;AN000;(of KeySW)
 016F                        C	$P_Chk_Key_Control endp 		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-23


			     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	;***********************************************************************
 016F                        C	$P_Search_KEYorSW proc			;AN000;
 016F  55                    C		push	bp			;AN000;
 0170  51                    C		push	cx			;AN000;
 0171  26: 8A 4F 08          C		mov	cl,es:[bx].$P_nid	;AN000; Get synonym count
 0175  32 ED                 C		xor	ch,ch			;AN000; and set it to cx
 0177  0B C9                 C		or	cx,cx			;AN000; No synonyms specified ?
 0179  74 0D                 C		je	$P_KEYorSW_Not_Found	;AN000; then indicate not found by CY
			     C	
 017B  8D 6F 09              C		lea	bp,es:[bx].$P_KEYorSW	;AN000; BP points to the 1st synonym
 017E                        C	$P_KEYorSW_Loop:			;AN000;
 017E  E8 03C8 R             C		call	$P_String_Comp		;AN000; compare string in buffer w/ the synonym
 0181  73 08                 C		jnc	$P_KEYorSW_Found	;AN000; If match, set it to synonym pointer
			     C	
 0183  E8 0193 R             C		call	$P_MoveBP_NUL		;AN000; else, bp points to the next string
 0186  E2 F6                 C		loop	$P_KEYorSW_Loop 	;AN000; loop nid times
 0188                        C	$P_KEYorSW_Not_Found:			;AN000;
 0188  F9                    C		stc				;AN000; indicate not found in synonym list
 0189  EB 05                 C		jmp	short $P_KEYorSW_Exit	;AN000; and exit
			     C	
 018B                        C	$P_KEYorSW_Found:			;AN000;
 018B  89 2E 0015 R          C		mov	psdata_seg:$P_Found_SYNONYM,bp ;AC034; set synonym pointer
 018F  F8                    C		clc				;AN000; indicate found
 0190                        C	$P_KEYorSW_Exit:			;AN000;
 0190  59                    C		pop	cx			;AN000;
 0191  5D                    C		pop	bp			;AN000;
 0192  C3                    C		ret				;AN000;
 0193                        C	$P_Search_KEYorSW endp			;AN000;
			     C	;***********************************************************************
			     C	; $P_MoveBP_NUL
			     C	;***********************************************************************
 0193                        C	$P_MoveBP_NUL proc			;AN000;
 0193                        C	$P_MBP_Loop:				;AN000;
 0193  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN000; Increment BP that points
 0198  74 03                 C		je	$P_MBP_Exit		;AN000; to the synomym list
			     C	
 019A  45                    C		inc	bp			;AN000; until
 019B  EB F6                 C		jmp	short $P_MBP_Loop	;AN000; NULL encountered.
			     C	
 019D                        C	$P_MBP_Exit:				;AN000;
 019D  45                    C		inc	bp			;AN000; bp points to next to NULL
 019E  C3                    C		ret				;AN000;
 019F                        C	$P_MoveBP_NUL endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-24


			     C	ENDIF					;AN000;(of KeySW+SwSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-25


			     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	;***********************************************************************
 019F                        C	$P_Chk_SW_Control proc			;AN000;
			     C	
			     C	
			     C	IF	SwSW				;AN000;(Check if switch is supported)
 019F  80 0E 000E R 10       C		or	psdata_seg:$P_Flags2,$P_Sw_Cmp ;AC034; Indicate switch for later string comparison
 01A4  E8 016F R             C		call	$P_Search_KEYorSW	;AN000; Search the switch in the CONTROL block
 01A7  72 42                 C		jc	$P_Chk_SW_Err0		;AN000; not found, then try next CONTROL
			     C	
 01A9  80 26 000E R EF       C		and	psdata_seg:$P_Flags2,0ffh-$P_Sw_Cmp ;AC034; reset the indicator previously set
			     C	;
 01AE  50                    C		push	ax			;AN000; 	      /switch:
 01AF  A1 0011 R             C		mov	ax,psdata_seg:$P_KEYorSW_Ptr ;AC034;	      ^       ^
 01B2  2B C6                 C		sub	ax,si			;AN000;  SI	KEYorSW
 01B4  01 06 000F R          C		add	psdata_seg:$P_SaveSI_Cmpx,ax ;AC034; update for complex list
 01B8  58                    C		pop	ax			;AN000;
			     C	;
 01B9  8B 36 0011 R          C		mov	si,psdata_seg:$P_KEYorSW_Ptr ;AC034; set si at the end or colon
 01BD  80 3C 00              C		cmp	byte ptr psdata_seg:[si],$P_NULL ;AN000; any data after colon
 01C0  75 23                 C		jne	$P_CSW00		;AN000; if yes, process match flags
			     C	
 01C2  80 7C FF 3A           C		cmp	byte ptr psdata_seg:[si-1],$P_Colon ;AN000; if no, the switch terminated by colon ?
 01C6  75 08                 C		jne	$P_Chk_if_data_required ;AN000; if yes,
			     C	
 01C8  C7 06 0002 R 0009     C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034; return syntax error
 01CE  EB 1E                 C		jmp	short $P_Chk_SW_Exit	;AN000;
			     C	
 01D0                        C	$P_Chk_if_data_required:		;AN018; no data, no colon
 01D0  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
 01D4  74 18                 C		je	$P_Chk_SW_Exit		;AN018; match flags not zero so should have something if opt
				ional bit is not on
			     C	
 01D6  26: F7 07 0001        C		test	es:[bx].$P_Match_Flag,$P_Optional ;AN019; see if no value is valid
 01DB  75 11                 C		jnz	$P_Chk_SW_Exit		;AN019; if so, then leave, else yell
			     C	
 01DD  C7 06 0002 R 0002     C		mov	psdata_seg:$P_RC,$P_Op_Missing ;AC034; return required operand missing
 01E3  EB 09                 C		jmp	short $P_Chk_SW_Exit	;AN018;
			     C	
 01E5                        C	$P_CSW00:				;AN000;
 01E5  E8 027B R             C		call	$P_Check_Match_Flags	;AN000; process match flag
 01E8  F8                    C		clc				;AN000; indicate match
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-26


 01E9  EB 0D                 C		jmp	short $P_Chk_SW_Single_Exit ;AN000;
			     C	
 01EB                        C	$P_Chk_SW_Err0: 			;AN000;
 01EB  F9                    C		stc				;AN000; not found in switch synonym list
 01EC  EB 0A                 C		jmp	short $P_Chk_SW_Single_Exit ;AN000;
			     C	
 01EE                        C	$P_Chk_SW_Exit: 			;AN000;
 01EE  50                    C		push	ax			;AN000;
 01EF  B0 03                 C		mov	al,$P_String		;AN000; set
 01F1  B4 FF                 C		mov	ah,$P_No_Tag		;AN000;    result
 01F3  E8 01F9 R             C		call	$P_Fill_Result		;AN000; 	 buffer
 01F6  58                    C		pop	ax			;AN000;
 01F7  F8                    C		clc				;AN000;
 01F8                        C	$P_Chk_SW_Single_Exit:			;AN000;
 01F8  C3                    C		ret				;AN000;
			     C	ENDIF					;AN000;(of SwSW)
 01F9                        C	$P_Chk_SW_Control endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-27


			     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	;***********************************************************************
 01F9                        C	$P_Fill_Result proc			;AN000;
 01F9  57                    C		push	di			;AN000;
 01FA  26: 8B 7F 04          C		mov	di,es:[bx].$P_Result_Buf ;AN000; di points to result buffer
 01FE  89 3E 0006 R          C		mov	psdata_seg:$P_DX,di	;AC034; set returned result address
 0202  26: 88 05             C		mov	es:[di].$P_Type,al	;AN000; store type
 0205  26: 88 65 01          C		mov	es:[di].$P_Item_Tag,ah	;AN000; store item tag
 0209  50                    C		push	ax			;AN000;
 020A  A1 0015 R             C		mov	ax,psdata_seg:$P_Found_SYNONYM ;AC034; if yes,
 020D  26: 89 45 02          C		mov	es:[di].$P_SYNONYM_Ptr,ax ;AN000;   then set it to the result
 0211  58                    C		pop	ax			;AN000;
 0212                        C	$P_RLT04:				;AN000;
 0212  3C 01                 C		cmp	al,$P_Number		;AN000; if number
 0214  75 0A                 C		jne	$P_RLT00		;AN000;
			     C	
 0216                        C	$P_RLT02:				;AN000;
 0216  26: 89 55 04          C		mov	word ptr es:[di].$P_Picked_Val,dx ;AN000; then store 32bit
 021A  26: 89 4D 06          C		mov	word ptr es:[di+2].$P_Picked_Val,cx ;AN000;	number
 021E  EB 59                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 0220                        C	$P_RLT00:				;AN000;
 0220  3C 02                 C		cmp	al,$P_List_Idx		;AN000; if list index
 0222  75 06                 C		jne	$P_RLT01		;AN000;
			     C	
 0224  26: 89 55 04          C		mov	word ptr es:[di].$P_Picked_Val,dx ;AN000; then store list index
 0228  EB 4F                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 022A                        C	$P_RLT01:				;AN000;
 022A  3C 07                 C		cmp	al,$P_Date_F		;AN000; Date format ?
 022C  74 E8                 C		je	$P_RLT02		;AN000;
			     C	
 022E  3C 08                 C		cmp	al,$P_Time_F		;AN000; Time format ?
 0230  74 E4                 C		je	$P_RLT02		;AN000;
			     C	;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-28


 0232  3C 06                 C		cmp	al,$P_Drive		;AN000; drive format ?
 0234  75 06                 C		jne	$P_RLT03		;AN000;
			     C	
 0236  26: 88 55 04          C		mov	byte ptr es:[di].$P_Picked_Val,dl ;AN000; store drive number
 023A  EB 3D                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 023C                        C	$P_RLT03:				;AN000;
 023C  3C 04                 C		cmp	al,$P_Complex		;AN000; complex format ?
 023E  75 0E                 C		jne	$P_RLT05		;AN000;
			     C	
 0240  A1 000F R             C		mov	ax,psdata_seg:$P_SaveSI_Cmpx ;AC034; then get pointer in command buffer
 0243  40                    C		inc	ax			;AN000; skip left Parentheses
 0244  26: 89 45 04          C		mov	word ptr es:[di].$P_Picked_Val,ax ;AN000; store offset
 0248  26: 8C 5D 06          C		mov	word ptr es:[di+2].$P_Picked_Val,ds ;AN000; store segment
 024C  EB 2B                 C		jmp	short $P_RLT_Exit	;AN000;
			     C	
 024E                        C	$P_RLT05:				;AN000;
			     C	;------------------------  AL = 3, 5, or 9
 024E  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
 0252  26: 8C 5D 06          C		mov	word ptr es:[di+2].$P_Picked_Val,Psdata_Seg ;AN031; store segment of STRING_BUF
			     C	;
 0256  50                    C		push	ax			;AN000;
 0257  26: F6 47 02 01       C		test	byte ptr es:[bx].$P_Function_Flag,$P_CAP_File ;AN000; need CAPS by file table?
 025C  74 04                 C		je	$P_RLT_CAP00		;AN000;
			     C	
 025E  B0 04                 C		mov	al,$P_DOSTBL_File	;AN000; use file upper case table
 0260  EB 09                 C		jmp	short $P_RLT_CAP02	;AN000;
			     C	
 0262                        C	$P_RLT_CAP00:				;AN000;
 0262  26: F6 47 02 02       C		test	byte ptr es:[bx].$P_Function_Flag,$P_CAP_Char ;AN000; need CAPS by char table ?
 0267  74 05                 C		je	$P_RLT_CAP01		;AN000;
			     C	
 0269  B0 02                 C		mov	al,$P_DOSTBL_Char	;AN000; use character upper case table
 026B                        C	$P_RLT_CAP02:				;AN000;
 026B  E8 032D R             C		call	$P_Do_CAPS_String	;AN000;  process CAPS along the table
 026E                        C	$P_RLT_CAP01:				;AN000;
 026E  58                    C		pop	ax			;AN000;
 026F  26: F6 47 02 10       C		test	byte ptr es:[bx].$P_Function_Flag,$P_Rm_Colon ;AN000; removing colon at end ?
 0274  74 03                 C		je	$P_RLT_Exit		;AN000;
			     C	
 0276  E8 030A R             C		call	$P_Remove_Colon 	;AN000; then process it.
 0279                        C	$P_RLT_Exit:				;AN000;
 0279  5F                    C		pop	di			;AN000;
 027A  C3                    C		ret				;AN000;
 027B                        C	$P_Fill_Result endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-29


			     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	;***********************************************************************
 027B                        C	$P_Check_Match_Flags proc		;AN000;
 027B  C6 06 00D5 R 00       C		mov	psdata_seg:$P_err_flag,$P_NULL ;AN033;AC034;; clear filespec error flag.
 0280  50                    C		push	ax			;AN000;
 0281  26: 8B 07             C		mov	ax,es:[bx].$P_Match_Flag ;AN000; load match flag(16bit) to ax
			     C	
 0284  0B C0                 C		or	ax,ax			;AC035; test ax for zero
			     C	;(changed ;AC035;)  cmp     ax,0	;AN000; (tm12)
 0286  75 17                 C		jne	$P_Mat			;AN000; (tm12)
			     C	
 0288  50                    C		push	ax			;AN000; (tm12)
 0289  53                    C		push	bx			;AN000; (tm12)
 028A  52                    C		push	dx			;AN000; (tm12)
 028B  57                    C		push	di			;AN000; (tm12)
 028C  C7 06 0002 R 0009     C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034; (tm12)
 0292  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; (tm12)
 0294  B0 03                 C		mov	al,$P_String		;AN000; (tm12)
 0296  E8 01F9 R             C		call	$P_Fill_Result		;AN000; (tm12)
 0299  5F                    C		pop	di			;AN000; (tm12)
 029A  5A                    C		pop	dx			;AN000; (tm12)
 029B  5B                    C		pop	bx			;AN000; (tm12)
 029C  58                    C		pop	ax			;AN000; (tm12)
 029D  EB 17                 C		jmp	short $P_Bridge 	;AC035; (tm12)
			     C	
 029F                        C	$P_Mat: 				;AN000; (tm12)
			     C	
			     C	IF	DateSW				;AN000;(Check if date format is supported)
 029F  A9 1000               C		test	ax,$P_Date_S		;AN000; Date string
 02A2  74 10                 C		je	$P_Match02		;AN000;
			     C	
 02A4  C7 06 0002 R 0000     C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 02AA  E8 0465 R             C		call	$P_Date_Format		;AN000; do process
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-30


 02AD  83 3E 0002 R 09       C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examine the next type
 02B2  75 02                 C		jne	$P_Bridge		;AN000;
			     C	
 02B4                        C	$P_Match02:				;AN000;
			     C	ENDIF					;AN000;(of DateSW)
 02B4  EB 03                 C		jmp	short $P_Match03	;AN025; (tm09)
			     C	
 02B6                        C	$P_Bridge:				;AN000;
			     C	;	jmp	short $P_Match_Exit (tm02)
			     C	
 02B6  EB 3C 90              C		jmp	$P_Match_Exit		;AN000; (tm02)
			     C	
 02B9                        C	$P_Match03:				;AN000;
			     C	; ENDIF ;AN000;(of TimeSW) (tm04)
			     C	IF	DrvSW				;AN000;(Check if drive only is supported)
 02B9  A9 0100               C		test	ax,$P_Drv_Only		;AN000; Drive only
 02BC  74 13                 C		je	$P_Match06		;AN000;
			     C	
 02BE  C7 06 0002 R 0000     C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 02C4  E8 0579 R             C		call	$P_File_Format		;AN000; 1st, call file format
 02C7  E8 05F4 R             C		call	$P_Drive_Format 	;AN000; check drive format, next
 02CA  83 3E 0002 R 09       C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examinee the next type
 02CF  75 23                 C		jne	$P_Match_Exit		;AN000;
			     C	
 02D1                        C	$P_Match06:				;AN000;
			     C	ENDIF					;AN000;(of DrvSW)
			     C	IF	FileSW				;AN000;(Check if file spec is supported)
 02D1  A9 0200               C		test	ax,$P_File_Spc		;AN000; File spec
 02D4  74 10                 C		je	$P_Match07		;AN000;
			     C	
 02D6  C7 06 0002 R 0000     C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 02DC  E8 0579 R             C		call	$P_File_Format		;AN000; do process
 02DF  83 3E 0002 R 09       C		cmp	psdata_seg:$P_RC,$P_Syntax ;AC034; if error, examine the next type
 02E4  75 0E                 C		jne	$P_Match_Exit		;AN000;
			     C	
 02E6                        C	$P_Match07:				;AN000;
			     C	ENDIF					;AN000;(of FileSW)
 02E6  A9 2000               C		test	ax,$P_Simple_S		;AN000; Simple string
 02E9  74 09                 C		je	$P_Match09		;AN000;
			     C	
 02EB  C7 06 0002 R 0000     C		mov	psdata_seg:$P_RC,$P_No_Error ;AC034; assume no error
 02F1  E8 03A3 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.
 02F4                        C	$P_Match09:				;AN000;
 02F4                        C	$P_Match_Exit:				;AN000;
 02F4  80 3E 00D5 R 01       C		cmp	psdata_seg:$P_err_flag,$P_error_filespec ;AC034; bad filespec ?
 02F9  75 0D                 C		jne	$P_Match2_Exit		;AN033; no, continue
 02FB  83 3E 0002 R 00       C		cmp	psdata_seg:$P_RC,$P_No_Error ;AN033;AC034;; check for other errors ?
 0300  75 06                 C		jne	$P_Match2_Exit		;AN033; no, continue
 0302  C7 06 0002 R 0009     C		mov	psdata_seg:$P_RC,$P_Syntax ;AN033;AC034;; set error flag
 0308                        C	$P_Match2_Exit: 			;AN033;
 0308  58                    C		pop	ax			;AN000;
 0309  C3                    C		ret				;AN000;
 030A                        C	$P_Check_Match_Flags endp		;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-31


			     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	;***********************************************************************
 030A                        C	$P_Remove_Colon proc			;AN000;
 030A  50                    C		push	ax			;AN000;
 030B  56                    C		push	si			;AN000;
 030C                        C	$P_RCOL_Loop:				;AN000;
 030C  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; get character
 030E  0A C0                 C		or	al,al			;AN000; end of string ?
 0310  74 18                 C		je	$P_RCOL_Exit		;AN000; if yes, just exit
			     C	
 0312  3C 3A                 C		cmp	al,$P_Colon		;AN000; is it colon ?
 0314  75 0B                 C		jne	$P_RCOL00		;AN000;
			     C	
 0316  80 7C 01 00           C		cmp	byte ptr psdata_seg:[si+byte],$P_NULL ;AN000; if so, next is NULL ?
 031A  75 05                 C		jne	$P_RCOL00		;AN000; no, then next char
			     C	
 031C  C6 04 00              C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN000; yes, remove colon
 031F  EB 09                 C		jmp	short $P_RCOL_Exit	;AN000; and exit.
			     C	
 0321                        C	$P_RCOL00:				;AN000;
 0321  E8 0716 R             C		call	$P_Chk_DBCS		;AN000; if not colon, then check if
 0324  73 01                 C		jnc	$P_RCOL01		;AN000; DBCS leading byte.
			     C	
 0326  46                    C		inc	si			;AN000; if yes, skip trailing byte
 0327                        C	$P_RCOL01:				;AN000;
 0327  46                    C		inc	si			;AN000; si points to next byte
 0328  EB E2                 C		jmp	short $P_RCOL_Loop	;AN000; loop until NULL encountered
			     C	
 032A                        C	$P_RCOL_Exit:				;AN000;
 032A  5E                    C		pop	si			;AN000;
 032B  58                    C		pop	ax			;AN000;
 032C  C3                    C		ret				;AN000;
 032D                        C	$P_Remove_Colon endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-32


			     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	;***********************************************************************
 032D                        C	$P_Do_CAPS_String proc			;AN000;
 032D  56                    C		push	si			;AN000;
 032E  52                    C		push	dx			;AN000;
 032F  8A D0                 C		mov	dl,al			;AN000; save info id
			     C	
 0331                        C	$P_DCS_Loop:				;AN000;
 0331  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; load charater and
 0333  E8 0716 R             C		call	$P_Chk_DBCS		;AN000; check if DBCS leading byte
 0336  72 0B                 C		jc	$P_DCS00		;AN000; if yes, do not need CAPS
			     C	
 0338  0A C0                 C		or	al,al			;AN000; end of string ?
 033A  74 0B                 C		je	$P_DCS_Exit		;AN000; then exit.
			     C	
 033C  E8 034A R             C		call	$P_Do_CAPS_Char 	;AN000; Here a SBCS char need to be CAPS
 033F  88 04                 C		mov	psdata_seg:[si],al	;AN000; stored upper case char to buffer
 0341  EB 01                 C		jmp	short $P_DCS01		;AN000; process nexit
 0343                        C	$P_DCS00:				;AN000;
 0343  46                    C		inc	si			;AN000; skip DBCS leading and trailing byte
 0344                        C	$P_DCS01:				;AN000;
 0344  46                    C		inc	si			;AN000; si point to next byte
 0345  EB EA                 C		jmp	short $P_DCS_Loop	;AN000; loop until NULL encountered
 0347                        C	$P_DCS_Exit:				;AN000;
 0347  5A                    C		pop	dx			;AN000;
 0348  5E                    C		pop	si			;AN000;
 0349  C3                    C		ret				;AN000;
 034A                        C	$P_Do_CAPS_String endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-33


			     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	;***********************************************************************
 034A                        C	$P_Do_CAPS_Char proc			;AN000;
 034A  3C 80                 C		cmp	al,$P_ASCII80		;AN000; need upper case table ?
 034C  73 0C                 C		jae	$P_DCC_Go		;AN000;
			     C	
 034E  3C 61                 C		cmp	al,"a"                  ;AN000; if no,
 0350  72 42                 C		jb	$P_CAPS_Ret		;AN000;   check if  "a" <= AL <= "z"
			     C	
 0352  3C 7A                 C		cmp	al,"z"                  ;AN000;
 0354  77 3E                 C		ja	$P_CAPS_Ret		;AN000;   if yes, make CAPS
			     C	
 0356  24 DF                 C		and	al,$P_Make_Upper	;AN000;   else do nothing.
 0358  EB 3A                 C		jmp	short $P_CAPS_Ret	;AN000;
			     C	
 035A                        C	$P_DCC_Go:				;AN000;
 035A  53                    C		push	bx			;AN000;
 035B  06                    C		push	es			;AN000;
 035C  57                    C		push	di			;AN000;
			     C	IF	CAPSW				;AN000;(Check if uppercase conversion is supported)
 035D  8D 3E 00C7 R          C		lea	di,psdata_seg:$P_File_CAP_Ptr ;AC034;
 0361  80 FA 04              C		cmp	dl,$P_DOSTBL_File	;AN000; Use file CAPS table ?
 0364  74 04                 C		je	$P_DCC00		;AN000;
			     C	
			     C	ENDIF					;AN000;(of CAPSW)
 0366  8D 3E 00C2 R          C		lea	di,psdata_seg:$P_Char_CAP_Ptr ;AC034; or use char CAPS table ?
 036A                        C	$P_DCC00:				;AN000;
 036A  38 15                 C		cmp	psdata_seg:[di],dl	;AN000; already got table address ?
 036C  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	IFDEF BASESW				;AN037; If BASESW has been defined, and
			     C	ENDIF					;AN037;
			     C	
 036E  50                    C		push	ax			;AN000; get CAPS table thru DOS call
 036F  51                    C		push	cx			;AN000;
 0370  52                    C		push	dx			;AN000;
			     C	
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-34


 0371  1E                    C		push	PSDATA_SEG		;AC036; pass current base seg into
			     C						;(Note: this used to push CS.  BUG...
 0372  07                    C		pop	es			;AN000;   ES reg, required for
			     C						;get extended country information
 0373  B4 65                 C		mov	ah,$P_DOS_Get_TBL	;AN000; get extended CDI
 0375  8A C2                 C		mov	al,dl			;AN000; upper case table
 0377  BB FFFF               C		mov	bx,$P_DOSTBL_Def	;AN000; get active CON
 037A  B9 0005               C		mov	cx,$P_DOSTBL_BL 	;AN000; buffer length
 037D  BA FFFF               C		mov	dx,$P_DOSTBL_Def	;AN000; get for default code page
			     C						;DI already set to point to buffer
 0380  CD 21                 C		int	21h			;AN000; es:di point to buffer that
			     C						;now has been filled in with info
 0382  5A                    C		pop	dx			;AN000;
 0383  59                    C		pop	cx			;AN000;
 0384  58                    C		pop	ax			;AN000;
			     C	IFDEF BASESW				;AN037; If BASESW has been defined, and
			     C	ENDIF					;AN037;
 0385                        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	
			     C	IFDEF BASESW				;AN037; If BASESW has been defined, and
			     C	ENDIF					;AN037;
 0385  8B 5D 01              C		mov	bx,psdata_seg:[di+$P_DOS_TBL_Off] ;AN000; get offset of table
 0388  8E 45 03              C		mov	es,psdata_seg:[di+$P_DOS_TBL_Seg] ;AN000; get segment of table
 038B  43                    C		inc	bx			;AC035; add '2' to
 038C  43                    C		inc	bx			;AC035;  BX reg
			     C						;AN000; skip length field
			     C	;(changed ;AN035;) add	   bx,word	;AN000; skip length field
 038D  2C 80                 C		sub	al,$P_ASCII80		;AN000; make char to index
 038F  26: D7                C		xlat	es:[bx] 		;AN000; perform case map
			     C	
			     C	IFDEF BASESW				;AN037; If BASESW has been defined, and
			     C	ENDIF					;AN037;
 0391  5F                    C		pop	di			;AN000;
 0392  07                    C		pop	es			;AN000;
 0393  5B                    C		pop	bx			;AN000;
 0394                        C	$P_CAPS_Ret:				;AN000;
 0394  C3                    C		ret				;AN000;
 0395                        C	$P_Do_CAPS_Char endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-35


			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     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	;***********************************************************************
 0395                        C	$P_0099 proc				;AN000;
 0395  3C 30                 C		cmp	al,"0"                  ;AN000;
 0397  72 08                 C		jb	$P_0099Err		;AN000;  must be 0 =< al =< 9
			     C	
 0399  3C 39                 C		cmp	al,"9"                  ;AN000;
 039B  77 04                 C		ja	$P_0099Err		;AN000;  must be 0 =< al =< 9
			     C	
 039D  2C 30                 C		sub	al,"0"                  ;AN000; make char -> bin
 039F  F8                    C		clc				;AN000; indicate no error
 03A0  C3                    C		ret				;AN000;
			     C	
 03A1                        C	$P_0099Err:				;AN000;
 03A1  F9                    C		stc				;AN000; indicate error
 03A2  C3                    C		ret				;AN000;
 03A3                        C	$P_0099 endp				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-36


			     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	;***********************************************************************
 03A3                        C	$P_Simple_String proc			;AN000;
 03A3  50                    C		push	ax			;AN000;
 03A4  53                    C		push	bx			;AN000;
 03A5  52                    C		push	dx			;AN000;
 03A6  57                    C		push	di			;AN000;
 03A7  26: 8B 7F 06          C		mov	di,es:[bx].$P_Value_List ;AN000; di points to value list
 03AB  26: 8A 05             C		mov	al,es:[di]		;AN000; get nval
 03AE  0A C0                 C		or	al,al			;AN000; no value list ?
 03B0  75 04                 C		jne	$P_Sim00		;AN000; then
			     C	
 03B2  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; No ITEM_TAG set
 03B4  EB 08                 C		jmp	short $P_Sim_Exit	;AN000; and set result buffer
			     C	
 03B6                        C	$P_Sim00:				;AN000;
 03B6                        C	$P_Sim01:				;AN000;
 03B6  C7 06 0002 R 0009     C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034;
 03BC  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; No ITEM_TAG set
 03BE                        C	$P_Sim_Exit:				;AN000;
 03BE  B0 03                 C		mov	al,$P_String		;AN000; Set type
 03C0                        C	$P_Sim_Exit0:				;AN000;
 03C0  E8 01F9 R             C		call	$P_Fill_Result		;AN000;
 03C3  5F                    C		pop	di			;AN000;
 03C4  5A                    C		pop	dx			;AN000;
 03C5  5B                    C		pop	bx			;AN000;
 03C6  58                    C		pop	ax			;AN000;
 03C7  C3                    C		ret				;AN000;
 03C8                        C	$P_Simple_String endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-37


			     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	;***********************************************************************
 03C8                        C	$P_String_Comp proc			;AN000;
 03C8  50                    C		push	ax			;AN000;
 03C9  55                    C		push	bp			;AN000;
 03CA  52                    C		push	dx			;AN000;
 03CB  56                    C		push	si			;AN000;
 03CC  B2 02                 C		mov	dl,$P_DOSTBL_Char	;AN000; use character case map table
 03CE                        C	$P_SCOM_Loop:				;AN000;
 03CE  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; get command character
 03D0  E8 0716 R             C		call	$P_Chk_DBCS		;AN000; DBCS ?
 03D3  72 3A                 C		jc	$P_SCOM00		;AN000; yes,DBCS
			     C	
 03D5  E8 034A 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)
 03D8  F6 06 000E R 08       C		test	psdata_seg:$P_Flags2,$P_Key_Cmp ;AC034; keyword search ?
 03DD  74 0D                 C		je	$P_SCOM04		;AN000;
			     C	
 03DF  3C 3D                 C		cmp	al,$P_Keyword		;AN000; "=" is delimiter
 03E1  75 1E                 C		jne	$P_SCOM03		;AN000;IF "=" on command line AND  (bp+1=> char after the "=
				" in synonym list)
			     C	
 03E3  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
 03E8  75 6E                 C		jne	$P_SCOM_DIFFER		;AN021;
			     C	
 03EA  EB 12                 C		jmp	short $P_SCOM05 	;AN000;   keyword found in synonym list
			     C	
 03EC                        C	$P_SCOM04:				;AN000;
 03EC  F6 06 000E R 10       C		test	psdata_seg:$P_Flags2,$P_SW_Cmp ;AC034; switch search ?
 03F1  74 0E                 C		je	$P_SCOM03		;AN000;
			     C	
 03F3  3C 3A                 C		cmp	al,$P_Colon		;AN000; ":" is delimiter, at end of switch on command line
 03F5  75 0A                 C		jne	$P_SCOM03		;AN000; continue compares
			     C	
 03F7  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN021; IF at end of switch on command AND
 03FC  75 5A                 C		jne	$P_SCOM_DIFFER		;AN021;   at end of switch string in the control block THEN
			     C	
 03FE                        C	$P_SCOM05:				;AN000;   found a match
 03FE  46                    C		inc	si			;AN000; si points to just after "=" or ":"
 03FF  EB 5A                 C		jmp	short $P_SCOM_Same	;AN000; exit
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-38


 0401                        C	$P_SCOM03:				;AN000;
			     C	ENDIF					;AN000;(of KeySW+SwSW)
 0401  26: 3A 46 00          C		cmp	al,es:[bp]		;AN000; compare operand w/ a synonym
 0405  75 1C                 C		jne	$P_SCOM_Differ0 	;AN000; if different, check ignore colon option
			     C	
 0407  0A C0                 C		or	al,al			;AN000; end of line
 0409  74 50                 C		je	$P_SCOM_Same		;AN000; if so, exit
			     C	
 040B  46                    C		inc	si			;AN000; update operand pointer
 040C  45                    C		inc	bp			;AN000; 	   and synonym pointer
 040D  EB 12                 C		jmp	short $P_SCOM01 	;AN000; loop until NULL or "=" or ":" found in case
			     C	
 040F                        C	$P_SCOM00:				;AN000; Here al is DBCS leading byte
 040F  26: 3A 46 00          C		cmp	al,es:[bp]		;AN000; compare leading byte
 0413  75 43                 C		jne	$P_SCOM_Differ		;AN000; if not match, say different
			     C	
 0415  46                    C		inc	si			;AN000; else, load next byte
 0416  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; and
 0418  45                    C		inc	bp			;AN000;
 0419  26: 3A 46 00          C		cmp	al,es:[bp]		;AN000; compare 2nd byte
 041D  75 39                 C		jne	$P_SCOM_Differ		;AN000; if not match, say different, too
			     C	
 041F  46                    C		inc	si			;AN000; else update operand pointer
 0420  45                    C		inc	bp			;AN000; 		and synonym pointer
 0421                        C	$P_SCOM01:				;AN000;
 0421  EB AB                 C		jmp	short $P_SCOM_Loop	;AN000; loop until NULL or "=" or "/" found in case
			     C	
 0423                        C	$P_SCOM_Differ0:			;AN000;
			     C	
			     C	IF	SwSW				;AN000;(tm10)
 0423  F6 06 000E R 40       C		test	psdata_seg:$P_Flags2,$P_SW ;AC034;(tm10)
 0428  74 0F                 C		je	$P_not_applicable	;AN000;(tm10)
			     C	
 042A  26: F7 47 02 0020     C		test	es:[bx].$P_Function_Flag,$P_colon_is_not_necessary ;AN000;(tm10)
 0430  74 07                 C		je	$P_not_applicable	;AN000;(tm10)
			     C	
 0432  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN000;(tm10)
			     C	;(deleted ;AN025;) jne $P_not_applicable ;AN000;(tm10)
 0437  74 22                 C		je	$P_SCOM_Same		;AN025;(tm10)
			     C	
 0439                        C	$P_not_applicable:			;AN000;(tm10)
			     C	ENDIF					;AN000;(tm10)
			     C	
 0439  26: F7 07 0010        C		test	es:[bx].$P_Match_Flag,$P_Ig_Colon ;AN000; ignore colon option specified ?
 043E  74 18                 C		je	$P_SCOM_Differ		;AN000; if no, say different.
			     C	
 0440  3C 3A                 C		cmp	al,$P_Colon		;AN000; End up with ":" and
 0442  75 09                 C		jne	$P_SCOM02		;AN000;    subseqently
			     C	
 0444  26: 80 7E 00 00       C		cmp	byte ptr es:[bp],$P_NULL ;AN000;       NULL ?
 0449  75 0D                 C		jne	$P_SCOM_Differ		;AN000; if no, say different
			     C	
 044B  EB 0E                 C		jmp	short $p_SCOM_Same	;AN000; else, say same
			     C	
 044D                        C	$P_SCOM02:				;AN000;
 044D  3C 00                 C		cmp	al,$P_NULL		;AN000; end up NULL and :
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-39


 044F  75 07                 C		jne	$P_SCOM_Differ		;AN000;
			     C	
 0451  26: 80 7E 00 3A       C		cmp	byte ptr es:[bp],$P_Colon ;AN000; if no, say different
 0456  74 03                 C		je	$p_SCOM_Same		;AN000; else, say same
			     C	
 0458                        C	$P_SCOM_Differ: 			;AN000;
 0458  F9                    C		stc				;AN000; indicate not found
 0459  EB 05                 C		jmp	short $P_SCOM_Exit	;AN000;
			     C	
 045B                        C	$P_SCOM_Same:				;AN000;
 045B  89 36 0011 R          C		mov	psdata_seg:$P_KEYorSW_Ptr,si ;AC034; for later use by keyword or switch
 045F  F8                    C		clc				;AN000; indicate found
 0460                        C	$P_SCOM_Exit:				;AN000;
 0460  5E                    C		pop	si			;AN000;
 0461  5A                    C		pop	dx			;AN000;
 0462  5D                    C		pop	bp			;AN000;
 0463  58                    C		pop	ax			;AN000;
 0464  C3                    C		ret				;AN000;
 0465                        C	$P_String_Comp endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-40


			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	DateSW				;AN000;(Check if date format is supported)
			     C	; $P_Date_Format
			     C	;
			     C	; Function:  Convert a date string to DOS date format for int 21h
			     C	;	     with format validation.
			     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_Set_CDI, $P_Get_DecNum
			     C	;
			     C	; Vars: $P_RC(W), $P_1st_Val(RW), $P_2nd_Val(RW), $P_3rd_Val(RW)
			     C	;***********************************************************************
 0465                        C	$P_Date_Format proc			;AN000;
 0465  50                    C		push	ax			;AN000;
 0466  51                    C		push	cx			;AN000;
 0467  52                    C		push	dx			;AN000;
 0468  56                    C		push	si			;AN000;
 0469  53                    C		push	bx			;AN000;
 046A  56                    C		push	si			;AN000;
 046B  E8 050A R             C		call	$P_Set_CDI		;AN000; set country dependent information before process
			     C	;	mov	bl,psdata_seg:[si].$P_CDI_DateS ;load date separator ;AN020; (deleted)
			     C	;					note: the country info is still needed
			     C	;					to determine the order of the fields,
			     C	;					but the separator char is no longer used.
 046E  5E                    C		pop	si			;AN000;
 046F  C7 06 00BA R 0000     C		mov	psdata_seg:$P_1st_Val,0 ;AC034; set initial value
 0475  C7 06 00BC R 0000     C		mov	psdata_seg:$P_2nd_Val,0 ;AC034; set initial value
 047B  C7 06 00BE R 0000     C		mov	psdata_seg:$P_3rd_Val,0 ;AC034; set initial value
 0481  E8 0525 R             C		call	$P_Get_DecNum		;AN000; get 1st number
 0484  72 16                 C		jc	$P_DateF_Err0		;AN000;-----------------------+
			     C	
 0486  A3 00BA R             C		mov	psdata_seg:$P_1st_Val,ax ;AC034;	      |
 0489  0A DB                 C		or	bl,bl			;AN000; end of line ?	      |
 048B  74 18                 C		je	$P_DateF_YMD		;AN000; 		      |
			     C	
 048D  E8 0525 R             C		call	$P_Get_DecNum		;AN000; get 2nd number	      |
 0490  72 65                 C		jc	$P_DateF_Error		;AN000; 		      |
			     C	
 0492  A3 00BC R             C		mov	psdata_seg:$P_2nd_Val,ax ;AC034;	      |
 0495  0A DB                 C		or	bl,bl			;AN000; end of line ?	      |
 0497  74 0C                 C		je	$P_DateF_YMD		;AN000; 		      |
			     C	
 0499  E8 0525 R             C		call	$P_Get_DecNum		;AN000; get 3rd number	      |
 049C                        C	$P_DateF_Err0:				;AN000; Bridge	  <-----------+
 049C  72 59                 C		jc	$P_DateF_Error		;AN000;
			     C	
 049E  A3 00BE R             C		mov	psdata_seg:$P_3rd_Val,ax ;AC034;
 04A1  0A DB                 C		or	bl,bl			;AN000; end of line ?
 04A3  75 52                 C		jne	$P_DateF_Error		;AN000;
			     C	
 04A5                        C	$P_DateF_YMD:				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-41


 04A5  8B 1E 0098 R          C		mov	bx,psdata_seg:$P_Country_Info.$P_CDI_DateF ;AC034; get date format
 04A9  83 FB 02              C		cmp	bx,$P_Date_YMD		;AN000;
 04AC  74 1F                 C		je	$P_DateF00		;AN000;
			     C	
 04AE  A1 00BA R             C		mov	ax,psdata_seg:$P_1st_Val ;AC034;
 04B1  0A E4                 C		or	ah,ah			;AN000;
 04B3  75 42                 C		jne	$P_DateF_Error		;AN000;
			     C	
 04B5  8A C8                 C		mov	cl,al			;AN000; set month
 04B7  A1 00BC R             C		mov	ax,psdata_seg:$P_2nd_Val ;AC034;
 04BA  0A E4                 C		or	ah,ah			;AN000; if overflow, error.
 04BC  75 39                 C		jne	$P_DateF_Error		;AN000;
			     C	
 04BE  8A E8                 C		mov	ch,al			;AN000; set date
 04C0  8B 16 00BE R          C		mov	dx,psdata_seg:$P_3rd_Val ;AC034; set year
 04C4  83 FB 01              C		cmp	bx,$P_Date_DMY		;AN000; from here format = MDY
 04C7  75 02                 C		jne	$P_DateF01		;AN000; if it is DMY
			     C	
 04C9  86 E9                 C		xchg	ch,cl			;AN000;  then swap M <-> D
 04CB                        C	$P_DateF01:				;AN000;
 04CB  EB 16                 C		jmp	short $P_DateF02	;AN000;
			     C	
 04CD                        C	$P_DateF00:				;AN000; / here format = YMD
 04CD  8B 16 00BA R          C		mov	dx,psdata_seg:$P_1st_Val ;AC034; set year
 04D1  A1 00BC R             C		mov	ax,psdata_seg:$P_2nd_Val ;AC034;
 04D4  0A E4                 C		or	ah,ah			;AN000; if overflow, error
 04D6  75 1F                 C		jne	$P_DateF_Error		;AN000;
			     C	
 04D8  8A C8                 C		mov	cl,al			;AN000; set month
 04DA  A1 00BE R             C		mov	ax,psdata_seg:$P_3rd_Val ;AC034;
 04DD  0A E4                 C		or	ah,ah			;AN000; if overflow, error
 04DF  75 16                 C		jne	$P_DateF_Error		;AN000;
			     C	
 04E1  8A E8                 C		mov	ch,al			;AN000; set date
 04E3                        C	$P_DateF02:				;AN000;
 04E3  83 FA 64              C		cmp	dx,100			;AN000; year is less that 100 ?
 04E6  73 04                 C		jae	$P_DateF03		;AN000;
			     C	
 04E8  81 C2 076C            C		add	dx,1900 		;AN000; set year 19xx
 04EC                        C	$P_DateF03:				;AN000;
 04EC  5B                    C		pop	bx			;AN000; recover CONTROL block
 04ED  5E                    C		pop	si			;AN000; recover string pointer
 04EE  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; set
 04F0  B0 07                 C		mov	al,$P_Date_F		;AN000;     result
 04F2  E8 01F9 R             C		call	$P_Fill_Result		;AN000; 	   buffer
 04F5  EB 0F                 C		jmp	short $P_Date_Format_Exit ;AN000;	to Date
			     C	
 04F7                        C	$P_DateF_Error: 			;AN000;
 04F7  5B                    C		pop	bx			;AN000; recover CONTROL block
 04F8  5E                    C		pop	si			;AN000; recover string pointer
 04F9  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; set
 04FB  B0 03                 C		mov	al,$P_String		;AN000;     result
 04FD  E8 01F9 R             C		call	$P_Fill_Result		;AN000; 	   buffer  to string
 0500  C7 06 0002 R 0009     C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034; indicate syntax error
 0506                        C	$P_Date_Format_Exit:			;AN000;
 0506  5A                    C		pop	dx			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-42


 0507  59                    C		pop	cx			;AN000;
 0508  58                    C		pop	ax			;AN000;
 0509  C3                    C		ret				;AN000;
 050A                        C	$P_Date_Format endp			;AN000;
			     C	ENDIF					;AN000;(of DateSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-43


			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	IF	TimeSW+DateSW			;AN000;(Check if time or date format is supported)
			     C	; $P_Set_CDI:
			     C	;
			     C	; Function: Read CDI from DOS if it has not been read yet
			     C	;
			     C	; Input:    None
			     C	;
			     C	; Output:   psdata_seg:SI -> CDI
			     C	;
			     C	; Use:	INT 21h w/ AH = 38h
			     C	;***********************************************************************
 050A                        C	$P_Set_CDI proc 			;AN000;
 050A  8D 36 0098 R          C		lea	si,psdata_seg:$P_Country_Info ;AC034;
 050E  83 3C FF              C		cmp	psdata_seg:[si].$P_CDI_DateF,$P_NeedToBeRead ;AN000; already read ?
 0511  74 02                 C		je	$P_Read_CDI		;AN000;
			     C	
 0513  EB 0F                 C		jmp	short $P_Set_CDI_Exit	;AN000; then do nothing
			     C	
 0515                        C	$P_Read_CDI:				;AN000; else read CDI thru DOS
 0515  1E                    C		push	ds			;AN000;
 0516  52                    C		push	dx			;AN000;
 0517  50                    C		push	ax			;AN000;
 0518  1E                    C		push	PSDATA_SEG		;AC023;
 0519  1F                    C		pop	ds			;AN000; set segment register
 051A  B8 3800               C		mov	ax,$P_DOS_Get_CDI	;AN000; get country information
 051D  8B D6                 C		mov	dx,si			;AN000; set offset of CDI in local data area
 051F  CD 21                 C		int	21h			;AN000;
 0521  58                    C		pop	ax			;AN000;
 0522  5A                    C		pop	dx			;AN000;
 0523  1F                    C		pop	ds			;AN000;
 0524                        C	$P_Set_CDI_Exit:			;AN000;
 0524  C3                    C		ret				;AN000;
 0525                        C	$P_Set_CDI endp 			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-44


			     C	PAGE					;AN000;
			     C	;***********************************************************************
			     C	; $P_Get_DecNum:
			     C	;
			     C	; Function:  Read a chcrater code from psdata_seg:SI until specified delimiter
			     C	;	     or NULL encountered. And make a decimal number.
			     C	;
			     C	; Input:     psdata_seg:SI -> $P_STRING_BUF
			     C	;
			     C	; Output:    BL = delimiter code or NULL
			     C	;	     AX = Decimal number
			     C	;	     SI advanced to the next number
			     C	;	     CY = 1 : Syntax error, AL = Latest examineed number
			     C	;
			     C	; Use:	$P_0099
			     C	;***********************************************************************
 0525                        C	$P_Get_DecNum proc			;AN000;
 0525  51                    C		push	cx			;AN000;
 0526  52                    C		push	dx			;AN000;
 0527  33 C9                 C		xor	cx,cx			;AN000; cx will have final value
 0529                        C	$P_GetNum_Loop: 			;AN000;
 0529  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; load character
 052B  0A C0                 C		or	al,al			;AN000; end of line ?
 052D  74 3B                 C		je	$P_GetNum00		;AN000; if yes, exit
			     C	
 052F  80 3E 0097 R 00       C		cmp	psdata_seg:$P_Got_Time,0 ;AC034; ;is this numeric in a time field?    ;AC023
 0534  74 0F                 C		je	$P_Do_Date_Delims	;AN000;no, go check out Date delimiters  ;AC023
			     C	
			     C	; Determine which delimiter(s) to check for.  Colon & period  or period only
 0536  80 FB 01              C		cmp	bl,$P_colon_period	;AN032; ;Time
 0539  75 04                 C		jne	$P_Do_Time_Delim1	;AN032; ;only check for period
			     C	
 053B  3C 3A                 C		cmp	al,$P_Colon		;AN032; ;Is this a valid delimiter ?
 053D  74 30                 C		je	$P_GetNum01		;AN032; ;yes, exit
			     C	
 053F                        C	$P_Do_Time_Delim1:			;AN000;
 053F  3C 2E                 C		cmp	al,$P_Period		;;AC032;;AC023;Is this a valid delimiter ?
 0541  74 2C                 C		je	$P_GetNum01		;AC023; yes, exit
			     C	
 0543  EB 0C                 C		jmp	short $P_Neither_Delims ;AN023;
			     C	
 0545                        C	$P_Do_Date_Delims:			;AN000;
			     C	;Regardless of the date delimiter character specified in the country
			     C	;dependent information, check for the presence of any one of these
			     C	;three field delimiters: "-", "/", or ".".
 0545  3C 2D                 C		cmp	al,$P_Minus		;AN020;is this a date delimiter character?
 0547  74 26                 C		je	$P_GetNum01		;AN020;if yes, exit
			     C	
 0549  3C 2F                 C		cmp	al,$P_Slash		;AN020;is this a date delimiter character?
 054B  74 22                 C		je	$P_GetNum01		;AN020;if yes, exit
			     C	
 054D  3C 2E                 C		cmp	al,$P_Period		;AN020;is this a date delimiter character?
 054F  74 1E                 C		je	$P_GetNum01		;AN000; if yes, exit
			     C	
 0551                        C	$P_Neither_Delims:			;AN023;
			     C	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-45


 0551  E8 0395 R             C		call	$P_0099 		;AN000; convert it to binary
 0554  72 1E                 C		jc	$P_GetNum_Exit		;AN000; if error exit
			     C	
 0556  B4 00                 C		mov	ah,0			;AN000;
 0558  91                    C		xchg	ax,cx			;AN000;
 0559  BA 000A               C		mov	dx,10			;AN000;
 055C  F7 E2                 C		mul	dx			;AN000; ax = ax * 10
 055E  0B D2                 C		or	dx,dx			;AN000; overflow
 0560  75 11                 C		jne	$P_GetNum02		;AN000; then exit
			     C	
 0562  03 C1                 C		add	ax,cx			;AN000;
 0564  72 0E                 C		jc	$P_GetNum_Exit		;AN000;
			     C	
 0566  91                    C		xchg	ax,cx			;AN000;
 0567  46                    C		inc	si			;AN000;
 0568  EB BF                 C		jmp	short $P_GetNum_Loop	;AN000;
			     C	
 056A                        C	$P_GetNum00:				;AN000;
 056A  8A D8                 C		mov	bl,al			;AN000; set bl to NULL
 056C  F8                    C		clc				;AN000; indicate no error
 056D  EB 05                 C		jmp	short $P_GetNum_Exit	;AN000;
			     C	
 056F                        C	$P_GetNum01:				;AN000;
 056F  46                    C		inc	si			;AN000; si points to next number
 0570  F8                    C		clc				;AN000; indicate no error
 0571  EB 01                 C		jmp	short $P_GetNum_Exit	;AN000;
			     C	
 0573                        C	$P_GetNum02:				;AN000;
 0573  F9                    C		stc				;AN000; indicate error
 0574                        C	$P_GetNum_Exit: 			;AN000;
 0574  8B C1                 C		mov	ax,cx			;AN000;return value
 0576  5A                    C		pop	dx			;AN000;
 0577  59                    C		pop	cx			;AN000;
 0578  C3                    C		ret				;AN000;
 0579                        C	$P_Get_DecNum endp			;AN000;
			     C	ENDIF					;AN000;(of TimeSW+DateSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-46


			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-47


			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-48


			     C	PAGE					;AN000;
			     C	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-49


			     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	;***********************************************************************
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-50


			     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	;***********************************************************************
 0579                        C	$P_File_Format proc			;AN000;
 0579  50                    C		push	ax			;AN000;
 057A  57                    C		push	di			;AN000;
 057B  56                    C		push	si			;AN000;
 057C  8B 3E 000F R          C		mov	di,psdata_seg:$P_SaveSI_cmpx ;AC034; get user buffer address
 0580                        C	$P_FileF_Loop0: 			;AN000; / skip special characters
 0580  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; load character
 0582  0A C0                 C		or	al,al			;AN000; end of line ?
 0584  74 11                 C		je	$P_FileF_Err		;AN000; if yes, error exit
			     C	
 0586  E8 05E0 R             C		call	$P_FileSp_Chk		;AN000; else, check if file special character
 0589  75 20                 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
 058B  C6 06 00D5 R 01       C		mov	psdata_seg:$P_err_flag,$P_error_filespec ;AN033;AC034;; set error flag- bad char.
 0590  5E                    C		pop	si			;AN033;
 0591  C6 04 00              C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN033;
 0594  5F                    C		pop	di			;AN033;
 0595  EB 39                 C		jmp	short $P_FileF02	;AN033;
			     C	
			     C	
 0597                        C	$P_FileF_Err:				;AN000;
 0597  5E                    C		pop	si			;AN000;
 0598  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
 059B  5F                    C		pop	di			;AN000;
 059C  26: F7 07 0001        C		test	es:[bx].$P_Match_Flag,$P_Optional ;AN000; is it optional ?
 05A1  75 2D                 C		jne	$P_FileF02		;AN000;
			     C	
 05A3  C7 06 0002 R 0002     C		mov	psdata_seg:$P_RC,$P_Op_Missing ;AC034; 3/17/87
 05A9  EB 25                 C		jmp	short $P_FileF02	;AN000;
			     C	
 05AB                        C	$P_FileF03:				;AN000;
 05AB  58                    C		pop	ax			;AN000; discard save si
 05AC  56                    C		push	si			;AN000; save new si
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-51


 05AD                        C	$P_FileF_Loop1: 			;AN000;
 05AD  8A 04                 C		mov	al,psdata_seg:[si]	;AN000; load character (not special char)
 05AF  0A C0                 C		or	al,al			;AN000; end of line ?
 05B1  74 1B                 C		je	$P_FileF_RLT		;AN000;
			     C	
 05B3  E8 05E0 R             C		call	$P_FileSp_Chk		;AN000; File special character ?
 05B6  74 0B                 C		je	$P_FileF00		;AN000;
			     C	
 05B8  E8 0716 R             C		call	$P_Chk_DBCS		;AN000; no, then DBCS ?
 05BB  73 02                 C		jnc	$P_FileF01		;AN000;
 05BD  47                    C		inc	di			;AN000; if yes, skip next byte
 05BE  46                    C		inc	si			;AN000;
 05BF                        C	$P_FileF01:				;AN000;
 05BF  47                    C		inc	di			;AN000;
 05C0  46                    C		inc	si			;AN000;
 05C1  EB EA                 C		jmp	short $P_FileF_Loop1	;AN000;
			     C	;
 05C3                        C	$P_FileF00:				;AN000;
 05C3  A2 0008 R             C		mov	psdata_seg:$P_Terminator,al ;AC034;
 05C6  C6 04 00              C		mov	byte ptr psdata_seg:[si],$P_NULL ;AN000; update end of string
 05C9  47                    C		inc	di			;AN000;
 05CA  89 3E 0004 R          C		mov	psdata_seg:$P_SI_Save,di ;AC034; update next pointer in command line
 05CE                        C	$P_FileF_RLT:				;AN000;
 05CE  5E                    C		pop	si			;AN000;
 05CF  5F                    C		pop	di			;AN000;
 05D0                        C	$P_FileF02:				;AN000;
			     C	
 05D0  58                    C		pop	ax			;AN000; (tm14)
 05D1  A9 0200               C		test	ax,$P_File_Spc		;AN000; (tm14)
 05D4  74 09                 C		je	$P_Drv_Only_Exit	;AN000; (tm14)
			     C	
 05D6  50                    C		push	ax			;AN000;  (tm14)
			     C	
 05D7  B4 FF                 C		mov	ah,$P_No_Tag		;AN000; set
 05D9  B0 05                 C		mov	al,$P_File_Spec 	;AN000;    result
 05DB  E8 01F9 R             C		call	$P_Fill_Result		;AN000; 	 buffer to file spec
 05DE  58                    C		pop	ax			;AN000;
			     C	
 05DF                        C	$P_Drv_Only_Exit:			;AN000; (tm14)
			     C	
 05DF  C3                    C		ret				;AN000;
 05E0                        C	$P_File_Format endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-52


			     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	;***********************************************************************
 05E0                        C	$P_FileSp_Chk proc			;AN000;
 05E0  53                    C		push	bx			;AN000;
 05E1  51                    C		push	cx			;AN000;
 05E2  8D 1E 00CC R          C		lea	bx,psdata_seg:$P_FileSp_Char ;AC034; special character table
 05E6  B9 0009               C		mov	cx,$P_FileSp_Len	;AN000; load length of it
 05E9                        C	$P_FileSp_Loop: 			;AN000;
 05E9  3A 07                 C		cmp	al,psdata_seg:[bx]	;AN000; is it one of special character ?
 05EB  74 04                 C		je	$P_FileSp_Exit		;AN000;
			     C	
 05ED  43                    C		inc	bx			;AN000;
 05EE  E2 F9                 C		loop	$P_FileSp_Loop		;AN000;
			     C	
 05F0  41                    C		inc	cx			;AN000; reset ZF
 05F1                        C	$P_FileSp_Exit: 			;AN000;
 05F1  59                    C		pop	cx			;AN000;
 05F2  5B                    C		pop	bx			;AN000;
 05F3  C3                    C		ret				;AN000;
 05F4                        C	$P_FileSp_Chk endp			;AN000;
			     C	ENDIF					;AN000;(of FileSW+DrvSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-53


			     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	;***********************************************************************
 05F4                        C	$P_Drive_Format proc			;AN000;
 05F4  50                    C		push	ax			;AN000;
 05F5  52                    C		push	dx			;AN000;
 05F6  8A 04                 C		mov	al,psdata_seg:[si]	;AN000;
 05F8  0A C0                 C		or	al,al			;AN000; if null string
 05FA  74 35                 C		je	$P_Drv_Exit		;AN000; do nothing
			     C	
 05FC  E8 0716 R             C		call	$P_Chk_DBCS		;AN000; is it leading byte ?
 05FF  72 2A                 C		jc	$P_Drv_Err		;AN000;
			     C	
 0601  83 7C 01 3A           C		cmp	word ptr psdata_seg:[si+byte],$P_Colon ;AN000; "d", ":", 0  ?
 0605  74 0D                 C		je	$P_DrvF00		;AN000;
			     C	
 0607  26: F7 07 0010        C		test	es:[bx].$P_Match_Flag,$P_Ig_Colon ;AN000; colon can be ignored?
 060C  74 1D                 C		je	$P_Drv_Err		;AN000;
			     C	
 060E  80 7C 01 00           C		cmp	byte ptr psdata_seg:[si+byte],$P_NULL ;AN000; "d", 0  ?
 0612  75 17                 C		jne	$P_Drv_Err		;AN000;
			     C	
 0614                        C	$P_DrvF00:				;AN000;
 0614  0C 20                 C		or	al,$P_Make_Lower	;AN000; lower case
 0616  3C 61                 C		cmp	al,"a"                  ;AN000; drive letter must
 0618  72 11                 C		jb	$P_Drv_Err		;AN000; in range of
			     C	
 061A  3C 7A                 C		cmp	al,"z"                  ;AN000; "a" - "z"
 061C  77 0D                 C		ja	$P_Drv_Err		;AN000; if no, error
			     C	
 061E  2C 60                 C		sub	al,"a"-1                ;AN000; make text drive to binary drive
 0620  8A D0                 C		mov	dl,al			;AN000; set
 0622  B4 FF                 C		mov	ah,$P_No_Tag		;AN000;    result
 0624  B0 06                 C		mov	al,$P_Drive		;AN000; 	 buffer
 0626  E8 01F9 R             C		call	$P_Fill_Result		;AN000; 	       to drive
 0629  EB 06                 C		jmp	short $P_Drv_Exit	;AN000;
			     C	
 062B                        C	$P_Drv_Err:				;AN000;
 062B  C7 06 0002 R 0009     C		mov	psdata_seg:$P_RC,$P_Syntax ;AC034;
 0631                        C	$P_Drv_Exit:				;AN000;
 0631  5A                    C		pop	dx			;AN000;
 0632  58                    C		pop	ax			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-54


 0633  C3                    C		ret				;AN000;
 0634                        C	$P_Drive_Format endp			;AN000;
			     C	ENDIF					;AN000;(of DrvSW)
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-55


			     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	;***********************************************************************
 0634                        C	$P_Skip_Delim proc			;AN000;
 0634                        C	$P_Skip_Delim_Loop:			;AN000;
 0634  AC                    C		LODSB				;AN000;
 0635  E8 0658 R             C		call	$P_Chk_EOL		;AN000; is it EOL character ?
 0638  74 16                 C		je	$P_Skip_Delim_CY	;AN000; if yes, exit w/ CY on
			     C	
 063A  E8 068E R             C		call	$P_Chk_Delim		;AN000; is it one of delimiters ?
 063D  75 14                 C		jne	$P_Skip_Delim_NCY	;AN000; if no, exit w/ CY off
			     C	
 063F  F6 06 000E R 20       C		test	psdata_seg:$P_Flags2,$P_Extra ;AC034; extra delim or comma found ?
 0644  74 EE                 C		je	$P_Skip_Delim_Loop	;AN000; if no, loop
			     C	
 0646  F6 06 000E R 41       C		test	psdata_seg:$P_Flags2,$P_SW+$P_equ ;AC034; /x , or xxx=zzz , (tm08)
 064B  74 09                 C		je	short $P_Exit_At_Extra	;AN000; no switch, no keyword (tm08)
			     C	
 064D  4E                    C		dec	si			;AN000; backup si for next call (tm08)
 064E  EB 06                 C		jmp	short $P_Exit_At_Extra	;AN000; else exit w/ CY off
			     C	
 0650                        C	$P_Skip_Delim_CY:			;AN000;
 0650  F9                    C		stc				;AN000; indicate EOL
 0651  EB 01                 C		jmp	short $P_Skip_Delim_Exit ;AN000;
			     C	
 0653                        C	$P_Skip_Delim_NCY:			;AN000;
 0653  F8                    C		clc				;AN000; indicate non delim
 0654                        C	$P_Skip_Delim_Exit:			;AN000; in this case, need
 0654  4E                    C		dec	si			;AN000;  backup index pointer
 0655  C3                    C		ret				;AN000;
			     C	
 0656                        C	$P_Exit_At_Extra:			;AN000;
 0656  F8                    C		clc				;AN000; indicate extra delim
 0657  C3                    C		ret				;AN000;
 0658                        C	$P_Skip_Delim endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-56


			     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	;**********************************************************************
 0658                        C	$P_Chk_EOL proc 			;AN000;
 0658  53                    C		push	bx			;AN000;
 0659  51                    C		push	cx			;AN000;
 065A  3C 0D                 C		cmp	al,$P_CR		;AN000; Carriage return ?
 065C  74 2D                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	
 065E  3C 00                 C		cmp	al,$P_NULL		;AN000; zero ?
 0660  74 29                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	
			     C	IF LFEOLSW				;AN028; IF LF TO BE ACCEPTED AS EOL
 0662  3C 0A                 C		cmp	al,$P_LF		;AN000; Line feed ?
 0664  74 25                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	ENDIF					;AN028;
			     C	
 0666  26: 80 7D 02 02       C		cmp	byte ptr es:[di].$P_Num_Extra,$P_I_Have_EOL ;AN000; EOL character specified ?
 066B  72 1E                 C		jb	$P_Chk_EOL_Exit 	;AN000;
			     C	
 066D  33 DB                 C		xor	bx,bx			;AN000;
 066F  26: 8A 5D 03          C		mov	bl,es:[di].$P_Len_Extra_Delim ;AN000; get length of delimiter list
 0673  83 C3 04              C		add	bx,$P_Len_PARMS 	;AN000; skip it
 0676  26: 80 39 00          C		cmp	byte ptr es:[bx+di],$P_I_Use_Default ;AN000; No extra EOL character ?
 067A  74 0D                 C		je	$P_Chk_EOL_NZ		;AN000;
			     C	
 067C  33 C9                 C		xor	cx,cx			;AN000; Get number of extra chcracter
 067E  26: 8A 09             C		mov	cl,es:[bx+di]		;AN000;
 0681                        C	$P_Chk_EOL_Loop:			;AN000;
 0681  43                    C		inc	bx			;AN000;
 0682  26: 3A 01             C		cmp	al,es:[bx+di]		;AN000; Check extra EOL character
 0685  74 04                 C		je	$P_Chk_EOL_Exit 	;AN000;
			     C	
 0687  E2 F8                 C		loop	$P_Chk_EOL_Loop 	;AN000;
			     C	
 0689                        C	$P_Chk_EOL_NZ:				;AN000;
 0689  3C 0D                 C		cmp	al,$P_CR		;AN000; reset ZF
 068B                        C	$P_Chk_EOL_Exit:			;AN000;
 068B  59                    C		pop	cx			;AN000;
 068C  5B                    C		pop	bx			;AN000;
 068D  C3                    C		ret				;AN000;
 068E                        C	$P_Chk_EOL endp 			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-57


			     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	;***********************************************************************
 068E                        C	$P_Chk_Delim proc			;AN000;
 068E  53                    C		push	bx			;AN000;
 068F  51                    C		push	cx			;AN000;
 0690  C6 06 0008 R 20       C		mov	psdata_seg:$P_Terminator,$P_Space   ;AC034; Assume terminated by space
 0695  80 26 000E R DF       C		and	psdata_seg:$P_Flags2,0ffh-$P_Extra ;AC034;
 069A  3C 20                 C		cmp	al,$P_Space		;AN000; Space ?
 069C  74 36                 C		je	$P_Chk_Delim_Exit	;AN000;
			     C	
 069E  3C 09                 C		cmp	al,$P_TAB		;AN000; TAB ?
 06A0  74 32                 C		je	$P_Chk_Delim_Exit	;AN000;
			     C	
 06A2  3C 2C                 C		cmp	al,$P_Comma		;AN000; Comma ?
 06A4  74 31                 C		je	$P_Chk_Delim_Exit0	;AN000;
			     C	
 06A6                        C	$P_Chk_Delim00: 			;AN000;
 06A6  3C 81                 C		cmp	al,$P_DBSP1		;AN000; 1st byte of DBCS Space ?
 06A8  75 0C                 C		jne	$P_Chk_Delim01		;AN000;
			     C	
 06AA  80 3C 40              C		cmp	byte ptr [si],$P_DBSP2	;AN000; 2nd byte of DBCS Space ?
 06AD  75 07                 C		jne	$P_Chk_Delim01		;AN000;
			     C	
 06AF  B0 20                 C		mov	al,$P_Space		;AN000;
 06B1  46                    C		inc	si			;AN000; make si point to next character
 06B2  3A C0                 C		cmp	al,al			;AN000; Set ZF
 06B4  EB 1E                 C		jmp	short $P_Chk_Delim_Exit ;AN000;
			     C	
 06B6                        C	$P_Chk_Delim01: 			;AN000;
 06B6  26: 80 7D 02 01       C		cmp	byte ptr es:[di].$P_Num_Extra,$P_I_Have_Delim ;AN000; delimiter character specified 
				?
 06BB  72 17                 C		jb	$P_Chk_Delim_Exit	;AN000;
			     C	
 06BD  33 C9                 C		xor	cx,cx			;AN000;
 06BF  26: 8A 4D 03          C		mov	cl,es:[di].$P_Len_Extra_Delim ;AN000; get length of delimiter list
 06C3  0B C9                 C		or	cx,cx			;AN000; No extra Delim character ?
 06C5  74 0B                 C		je	$P_Chk_Delim_NZ 	;AN000;
			     C	
 06C7  BB 0003               C		mov	bx,$P_Len_PARMS-1	;AN000; set bx to 1st extra delimiter
 06CA                        C	$P_Chk_Delim_Loop:			;AN000;
 06CA  43                    C		inc	bx			;AN000;
 06CB  26: 3A 01             C		cmp	al,es:[bx+di]		;AN000; Check extra Delim character
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-58


 06CE  74 07                 C		je	$P_Chk_Delim_Exit0	;AN000;
			     C	
 06D0  E2 F8                 C		loop	$P_Chk_Delim_Loop	;AN000; examine all extra delimiter
			     C	
 06D2                        C	$P_Chk_Delim_NZ:			;AN000;
 06D2  3C 20                 C		cmp	al,$P_Space		;AN000; reset ZF
 06D4                        C	$P_Chk_Delim_Exit:			;AN000;
			     C	;;;;	jne	$P_ChkDfin
			     C	;;;;	mov	psdata_seg:$P_Terminator,al ;AN034;
 06D4                        C	$P_ChkDfin:				;AN000;
 06D4  59                    C		pop	cx			;AN000;
 06D5  5B                    C		pop	bx			;AN000;
 06D6  C3                    C		ret				;AN000;
			     C	
 06D7                        C	$P_Chk_Delim_Exit0:			;AN000;
 06D7  A2 0008 R             C		mov	psdata_seg:$P_Terminator,al ;AC034; keep terminated delimiter
 06DA  F6 06 000E R 01       C		test	psdata_seg:$P_Flags2,$P_Equ  ;AN027;AC034;; if terminating a key=
 06DF  75 05                 C		jnz	$P_No_Set_Extra 	;AN027; then do not set the EXTRA bit
			     C	
 06E1  80 0E 000E R 20       C		or	psdata_seg:$P_Flags2,$P_Extra ;AC034; flag terminated extra delimiter or comma
 06E6                        C	$P_No_Set_Extra:			;AN027;
 06E6  3A C0                 C		cmp	al,al			;AN000; set ZF
 06E8  EB EA                 C		jmp	short $P_Chk_Delim_Exit ;AN000;
			     C	
 06EA                        C	$P_Chk_Delim endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-59


			     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	;***********************************************************************
 06EA                        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	
 06EA  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
 06EE  3B DD                 C		cmp	BX,BP			;AN000;
 06F0  74 19                 C		je	$P_STRUC_L2		;AN000;
			     C	
			     C	;	    .IF <AL EQ $P_Switch> THEN	;AN020;otherwise see if a slash
 06F2  3C 2F                 C		    cmp     AL,$P_Switch	;AN000;
 06F4  75 12                 C		    jne     $P_STRUC_L5 	;AN000;
			     C	
 06F6  F9                    C			STC			;AN020;not in first position and is slash, now see if might 
				be in date string
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-60


			     C	IF	DateSw				;AN020;caller looking for date, see if this may be part of o
				ne
 06F7  50                    C			PUSH	AX		;AN020;save input char
 06F8  8A 47 FF              C			MOV	AL,PSDATA_SEG:[BX-1] ;AN026;AL=char before the current char
 06FB  E8 0395 R             C			CALL	$P_0099 	;AN020;return carry set if not numeric
			     C	;		.IF   NC ;AND		;AN020;IF previous char numeric AND
 06FE  72 05                 C			jc	$P_STRUC_L7	;AN000;
			     C	
 0700  8A 04                 C			    MOV     AL,[SI]	;AN020;AL=char after the current char
 0702  E8 0395 R             C			    CALL    $P_0099	;AN020;return carry set if not numeric
			     C	;(deleted)	    .IF     NC THEN	;AN020;IF next char numeric THEN could be a date
			     C	;(deleted)		CLC		;AN020;reset CF so "/" not treated as a delimiter
			     C	;(deleted)	    .ENDIF		;AN026;
			     C	;		.ENDIF			;AN020;ENDIF looks like date (number/number)
 0705                        C	$P_STRUC_L7:				;AN000;
 0705  58                    C			POP	AX		;AN020;restore AL to input char
			     C	ENDIF					;AN020;DateSw
			     C	;	    .ELSE			;AN020;
 0706  EB 0D                 C		    jmp     short $P_STRUC_L1	;AN000;
			     C	
 0708                        C	$P_STRUC_L5:				;AN000;
 0708  F8                    C			CLC			;AN020;not a slash
			     C	;	    .ENDIF			;AN020;
			     C	;	.ELSE				;AN020;is first char in the buffer, ZF=0
 0709  EB 0A                 C		jmp	short $P_STRUC_L1	;AN000;
			     C	
 070B                        C	$P_STRUC_L2:				;AN000;
			     C	;	    .IF <AL EQ $P_Switch> THEN	;AN020;
 070B  3C 2F                 C		    cmp     AL,$P_Switch	;AN000;
 070D  75 05                 C		    jne     $P_STRUC_L12	;AN000;
			     C	
 070F  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;
 0714                        C	$P_STRUC_L12:				;AN000;
 0714  F8                    C		    CLC 			;AN020;CF=0 indicating first char
			     C	;	.ENDIF				;AN020;
 0715                        C	$P_STRUC_L1:				;AN000;
			     C	
 0715  C3                    C		ret				;AN000;
 0716                        C	$P_Chk_Switch endp			;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-61


			     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	;***************************************************************************
 0716                        C	$P_Chk_DBCS PROC			;AN000;
			     C	;
 0716  1E                    C		PUSH	DS			;AN000;
 0717  56                    C		PUSH	SI			;AN000;
 0718  53                    C		PUSH	bx			;AN000; (tm11)
 0719  83 3E 000B R 00       C		CMP	psdata_seg:$P_DBCSEV_SEG,0 ;AC034; ALREADY SET ?
 071E  75 25                 C		JNE	$P_DBCS00		;AN000;
			     C	
 0720  50                    C		PUSH	AX			;AN000;
			     C	;	PUSH	BX			;AN000; (tm11)
 0721  1E                    C		PUSH	ds			;AN000; (tm11)
 0722  51                    C		PUSH	CX			;AN000;
 0723  52                    C		PUSH	DX			;AN000;
 0724  57                    C		PUSH	DI			;AN000;
 0725  55                    C		PUSH	BP			;AN000;
 0726  06                    C		PUSH	ES			;AN000;
 0727  33 F6                 C		XOR	SI,SI			;AN000;
 0729  8E DE                 C		MOV	DS,SI			;AN000;
 072B  B8 6300               C		MOV	AX,$P_DOS_GetEV 	;AN000; GET DBCS EV CALL
 072E  CD 21                 C		INT	21H			;AN000;
			     C	
			     C	;	MOV	AX,DS			;AN000; (tm11)
			     C	;	OR	AX,AX			;AN000; (tm11)
 0730  8C DB                 C		MOV	bx,DS			;AN000; (tm11)
 0732  0B DB                 C		OR	bx,bx			;AN000; (tm11)
 0734  07                    C		POP	ES			;AN000;
 0735  5D                    C		POP	BP			;AN000;
 0736  5F                    C		POP	DI			;AN000;
 0737  5A                    C		POP	DX			;AN000;
 0738  59                    C		POP	CX			;AN000;
			     C	;	POP	BX			;AN000; (tm11)
 0739  1F                    C		POP	ds			;AN000; (tm11)
 073A  58                    C		POP	AX			;AN000;
 073B  74 25                 C		JE	$P_NON_DBCS		;AN000;
			     C	
 073D                        C	$P_DBCS02:				;AN000;
 073D  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
 0741  89 1E 000B R          C		MOV	psdata_seg:$P_DBCSEV_SEG,bx ;AC034; save EV segment (tm11)
 0745                        C	$P_DBCS00:				;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-62


 0745  8B 36 0009 R          C		MOV	SI,psdata_seg:$P_DBCSEV_OFF ;AC034; load EV offset
 0749  8E 1E 000B R          C		MOV	DS,psdata_seg:$P_DBCSEV_SEG ;AC034; and segment
			     C	
 074D                        C	$P_DBCS_LOOP:				;AN000;
 074D  83 3C 00              C		CMP	WORD PTR [SI],0 	;AN000; zero vector ?
 0750  74 10                 C		JE	$P_NON_DBCS		;AN000; then exit
			     C	
 0752  3A 04                 C		CMP	AL,[SI] 		;AN000;
 0754  72 08                 C		JB	$P_DBCS01		;AN000; Check if AL is in
			     C	
 0756  3A 44 01              C		CMP	AL,[SI+BYTE]		;AN000;   range of
 0759  77 03                 C		JA	$P_DBCS01		;AN000;      the vector
			     C	
 075B  F9                    C		STC				;AN000; if yes, indicate DBCS and exit
 075C  EB 05                 C		JMP	short $P_DBCS_EXIT	;AN000;
			     C	
 075E                        C	$P_DBCS01:				;AN000;
 075E  46                    C		INC	SI			;AC035; add '2' to
 075F  46                    C		INC	SI			;AC035;  SI reg
			     C						;AN000; get next vector
			     C	;(changed ;AC035;) ADD	   SI,2 	;AN000; get next vector
 0760  EB EB                 C		JMP	short $P_DBCS_LOOP	;AN000; loop until zero vector found
			     C	
 0762                        C	$P_NON_DBCS:				;AN000;
 0762  F8                    C		CLC				;AN000; indicate SBCS
 0763                        C	$P_DBCS_EXIT:				;AN000;
 0763  5B                    C		POP	bx			;AN000; (tm11)
 0764  5E                    C		POP	SI			;AN000;
 0765  1F                    C		POP	DS			;AN000;
 0766  C3                    C		RET				;AN000;
 0767                        C	$P_Chk_DBCS ENDP			;AN000;
				;-------------------------------------------------------------------
				
 0767				_parse	proc	near								;AN000;
				
 0767  55				push	bp			; save user's base pointer              ;AN000;
 0768  8B EC				mov	bp,sp			; set bp to current sp			;AN000;
 076A  57				push	di			; save some registers			;AN000;
 076B  56				push	si								;AN000;
				
				;	copy C inregs into proper registers
				
 076C  8B 7E 04				mov	di,[bp+4]		; fix di (arg 0)			;AN000;
				
				;-------------------------------------------------------------------
				
 076F  8B 45 0A				mov	ax,[di+0ah]		; load di				;AN000;
 0772  50				push	ax			; the di value from inregs is now on stack;AN000;
				
 0773  8B 05				mov	ax,[di+00]		; get inregs.x.ax			;AN000;
 0775  8B 5D 02				mov	bx,[di+02]		; get inregs.x.bx			;AN000;
 0778  8B 4D 04				mov	cx,[di+04]		; get inregs.x.cx			;AN000;
 077B  8B 55 06				mov	dx,[di+06]		; get inregs.x.dx			;AN000;
 077E  8B 75 08				mov	si,[di+08]		; get inregs.x.si			;AN000;
 0781  5F				pop	di			; get inregs.x.di from stack		;AN000;
				
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Page     1-63


 0782  55				push	bp			; save base pointer			;AN000;
				
				;-------------------------------------------------------------------
 0783  E8 0000 R			call	sysparse		; call the parser			;AN000;
				;-------------------------------------------------------------------
				
 0786  5D				pop	bp			; restore base pointer			;AN000;
 0787  57				push	di			; the di value from call is now on stack;AN000;
 0788  8B 7E 06				mov	di,[bp+6]		; fix di (arg 1)			;AN000;
				
 078B  89 05				mov	[di+00],ax		; load outregs.x.ax			;AN000;
 078D  89 5D 02				mov	[di+02],bx		; load outregs.x.bx			;AN000;
 0790  89 4D 04				mov	[di+04],cx		; load outregs.x.cx			;AN000;
 0793  89 55 06				mov	[di+06],dx		; load outregs.x.dx			;AN000;
 0796  89 75 08				mov	[di+08],si		; load outregs.x.si			;AN000;
				
 0799  9F				lahf				; get flags into ax			;AN000;
 079A  8A C4				mov	al,ah			; move into low byte			;AN000;
 079C  89 45 0C				mov	[di+0ch],ax		; load outregs.x.cflag			;AN000;
				
 079F  58				pop	ax			; get di from stack			;AN000;
 07A0  89 45 0A				mov	[di+0ah],ax		; load outregs.x.di			;AN000;
				
				;-------------------------------------------------------------------
				
 07A3  5E				pop	si			; restore registers			;AN000;
 07A4  5F				pop	di								;AN000;
 07A5  8B E5				mov	sp,bp			; restore sp				;AN000;
 07A7  5D				pop	bp			; restore user's bp                     ;AN000;
 07A8  C3				ret									;AN000;
				
 07A9				_parse	endp									;AN000;
				
 07A9				_TEXT	ends				; end code segment			;AN000;
					end									;AN000;
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-1


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

DGROUP . . . . . . . . . . . . .  	GROUP
  _DATA  . . . . . . . . . . . .  	00D6	BYTE	PUBLIC	'DATA'
PGROUP . . . . . . . . . . . . .  	GROUP
  _TEXT  . . . . . . . . . . . .  	07A9	BYTE	PUBLIC	'CODE'
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-2


Symbols:            

                N a m e         	Type	 Value	 Attr

BASESW . . . . . . . . . . . . .  	NUMBER	0001	

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

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

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

INCSW  . . . . . . . . . . . . .  	NUMBER	0000	

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

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

NUMSW  . . . . . . . . . . . . .  	NUMBER	0000	

PSDATA_SEG . . . . . . . . . . .  	ALIAS	 DS		

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

SWSW . . . . . . . . . . . . . .  	NUMBER	0001	
SYSPARSE . . . . . . . . . . . .  	N PROC	0000	_TEXT	Length = 013E

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

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

$P_0099  . . . . . . . . . . . .  	N PROC	0395	_TEXT	Length = 000E
$P_0099ERR . . . . . . . . . . .  	L NEAR	03A1	_TEXT
$P_1ST_VAL . . . . . . . . . . .  	L WORD	00BA	_DATA
$P_2ND_VAL . . . . . . . . . . .  	L WORD	00BC	_DATA
$P_3RD_VAL . . . . . . . . . . .  	L WORD	00BE	_DATA
$P_4TH_VAL . . . . . . . . . . .  	L WORD	00C0	_DATA
$P_ASCII80 . . . . . . . . . . .  	NUMBER	0080	
$P_BRIDGE  . . . . . . . . . . .  	L NEAR	02B6	_TEXT
$P_CAPS_RET  . . . . . . . . . .  	L NEAR	0394	_TEXT
$P_CAP_CHAR  . . . . . . . . . .  	NUMBER	0002	
$P_CAP_FILE  . . . . . . . . . .  	NUMBER	0001	
$P_CHAR_CAP_PTR  . . . . . . . .  	L BYTE	00C2	_DATA
$P_CHECK_MATCH_FLAGS . . . . . .  	N PROC	027B	_TEXT	Length = 008F
$P_CHKDFIN . . . . . . . . . . .  	L NEAR	06D4	_TEXT
$P_CHK_DBCS  . . . . . . . . . .  	N PROC	0716	_TEXT	Length = 0051
$P_CHK_DELIM . . . . . . . . . .  	N PROC	068E	_TEXT	Length = 005C
$P_CHK_DELIM00 . . . . . . . . .  	L NEAR	06A6	_TEXT
$P_CHK_DELIM01 . . . . . . . . .  	L NEAR	06B6	_TEXT
$P_CHK_DELIM_EXIT  . . . . . . .  	L NEAR	06D4	_TEXT
$P_CHK_DELIM_EXIT0 . . . . . . .  	L NEAR	06D7	_TEXT
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-3


$P_CHK_DELIM_LOOP  . . . . . . .  	L NEAR	06CA	_TEXT
$P_CHK_DELIM_NZ  . . . . . . . .  	L NEAR	06D2	_TEXT
$P_CHK_EOL . . . . . . . . . . .  	N PROC	0658	_TEXT	Length = 0036
$P_CHK_EOL_EXIT  . . . . . . . .  	L NEAR	068B	_TEXT
$P_CHK_EOL_LOOP  . . . . . . . .  	L NEAR	0681	_TEXT
$P_CHK_EOL_NZ  . . . . . . . . .  	L NEAR	0689	_TEXT
$P_CHK_IF_DATA_REQUIRED  . . . .  	L NEAR	01D0	_TEXT
$P_CHK_KEY_CONTROL . . . . . . .  	N PROC	016D	_TEXT	Length = 0002
$P_CHK_POS_CONTROL . . . . . . .  	N PROC	013E	_TEXT	Length = 002F
$P_CHK_SWITCH  . . . . . . . . .  	N PROC	06EA	_TEXT	Length = 002C
$P_CHK_SW_CONTROL  . . . . . . .  	N PROC	019F	_TEXT	Length = 005A
$P_CHK_SW_ERR0 . . . . . . . . .  	L NEAR	01EB	_TEXT
$P_CHK_SW_EXIT . . . . . . . . .  	L NEAR	01EE	_TEXT
$P_CHK_SW_SINGLE_EXIT  . . . . .  	L NEAR	01F8	_TEXT
$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_COUNTRY_INFO  . . . . . . . .  	L 	0098	_DATA
$P_CPC00 . . . . . . . . . . . .  	L NEAR	014B	_TEXT
$P_CPC01 . . . . . . . . . . . .  	L NEAR	0168	_TEXT
$P_CPC02 . . . . . . . . . . . .  	L NEAR	015D	_TEXT
$P_CPC_EXIT  . . . . . . . . . .  	L NEAR	016B	_TEXT
$P_CR  . . . . . . . . . . . . .  	NUMBER	000D	
$P_CSW00 . . . . . . . . . . . .  	L NEAR	01E5	_TEXT
$P_DATEF00 . . . . . . . . . . .  	L NEAR	04CD	_TEXT
$P_DATEF01 . . . . . . . . . . .  	L NEAR	04CB	_TEXT
$P_DATEF02 . . . . . . . . . . .  	L NEAR	04E3	_TEXT
$P_DATEF03 . . . . . . . . . . .  	L NEAR	04EC	_TEXT
$P_DATEF_ERR0  . . . . . . . . .  	L NEAR	049C	_TEXT
$P_DATEF_ERROR . . . . . . . . .  	L NEAR	04F7	_TEXT
$P_DATEF_YMD . . . . . . . . . .  	L NEAR	04A5	_TEXT
$P_DATE_DMY  . . . . . . . . . .  	NUMBER	0001	
$P_DATE_F  . . . . . . . . . . .  	NUMBER	0007	
$P_DATE_FORMAT . . . . . . . . .  	N PROC	0465	_TEXT	Length = 00A5
$P_DATE_FORMAT_EXIT  . . . . . .  	L NEAR	0506	_TEXT
$P_DATE_MDY  . . . . . . . . . .  	NUMBER	0000	
$P_DATE_S  . . . . . . . . . . .  	NUMBER	1000	
$P_DATE_YMD  . . . . . . . . . .  	NUMBER	0002	
$P_DBCS00  . . . . . . . . . . .  	L NEAR	0745	_TEXT
$P_DBCS01  . . . . . . . . . . .  	L NEAR	075E	_TEXT
$P_DBCS02  . . . . . . . . . . .  	L NEAR	073D	_TEXT
$P_DBCSEV_OFF  . . . . . . . . .  	L WORD	0009	_DATA
$P_DBCSEV_SEG  . . . . . . . . .  	L WORD	000B	_DATA
$P_DBCS_EXIT . . . . . . . . . .  	L NEAR	0763	_TEXT
$P_DBCS_LOOP . . . . . . . . . .  	L NEAR	074D	_TEXT
$P_DBSP1 . . . . . . . . . . . .  	NUMBER	0081	
$P_DBSP2 . . . . . . . . . . . .  	NUMBER	0040	
$P_DCC00 . . . . . . . . . . . .  	L NEAR	036A	_TEXT
$P_DCC01 . . . . . . . . . . . .  	L NEAR	0385	_TEXT
$P_DCC_GO  . . . . . . . . . . .  	L NEAR	035A	_TEXT
$P_DCS00 . . . . . . . . . . . .  	L NEAR	0343	_TEXT
$P_DCS01 . . . . . . . . . . . .  	L NEAR	0344	_TEXT
$P_DCS_EXIT  . . . . . . . . . .  	L NEAR	0347	_TEXT
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-4


$P_DCS_LOOP  . . . . . . . . . .  	L NEAR	0331	_TEXT
$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	
$P_DOS_GET_CDI . . . . . . . . .  	NUMBER	3800	
$P_DOS_GET_TBL . . . . . . . . .  	NUMBER	0065	
$P_DO_CAPS_CHAR  . . . . . . . .  	N PROC	034A	_TEXT	Length = 004B
$P_DO_CAPS_STRING  . . . . . . .  	N PROC	032D	_TEXT	Length = 001D
$P_DO_DATE_DELIMS  . . . . . . .  	L NEAR	0545	_TEXT
$P_DO_TIME_DELIM1  . . . . . . .  	L NEAR	053F	_TEXT
$P_DQUOTE  . . . . . . . . . . .  	NUMBER	0022	
$P_DRIVE . . . . . . . . . . . .  	NUMBER	0006	
$P_DRIVE_FORMAT  . . . . . . . .  	N PROC	05F4	_TEXT	Length = 0040
$P_DRVF00  . . . . . . . . . . .  	L NEAR	0614	_TEXT
$P_DRV_ERR . . . . . . . . . . .  	L NEAR	062B	_TEXT
$P_DRV_EXIT  . . . . . . . . . .  	L NEAR	0631	_TEXT
$P_DRV_ONLY  . . . . . . . . . .  	NUMBER	0100	
$P_DRV_ONLY_EXIT . . . . . . . .  	L NEAR	05DF	_TEXT
$P_DX  . . . . . . . . . . . . .  	L WORD	0006	_DATA
$P_EOL . . . . . . . . . . . . .  	NUMBER	0000	
$P_EQU . . . . . . . . . . . . .  	NUMBER	0001	
$P_ERROR_FILESPEC  . . . . . . .  	NUMBER	0001	
$P_ERR_FLAG  . . . . . . . . . .  	L BYTE	00D5	_DATA
$P_EXIT_AT_EXTRA . . . . . . . .  	L NEAR	0656	_TEXT
$P_EXTRA . . . . . . . . . . . .  	NUMBER	0020	
$P_FILEF00 . . . . . . . . . . .  	L NEAR	05C3	_TEXT
$P_FILEF01 . . . . . . . . . . .  	L NEAR	05BF	_TEXT
$P_FILEF02 . . . . . . . . . . .  	L NEAR	05D0	_TEXT
$P_FILEF03 . . . . . . . . . . .  	L NEAR	05AB	_TEXT
$P_FILEF_ERR . . . . . . . . . .  	L NEAR	0597	_TEXT
$P_FILEF_LOOP0 . . . . . . . . .  	L NEAR	0580	_TEXT
$P_FILEF_LOOP1 . . . . . . . . .  	L NEAR	05AD	_TEXT
$P_FILEF_RLT . . . . . . . . . .  	L NEAR	05CE	_TEXT
$P_FILESP_CHAR . . . . . . . . .  	L BYTE	00CC	_DATA
$P_FILESP_CHK  . . . . . . . . .  	N PROC	05E0	_TEXT	Length = 0014
$P_FILESP_EXIT . . . . . . . . .  	L NEAR	05F1	_TEXT
$P_FILESP_LEN  . . . . . . . . .  	NUMBER	0009	
$P_FILESP_LOOP . . . . . . . . .  	L NEAR	05E9	_TEXT
$P_FILE_CAP_PTR  . . . . . . . .  	L BYTE	00C7	_DATA
$P_FILE_FORMAT . . . . . . . . .  	N PROC	0579	_TEXT	Length = 0067
$P_FILE_SPC  . . . . . . . . . .  	NUMBER	0200	
$P_FILE_SPEC . . . . . . . . . .  	NUMBER	0005	
$P_FILL_RESULT . . . . . . . . .  	N PROC	01F9	_TEXT	Length = 0082
$P_FIN . . . . . . . . . . . . .  	L NEAR	0031	_TEXT
$P_FLAGS . . . . . . . . . . . .  	L WORD	000D	_DATA
$P_FLAGS1  . . . . . . . . . . .  	BYTE	000D	_DATA
$P_FLAGS2  . . . . . . . . . . .  	BYTE	000E	_DATA
$P_FOUND_SYNONYM . . . . . . . .  	L WORD	0015	_DATA
$P_GETNUM00  . . . . . . . . . .  	L NEAR	056A	_TEXT
$P_GETNUM01  . . . . . . . . . .  	L NEAR	056F	_TEXT
$P_GETNUM02  . . . . . . . . . .  	L NEAR	0573	_TEXT
$P_GETNUM_EXIT . . . . . . . . .  	L NEAR	0574	_TEXT
$P_GETNUM_LOOP . . . . . . . . .  	L NEAR	0529	_TEXT
$P_GET_DECNUM  . . . . . . . . .  	N PROC	0525	_TEXT	Length = 0054
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-5


$P_GOT_TIME  . . . . . . . . . .  	L BYTE	0097	_DATA
$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	0190	_TEXT
$P_KEYORSW_FOUND . . . . . . . .  	L NEAR	018B	_TEXT
$P_KEYORSW_LOOP  . . . . . . . .  	L NEAR	017E	_TEXT
$P_KEYORSW_NOT_FOUND . . . . . .  	L NEAR	0188	_TEXT
$P_KEYORSW_PTR . . . . . . . . .  	L WORD	0011	_DATA
$P_KEYWORD . . . . . . . . . . .  	NUMBER	003D	
$P_KEY_CMP . . . . . . . . . . .  	NUMBER	0008	
$P_KEY_MANAGER . . . . . . . . .  	L NEAR	00F3	_TEXT
$P_KEY_MGR_LOOP  . . . . . . . .  	L NEAR	0112	_TEXT
$P_KEY_NOT_FOUND . . . . . . . .  	L NEAR	0120	_TEXT
$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	029F	_TEXT
$P_MATCH02 . . . . . . . . . . .  	L NEAR	02B4	_TEXT
$P_MATCH03 . . . . . . . . . . .  	L NEAR	02B9	_TEXT
$P_MATCH06 . . . . . . . . . . .  	L NEAR	02D1	_TEXT
$P_MATCH07 . . . . . . . . . . .  	L NEAR	02E6	_TEXT
$P_MATCH09 . . . . . . . . . . .  	L NEAR	02F4	_TEXT
$P_MATCH2_EXIT . . . . . . . . .  	L NEAR	0308	_TEXT
$P_MATCH_EXIT  . . . . . . . . .  	L NEAR	02F4	_TEXT
$P_MBP_EXIT  . . . . . . . . . .  	L NEAR	019D	_TEXT
$P_MBP_LOOP  . . . . . . . . . .  	L NEAR	0193	_TEXT
$P_MINUS . . . . . . . . . . . .  	NUMBER	002D	
$P_MOVEBP_NUL  . . . . . . . . .  	N PROC	0193	_TEXT	Length = 000C
$P_NEEDTOBEREAD  . . . . . . . .  	NUMBER	FFFF	
$P_NEG . . . . . . . . . . . . .  	NUMBER	0002	
$P_NEITHER_DELIMS  . . . . . . .  	L NEAR	0551	_TEXT
$P_NON_DBCS  . . . . . . . . . .  	L NEAR	0762	_TEXT
$P_NOT_APPLICABLE  . . . . . . .  	L NEAR	0439	_TEXT
$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	
$P_NO_SET_EXTRA  . . . . . . . .  	L NEAR	06E6	_TEXT
$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	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-6


$P_OPTIONAL  . . . . . . . . . .  	NUMBER	0001	
$P_OP_MISSING  . . . . . . . . .  	NUMBER	0002	
$P_ORDINAL . . . . . . . . . . .  	L WORD	0000	_DATA
$P_OUT_OF_RANGE  . . . . . . . .  	NUMBER	0006	
$P_PACK_END  . . . . . . . . . .  	L NEAR	0085	_TEXT
$P_PACK_END_BACKUP_SI  . . . . .  	L NEAR	0063	_TEXT
$P_PACK_END_BY_EOL . . . . . . .  	L NEAR	0084	_TEXT
$P_PACK_LOOP . . . . . . . . . .  	L NEAR	0047	_TEXT
$P_PERIOD  . . . . . . . . . . .  	NUMBER	002E	
$P_PERIOD_ONLY . . . . . . . . .  	NUMBER	0002	
$P_PL00  . . . . . . . . . . . .  	L NEAR	0078	_TEXT
$P_PL01  . . . . . . . . . . . .  	L NEAR	006D	_TEXT
$P_PLUS  . . . . . . . . . . . .  	NUMBER	002B	
$P_POSITIONAL_MANAGER  . . . . .  	L NEAR	00A3	_TEXT
$P_QUOTED_STRING . . . . . . . .  	NUMBER	0009	
$P_QU_STRING . . . . . . . . . .  	NUMBER	0080	
$P_RC  . . . . . . . . . . . . .  	L WORD	0002	_DATA
$P_RCOL00  . . . . . . . . . . .  	L NEAR	0321	_TEXT
$P_RCOL01  . . . . . . . . . . .  	L NEAR	0327	_TEXT
$P_RCOL_EXIT . . . . . . . . . .  	L NEAR	032A	_TEXT
$P_RCOL_LOOP . . . . . . . . . .  	L NEAR	030C	_TEXT
$P_RC_EOL  . . . . . . . . . . .  	NUMBER	-0001	
$P_READ_CDI  . . . . . . . . . .  	L NEAR	0515	_TEXT
$P_REMOVE_COLON  . . . . . . . .  	N PROC	030A	_TEXT	Length = 0023
$P_REPEAT  . . . . . . . . . . .  	NUMBER	0002	
$P_RETURN_TO_CALLER  . . . . . .  	L NEAR	0126	_TEXT
$P_RETURN_TO_CALLER0 . . . . . .  	L NEAR	0126	_TEXT
$P_RLT00 . . . . . . . . . . . .  	L NEAR	0220	_TEXT
$P_RLT01 . . . . . . . . . . . .  	L NEAR	022A	_TEXT
$P_RLT02 . . . . . . . . . . . .  	L NEAR	0216	_TEXT
$P_RLT03 . . . . . . . . . . . .  	L NEAR	023C	_TEXT
$P_RLT04 . . . . . . . . . . . .  	L NEAR	0212	_TEXT
$P_RLT05 . . . . . . . . . . . .  	L NEAR	024E	_TEXT
$P_RLT_CAP00 . . . . . . . . . .  	L NEAR	0262	_TEXT
$P_RLT_CAP01 . . . . . . . . . .  	L NEAR	026E	_TEXT
$P_RLT_CAP02 . . . . . . . . . .  	L NEAR	026B	_TEXT
$P_RLT_EXIT  . . . . . . . . . .  	L NEAR	0279	_TEXT
$P_RM_COLON  . . . . . . . . . .  	NUMBER	0010	
$P_RPAREN  . . . . . . . . . . .  	NUMBER	0029	
$P_SAVESI_CMPX . . . . . . . . .  	L WORD	000F	_DATA
$P_SAVE_EOB  . . . . . . . . . .  	L WORD	0013	_DATA
$P_SCOM00  . . . . . . . . . . .  	L NEAR	040F	_TEXT
$P_SCOM01  . . . . . . . . . . .  	L NEAR	0421	_TEXT
$P_SCOM02  . . . . . . . . . . .  	L NEAR	044D	_TEXT
$P_SCOM03  . . . . . . . . . . .  	L NEAR	0401	_TEXT
$P_SCOM04  . . . . . . . . . . .  	L NEAR	03EC	_TEXT
$P_SCOM05  . . . . . . . . . . .  	L NEAR	03FE	_TEXT
$P_SCOM_DIFFER . . . . . . . . .  	L NEAR	0458	_TEXT
$P_SCOM_DIFFER0  . . . . . . . .  	L NEAR	0423	_TEXT
$P_SCOM_EXIT . . . . . . . . . .  	L NEAR	0460	_TEXT
$P_SCOM_LOOP . . . . . . . . . .  	L NEAR	03CE	_TEXT
$P_SCOM_SAME . . . . . . . . . .  	L NEAR	045B	_TEXT
$P_SEARCH_KEYORSW  . . . . . . .  	N PROC	016F	_TEXT	Length = 0024
$P_SET_CDI . . . . . . . . . . .  	N PROC	050A	_TEXT	Length = 001B
$P_SET_CDI_EXIT  . . . . . . . .  	L NEAR	0524	_TEXT
$P_SIGNED  . . . . . . . . . . .  	NUMBER	0080	
Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30
C	to PARSER interface                                       Symbols-7


$P_SIM00 . . . . . . . . . . . .  	L NEAR	03B6	_TEXT
$P_SIM01 . . . . . . . . . . . .  	L NEAR	03B6	_TEXT
$P_SIMPLE_S  . . . . . . . . . .  	NUMBER	2000	
$P_SIMPLE_STRING . . . . . . . .  	N PROC	03A3	_TEXT	Length = 0025
$P_SIM_EXIT  . . . . . . . . . .  	L NEAR	03BE	_TEXT
$P_SIM_EXIT0 . . . . . . . . . .  	L NEAR	03C0	_TEXT
$P_SINGLE_EXIT . . . . . . . . .  	L NEAR	013C	_TEXT
$P_SI_SAVE . . . . . . . . . . .  	L WORD	0004	_DATA
$P_SKIP_DELIM  . . . . . . . . .  	N PROC	0634	_TEXT	Length = 0024
$P_SKIP_DELIM_CY . . . . . . . .  	L NEAR	0650	_TEXT
$P_SKIP_DELIM_EXIT . . . . . . .  	L NEAR	0654	_TEXT
$P_SKIP_DELIM_LOOP . . . . . . .  	L NEAR	0634	_TEXT
$P_SKIP_DELIM_NCY  . . . . . . .  	L NEAR	0653	_TEXT
$P_SLASH . . . . . . . . . . . .  	NUMBER	002F	
$P_SNUM_VAL  . . . . . . . . . .  	NUMBER	4000	
$P_SPACE . . . . . . . . . . . .  	NUMBER	0020	
$P_START . . . . . . . . . . . .  	L NEAR	0035	_TEXT
$P_STRING  . . . . . . . . . . .  	NUMBER	0003	
$P_STRING_BUF  . . . . . . . . .  	L BYTE	0017	_DATA	Length = 0080
$P_STRING_BUF_END  . . . . . . .  	NEAR	0097	_DATA
$P_STRING_COMP . . . . . . . . .  	N PROC	03C8	_TEXT	Length = 009D
$P_STRUC_L1  . . . . . . . . . .  	L NEAR	0715	_TEXT
$P_STRUC_L12 . . . . . . . . . .  	L NEAR	0714	_TEXT
$P_STRUC_L2  . . . . . . . . . .  	L NEAR	070B	_TEXT
$P_STRUC_L5  . . . . . . . . . .  	L NEAR	0708	_TEXT
$P_STRUC_L7  . . . . . . . . . .  	L NEAR	0705	_TEXT
$P_SW  . . . . . . . . . . . . .  	NUMBER	0040	
$P_SWITCH  . . . . . . . . . . .  	NUMBER	002F	
$P_SW_CMP  . . . . . . . . . . .  	NUMBER	0010	
$P_SW_MANAGER  . . . . . . . . .  	L NEAR	00C8	_TEXT
$P_SW_MGR_LOOP . . . . . . . . .  	L NEAR	00DD	_TEXT
$P_SW_NOT_FOUND  . . . . . . . .  	L NEAR	00EB	_TEXT
$P_SYNTAX  . . . . . . . . . . .  	NUMBER	0009	
$P_TAB . . . . . . . . . . . . .  	NUMBER	0009	
$P_TERMINATOR  . . . . . . . . .  	L BYTE	0008	_DATA
$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	00C0	_TEXT
@CPU . . . . . . . . . . . . . .  	TEXT  0101h		
@FILENAME  . . . . . . . . . . .  	TEXT  _parse		
@VERSION . . . . . . . . . . . .  	TEXT  510		
_parse . . . . . . . . . . . . .  	N PROC	0767	_TEXT	Global	Length = 0042

Microsoft (R) Macro Assembler Version 5.10                  2/14/25 23:44:30

C	to PARSER interface                                       Symbols-8






   3597 Source  Lines
   3597 Total   Lines
    355 Symbols

  46334 + 253432 Bytes symbol space free

      0 Warning Errors
      0 Severe  Errors
