;	This routine is the state table for the call to LIB$TPARSE which
;	parses the commands entered at the HEX> prompt.  It in essence,
;	drives the entire program because it calls the appropriate routines
;	based on the user's input.
;
	.TITLE		HEXPARSER	HEX state table for LIB$TPARSE

	.ENABLE	GLOBAL				; look to the PASCAL routines
						; for undefined symbols

	APOSTROPHE	= ^X27		; Define constants
	ASTERISK	= ^X2A
	SEMICOLON	= ^X3B
	TILDE		= ^X7E


	$INIT_STATE	HEX_PARSE_STATE,HEX_PARSE_KEY

	$STATE	START

	$TRAN	TPA$_EOS, TPA$_EXIT		; null string is valid

	; Initial key words

	$TRAN	'ADDRESSING',	ADDRESS_STATE
	$TRAN	'AND',		AND_STATE,	RESET_RANGE,,,0
	$TRAN	'APPEND',	APPEND_STATE,	RESET_RANGE,,,0
	$TRAN	'COMPARE',	READ_STATE,	RESET_RANGE,,,3
	$TRAN	'COMPLEMENT',	COMP_STATE,	RESET_RANGE,,,0
	$TRAN	'COPY',		COPY_STATE,	RESET_RANGE,,,0
	$TRAN	'CRC',		CRC_STATE,	RESET_RANGE,,,0
	$TRAN	'CSUM',		CSUM_STATE,	RESET_RANGE,,,0
	$TRAN	'DECREMENT',	DEC_STATE,	RESET_RANGE,,,1
	$TRAN	'DISPLAY',	DISPLAY_STATE,	RESET_RANGE,,,0
	$TRAN	'DIVIDE',	DIVIDE_STATE,	RESET_RANGE,,,1
	$TRAN	'ECHO',		TPA$_EXIT,	DO_ECHO
	$TRAN	'EDIT',		EDIT_STATE,	RESET_RANGE,,,0
	$TRAN	'EXIT',        	TPA$_EXIT,	DO_EXIT
	$TRAN	'FILL',		FILL_STATE,	RESET_RANGE,,,0
	$TRAN	'FORMAT',	FORMAT_STATE
	$TRAN	'HELP',		HELP_STATE
	$TRAN	'IDENT',	TPA$_EXIT,	DO_IDENT
	$TRAN	'INCREMENT',	INC_STATE,	RESET_RANGE,,,1
	$TRAN	'INIT',		INIT_COMMAND_STATE,	RESET_RANGE,,,2
	$TRAN	'MOVE',		MOVE_STATE,	RESET_RANGE,,,0
	$TRAN	'MULTIPLY',	MULT_STATE,	RESET_RANGE,,,0
	$TRAN	'NAME',		NAME_STATE
	$TRAN	'NEGATE',  	NEG_STATE,	RESET_RANGE,,,0
	$TRAN	'NOECHO',	TPA$_EXIT,	DO_NOECHO
	$TRAN	'OFFSET',	OFFSET_STATE
	$TRAN	'OR',		OR_STATE,	RESET_RANGE,,,0
	$TRAN	'READ',		READ_STATE,	RESET_RANGE,,,4
	$TRAN	'REVERSE',	REVERSE_STATE,	RESET_RANGE,,,0
	$TRAN	'REMAINDER',	REMAINDER_STATE,RESET_RANGE,,,1
	$TRAN	'ROTATE',   	ROTATE_STATE,	RESET_RANGE,,,1
	$TRAN	'SEARCH',	SEARCH_STATE,	RESET_RANGE,,,0
	$TRAN	'SHIFT',	SHIFT_STATE,	RESET_RANGE,,,1
	$TRAN	'SUM',		SUM_STATE,	RESET_RANGE,,,0
	$TRAN	'TRANSFER',	TRANSFER_STATE
	$TRAN	'USE',		USE_STATE,	RESET_RANGE,,,0
	$TRAN	'WRITE',   	WRITE_STATE,	RESET_RANGE,,,0
	$TRAN	'XOR',		XOR_STATE,	RESET_RANGE,,,0
	$TRAN	'.',		TPA$_EXIT,	DO_CLI
	$TRAN	'$',		TPA$_EXIT,	DO_CLI
	$TRAN	'@',		TPA$_EXIT,	DO_COMMAND_FILE
	$TRAN	'?',		HELP_STATE
	$TRAN	SEMICOLON,	TPA$_EXIT
	$TRAN	ASTERISK,	TPA$_EXIT,	DISPLAY_COMMENT

	$END_STATE


	;***********************************************************************
        ;
	;			Get Range Parameters Subexpression
	;
	;***********************************************************************

	$STATE	RANGE_STATE	; check for ODD or EVEN keyword

	$TRAN	'ODD',		RANGE_STATE_1,SET_ODD_EVEN,,,1
	$TRAN	'EVEN',		RANGE_STATE_1,SET_ODD_EVEN,,,2
	$TRAN	TPA$_LAMBDA,	RANGE_STATE_1

      	$END_STATE

	$STATE	RANGE_STATE_1	; look for FROM

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'FROM',		RANGE_STATE_2

	$END_STATE


	$STATE	RANGE_STATE_2	; look for a legal address for FROM

	$TRAN	'LOW',		RANGE_STATE_3, SET_HIGH_LOW,,,1
	$TRAN	'HIGH',		RANGE_STATE_3, SET_HIGH_LOW,,,2
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	RANGE_STATE_3, CHECK_ADDRESS,,,1

	$END_STATE


	$STATE	RANGE_STATE_3	; look for THRU

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'THRU',		RANGE_STATE_4

	$END_STATE


	$STATE	RANGE_STATE_4	; look for a legal address for THRU

	$TRAN	'LOW',		RANGE_STATE_5, SET_HIGH_LOW,,,3
	$TRAN	'HIGH',		RANGE_STATE_5, SET_HIGH_LOW,,,4
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	RANGE_STATE_5, CHECK_ADDRESS,,,2

	$END_STATE


	$STATE	RANGE_STATE_5	; look for STEP

	$TRAN	'STEP',		RANGE_STATE_6
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT

	$END_STATE


	$STATE	RANGE_STATE_6	; look for step param

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	TPA$_EXIT, SET_STEP

	$END_STATE


	;***********************************************************************
        ;
	;			Get With/By Parameters Subexpression
	;
	;***********************************************************************

	$STATE WITH_STATE	; look for a valid WITH/BY character

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	TPA$_EXIT, SET_WITH,,,1
	$TRAN	'^',		WITH_STATE_1
	$TRAN	APOSTROPHE,	WITH_STATE_2,TURN_ON_BLANKS
	$TRAN	TILDE,		WITH_STATE_3
	$TRAN	'-',		WITH_STATE_4,TURN_ON_BLANKS

	$END_STATE


	$STATE WITH_STATE_1	; by character ^c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'#',		TPA$_EXIT, SET_WITH,,,2
	$TRAN	TPA$_ANY,	TPA$_EXIT, SET_WITH,,,3

	$END_STATE


	$STATE WITH_STATE_2	; by character 'c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	TPA$_EXIT, SET_WITH,,,4

	$END_STATE


	$STATE WITH_STATE_3	; by character ~c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'#',		TPA$_EXIT, SET_WITH,,,5
	$TRAN	TPA$_ANY,	TPA$_EXIT, SET_WITH,,,6

	$END_STATE


	$STATE WITH_STATE_4	; by character -c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	TPA$_EXIT, SET_WITH,,,7

	$END_STATE


	;***********************************************************************
        ;
	;	Process PLUS/MINUS thru PARTIAL Subexpression for READ and WRITE
	;
	;***********************************************************************

	$STATE	PLUS_PARTIAL

	$TRAN	'PLUS',		PLUS_PARTIAL_1, SET_PLUS_MINUS,,,1
	$TRAN	'MINUS',	PLUS_PARTIAL_1, SET_PLUS_MINUS,,,2
	$TRAN	TPA$_LAMBDA,	PLUS_PARTIAL_2

	$END_STATE


	$STATE	PLUS_PARTIAL_1

	$TRAN	TPA$_HEX,	PLUS_PARTIAL_2, SET_PLUS_MINUS,,,3

	$END_STATE


	$STATE	PLUS_PARTIAL_2

	$TRAN	'PARTIAL',	TPA$_EXIT, SET_PARTIAL
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT

	$END_STATE


	;***********************************************************************
	;
	;	     		Get WIDTH Subexpression
	;
	;***********************************************************************

	$STATE	WIDTH_STATE		; look for WIDTH

	$TRAN	'WIDTH',	WIDTH_STATE_1
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT

	$END_STATE


	$STATE	WIDTH_STATE_1		; get the WIDTH parameter

	$TRAN	TPA$_HEX,	TPA$_EXIT, SET_WIDTH

	$END_STATE


	;***********************************************************************
	;
	;	     		Get FILE Spec Subexpression
	;
	;***********************************************************************

	$STATE	FILE_STATE		; look for FILE

	$TRAN	'FILE',		FILE_STATE_1

	$END_STATE


	$STATE	FILE_STATE_1		; get file spec

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	FILE_STATE_2,SET_FILE_SPEC,,,0

	$END_STATE


	$STATE	FILE_STATE_2

	$TRAN	TPA$_EOS,	TPA$_EXIT
	$TRAN	TPA$_BLANK,	TPA$_EXIT
	$TRAN	TPA$_ANY,	FILE_STATE_2,SET_FILE_SPEC,,,1

	$END_STATE


	;***********************************************************************
        ;
	;			Process ADDRESSING MODE Command
	;
	;***********************************************************************

	$STATE	ADDRESS_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'MODE',		ADDRESS_STATE_1

	$END_STATE

	$STATE	ADDRESS_STATE_1

	$TRAN	TPA$_EOS,	TPA$_EXIT, SHOW_MODE
	$TRAN	'16',		TPA$_EXIT, SET_MODE,,,1
	$TRAN	'24',		TPA$_EXIT, SET_MODE,,,2
	$TRAN	'32',		TPA$_EXIT, SET_MODE,,,3

	$END_STATE
	

	;***********************************************************************
        ;
	;	   		Process AND Command
	;
	;***********************************************************************

	$STATE	AND_STATE	; get command range

	$TRAN	!RANGE_STATE,	AND_STATE_1

      	$END_STATE


	$STATE	AND_STATE_1	; look for WITH

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'WITH',		AND_STATE_2

	$END_STATE


	$STATE	AND_STATE_2	; get WITH Param

	$TRAN	!WITH_STATE,	AND_STATE_FINAL

      	$END_STATE


	$STATE AND_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_AND

	$END_STATE


	;***********************************************************************
        ;
	;			Process APPEND Command
	;
	;***********************************************************************


	$STATE	APPEND_STATE	; get command range

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	!RANGE_STATE,	APPEND_STATE_1

      	$END_STATE


	$STATE	APPEND_STATE_1	; look for PLUS/MINUS and PARTIAL

	$TRAN	!PLUS_PARTIAL,	APPEND_STATE_2
	$TRAN	TPA$_LAMBDA,	APPEND_STATE_2

	$END_STATE


	$STATE	APPEND_STATE_2	; look for PLUS/MINUS and PARTIAL

	$TRAN	!WIDTH_STATE,	APPEND_STATE_3
	$TRAN	TPA$_LAMBDA,	APPEND_STATE_3

	$END_STATE


	$STATE	APPEND_STATE_3    ; look for FILE spec

	$TRAN	!FILE_STATE,	TPA$_EXIT, DO_APPEND

	$END_STATE


	;***********************************************************************
        ;
	;			Process COMPLEMENT Command
	;
	;***********************************************************************


	$STATE	COMP_STATE	; get command range

	$TRAN	!RANGE_STATE,	COMP_STATE_FINAL

      	$END_STATE


	$STATE COMP_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_COMPLEMENT

	$END_STATE


	;***********************************************************************
        ;
	;			Process COPY Command
	;
	;***********************************************************************

	$STATE	COPY_STATE	; Get command range

	$TRAN	!RANGE_STATE,	COPY_STATE_1

	$END_STATE


	$STATE	COPY_STATE_1	; look for TO

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'TO',		COPY_STATE_2

	$END_STATE


	$STATE	COPY_STATE_2	; look for TO param

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	COPY_STATE_3, CHECK_ADDRESS,,,3

	$END_STATE


	$STATE	COPY_STATE_3   	; look for REPEAT

	$TRAN	TPA$_EOS,	COPY_STATE_FINAL
	$TRAN	'REPEAT',	COPY_STATE_4
	$TRAN	TPA$_LAMBDA,	COPY_STATE_FINAL

	$END_STATE


	$STATE	COPY_STATE_4	; look for REPEAT param

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	COPY_STATE_FINAL, SET_REPEAT

	$END_STATE


	$STATE	COPY_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_COPY

	$END_STATE


	;***********************************************************************
        ;
	;	    		Process CRC Command
	;
	;***********************************************************************

	$STATE	CRC_STATE  	; get command range

	$TRAN	!RANGE_STATE,	CRC_STATE_1

      	$END_STATE

                
	$STATE	CRC_STATE_1

	$TRAN	TPA$_EOS,	TPA$_EXIT, DO_CRC
	$TRAN	'TO',		CRC_STATE_2
	$TRAN	TPA$_LAMBDA,	CRC_STATE_4

	$END_STATE


	$STATE	CRC_STATE_2

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	CRC_STATE_4,CHECK_ADDRESS,,,3
	$TRAN	'%',		CRC_STATE_3,SET_PSEUDO,,,1

	$END_STATE


	$STATE	CRC_STATE_3

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	CRC_STATE_4,CHECK_ADDRESS,,,3

	$END_STATE


	$STATE	CRC_STATE_4

	$TRAN	TPA$_EOS,	TPA$_EXIT, DO_CRC
	$TRAN	'EXPECTING',	CRC_STATE_5

	$END_STATE


	$STATE	CRC_STATE_5

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	CRC_STATE_FINAL, SET_EXPECTING

	$END_STATE

                                           
	$STATE	CRC_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_CRC

	$END_STATE


	;***********************************************************************
        ;
	;			Process CSUM Command
	;
	;***********************************************************************

	$STATE	CSUM_STATE  	; get command range

	$TRAN	!RANGE_STATE,	CSUM_STATE_FINAL

      	$END_STATE


	$STATE	CSUM_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_CSUM

	$END_STATE


	;***********************************************************************
        ;
	;			Process DECREMENT Command
	;
	;***********************************************************************

	$STATE	DEC_STATE	; get command range

 	$TRAN	!RANGE_STATE,	DEC_STATE_1

      	$END_STATE


	$STATE	DEC_STATE_1	; look for BY

	$TRAN	TPA$_EOS,	DEC_STATE_FINAL
	$TRAN	'BY',		DEC_STATE_2

	$END_STATE


	$STATE DEC_STATE_2	; look for a valid decrement character

	$TRAN	!WITH_STATE,	DEC_STATE_FINAL

	$END_STATE


	$STATE DEC_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_DECREMENT

	$END_STATE


	;***********************************************************************
        ;
	;			Process DIVIDE Command
	;
	;***********************************************************************

	$STATE	DIVIDE_STATE	; check for SIGNED keyword

	$TRAN	'SIGNED',	DIV_STATE_1,SET_SIGNED
	$TRAN	TPA$_LAMBDA,	DIV_STATE_1

      	$END_STATE


	$STATE	DIV_STATE_1	; get command range

	$TRAN	!RANGE_STATE,	DIV_STATE_2

      	$END_STATE

	$STATE	DIV_STATE_2	; look for 'BY'

	$TRAN	'BY',		DIV_STATE_3
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE

	$END_STATE


	$STATE DIV_STATE_3	; look for a valid divide character

	$TRAN	!WITH_STATE,	DIV_STATE_FINAL

	$END_STATE


	$STATE DIV_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_DIVIDE

	$END_STATE


	;***********************************************************************
        ;
	;			Process DISPLAY Command
	;
	;***********************************************************************

	$STATE	DISPLAY_STATE		; look for ASCII

	$TRAN	'ASCII',	DISPLAY_STATE_1, SET_ASCII
	$TRAN	TPA$_LAMBDA,	DISPLAY_STATE_1

	$END_STATE


	$STATE	DISPLAY_STATE_1		; get command range

	$TRAN	'PSEUDO',	TPA$_EXIT,DO_DISPLAY_PSEUDO
	$TRAN	'HIGH',		TPA$_EXIT,DO_DISPLAY_HILOW
	$TRAN	'LOW',		TPA$_EXIT,DO_DISPLAY_HILOW
	$TRAN	!RANGE_STATE,	DISPLAY_STATE_2

	$END_STATE


	$STATE	DISPLAY_STATE_2		; look for FILE

	$TRAN	!FILE_STATE,	DISPLAY_STATE_FINAL
	$TRAN	TPA$_LAMBDA,	DISPLAY_STATE_FINAL

	$END_STATE


	$STATE	DISPLAY_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_DISPLAY

	$END_STATE


	;***********************************************************************
        ;
	;    			Process EDIT Command
	;
	;***********************************************************************

	$STATE	EDIT_STATE		; look for edit address

	$TRAN	'LOW',		EDIT_STATE_1, SET_HIGH_LOW,,,1
	$TRAN	'HIGH',		EDIT_STATE_1, SET_HIGH_LOW,,,2
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	EDIT_STATE_1, CHECK_ADDRESS,,,1

	$END_STATE


	$STATE	EDIT_STATE_1	; look for STEP

	$TRAN	'STEP',		EDIT_STATE_2
	$TRAN	TPA$_LAMBDA,	EDIT_STATE_FINAL

	$END_STATE


	$STATE	EDIT_STATE_2	; look for step param

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	EDIT_STATE_FINAL, SET_STEP

	$END_STATE


	$STATE	EDIT_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_EDIT

	$END_STATE


	;***********************************************************************
        ;
	;			Process FILL Command
	;
	;***********************************************************************

	$STATE	FILL_STATE	; get command range

	$TRAN	!RANGE_STATE,	FILL_STATE_1

      	$END_STATE

	$STATE	FILL_STATE_1	; look for WITH

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'WITH',		FILL_STATE_2

	$END_STATE


	$STATE FILL_STATE_2	; look for a valid fill character

	$TRAN	!WITH_STATE,	FILL_STATE_FINAL

	$END_STATE


	$STATE FILL_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_FILL

	$END_STATE


	;***********************************************************************
        ;
	;			Process FORMAT Command
	;
	;***********************************************************************

	$STATE	FORMAT_STATE		; valid format keywords

	$TRAN 	TPA$_EOS,	TPA$_EXIT, SHOW_FORMAT
	$TRAN	'INTEL',	TPA$_EXIT, SET_FORMAT,,,1
	$TRAN	'MOTOROLA',	TPA$_EXIT, SET_FORMAT,,,2
	$TRAN	'ROCKWELL',	TPA$_EXIT, SET_FORMAT,,,3
	$TRAN	'RCA',		TPA$_EXIT, SET_FORMAT,,,4
	$TRAN	'TEKHEX',	TPA$_EXIT, SET_FORMAT,,,5
	$TRAN	'EXTENDED',	EXTENDED_FORMAT
	$TRAN	'TEXAS',	TPA$_EXIT, SET_FORMAT,,,7
	$TRAN	'MOSTEK',   	TPA$_EXIT, SET_FORMAT,,,8
	$TRAN	'TCI',		TPA$_EXIT, SET_FORMAT,,,14
	$TRAN	'FAIRCHILD',	TPA$_EXIT, SET_FORMAT,,,15

	$END_STATE

	$STATE	EXTENDED_FORMAT		; check for Extended Tekhex Format

	$TRAN	TPA$_EOS,	TPA$_EXIT, SET_FORMAT,,,6
	$TRAN	'TEKHEX',	TPA$_EXIT, SET_FORMAT,,,6

	$END_STATE


	;***********************************************************************
        ;
	;			Process HELP Command
	;
	;***********************************************************************

	$STATE	HELP_STATE		; request for help

	$TRAN	TPA$_EOS,	TPA$_EXIT, DO_HELP
	$TRAN	TPA$_SYMBOL,	TPA$_EXIT, DO_HELP
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, HELP_ERROR

	$END_STATE


	;***********************************************************************
        ;
	;			Process INCREMENT Command
	;
	;***********************************************************************

	$STATE	INC_STATE	; get command range

	$TRAN	!RANGE_STATE,	INC_STATE_1

      	$END_STATE


	$STATE	INC_STATE_1	; look for BY

	$TRAN	TPA$_EOS,	INC_STATE_FINAL
	$TRAN	'BY',		INC_STATE_2

	$END_STATE


	$STATE INC_STATE_2	; look for a valid increment character

	$TRAN	!WITH_STATE,	INC_STATE_FINAL

	$END_STATE


	$STATE INC_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_INCREMENT

	$END_STATE


	;***********************************************************************
        ;
	;			Process INIT Command
	;
	;***********************************************************************

	$STATE	INIT_COMMAND_STATE

	$TRAN	'WITH',		INIT_COMMAND_STATE_1
	$TRAN	TPA$_EOS,	INIT_COMMAND_STATE_FINAL

	$END_STATE


	$STATE	INIT_COMMAND_STATE_1

	$TRAN	!WITH_STATE,	INIT_COMMAND_STATE_FINAL

	$END_STATE


	$STATE	INIT_COMMAND_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT,DO_INIT

	$END_STATE


	;***********************************************************************
        ;
	;			Process MOVE Command
	;
	;***********************************************************************

	$STATE	MOVE_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'BYTE',		MOVE_STATE_1,	SET_MOVE_SIZE,,,0
	$TRAN	'WORD',		MOVE_STATE_1,	SET_MOVE_SIZE,,,1

	$END_STATE


	$STATE	MOVE_STATE_1

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'FROM',		MOVE_STATE_2

	$END_STATE


	$STATE	MOVE_STATE_2

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	MOVE_STATE_4,CHECK_ADDRESS,,,1
	$TRAN	'%',		MOVE_STATE_3,SET_PSEUDO,,,0

	$END_STATE


	$STATE	MOVE_STATE_3

	$TRAN	TPA$_EOS,	TPA$_EXIT,INCOMPLETE
	$TRAN	TPA$_HEX,	MOVE_STATE_4,CHECK_ADDRESS,,,1

	$END_STATE


	$STATE	MOVE_STATE_4

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'TO',		MOVE_STATE_5

	$END_STATE


	$STATE	MOVE_STATE_5

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	MOVE_STATE_FINAL,CHECK_ADDRESS,,,3
	$TRAN	'%',		MOVE_STATE_6,SET_PSEUDO,,,1

	$END_STATE


	$STATE	MOVE_STATE_6

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	MOVE_STATE_FINAL,CHECK_ADDRESS,,,3

	$END_STATE


	$STATE	MOVE_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT,DO_MOVE

	$END_STATE


	;***********************************************************************
        ;
	;			Process MULTIPLY Command
	;
	;***********************************************************************

	$STATE	MULT_STATE	; get command range

	$TRAN	!RANGE_STATE,	MULT_STATE_1

      	$END_STATE


	$STATE	MULT_STATE_1	; look for BY

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'BY',		MULT_STATE_2

	$END_STATE

	$STATE MULT_STATE_2	; look for a valid multiply character

	$TRAN	!WITH_STATE,	MULT_STATE_FINAL

	$END_STATE


	$STATE MULT_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_MULTIPLY

	$END_STATE


	;***********************************************************************
        ;
	;			Process NAME Command
	;
	;***********************************************************************

	$STATE	NAME_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, SHOW_NAME
	$TRAN	TPA$_ANY,	NAME_BUILD, BUILD_NAME,,,0

	$END_STATE


	$STATE	NAME_BUILD

	$TRAN	TPA$_EOS,	TPA$_EXIT, SET_NAME
	$TRAN	TPA$_BLANK,	TPA$_EXIT, SET_NAME
	$TRAN	TPA$_ANY,	NAME_BUILD, BUILD_NAME,,,1

	$END_STATE


	;***********************************************************************
        ;
	;			Process NEGATE Command
	;
	;***********************************************************************


	$STATE	NEG_STATE	; get command range

	$TRAN	!RANGE_STATE,	NEG_STATE_FINAL

      	$END_STATE


	$STATE NEG_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_NEGATE

	$END_STATE


	;***********************************************************************
        ;
	;			Process OFFSET Command
	;
	;***********************************************************************

	$STATE	OFFSET_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, SHOW_OFFSET
	$TRAN	TPA$_HEX,	TPA$_EXIT, SET_OFFSET
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, HEX_ERROR

	$END_STATE


	;***********************************************************************
        ;
	;			Process OR Command
	;
	;***********************************************************************

	$STATE	OR_STATE	; get command range

	$TRAN	!RANGE_STATE,	OR_STATE_1

      	$END_STATE


	$STATE OR_STATE_1	; look for WITH

	$TRAN	'WITH',		OR_STATE_2
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE

	$END_STATE


	$STATE OR_STATE_2	;  look for a valid OR character

	$TRAN	!WITH_STATE,	OR_STATE_FINAL

	$END_STATE


	$STATE OR_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_OR

	$END_STATE


	;***********************************************************************
        ;
	;			Process READ Command
	;
	;***********************************************************************


	$STATE	READ_STATE	; get command range

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	!RANGE_STATE,	READ_STATE_1
	$TRAN	TPA$_LAMBDA,	READ_STATE_1

      	$END_STATE


	$STATE	READ_STATE_1	; look for PLUS/MINUS and PARTIAL

	$TRAN	'WITH',		READ_STATE_3, CHECK_COMPARE_WITH
	$TRAN	!PLUS_PARTIAL,	READ_STATE_2
	$TRAN	TPA$_LAMBDA,	READ_STATE_2

	$END_STATE


 	$STATE	READ_STATE_2    ; look for FILE spec

	$TRAN	!FILE_STATE,	TPA$_EXIT, DO_READ

	$END_STATE


	$STATE	READ_STATE_3    ; look for FILE spec

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	TPA$_EXIT, DO_COMPARE

	$END_STATE


	;***********************************************************************
        ;
	;			Process REMAINDER Command
	;
	;***********************************************************************

	$STATE	REMAINDER_STATE	; check for SIGNED keyword

	$TRAN	'SIGNED',	REMAIN_STATE_1, SET_SIGNED
	$TRAN	TPA$_LAMBDA,	REMAIN_STATE_1

      	$END_STATE


	$STATE	REMAIN_STATE_1	; get command range

	$TRAN	!RANGE_STATE,	REMAIN_STATE_2

      	$END_STATE


	$STATE	REMAIN_STATE_2	; look for 'BY'

	$TRAN	'BY',		REMAIN_STATE_3
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE

	$END_STATE


	$STATE REMAIN_STATE_3	; look for a valid remainder character

	$TRAN	!WITH_STATE,	REMAIN_STATE_FINAL

	$END_STATE


	$STATE REMAIN_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_REMAINDER

	$END_STATE


	;***********************************************************************
        ;
	;			Process REVERSE Command
	;
	;***********************************************************************

	$STATE	REVERSE_STATE	; get command range

	$TRAN	!RANGE_STATE,	REV_STATE_FINAL

      	$END_STATE


	$STATE	REV_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_REVERSE

	$END_STATE


	;***********************************************************************
        ;
	;			Process ROTATE Command
	;
	;***********************************************************************

	$STATE	ROTATE_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'LEFT',		ROT_STATE_1,SET_DIRECTION,,,0
	$TRAN	'RIGHT',	ROT_STATE_1,SET_DIRECTION,,,1

	$END_STATE

	$STATE	ROT_STATE_1	; get command range

	$TRAN	!RANGE_STATE,	ROT_STATE_2

      	$END_STATE


	$STATE ROT_STATE_2	; look for 'BY'

	$TRAN	'BY', 		ROT_STATE_3
	$TRAN	TPA$_EOS,	ROT_STATE_FINAL

	$END_STATE


	$STATE	ROT_STATE_3	; look for a valid rotate character

	$TRAN	!WITH_STATE,	ROT_STATE_FINAL

	$END_STATE


	$STATE ROT_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_ROTATE

	$END_STATE


	;***********************************************************************
        ;
	;	    		Process SEARCH Command
	;
	;***********************************************************************

	$STATE	SEARCH_STATE		; get command range

	$TRAN	!RANGE_STATE,	SEARCH_STATE_1

	$END_STATE


	$STATE	SEARCH_STATE_1		; look for FOR

	$TRAN	'FOR',		SEARCH_STATE_2
	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE

	$END_STATE


	$STATE	SEARCH_STATE_2		; look for NOT

	$TRAN	'NOT',		SEARCH_STATE_3, SET_NOT
	$TRAN	TPA$_LAMBDA,	SEARCH_STATE_3

	$END_STATE


	$STATE	SEARCH_STATE_3		; look for search character(s)

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	SEARCH_STATE_FINAL, SET_SEARCH,,,1
	$TRAN	'^',		SEARCH_STATE_4
	$TRAN	APOSTROPHE,	SEARCH_STATE_5,TURN_ON_BLANKS
	$TRAN	TILDE,		SEARCH_STATE_6
	$TRAN	'-',		SEARCH_STATE_7,TURN_ON_BLANKS
	$TRAN	'"',		SEARCH_STATE_8,TURN_ON_BLANKS

	$END_STATE


	$STATE	SEARCH_STATE_4	; by character ^c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'#',		SEARCH_STATE_FINAL, SET_SEARCH,,,2
	$TRAN	TPA$_ANY,	SEARCH_STATE_FINAL, SET_SEARCH,,,3

	$END_STATE


	$STATE	SEARCH_STATE_5	; by character 'c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	SEARCH_STATE_FINAL, SET_SEARCH,,,4

	$END_STATE


	$STATE	SEARCH_STATE_6	; by character ~c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'#',		SEARCH_STATE_FINAL, SET_SEARCH,,,5
	$TRAN	TPA$_ANY,	SEARCH_STATE_FINAL, SET_SEARCH,,,6

	$END_STATE


	$STATE	SEARCH_STATE_7	; by character -c

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	SEARCH_STATE_FINAL, SET_SEARCH,,,7

	$END_STATE


	$STATE	SEARCH_STATE_8	; look for first printing character

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	SEARCH_STATE_9, SET_SEARCH,,,8

	$END_STATE


	$STATE	SEARCH_STATE_9	; look for second printing character

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_ANY,	SEARCH_STATE_10, SET_SEARCH,,,9

	$END_STATE


	$STATE	SEARCH_STATE_10	; look for the second double quote

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'"',		SEARCH_STATE_FINAL

	$END_STATE


	$STATE	SEARCH_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_SEARCH

	$END_STATE


	;***********************************************************************
        ;
	;	    		Process SHIFT Command
	;
	;***********************************************************************

	$STATE	SHIFT_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'LEFT',		SHIFT_STATE_1,SET_DIRECTION,,,0
	$TRAN	'RIGHT',	SHIFT_STATE_1,SET_DIRECTION,,,1

	$END_STATE


	$STATE	SHIFT_STATE_1

	$TRAN	'SIGNED',	SHIFT_STATE_2,SET_SIGNED
	$TRAN	TPA$_LAMBDA,	SHIFT_STATE_2

	$END_STATE


	$STATE	SHIFT_STATE_2	; get command range

	$TRAN	!RANGE_STATE,	SHIFT_STATE_3

      	$END_STATE

	$STATE	SHIFT_STATE_3	; look for BY

	$TRAN	'BY',	      	SHIFT_STATE_4
	$TRAN	TPA$_EOS,	TPA$_EXIT, SHIFT_STATE_FINAL

	$END_STATE


	$STATE	SHIFT_STATE_4	; look for a valid shift character

	$TRAN	!WITH_STATE,	SHIFT_STATE_FINAL

	$END_STATE


	$STATE SHIFT_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_SHIFT

	$END_STATE


	;***********************************************************************
        ;
	;	    		Process SUM Command
	;
	;***********************************************************************

	$STATE	SUM_STATE  	; get command range

	$TRAN	!RANGE_STATE,	SUM_STATE_1

      	$END_STATE


	$STATE	SUM_STATE_1

	$TRAN	TPA$_EOS,	TPA$_EXIT, DO_SUM
	$TRAN	'TO',		SUM_STATE_2
	$TRAN	TPA$_LAMBDA,	SUM_STATE_4

	$END_STATE


	$STATE	SUM_STATE_2

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	SUM_STATE_4,CHECK_ADDRESS,,,3
	$TRAN	'%',		SUM_STATE_3,SET_PSEUDO,,,1

	$END_STATE


	$STATE	SUM_STATE_3

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	SUM_STATE_4,CHECK_ADDRESS,,,3

	$END_STATE


	$STATE	SUM_STATE_4

	$TRAN	TPA$_EOS,	TPA$_EXIT, DO_SUM
	$TRAN	'EXPECTING',	SUM_STATE_5

	$END_STATE


	$STATE	SUM_STATE_5

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	SUM_STATE_FINAL, SET_EXPECTING

	$END_STATE


	$STATE	SUM_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_SUM

	$END_STATE


	;***********************************************************************
        ;
	;			Process TRANSFER Command
	;
	;***********************************************************************

	$STATE	TRANSFER_STATE

	$TRAN	TPA$_EOS,	TPA$_EXIT, SHOW_TRANSFER
	$TRAN	TPA$_HEX,	TPA$_EXIT, SET_TRANSFER
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, HEX_ERROR

	$END_STATE


	;***********************************************************************
        ;
	;				USE Command
	;
	;***********************************************************************

	$STATE	USE_STATE	; look for first use parameter

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	USE_STATE_1, SET_USE,,,1

	$END_STATE


	$STATE	USE_STATE_1	; look for OF

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'OF',		USE_STATE_2

	$END_STATE


	$STATE	USE_STATE_2	; look for second use parameter

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	TPA$_HEX,	USE_STATE_3, SET_USE,,,2

	$END_STATE


	$STATE	USE_STATE_3

	$TRAN	'FOR',		USE_STATE_4
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT,CHECK_EXTRA_CHARS

	$END_STATE


	$STATE	USE_STATE_4

	$TRAN	'READ',		TPA$_EXIT, CHECK_EXTRA_CHARS
	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, CHECK_EXTRA_CHARS

	$END_STATE


	;***********************************************************************
        ;
	;			Process WRITE Command
	;
	;***********************************************************************


	$STATE	WRITE_STATE	; get command range

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	!RANGE_STATE,	WRITE_STATE_1

      	$END_STATE


	$STATE	WRITE_STATE_1	; look for PLUS/MINUS and PARTIAL

	$TRAN	!PLUS_PARTIAL,	WRITE_STATE_2
	$TRAN	TPA$_LAMBDA,	WRITE_STATE_2

	$END_STATE


	$STATE	WRITE_STATE_2	; look for PLUS/MINUS and PARTIAL

	$TRAN	!WIDTH_STATE,	WRITE_STATE_3
	$TRAN	TPA$_LAMBDA,	WRITE_STATE_3

	$END_STATE


	$STATE	WRITE_STATE_3    ; look for FILE spec

	$TRAN	!FILE_STATE,	TPA$_EXIT, DO_WRITE

	$END_STATE


	;***********************************************************************
        ;
	;				XOR Command
	;
	;***********************************************************************

	$STATE	XOR_STATE	; get command range

	$TRAN	!RANGE_STATE,	XOR_STATE_1

      	$END_STATE


	$END_STATE

	$STATE	XOR_STATE_1	; look for WITH

	$TRAN	TPA$_EOS,	TPA$_EXIT, INCOMPLETE
	$TRAN	'WITH',		XOR_STATE_2

	$END_STATE


	$STATE XOR_STATE_2	; look for a valid XOR character

	$TRAN	!WITH_STATE,	XOR_STATE_FINAL

	$END_STATE


	$STATE XOR_STATE_FINAL

	$TRAN	TPA$_LAMBDA,	TPA$_EXIT, DO_XOR

	$END_STATE


	.END