Commit: 711172d9e1780ce2814c68d9496e196476b40f0c - fig_sh (git)

Implementing figFORTH on SH3 assembler

Commit MetaInfo

• Revision: 711172d9e1780ce2814c68d9496e196476b40f0c (tree)
• Time: 2014-03-07 14:05:47
• Author: Joel Matthew Rees <reiisi@user...>
• Commiter: Joel Matthew Rees

Log Message

Stubs for EMIT, KEY, etc., CMOVE

Change Summary

• modified: context.inc
• add: driver.inc
• modified: evaluator.inc
• add: inout.inc
• modified: main.src
• modified: parser.inc
• modified: primitive.inc
• modified: symbol.inc

Incremental Difference

--- a/context.inc
+++ b/context.inc
@@ -34,6 +34,7 @@
 	.cpu	sh3
 
 NATURAL_SIZE:	.equ	4	; 4 byte word
+HALF_SIZE:		.equ	( NATURAL_SIZE / 2 )
 ALIGN_MASK: 	.equ	( H'FF & ~(NATURAL_SIZE - 1) )
 ALL_BITS8:		.equ	( H'FF & -1 )
 
@@ -95,6 +96,71 @@ fW:		.reg	r4	; currently executing Word definition pointer
 ; we can save a lot of time during interrupt processing.
 
 
+; Structure of the per-USER variables table:
+	.section usertable, dummy
+	.org	0
+UORIG:	.equ $
+	.res.l	3	; three reserved variables, not sure why
+XSPZER:	.equ $-UORIG
+	.res.l	1	; initial top of data stack for this user
+XRZERO:	.equ $-UORIG
+	.res.l	1	; initial top of return stack
+XTIB:	.equ $-UORIG
+	.res.l	1	; start of terminal input buffer
+XWIDTH:	.equ $-UORIG
+	.res.l	1	; name field width
+XWARN:	.equ $-UORIG
+	.res.l	1	; warning message mode (0 = no disc)
+XFENCE:	.equ $-UORIG
+	.res.l	1	; fence for FORGET
+XDP:	.equ $-UORIG
+	.res.l	1	; dictionary pointer
+XVOCL:	.equ $-UORIG
+	.res.l	1	; vocabulary linking
+XBLK:	.equ $-UORIG
+	.res.l	1	; disc block being accessed
+XIN:	.equ $-UORIG
+	.res.l	1	; scan pointer into the block
+XOUT:	.equ $-UORIG
+	.res.l	1	; cursor position
+XSCR:	.equ $-UORIG
+	.res.l	1	; disc screen being accessed ( O=terminal )
+XOFSET:	.equ $-UORIG
+	.res.l	1	; disc sector offset for multi-disc
+XCONT:	.equ $-UORIG
+	.res.l	1	; last word in primary search vocabulary
+XCURR:	.equ $-UORIG
+	.res.l	1	; last word in extensible vocabulary
+XSTATE:	.equ $-UORIG
+	.res.l	1	; flag for 'interpret' or 'compile' modes
+XBASE:	.equ $-UORIG
+	.res.l	1	; number base for I/O numeric conversion
+XDPL:	.equ $-UORIG
+	.res.l	1	; decimal point place
+XFLD:	.equ $-UORIG
+	.res.l	1	; 
+XCSP:	.equ $-UORIG
+	.res.l	1	; current stack position, for compile checks
+XRNUM:	.equ $-UORIG
+	.res.l	1	; 
+XHLD:	.equ $-UORIG
+	.res.l	1	; 
+XDELAY:	.equ $-UORIG
+	.res.l	1	; carriage return delay count
+XCOLUM:	.equ $-UORIG
+	.res.l	1	; carriage width
+IOSTAT:	.equ $-UORIG
+	.res.l	1	; last acia status from write/read
+; ( 4 spares! )
+	.res.l	1	; 
+	.res.l	1	; 
+	.res.l	1	; 
+	.res.l	1	; 
+;
+UTABLESZ:	.equ $-UORIG
+
+
+
 ; Structure of the symbol table entry:
 ; Length byte of the symbol name (NFA)
 ; 	high bit set to flag the start byte

--- /dev/null
+++ b/driver.inc
@@ -0,0 +1,59 @@
+	.list ON, EXP
+	
+; Actual driver definitions for fig-FORTH for SH-3
+; Joel Matthew Rees, Hyougo Polytec Center
+; 2014.03.05
+
+; This is where you put the drivers for your hardware.
+
+; Monolithic, not separate assembly:
+; context.inc must be included before this file.
+;	.include	"context.inc"
+;
+;	.section	driver, code
+
+
+; Not sure whether to make headers for these.
+; See screens 21 and around 63 in the fig model.
+
+
+; (EMIT)    ( c --- )
+;           Low level details of outputting a character 
+;           to the current output device.
+;
+	HEADER	(EMIT), PEMIT
+	mov.l	@fSP+, r0
+	rts
+	nop	
+
+
+; (KEY)    ( --- c )
+;           Low level details of getting a key 
+;           from the current input device.
+;
+	HEADER	(KEY), PKEY
+	mov.l	r0, @-fSP
+	rts
+	nop	
+
+
+; (?TERMINAL)    ( --- f )
+;           Low level details of checking the break key.
+;
+	HEADER	(?TERMINAL), PQTER
+	mov 	#6, r0
+	mov.l	r0, @-fSP
+	rts
+	nop	
+
+
+; (CR)    ( --- )
+;           Low level details of performing carriage return/line feed 
+;           on the current output device.
+;
+	HEADER	(CR), PCR
+	mov.l	@fSP+, r0
+	rts
+	nop	
+
+

--- a/evaluator.inc
+++ b/evaluator.inc
@@ -32,12 +32,40 @@
 ; I       ( --- index )           ( limit index *** limit index )
 ;         Copy the loop index from the return stack.  Synonym for R, here.
 ;
-	HEADER	I, xI
+	HEADER	I, I
 	mov.l	@fRP, r0	; I (loop counter)
 	rts
 	mov.l	r0, @-fSP	
-
-
+
+
+; U*      ( u1 u2 --- ud )
+;         Multiplies the top two unsigned integers, yielding a double
+;         integer product.
+;         SH3 MAC is a signed multiply/add, so we can't cheat on U*.
+;         If we cheat and use memory access to grab half words, 
+;         we have to know whether we are LSB or MSB first.
+;
+	HEADER	U*, USTAR
+	.AIFDEF	_LIT
+	mov.w	@fSP, r0
+	mov.w	@(NATURAL_SIZE,fSP), r1
+	.etc
+	.AELSE	; _BIG is default
+	mov.w	@(HALF_SIZE,fSP), r0
+	mov.w	@(NATURAL_SIZE+HALF_SIZE,fSP), r1
+	
+	.AENDI
+
+; +       ( n1 n2 --- n1+n2 )
+;         Add top two words.
+;
+	HEADER	+, PLUS
+	mov.l	@fSP+, r0
+	mov.l	@fSP, r1
+	add 	r1, r0
+	rts
+	mov.l	r0, @fSP
+	
 
 
 

--- /dev/null
+++ b/inout.inc
@@ -0,0 +1,85 @@
+	.list ON, EXP
+	
+; FORTH input/output definitions for fig-FORTH for SH-3
+; Joel Matthew Rees, Hyougo Polytec Center
+; 2014.03.05
+
+; Monolithic, not separate assembly:
+; context.inc must be included before this file.
+;	.include	"context.inc"
+;
+;	.section	inputoutput, code
+
+
+; EMIT, KEY, QTERM, and CR are assumed to be the focus 
+; of porting to new hardware.
+
+; These are stubs which call real drivers defined in driver.inc
+; In the fig-FORTH model, you see the stubs around screen 21.
+; And you see the drivers around screen 63.
+
+; Contrary to usual practice, I am assuming the drivers 
+; use the stack instead of registers to pass results.
+; No particular reason not use the registers, of course.
+
+
+; EMIT    ( c --- )
+;         Write c to the terminal device, whatever that may be.
+;         Increment the OUT per USER variable.
+;
+	HEADER	EMIT, EMIT
+	mov.l	#PEMIT, r1	; May be within range of absolute call?
+	jsr 	@r1
+	nop
+	mov.l	#XOUT, r0	; We defined XOUT as the offset itself.
+	mov.l	@(r0,fUP), r1
+	add 	#1, r1
+	rts
+	mov.l	r1, @(r0,fUP)
+	
+
+; KEY     ( --- c )
+;         Leave the ascii value of the next terminal key struck.
+;
+	HEADER	KEY, KEY
+	mov.l	#PKEY, r1	; May be within range of absolute call?
+	jsr 	@r1
+	nop
+	mov.l	@fSP, r1
+	mov.l	#H'000000ff, r0
+	and 	r1, r0
+	rts
+	mov.l	r0, @fSP
+
+
+; ?TERMINAL       ( --- f )
+;        Perform a test of the terminal keyboard for actuation of the break
+;        key. A true flag indicates actuation.
+;        In other words, scan keyboard, but do not wait.  
+;        Return true if break key currently pressed, 0 otherwise.
+;        Ignores any keys buffered up, in theory.
+;        But this definition is installation dependent,
+;        and may not give exactly these results.
+;
+	HEADER	?TERMINAL, QTERM
+	mov.l	#PQTER, r1	; May be within range of absolute call?
+	jsr 	@r1
+	nop		; Might need to filter results?
+	rts
+	nop
+
+
+; CR      ( --- )
+;         Transmit a carriage return and line feed to the selected output
+;         device.
+;
+	HEADER	CR, CR
+	mov.l	#PCR, r1	; May be within range of absolute call?
+	jsr 	@r1
+	nop		; Might push a CR and EMIT, then a LF and EMIT?
+	rts
+	nop
+
+
+
+

--- a/main.src
+++ b/main.src
@@ -5,8 +5,29 @@
 ; 2014.02.28
 
 	.include	"context.inc"
+	
+
+	.section	main,    code,  locate=h'8c000000
+	.org	$
+COLD:
+	mov.l	#PER_USER, fUP
+	mov.l	#fSP_BASE, fSP
+	mov.l	#fRP_BASE, fRP
+	mov.l	#TEST_THINGY, fIP
+	mov.l	#NEXT, r0
+	jmp 	@r0
+	nop
+	
+TEST_THINGY:
+	.data.l	LIT
+	.data.l	1
+	.data.l	LIT
+	.data.l	-1
+	.data.l	PLUS
+	.data.l	BRAN
+	.data.l $+NATURAL_SIZE-TEST_THINGY
 
-	.section	initialize, code, locate=h'8c000000
+	
 ; For various reasons, including the above "locate" declaration, 
 ; this will be assembled monolithically, rather than separately.
 ; Thus:
@@ -16,10 +37,29 @@
 	.include	"parser.inc"
 	.include	"evaluator.inc"
 	.include	"symbol.inc"
+	.include	"inout.inc"
+	
+	.include	"driver.inc"
 
 
+	.section	user,    data,  locate=h'8c010000
+PER_USER:	.equ $
+	.res.b	UTABLESZ
+	
+	.section	pstack,  stack, locate=PER_USER+h'E000
+fSP_LIMIT:	.equ $
+	.res.b		h'1800
+fSP_BASE:	.equ $
 
+	.section	rstack,  stack, locate=h'8c01F800
+fRP_LIMIT:	.equ $
+	.res.b		h'800
+fRP_BASE:	.equ $
+	
+	.section	thevoid, dummy, locate=h'8c020000
+OUTERSPACE:	.equ $
 
+	
 
 
 

--- a/parser.inc
+++ b/parser.inc
@@ -18,29 +18,29 @@
 ;         translation is not valid in the specified base, only the false
 ;         flag is returned.
 ;
-	HEADER	DIGIT, xDIGIT
+	HEADER	DIGIT, DIGIT
 	mov.l	@(NATURAL_SIZE,fSP), r0	; ７ビット文字
 	mov.b	#"0", r1
 	cmp/ge	r1, r0 		; character (r0) >= "0"
-	bf	xDIGITno
+	bf	DIGITno
 	add 	#-"0", r0
 	mov.b	#9, r1
 	cmp/gt	r1, r0		; digit (r0) > 9
-	bf	xDIGITbase
+	bf	DIGITbase
 	mov.b	#"A"-"0", r1
 	cmp/ge	r1, r0		; was it between "9" and "A"?
-	bf	xDIGITno
+	bf	DIGITno
 	add 	#"9"-"A"+1, r0
-xDIGITbase:
+DIGITbase:
 	mov.l	@fSP, r1
 	cmp/ge	r1, r0		; digit (r0) >= base
-	bt xDIGITno
+	bt DIGITno
 	mov.l	r0, @(NATURAL_SIZE,fSP)
 	mov.b	#-1, r0 	; store the converted digit
 	rts
 	mov.l	r0, @fSP	; set the flag on our way out
 ;
-xDIGITno:
+DIGITno:
 	mov.b	#0, r0
 	add 	#NATURAL_SIZE, fSP
 	rts
@@ -52,103 +52,51 @@ xDIGITno:
 ;         return the offsets to the first character of the symbol,
 ;         the last character of the symbol,
 ;         and the next character after the symbol.
+;         Walks all over r0-r3 and fW.
 ;
-	HEADER	ENCLOSE, xENCLOSE
+	HEADER	ENCLOSE, ENCLOS
 	mov.l	@fSP, r2	; delimiter
-	mov.b	#0, r3		; start the count at zero
-	mov.l	@(NATURAL_SIZE,fSP), r1
-xENCLOSEloopwhite:
+	mov.l	@(NATURAL_SIZE,fSP), r1		; point to start in the buffer
+	mov 	#0, r3		; count
+ENCLOSleadloop:
 	mov.b	@r1+, r0
 	cmp/eq	#0, r0		; NUL character before symbol?
-	bt  	xENCLOSEnone
+	bt  	ENCLOSnone
 	cmp/eq	r2, r0		; leading delimiter? (Usually SPACE.)
-	bt  	xENCLOSEloopwhite
-	add 	#1, r3		; Count it as we go.
+	bt  	ENCLOSword
+	bra 	ENCLOSleadloop
+	add 	#1, r1		; Count it as we go.
 ;
-	add 	#-1, r3		; Counted too far.
+ENCLOSword:
 	mov.l	r3, @fSP	; Save offset to symbol or NUL.
-	add 	#-1, r1		; Back up to what stopped us.
-xENCLOSEloopword:
+	mov.l	@r1+, r0	; get the next one
+ENCLOSwordloop:
 	cmp/eq	#0, r0		; NUL?
-	bt  	xENCLOSEnul
-	****
-	add 	#1, r3
-	bra 	xENCLOSEloopword
-	mov.l	@r1+, r0
+	bt/s  	ENCLOSnulterm
+	add 	#1, r3		; count the one before
+	cmp/eq	r2, r0		; delimiter
+	bf/s  	ENCLOSwordloop
+	mov.l	@r1+, r0	; Get the next one, but not beyond NUL.
 ;
-		
+; The pointer and character don't matter, just the count.
+	mov.l	r3, @-fSP	; Count to non-NUL delimiter.
+	add 	#1, r3		; Next character that might be part of a symbol.
+	rts
+	mov.l	r3, @-fSP	; Save it as we go.
+	
 ; found NUL before non-delimiter, therefore there is no word
-xENCLOSEnone:
-	mov.l	r3, @fSP
+ENCLOSnone:
+	mov.l	r3, @fSP	; Save offset to NUL.
 	add 	#1, r3
-	mov.l	r3, @-fSP
+	mov.l	r3, @-fSP	; Make the symbol at least one char long.
 	add 	#-1, r3
 	rts
-	mov.l	r3, @-fSP
+	mov.l	r3, @-fSP	; But keep us stopped at the NUL.
 ; delimited by NUL
-xENCLOSEnul:
-	mov.l	r3, @-fSP
+ENCLOSnulterm:
+	mov.l	r3, @-fSP	; Delimiter is NUL.
 	rts
-	mov.l	r3, @-fSP
-
+	mov.l	r3, @-fSP	; No next character included, keep us at the NUL.
 
 
-;* ######>> screen 20 <<
-;* ======>>  12  <<
-;	FCB	$87
-;	FCC	6,ENCLOSE
-;	FCB 	$C5
-;	FDB	PFIND-9
-;* NOTE :
-;* FC means offset (bytes) to First Character of next word
-;* EW  "     "   to End of Word
-;* NC  "     "   to Next Character to start next enclose at
-;ENCLOS	FDB	*+2
-;	INS
-;	PUL B		now, get the low byte, for an 8-bit delimiter
-;	TSX
-;	LDX	0,X
-;	CLR	N
-;*	wait for a non-delimiter or a NUL
-;ENCL2	LDA A	0,X
-;	BEQ	ENCL6
-;	CBA		CHECK FOR DELIM
-;	BNE	ENCL3
-;	INX
-;	INC	N
-;	BRA	ENCL2
-;*	found first character. Push FC
-;ENCL3	LDA A	N	found first char.
-;	PSH A
-;	CLR A
-;	PSH A
-;*	wait for a delimiter or a NUL
-;ENCL4	LDA A	0,X
-;	BEQ	ENCL7
-;	CBA		ckech for delim.
-;	BEQ	ENCL5
-;	INX
-;	INC	N
-;	BRA	ENCL4
-;*	found EW. Push it
-;ENCL5	LDA B	N
-;	CLR A
-;	PSH B
-;	PSH A
-;*	advance and push NC
-;	INC B
-;	JMP	PUSHBA
-;
-;ENCL6	LDA B	N	found NUL
-;	PSH B
-;	PSH A
-;	INC B
-;	BRA	ENCL7+2	
-;*	found NUL following the word instead of SPACE
-;ENCL7	LDA B	N
-;	PSH B		save EW
-;	PSH A
-;ENCL8	LDA B	N	save NC
-;	JMP	PUSHBA
-;
 

--- a/primitive.inc
+++ b/primitive.inc
@@ -17,14 +17,15 @@
 ;
 ; Anyway, this is the inner interpreter.
 ;
-next:
+NEXT:
 	mov.l	@fIP+, fW	; get the pointer to the next definition to execute
+NEXTloop:
 	mov.l	@fW, r0		; get the defitinition characteristic
 	jsr		@r0
 ; 3 cycles to get back to the top of the loop.
 	nop	
-	bra		next
-	nop
+	bra		NEXTloop
+	mov.l	@fIP+, fW	; grab the next pointer as we go.
 ; Note that, since jumps to absolute addresses have limits in constant-width instruction sets,
 ; using the subroutine call mode for the virtual machine is not as much a penalty as it might seem.
 ; It also has the advantage of being more compatible with more conventional code.
@@ -39,9 +40,8 @@ next:
 ;
 	HEADER	LIT, LIT
 	mov.l	@fIP+, r0
-	mov.l	r0, @-fSP
 	rts
-	nop
+	mov.l	r0, @-fSP
 
 
 ; "character" (byte or word) literal doesn't work on SH3
@@ -52,7 +52,7 @@ next:
 ;         Jump to address on stack.  Used by the "outer" interpreter to
 ;         interactively invoke routines.  (Not compile-only in fig.)
 ;
-	HEADER	EXECUTE, EXECUTE
+	HEADER	EXECUTE, EXEC
 	mov.l	@fSP+, fW
 	mov.l	@fW, r0
 	jmp 	@r0		; borrow the return there
@@ -63,25 +63,23 @@ next:
 ;         Add the following word from the instruction stream to the
 ;         instruction pointer (postincrement).  Causes a program branch.
 ;
-	HEADER	BRANCH, BRANCH
+	HEADER	BRANCH, BRAN
 	mov.l	@fIP+, r0
 BRANCHgo:
-	add 	r0, fIP
 	rts
-	nop
+	add 	r0, fIP
 
 
 ; 0BRANCH ( f --- )                                               C
 ;         BRANCH if flag is zero.
 ;
-	HEADER	0BRANCH, ZBRANCH
+	HEADER	0BRANCH, ZBRAN
 	mov.l	@fSP+, r0
 	cmp/eq	#0, r0	
 	bt/s	BRANCHgo
 	mov.l	@fIP+, r0
 	rts
 	nop
-	
 
 ; fig-FORTH puts temporaries on the control stack. I prefer a third stack.
 ; But if we put I in registers, (DO) is affected.
@@ -101,7 +99,7 @@ BRANCHgo:
 ;         does not occur, and the index and limit are dropped from the
 ;         return stack.
 ;
-	HEADER	(LOOP), xLOOP
+	HEADER	(LOOP), XLOOP
 	mov.l	@fRP, r0	; I (loop counter)
 	add 	#1, r0
 	mov.l	r0, @fRP	; update I
@@ -121,24 +119,24 @@ BRANCHgo:
 ;         limit.  A negative n must cause the index to become less than
 ;         the limit to cause loop termination.
 ;
-	HEADER	(+LOOP), xPLOOP
+	HEADER	(+LOOP), XPLOOP
 	mov.l	@fSP+, r1	; increment
 	mov.l	@fRP, r0	; I (loop counter)
 	add 	r1, r0
 	mov.l	r0, @fRP	; update I
 	shal	r1		 	; increment negative or positive?
-	bt/s	xPLOOPminus
+	bt/s	XPLOOPminus
 	mov.l	@(NATURAL_SIZE,fRP), r1	; limit
 ;
 ; Stealing too much code would cost more than it would save.
-xPLOOPplus:
+XPLOOPplus:
 	cmp/ge	r0, r1		; limit (r1) >= counter (I=r0) ?
 	bf/s	BRANCHgo	; not yet
 	mov.l	@fIP+, r0	; grab offset and bump fIP before we go
 	rts
 	add.l	#2*NATURAL_SIZE, fRP	; drop I and limit before we return
 ;
-xPLOOPminus:
+XPLOOPminus:
 	cmp/ge	r0, r1		; limit (r1) >= counter (I=r0) ?
 	bt/s	BRANCHgo	; not yet
 	mov.l	@fIP+, r0	; grab offset and bump fIP before we go
@@ -153,7 +151,7 @@ xPLOOPminus:
 ; (DO)    ( limit index --- )     ( *** limit index )
 ;         Move the loop parameters to the return stack.  Synonym for D>R, here.
 ; 
-	HEADER (DO), xPDO
+	HEADER	(DO), XDO
 	mov.l	@fSP+, r0
 	mov.l	@fSP+, r1
 	add 	#-2*NATURAL_SIZE, fRP
@@ -162,7 +160,32 @@ xPLOOPminus:
 	mov.l	r0, @fRP
 
 
+; CMOVE   ( source target count --- )
+;         Copy/move count bytes from source to target.  Moves ascending
+;         addresses, so that overlapping only works if the source is
+;         above the destination.
+;  	      Further specification is necessary on word addressing computers.
+;         Note -- In many cases, the source and target will not be an even 
+;         number of words apart, so we can't optimize to long moves. 
+;         Walks on r0-r3.
+;
+	HEADER	CMOVE, CMOVE
+	mov.l	@fSP, r0					; count
+	mov.l	@(NATURAL_SIZE,fSP), r2		; target
+	bra 	CMOVEenter
+	mov.l	@(2*NATURAL_SIZE,fSP), r1	; source (as we jump)
+CMOVEloop:
+	mov.b	@r1+, r3
+	mov.b	r3, @r2+
+	add 	#-1, r0
+CMOVEenter:
+	cmp/eq	#0, r0
+	bf  	CMOVEloop
+;
+	rts
+	add 	#3*NATURAL_SIZE, fSP	; Drop the parameters as we go.
 
+
 
 
 

--- a/symbol.inc
+++ b/symbol.inc
@@ -17,14 +17,13 @@
 ;         leave ptr2 pointing to the next byte.
 ;         Walks all over r0 and r1. Must leave fW untouched.
 ;
-	HEADER	(NAME-SCAN), xNAMESCAN
+	HEADER	(NAME-SCAN), PNAMESCAN
 	mov.l	@fSP, r1 
 	mov.b	@r1+, r0
-xNAMESCANloop:
+PNAMESCANloop:
 	and 	#CTFLAG, r0
 	cmp/eq	#CTFLAG, r0
-xNAMESCANstart:
-	bf/s 	xNAMESCANloop
+	bf/s 	PNAMESCANloop
 	mov.b	@r1+, r0
 ;
 	add 	#-1, r1
@@ -43,7 +42,7 @@ xNAMESCANstart:
 ;         (Names only save 3 significant characters in some FORTHs.)
 ;         Walks all over r0 - r3. Must leave fW untouched.
 ;
-	HEADER	(CHK-NAME), xCHKNAME
+	HEADER	(CHK-NAME), PCHKNAME
 	sts.l	pr, @-fRP	; so we can call stuff
 	mov.l	@fSP, r2	; name in dictionary
 	mov.l	@(NATURAL_SIZE, fSP), r3	; name in buffer
@@ -51,31 +50,31 @@ xNAMESCANstart:
 	and 	#CTMASK, r0	; Extract the actual count.
 	mov.b	@r3+, r1	; count byte in buffer
 	cmp/eq	r0, r1
-	bf  	xCHKNAMEno
-xCHKNAMEloop:
+	bf  	PCHKNAMEno
+PCHKNAMEloop:
 	mov.b	@r2+, r0	; character in dictionary
 	tst 	#TAILFLAG, r0
-	bt  	xCHKNAMElast
+	bt  	PCHKNAMElast
 	mov.b	@r3+, r1	; character in buffer
 	cmp/eq	r0, r1
-	bt  	xCHKNAMEloop
+	bt  	PCHKNAMEloop
 ;
-xCHKNAMEno:
+PCHKNAMEno:
 	mov 	#0, r3		; r3 is not touched by xNAMESCAN
-xCHKNAMEret:
-	bsr 	 xNAMESCAN
+PCHKNAMEret:
+	bsr 	PNAMESCAN
 	mov.l	r2, @fSP	; save it as we go
 	lds.l	@fRP+, pr	; Gotta have that return address!
 	rts
 	mov.l	r3, @-fSP	; flag it as we go
 ;
-xCHKNAMElast:	
+PCHKNAMElast:	
 	mov.b	@r3+, r1	; last character in buffer
 	and		#TAILMASK, r0
 	cmp/eq	r0, r1
-	bf  	xCHKNAMEno
+	bf  	PCHKNAMEno
 ;
-	bra 	xCHKNAMEret	
+	bra 	PCHKNAMEret	
 	mov 	#ALL_BITS8, r3	; Set the flag as we go.
 	
 	
@@ -86,34 +85,34 @@ xCHKNAMElast:
 ;         nfa is the NFA of the last entry in the vocabulary to be searched.
 ;         Walks all over r0 - r3, and fW.
 ;
-	HEADER	(FIND), xPFIND
+	HEADER	(FIND), PFIND
 	sts.l	pr, @-fRP	; so we can call stuff
 	mov.l	@fSP, r0
-xPFINDloop:
+PFINDloop:
 	mov.b	@r0, fW		; We aren't using fW anyway, and it doesn't get walked in.
-	bsr 	xCHKNAME
+	bsr 	PCHKNAME
 	mov.l	@fSP+, r0	; Did we find it?
 	cmp/eq	#0, r0
-	bf/s  	xPFINDfound	; Use the true flag in r0
+	bf/s  	PFINDfound	; Use the true flag in r0
 	mov.l	@fSP, r1	; LFA needed either way
 ;
 	mov.l	@r1, r0
 	cmp/eq	#0, r0
-	bt  	xPFINDnot
-	bra 	xPFINDloop
+	bt  	PFINDnot
+	bra 	PFINDloop
 	mov.l	r0, @fSP	; Store the next one to check as we go.
 ;
-xPFINDnot:
+PFINDnot:
 ;	mov 	#0, r0		; use the NULL pointer as a false flag
-	bra 	xPFINDret
+	bra 	PFINDret
 	add 	#2*NATURAL_SIZE, fSP	; bump as we go
 ;
-xPFINDfound:
+PFINDfound:
 	add 	#2*NATURAL_SIZE, r1		; pfa
 	mov.l	r1, @(NATURAL_SIZE,fSP)
 	mov.l	fW, @fSP	; Store the saved count byte, with mode bits.
 ;	mov 	#ALL_BITS8, r0	; We can reuse the flag that sent us here.
-xPFINDret:
+PFINDret:
 	lds.l	@fRP+, pr	; Gotta have that return address!
 	rts
 	mov.l	r0, @-fSP	; Flag it as we go.