.TITLE	COMMAND Read and interpret command lines

	.ENABLE	SUPPRESSION

	.LIBRARY	'VFELIB'

	$TPADEF

	.PSECT	CODE,EXE,NOWRT
	.PAGE
	.SBTTL	GETCMD - Get command
  .globl getcmd
GETCMD:: .jsb_entry
100$:
	CLRB	HLPON
	MOVL	#25,OUTDSC
	TSTB	TAPFLG
	BEQL	110$
	BRW	200$
110$:
	MOVAL	SOLDSK1,R5
	TSTB	RMSFLG
	BNEQ	130$
	CMPL	BUFFCT,#1
	BNEQ	150$
	$FAO_S	CTRSTR=SOLDSK0,OUTLEN=OUTDSC,OUTBUF=OUTDSC,-
		P1=CURBLK
	BRW	300$
130$:
	TSTB	NRFLAG
	BEQL	140$
	$FAO_S	CTRSTR=SOLNEW,OUTLEN=OUTDSC,OUTBUF=OUTDSC,-
		P1=CURBCT
	BRW	300$
140$:
	TSTB	KEYFLG
	BEQL	150$
	MOVAL	SOLDSK2,R5
150$:
	$FAO_S	CTRSTR=(R5),OUTLEN=OUTDSC,OUTBUF=OUTDSC,-
		P1=CURBLK,P2=CURBCT
	BRB	300$
200$:
	TSTL	CURBCT
	BGTR	250$
	$FAO_S	CTRSTR=SOLTP0,OUTLEN=OUTDSC,OUTBUF=OUTDSC,-
		P1=CURFIL,P2=CURBLK
	BRB	300$
250$:
	$FAO_S	CTRSTR=SOLTP1,OUTLEN=OUTDSC,OUTBUF=OUTDSC,-
		P1=CURFIL,P2=CURBLK,P3=CURBCT
300$:
	INPUT	OUTDSC,OUT_BUFF,#80,FUNC
	CMPB	TSTATUS+2,#0
	BGTR	450$
	MOVL	#1,PARA1
	MOVAL	NEXT,JMPADR
	BRW	800$
450$:
	MOVZWL	TSTATUS+2,R3
	MOVAL	FUNC,R4
500$:
	CMPB	(R4),#^A/ /
	BNEQ	550$
	INCL	R4
	SOBGTR	R3,500$
	BRB	650$
550$:
	CMPB	(R4),#^A/a/
	BLSSU	600$
	CMPB	(R4),#^A/z/
	BGTRU	650$
	SUBB2	#^X20,(R4)
600$:
	CMPB	(R4),#^A/A/
	BLSS	650$
	CMPB	(R4),#^A/Z/
	BGTR	650$
	INCL	R4
	SOBGTR	R3,550$
650$:
	CLRL	JMPADR
	CLRL	MFLAG
	CLRL	SETMASK
	CLRL	SHOMASK
	CLRB	DPBFLG
	CLRB	RFLAG
	CLRB	LGFLAG
	CLRB	SBFLAG
	CLRB	POSFLG
	MOVL	#TPA$K_COUNT0,TPBLK+TPA$L_COUNT
	MOVL	#TPA$M_ABBRFM,TPBLK+TPA$L_OPTIONS
	MOVZWL	TSTATUS+2,TPBLK+TPA$L_STRINGCNT
	MOVAL	FUNC,TPBLK+TPA$L_STRINGPTR
	PUSHAL	VFE_KEY
	PUSHAL	VFE_STATE
	PUSHAL	TPBLK
	CALLS	#3,G^LIB$TPARSE
	BLBS	R0,700$
	BSBW	ERROUT
	BRW	100$
700$:
	CMPL	#0,JMPADR
	BNEQ	800$
	BRW	100$
800$:
	RSB
	.PAGE
	.SBTTL	FPARSE - Parse file spec w/qualifiers
	.globl fparse
FPARSE:: .jsb_entry
	MOVL	#TPA$K_COUNT0,TPBLK+TPA$L_COUNT
	MOVL	#TPA$M_ABBRFM,TPBLK+TPA$L_OPTIONS
	MOVZWL	DESC,TPBLK+TPA$L_STRINGCNT
	MOVL	DESC+4,TPBLK+TPA$L_STRINGPTR
	CLRW	FDESC
	CLRL	SETMASK
	PUSHAL	VFE_KEY
	PUSHAL	FP1
	PUSHAL	TPBLK
	CALLS	#3,G^LIB$TPARSE
	BLBS	R0,200$
	BSBW	ERROUT
	BRB	600$
200$:
	TSTB	OVRFLG
	BEQL	800$
	TSTB	WRTFLG
	BEQL	800$
	OUTMSG	#NWOL,NWOMSG
	CLRW	OVRWRT
600$:
	CLRL	R0
800$:
	RSB
	.PAGE
	.SBTTL	Parser state table
	.PSECT	PRSDATA,WRT,NOEXE,quad
COMMA=^A/,/
DQUOTE=^A/"/
SQUOTE=^A/'/
QUEST=^A/?/

	$INIT_STATE  VFE_STATE,VFE_KEY

	$STATE	BEGIN
	$TRAN	TPA$_DECIMAL,DEFGET,,,PARA1
	$TRAN	SQUOTE,DEFGET2,SPACON,,QCHAR
	$TRAN	DQUOTE,DEFGET2,SPACON,,QCHAR
	$TRAN	'ALPHA',PARAM2P,ALPHINIT
	$TRAN	'ASCII',PARAM2P,AINIT,ASCII,JMPADR
	$TRAN	'ADD',ADDPAR,ADDINI,ADD,JMPADR
	$TRAN	'BINARY',PARAM2P,AINIT,BINARY,JMPADR
	$TRAN	'CHANGE',CPARA,,CHANGE,JMPADR
	$TRAN	'CUT',PARAM2,CINIT,CUT,JMPADR
	$TRAN	'CREATE',CRPARA,CRINIT,CREATE,JMPADR
	$TRAN	'DIFFERENCES',PARAM2,DPINIT,DIFF,JMPADR
	$TRAN	'DATE',PARAM2P,DTINIT,DATE,JMPADR
	$TRAN	'DELETE',TSTEOS,,DELETE,JMPADR
	$TRAN	'EXIT',TSTEOS,,EXIT,JMPADR
	$TRAN	'EBCDIC',PARAM2P,AINIT,EBCDIC,JMPADR
	$TRAN	'EOF',TSTEOS,,EOF,JMPADR
	$TRAN	'FILE',FPARM
	$TRAN	'GET',GPARA
	$TRAN	'HEX',PARAM2P,AINIT,HEX,JMPADR
	$TRAN	'HELP',HLPPAR,,HELP,JMPADR
	$TRAN	'IBYTE',PARAM2P,AINIT,IBYTE,JMPADR
	$TRAN	'IWORD',PARAM2P,IWINIT,IWLDSP,JMPADR
	$TRAN	'ILONG',PARAM2P,ILINIT,IWLDSP,JMPADR
	$TRAN	'LOCATE',LPARA,,LOCATE,JMPADR
	$TRAN	'LGLOBAL',LPARA,LGINIT,LOCATE,JMPADR
	$TRAN	'LAST',TSTEOS,,LAST,JMPADR
	$TRAN	'LOCK',TSTEOS,,LOCK,JMPADR
	$TRAN	'MULTI',PARAM2P,AINIT,MULTI,JMPADR
	$TRAN	'MOVE',NPARA,NINIT,MOVE,JMPADR
	$TRAN	'NEXT',NPARA,NINIT,NEXT,JMPADR
	$TRAN	'PASTE',PARAM2,DPINIT,PASTE,JMPADR
	$TRAN	'PUT',TSTEOS,,PUTRMS,JMPADR
	$TRAN	'RECORD',PARAM2,RINIT,RECORD,JMPADR
	$TRAN	'REWIND',TSTEOS,,REWIND,JMPADR
	$TRAN	'SUBSTITUTE',SBPARA,,SUBSTITUTE,JMPADR
	$TRAN	'SET',SETPAR,UCASE
	$TRAN	'SHOW',SHOPAR,UCASE,SHOCMD,JMPADR
	$TRAN	'TOP',TSTEOS,,TOP,JMPADR
	$TRAN	'UPDATE',TSTEOS,,UPDRMS,JMPADR
	$TRAN	'WRITE',TSTEOS,,WRITEDISK,JMPADR
	$TRAN	'+',NPARA2,NINIT,NEXT,JMPADR
	$TRAN	'-',NPARA2,NINITM,NEXT,JMPADR
	$TRAN	TPA$_EOS,TPA$_EXIT,NINIT,NEXT,JMPADR
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,BDCOMM

	$STATE	DEFGET
	$TRAN	TPA$_EOS,TPA$_EXIT,,READ,JMPADR

	$STATE	DEFGET2
	$TRAN	TPA$_LAMBDA,QP2,UCASE,KEYREAD,JMPADR

	$STATE	PARAM2P
	$TRAN	'/',,UCASE
	$TRAN	TPA$_LAMBDA,PARAM2
	$STATE
	$TRAN	'PASTE',,PASTON
	$STATE	PARAM2
	$TRAN	TPA$_DECIMAL,,HEXTST,,PARA1
	$TRAN	TPA$_HEX,,,,PARA1
	$TRAN	COMMA,P2S2
	$TRAN	':',P2S3,RECCHK
	$TRAN	TPA$_EOS,TPA$_EXIT
	$STATE
	$TRAN	COMMA,P2S2
	$TRAN	':',P2S3,RECCHK
	$TRAN	TPA$_EOS,TPA$_EXIT,SINGLE
	$STATE	P2S2
	$TRAN	TPA$_DECIMAL,TSTEOS,,,PARA2
	$STATE	P2S3
	$TRAN	TPA$_DECIMAL,,HEXTST,,PARA2
	$TRAN	TPA$_HEX,,,,PARA2
	$STATE
	$TRAN	TPA$_EOS,TPA$_EXIT,OFFSET

	$STATE	GPARA
	$TRAN	'/',GP2
	$TRAN	TPA$_LAMBDA,,GINIT,READ,JMPADR
	$STATE
	$TRAN	TPA$_DECIMAL,TSTEOS,,,PARA1
	$TRAN	TPA$_EOS,TPA$_EXIT
	$STATE	GP2
	$TRAN	'KEY',,,KEYREAD,JMPADR
	$TRAN	'key',,,KEYREAD,JMPADR
	$TRAN	'RFA',GP3,,RFAREAD,JMPADR
	$TRAN	'rfa',GP3,,RFAREAD,JMPADR
	$STATE
	$TRAN	'=',QPARSE
	$TRAN	TPA$_LAMBDA,QPARSE
	$STATE	GP3
	$TRAN	'='
	$TRAN	TPA$_LAMBDA
	$STATE
	$TRAN	TPA$_DECIMAL,,,,PARA1
	$STATE
	$TRAN	':'
	$TRAN	COMMA
	$STATE
	$TRAN	TPA$_DECIMAL,TSTEOS,,,PARA2

	$STATE	NPARA
	$TRAN	'-',,NINITM
	$TRAN	'+'
	$TRAN	TPA$_LAMBDA
	$STATE	NPARA2
	$TRAN	TPA$_DECIMAL,,,,PARA1
	$TRAN	TPA$_LAMBDA
	$STATE
	$TRAN	TPA$_EOS,TPA$_EXIT,NEGATE

	$STATE	ADDPAR
	$TRAN	'-',,,1,MFLAG
	$TRAN	'+'
	$TRAN	TPA$_LAMBDA
	$STATE
	$TRAN	'H',HEXX
	$TRAN	'h',HEXX
	$TRAN	'0',OCT
	$TRAN	TPA$_DECIMAL,ADDP2,ACCUML
	$STATE	HEXX
	$TRAN	TPA$_HEX,ADDP2,ACCUML
	$STATE	OCT
	$TRAN	TPA$_OCTAL,ADDP2,ACCUML
	$STATE	ADDP2
	$TRAN	COMMA,ADDPAR
	$TRAN	TPA$_EOS,TPA$_EXIT
	
	$STATE	CRPARA
	$TRAN	'/',,UCASE
	$TRAN	TPA$_LAMBDA,CR2
	$STATE
	$TRAN	'PASTE',,CRPASTE
	$TRAN	'NULL',,,2,CRTYPE
	$STATE	CR2
	$TRAN	TPA$_DECIMAL,TSTEOS,HEXTST,,PARA1
	$TRAN	TPA$_HEX,TSTEOS,,,PARA1
	$TRAN	TPA$_EOS,TPA$_EXIT

	$STATE	CPARA
	$TRAN	TPA$_DECIMAL,,HEXTST,,PARA1
	$TRAN	TPA$_HEX,,,,PARA1
	$TRAN	'*',,CHGLOC
	$TRAN	TPA$_EOS,,CHGLOC
	$STATE
	$TRAN	TPA$_EOS,TPA$_EXIT,CNULL
	$TRAN	COMMA,QPARSE

	$STATE	SBPARA
	$TRAN	TPA$_EOS,TPA$_EXIT,SBNULL
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,GENDESC

	$STATE	LPARA
	$TRAN	TPA$_EOS,TPA$_EXIT,LNULL
	$TRAN	TPA$_LAMBDA,QPARSE

	$STATE	QPARSE
	$TRAN	TPA$_HEX,TSTEOS,CNUM
	$TRAN	'+',DECCL
	$TRAN	'-',DECCL,,1,MFLAG
	$TRAN	SQUOTE,,SPACON,,QCHAR
	$TRAN	DQUOTE,,SPACON,,QCHAR
	$STATE	QP2
	$TRAN	!QSTRING,,,,QDESC
	$STATE
	$TRAN	TPA$_EOS,TPA$_EXIT,CHKSTR
	$TRAN	TPA$_ANY,TSTEOS,CHKSTR

	$STATE	QSTRING
	$TRAN	TPA$_ANY,QSTRING,TESTQ
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE	DECCL
	$TRAN	TPA$_DECIMAL,TSTEOS,CDEC

	$STATE	FPARM
	$TRAN	QUEST,TSTEOS,,SHOFILE,JMPADR
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,GENDESC,GETFILE,JMPADR

	$STATE	HLPPAR
	$TRAN	TPA$_BLANK
	$TRAN	TPA$_LAMBDA
	$STATE
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,GENDESC

	$STATE	SETPAR
	$TRAN	!SETSUB,SP1
	$TRAN	'LENGTH',SP2
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,BDCOMM

	$STATE	SP1
	$TRAN	TPA$_EOS,TPA$_EXIT,,SETCMD,JMPADR

	$STATE	SP2
	$TRAN	'=',,,SETLEN,JMPADR
	$STATE
	$TRAN	TPA$_DECIMAL,TSTEOS,,,PARA1

	$STATE	SHOPAR
	$TRAN	'MODES',TSTEOS,,<^X1>,SHOMASK
	$TRAN	'CHANGE',TSTEOS,,<^X2>,SHOMASK
	$TRAN	'LOCATE',TSTEOS,,<^X4>,SHOMASK
	$TRAN	'PASTE',TSTEOS,,<^X8>,SHOMASK
	$TRAN	'FILE',TSTEOS,,<^X10>,SHOMASK
	$TRAN	'DEVICE',TSTEOS,,<^X10>,SHOMASK
	$TRAN	'ALL',TSTEOS,,<^X1F>,SHOMASK
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,BDCOMM

	$STATE	FP1
	$TRAN	TPA$_LAMBDA,,UCASE

	$STATE	FP2
	$TRAN	'/',FP3
	$TRAN	TPA$_EOS,TPA$_EXIT
	$TRAN	TPA$_LAMBDA,FP4

	$STATE	FP3
	$TRAN	'OVERRIDE',FP2,SETOVR
	$TRAN	'WRITE',FP2,SETWRT
	$TRAN	'BLOCK',FP2,CLRREC
	$TRAN	'RECORD',FP2,SETREC
	$TRAN	'NOREWIND',FP3A,CHAR3
	$TRAN	'REWIND',FP2
	$TRAN	'POSITION',FP3B
	$TRAN	'KEY',FP3C
	$TRAN	TPA$_LAMBDA,,TSTINIT
	$STATE
	$TRAN	!SETSUB,FP2
	$STATE	FP3A
	$TRAN	TPA$_LAMBDA,FP2,CLRREW
	$STATE	FP3B
	$TRAN	!POSSUB,FP2
	$STATE	FP3C
	$TRAN	!KEYSUB,FP2

	$STATE	FP4
	$TRAN	TPA$_LAMBDA,,TESTF
	$STATE
	$TRAN	!FSTRING,FP2,,,FDESC

	$STATE	SETSUB
	$TRAN	'LOG',LOGPAR,,<^X1>,SETMASK
	$TRAN	'NOLOG',TPA$_EXIT,CHAR3,<^X1000>,SETMASK
	$TRAN	'DISPLAY',TPA$_EXIT,,<^X2>,SETMASK
	$TRAN	'NODISPLAY',TPA$_EXIT,CHAR3,<^X2000>,SETMASK
	$TRAN	'SIGN',TPA$_EXIT,,<^X4>,SETMASK
	$TRAN	'NOSIGN',TPA$_EXIT,CHAR3,<^X4000>,SETMASK
	$TRAN	'HEADER',TPA$_EXIT,,<^X8>,SETMASK
	$TRAN	'NOHEADER',TPA$_EXIT,CHAR3,<^X8000>,SETMASK
	$TRAN	'CASE',TPA$_EXIT,,<^X10>,SETMASK
	$TRAN	'NOCASE',TPA$_EXIT,CHAR3,<^X10000>,SETMASK
	$TRAN	'RADIX',RADPAR
	$TRAN	'BUFF',BUFPAR
	$TRAN	'SKIP',SKIPPAR
	$TRAN	'WIDTH',WIDPAR
	$TRAN	'CHARSET',CHARPAR
	$TRAN	'POSITION',POSPAR
	$TRAN	'KEY',KEYPAR

	$STATE	LOGPAR
	$TRAN	'='
	$TRAN	TPA$_LAMBDA,TPA$_EXIT,LOGDEF
	$STATE
	$TRAN	!FSTRING,TPA$_EXIT,,,DESC

	$STATE	RADPAR
	$TRAN	'='
	$STATE
	$TRAN	'HEX',TPA$_EXIT,,<^X20>,SETMASK
	$TRAN	'DECIMAL',TPA$_EXIT,,<^X20000>,SETMASK

	$STATE	BUFPAR
	$TRAN	'=',,,<^X100000>,SETMASK
	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,,,NBUFCT

	$STATE	SKIPPAR
	$TRAN	'='
	$STATE
	$TRAN	'FAST',TPA$_EXIT,,<^X100>,SETMASK
	$TRAN	'SLOW',TPA$_EXIT,,<^X200>,SETMASK
	$TRAN	'NORMAL',TPA$_EXIT,,<^X400>,SETMASK

	$STATE	WIDPAR
	$TRAN	'=',,,<^X800>,SETMASK
	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,,,NEWWID

	$STATE	CHARPAR
	$TRAN	'='
	$STATE
	$TRAN	'EBCDIC',TPA$_EXIT,,<^X40>,SETMASK
	$TRAN	'ASCII',TPA$_EXIT,,<^X40000>,SETMASK

	$STATE	POSPAR
	$TRAN	!POSSUB,TPA$_EXIT

	$STATE	POSSUB
	$TRAN	'=',,POSINIT
	$STATE
	$TRAN	'('
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,,,POSBLK
	$STATE
	$TRAN	TPA$_DECIMAL,,,,POSFIL
	$STATE
	$TRAN	':'
	$STATE
	$TRAN	TPA$_DECIMAL,,,,POSBLK
	$STATE
	$TRAN	')',TPA$_EXIT

	$STATE	KEYPAR
	$TRAN	!KEYSUB,TPA$_EXIT

	$STATE	KEYSUB
	$TRAN	'=',,,<^X80>,SETMASK
	$STATE
	$TRAN	TPA$_DECIMAL,TPA$_EXIT,,,NEWKRF

	$STATE	FSTRING
	$TRAN	TPA$_ANY,,FSSL

	$STATE	FS1
	$TRAN	TPA$_ANY,FS1,FSSL
	$TRAN	TPA$_LAMBDA,TPA$_EXIT

	$STATE	TSTEOS
	$TRAN	TPA$_EOS,TPA$_EXIT

	$END_STATE
	.PAGE
	.SBTTL	Action routines
	.psect code,exe,rd,nowrt
	.entry alphinit,^m<>
;ALPHINIT:
;	.WORD	0
	MOVAL	ASCII,JMPADR
	TSTB	EBCFLG
	BEQL	100$
	MOVAL	EBCDIC,JMPADR
100$:
	MOVL	#1,DSPCNT
	CLRL	PARA1
	MNEGL	#1,PARA2
	RET

	.entry ainit,^m<>
;AINIT:
;	.WORD	0
	MOVL	#1,DSPCNT
	CLRL	PARA1
	MNEGL	#1,PARA2
	RET

	.entry cinit,^m<>
;CINIT:
;	.WORD	0
	MOVL	#1,DSPCNT
	CLRL	PARA1
	MOVL	CURBCT,PARA2
	INCL	MFLAG
	RET

	.entry crinit,^m<>
;CRINIT:
;	.WORD	0
	MOVL	CURBCT,PARA1
	CLRL	CRTYPE
	RET

	.entry crpaste,^m<>
;CRPASTE:
;	.WORD	0
	MOVL	#1,CRTYPE
	MOVL	PBBCT,PARA1
	RET

	.entry dpinit,^m<>
;DPINIT:
;	.WORD	0
	MOVL	#1,DSPCNT
	MOVL	PBOFF,PARA1
	SUBL3	PBOFF,CURBCT,PARA2
	CMPL	PARA2,PBBCT
	BLEQ	100$
	MOVL	PBBCT,PARA2
100$:
	DECL	MFLAG
	RET

	.entry dtinit,^m<>
;DTINIT:
;	.WORD	0
	MOVL	#8,DSPCNT
	MNEGL	#1,PARA1
	RET

	.entry iwinit,^m<>
;IWINIT:
;	.WORD	0
	MOVL	#2,DSPCNT
	CLRL	PARA1
	MNEGL	#1,PARA2
	MOVL	#8,WLPARM
	MOVL	#6,WLPOSN
	RET

	.entry ilinit,^m<>
;ILINIT:
;	.WORD	0
	MOVL	#4,DSPCNT
	CLRL	PARA1
	MNEGL	#1,PARA2
	MOVL	#4,WLPARM
	MOVL	#11,WLPOSN
	RET

	.entry lginit,^m<>
;LGINIT:
;	.WORD	0
	MOVB	#1,LGFLAG
	RET

	.entry rinit,^m<>
;RINIT:
;	.WORD	0
	MNEGL	#1,PARA1
	MNEGL	#1,PARA2
	MOVB	#1,RFLAG
	RET

	.entry paston,^m<>
;PASTON:
;	.WORD	0
	INCB	DPBFLG
	DIVL3	DSPCNT,PBBCT,PARA2
	RET

	.entry hextst,^m<>
;HEXTST:
;	.WORD	0
	TSTB	HEXFLG
	BEQL	100$
	CLRL	R0
100$:
	RET

	.entry recchk,^m<>
;RECCHK:
;	.WORD	0
	TSTB	RFLAG
	BEQL	100$
	CLRL	R0
100$:
	RET

	.entry single,^m<>
;SINGLE:
;	.WORD	0
	TSTL	MFLAG
	BNEQ	100$
	MOVL	#1,PARA2
	BRB	200$
100$:
	SUBL3	PARA1,CURBCT,PARA2
	TSTL	MFLAG
	BGTR	200$
	CMPL	PARA2,PBBCT
	BLEQ	200$
	MOVL	PBBCT,PARA2
200$:
	RET

	.entry offset,^m<>
;OFFSET:
;	.WORD	0
	SUBL2	PARA1,PARA2
	ADDL2	DSPCNT,PARA2
	BGTR	100$
	CLRL	PARA2
100$:
	DIVL2	DSPCNT,PARA2
	RET

	.entry addini,^m<>
;ADDINI:
;	.WORD	0
	CLRL	ACCUM
	CLRL	MFLAG
	RET

	.entry accuml,^m<>
;ACCUML:
;	.WORD	0
	CMPL	MFLAG,#0
	BEQL	100$
	SUBL2	TPA$L_NUMBER(AP),ACCUM
	BRB	200$
100$:
	ADDL2	TPA$L_NUMBER(AP),ACCUM
200$:
	CLRL	MFLAG
	RET

	.entry ginit,^m<>
;GINIT:
;	.WORD	0
	MOVL	CURBLK,PARA1
	RET

	.entry ninit,^m<>
;NINIT:
;	.WORD	0
	CLRL	MFLAG
	MOVL	#1,PARA1
	RET

	.entry nintim,^m<>
;NINITM:
;	.WORD	0
	MOVL	#1,MFLAG
	MOVL	#1,PARA1
	RET

	.entry negate,^m<>
;NEGATE:
;	.WORD	0
	TSTL	MFLAG
	BEQL	100$
	MNEGL	PARA1,PARA1
100$:
	RET

	.entry chgloc,^m<>
;CHGLOC:
;	.WORD	0
	MOVL	LPTR,PARA1
	DECL	PARA1
	RET

	.entry cnumm,^m<>
;CNULL:
;	.WORD	0
	TSTW	CSTRL
	BGTR	100$
	CLRL	R0
	BRB	200$
100$:
	MOVW	CSTRL,QDESC
	MOVAL	CSTR,QDESC+4
	MOVB	CSTRT,QTYPE
200$:
	RET

	.entry sbnull,^m<>
;SBNULL:
;	.WORD	0
	TSTL	SBSTRL
	BGTR	100$
	CLRL	R0
	BRB	200$
100$:
	MOVW	SBSTRL,DESC
	MOVAL	SUBSTR,DESC+4
200$:
	RET

	.entry lnull,^m<>
;LNULL:
;	.WORD	0
	CMPW	LSTRL,#0
	BGTR	100$
	CLRL	R0
	BRB	200$
100$:
	MOVW	LSTRL,QDESC
	MOVAL	LSTR,QDESC+4
	MOVB	LSTRT,QTYPE
200$:
	RET

	.entry cnum,^m<R2,R3,R4,R5,R6,R7,R8>
;CNUM:
;	.WORD	^M<R2,R3,R4,R5,R6,R7,R8>
	MOVAL	QSTR,R6
	MOVL	R6,QDESC+4
	ADDL3	#1,TPA$L_TOKENCNT(AP),R7
	DIVL2	#2,R7
	MOVW	R7,QDESC
	CMPL	R7,#4
	BLEQ	100$
	SUBL3	#4,R7,R8
	MOVC5	#0,BUFF,#0,R8,(R6)
	ADDL2	R8,R6
	MOVL	#4,R7
100$:
	MOVAL	TPA$L_NUMBER(AP),R8
	ADDL2	R7,R8
200$:
	MOVB	-(R8),(R6)+
	SOBGTR	R7,200$
	MOVB	#3,QTYPE
	MOVL	#1,R0
	RET

	.entry cdec,^m<>
;CDEC:
;	.WORD	0
	MOVL	TPA$L_NUMBER(AP),R1
	CMPL	TPA$L_TOKENCNT(AP),#5
	BGTR	600$
	CMPL	TPA$L_TOKENCNT(AP),#3
	BGTR	400$
	CMPL	R1,#255
	BGTR	400$
	TSTL	MFLAG
	BEQL	300$
	CMPL	R1,#128
	BGTR	400$
	MNEGL	R1,R1
300$:
	MOVB	R1,QSTR
	MOVW	#1,QDESC
	BRB	850$
400$:
	CMPL	R1,#65535
	BGTR	600$
	TSTL	MFLAG
	BEQL	500$
	CMPL	R1,#32768
	BGTR	600$
	MNEGL	R1,R1
500$:
	MOVW	R1,QSTR
	MOVW	#2,QDESC
	BRB	850$
600$:
	TSTL	MFLAG
	BEQL	800$
	TSTL	R1
	BGEQ	700$
	CLRL	R0
	BRB	900$
700$:
	MNEGL	R1,R1
800$:
	MOVL	R1,QSTR
	MOVW	#4,QDESC
850$:
	MOVAL	QSTR,QDESC+4
	MOVB	#1,QTYPE
	TSTL	MFLAG
	BEQL	900$
	MOVB	#2,QTYPE
900$:
	RET

	.entry spacon,^m<>
;SPACON:
;	.WORD	0
	MOVL	#TPA$M_ABBRFM!TPA$M_BLANKS,TPA$L_OPTIONS(AP)
	RET

	.entry chkstr,^m<>
;CHKSTR:
;	.WORD	0
	CLRB	QTYPE
	MOVL	#TPA$M_ABBRFM,TPA$L_OPTIONS(AP)
	CMPW	QDESC,#0
	BGTR	100$
	CLRL	R0
100$:
	RET

	.entry testq,^m<>
;TESTQ:
;	.WORD	0
	CMPB	TPA$B_CHAR(AP),QCHAR
	BNEQ	100$
	CLRL	R0
100$:
	RET

	.entry ucase,^m<r2,r3>
;UCASE:
;	.WORD	^M<R2,R3>
	MOVL	TPA$L_STRINGCNT(AP),R2
	BLEQ	900$
	MOVL	TPA$L_STRINGPTR(AP),R3
100$:
	CMPB	(R3),#^A/a/
	BLSS	200$
	CMPB	(R3),#^A/z/
	BGTR	200$
	SUBB2	#^X20,(R3)
200$:
	INCL	R3
	SOBGTR	R2,100$
900$:
	RET

	.entry char3,^m<>
;CHAR3:
;	.WORD	0
	CMPL	TPA$L_TOKENCNT(AP),#3
	BGEQ	100$
	CLRL	R0
100$:
	RET

	.entry gendesc,^m<>
;GENDESC:
;	.WORD	0
	MOVW	TPA$L_STRINGCNT(AP),DESC
	MOVL	TPA$L_STRINGPTR(AP),DESC+4
	RET

	.entry logdef,^m<>
;LOGDEF:
;	.WORD	0
	MOVQ	DEFLOG,DESC
	RET
	.entry bdcomm,^m<>
;BDCOMM:
;	.WORD	0
	OUTMSG	#BDCL,BDC
	CLRL	JMPADR
	RET
	.entry setovr,^m<>
;SETOVR:
;	.WORD	0
	MOVB	#1,OVRFLG
	RET
	.entry setwrt,^m<>
;SETWRT:
;	.WORD	0
	MOVB	#1,WRTFLG
	RET
	.entry clrrec,^m<>
;CLRREC:
;	.WORD	0
	CLRB	RECMOD
	RET
	.entry setrec,^m<>
;SETREC:
;	.WORD	0
	MOVB	#1,RECMOD
	RET
	.entry clrrew,^m<>
;CLRREW:
;	.WORD	0
	MOVB	#1,NOREW
	RET
	.entry tstinit,^m<>
;TSTINIT:
;	.WORD	0
	TSTB	INITFLG
	BNEQ	100$
	CLRL	R0
100$:
	RET
	.entry testf,^m<>
;TESTF:
;	.WORD	0
	TSTW	FDESC
	BEQL	100$
	CLRL	R0
100$:
	RET
	.entry posinit,^m<>
;POSINIT:
;	.WORD	0
	MOVB	#1,POSFLG
	MOVL	CURFIL,POSFIL
	RET
	.entry fssl,^m<>
;FSSL:
;	.WORD	0
	CMPB	TPA$B_CHAR(AP),#^A./.
	BNEQ	100$
	CLRL	R0
100$:
	RET
	.PAGE
	.SBTTL	Data definitions

	.PSECT	DATA,WRT,NOEXE,quad

SOLDSK0: .ASCID	/!UL> /
SOLDSK1: .ASCID	/!UL(!UL)> /
SOLDSK2: .ASCID	/!UL* (!UL)> /
SOLNEW:	.ASCID	/*NR* (!UL)> /
SOLTP0:	.ASCID	/!SL:!SL> /
SOLTP1:	.ASCID	/!SL:!SL(!UL)> /
	.align quad
FUNC:	.BLKB	80

DEFLOG: .ASCID	/VFE.LOG/

BDC:	.ASCII	/Invalid command./
BDCL=.-BDC

NWOMSG:	.ASCII	"/OVERRIDE and /WRITE may not be used together."
NWOL=.-NWOMSG
	.align quad
TPBLK:	.BLKB	TPA$K_LENGTH0

INITFLG:: .BYTE	1
JMPADR:: .LONG	0
SETMASK:: .LONG	0
SHOMASK:: .LONG	0
PARA1::	.LONG	0
	.LONG	0
PARA2::	.LONG	0

MFLAG:	.LONG	0
CRTYPE:: .LONG	0
DPBFLG:: .BYTE	0
RFLAG:	.BYTE	0

QCHAR:	.BYTE	0
QDESC::	.QUAD	0
QTYPE::	.BYTE	0
	.align quad
QSTR:	.BLKB	100

	.END