by [ name | topic | voc ] [ glos | files | xref ] [ notation | dpans94 | syscalls ] [ bot | top ]

lib4th 1-1-4+18 short reference, sorted by topic (preliminary)

Text formatted for the lynx html-browser and for plain text printing, 132 chars/line

|                                                                                                                118>|

Name	Asm-Label	Wordlist	Comment
	(imed)
arithmetic, sing numeric (cons, vari) arithmetic, mixed sing w/ double or quad arithmetic, double and mixed w/quad arithmetic, quad and 8-cells integers bignum opr bignum mixed praecision bignum data-/return-stack opr rational sing, if L4 cpl'd w/ '-d__SRANUM' rational logic, all sizes rational double, for {ans} "FLOAT" words rational quad, for {ans} double "FLOAT"s rational cons, all sizes numeric data, words local memory, data opr bit-opr, sing bit-opr, double bit-opr, quad & bignum cpu-opr, all sizes data conversion, misc. data conversion, to display data conversion, to text data conversion, to numeric data structures disp's conversion specific to ans-voc and environmental queries editor, screen-/block-file access sequential file access block-file access file or termial i/o, device independent terminal i/o vt control hidden words, not for regular use compiler runtimes & vari vectored data, ptr's, words vectored words' defaults conditional interpreting interpreter uninitiated, independent of L4 kernel set-up logic, all integer sizes memory arithmetic and logic opr memory, sing memory, multiple cells, strings memory, quad memory, doubles memory, vectored & miscellaneous floating pt. sing numbers (per double ranum) floating pt. double numbers (per quad ranum) defining words code compiler program flow control data compiler assembler i/o port access return-stack sing, doubles, quad data-stack doubles data-stack multiple cells data-stack quad data-stack sing text, chars data, words utilitiy words vocabularies, relating opr forth, other words... linux specific, system system related words novoc, header-less or not implemented/not complete

arithmetic, sing numeric (cons, vari)
-	ssub	forth	( n1 n2 -- n3 ) subtract sings
/	by	forth	( n1 n2 -- n3q ) div sings, leave quot
*	smul	forth	( n1 n2 -- n3 ) mul sings
*/	mulby	forth	( n1 n2 n3 -- n5q ) n1 / n2 * n3, qot n4
+	plus	forth	( n1 n2 -- n3 ) add sings
+-	spm	forth	( n1 n2 -- n3 ) apply sign of sing @tos to sing
0max	zmax	forth	0 max ; not less than 0
1-	sub1	forth	dec sing by one
1+	add1	forth	inc sing by one
10*	mul10	forth	mul sing by ten
16*	mul16	forth	mul sing by sixteen
16/mod	div16m	forth	div/mod sing by sixteen
1abs	abs1	forth	one-s complement if sing -ve
2-	sub2	forth	dec sing by two
2/	div2	forth	div sing by two
2*	mul2	forth	mul sing by two
2+	add2	forth	inc sing by two
3*	mul3	forth	mul sing by three
4-	sub4	forth	dec sing by four
4/	div4	forth	div sing by four
4*	mul4	forth	mul sing by four
4+	add4	forth	inc sing by four
5*	mul5	forth	mul sing by five
6*	mul6	forth	mul sing by six
7*	mul7	forth	mul sing by seven
8-	sub8	forth	dec sing by eight
8/	div8	forth	div sing by eight
8*	mul8	forth	mul sing by eight
8+	add8	forth	inc sing by eight
9*	mul9	forth	mul sing by nine
abits	mul8	ans	mul by no. of bits per address unit
ABS	aabs	ans	two-s cpl if sing -ve, '-0' unchanged
abs	cabs	forth	two-s cpl if sing -ve, '-0' -> 0
base	base	forth	number conversion radix
base!	bases	forth	sto to {base}
base@	basef	forth	fetch {base} base value
binary	binary	forth	store 2 to base
cell-	sub4	forth	dec sing by no. of bytes per cell (4)
CELL/	cellby	ans	floored div sing by bytes per cell (4)
cell+	add4	forth	inc sing by no. of bytes per cell (4)
CELLS	mul4	ans	mul sing by bytes per cell (4)
char-	sub1	forth	dec sing by bytes per char (1)
char+	add1	forth	inc sing by bytes per char (1)
chars	noop	forth	mul sing by bytes per char (1)
decimal	decimal	forth	sto 10 to base
dpl	dpl	forth	decimal point location of just converted number
dpl@	dplfetch	forth	fetch dpl
edpl@	edplfetch	forth	fetch optional num. input exponent value
gcd	gcd	forth	( n1 n2 -- n3 ) greatest common denominator
hex	hex	forth	sto 16 to base
lg2	lg2	forth	numerus of log at base 2 of item @tos
lg(base)	lgbase	forth	numerus of log at @base of item @nos
log	log	forth	numerus of log at base @tos of item @nos
max	max	forth	( n1 n2 -- f ) leave the greater of top two sings
min	min	forth	( n1 n2 -- f ) leave the smaller of top two sings
minus	negate	fig	( n1 -- n2 ) negate sing
mod	mod	forth	( n1 n2 -- n3r ) div sings, leave rmd
/mod	bymod	forth	( n1 n2 -- n3r n4q ) div sings, leave quot & rmd
*/mod	mulbym	forth	( n1 n2 n3 -- n4r n5q ) n1 / n2 * n3, rmd n4 & qot n5
negate	negate	forth	( n1 -- n2 ) negate sing
?NEGATE	spm	ans	( n1 n2 -- n3 ) apply sign of sing n2 to sing n1
octal	octal	forth	sto 8 to base
over-	overm	forth	over -
over+	overp	forth	over +
sgn	sgn	forth	( n1 -- n2 ) sign of sing
umax	umax	forth	( n1 n2 -- n3 ) leave unsigned greater of top two sings
umin	umin	forth	( n1 n2 -- n3 ) leave unsigned smaller of top two sings
uwithin?	uwithinq	forth	unsigned test & adjust 3rd w/ range of 2nd..1st
within?	withinq	forth	signed test & adjust 3rd w/ range of 2nd..1st

arithmetic, mixed sing w/ double or quad
^	pow	forth	( n1 n2 -- d ) double, sing to the power of sing
2^	pow2	forth	( n1 -- d1 ) 2^n sing -> double
d+-	dpm	forth	( d1 n -- d2 ) apply sign of sing to double @nos
dm*	dmmul	forth	( d1 d2 -- d3 n ) mul doubles, leave 3-cells prod.
factorial	factorial	forth	( u1 -- ud2 ) double factorial of u1, -1 < u1 < 21
fm/mod	fmbymod	forth	( d1 n2 -- n3r n4q ) floored double by sing
m/	mby	forth	( d1 n2 -- n3r d4q )
m*	mmul	forth	( n1 n2 -- d3 ) mul sings, leave double prod
m*/	mmulby	forth	( d1 n2 n3 -- d4q ) d1 * n2 / n3
m+	mplus	forth	( d1 n2 -- d3 ) signed add sing to double @nos
md*	mdmul	forth	( d1 d2 -- q ) mul doubles, leave quad prod.
m/mod	mbym	forth	( d1 n2 -- n3r n4q ) vectored sm/rem(dft) or fm/mod
q+-	qpm	forth	( q1 n2 -- q3 ) apply sign of sing n1 to quad
sm/rem	smbyrem	forth	( d1 n2 -- n3r n4q ) div round near zero
u^	upow	forth	( u1 u2 -- ud3 ) unsigned double, n1 to the power of n2
u*	umul	forth	( u1 u2 -- ud3 )
u+	uplus	forth	( ud1 u2 -- ud3 ) unsigned add sing to double
u16/mod	ubym16	forth	( u1 -- u2r u3q ) udiv by 16, rmd = u2r
u4/mod	ubym4	forth	( u1 -- u2r u3q ) udiv by 4, rmd = u2r
u8/mod	ubym8	forth	( u1 -- u2r u3q ) udiv by 8, rmd = u2r
udm*	udmmul	forth	( ud1 u2 -- ud3 n4 ) treble prod, n4 = ovf
udm*/mod	udmmulbym	forth	( d1 n2 n3 -- u5r ud4q ) d1 u* n2 u/ n3
um/	umby	forth	( ud1 n2 -- u3r ud4q )
um*	umul	forth	( u1 u2 -- ud3 )
um*/	ummulby	forth	( n1 n2 n3 -- ud4q ) n1 u* n2 u/ n3
um/mod	umbymod	forth	( ud1 u2 -- u2r u3q )
u/mod	ubym	forth	( u1 u2 -- u2r u3q )
umq^	umqpow	forth	( n1 n2 -- uq3 ) unsigned quad n1^n2
uqsm/	uqsmby	forth	( q1 n2 -- n3 q4 ) q by sing, ret quad quot, sing rmd
uqsm*	uqsmmul	forth	( q1 n2 -- q3 n4 ) mul quad by sing to 5 cells prod

arithmetic, double and mixed w/quad
d-	dsub	forth	( d1 d2 -- d3 ) subtract doubles
d/	dby	forth	( d1 d2 -- d3 ) d3=quot of div
d*	dmul	forth	( d1 d2 -- d3 ) d3=prod of mul
d+	dplus	forth	( d1 d2 -- d3 ) add doubles
d1-	donem	forth	( d1 -- d2 ) dec double by one
d1+	donep	forth	( d1 -- d2 ) inc double by one
d1abs	d1abs	forth	( d1 -- d2 ) bitwise one-s cpl doubles if -ve
d2-	dtwom	forth	( d1 -- d2 ) dec double by two
d2/	dtwoby	forth	( d1 -- d2 ) div double by two
d2*	dmul2	forth	( d1 -- d2 ) mul double by two
d2+	dtwop	forth	( d1 -- d2 ) inc double by two
d4-	dfourm	forth	( d1 -- d2 ) dec double by four
d4/	dfourby	forth	( d1 -- d2 ) div double by four
d4*	dmul4	forth	( d1 -- d2 ) mul double by four
d4+	dfourp	forth	( d1 -- d2 ) inc double by four
d8-	deightm	forth	( d1 -- d2 ) dec double by eight
d8/	deightby	forth	( d1 -- d2 ) div double by eight
d8*	dmul8	forth	( d1 -- d2 ) mul double by eight
d8+	deightp	forth	( d1 -- d2 ) inc double by eight
dabs	dabs	forth	( d1 -- d2 ) two-s cpl doubles if -ve
df/mod	dfbym	forth	floored div doubles w/ remainder
dgcd	dgcd	forth	( d1 d2 -- d3 ) greatest common denominator, doubles
dmax	dmax	forth	( d1 d2 -- d3 ) leave the greater of two doubles on tos
dmin	dmin	forth	( d1 d2 -- d3 ) leave the smaller of two doubles on tos
dminus	dnegate	fig	( d1 -- d2 ) negate a double
dmod	dmod	forth	div doubles, leave double rmd
d/mod	dbym	forth	( d1 d2 -- d3 ) d3=rmd of div
dnegate	dnegate	forth	( d1 -- d2 ) two-s complement of a double
dsgn	dsgn	forth	( dn -- f ) f=signum(dn)
dslbits	dslbits	forth	( d1 -- d1 n ) no. of top zero-bits less 2
qdfm/mod	qdfmbym	forth	( q1 d2 -- d3r d4q ) floored q by d, ret doubles
ud/	udby	forth	div doubles, leave double quot
ud*	udmul	forth	mul doubles, leave double prod
ud/mod	udbym	forth	div doubles, leave double quot & rmd
udsqrt	udsqrt	forth	( d1 -- d2 n ) +ve double square root, sing 'j'-flag
udsqrt	fudsqrt	nonmmx	+ve double square root of double, sing 'j'-flag
umd*	umdmul	forth	( ud1 d2 -- uq3 )
uqd*	uqdmul	forth	( q1 d2 -- q3 d4 ) mul quad by duble to 6 cells prod
uqd/mod	uqdbym	forth	( q1 d2 -- d3r d4q ) q by d, double quot & rmd
uqm/mod	uqmbym	forth	( q1 d2 -- d3r q4q ) q by d, quad quot, double rmd

arithmetic, quad and 8-cells integers
3rd-q1+	q1pt	hidden	( q1 qx qy -- q2 qx qy ) inc quad q1 by one
3rd-q2*	qmul2t	hidden	( q1 qx qy -- q2 qx qy ) mul quad q1 by two
3rd-uq2/	uqdiv2t	hidden	( q1 qx qy -- q2 qx qy ) unsigned div quad q1 by two
nos-q1-	q1mn	hidden	( q1 qx -- q2 qx ) dec quad @nos by one
nos-q1+	q1pn	hidden	( q1 qx -- q2 qx ) inc quad @nos by one
nos-q2/	qdiv2n	hidden	( q1 qx -- q2 qx ) div quad @nos by two
nos-q2*	qmul2n	hidden	( q1 qx -- q2 qx ) mul quad @nos by two
nos-qnegate	qnegaten	hidden	( q1 qx -- q2 qx ) negate quad @nos
nos-uq2/	uqdiv2n	hidden	( q1 qx -- q2 qx ) unsigned div quad @nos by two
o-	osub	hidden	( o1 o2 -- o3 ) subtract 8-cells numbers
o+	oplus	hidden	( o1 o2 -- o3 ) add 8-cells numbers
o1+	o1p	hidden	( o1 -- o2 ) inc eight-cells integer by one
onegate	onegate	hidden	( o1 -- o2 ) negate eight-cells integer
q-	qsub	forth	( q1 q2 -- q3 ) subtract quad numbers
q/	qby	forth	( q1 q2 -- q3q ) quot of quad div
q*	qmul	forth	( q1 q2 -- o3 ) signed mul quad by quad to 8 cells prod
q+	qplus	forth	( q1 q2 -- q3 ) add quad numbers
q1-	qonem	forth	( q1 -- q2 ) decrement quad by one
q1+	qonep	forth	( q1 -- q2 ) increment quad by one
q1abs	q1abs	forth	( q1 -- q2 ) one-s complement if quad -ve
q2/	qdiv2	forth	( q1 -- q2 ) signed 'round near zero' div quad by 2
q2*	qmul2	forth	( q1 -- q2 ) mul quad by 2
qabs	qabs	forth	( q1 -- q2 ) two-s complement if quad -ve
qfm/mod	qfmbym	forth	( q1 d2 -- d3r q4q ) floored q by d, ret quad,double
qf/mod	qfbym	forth	( q1 q2 -- q3r q4q ) floored div q/q, ret q,q
qgcd	qgcd	forth	( q1 q2 -- q3 ) greatest common denominator
qlshift	qlshift	forth	( q1 n2 -- q3 ) shift quad left
qmod	qmod	forth	( q1 q2 -- q3r ) rmd of quad div
q/mod	qbym	forth	( q1 q2 -- q3r q4q ) quot, rmd of quad div
qnegate	qnegate	forth	( q1 -- q2 ) negate quad
qrshift	qrshift	forth	( q1 n2 -- q3 ) unsigned shift quad right
qsgn	qsgn	forth	( q1 -- n2 ) sing sign value of a quad
qslbits	qslbits	forth	( q1 -- q1 n ) no. of top zero-bits less 2
qsm+	qsmplus	forth	( q1 n2 -- n3 ) signed add sing to quad
qsqrt	qsqrt	forth	( q1 -- q2 n3 ) quad square root of quad, sing 'j'-flag
uq*	uqmul	forth	( q1 q2 -- o3 ) unsigned mul q by q to 8 cells prod
uq2/	uqdiv2	forth	( q1 -- q2 ) unsigned div quad by 2
uqmax	uqmax	forth	( q1 q2 -- q3 ) unsigned greater of two quads
uqmin	uqmin	forth	( q1 q2 -- q3 ) unsigned smaller of two quads
uq/mod	uqbym	forth	( q1 q2 -- q3r q4q )

bignum opr
n^	npow	bignum	( n.N m -- p.P ) n.N to the power of m
n-	nsub	bignum	normalize & subtract two bignums
n->	ntoq	bignum	signed reduce bignum to minimal cell size
n/	nby	bignum	signed divide two counted ints
n*	nmul	bignum	multiply two counted ints
n+	nadd	bignum	normalize & add two bignums
n+-	npm	bignum	apply sign of sing to bignum
n1-	nonem	bignum	dec counted int by 1
n1+	nonep	bignum	inc counted int by 1
n2/	nn2div	bignum	divide counted int by 2
n2*	nn2mul	bignum	multiply counted int by 2
n/2^32	nd32	bignum	divide counted int by 2^32
n*2^32	nm32	bignum	multiply counted int by 2^32
nabs	nabs	bignum	abs value of counted int
ncmp	ncmp	bignum	ret sign of subtraction of two bignums
ngcd	ngcd	bignum	ret greatest common divisor of two bignums
nminus	nminus	bignum	2's cpl of counted int
n/mod	nbym	bignum	signed divide two counted ints w/ remainder
n->n	nton	bignum	sign extend bignum
nnegate	nminus	bignum	negate counted int
nnorm	nnorm	bignum	normalize top two bignums to equal size
nsgn	nsgn	bignum	( n1.N -- n2 ) signum of a counted int
nsqrt	nsqrt	bignum	( n1 -- n2.N ) square root of a counted int
n->un	n2un	bignum	modify bignum to unsigned
un->un	untoun	bignum	( n1.N M -- n2.M ) unsigned extend counted int

bignum mixed praecision
2n->2q	n22q	bignum	bignum pair to quad
2n->2uq	n22uq	bignum	bignum pair unsigned to quad
2q->2n	q22n	bignum	quad pair to bignum
2q->2un	q22un	bignum	quad pair unsigned to bignum
lg(nn)	lgnn	bignum	sing numerus of log(bignum)(sing)
nn->dd	n22d	bignum	bignum pair to data
n->q	n2q	bignum	bignum to quad
q->n	q2n	bignum	( q1 -- n1.N ) quad to bignum
s>nfactorial	s2nfac	bignum	( n1 -- n2.N ) counted int factorial of a sing
uns*	unsmul	bignum	( n1.N n2 -- n3.(N+1) ) unsgd mul counted int by sing
uns/mod	unsbym	bignum	( n1.N n2 -- q3.Q n4r ) unsgd div counted int by sing

bignum data-/return-stack opr
n2dup	nn2dup	bignum	dup double counted int
ndrop	ndrop	bignum	drop counted int
nndrop	nndrop	bignum	drop a number of counted ints
nndup	nndup	bignum	dup counted int
nnover	nnover	bignum	over counted int
nnpick	nnpick	bignum	pick counted int
nn>r	nntor	bignum	counted int from data-stack to return-stack
nnr>	nnrfrom	bignum	bignum from return-stack to data-stack
nnroll	nnroll	bignum	+/- roll counted ints
nnrot	nnrot	bignum	( n1.N m2.M o3.O -- m2.M o3.O n1.N ) rot counted ints
nn-rot	nnmrot	bignum	rot back counted ints
nnsdrop	nnsdrop	bignum	( n.N m.M -- m.M ) , -1 nnpick
nnswap	nnswap	bignum	( n1.N m2.M -- m2.M n1.N ) swap counted ints
n@sp	nnposn	hidden	cells disp to indexed 'bignum'

rational sing, if L4 cpl'd w/ '-d__SRANUM'
1/v	vrecip	rational	( v1 -- v2 ) abs(1 div by v1)
>ch	gtch	rahidden	( p u c -- n ) find 1st occurrence of char c
#digits	pdoval	rational	max displayed no. of ranum fractional digits
>double	todouble	rational	convert stg to double number
#dp	pdoval	forth	floating pt. fraction marker char, dft=","
dv>udv?	dv2udvq	rahidden	( dv -- udv flg ) |dv| and sign flag
dv>uqv?	dv2uqvq	rahidden	( dv -- +qv f ) |dv| to quad and sign flag
dv>v	dv2v	rational	( dv -- v ) convert double to sing ranum
e^v	epowv	rational	( v1 -- v2 ) v2 <- e^v1
#fd	pdoval	rahidden	ranum integral part delimiter, dft=<bl>
#fplaces	pdoval	forth	max no. of {f.} fraction digits, dft=14
#fround	pdoval	rational	-ve(dft) or no. of f.p. fractional digits
#n!v	pdoval	rahidden	max+1 for sing factorial calculations, dft=13
s>dvfactorial	s2dvfac	rational	( +n -- dv ) factorial of n
s>v	s2v	rational	( n -- v ) signed sing to vulgar
s>vfactorial	s2vfac	rational	( +n -- v ) factorial of n
truncation	pdoval	rational	suppress trailing zeroes if non-zero(dft)
ud>n?	ud2nq	rahidden	( ud -- +n f ) tf if ud not in range of +ve sing
<#v#>	ltvgt	rahidden	( v -- p u ) convert v to rational num stg
#v	sharpv	rational	( +v -- 0 0 ) app stg to num output buf, for v.
v-	vsub	rational	( v1 v2 -- v3 ) v1 minus v2.
v!	vstore	rational	( v p -- ) store ranum v to memory at p
v/	vby	rational	( v1 v2 -- v3 ) quot of v1 divided by v2.
v.	vdot	rational	( v -- ) display rational number
v@	vfetch	rational	( p -- v ) fetch ranum v from memory at p
v*	vmul	rational	( v1 v2 -- v3 ) product of v1 and v2.
v+	vplus	rational	( v1 v2 -- v3 ) sum of v1 and v2.
v+-	vpm	rational	( v1 n -- v2 ) negate if -ve n
v1-	vonem	rational	( v1 -- v2 ) v2 <- v1 - 1
v1+	vonep	rational	( v1 -- v2 ) v2 <- v1 + 1
v2/	v2div	rational	( v1 -- v2 ) v2 <- v1/2
v2*	v2mul	rational	( v1 -- v2 ) v2 <- v1*2
vabs	vabs	rational	( v1 -- v2 ) negate if v1 -ve
vconstant	vconstant	rational	( -- v ) non-alterable constant
vdigits>	vdigitsgt	rahidden	( -- un ) largest num w/ no. {digits} digits
vdrop	vdrop	rational	( v1 -- v1 v1 )
vdup	vdup	rational	( v1 -- v1 v1 )
v>dv	v2dv	rational	( v1 -- dv2 ) expand sing v1 to double dv2
<#vf#>	ltvfgt	rahidden	( v -- p u ) convert v to floating pt num stg
#vf	sharpvf	rational	( +v -- 0 0 ) app stg to num output buf, for f.
vfrac	vfrac	rational	( v1 -- +v2 ) fractional component of v1
vinteger	vinteger	rational	( -- v ) constant, alterable before being cpl'd
v.j	vdotj	rational	( left right v -- ) justified disp. ranum
vliteral	vliteral	rational	( v -- | v ) compile/interpret ranum as a dliteral
vm*	vmmul	rational	( v1 v2 -- dv ) double product of v1 and v2.
vmax	vmax	rational	( v1 v2 -- v3 ) the larger of v1 and v2.
vmin	vmin	rational	( v1 v2 -- v3 ) the smaller of v1 and v2.
v^n	vpown	rational	( v n -- ) raise ranum to the power of sing
vnegate	vnegate	rational	( v1 -- v2 ) v2 = -v1
vnormal	vnormal	rational	( dv -- v ) approximate double to sing ranum
vover	vover	rational	( v1 v2 -- v1 v2 v1 )
voverflow	voverflow	rational	( v -- f ) tf if v was overflow indicator value
vpick	vpick	rational	( ... n -- ... vn )
vreduce	vreduce	rational	( v1 -- v2 ) normalize to prime components
vroll	vroll	rational	( ... n -- ... vn )
vrot	vrot	rational	( v1 v2 v3 -- v2 v3 v1 )
v-rot	vmrot	rational	( v1 v2 v3 -- v3 v1 v2 )
vround	vround	rational	( v1 +n -- v2 ) v2 is an approximation to v1
v>s	v2s	rational	( v -- n ) floored, integral component of v.
vsgn	vsgn	rational	( v1 -- -1|0|1 ) unit of v1
vsimplify	vsimplify	rational	( v1 +n -- v2 ) v2 is an approximation to v1
vsplit	vsplit	rational	( v1 -- v2 v3 ) {v>s} & {vfrac}
vsqrt	vsqrt	rational	( v1 -- v2 ) square root of a ranum
vswap	vswap	rational	( v1 v2 -- v2 v1 )
v>uv?	v2uvq	rahidden	( v -- +v f ) |v| and sign flag
vvariable	vvariable	rational	( -- p ) 'ranum' (i.e. double) variable

rational logic, all sizes
dv~	dvaeq	rational	( dv1 dv2 -- f ) tf if dv1, dv2 approximately equal
dv<	dvlt	rational	( dv1 dv2 -- f ) tf if dv1 < dv2
dv=	dveq	rational	( dv1 dv2 -- f ) tf if dv1, dv2 exactly equal
dv>	dvgt	rational	( dv1 dv2 -- f ) tf if dv1 > dv2
dv0<	dvzlt	rational	( dv -- f ) tf if dv is -ve.
dv0=	dvzeq	rational	( dv -- f ) tf if dv zero.
flt?	fltq	forth	( -- n ) cells count if last num was a float
qv=	qveq	rahidden	( qv1 qv2 -- f ) tf if q1 equal to q2
?qv0=	qqvzeq	rahidden	( qv -- qv f ) tf if qv is zero.
small?	smallq	rahidden	( dv -- f ) tf if "normal"izeable
v~	vaeq	rational	( v1 v2 -- f ) tf if v1 approximately equal to v2.
v<	vlt	rational	( v1 v2 -- f ) tf if v1 less than v2.
v=	veq	rational	( v1 v2 -- f ) tf if v1 exactly equal to v2.
v>	vgt	rational	( v1 v2 -- f ) tf if v1 greater than v2.
v0<	vzlt	rational	( v -- f ) tf if v negative.
v0=	vzeq	rational	( v -- f ) tf if v zero.

rational double, for {ans} "FLOAT" words
10^dv	powdv10	rational	( dv1 -- dv2 ) dv1 to the power of ten
1/dv	dvrecip	rational	( dv1 -- dv2 ) abs(1 div by dv1)
acos(dv)	acosdv	rational	( dv1 -- dv2 ) arcus cosinus
asin(dv)	asindv	rational	( dv1 -- dv2 ) arcus sinus
atg(dv)	atgdv	rational	( dv1 -- dv2 ) arcus tg
cos(dv)	cosdv	rational	( dv1 -- dv2 ) cosinus
d>dv	d2dv	rational	( dn -- dv ) double int signed to double ranum
df#.	dfdecdot	rational	( dv -- ) display ranum in floating pt format, decimal
<#dv#>	ltdvgt	rahidden	( dv -- p u ) convert dv to rational num stg
#dv	sharpdv	rational	( +dv -- 0 0 ) app stg to ranum output buf
dv^	dvpowdv	rational	( dv1 dv2 -- dv3 ) double dv1 to the power of dv2
dv-	dvsub	rational	( dv1 dv2 -- dv3 ) diff.
dv!	dvstore	rational	( dv p -- ) store ranum dv to memory at p
dv/	dvby	rational	( dv1 dv2 -- dv3 ) div doubles
dv@	dvfetch	rational	( p -- dv ) fetch ranum dv from memory at p
dv*	dvmul	rational	( dv1 dv2 -- dv3 ) double ranum product
dv*/	dvmulby	rational	( dv1 dv2 dv3 -- dv4 ) mul dv1 by dv2 div by dv3
dv%	dvvh	rational	( dv1 dv2 -- dv3 ) per 100
dv+	dvplus	rational	( dv1 dv2 -- dv3 ) sum
dv+-	dvpm	rational	( dv1 n -- dv2 ) negate if -ve n
dv1-	dvonem	rational	( dv1 -- dv2 ) subtract 1 from dv1
dv1+	dvonep	rational	( dv1 -- dv2 ) add 1 to dv1
dv2/	dv2div	rational	( dv1 -- dv2 ) dv2 <- dv1/2
dv2*	dv2mul	rational	( dv1 -- dv2 ) dv2 <- dv1*2
dv2dup	dv2dup	rational	( dv1 dv2 -- dv1 dv2 dv1 dv2 )
dvabs	dvabs	rational	( dv -- |dv| ) negate dv if -ve
dvcmp	dvcmp	rational	( dv1 dv2 -- dv1 dv2 n ) signum(dv1-dv2)
dvconstant	dvconstant	rational	( -- dv ) non-alterable constant
dv>d	dv2d	rational	( dv -- dn ) dv to floored double int
dvdepth	dvdepth	rational	number of double ranum sized items on data-stack
dv>dn	dv2dn	rational	( dv1 -- dn ) dv to signed double int
dvdrop	dvdrop	rational	( dv1 -- dv1 dv1 )
dvdup	dvdup	rational	( dv1 -- dv1 dv1 )
<#dvf#>	ltdvfgt	rahidden	( dv -- p u ) convert dv to floating pt num stg
#dvf	sharpdvf	rational	( +dv -- 0 0 ) app stg to float output buf
dv>floor	dv2floor	rational	( dv1 -- dv2 ) floored integral value
dvfrac	dvfrac	rational	( dv -- dv ) fractional component of dv
dvfround	dvfround	rational	( dv1 -- dv2 ) round for floating point stg
dv>int	dv2int	rational	( dv1 -- dv2 ) signed integral value
dvinteger	dvinteger	rational	( -- dv ) constant, alterable before being cpl'd
dvliteral	dvliteral	rational	( dv -- | dv ) compile/interpret ranum as a dliteral
dvm/	dvmby	rational	( dv1 v2 -- dv3 ) div double by sing
dvm*	dvmmul	rational	( dv1 dv2 -- qv3 ) quad ranum product
dvmax	dvmax	rational	( dv1 dv2 -- dv3 ) the larger of dv1 and dv2.
dvmin	dvmin	rational	( dv1 dv2 -- dv3 ) the smaller of dv1 and dv2.
dvnegate	dvnegate	rational	( dv1 -- dv2 ) negate dv1
dvover	dvover	rational	( dv1 dv2 -- dv1 dv2 dv1 )
dvoverflow	dvoverflow	rational	( dv -- f ) tf if dv was overflow indicator value
dvpick	dvpick	rational	( ... n -- ... dvn )
dv>qv	dv2qv	rational	( dv1 -- qv2 ) expand double dv1 to quad qv2
dvrandom	dvrandom	rational	( dv1 -- dv2 ) random number in range [0,dv1)
dvreduce	dvreduce	rational	( dv1 -- dv2 ) reduce by greatest common divisor
dvroll	dvroll	rational	( ... n -- ... dvn )
dvrot	dvrot	rational	( dv1 dv2 dv3 -- dv2 dv3 dv1 )
dv-rot	dvmrot	rational	( dv1 dv2 dv3 -- dv3 dv1 dv2 )
dvround	dvround	rational	( dv1 +dn -- dv2 ) approximation to dv1
dv^s	dvpows	rational	( dv1 n -- dv2 ) dv1 to the power of a sing
dv>s	dv2n	rational	( dv -- dn ) dv to signed sing
dvsgn	dvsgn	rational	( dv -- n ) signum
dvsimplify	dvsimplify	rational	( dv1 +dn -- dv2 ) approximation
dvsplit	dvsplit	rational	( dv1 -- dv2 dv3 ) integral dv2 and fractional dv3
dvsqrt	dvsqrt	rational	( dv1 -- dv2 ) square root of a double ranum
dvswap	dvswap	rational	( dv1 dv2 -- dv2 dv1 )
dvvariable	dvvariable	rational	( -- p ) 'ranum' (i.e. double) variable
e^dv	epowdv	rational	( dv1 -- dv2 ) double e to the power of dv1
lg(dv)	lgdv	rational	( dv1 -- dv2 ) double ranum log dec.
ln(dv)	lndv	rational	( dv1 -- dv2 ) double ranum log naturalis
s>dv	s2dv	rational	( n -- dv ) sing int signed to double ranum
sincos(dv)	sincosdv	rational	( dv1 -- dv2 dv3 ) sinus dv2, cosinus dv3
sin(dv)	sindv	rational	( dv1 -- dv2 ) sinus
tg(dv)	tgdv	rational	( dv1 -- dv2 ) tangens
v2dup	v2dup	rational	( v1 v2 -- v1 v2 v1 v2 )
v>qv	v2qv	rational	( v1 -- qv2 ) expand sing v1 to quad qv2

rational quad, for {ans} double "FLOAT"s
1/qv	qvrecip	rahidden	( dv1 -- dv2 ) abs(1 div by dv1)
atg(qv)	atgqv	rahidden	( qv1 -- qv2 ) arcus tg
cos(qv)	cosqv	rahidden	( qv1 -- qv2 ) cosinus
d>qv	d2qv	rahidden	( dn -- qv ) double int signed to quad ranum
dv>uqv	dv2uqv	rahidden	( dv1 -- qv2 ) unsigned expand double to quad qv2
e^qv	epowqv	rahidden	( qv1 -- qv2 ) quad e to the power of qv1
ln(qv)	lnqv	rational	( qv1 -- qv2 ) log naturalis
n>qv	n2qv	rahidden	( n.N -- qv ) counted int trunc/signed to quad ranum
q>qv	q2qv	rahidden	( qn -- qv ) quad int signed to quad ranum
>quad	toquad	rahidden	ccc( -- q d f ) convert stg to quad number
qv^	qvpowqv	rahidden	( qv1 qv2 -- qv3 ) qv1 to the power of qv2
qv~	qvaeq	rahidden	( qv1 qv2 -- f ) tf if q1 approx. equal to q2
qv-	qvsub	rahidden	( qv1 qv2 -- qv3 ) subtract quad ranums
qv!	qvstore	rahidden	( qv p -- ) store ranum qv to memory at p
qv/	qvdiv	rahidden	( qv1 qv2 -- qv3 ) divide quad ranums
qv.	qvdot	rahidden	( qv -- ) display quad ranum
qv@	qvfetch	rahidden	( p -- qv ) fetch ranum qv from memory at p
qv*	qvmul	rahidden	( qv1 qv2 -- qv3 ) multiply quad ranums
qv+	qvplus	rahidden	( qv1 qv2 -- qv3 ) add quad ranums
qv1-	qvonem	rahidden	( qv1 -- qv2 ) subtract 1 from qv1
qv1+	qvonep	rahidden	( qv1 -- qv2 ) add 1 to qv1
qv2/	qv2div	rahidden	( qv1 -- qv2 ) signed divide by 2
qv2*	qv2mul	rahidden	( qv1 -- qv2 ) multiply by 2
qv2dup	qv2dup	rahidden	( qv1 qv2 -- qv1 qv2 qv1 qv2 )
qvabs	qvabs	rahidden	( qv1 -- qv2 ) negate if qv1 -ve
qvcmp	qvcmp	rahidden	( qv1 qv2 -- qv1 qv2 n ) signum of diff. qv1-qv2
qv>d	qv2dn	rahidden	( qv -- dn ) quad ranum signed to double int
qvdround	qvdround	rahidden	( qv1 +qn -- qv2 ) approx. qv1 to doubles' range
qvdup	qvdup	rahidden	( qv -- qv qv ) duplicate quad ranum
qv>dv	qv2dv	rational	( qv -- dv ) reduce quad, truncate, ret double ranum
qv>fq	qv2q	rahidden	( qv -- qn ) quad ranum floored to quad int
qvfrac	qvfrac	rahidden	( qv1 -- qv2 ) fractional component of qv1
qvinteger	qvinteger	rahidden	ccc(C qv1 -- )(X -- qv ) quad ranum integer
qvliteral	qvliteral	rahidden	( qv -- | qv ) quad ranum literal
qvm/	qvmby	rahidden	( qv1 dv2 -- qv3 ) quad ranum by double
qvnegate	qvnegate	rahidden	( qv1 -- qv2 ) negate quad ranum qv1
qvover	qvover	rahidden	( qv1 qv2 -- qv1 qv2 qv1 )
qvpick	qvpick	rahidden	+/- pick quad ranum, re {8pick}
qv>q	qv2qn	rahidden	( qv -- qn ) quad ranum signed to quad int
qvreduce	qvreduce	rahidden	( qv1 -- qv2 ) reduce quad ranum by g.c.d.
qvroll	qvroll	rahidden	+/- roll quad ranum, re {8roll}
qvrot	qvrot	rahidden	( qv1 qv2 qv3 -- qv2 qv3 qv1 ) 2 qvroll
qv-rot	qvmrot	rahidden	( qv1 qv2 qv3 -- qv3 qv1 qv2 ) -2 qvroll
qvround	qvround	rahidden	( qv1 +qn -- qv2 ) approximation to qv1
-qvround	mqvround	rahidden	( qv1 +qn -- qv2 ) approx. qv1 to range of a double
qv^s	qvpows	rahidden	( qv1 n -- qv2 ) qv1 to the power of a sing
qv>s	qv2n	rahidden	( qv -- n ) quad ranum signed to single int
qvsgn	qvsgn	rahidden	( qv1 -- n ) signum of a quad
qvsover	qvsover	rahidden	( qv1 qv2 -- qv2 qv1 qv2 ) swap and over
qvsplit	qvsplit	rahidden	( qv1 -- qv2 qv3 ) integral qv2 and fractional qv3
qvsqrt	qvsqrt	rahidden	( qv1 -- qv2 ) square root of a quad
qvswap	qvswap	rahidden	( qv1 qv2 -- qv2 qv1 )
qv>uqv?	qv2uqvq	rahidden	( qv -- uqv f ) |qv| and sign flag
qv>v	qv2v	rational	( qv -- v ) reduce quad, truncate, ret sing ranum
sincos(qv)	sincosqv	rahidden	( qv1 -- qv2 qv3 ) sinus qv2, cosinus qv3
sin(qv)	sinqv	rahidden	( qv1 -- qv2 ) sinus
s>qv	s2qv	rational	( n -- qv ) sing int signed to quad ranum
stg>qv	todfloat	rational	convert stg to quad ranum, i.e. double "float"
tg(qv)	tgqv	rahidden	( qv1 -- qv2 ) tangens

rational cons, all sizes
0dv	v0dv	racons	( -- dv ) 0
0qv	v0qv	racons	( -- qv ) 0
0v	v0v	racons	( -- v ) 0
100dv	v100dv	racons	( -- dv ) 100
10^(1/2)	casqr2n10	racons	( -- v )
1dv	v1dv	racons	( -- dv ) 1
-1dv	vm1dv	racons	( -- dv ) -1
1qv	v1qv	racons	( -- qv ) 1
-1qv	vm1qv	racons	( -- qv ) -1
1v	v1v	racons	( -- v ) 1
-1v	vm1v	racons	( -- v ) -1
2^(1/12)	casqr12n2	racons	( -- v )
2^(1/2)	casqr2n2	racons	( -- v )
3^(1/2)	casqr2n3	racons	( -- v )
bernulli(v)	bernulliv	racons	( n -- v ) sing, bernulli'sche zahlen
c	cac	racons	( -- v ) speed of light
dv.e	caed	racons	( -- dv ) the natural constant
dv.e^10	cae10d	racons	( -- dv ) 10 * lim (1+1/n)^n
dv.e^6	cae6d	racons	( -- dv ) 6 * lim (1+1/n)^n
dv.ln(10)	cdvln10	racons	( -- dv ) double, log 10 base e
dv.ln(2)	cdvln2	racons	( -- dv ) double, log 2 base e
dvovf	dvovf	racons	( -- dv ) double overflow indicator
e	cae	racons	( -- v ) natuerliche zahl
e^10	cae10	racons	( -- v ) 10 * lim (1+1/n)^n
e^6	cae6	racons	( -- v ) 6 * lim (1+1/n)^n
euler-c	caec	racons	( -- v ) euler'sche zahl
euler(v)	eulerv	racons	( n -- v ) sing, euler'sche zahlen
k(h)	cakphp	racons	( -- v ) CORDIC hyperbolic correction
k(t)	cakptp	racons	( -- v ) CORDIC trigonometric correction
lg(2)	calg2	racons	( -- v ) log 2 base 10
lg(e)	calge	racons	( -- v ) log e base 10
ln(10)	caln10	racons	( -- v ) log 10 base e
ln(2)	caln2	racons	( -- v ) log 2 base e
pi	capi	racons	( -- v ) pi, kreiszahl
qv.2/3pi	cqv23pi	racons	( -- qv ) quad pi*2/3
qv.2pi	cqv2pi	racons	( -- qv ) quad pi*2
qvovf	qvovf	racons	( -- qv ) quad overflow indicator
qv.pi/180	cqvpi180	racons	( -- qv ) quad pi/180, for rad<->deg conversion
qv.pi/2	cqvpi2	racons	( -- qv ) quad pi/2
qv.pi/4	cqvpi4	racons	( -- qv ) quad pi/4
qvrdv	qvmdv	racons	( -- qn ) quad int limit for qvround to range of double
vovf	vovf	racons	( -- v ) sing overflow indicator

numeric data, words
-0	mzero	forth	cons $80000000
-0.	dmzero	forth	dcons "-ve zero", only sign-bit set
0.	dzero	forth	dcons zero
-1.	dmone	forth	dcons -1
bl	bbl	forth	cons 32
blbl	blbl	hidden	cons 8224 (double bl)
blkhead-size	pdoval	blkfile	size of a per screenfile block header
bufhead-size	pdoval	blkfile	size of a (kernel-)block buffer header
casehead-size	caseheadsz	hidden	( -- n ) size in bytes of {case:}-list header
cdt-size	cdtsize	linux	size of channel defn storage
false	zero	forth	cons 0
heaphead-size	hpheads	linux	size of a heap/device description header
n#max	nhmax	bignum	max size for counted int to stg
n#size	nhsize	bignum	memory requirement for num to stg conversion
pad-size	padsize	forth	size of tmp. buffers in data-space
page-size	pagesize	linux	Linux kernel constant
place-size	placesize	forth	( -- n ) max. stg size for -re- {place}, {+place}
sighnd-size	sighsz	linux	size of a signal hnd definition block
stat-size	statsize	linux	size in bytes of file-status required buffer
tib-dft	tibdft	hidden	default t.i.b. location
tib-max	tibmax	hidden	storage size of t.i.b.
true	pone	fig	cons 1
true	true	forth	cons -1

local memory, data opr
{	loccb	forth	cpl locals list, un-/initiated & comment
l!!	dolxsto	novoc	xchg 2 locals
la:	doloca	novoc	allocate local values' memory
l-allot	lallot	forth	local data-space
>loc	toloc	forth	de-/allocation
loc!!	locxsto	local	exchange two local values
loc'	loctick	local	find a local values xt by supplied name
loc2!	loc2s	local	sto double local; sing -re- {to}
loc2@	loc2f	local	fetch double local; sing by name
(LOCAL)	plocalp	ans	local wordheader by supplied stg
local:	locol	hidden	def. a local alterable constant
locals	locals	forth	( -- n ) available cells for local data
locals|	locbar	forth	cpl initiated locals list
locals?	localsq	forth	tf if suffient no. of local cells available
loc-body	locbody	local	>body wrt local value, ptr to disp wrt @s0 field
loc-ptr	locptr	forth	ptr to local data-space { s0 @ loc-body @ - }
locref{	locref	forth	define locals referring list
locrmv	locrmv	compiler	intermediate local values de-allocation
;lv	dolocr	novoc	free local space
lv>	dolocc	novoc	cpl ref to local value
lv:	doloci	novoc	init a local value
lv@	dolocv	novoc	fetch interpreting defined locv.
lz:	dolocz	novoc	zero-init a local value

bit-opr, sing
and	aand	forth	( n1 n2 -- n3 ) bitwise AND sings
andx	andx	forth	( n1 n2 n3 -- n4 ) n1 n2 AND n3 XOR
bsf	bsff	forth	bit scan forward
bsr	bsrf	forth	bit scan reverse
cplb	cplb	forth	complement bit
invert	invert	forth	( n1 -- n2 ) 1-s complement
lshift	lshift	forth	( n1 n2 -- n3 ) shift left
not	invert	forth	( n1 -- n2 ) flag inversion, bitwise invert, cpu opr
or	oor	forth	( n1 n2 -- n3 ) bitwise OR sings
parity	parity	forth	ff if odd no of set bits in a sing
resb	resb4	forth	reset (clear) bit
rot-l	rotl	forth	bitwise rotate cell left
rot-r	rotr	forth	bitwise rotate cell right
rshift	rshift	forth	( n1 n2 -- n3 ) right shift
rshifta	rshifta	forth	( n1 n2 -- n3 ) arithmetic shift
setb	setb4	forth	set bit
shift	shift	forth	( n1 n2 -- n3 ) shift left
tstb	tstb	forth	test bit
xor	xxor	forth	( n1 n2 -- n3 ) bitwise XOR sings

bit-opr, double
2and	and2	forth	( d1 d2 -- d3 ) bitwise AND doubles
2invert	dnot	forth	( d1 -- d2 ) bitwise complement a double
2lshift	dlshift	forth	( d1 n -- d2 ) shift left a double
2not	dnot	fig	( d1 -- d2 ) one-s complement a double
2or	or2	forth	( d1 d2 -- d3 ) bitwise OR doubles
2rshift	drshift	forth	( d1 n -- d2 ) shift right a double
2rshifta	drshifta	forth	( d1 n -- d2 ) sign preserving shift right a double
2xor	xor2	forth	( d1 d2 -- d3 ) bitwise XOR doubles
dparity	dparity	forth	ff if odd no of set bits in a double

bit-opr, quad & bignum
4not	not4	forth	( q1 -- q2 ) bitwise complement top 4 cells
8not	not8	hidden	( o1 -- o2 ) bitwise complement top 8-cells item
nand	nand	forth	binary AND 2 groups of cells
ninvert	ninvert	bignum	1's cpl counted int
nlshift	nlshift	bignum	shift left counted int
nor	nor	forth	binary OR 2 groups of cells
nos-4not	not4n	hidden	( q1 qx -- q2 qx ) bitwise complement quad @nos
nrshift	nrshift	bignum	( n1.N n2 -- n2.M ) shift right counted int
nshift	nshift	bignum	( n1.N n2 -- n3.N ) shift bignum +n2 left, -n2 right
nxor	nxor	forth	binary XOR 2 groups of cells
true=	ftequ	fig	( n -- f ) tf if cell is f.i.g.-mode 'true' value
true=	tequ	forth	( n -- f ) tf if cell is ANS-mode 'true' value

cpu-opr, all sizes
bsfm	bsfm	forth	{bsf} memory
bsfr	bsfr	forth	{bsf} register
bsrm	bsrm	forth	{bsr} memory
bsrr	bsrr	forth	{bsr} register
bswap	bbswap	forth	swap bytes of a dword
cpuid	cpuidf	systm	cpu queries
emms	emmsf	forth	clr cpu mmx/fp state
femms	femmsf	nonmmx	clr fp & mmx state, sync cpu
flg	flg	tools	( -- n ) eflags, display w/ -re- {flg>smb}
?ms	qms	ans	time in milli-seconds since host startup
rdpmc	rdpmcf	systm	( -- d ) read perfromance monitoring counters
tick	tic	root	get current cpu clock count

data conversion, misc.
4th>abs	fth2abs	forth	ptr to address
abs>4th	abs2fth	forth	address to ptr
cc4th	cc4th	forth	xec vectored control character 4th actions
c->s	c2sn	forth	l.s.byte to sing (cell)
date	date4	forth	system time in seconds
day	day4	forth	day of system time
d->b	d2bn	forth	extract 8 bytes from double
defer-lk	pdovar	hidden	base link of deferred words
deg>rad	deg2rad	rational	( dv1 -- dv2 ) convert degrees to radians
d->q	d2qn	forth	double to quad
d>s	d2sn	forth	double to sing
d->s	d2sn	forth	double to sing
dv>ieee	f2ieee	rational	( f1 -- d2 ) ranum to ieee format
errno	erno	forth	cnv error name to number
errstg	errs	forth	cnv err number to name
forget-lk	pdovar	hidden	base link of specific forget actions
hash11	hash11	linux	ELF standard hash figure
ieee>dv	ieee2f	rational	( f1 -- d2 ) ieee to ranum format
is-case	iscase	forth	ccc( n1 n2 -- ) re-define item #n2 to n1
rad>deg	rad2deg	rational	( dv1 -- dv2 ) convert radians to sexagesimal degrees
s->c	s2cn	forth	signed sing to byte
S>D	s2dn	ans	signed sing to double
s->d	s2dn	forth	signed sing to double
s->w	s2wn	forth	signed sing to word
tick>s	tic2s	forth	convert cpu clock count to seconds
>time&date	totida	forth	cnv dn date to time&date format
time&date	timedate	forth	time & date in standard format
U>D	u2dn	ans	sing to unsigned double
u->d	u2dn	forth	sing to unsigned double
w->s	w2sn	forth	l.s.word to sing

data conversion, to display
?	ques	forth	( p - ) display numeric content of cell at ptr
.	fdot	floatop	( f1 -- ) 12.6.2.1427 12.6.2.1427
.	dot	forth	( n -- ) display signed sing
$.	hexdot	forth	( u -- ) sedecimal display unsigned sing
&.	octdot	forth	( u -- ) octal display unsigned sing
#.	decdot	forth	( u -- ) decimal display unsigned sing
%.	bindot	forth	( u -- ) binary display unsigned sing
b.	bdot	forth	( n1 n2 -- ) display n1 at radix n2
d.	ddot	forth	display signed double
df.	dvdotf	rational	( dv -- ) display ranum in floating pt format
df.j	dvdotfj	rational	( dv left right -- ) justified disp. fp-ranum
d.r	ddotr	forth	right aligned display signed double
dv.	dvdot	rational	( dv -- ) display rational number
dv.j	dvdotj	rational	( left right dv -- ) justified disp. ranum
F.	fdot	float	( f1 -- ) 12.6.2.1427 12.6.2.1427
f.	vdotf	rational	( v -- ) display ranum in floating pt format
FE.	fedot	float	n.i. - 12.6.2.1513 12.6.2.1513
f.j	vdotfj	rational	( left right v -- ) justified disp. fp-ranum
FS.	fsdot	float	n.i. - 12.6.2.1613 12.6.2.1613
n.	ndot	bignum	send numeric bignum stg to stdout
q.	qdot	forth	signed display a quad
qf.	qfdot	rahidden	( qv -- ) display quad ranum in f.p. format
qf#.	qfdecdot	rahidden	( qv -- ) decimal display quad ranum in f.p. format
qf.j	qfdotj	rahidden	( qv n1 n2 -- ) l/r justified display quad f.p.
q.r	qdotr	forth	( q1 n2 -- ) signed display a quad right aligned
.r	dotr	forth	( n1 n2 -- ) right aligned display signed sing n1
(r)	prp	hidden	formatted output fill char(s)
s#.	sdecdot	forth	signed #.
.time&date	dotimedate	forth	display full size system date
u?	uques	forth	unsigned display numeric content of cell at ptr
u.	udot	forth	unsigned display a sing
ud.	uddot	forth	unsigned display a double
ud.r	uddotr	forth	unsigned right aligned display a double
un.	undot	bignum	( .n1.N -- ) send unsigned numeric bignum stg to stdout
uq.	uqdot	forth	unsigned display a quad
uq.r	uqdotr	forth	( q1 n2 -- ) unsigned right aligned display a quad
u.r	udotr	forth	unsigned right aligned display a sing

data conversion, to text
<#	ltsharp	forth	begin number to stg conversion
#	sharp	forth	extract l.s. digit char from a double
#>	sharpgt	forth	terminate number to stg conversion
c>lower	c2lower	forth	convert char to lower-case
c>upper	c2upper	forth	convert char to upper-case
"date	sdate4	forth	stg w. system date
"day	sday4	forth	stg w. day of system time
daystg	daystg	forth	convert day no. to text
digit	digit	forth	convert char to digit + flag
ekey>asci	ekey2asci	forth	tf & char if code in 8bit ascii+ctrls range
ekey>char	ekey2char	forth	tf & char if code in range of printing chars
flg>smb	flg2smb	tools	( n -- p u )convert eflags bits to symbolic chars
hld	hld	forth	ptr to bot. of used number conversion buffer
hld0	hld0	hidden	initial hld after <#
(n.)	pndotp	bignum	convert signed counted int to stg
n<#	nlth	bignum	prepare counted int stg conversion
n#	nh	bignum	extract l.s. digit of bignum to stg
n#>	nhgt	bignum	finish counted int to stg conversion
n#?	nhq	bignum	ptr and flg whether stg conversion possible
n#s	nhs	bignum	convert bignum to numeric chars
>number	tonumber	forth	convert stg to number till non-valid char
q#	qsharp	forth	extract l.s. digit from a quad
q#>	qsharpgt	forth	terminate quad to stg conversion
q#s	qsharps	forth	convert quad to chars in {hld} buffer
represent	frepresent	rational	( dv p u -- n flg1 flg2 ) ranum normalized text repr.
#s	sharps	forth	convert a double to numeric chars
sign	sign	fig	fig-variant, sign cell 3rd from tos
SIGN	asign	forth	sign cell on tos
s>lower	s2lower	forth	convert stg to lower-case
s>upper	s2upper	forth	convert stg to upper-case
"time	stime4	forth	stg w. time
"time&date	stimedate	forth	stg w. full size system date
"timezone	stz4	linux	stg w. numeric 'timezone'
(un.)	pundotp	bignum	convert unsigned counted int to stg

data conversion, to numeric
a-base	abase	forth	determine stg to number conversion radix
a-number	anumber	ans	convert stg to number - ANS-mode
cc4cc!	cc4ths	forth	sto ctrl char xec vector
cc4cc@	cc4thf	forth	fetch ctrl char xec vector
CONVERT	converta	ans	convert stg to number - ANS-mode
convert	convert	fig	convert stg to number - f.i.g.-mode
convert	converta	forth	convert stg to number - ANS-mode
f-number	fnumber	fig	convert stg to double - f.i.g-mode
h>a	h2a	forth	convert char to numeric value
hold	hold	forth	store char to number conversion stg buffer
nnumber	nnumber	bignum	convert stg to counted int
n>number	ntonumber	bignum	convert stg to bignum until invalid char
NUMBER	anumber	ans	convert stg to double - ANS-mode
number	fnumber	fig	convert stg to double - f.i.g-mode
number	number	forth	vectored stg to double conversion
[number]	bnumberb	fig	f.i.g. mode stg to number conversion
[number]	abnumberb	forth	ANS mode stg to number conversion

data structures disp's conversion
>body	tobody	root	ptr to datafield by ix, for CREATEd words
body>lfa	body2lfa	hidden	ptr to lfa from data-"body"
cdt-flags	cdtflags	linux	disp of channel flags to channel defn ptr
cdt-fptr	cdtfptr	linux	disp of file ptr double cell to cdt ptr
cdt-xptr	cdtxptr	linux	disp of channel extn ptr to channel defn ptr
>data	todata	root	ptr to datafield by ix, wrt kernel-vari.
dsp>xec	dsp2xec	hidden	xec ptr from pc-rel ref at ptr
idx>do	idx2do	hidden	does>-entry per ix
idx>lfa	idx2lfa	root	lfa from uot index
idx>pfa	idx2pfa	hidden	pfa from uot index
idx>uds	idx2uds	hidden	disp to base of uot
idx>uot	idx2uot	hidden	ptr to uot entry from index
idx>wid	idx2wid	hidden	index to wordlist id
idx>xec	idx2xec	hidden	execution ptr from index
ifa>lfa	ifa2lfa	hidden	ptr to uot index from lfa
lfa>body	lfa2body	hidden	ptr to data-"body" from lfa
lfa>ffa	lfa2ffa	hidden	ptr to compileflags from lfa
lfa>head	lfa2head	hidden	beginning of word-header
lfa>idx	lfa2idx	forth	uot index from lfa
lfa>ifa	lfa2ifa	hidden	ptr to uot index from lfa
lfa>mfa	lfa2mfa	hidden	macro field from lfa
lfa>nfa	lfa2nfa	forth	ptr to name from lfa
lfa>pfa	lfa2pfa	forth	ptr to execution ptr from lfa
lfa>wid	lfa2wid	hidden	vocabulary linkfield
lfa>xec	lfa2xec	hidden	execution ptr from lfa
nfa>lfa	nfa2lfa	forth	ptr to linkfield from nfa
pfa>lfa	pfa2lfa	hidden	lfa from pfa
uds>idx	uds2idx	hidden	index from compiled disp to uot-ptr
uot>idx	uot2idx	hidden	index from uot-ptr
wid>idx	wid2idx	hidden	wordlist id to index
wid>lfa	wid2lfa	hidden	word-lfa from voc-link posn
wid>top	wid2top	hidden	ptr to top header in voc from voc-link posn
xec>idx	xec2idx	hidden	index from execution ptr
xec>lfa	xec2lfa	hidden	ptr to linkfield from execution ptr
xec>uot	xec2uot	hidden	ptr to execution ptr in uot from execution ptr

specific to ans-voc and environmental queries
2/	shr2	ans	signed shift sing right by one
ADDRESS-UNIT-BITS	aub	environment	consecutive bits per address unit
BLOCK	bcore	environment	wordset availabilty flag
BLOCK-EXT	bcorex	environment	wordset availabilty flag
caps?	capsq	forth	tf if text interpreting letter-case dependently
CORE	acore	environment	wordset availabilty flag
CORE-EXT	acorex	environment	wordset availabilty flag
/COUNTED-STRING	scstg	environment	max. length of a counted string
DATASTACK-SIZE	dss	environment	cells available for data-stack
DOUBLE	dcore	environment	wordset availabilty flag
DOUBLE-EXT	dcorex	environment	wordset availabilty flag
ENVIRONMENT?	envirq	root	( p u -- .xx. f ) ans-4th environment query
errno?	ernoq	forth	display known error names
EXCEPTION	xcore	environment	(untested, hi-level substitutes available)
EXCEPTION-EXT	xcorex	environment	wordset availabilty flag
FACILITY	ccore	environment	wordset availabilty flag
FACILITY-EXT	ccorex	environment	wordset availabilty flag
FILE	fcore	environment	wordset availabilty flag
FILE-EXT	fcorex	environment	wordset availabilty flag
FLOATING	flting	environment	wordset availabilty flag
FLOATING-EXT	fltingx	environment	wordset availabilty flag
FLOORED	floored	environment	flag whether defaul div is 'floored'
/HOLD	shold	environment	size of numeric stg conversion buffer
LIB4TH	l4e	environment	flag, "lib4th" present
LOCALS	lcore	environment	wordset availabilty flag
#LOCALS	nlocals	environment	cells available for local data
LOCALS-EXT	lcorex	environment	wordset availabilty flag
MAX-CHAR	mxc	environment	highest character code
MAX-D	mxd	environment	greatest signed double integer value
MAX-FLOAT	mxflt	environment	greatest floating pt. integral value
MAX-N	mxn	environment	greatest signed single integer value
MAX-U	mxu	environment	greatest unsigned single integer value
MAX-UD	mxud	environment	greatest unsigned double integer value
MEMORY-ALLOC	mcore	environment	RESIZE restricted to top alloc. block
/PAD	spad	environment	size of {pad} buffer
RETURNSTACK-CELLS	rsc	environment	cells available for return-stack
SEARCH-ORDER	score	environment	wordset availabilty flag
SEARCH-ORDER-EXT	scorex	environment	wordset availabilty flag
signo?	signoq	linux	display known signal names
STACK-CELLS	sss	environment	cells available for data-stack
STRING	gcore	environment	wordset availabilty flag
TOOLS	tcore	environment	wordset availabilty flag
TOOLS-EXT	tcorex	environment	wordset availabilty flag

editor, screen-/block-file access
1line	e1line	editor	find in curs-line
B	eB	editor	backup by text len in pad
b/b	bbyb	systm	bits per byte (8)
b/c	bbyc	editor	bytes per character (8)
blk@	blkfetch	forth	fetch {blk}
b/scr	bbyscr	fig	buffer blocks per screen(1)
C	eC	editor	indsert text
c/l	cbyl	fig	chars per line (64)
CLEAR	clear	editor	fill screen w/ blanks
col	col	vt	get cursor column
COPY	copy	editor	copy 1st to 2nd screen
c/scr	pdoval	editor	chars per editor screen (1024)
D	eD	editor	push line to pad
DELETE	delete	editor	del chars backward
E	eE	editor	blank line
editting	eding	blkfile	modify screenfile access to r/w
F	eF	editor	find text
FIND	efind	editor	find stg at pad in screen
H	eH	editor	copy line to pad
(hichar)	phicharp	hidden	upper case char codes
I	eI	editor	ins line from pad
L	relist	editor	re-list @{scr}
L-	relim	editor	list previous @{scr}
L+	relip	editor	list next @{scr}
#lag	hlag	editor	ptr & count after curs
#lead	hlead	editor	ptr & count till curs
LINE	line	editor	ptr to line or abort-16
.LINE	dotline	editor	display line/screen
(line)	plinep	editor	fetch line/screen
#lmg	pdoval	editor	editor screen & printing, left margin
#locate	hlocate	editor	line no, curpos
(lochar)	plocharp	hidden	lower case char codes
M	eM	editor	move curs
match	match	editor	search mem for stg
max-lw	maxlw	editor	max stdout line width
-move	mmove	editor	copy from ptr to line
N	eN	editor	next find
out	nout	forth	count of bytes sent after latest <eol>
P	eP	editor	put text to line
#pcol	pdoval	editor	text to file, chars/line
#prow	pdoval	editor	text to file, rows/page
R	eR	editor	replace line from pad
r#	unr	editor	uvari, chars count till cursor
reading	rding	blkfile	modify screenfile access to r/o
#rmg	pdoval	editor	editor screen & printing, right margin
row	row	vt	get cursor row
rows	rows	forth	count of lines sent after latest {open}
S	eSe	editor	ins empty line
scr	scr	forth	'screen' no. of current screenfile
T	eT	editor	type and copy line to pad
tab-to	tabto	forth	set cursor column, not less current posn
text	text	editor	fetch by char delimited text to pad
-text	mtext	editor	find text in stg
TILL	till	editor	erase till text end
to-col	tocol	vt	set cursor column
TOP	etop	editor	cursor to top left
to-row	torow	vt	set cursor row
TRUNCATE	truncate	editor	set size of screenfile
X	eX	editor	delete text
Y	eY	editor	insert stg

sequential file access
a-close	aclose	utility	close channels 5 till end of table
app	appf	linux	file open modifier, "append"
bin	binf	forth	useless, but ANS required file open modifier
block-lk	pdovar	blkfile	base link of screenfile storage blocks
cd	cdf	root	change cwd
channel	channel	forth	id and i/o-flags
ch-cons?	chconsq	linux	tf if echoing console flag set
chdir	chdirf	linux	change cwd to supplied
ch-eof	cheof	linux	tf if channel at eof
ch-flags	chflagsf	linux	channel flags dword
ch-id	chid	linux	channel identifier
ch-name	chname	forth	a channel's file name
chn-num	chnnum	linux	top chan a copy of which is in supplied ch-id
ch-omode	chomodef	linux	channel open mode
chp	chp	linux	ptr to channel definition table
chp>chan	chp2ch	linux	get channel no. by chp
ch-perm	chpermf	linux	channel permission bits
ch-pipe?	chpipeq	linux	tf if pipe flag set
ch-pty?	chptyq	linux	tf if pty-device flag set
ch-rnum	chrnum	linux	latest err code
ch-stat	chstat	linux	fetch channel state into cdt
ch-tag	chtag	linux	channel's tag no.
close-dir	closef	ans	close a directory-file
close-file	closef	forth	close a file
copy-file	copyf	forth	directly copy by names one file to another
cre	cref	linux	file open modifier, "create"
create-dir	cread	linux	create directory by supplied name
create-file	creaf	forth	overwriting open a file
ctag+	ctagp	system	inc channel tag kernel vari, ret old.
cwd@	cwdf	linux	get current working directory path-name
delete-file	deletf	forth	delete (not erase) a file
dir	dirf	linux	file open modifier, "type directory"
err-chan	pdoval	root	channel number of error channel
f"	fqte	forth	fname" w/ buffer at pad
f8dir	f8dir	forth	path to installed suppl. lib4th library files
f8doc	f8doc	utility	path to installed documentation files
(f8doc)	pdoval	utility	ptr to default documentation dir
f8glo	f8glo	utility	name of l4 glossary file
f8gls	f8gls	utility	( -- p u ) path+name of l4 glossary file
(f8gls)	pdoval	utility	ptr to default filename for {help}
(f8lib)	pdoval	utility	ptr to default support library dir
faccess	faccessfd	linux	by channel test file access permissions
fd>chan	fd2ch	linux	sto file descriptor to channel
file-access	faccessf	forth	by name test file access permissions
file>file	f2file	forth	directly copy between two files
file-position	fposf	forth	( n1 -- d2 er ) file-pointer by channel no.
file-size	fsizef	forth	( n1 -- n2 ) size of file by channel no.
FILE-STATUS	afstatf	ans	file state by name -re- linux {file-status}
file-status	fstatf	linux	file state by name -re- ans {FILE-STATUS}
[first]	pdoval	blkfile	bot. of 1st block buffer, 0 if unassigned
flush-file	flushf	forth	store cached buffers back to file by channel no.
[fname]	bfnameb	forth	find file in F8DIR & PATH, ret path+file-name
fname"	fnmqte	forth	find file in F8DIR & PATH, ret path+file-name
f-ok	fok	forth	file access query modifier
fopen	fopenf	forth	open file by fetched name
fposre	fposre	linux	adjust file-ptr relative to current posn
fstat	ffstatf	linux	file status by channel no.
get-chan	getchan	linux	fetch channel description data
in-chan	pdoval	root	channel number of input channel
?input	qinput	forth	( ch -- c f ) key/char input query by channel
is-chan	ischan	forth	copy {work}-channel description to supplied
[limit]	pdoval	blkfile	top+1 of last block buffer, 0 if unassigned
llseek	llseekf	linux	abs/rel set posn of file-ptr (syscall)
lock-file	lockf	linux	lock file, prevent write access
lxfiles	lxfiles	linux	host definitions source-files
lxpath	lxpath	linux	path to host definitions source
max-chan	maxchan	linux	max no. of supplied channel description tables
mcreate-dir	mcread	linux	create directory w/ supplied access mode
mcreate-file	mcreaf	linux	create file w/ supplied access mode
mfopen	mfopen	linux	open file w/ supplied access mode by fetched stg
mopen-file	mopenf	linux	open file w/ supplied access mode by supplied stg
nbl	nblf	linux	file access modifier to non-blocking
new-chan	newchan	forth	get next free channel no.
nof	noff	linux	file access modifier to not following links
open-dir	opendirf	linux	open directory-file by supplied name
open-file	openf	forth	open a file by supplied name
open-pipe	opipe	linux	open a pipe, ret i/o channels
out-chan	pdoval	root	channel number of output channel
path	epath	forth	PATH env. vari at prog startup time
path+file	pthfile	linux	find file in PATH, ret fully qualified path
path-max	pathmax	linux	max len of path string
pread	preadf	linux	read text at given fileptr
[prev]	pdoval	blkfile	ptr to most recently used block buffer
prt-chan	pdoval	linux	no. of printer channel
pwd	pwd	linux	( -- ) print working directory
pwrite	pwritef	linux	write text to given fileptr
read-char	readchar	forth	read a char from channel
read-file	readf	forth	read file until buffer full or <eof>
read-line	readl	forth	read file until <nl> or buffer full or <eof>
readlink	readlk	linux	read a linked files' source name
rename-file	renamf	forth	assign new name to a file by names
reposition-file	reposnf	forth	set file ptr to supplied posn
resize-file	resizef	forth	truncate file at supplied posn
r/o	rbyof	forth	( -- n ) file open mode modifier
r-ok	rok	forth	( -- n ) file access query modifier
r/w	rbywf	forth	( -- n ) file open mode modifier
rw?	rwq	forth	( c -- er ) whether a file is open in r/w mode
search-file	searchf	forth	search file for a string
set-chan	setchan	linux	store channel description from data-stack
source-chan	sourcechan	forth	channel of current input source
syn	synf	linux	file access modifier to blocking mode
to-chan	tochan	forth	copy a channel description
trn	trnf	linux	file access modifier to truncate after open
unlock-file	unlockf	linux	unlock file from preventing write access
[use]	pdoval	blkfile	ptr to block buffer to use next
wait4'	wait4t	linux	xec by name w/ temp. timeout
wait4ch	wait4ch	linux	sys_select for any channel's input timeout
wait4fd	wait4fd	linux	sys_select for any fd input timeout
wait4in	wait4in	linux	sys_select for console stdin timeout
wait4ti	wait4ti	linux	sys_select for any channel's timeout
wait4x	wait4x	linux	xec by xt w/ temp. timeout
w-close	wclose	forth	close the work-channel
w/o	wbyof	forth	file open mode modifier
w-ok	wok	forth	file access query modifier
work-chan	pdoval	linux	default {work} channel no.
work-num	worknum	linux	actual {work} no.
write-char	writechar	forth	write (multi-byte) char to channel
WRITE-FILE	awritefile	ans	write no. of bytes from buffer to file, ans-mode
write-file	writefile	forth	write no. of bytes from buffer to file
write-line	writeline	forth	write send string to file & append <lf> code
xg-chan	xgchan	forth	exchange two channel descriptions
xg-io	xgio	linux	exchange stdin and stdout channel descriptions
x-io	xio	root	exchange stdin,stdout,stderr w. in-chan &c.
x-ok	xok	forth	file access query modifier

block-file access
-->	pdodefer	root	-re- {load} next screen
[-->]	bnxldb	forth	dft for {load} or, for immediate xec
b/buf	bbybuf	forth	bytes per buffer-block (1K)
blk>buf	blk2buf	blkfile	ptr to screenfile buffer by blk#
blk>head	blk2head	blkfile	ptr to header of screenfile block by blk#
blk>lnk	blk2lnk	blkfile	ptr to buffer-block by block-no.
block	block	forth	xec.vec
(boot)	pdovar	blkfile	dft -re- {l-load} library file
+buf	plusbuf	fig	next buffer
buf>blk	buf2blk	blkfile	block no. assigned to a screenfile buffer
buffer	buffer	forth	xec.vec
buf>head	buf2head	blkfile	ptr to header of screenfile block by ptr
buf>lnk	buf2lnk	blkfile	ptr to buffer-block by block-buffer ptr.
del-buffer	fgbblok	blkfile	remove {latest} buffer block, if possible
dr?	schq	blkfile	whether {scr-chan} is dr0, dr1 or neither one
dr0	dr0c	forth	activate 1st screenfile channel
dr1	dr1c	forth	activate 2nd screenfile channel
empty-blk	emblk	blkfile	invalidate a single blockfile buffer
empty-buffers	embufs	forth	close scr-chan, make buffers available
first	first	fig	bot. of 1st block buffer, 0 if unassigned
flush	flush	forth	save updated blocks
head>blk	head2blk	blkfile	ptr to buffer by ptr to header
head>buf	head2buf	blkfile	block no. by ptr to header
ibbuf	ibbuf	blkfile	initiate/install a buffer w/ 4 blocks
limit	limit	fig	top+1 of last block buffer, 0 if unassigned
list	elist	forth	list screen
lnk>chn	lnk2chn	blkfile	buffer block owner channel
lnk>num	lnk2num	blkfile	buffer block count of buffers
lnk>tag	lnk2tag	blkfile	buffer block owner channel's tag no.
load	pdodefer	forth	input from current screenfile, -re- {using}
[load]	bloadb	hidden	dft for deferred -re- {load}
nextbuf	nextbuf	blkfile	{+buf} wrt by -re- {source-id} used blocks
offset	pdoval	fig	block disp by multiple of -re- {b/scr} (1)
prev	prev	fig	screenfile blockbuffer currently in use
r#@	rnf	editor	{ r# @ } get cursor count
ro?	roq	blkfile	query write protection mode
rw!	rws	blkfile	aequivalent to f.i.g. { 0 r/w }
rw@	rwf	blkfile	aequivalent to f.i.g. { 1 r/w }
save-buffers	sbufs	forth	save updated blocks, "unassign" last buffer block
scr!	scrs	editor	{ scr ! } sto screen no.
scr@	scrf	editor	{ scr @ } fetch screen no.
scr-chan	pdoval	forth	no. of screenfile channel
scrfpos	scrfpos	blkfile	scr-chan file-ptr at scr@+r#@
thru	thru	forth	{load} a range of screens, xec only
[upd]	bupdb	hidden	dft opr for {update}
update	pdodefer	forth	mark buffer to save before re-useage
update?	updateq	blkfile	flag whether blk -re- {update}d
update-off	updateoff	blkfile	clear screenfile buffer update flag
use	use	fig	least recently used screenfile blockbuffer
using	using	forth	screenfile for {load} opr.
where	where	root	show error source, afte cpl error

file or termial i/o, device independent
0m	pdodefer	hidden	re-display screenfile listing
accept	vaccept	forth	( p u -- u' ) input from stdin, edittable if terminal
cr	cr	forth	send <lf> to stdout
-cr	dcr	forth	( f -- ) if tf send <lf> to stdout
?cr	qcr	forth	<nl> if no space left in display line
EDIT	pdodefer	root	the screenfile editor, dft {[edit]}
edlin	edlin	forth	{accept}, after 1st <tab> edit text at buffer
ekey	ekey	forth	get input byte
ekey?	ekeyq	forth	test and get input byte and flag
emit	emit	forth	send a char to stdout
emit?	emitq	forth	tf if stdout can emit
emit-m	emitm	forth	multiply send a char to stdout
esc?	escq	forth	tf if key <esc>, wait after <bl> until next
(escc)	uescc	hidden	escape symbol for {etype}
expect	expect	forth	accept max buffer size input, then terminate
(ierr)	ierr	hidden	input opr. error code
(inchp)	pinchpp	hidden	chp of latest used input channel
(ioacc)	uioacc	hidden	received vt.. control chars -n.i.-
(iolink)	iolink	hidden	i/o redirection linkage
key	key	forth	wait until character input
key!	keysto	forth	store last input char back (if char-buf empty)
key?	keyq	forth	tf if input char available
o-cr	odcr	forth	<lf> if stdout is console
(oerr)	oerr	hidden	output opr. error code
(outchp)	poutchpp	hidden	chp of latest used output channel
(pchr)	pchr	hidden	4 bytes ranges of printing chars
print	print	forth	display stg, whether counted or <nul> terminated
source-id	sourceid	forth	input source flags
stderr	stderrc	forth	stderr channel no.
stdin	stdinc	forth	stdin channel no.
stdin?	stdinq	forth	tf if input from console
stdout	stdoutc	forth	stdout channel no.
(stimo)	ustimo	hidden	wait4.. timeout value
(tattr)	utattr	hidden	modified console attributes
(tattr-s)	ustattr	hidden	saved console attributes
(tib)	ptibp	hidden	ptr to terminal input buffer (t.i.b.)
type	type	forth	send a string
(vtim)	uiovtim	hidden	keyboard input timeout, "VTIME" & "VMAX" values
work	workc	forth	work-channel no. (for file opr's)
zprint	zprint	forth	display <nul> terminated stg

terminal i/o
at-xy	atxy	forth	hor and vert. cursor posn by chars
bel	bel	forth	noise..
<bel>	lbelg	vt	ascii ctrl code
bs	bs	forth	backspace, backup cursor by one column
<bs>	lbsg	vt	ascii ctrl code
<can>	lcang	vt	ascii ctrl code
cls	cls	forth	clear console screen & home
clsc	clsc	forth	clear console screen
cons?	consq	forth	tf if channel is console
<cr>	lcrg	vt	ascii ctrl code
<csi>	lcsig	vt	ascii ctrl code
del	del	vt	<bs> and delete chr at cursor posn
<del>	ldelg	vt	ascii ctrl code
echo-off	echof	forth	suppress kbd input echo
echo-on	echon	forth	enable kbd input echo
?ekey	qekey	forth	( -- c f ) tf if input byte available
?eol	qeol	forth	tf if display posn grater than window width
<esc>	lescg	vt	ascii ctrl code
ff	ff	vt	form feed, <nl> for console
<ff>	lffg	vt	ascii ctrl code
g0	g0	vt	character set
[g0]	pdoval	vt	latest g0 character set selection
g1	g1	vt	character set
[g1]	pdoval	vt	latest g1 character set selection
home	home	vt	cursor to top left
<ht>	lhtg	vt	ascii ctrl code
in-cons?	inconsq	forth	tf if stdin is console
ink	vtink	vt	set foreground colour/vt-mode
io-cons	siocons	forth	determine i/o mode
io-cons?	ioconsq	forth	query i/o mode
kbd	kbdc	forth	keyboard input channel no.
kbd!	kbdsto	forth	store last kbd char back (if char-buf empty)
kbd'	kbdt	forth	xec fetched name w. stdin from console
kbd-chan	kbdchan	linux	keyboard channel constant
kbd-emit	kbdemit	forth	send a char to keyboard
kbd-id	kbdid	linux	identifier of keyboard channel
kbd-key	kbdkey	forth	wait until char from keyboard
kbd?key	kbdqkey	forth	w/ zero timeout get a char from keyboard
kbd-type	kbdtype	forth	send a string to keyboard channel
?key	qkey	forth	( -- c f ) tf if char available
<lf>	llfg	vt	ascii ctrl code
max-x	maxx	vt	max console window width
max-xy	maxxy	vt	console window size by count of chars
max-y	maxy	vt	max console window height
otty	otty	linux	open stdin at tty
out-cons?	outconsq	forth	tf if stdout is console
out-pty?	outptyq	linux	tf if stdout is a pty device
page	ff	forth	ff
pty?	ptyq	linux	tf if channel is a pty device
[r]	pdoval	vt	latest reverse video state
rstty	rstty	linux	reset stdin-console to initial state
setty	setty	linux	prepare stdin console to single-key input
<si>	lsig	vt	ascii ctrl code
<so>	lsog	vt	ascii ctrl code
stty-s	sttys	linux	simulates Linux cmd 'stty sane'
<sub>	lsubg	vt	ascii ctrl code
tab	tab	forth	emit a <tab> char, adjust @out
?terminal	qterminal	forth	( -- n ) basic keyboard input query from stdin
<vt>	lvtg	vt	ascii ctrl code
?vt	qvt	forth	query terminal type
vt0	pdo2val	vt	top of console co-ordinates (-1 unset)
wait4kbd	wait4kbd	linux	sys_select for keyboard stdin timeout
xy	xy	forth	fetch cursor posn

vt control
abscur	abscur	vt	curs addr wrt top left of screen
bg	pdoval	vt	background assignation
black	pdoval	vt	colour value
blue	pdoval	vt	colour value
cdn	cdn	vt	cursor one row down
colour	vtcolour	vt	console display colour, attr, etc. (ECMA-48)
csr	csr	vt	set scrolling region
cup	cup	vt	cursor one row up
cur-	clft	vt	cursor one posn to the left
cur!	curs	vt	save cursor posn
cur@	curf	vt	restore cursor posn
cur+	crgt	vt	cursor one posn to the right
curd	curd	vt	disable cursor
cure	cure	vt	enable cursor
cyan	pdoval	vt	colour value
fg	pdoval	vt	foreground assignation
green	pdoval	vt	colour value
[i]	pdoval	vt	latest {ink} colour
magenta	pdoval	vt	colour value
mb	pdo2val	vt	blink
md	pdo2val	vt	bold
me	pdo2val	vt	reset all vt attributes
mr	pdo2val	vt	reverse video
none	pdoval	vt	noop argument
[p]	pdoval	vt	latest {paper} colour
paper	vtpaper	vt	set background colour/vt-mode
red	pdoval	vt	colour value
relcur	relcur	vt	curs addr wrt top left of scrolling region
reset-palette	rstpalette	vt	rst console colours assignations from dft
rev	rev	vt	by flag set display to non-/reversed
rev-off	revoff	vt	standard mode display
rev-on	revon	vt	display at inverse video
rs	rs	root	reset console to 'sane' state
se	pdo2val	vt	normal intensity
set-palette	setpalette	vt	assign a colour value
so	pdo2val	vt	half-bright
ue	pdo2val	vt	underline off
us	pdo2val	vt	underscore
(vpal)	uvpalette	hidden	initial console colours storage
vt?csi	wcsi	vt	wait for <esc>[ or <csi> vt response
vt?esc	wesc	vt	wait for <esc> response to vt query
!vtp	vtsp	vt	send a vt... decimal parameter
@vtp	vtfp	vt	fetch a vt... decimal parameter
vtstate	pdoval	vt	colour, fg/bg state of main window
vt!state	vts	vt	save console state
vt@state	vtf	vt	fetch latest saved console state
white	pdoval	vt	colour value
yellow	pdoval	vt	colour value

hidden words, not for regular use
0branch	zbra	hidden	runtime branch if flg = 0
?0branch	zdupbra	hidden	runtime branch if flg = 0, else dup
0<branch	mibra	hidden	runtime branch if flg < 0
0>branch	gtbra	hidden	runtime branch if flg > 0
0-branch	lebra	hidden	runtime branch if flg not > 0
?1branch	nzdb	hidden	runtime branch and dup if flg =/= 0
a-heap	aheap	hidden	allocated heap memory linkage base -n.i.-
branch	branch	hidden	runtime branch unconditionally
-branch	nzbra	hidden	runtime branch if flg =/= 0
?=branch	neqbra	hidden	runtime branch if @nos =/= @tos
+branch	plbra	hidden	runtime branch if flg not < 0
cbytes	cbytes4	hidden	count of l.s. significant chars/cell
(d.r)	pddotrp	hidden	stg to right aligned display a signed double
drop;s	drops	hidden	combined drop and ;s
r+	rplus	hidden	fetch next cell from 2ndary subroutne level
(ud.r)	puddotrp	hidden	stg to right aligned display an unsigned double

compiler runtimes & vari
(.")	pdotqtep	hidden	runtime display stg
(")	pqtep	hidden	runtime ptr to stg
(-0exit)	pdzexitp	hidden	runtime if ff leave current word
(cd	pcdp	novoc	{cd} runtime
(;code)	pscodep	assembler	runtime for 'does>'
(;code@)	pscodefp	assembler	runtime for '@does>'
dlit	dlit	hidden	runtime dliteral
(?do)	pqdop	hidden	runtime ?do
(do)	pdop	hidden	runtime {do}
(-exit)	pdexitp	hidden	runtime if tf leave current word
fgl	fgl	novoc	forget> runtime code
(find)	pfindp	hidden	runtime find in specified vocabulary
flit	flit	hidden	runtime ANS dliteral
[fn	pfnamep	hidden	[fname] runtime code
(for)	pforp	novoc	runtime ranum {FOR}
(+from)	ppfromp	novoc	runtime ranum {+FROM}
(from)	pfromp	novoc	runtime ranum {FROM}
(i1	dointeger	novoc	{integer} runtime
(i2	dointeger2	novoc	{2integer} runtime
(i4	dointeger4	novoc	{4integer} runtime
(-leave)	pmleavep	hidden	runtime -leave
(leave)	pleavep	hidden	runtime leave
lit	lit	hidden	runtime literal
(+loop)	pploopp	hidden	runtime +loop
(loop)	ploopp	hidden	runtime loop
(next)	pnextp	novoc	runtime ranum {NEXT}
nlit	nlit	hidden	runtime bliteral
qlit	qlit	hidden	runtime qliteral
(s")	psqtep	hidden	runtime sliteral
srd	psortedp	novoc	by {sorted} compiled runtime
(step)	pstepp	novoc	runtime ranum {STEP}
(unloop)	rdrop2	hidden	runtime unloop

vectored data, ptr's, words
[abort]	babortb	hidden	deferred {abort} dft
(accept)	uaccept	hidden	xec. vec
(bits)	bbitsb	hidden	system flags
(block)	ublock	hidden	xec. vec
(bootp)	ubootp	hidden	ptr to xec's data area
(buffer)	ubuffer	hidden	xec. vec
(can)	ucan	hidden	<can> code
(cc4th)	icc4th	hidden	xec. vec
(chans)	pchansp	hidden	ptr to base of channel description tables
(cmc)	ucmc	hidden	compiler control counter for back-patching bound
(compile)	ucompile	hidden	xec. vec
(dpl)	pdplp	hidden	i/o flags
(eax)	ueax	hidden	initial reg storage
(ebp)	uebp	hidden	initial reg storage
(ebx)	uebx	hidden	initial reg storage
(ecx)	uecx	hidden	initial reg storage
(edi)	uedi	hidden	initial reg storage
(edx)	uedx	hidden	initial reg storage
(ekey?)	uekeyq	hidden	xec. vec
(emit)	uemit	hidden	xec. vec
(eof)	peofp	hidden	received chars count, zero at eof
(eol)	ueol	hidden	<eol> code
(?error)	uqerror	hidden	xec. vec ?error
(error)	uerror	hidden	xec. vec
(esi)	uesi	hidden	initial reg storage
(esp)	uesp	hidden	initial reg storage
(eval)	ueval	hidden	xec. vec
(fperm)	ufperm	linux	default new file access permissions
(head)	pheadp	hidden	cpl head-ptr
(hi>lo)	uhi2lo	hidden	ptr to table of lower case characters
]interpret	binter	compiler	xec (]interpret)
interpret[	interb	compiler	xec (interpret[)
(locb)	locb	hidden	uvari, bytecount
(locn)	locn	hidden	uvari, items per defn count
(lo>hi)	ulo2hi	hidden	ptr to table of upper case characters
(m/mod)	upmbymp	hidden	xec. vec
(>number)	utonum	hidden	xec. vec >number
(number)	unumber	hidden	xec. vec
(ok)	upokp	hidden	xec. vec
(padsz)	padsz	hidden	pads' and max+4 input stgs' sizes
(path)	upath	hidden	ptr to PATH env. vari
(pause)	upause	hidden	xec vec after {wait4..} timeout
(quit)	uquit	hidden	xec. vec
(scanwl)	uscanwl	hidden	xec. vec
(sighnd)	sigh	linux	base of signal handlers def.blocks
(source)	usource	hidden	xec.vec of {source}, dft [source]
(source-id)	psourceidp	hidden	saved source-id
(sp!)	ustosp	hidden	xec. vec
(#tab)	pntabp	hidden	tab spacing
(tail)	ptailp	hidden	cpl tail-ptr
(?terminal)	uqterminal	hidden	xec. vec ?terminal
(#tib)	pntibp	hidden	#tib storage
(tib-max)	ptibmaxp	hidden	space of tib
(type)	utype	hidden	xec. vec
#vocs	nvocs	forth	max no. of items in voc-stack

vectored words' defaults
[0m]	bm0b	hidden	scr re-listing after {m} dft opr.
[accept]	osaccept	hidden	dft accept
[block]	bblockb	hidden	{block} default opr.
[buffer]	bbufb	hidden	{buffer} default opr.
(code)	pcodep	forth	terminate colon defn, continue lo-level
[ctype]	bctypeb	hidden	dft non-escaping type
[debug]	bdebugb	compiler	default (debug) opr
[edit]	beditb	editor	{edit} default opr.
[emit]	bemitb	hidden	dft emit
[?error]	bqerrb	hidden	dft ?error
[error]	berrb	hidden	dft error
[etype]	betypeb	hidden	dft escaping type
[eval]	bevalb	hidden	dft evaluate
[f]	bfb	editor	-find w/ forth voc preferrence
[interpret]	binterpretb	compiler	default (interpret) opr
[>number]	btonumb	hidden	dft >number
[ok]	bokb	hidden	dft ok
(q.)	pqdotp	hidden	( q sgn fmt -- ) quad to string
[quit]	bquitb	hidden	dft quit
[scanvocs]	bscanvb	hidden	execute vector by xec ptr on all wordlists
[source]	bsourceb	hidden	dft xec vec for {source}
[squit]	bsquitb	hidden	dft quit entry after segfault
[type]	pdodefer	hidden	deferred, string to stdout

conditional interpreting
[0=]	izeq	ans	immediate flag inversion, {0=}
defined	defined	forth	immediate tf if name found
[DEFINED]	defined	ans	re {defined}
[ELSE]	belseb	root	read input until [then] if flag to [if] was false
[FALSE]	zero	ans	immediate cons 0
[IF]	bifb	root	read input until [else], discard till [then]
if-found	iffound	root	discard till eol if name not found
if-nfound	ifnfound	root	discard till eol if name found
if-true	iftrue	root	discard till eol if false flag
[THEN]	bthenb	root	terminate conditional input sequence [if]...
[TRUE]	true	ans	immediate cons -1

interpreter
;	semi	forth	terminate colon defn, clr locals, check
.(	commentp	root	printing comment until next ")"
'	atick	ans	fetch xec token ix by name
(	paren	root	in-active comment until next ")"
(*	paren	root	synonym "(", comment until next ")"
.\	dotbslash	root	printing comment until <eol>
\	bslash	root	ignore input until <eol>
\\	quit	root	ignore input until <eof>
ascii	char	forth	fetch character value literal
big	big	root	fetch next numeric input as a bignum
?comp	qcomp	forth	abort if not in permanently compiling state
cpl?	cplq	root	tf if permanently compiling
?csp	qcsp	forth	abort if data-stack out of balance
([debug])	updebugp	hidden	xec. vec, initially zero i.e. a noop
?deferred	qdferd	forth	abort if xt is not of a deferred word
deferred?	dferdq	forth	tf if xt is of a deferred word
?depth	qdepth	forth	abort if unsufficient data on stack
df	ranum	root	next numeric input is double rational num, single float
dp	dp	forth	ptr to available data-space
?error	qerror	forth	abort if flag indicates an error
evaluate	evaluate	forth	interpret supplied string
?exec	qexec	forth	abort if not in execution of a word
execute	execute	forth	execute from uot index
-execute	dexecute	forth	execute from uot index if flg =/= 0
find	find	forth	find by supplied ptr to name, 6.1.1550 6.1.1550
-find	dfind	forth	find a word's lfa by fetched name
[find]	bfindb	forth	find a word's lfa by stg(p,u)
flt	fltf	root	set numeric input mode to double ranum
-flt	mflt	root	false(!) flag if double ranum input mode
in	xin	fig	parsed terminal input count
>in	xin	forth	parsed terminal input count
in@	infetch	forth	fetch {in}
include	include	forth	input from file by <bl>-enclosed name
include?	includeq	forth	{include} if specified word not found
include"	includeqte	forth	input from file by <">-terminated name
included	included	forth	input from file by supplied name
include-file	ifile	forth	(re dpans94) input from file by channel no.
int	intf	root	reset from {flt} to integer numeric input mode
interpret	interpret	forth	evaluate input stream
(]interpret)	ubinterpret	hidden	xec. vec, initially zero i.e. a noop
(interpret)	uinterpret	hidden	xec. vec
(interpret[)	uinterpretb	hidden	xec. vec, initially zero i.e. a noop
is?	isq	forth	display xec word of a deferred word
lcase@	lcasef	forth	stg comparison letter case dependency flg
LCASE@	lcasef	forth	stg comparison letter case dependency flg
lp	lp	local	local memory running ptr
?null	qnull	forth	abort-14 if 4th ptr is zero true address
o(	ocommentp	root	comment until next ")" if stdout is console
?pairs	qpairs	forth	abort if stacked compile-flags dont match
perform	perform	forth	execute from lfa
?prog	qprog	forth	abort if ptr not in program or kernel space
qf	double	root	next numeric input is quad rational num, double float
quad	quad	root	fetch next numeric input as a quad integer
query	query	forth	{accept} until <lf>
;r	semir	forth	-re- {;} with return address adjustmt
:r	colonr	forth	-re- codespace adjustmt for safe return
refill	refill	forth	fill tib from input stream until <eof>
restore-input	restoreinput	forth	restore saved input
;s	semis	forth	terminate an execution sequence
save-input	saveinput	forth	save input descriptors
sf	sing	root	next numeric input is single rational num
span	span	forth	#tib
span@	spanf	forth	no. of last input chars
?stack	qstack	forth	abort if data-stack out of bounds
state	state	forth	compiler/interpreter flags
state@	statef	forth	whether interpreting(0) or compiling(=/= 0)
#tib	ntib	forth	( -- n ) no. of chars fetched to tib
up	up	forth	ptr to next available user vari
up+	upplus	forth	add disp to ptr to uservari-space

uninitiated, independent of L4 kernel set-up
--env-ini	noop	root	a noop dummy, initially in search order
eud	erudot	novoc	unsigned error no., message
eus	erustg	novoc	send a text
get-cp	getcp	systm	get ptr into code space, where this word returns.
getgot	getgot	linux	ptr to lib's ELF global offset table
getref	getrefb	systm	restore kernel reference
--help	ihelp	root	minimalistic help
kmessage	kmessage	hidden	send message txt to STDOUT, uninitated
sigmsg	sigmsg	linux	send messgae, leave msg-no. at nos
version	version	root	display l4-version
--version	sversion	root	library version
wzo	writezo	novoc	send asciz-string

logic, all integer sizes
<	less	forth	( n1 n2 -- f ) tf if @tos smaller than @nos
<>	nequal	ans	( n1 n2 -- f ) ff if @tos = @nos
=	equal	forth	( n1 n2 -- f ) tf if @tos = @nos
=/=	nequal	forth	( n1 n2 -- f ) ff if @tos = @nos
>	greater	forth	( n1 n2 -- f ) tf if @tos greater than @nos
>/	nlt	forth	( n1 n2 -- f ) tf if @tos greater than @nos
-0=	mzeq	forth	tf if only sign-bit set
?0=	zeqq	forth	( n -- n f ) tf if n = 0
@0=	zeqf	forth	@ 0= ; tf if cell @ptr = zero
0<	zless	forth	( n -- f ) tf if -ve sing
0<>	zneq	ans	( n -- f ) tf if non-zero sing
0=	zeq	forth	( n -- f ) tf if zero item, flag inversion
0=/=	zneq	forth	( n -- f ) tf if non-zero sing
0>	zgreat	forth	( n -- f ) tf if @tos > 0
\<	ngt	forth	( n1 n2 -- f ) tf if @tos smaller than @nos
0and	dng	hidden	( n -- 0 ) replace @tos w/ 0
1or	dgt	hidden	( n -- 0 ) replace @tos w/ 0
d<	dless	forth	tf if double @tos smaller than @nos
D<>	dneq	ans	tf if doubles not equal
d=	deq	forth	tf if double @tos and @nos equal
d=/=	dneq	forth	tf if doubles not equal
d>	dgreat	forth	tf if double @tos smaller than @nos
?d0=	qdzeq	forth	( dn -- dn f ) tf if double @tos is zero
d0<	dzless	forth	tf if double @tos -ve
D0<>	dzneq	ans	ff if double @tos is zero
d0=	dzeq	forth	tf if double @tos is zero
d0=/=	dzneq	forth	ff if double @tos is zero
d0>	dzgt	forth	tf if double @tos -ve
du<	duless	forth	td if double @tos unsigned smaller than @nos
du>	dugreat	forth	td if double @tos unsigned smaller than @nos
l-and	land	forth	( n1 n2 -- f ) ; logic AND
l-or	lor	forth	( n1 n2 -- f ) ; logic OR
n=	neq	bignum	signed compare two bignums
?n0=	qnzeq	bignum	non-destructively test counted int for zero
n0<	nzlt	bignum	test counted int for < zero
n0=	nzeq	bignum	test counted int for zero
n0>	nzgt	bignum	test counted int for > zero
?ncmp	qncmp	bignum	non-destr. ret sgn(diff of two counted ints)
o0=	ozeq	hidden	( o1 -- flg ) test eight-cells for zero
pow2?	pow2q	forth	tf if item is a power of 2
q<	qless	forth	( q1 -- f ) tf if quad @tos less than @nos
q=	qeq	forth	( q1 q2 -- f ) tf if top two quads equal
?q0=	qqzeq	forth	( q1 -- q1 f ) non-destructive test, tf if quad = zero
q0<	qzless	forth	( q1 -- f ) tf if quad -ve
q0=	qzeq	forth	( q1 -- f ) tf if quad is zero
q0>	qzgreat	forth	( q1 -- f ) tf if quad greater than zero
qu<	quless	forth	( q1 -- f ) tf if unsigned quad @tos smaller than @nos
qu>	qugreat	forth	( q1 -- f ) tf if unsigned quad @tos greater than @nos
u<	uless	forth	( n1 n2 -- f ) tf if unsigned @tos smaller than @nos
u>	ugreater	forth	( n1 n2 -- f ) tf if unsigned @tos greater than @nos
uc<	ucless	forth	( c1 c2 -- f ) tf if unsigned byte @tos < byte @nos
?udcmp	qudcmp	forth	( d1 d2 -- d1 d2 f ) f=(d1 u< d2)-(d2 u< d1)
?uqcmp	quqcmp	forth	( q1 q2 -- q1 q2 f ) unsgnd compare, f=1 if q2 u< q1
within	within	forth	un/signed test 3rd w/ range of 2nd..1st

memory arithmetic and logic opr
(1-)	b1mb	forth	( p -- ) sub 1 from cell at ptr
(1+)	b1pb	forth	( p -- ) add 1 to cell at ptr
and!	ands	forth	( n p -- ) and to cell in memory
(d1-)	bd1mb	forth	( p -- ) sub 1 from double cell at ptr
(d1+)	bd1pb	forth	( p -- ) add 1 to double cell at ptr
@lshift	mlshift	forth	( p n -- ) left shift cell in memory
n!+	nstorep	bignum	store counted int, leave advanced ptr
n@+	nfetchp	bignum	fetch counted int, leave advanced ptr
or!	ors	forth	( n p -- ) or to cell in memory
@rshift	mrshift	forth	( p n -- ) right shift cell in memory
@rshifta	mrshifta	forth	( p n -- ) arithmetic shift cell in memory
xor!	xors	forth	( n p -- ) xor to cell in memory

memory, sing
->	tov	ans	-re- {to} for "pforth" (etc)
!	store	forth	( n p -- ) sto sing to memory
!-	storem	forth	( p1 -- p2 n ) pre-decrement & store dword
!!	xsto	forth	( p1 p2 -- ) xchange cells in memory
!+	storep	forth	( n p1 -- p2 ) store dword & post-increment
@	fetch	forth	( p -- n ) fetch cell ("dword") from memory
@-	fetchm	forth	( p1 -- p2 n ) nos=tos-4,tos=@kref(nos)
@!	fsto	forth	( p1 p2 -- ) copy cell from/to memory
@+	fetchp	forth	( p1 -- p2 n ) nos=tos+4,tos=@kref(tos)
+!	plsto	forth	( n p -- ) add sing to cell in memory
2to	to2	forth	store to alterable double cons
a!	astore	forth	( n a -- ) sto cell to true addr
a@	afetch	forth	( a -- n ) fetch cell from true addr
b!	bstore	forth	( c p -- ) sto l.s.byte of sing to memory
b!-	bstorem	forth	( p1 -- p2 c ) pre-decrement & store byte
b!+	bstorep	forth	( c p1 -- p2 ) store byte & post-increment
b@	bfetch	forth	( p -- c ) fetch byte from memory
b@+	bfetchp	forth	( p1 -- p2 c ) nos=tos+1,tos=c@kref(tos)
c!	cstore	forth	( c p -- ) sto char to memory
c!!	cxsto	forth	( p1 p2 -- ) xchange bytes in memory
c!+	cstorep	forth	( c p -- ) store char & post-increment
c@	cfetch	forth	( p -- c ) fetch char from memory
c@!	cfsto	forth	( p1 p2 -- ) copy byte from/to memory
c@+	cfetchp	forth	( p1 -- p2 c ) nos=tos+1,tos=c@kref(tos)
c+!	cplsto	forth	( c p -- ) add byte to byte in memory
m+!	mplsto	forth	( n p -- ) sign extended add sing to double in memory
n!	nstore	bignum	store counted integer
n@	nfetch	bignum	fetch counted integer
off	off	forth	sto 0 to ptr
on	on	forth	sto -1 to ptr
to	tov	forth	store sing to alterable cons
w!	wstore	forth	( n p -- ) sto l.s. half cell of sing to memory
w!-	wstorem	forth	( p1 -- p2 n ) pre-decrement & store word
w!!	wxsto	forth	( p1 p2 -- ) xchange half cells in memory
w!+	wstorep	forth	( n p1 -- p2 ) store word & post-increment
w@	wfetch	forth	( p -- n ) fetch half cell ("word") from memory
w@!	wfsto	forth	( p1 p2 -- ) copy half cell from/to memory
w@+	wfetchp	forth	( p1 -- p2 n ) nos=tos+2,tos=w@kref(tos)

memory, multiple cells, strings
add-link	addlink	systm	( p1 p2 -- ) link p1 into list p2
allocate	allocatem	forth	allocate data-space, extends into .bss section
cmove	xcmove	forth	( p1 p2 +u ) copy memory contents w/ ascending ptrs
cmove>	cmovegt	forth	( p1 p2 +u ) copy memory contents w/ descending ptrs
c-xchg	cxchg	forth	( p1 p2 +u -- ) xchange memory content
erase	erase	forth	( p +u -- ) fill memory range w/ <nul> bytes
fill	fill	forth	( p +u n -- ) fill memory range w/ supplied byte
free	freem	forth	link mem back to .bss section
move	move	forth	( p1 p2 +u ) copy non-overwriting
>move<	movex	forth	( p1 p2 +u -- ) copy reversed bytes order
m>r	mtor	forth	mem bytes to return-stack
m>s	mtos	forth	mem bytes to data-stack
readmc	readmc	forth	( p u u2 -- p' u' p1 u1 ) u2 chars(=bytes) from mem
readm-c/l	readmcl	editor	( p u -- p' u' p1 u1 ) c/l chars(=bytes) from mem
readml	readml	forth	( p u -- p' u' p1 u1 ) next line from mem
resize	resizem	forth	alloc/link back, w/o loss of data (as possible)
?resize	qresizem	forth	allocate if required for -re- {allot}
r>m	rtom	forth	return-stack bytes to mem
rmv-link	rmvlink	systm	( p1 p2 -- ) unlink p1 from list p2
s>m	stom	forth	stack bytes to mem
top-mblock	topmblock	forth	allocate data-space, extends into .bss section
unused	unused	forth	( -- n ) free space in data-memory

memory, quad
4!	store4	forth	( q1 p -- ) sto quad to memory
4!!	qxsto	forth	( p1 p2 -- ) xchange quads in memory
4!!	qxstof	nonmmx	xchg quad
4@	fetch4	forth	( p -- q1 ) fetch quad from memory

memory, doubles
2!	twostoa	ans	( d p -- ) sto double to mem, BIG ENDIAN (ANS!)
2!	twosto	fig	( d p -- ) sto double to mem
2!	twosto	forth	( d p -- ) sto double to mem
2!!	twoxsto	forth	( p1 p2 -- ) xchange doubles in memory
2!!	twoxstof	nonmmx	xchg doubles
2@	twofetcha	ans	( p -- d ) fetch double, BIG ENDIAN (ANS!)
2@	twofetch	fig	( p -- d ) fetch double
2@	twofetch	forth	( p -- d ) fetch double
2@!	twofsto	forth	( p1 p2 -- ) copy double from/to memory
2@!	twofstof	nonmmx	copy double
2+!	twoplsto	forth	( d p -- ) add double to double in memory

memory, vectored & miscellaneous
(bot)	mbot	hidden	base job true addr of .bss bottom
d!	pdodefer	utility	( n p -- ) deferred {!}
d!!	pdodefer	utility	( p1 p2 -- ) deferred {!!}
d@	pdodefer	utility	( p -- n ) deferred {@}
default-is	defaultis	forth	re-define a deferred word's default action
d-top	dtop	forth	ptr to top of available data-space
f-heap	fheap	hidden	free heap memory linkage base -n.i.-
here	here	forth	fetch dp, ptr to data-space
is	is	forth	re-define a deferred word
is@	isf	forth	dft and xec ix's by ix of a deferred word
mmap	mmap	linux	map a file into memory
mmap-chan	mmapc	linux	simplified, map a file by chan into memory.
mmap-file	mmapf	linux	simplified, map a file by name into memory.
mremap	mremap	linux	( p1 u1 u2 flg -- p3 ) change memory mapping
msync	msync	linux	sync. memory data w/ mapped file
munmap	munmap	linux	detach {mmap}ped file from memory
n-top	pdovar	bignum	memtop for bignum to stg conversion
pad	pad	forth	ptr to tmp. buffer in data-space
pad2	pad2	forth	ptr to tmp. string-buffer in data-space
(sstop)	sstop	hidden	base job true addr of .bss top
<top>	utop	hidden	top address of user-vari space - don't read,store!
(top)	mtop	hidden	global true addr of .bss top
uv@	uvfetch	forth	fetch uvari by disp
(vbot)	vbot	hidden	end of user area

floating pt. sing numbers (per double ranum)
^	fpow	floatop	( f1 f2 -- f3 ) f1 to the power of f2
~	faeq	floatop	( f1 f2 f3 -- flg ) 12.6.2.1640 12.6.2.1640 (-?-)
<	flt	floatop	( f1 f2 -- flg ) 12.6.1.1460 12.6.1.1460
-	fsubf	floatop	( f1 f2 -- f3 ) 12.6.1.1425 12.6.1.1425
!	fstore	floatop	( f1 p -- ) 12.6.1.1400 12.6.1.1400
/	fby	floatop	( f1 f2 -- f3 ) 12.6.1.1430 12.6.1.1430
@	ffetch	floatop	( p -- f1 ) 12.6.1.1472 12.6.1.1472
*	fmulf	floatop	( f1 f2 -- f3 ) 12.6.1.1410 12.6.1.1410
*/	dvmulby	floatop	( f1 f2 f3 -- f4 ) mul f1 by f2 div by f3
**	fpow	floatop	( f1 f2 -- f3 ) 12.6.2.1415 12.6.2.1415
%	dvvh	floatop	( f1 f2 -- f3 ) per 100
+	fplus	floatop	( f1 f2 -- f3 ) 12.6.1.1420 12.6.1.1420
0<	fzlt	floatop	( f1 -- flg ) 12.6.1.1440 12.6.1.1440
0=	fzeq	floatop	( f1 -- flg ) 12.6.1.1450 12.6.1.1450
1-	fonem	floatop	( f1 -- f2 ) subtract one
1+	fonep	floatop	( f1 -- f2 ) add one
2/	f2by	floatop	( f1 f2 -- f3 ) div by two
2*	f2mul	floatop	( f1 f2 -- f3 ) mul by two
ABS	fabsf	floatop	( f1 -- f2 ) 12.6.2.1474 12.6.2.1474
ACOS	facos	floatop	( f1 -- f2 ) 12.6.2.1476 12.6.2.1476
ACOSH	facosh	floatop	( f1 -- f2 ) area cosh, 12.6.2.1477 12.6.2.1477
ALOG	falogf	floatop	( f1 -- f2 ) 12.6.2.1484 12.6.2.1484
ASIN	fasin	floatop	( f1 -- f2 ) 12.6.2.1486 12.6.2.1486
ASINH	fasinh	floatop	( f1 -- f2 ) area sinh, 12.6.2.1487 12.6.2.1487
ATAN	fatan	floatop	( f1 -- f2 ) 12.6.2.1488 12.6.2.1488
ATAN2	fatan2	floatop	( f1 f2 -- f3 ) 12.6.2.1489 12.6.2.1489
ATANH	fatanh	floatop	( f1 -- f2 ) area tanh, 12.6.2.1491 12.6.2.1491
CONSTANT	fcons	floatop	ccc( f1 -- ) 12.6.1.1492 12.6.1.1492
COS	fcosf	floatop	( f1 -- f2 ) 12.6.2.1493 12.6.2.1493
COSH	fcosh	floatop	( f1 -- f2 ) area tanh, 12.6.2.1494 12.6.2.1494
DEG>RAD	deg2rad	float	( f1 -- f2 ) convert degrees to radians
DEPTH	fdepth	floatop	( -- n ) 12.6.1.1497 12.6.1.1497
D>F	dtof	float	( d1 -- f2 ) 12.6.1.1130 12.6.1.1130
DROP	fdrop	floatop	( f1 -- ) 12.6.1.1500 12.6.1.1500
DUP	fdup	floatop	( f1 -- f1 f1 ) 12.6.1.1510 12.6.1.1510
END	fend	rational	( -- ) terminate FOR-loop at next NEXT
EXP	fexp	floatop	( f1 -- f2 ) 12.6.2.1515 12.6.2.1515
EXPM1	fexpm1	floatop	( f1 -- f2 ) 12.6.2.1516 12.6.2.1516
F^	fpow	float	( f1 f2 -- f3 ) f1 to the power of f2
F~	faeq	float	( f1 f2 f3 -- flg ) 12.6.2.1640 12.6.2.1640 (-?-)
F<	flt	float	( f1 -- flg ) 12.6.1.1460 12.6.1.1460
F-	fsubf	float	( f1 f2 -- f3 ) 12.6.1.1425 12.6.1.1425
F!	fstore	float	( f1 p -- ) 12.6.1.1400 12.6.1.1400
F/	fby	float	( f1 f2 -- f3 ) 12.6.1.1430 12.6.1.1430
F@	ffetch	float	( p -- f1 ) 12.6.1.1472 12.6.1.1472
F*	fmulf	float	( f1 f2 -- f3 ) 12.6.1.1410 12.6.1.1410
F**	fpow	float	( f1 f2 -- f3 ) 12.6.2.1415 12.6.2.1415
F+	fplus	float	( f1 f2 -- f3 ) 12.6.1.1420 12.6.1.1420
F0<	fzlt	float	( f1 -- flg ) 12.6.1.1440 12.6.1.1440
F0=	fzeq	float	( f1 -- flg ) 12.6.1.1450 12.6.1.1450
F1-	fonem	float	( f1 -- f2 ) subtract one
F1+	fonep	float	( f1 -- f2 ) add one
F2/	f2by	float	( f1 f2 -- f3 ) div by two
F2*	f2mul	float	( f1 f2 -- f3 ) mul by two
F2DUP	f2dup	float	( f1 f2 -- f1 f2 f1 f2 )
FABS	fabsf	float	( f1 -- f2 ) 12.6.2.1474 12.6.2.1474
FACOS	facos	float	( f1 -- f2 ) 12.6.2.1476 12.6.2.1476
FACOSH	facosh	float	( f1 -- f2 ) area cosh, 12.6.2.1477 12.6.2.1477
FALIGN	falign	ans	( -- ) 12.6.1.1479 12.6.1.1479
FALIGNED	faligned	ans	( p1 -- p2 ) 12.6.1.1483 12.6.1.1483
FALOG	falogf	float	( f1 -- f2 ) 12.6.2.1484 12.6.2.1484
FASIN	fasin	float	( f1 -- f2 ) 12.6.2.1486 12.6.2.1486
FASINH	fasinh	float	( f1 -- f2 ) area sinh, 12.6.2.1487 12.6.2.1487
FATAN	fatan	float	( f1 -- f2 ) 12.6.2.1488 12.6.2.1488
FATAN2	fatan2	float	( f1 f2 -- f3 ) 12.6.2.1489 12.6.2.1489
FATANH	fatanh	float	( f1 -- f2 ) area tanh, 12.6.2.1491 12.6.2.1491
FCONSTANT	fcons	float	ccc( f1 -- ) 12.6.1.1492 12.6.1.1492
FCOS	fcosf	float	( f1 -- f2 ) 12.6.2.1493 12.6.2.1493
FCOSH	fcosh	float	( f1 -- f2 ) area tanh, 12.6.2.1494 12.6.2.1494
F>D	ftod	float	( f1 -- d2 ) 12.6.1.1470 12.6.1.1470
FDEPTH	fdepth	float	( -- n ) 12.6.1.1497 12.6.1.1497
F>DF	ftodf	float	( f1 -- df2 ) convert float to double size
FDROP	fdrop	float	( f1 -- ) 12.6.1.1500 12.6.1.1500
FDUP	fdup	float	( f1 -- f1 f1 ) 12.6.1.1510 12.6.1.1510
FEXP	fexp	float	( f1 -- f2 ) 12.6.2.1515 12.6.2.1515
FEXPM1	fexpm1	float	( f1 -- f2 ) 12.6.2.1516 12.6.2.1516
F>IEEE	f2ieee	float	( f1 -- d2 ) ranum to ieee-754, 12.6.1.1470 12.6.1.1470
FLITERAL	fliteral	float	( f1 -- ) 12.6.1.1552 12.6.1.1552
FLN	fln	float	( f1 -- f2 ) 12.6.2.1553 12.6.2.1553
FLNP1	flnp1	float	( f1 -- f2 ) 12.6.2.1554 12.6.2.1554
>FLOAT	tofloat	float	( p u -- f1 ) 12.6.1.0558 12.6.1.0558
FLOAT+	floatp	ans	( p1 -- p2 ) 12.6.1.1555 12.6.1.1555
FLOATS	floats	ans	( n1 -- n2 ) mul-8 12.6.1.1556 12.6.1.1556
FLOG	flog	float	( f1 -- f2 ) 12.6.2.1557 12.6.2.1557
FLOOR	floor	float	( f1 -- dn ) 12.6.1.1558 12.6.1.1558
FMAX	fmax	float	( f1 f2 -- f3 ) 12.6.1.1562 12.6.1.1562
FMIN	fmin	float	( f1 f2 -- f3 ) 12.6.1.1565 12.6.1.1565
FNEGATE	fnegate	float	( f1 -- f2 ) 12.6.1.1567 12.6.1.1567
FOR	for	rational	( f1 -- ) begin a FOR .. NEXT loop
FOVER	fover	float	( f1 f2 -- f1 f2 f1 ) 12.6.1.1600 12.6.1.1600
FPICK	fpick	float	( f1... n1 -- f1 ) +/- pick float
FRANDOM	frandom	float	( f1 -- f2 ) random number in range [0,f1)
FROM	from	rational	( f1 -- ) modify FOT-loop start
+FROM	pfrom	rational	( f1 -- ) modify FOR-loop start and limit by disp
FROT	frot	float	( f1 f2 f3 -- f2 f3 f1 ) 12.6.1.1610 12.6.1.1610
FROUND	fround	float	( f1 -- f2 ) nearest int, 12.6.1.1612 12.6.1.1612
FSIN	fsinf	float	( f1 -- f2 ) 12.6.2.1614 12.6.2.1614
FSINCOS	fsc	float	( f1 -- f2 f3 ) 12.6.2.1616 12.6.2.1616
FSINH	fsinh	float	( f1 -- f2 ) hyperbelsinus, 12.6.2.1617 12.6.2.1617
FSQRT	fsqrtf	float	( f1 -- f2 ) 12.6.2.1618 12.6.2.1618
FSWAP	fswap	float	( f1 f2 -- f2 f1 ) 12.6.1.1620 12.6.1.1620
FTAN	ftan	float	( f1 -- f2 ) 12.6.2.1625 12.6.2.1625
FTANH	ftanh	float	( f1 -- f2 ) hyperbeltangens, 12.6.2.1626 12.6.2.1626
FVARIABLE	fvari	float	ccc( -- p ) 12.6.1.1630 12.6.1.1630
IDX	fidx	rational	( -- f1 ) innermost level FOR-loop index
!IDX	sidx	rational	( f1 -- ) store FOR-loop index
IEEE>F	ieee2f	float	( f1 -- d2 ) ieee-754 to ranum, 12.6.1.1470 12.6.1.1470
INC	fstep	rational	( -- f1 ) FOR-loop increment
!INC	sinc	rational	( f1 -- ) store FOR-loop increment
LIM	flim	rational	( -- f1 ) FOR-loop limit
LITERAL	fliteral	floatop	( f1 -- ) 12.6.1.1552 12.6.1.1552
LN	fln	floatop	( f1 -- f2 ) 12.6.2.1553 12.6.2.1553
LNP1	flnp1	floatop	( f1 -- f2 ) 12.6.2.1554 12.6.2.1554
LOG	flog	floatop	( f1 -- f2 ) 115 115 |12.6.2.1557
MAX	fmax	floatop	( f1 f2 -- f3 ) 12.6.1.1562 12.6.1.1562
MIN	fmin	floatop	( f1 f2 -- f3 ) 12.6.1.1565 12.6.1.1565
NEGATE	fnegate	floatop	( f1 -- f2 ) 12.6.1.1567 12.6.1.1567
NEXT	next	rational	( -- ) terminate a FOR .. NEXT loop
NX	nx	rational	( n -- f1 ) n-th level FOR-loop index
@NX	fnx	rational	( n -- p ) indext level ptr to FOR-loop ctrl. data
OVER	fover	floatop	( f1 f2 -- f1 f2 f1 ) 12.6.1.1600 12.6.1.1600
PICK	fpick	floatop	( f1... n1 -- f1 ) +/- pick float
PRECISION	fprec	float	( -- n ) -re- {fplaces} 12.6.2.2035 12.6.2.2035
RAD>DEG	rad2deg	float	( f1 -- f2 ) convert radians to sexagesimal degrees
RANDOM	frandom	floatop	( f1 -- f2 ) random number in range [0,f1)
REPRESENT	frepresent	float	( f1 p u -- n1 flg1 flg2 ) 12.6.1.2143 12.6.1.2143
ROT	frot	floatop	( f1 f2 f3 -- f2 f3 f1 ) 12.6.1.1610 12.6.1.1610
ROUND	dvfround	floatop	( f1 -- f2 ) round to #fround digits after dp
SET-PRECISION	sprec	float	( n -- ) 12.6.2.2200 12.6.2.2200 - { to #fplaces }
SF!	sfstore	float	( f1 p -- ) 12.6.2.2202 12.6.2.2202
SF@	sffetch	float	( p -- f1 ) 12.6.2.2203 12.6.2.2203
SFALIGN	sfalign	ans	( -- ) 12.6.2.2204 12.6.2.2204
SFALIGNED	sfaligned	ans	( p1 -- p2 ) 12.6.2.2206 12.6.2.2206
SFLOAT+	sfloatp	ans	( n1 -- n2 ) 12.6.2.2207 12.6.2.2207
SFLOATS	sfloats	ans	( n1 -- n2 ) mul8 12.6.2.2208 12.6.2.2208
SIN	fsinf	floatop	( f1 -- f2 ) 12.6.2.1614 12.6.2.1614
SINCOS	fsc	floatop	( f1 -- f2 f3 ) 12.6.2.1616 12.6.2.1616
SINH	fsinh	floatop	( f1 -- f2 ) hyperbelsinus, 12.6.2.1617 12.6.2.1617
SQRT	fsqrtf	floatop	( f1 -- f2 ) 12.6.2.1618 12.6.2.1618
STEP	step	rational	( f1 -- ) modify FOR-loop increment
SWAP	fswap	floatop	( f1 f2 -- f2 f1 ) 12.6.1.1620 12.6.1.1620
TAN	ftan	floatop	( f1 -- f2 ) 12.6.2.1625 12.6.2.1625
TANH	ftanh	floatop	( f1 -- f2 ) hyperbeltangens, 12.6.2.1626 12.6.2.1626
VARIABLE	fvari	floatop	ccc( -- p ) 12.6.1.1630 12.6.1.1630

floating pt. double numbers (per quad ranum)
2!	dfstore	floatop	( f1 p -- ) 12.6.2.1203 12.6.2.1203
2@	dffetch	floatop	( p -- df1 ) 12.6.2.1204 12.6.2.1204
2OVER	dfover	floatop	( df1 df2 -- df1 df2 df1 )
2PICK	dfpick	floatop	( df1... n1 -- df1 ) pick double float
2ROT	dfrot	floatop	( df1 df2 df3 -- df2 df3 df1 )
2SWAP	dfswap	floatop	( df1 df2 -- df2 df1 )
D.	dfdotf	floatop	( df1 -- ) print double float (quad ranum)
D2/	qv2div	floatop	( df1 df2 -- df3 ) div by two
D2*	qv2mul	floatop	( df1 -- df2 ) multiply by 2
DF!	dfstore	float	( f1 p -- ) 12.6.2.1203 12.6.2.1203
DF.	dfdotf	float	( df1 -- ) print double float (quad ranum)
DF@	dffetch	float	( p -- df1 ) 12.6.2.1204 12.6.2.1204
DFALIGN	dfalign	ans	( -- ) 12.6.2.1205 12.6.2.1205
DFALIGNED	dfaligned	ans	( p1 -- p2 ) 12.6.2.1207 12.6.2.1207
DFATANH	dfatanh	float	( df1 -- df2 ) area tanh double float
DF>F	dftof	float	( df1 -- f2 ) 12.6.1.1130 12.6.1.1130
>DFLOAT	todfloat	float	( p u -- df2 ) convert stg to quad ranum, d"float"
DFLOAT+	dfloatp	ans	( n1 -- n2 ) 12.6.2.1208 12.6.2.1208
DFLOATS	dfloats	ans	( n1 -- n2 ) mul-16, 12.6.2.1209 12.6.2.1209
DFOVER	dfover	float	( df1 df2 -- df1 df2 df1 )
DFPICK	dfpick	float	( df1... n1 -- df1 ) pick double float
DFROT	dfrot	float	( df1 df2 df3 -- df2 df3 df1 )
DFSWAP	dfswap	float	( df1 df2 -- df2 df1 )
D>S	dftof	floatop	( df1 -- f2 ) 12.6.1.1130 12.6.1.1130
S>D	ftodf	floatop	( f1 -- df2 ) convert float to double size

defining words
=:	valdef	forth	store integer to known or create new {value}
:	colon	forth	begin a 'colon definition'
+>	pltov	ans	-re- {to} for "pforth" (etc)
2constant	twocons	forth	define non-alterable double constant
2integer	integer2	forth	immediately compiled double cons
2value	value2	forth	double alterable 'constant'
2variable	twovari	forth	(un)initiated double variable
4constant	qconstant	forth	define non-alterable quad constant
4integer	integer4	forth	immediately compiled quad cons
4variable	qvari	forth	(un)initiated quad variable
alias	alias	tools	defining a synonymous word
associative:	assocc	forth	cpl an {associative:} list
build	build	hidden	cpl a linked header name
case:	caseco	forth	cpl a {case:} list
code	code	forth	begin lo-level word -useless w/ lib4th-
cons+	consp	forth	define constant increment
constant	constant	forth	define non-alterable constant
create	create	forth	build a 'variable'-type header
cstg	cstg4	forth	defines a counted string value
c+stg	cstgps	forth	append char to stg value
defer	defer	forth	stored true address or ix executing vari
:forget	colforget	forth	define a word-specific forget-action
forget>	forgetgt	forth	link a word to {forket-lk} chain
head	head	hidden	build a word header
integer	integer	forth	immediately compiled cons
is-default	isdefault	forth	reset deferred word to default action
ninteger	ninteger	bignum	counted int alterable constant
:noname	noname	forth	begin a header-less hi-level word
range:	rangec	forth	cpl a {range:} list
:slist	colslist	forth	init ref/subst-list for {substitute}
stg	stg4	forth	defines a string value
+to	pltov	forth	add @tos to a value
+to-stg	stgps	forth	append stg to stg value
to-stg	stgs	forth	sto new stg value
val+	valp	forth	alterable increment by a.u.
value	value	forth	alterable 'constant'
variable	variable	forth	uninitiated (set to 0) variable
vcells+	cellsvp	forth	alterable increment by cells
vocabulary	vocabulary	forth	define a vocabulary by name
wordlist	wordlist	forth	define a 'wordlist'

code compiler
'	tick	forth	fetch xec token ix by name as a literal
[	lbrac	root	dec cpl nesting level by one, interpret if < 1
[_]	bcb	root	synonym [compile]/compile/POSTPONE
[,]	bcompilecb	root	immediately compile from index
[;]	bsemib	compiler	return address adjustmt, -re- {;r} runtime
[:]	bcolonb	compiler	code-space adjustmt for safe return, by {:r}
[']	tick	ans	cpl xec token ix fetched by name
[[	llbrac	compiler	dec cpl nesting level by two, interpret if < 1
]	rbrac	forth	enter cpl state, inc nesting level by one
]]	rrbrac	compiler	enter structure compiling state
-0exit	dzexit	forth	if ff leave current word
1,	cpl1	forth	compile byte to c-here
2,	cpl2	forth	compile l.s. half sing (2 bytes) to c-here
2literal	adliteral	ans	cpl ANS mode (big endian) double literal
2literal	dliteral	forth	cpl double literal
4,	cpl4	forth	compile sing (4 bytes) to c-here
4literal	qliteral	forth	cpl quad literal
asciz	hasciz	compiler	cpl next stg in asciz-mode
c[	clbrac	root	dec cpl nesting level by one, interpret if < 1
calign	calign	forth	align code-ptr up to next multiple of 4
call,	c_call	compiler	( -- ) call dword disp
call-by-disp	cbdisp	compiler	cpl relative calls by disp
call-by-disp?	cbdispq	forth	query cpl mode
call-by-uot	cbuot	compiler	cpl indirect call by address in uot
c-allot	callot	forth	code-space & module non-modifyable data
cdepth	cdepth	compiler	depth of compile-stack doubles
cfalign	cfalign	forth	align code-ptr up to next multiple of 8
CHAR	char	ans	cpl character value literal
[CHAR]	char	ans	compile character value literal
cmac	hcmac	compiler	h-flg, enable macroes cpl
cmc?	cmcq	compiler	state of optimizing token counter
cmc-off	cmcoff	root	disable <call> to <jmp> conversion
cnalign	cnalign	forth	align code-ptr up to next multiple supplied sing
compile	compile	forth	compile next word
-compile	mcompile	forth	fetch name, xec if interpreting, else compile
-compile,	mcompilec	forth	xec by index else compile
[compile]	bcb	forth	synonym {postpone}
compile,	compilec	forth	compile by supplied ix
(cp)	uprevcp	compiler	by {compile,} previously used code-ptr
cpl	cpl	hidden	make compiled code permanent
cpl;	csemis	hidden	terminate permanent code compilation
cs-depth	csdepth	forth	( -- n ) cpl-stack depth, less count from <colon>
cs-drop	csdrop	forth	drop (double) item from compile-stack
csp	csp	forth	compiling state saved data-stack ptr
!csp	scsp	forth	store sp to csp
@csp	fcsp	hidden	restore sp from @csp
csp@	cspf	hidden	fetch stored sp from csp to tos
cs-pick	cspick	forth	pick (double) item from compile-stack
cs-roll	csroll	forth	roll double on compile-stack
dlit,	c_dlit	compiler	( d -- ) cpl double literal
dliteral	dliteral	forth	cpl double literal
dodoes,	c_dds	compiler	( -- ) cpl dodoes, pfa to be patched to start+2
does>	doesgt	forth	begin runtime part of defining word
does@>	fdoesgt	forth	begin runtime part of defining word
ds-pick	dspick	forth	pick sing wrt saved data-stack
end-macro	cendmacro	compiler	terminate macro code-expansion cpl
exit	exitf	forth	leave hi-level word, resolve locals
-exit	dexit	forth	if tf leave current word
flg>head	flg2head	compiler	( n ix -- n ) set/clr header flag
flit,	c_flit	compiler	( f -- ) cpl double precision f.p. literal (n.i.)
forget,	fgcomma	forth	link a word to {forket-lk} chain
imed	himed	compiler	h-flg, xec immediately
imed?	imedq	compiler	tf if word (by lfa) is immediate
immediate	immediate	root	set latest word to immediately executing
inif	hinif	compiler	h-flg, init from header fields at system startup
itld,	c_itld	compiler	( n -- ) load T register, mov edx,imed
itos,	c_itos	compiler	( -- ) mov eax,imed
itos1,	c_itos1	compiler	( n -- ) mov TOS(1),imed
iwld,	c_iwld	compiler	( n -- ) load W register, mov ecx,imed
(ix)	uprevix	compiler	previously cpl'd ix
ixec	hixec	compiler	h-flg, xec always
jccn,	c_jccn	compiler	( -- ) jcc near disp
jccs,	c_jccs	compiler	( -- ) jcc short disp
jmpn,	c_jmpn	compiler	( -- ) jmp near disp
jmps,	c_jmps	compiler	( -- ) jmp short disp
kcall,	c_kcall	compiler	( disp -- ) call [dword kref (disp)]
ktos,	c_ktos	compiler	( disp -- ) mov eax,[kref (disp)]
ktos1,	c_ktos1	compiler	( disp -- ) mov ecx,[kref (disp)]
ktosm,	c_ktosm	compiler	( -- ) mov TOS(1),ecx
lit,	c_lit	compiler	( n -- ) cpl single literal; spush, mov eax,dword n
literal	literal	forth	cpl single literal
litp,	c_litp	compiler	( n -- ) cpl single literal, add eax,dword n
(lkindex)	plkindexp	hidden	cpl next u.o.t. index
locp,	c_locp	compiler	( n -- ) cpl ptr to a local "value",
locto,	c_locto	compiler	( -n -- ) cpl local "to",
locv,	c_locv	compiler	( n -- ) cpl single local "value",
mac-disp	macdisp	compiler	( ix -- n ) +n disp xec to start of macro code
macro	cmacro	compiler	begin macro code-expansion cpl
mac-size	macsize	compiler	( ix -- n ) no. of bytes cpl'd in macro mode
nlit,	c_nlit	compiler	( .x. N -- ) cpl counted integer
nliteral	nliteral	bignum	cpl multi-cell literal
no-opt	noopt	root	modify latest to not substituting end-ret w/ jump
nopt	hnopt	compiler	h-flg, non-optimizing
pfax	hpfax	compiler	h-flg, pc-rel xec vector @pfa, data-field(s) follow
plocto,	c_plocto	compiler	( -n -- ) cpl local "+to",
plsto,	c_plsto	compiler	( n -- n ) prep add & drop @tos to "value"
pop-io	popio	forth	restore i/o from tor
POSTPONE	bcb	ans	delay execution
push-io	pushio	forth	save i/o to tor, assign local tib
qlit,	c_qlit	compiler	( q -- ) cpl quad literal
qvlit,	c_qvlit	compiler	( qv -- ) cpl quad ranum literal
ret,	c_ret	compiler	( disp -- ) return from suroutine call
sliteral	sliteral	forth	cpl supplied stg
smud	hsmud	compiler	h-flg, sumudged ("find" disabled)
smudge	smudge	fig	toggle find-ability of latest word
spop,	c_spop	compiler	( -- ) drop @nos into @tos
spush,	c_spush	compiler	( -- ) push @tos, free @tos for data item
spush2,	c_spush2	compiler	( -- ) push souble @tos for double data item
sto,	c_sto	compiler	( n -- n ) prep sto & drop @tos to "value"
szliteral	szliteral	forth	cpl supplied <nul>-terminated stg
toggle	toggle	fig	( p c -- ) xor byte in memory - fig, reversed opr
tospull,	c_tospull	compiler	( -- ) TOSPULL(1), dec PS by one cell
tospush,	c_tospush	compiler	( -- ) TOSPUSH(1), inc PS by one cell
unsmudge	unsmudge	root	enable finding of latest word
utod,	c_utod	compiler	( disp -- ) mov eax,[uref (disp)]
utosa,	c_utosa	compiler	( disp -- ) add eax,[uref (disp)], add uvari
valu,	c_valu	compiler	( n -- ) cpl "value"; spush, mov eax,[kref dword n]
varf	hvarf	compiler	h-flg, vari, 2nd header-field disp to dataspace
vocf	hvocf	compiler	h-flg, word is a vocabulary
wcas	hwcas	compiler	h-flg, search letter-case dependently, only
xcall,	c_xcall	compiler	( disp -- ) call [uref uv.ultab+(disp)]
xcalla,	c_xcalla	compiler	( -- ) call [uref 4*reg+uv.ultab]
xjmp,	c_xjmp	compiler	( disp -- ) jmp [uref uv.ultab+(disp)]
xtos,	c_xtos	compiler	( disp -- ) mov eax,[uref uv.ultab+(disp)
xwfl	hxwfl	compiler	h-flg, count of parameter fields, no-exec flag

program flow control
0if	nif	hidden	opt, subst. { ... if else }
again	again	forth	terminate endless loop after BEGIN
ahead	ahead	forth	prepare forward branch disp
back	back	forth	cpl backward disp to {here}
begin	begin	forth	begin a repeat/until/again structure
CASE	case	ans	begin a CASE decision sequence
?case	qcase	forth	enter true part if @tos = @nos
DEFAULT	noop	ans	last alternative in CASE sequence - a noop
do	do	forth	begin counted loop
?do	qdo	forth	enter DO-loop if start =/= limit
else	else	forth	enter IF "false" alternative
else;	elses	forth	opt, subst. { .. exit else }
END	fend	float	( -- ) terminate FOR-loop at next NEXT
ENDCASE	endcase	ans	terminate CASE sequence
endif	endif	forth	terminate IF/ELSE sequence
endif;	endifs	forth	opt, subst. { ... exit endif }
ENDOF	endof	ans	terminate OF-part in CASE sequence
enter	nter	forth	jump to after ENTRY in a BEGIN structure
-enter	mnter	forth	conditonally enter BEGIN structure at ENTRY
entry	ntry	forth	destination after BEGIN from ENTER
FOR	for	float	( f1 -- ) begin FOR .. NEXT loop, set range
FROM	from	float	( f1 -- ) set FOR-loop start
+FROM	pfrom	float	( f1 -- ) modify FOR-loop start & limit by disp f1
i	i	forth	( -- n ) copy loop index to tos
IDX	fidx	float	( -- f1 ) innermost FOR-loop index
!IDX	sidx	float	( f1 -- ) store FOR-loop index
if	if	forth	begin an IF/ELSE sequence
INC	fstep	float	( -- f1 ) FOR-loop increment
!INC	sinc	float	( f1 -- ) store FOR-loop increment
j	j	forth	( -- n ) copy 2nd order loop index to tos
leave	xleave	fig	unconditionally leave DO-loop at next LOOP
leave	xleave	forth	unconditionally leave DO-loop at next LOOP
-leave	dleave	fig	LEAVE if @tos =/= 0
li	li	forth	( n1 -- n2 ) n1-st order loop limit to tos
LIM	flim	float	( -- f1 ) FOR-loop limit
loop	xloop	forth	terminate a DO-loop sequence
+loop	ploop	forth	LOOP by explicit increment
mark	mark	forth	prepare back reference
NEXT	next	float	( -- ) terminate a FOR-loop
ni	ni	forth	( n1 -- n2 ) n1-st order loop index to tos
NX	nx	float	( n -- f1 ) n-th level FOR-loop index
@NX	fnx	float	( -- p ) ptr to n-th level FOR-loop ctrl data
OF	of	ans	begin true decision part in a CASE sequence
recurse	recurse	forth	call the caller
repeat	repeat	forth	terminate BEGIN/WHILE, loop back to BEGIN
>resolve	toresolve	forth	resolve forward branch
STEP	step	float	( f1 -- ) set FOR-loop increment
THEN	endif	ans	terminate IF/ELSE sequence
UNLOOP	unloop	ans	at runtime discard loop control data
until	until	forth	REPEAT if @tos = 0 else leave BEGIN structure
WHILE	whilea	ans	if @tos = 0 leave BEGIN structure
while	while	forth	if @tos = 0 leave BEGIN structure

data compiler
,	comma	forth	compile sing (4 bytes) to data-space
"	qte	forth	cpl stg, ret ptr to stg
align	xalign	forth	align data-ptr up to next multiple of 4
allot	allot	forth	reserve space in data-memory
b,	bcomma	forth	compile l.s. byte of sing to data-space
c,	ccomma	forth	compile char (1 byte) to data-space
c"	cqte	forth	ptr to stg
cases,	casesc	hidden	( -- ) {case:} &c, cpl ix or sing until {;}
s"	sqte	forth	ptr to 1st cahr of stg and count
slist	slists	forth	cpl by suppl. char dlm. ref/subst stg
slist,	slistc	forth	cpl ref/subst stg to data-space
slist;	slistsemi	forth	terminate list of ref/subst stg-s
slist"	slistqte	forth	cpl by {"} delimted ref/subst stg
slit,	slitc	forth	store & allot string to data-space
string	stng	forth	cpl by supplied char delimited stg
szlit,	szlitc	forth	allot & store <nul>-terminated stg in data-space
w,	wcomma	forth	compile l.s. half sing (2 bytes) to data-space
z"	zqte	forth	<nul>-terminated stg literal

assembler
16*+	mp16	assembler	( n -- n ) { 16 * + }
8*+	mp8	asmhidden	( n -- n ) { 8 * + }
c0-	c0m	asmhidden	( n -- n ) { $c0 - }
c0+	c0p	asmhidden	( n -- n ) { $c0 + }
c0-8*	c0m8m	asmhidden	( n -- n ) { $c0 - 8 * }
<call>	lcallg	assembler	x86 op-code, call pc-rel
;CODE	scode	ans	terminate colon defn, continue 'lo level'
end-code	endcode	assembler	terminate -re- {code} defn
<jmp>	ljmpg	assembler	x86 op-code, jmp near pc-rel
<jr>	ljrg	assembler	x86 op-code, jmp short pc-rel
<nop>	lnopg	assembler	x86 op-code, nop
<ret>	lretg	assembler	x86 op-code, ret

i/o port access
ioperm	sysioperm	linux	syscall, i/o permissions, interrupts
iopl	sysiopl	linux	set i/o priority (root user, only)
p!	ps	linux	store 32bit item to port
p@	pf	linux	fetch 32bit item from port
pc!	pcs	linux	store 8bit item to port
pc@	pcf	linux	fetch 8bit item from port
pc!s	pcss	linux	store multiple 8bit items to port
pc@s	pcfs	linux	fetch multiple 8bit items from port
p!s	pss	linux	store multiple 32bit items to port
p@s	pfs	linux	fetch multiple 32bit items from port
pw!	pws	linux	store 16bit item to port
pw@	pwf	linux	fetch 16bit item from port
pw!s	pwss	linux	store multiple 16bit items to port
pw@s	pwfs	linux	fetch multiple 16bit items from port

return-stack sing, doubles, quad
2r	r2	forth	(R d -- d )( -- d ) double from return-stack
2>R	ator2	ans	( n1 n2 -- )(R -- n1 n2 ) push to r-stack, BIG ENDIAN
2>r	tor2	forth	( n1 n2 -- )(R -- n2 n1 ) push double to return-stack
2R>	arfrom2	ans	(R d -- )( -- d ) pop double from rstack,BIG ENDIAN
2r>	rfrom2	forth	(R d -- )( -- d ) pop double from return-stack
2R@	ar2f	ans	(R d -- d )( -- d ) copy double from rstack, BIG ENDIAN
2r>>2r	r2xchg	forth	( d1 -- d2 )(R d2 -- d1 ) ; 2r> 2swap 2>r
2rdrop	rdrop2	forth	(R dn -- ) ; 2r> 2drop
2>rr	torr2	forth	( d -- )(R -- d ) copy double to return-stack
2rswap	rswap2	forth	(R d1 d2 -- d2 d1 ) ; 2r> 2r> 2swap 2>r 2>r
4r	r4	forth	( -- q1 )(R q1 -- q1 ) copy quad from RS to DS
4>r	tor4	forth	( -- q1 )(R q1 -- ) quad from return-stack
4r>	rfrom4	forth	( q1 -- )(R -- q1 ) quad to RS
4rdrop	rdrop4	forth	(R q1 -- ) ; drop four cells from RS
n>r	ntor	forth	push data-stack cells to return-stack
nr>	nrfrom	forth	pop return-stack cells to data-stack
nr@	nrfetch	forth	copy return-stack cells to data-stack
r	r	forth	( -- n )(R n -- n ) push @tor to @tos
>r	tor	forth	( n -- ) push sing to return-stack
!r	storer	hidden	( p -- )(R n -- ) ; r> swap !
r>	rfrom	forth	( -- n )(R n -- ) pop from ret-stack to tos
r@	r	forth	( -- n )(R n -- n ) push @tor to @tos (ans word)
r+!	rps	forth	( n -- )(R n2 -- n3 ) add to @RS
rdrop	rdrop	forth	(R n -- ) ; r> drop
RP!	arpstore	ans	( p -- )(R -- ) rst returnstack-ptr to ptr
rp!	rpstore	forth	( -- .xx. ) restore returnstack-ptr from uvari {r0}
rp@	rpfetch	forth	fetch returnstack-ptr
>rr	torr	forth	( n -- n ) copy sing to return-stack
r>>r	rxchg	forth	( n1 -- n2 )(R n2 -- n1 ) ; r> swap >r
rswap	rswap	forth	(R n1 n2 -- n2 n1 ) swap on returnstack

data-stack doubles
2drop	drop2	forth	( d -- ) drop two cells
2dropd	dropd2	forth	( d1 d2 -- d1 d1 ) ; 2drop 2dup
2dup	dup2	forth	( d -- d d ) duplicate double
2lshift	dlshiftf	nonmmx	2lshift
2oswap	oswap2	forth	( d1 d2 -- d1 d1 d2 ) ; 2over 2swap
2over	over2	forth	( d1 d2 -- d1 d2 d1 ) copy double @nos to tos
2pick	pick2	forth	( .dd. n -- .dd. dn ) pick double
2-pick	mpick2	forth	( dn ... d2 d1 m -- dn..d1..d2 ) ; 2store into stack
2roll	roll2	forth	( .dd. n -- .. dn ) roll doubles
2rot	rot2	forth	( d1 d2 d3 -- d2 d3 d1 ) roll by 2
2rot	rot2f	nonmmx	2rot
2-rot	mrot2	forth	( d1 d2 d3 -- d3 d1 d2 ) ; 2rot 2rot
2rotd	rotd2f	nonmmx	2rot 2drop, duplicate 3rd on tos
2rots	rots2	forth	( d1 d2 d3 -- d3 d2 d1 ) ; 2rot 2swap
2rshift	drshiftf	nonmmx	2rshift
2rshifta	drshiftaf	nonmmx	2rshifta
2sdrop	sdrop2	forth	( d1 d2 -- d2 ) ; 2swap 2drop
2sdup	sdup2	forth	( d1 d2 -- d2 d1 d1 ) ; 2swap 2dup
2sdup	twosdupf	nonmmx	2swap 2dup
2sover	sover2	forth	( d1 d2 -- d2 d1 d2 ) ; 2swap 2over
2sover	twosoverf	nonmmx	2swap 2over
2srot	srot2	forth	( d1 d2 d3 -- d3 d2 d1 ) ; 2swap 2rot
2srot	srot2f	nonmmx	2swap 2rot
2swap	swap2	forth	( d1 d2 -- d2 d1 ) exchange double @tos w/ @nos
2third	third2	forth	( d1 d2 d3 -- d1 d2 d3 d1 ) ; 2 2pick
d2dup	d2dup	forth	( d -- d d d ) ; 2dup 2dup

data-stack multiple cells
3drop	drop3	forth	( n1 n2 n3 -- ) ; 2drop drop
3dup	dup3	forth	( d1 n1 -- d1 n1 d1 n1 ) ; dup 2over rot
3dup	dup3f	nonmmx	dup 2over rot
8drop	drop8	forth	( o1 -- ) drop top 8 cells, quad ranum
8dup	dup8	forth	( o1 -- o1 o1 ) dup top 8 cells item, quad ranum
8dup	dup8f	nonmmx	4over 4over = 8 ndup
8over	over8	forth	( o1 o2 -- o1 o2 o1 ) over 8 cells item, quad ranum
8over	over8f	nonmmx	( o1 o2 -- o1 o2 o1 )
8pick	pick8	forth	( .. o1 n -- .. o1 on | .. ) +/- pick 8 cells items
8roll	roll8	forth	( on .. o1 n -- .. o1 on | o1 on .. ) roll by 8cells
8sdrop	sdrop8	forth	( o1 o2 -- o2 ) drop @nos 8-cells item
8sdrop	sdrop8f	nonmmx	( o1 o2 -- o2 )
8sover	sover8	forth	( o1 o2 -- o1 o2 o1 ) swap over quad ranums
8sover	sover8f	nonmmx	( o1 o2 -- o2 o1 o2 )
8swap	swap8	forth	( o1 o2 -- o2 o1 ) swap 8-cells items
b->d	b2dn	forth	combine 8 cells ls.bytes to a double
ndrop	ndrop	forth	drop n cells
ndup	ndup	forth	dup n cells
nswap	nswap	forth	swap blocks of n cells
rotd2s	rotd2s	forth	( n1 n2 n3 -- n1 n1 n2 n3 ) ; rot dup 2swap
rotd2s	rotd2sf	nonmmx	2 pick -rot, duplicate 3rd on tos
s->b	s2bn	forth	extract 4 bytes from sing
swap2s	swap2s	forth	( n1 n2 n3 n4 -- n4 n3 n2 n1 ) revert cells order

data-stack quad
4drop	drop4	forth	( q1 -- ) drop 4 cells
4dup	dup4	forth	( q1 -- q1 q1 ) duplicate quad @tos
4dup	dup4f	nonmmx	4dup
-4dup	qdup4	forth	( q1 -- q1 q1 | q0 ) 4dup @tos if non-zero
4over	over4	forth	( q1 q2 -- q1 q2 q1 ) push quad @nos to tos
4over	over4f	nonmmx	4over
4pick	pick4	forth	( qx..qn..q0 n -- qx..qn..q0 qn) +/- pick quad
4roll	roll4	forth	( qn .. q1 n -- .. q1 qn | q1 qn .. ) +/- roll quads
4rot	rot4	forth	( q1 q2 q3 -- q2 q3 q1 ) rot quads
4rot	rot4f	nonmmx	2 4roll
4-rot	mrot4	forth	( q1 q2 q3 -- q3 q1 q2 ) reverse rot quad
4-rot	mrot4f	nonmmx	-2 4roll
4rotd	rot4d	forth	( q1 q2 q3 -- q2 q3 ) rot drop quads
4rotd	rot4df	nonmmx	2 4roll 4drop
4sdrop	sdrop4	forth	( q1 q2 -- q2 ) ; 4swap 4drop
4sdrop	sdrop4f	nonmmx	4swap 4drop
4sover	sover4	forth	( q1 q2 -- q2 q1 q2 ) ; 4swap 4over
4sover	sover4f	nonmmx	4swap 4over
4swap	swap4	forth	( q1 q2 -- q2 q1 ) exchange top two quads
4swap	swap4f	nonmmx	4swap

data-stack sing
><	xgb	forth	( n1 -- n2 ) swap l.s. two bytes of a sing
>|<	w2b	forth	( n1 -- n2 ) extract l.s. two bytes of a sing
>||<	d2w	forth	( n1 -- n2 n3 ) extract the two halves of a sing
0drop	zdrop	forth	-dup drop ; discard zero cell @tos
2rotd	rotd2	forth	( d1 d2 d3 -- d2 d3 ) ; 2rot 2drop
aligned	aligned	forth	align sing up to next multiple of 4
bounds	bounds	forth	( n1 n2 -- n1+n2 n1 ) ; over + swap
b->s	b2sn	forth	combine 4 cells ls.bytes to a sing
ddup	ddup	forth	( n -- n n n ) ; dup dup
depth	depth	forth	( -- n ) count of cells on data-stack
-depth	mdepth	forth	( -- n ) cells free in data-stack
drop	drop	forth	( n -- ) discard cell @tos
-drop	mdrop	forth	dup 0= -dup 2drop ; discard non-zero @tos
dropd	dropd	forth	( n1 n2 -- n1 n1 ) ; drop dup
dup	cdup	forth	( n -- n n ) duplicate @tos, { 0 pick }
-dup	qdup	forth	( n | 0 -- n n | 0 ) dup @tos if non-zero
?DUP	qdup	ans	( n -- n n | 0 ) dup if dup endif ; {-dup}
naligned	naligned	forth	align sing up to next multiple of supplied sing
NIP	sdrop	ans	( n1 n2 -- n2 ) ; swap drop
oswap	oswap	forth	( n1 n2 -- n1 n1 n2 ) ; over swap
over	over	forth	( n1 n2 -- n1 n2 n1 ) copy @nos to tos
pack	pack	forth	byte to packed nib
paligned	palignp	linux	page align to next multiple of page size
paligned-	palignm	linux	page align (truncate)
pick	pick	forth	( .xx. n -- .xx. xn ) fetch cell wrt tos
-pick	mpick	forth	( nn ... n2 n1 m -- nn..n1..n2 ) ; store into stack
roll	roll	forth	( .xx. n -- .. xn ) roll cells
rot	rot	forth	( n1 n2 n3 -- n2 n3 n1 ) 2 roll
-rot	mrot	forth	( n1 n2 n3 -- n3 n2 n1 ) reverse rot, { -2 roll }
rotd	rotd	forth	( n1 n2 n3 -- n2 n3 ) ; rot drop
rots	rots	forth	( n1 n2 n3 -- n2 n1 n3 ) ; rot swap
sdrop	sdrop	forth	( n1 n2 -- n2 ) ; swap drop (a 'nip')
sdup	sdup	forth	( n1 n2 -- n2 n1 n1 ) ; swap dup
sover	sover	forth	( n1 n2 -- n2 n1 n2 ) ; swap over (a 'tuck')
sp>	fspstore	forth	( .xx. -- ) clr data-stack
SP!	aspstore	ans	( p -- ) set datastack-ptr to kref'd supplied value
sp!	fspstore	fig	( -- .xx. ) rst datastack-ptr from uvari {r0}
sp!	spstore	forth	( .. -- .. ) vectored to fig or ans mode, dft fig
sp@	spfetch	forth	fetch datastack-ptr
srot	srot	forth	( n1 n2 n3 -- n3 n2 n1 ) ; swap rot
swap	swap	forth	( n1 n2 -- n2 n1 ) exchange sings @tos w/ @nos
swap-	swsub	forth	{ swap - } ; reversed cells subtract
swapn	swapn	forth	swap tos w. n-th cell
third	third	forth	( n1 n2 n3 -- n1 n2 n3 n1 ) ; 2 pick
TUCK	sover	ans	( n1 n2 -- n2 n1 n2 ) ; swap over
unpack	unpack	forth	packed nib to byte
wswap	wswap	forth	( n1 -- n2 ) swap hi & lo half of cell @tos

text, chars data, words
."	dotquote	forth	display string
1/string	s1string	forth	adjust stg parameters by 1
blank	blanks	forth	( p +u -- ) fill memory w. blanks
blanks	blanks	fig	( p +u -- ) fill memory w. blanks
+blanks	pblanks	forth	right align a string by blanks
bl.r	bldotr	forth	( p n1 n2 -- p n1 ) right algn'd fill w/ leading <bl>s
bslice	bslice	forth	string slice by byte positions
can?	canq	forth	test input for <can> sequence
compare	compare	forth	compare two stgs
COUNT	count	ans	( p1 -- p2 u ) chars(bytes?) count of a counted string
count	ccount	forth	( p1 -- p2 u ) ptr to 1st char and count
csearch	csearch	forth	search by supplied char delimited stg
cslice	cslice	forth	string slice by chars
e\stg	estg	forth	convert escaped chars in stg
enclose	enclose	fig	isolate a word from tib -?-
enclose	enclose4	forth	isolate a word from tib -?-
#enum	nenum	forth	count of asciz stg in a slist
enum?	enumq	forth	list asciz stgs of enum-list
enum@	enumf	forth	find stg by item no. in list
enum#	enumn	forth	find no. of asciz stg in list
lc-depend	lcdepend	forth	stg comparison in letter case dependent mode
lc-ignore	lcignore	root	stg comparison in letter case independent mode
LC-IGNORE	lcignore	root	stg comparison in letter case independent mode
parse	parse	forth	isolate input field by (trailing) delimiter
parsec	parsec	forth	parse from supplied string
place	place	forth	( p1 +u1 p2 -- ) store stg to supplied buffer
+place	pplace	forth	( p1 n p2 -- ) pre-/append stg in memory
printing?	printingq	forth	tf if entire stg is printing chars
replace	replace	forth	replace text section in a string
rscan	rscan	forth	reverse scan stg for character
rskip	rskip	forth	reverse skip characters from stg
s=	compare	forth	compare always case dependently
s=	seq	forth	-re- {compare}, always case dependently
scan	scan	forth	scan stg for character
search	search	forth	search for a string in memory
skip	skip	forth	skip characters from stg
space	space	forth	send a blank space
spaces	spaces	forth	multiply send a blank space
sslice	sslice	forth	string slice by enclosing strings
/string	sstring	forth	adjust stg parameters
substitute	substitute	forth	substitute text from -re- {:slist}s
-trailing	mtrailing	forth	truncate stg from trailing blanks
word	xword	fig	fetch text enclosed by supplied char to {here}
word	XWORD	forth	fetch text enclosed by supplied char, ret ptr
zcount	zcount	forth	( p1 -- p2 u ) {count} wrt <nul>-terminated stg
-zeroes	mzeroes	rational	( p u -- p u' ) trucate trailing zeroes

utilitiy words
adump	adump	tools	dump from true address
[all-find]	ballfindb	utility	{find} by counted stg trough all vocabularies
all-find	allfind	utility	{find} trough all vocabularies
all-words	allwords	utility	{vlist} all vocabularies
bdump	bdump	tools	dump next, towards preceding addresses
#dcm	hdcm	tools	decompile at given ptr
dump	dump	forth	dump memory at ptr
dumpa	dumpa	tools	dump at ptr, display true addr.
fav	pdodefer	hidden	{find}-mode, internal to {help}
help	help	root	help-text from glossary
hv	hvstack	root	{help} mode modifier
id.	iddot	forth	display a word's name by lfa or ix
[locdef]	blocdefb	hidden	[_] also [_] local definitions
name	name	hidden	fetch a <bl>-enclosed filename, { bl word count }
ndump	ndump	tools	dump next, towards ascending addr.
precedes	pdodefer	utility	{ x1 x2 -- f ) {sort} relation
quick	quick	utility	sort datafield
random	random	utility;	uu crea 0, {'random'}, random, utility ;
randomize	randomize	utility;	uu crea 0, {'randomize'}, randomize, utility ;
rdump	rdump	tools	dump again, same range
.rs	dotrs	tools	display returnstack content
[rs]	dotrsi	tools	immediate {.rs}, displaying returnstack
s	nsee	tools	8 times {#see}
.s	dots	forth	dispay datastack content
[s]	dotsi	tools	immediate {.s}, displaying datastack
see	see	forth	de-compiler
#see	hsee	tools	continue decompiling at @fld
seed	pdovar	utility	random, quad vari 'seed'
selected	selected	forth	ccc{ -- ) activate {words} selection
(selected)	pdodefer	utility	{ .xx. -- .xx. ) {words} selection
[selected]	pdodefer	utility	{ .xx. n lfa -- .xx. n lfa ) {words}
sh	sh	root	xec a shell command
sh|	shp	root	xec shell cmd, pipe output to buf
sh-argp	pdovar	systm	shell command arguments ptr's
sort	sort	utility	tag sort array
sorted	sorted	utility	tag sort array by relation name
tdump	tdump	tools	dump, don't store ptrs
v	vau	root	display which wordlist a word is in
vlist	vlist	forth	sequentially list context vocabulary
voc.	vocdot	utility	by lfa display which wordlist a word is in
vocs	vocs	root	display all def'd voc-names
which	which	tools	display path+file if in L4 path
words	words	forth	sorted list context vocabulary

vocabularies, relating opr
also	also	root	push vocs in search order one posn up
ans	ans	forth	forth-voc, words specific to ANS-4th
asm-hidden	asmhidden	assembler	root-voc, native code cpl. words
assembler	assembler	root	root-voc, native code cpl. words
bignum	bignum	forth	forth-voc, unlimited praecision integers
blkfile	blkfile	forth	forth-voc, block-file special words
compiler	compiler	root	root-voc, cpl control
cons	racons	rational	rational-voc, all sizes' constants
context	context	forth	1st wordlist in search order
current	current	forth	current defining vocabulary
definitions	definitions	root	@current to ocurrent, @context to current
editor	editor	fig	fig-forth-voc, editting
environment	environment	hidden	hidden-voc, ansi-ish environment queries
fig	fig	forth	forth-voc, words specific f.i.g.-style 4th
FLOAT	float	ans	ans-voc, real numbers
float-op	floatop	float	{FLOAT}-subvoc w. un-praefixed names
forth	forth	root	root-voc, main
forth-wordlist	forthwl	root	wid of {forth}
get-current	gcurrent	root	@current
GET-ORDER	gorder	ans	content + count of voc-stack
get-vocflags	gvocflags	hidden	fetch vocabulary-specific flags at voc-stack
get-vocs	getvocs	root	fetch all wid-s + count from voc-stack
hidden	rahidden	rational	rational-voc, support and quad ranum
hidden	hidden	root	root-voc, used within other words
last	lastu	forth	global last words nfa in dictionary
latest	latest	forth	last words nfa in {current} voc.
linux	linux	root	root-voc, host access
local	local	hidden	hidden-voc, local memory control & names
non-mmx	nonmmx	forth	forth-voc, non-mmx substitutes
novoc	novoc	systm	system-voc, non-executeable, dummy names
ocontext	ocontext	hidden	previous {context}, 2nd in search order
ocurrent	ocurrent	hidden	previous {current}
only	only	root	minimal wordset
order	order	root	display vocabulary names as in search order
order?	orderq	root	item no of stacked voc by ix, or -1
prevdef	prevdef	root	restore previous {current}
previous	previous	root	pop and discard context voc fron voc-stack
rational	rational	root	root-voc, real numbers
root	root	root	basic voc, essential words, linkage base
root-wordlist	rootwl	hidden	wid of {root}
rvoc	rvoc	root	restore previous {context}
SEARCH-WORDLIST	swlist	ans	find a name in given wordlist
set-current	scurrent	root	store wid to {current}
set-order	sorder	root	store entire search order
set-vocflags	svocflags	hidden	(re)store vocabulary-specific flags at voc-stack
set-vocs	setvocs	root	(re)store vocabulary ptrs at voc-stack
system	systm	root	root-voc, hardware specific
testvoc	testvoc	hidden	hidden-voc, (praeliminary tests)
tools	tools	forth	forth-voc, debugging
util	utility	forth	forth-voc, forth utiliy words
voc-link	voclink	forth	wordlists and vocabularies link-ptr
vt	vt	forth	forth-voc, vt..-control
width	width	forth	max count of a 4th name -n.i.-
WORDLIST?	wordlq	ans	item no of stacked wordlist by wid, or -1
wvoc	wvoc	utility	vocabulary link by lfa of a word
wvoc-r	wvocr	utility	2ndary vocabulary link by lfa of a word

forth, other words...
abort	pdodefer	root	deferred {abort}
beep	beep	forth	controllable noise..
#case	ncase	forth	case-list index by which a word was called
#cases	ncases	forth	items in a {case:}, {range:}, {associative:} list
cell	pfour	forth	count of bytes per cell
--env-ini	f8ini	systm	evluate F8INI env vari
error	errorv	root	vectored {error}, dft deferred {<error>}
<error>	pdodefer	root	deferred, dft {[error]}
fld	ufld	forth	user vari in dump, else free
noop	noop	root	no action, just <ret>
quit	quit	root	outer interpreter, exit from loadfiles
scanvocs	scanvocs	hidden	execute a vector by ix on all wordlists
scanwlist	scanwlist	hidden	execute a vector on stacked wordlists
source	source	forth	current input source descriptor
task	task	forth	traditionally the forth kernel top word...

linux specific, system
alarm	calarm	forth	send alarm signal after given time in seconds
(alarm)	pdodefer	linux	SIGALRM redirection, dft { .s }
(argc)	argc	hidden	program's arguments count
(argn)	argn	hidden	internal, 2nd-ary args count
argp	argpp	hidden	ptr to args to program
(argp)	argp	hidden	ptr to args to program
(args)	args	hidden	1st in-active arg#
argstg	argstg	linux	prog args by no.
(aux)	pauxp	hidden	i/o flags
envp	envpp	hidden	ptr to program's environmental vari
envstg	envstg	linux	env vari by no.
fcntl	cfcntl	linux	syscall, files acces &c
getenv	gtenv	linux	env vari by strg
gid!	gids	linux	set process group id
gid@	gidf	linux	fetch process group id
int-ptrace	intptrace	systm	breakpoint for lo-level debugging
ioctl	cioctl	linux	syscall, limited i/o ports range
iomode	iomode	linux	check and (re)set i/o-channel flags
mm-a	mma	linux	MAP_ANONYMOUS 0x20, don't use a file
mm-d	mmd	linux	MAP_DENYWRITE 0x0800, ETXTBSY
mm-e	mme	linux	MAP_EXECUTABLE 0x1000, mark it as an executable
mm-f	mmf	linux	MAP_FIXED 0x10 Interpret addr exactly, fail otherwise
mm-g	mmg	linux	MAP_GROWSDOWN 0x0100, stack-like segment
mm-l	mml	linux	MAP_LOCKED 0x2000, pages are locked
mm-n	mmn	linux	MAP_NORESERVE 0x4000, don't check for reservations
mm-p	mmp	linux	MAP_PRIVATE 0x02, Changes are private
mm-s	mms	linux	MAP_SHARED 0x01, Share changes
mprotect	mprot	linux	memory access permissions
mr-f	mrf	linux	MREMAP_FIXED 2
mr-m	mrm	linux	MREMAP_MAYMOVE 1
ms-a	msa	linux	MS_ASYNC 1, sync memory asynchronously
ms-i	msi	linux	MS_INVALIDATE 2, invalidate the caches
ms-s	mss	linux	MS_SYNC 4, synchronous memory sync
pid@	pidf	linux	fetch own process id
prot-r	protr	linux	bitmask to disabling read-protection
prot-w	protw	linux	bitmask to disabling write-protection
prot-x	protx	linux	bitmask to disabling xec-protection
sleep	sleeps	linux	halt caller for given time in seconds
sleep-m	sleepm	linux	halt caller for given time in microseconds
sleep-n	nsleep	linux	halt caller for given time in nano- and seconds
(sys)	psysp	linux	find syscall-no. by name
[sys]	bsysb	linux	execute syscall by namestring
syscall	scall	linux	system call by number
syskill	syskill	linux	send signal
uid!	uids	linux	set process user id
uid@	uidf	linux	fetch process user id
umask	umaskf	linux	globally set new files default access mode
umask?	umaskq	linux	read file creation permissions mask
wdw-lk	pdovar	hidden	double linkage of window defn's

system related words
--	slsl	root	active initial args terminator, no-op
#!	hb	root	begin scripting marker, synonym {include}
4th-id	fthid	root	initial job-id
abort"	abtqte	forth	if tf abort and prnt message
anew	marker	ans	{marker}, for 'common useage' compatibility...
bye	bye	root	xit program w. 0 err code
bye-r	byer	linux	xit program with code n
c0	c0	forth	ptr to base of code-space
casedep	casedep	compiler	set latest word to case-dependent find mode
c-fence	cfence	forth	ptr to fenced code-space
c-here	chere	forth	ptr to available code-space
cp	cp	forth	storage of ptr into code-space
.cpu	dotcpu	forth	display cpu type
ctag	pdovar	linux	global channel open tag
c-top	ctop	forth	ptr to top of available code-space
d0	d0	forth	ptr to base of data-space
data?	dataq	hidden	tf if ptr points to data space
depth?	depthq	forth	tf if sufficient data on stack
empty	empty	forth	forget all above fence
err-id	errid	linux	channel-id of error channel
f8ini	f8ini	systm	evluate F8INI env vari
fence	fence4	forth	ptr to fenced data-space
!fence	stofence	forth	store current dictionary-ptrs to fence
fence!	fences	forth	store @tos to fence-ptrs
fence@	fencef	forth	set fence-values from supplied data
forget	forget	forth	forget name and all newer words
i-fence	ifence	forth	fenced no. next to rsp u.o.t. index
iforget	iforget	hidden	forget by ix
in-id	inid	linux	channel-id of input channel
kernel?	kernelq	hidden	tf if ptr points to kernel space
kprog?	kprogq	hidden	tf if ptr points to kernel or program space
lib4th	lib4th	root	display l4 cpl date
lxstg	lxstg	linux	control strings by indices
marker	marker	forth	save/restore current dictionary ptrs
message	message	forth	display system message
message?	messageq	forth	display system message if arg =/= 0
ms	ms	forth	halt caller for given time in milliseconds
msgstg	msgstg	forth	fetch system message stg
mtlock	mtlock	systm	lock int's for block opr, enable ports access
mtunlock	mtunlock	systm	un-lock int's, disable ports access
null?	nullq	hidden	tf if 4th ptr is zero true address
out-id	outid	linux	channel-id of output channel
pause	cpause	system	enable re-scheduling of jobs from @(pause)
[pause]	bpauseb	systm	dft {pause}
pop4th	pop4th	systm	(R regs -- ) rst saved cpu-regs -re- {push4th}
prog?	progq	hidden	tf if ptr points to program space
push4th	push4th	systm	(R -- regs ) save cpu regs used by L4 kernel
r0	r0	forth	ptr to return-stack bottom
real-user	ruser	root	set process effective to real user id
s0	s0	forth	ptr to data-stack bottom
set-cal	setcal	hidden	calibrate timer, find cpu clock rate
sforget	sforget	hidden	forget by supplied string and top ix
signo	signo	linux	convert signal name to number
sigstg	sigs	linux	convert signal number to name
ss	ss4	root	for #!-execution after exec. name
static?	staticq	systm	tf if prog statically linked
sys	sys	linux	execute syscall by name
term	eterm	linux	TERM env vari
tib	tib	forth	ptr to terminal input buffer
tib>dft	tib2dft	root	reset t.i.b. to default location
ti-cal	tical	forth	measured cpu clock rate
(tick)	ptickp	hidden	cpu-clocks per second
time	time4	forth	syscall gettimeofday
timezone	tz4	linux	'timezone' figure from <gettimeofday>
uc-map	uclm	linux	map keyboard input to lower chars
uc-unmap	uclu	linux	do not map keyboard input to lower chars
udisp?	udispq	forth	( n -- n f ) uot disp range check
(ulink)	plinkp	hidden	uvari link
(uot)	ultab	hidden	"user offset table" 4th words' true xec addr.
vers	vers	root	4 bytes numeric library version
wait	sleeps	forth	wait given no. of seconds
work-id	workid	linux	work-channel identifier
xec?	xecq	forth	( n -- a f ) xec-addr from ix/ptr
xlock	xlock	systm	exec word w. int's locked

novoc, header-less or not implemented/not complete
alcjob	allocjob	linux	-/-
blk	blk	forth	screenfile block number -n.i.-
blw	BLWORD	novoc	{ bl word find }, kernel only
bwf	blwf	novoc	{ bl word find }, kernel only
(ch	ccasec	novoc	( -- p ) build named list
c+s	ctps	novoc	{c+stg} runtime
(da	doassoc	novoc	( n1 p -- n2 ) {associative:} runtime
(dc	docasec	novoc	( ix p -- xx ) {case:} runtime
(dd	ddi	novoc	( n1 p -- n2 ) {is-default} runtime
ddf	dodfer	novoc	xec a deferred word
ddk	pdodefer	novoc	xec a kernel-deferred word
ddo	dodoes	novoc	xec <pfax>-words
df?	dfder	novoc	undef'd deferred word error if ff
dfg	dfdfg	novoc	dft forget action for deferred word
(di	dfi	novoc	( n1 p -- n2 ) {default-is} runtime
(dr	dorangec	novoc	( n1 p -- n2 ) {range:} runtime
dva	pdovar	novoc	pfax'ed value
dvo	dovoc	novoc	vocabulary
ekm	erkmsg	novoc	uninitiated error message
esm	ersmsg	novoc	signed error no., message
eum	erumsg	novoc	4th message
fga	fga	novoc	{alias} forget-handler
fgb	fgb	novoc	screenfile buffer blocks forget handler
(ic	doisc	novoc	( n1 n2 ix -- ) {iscase} runtime
(is	dois	novoc	( n1 p -- n2 ) {is} runtime
[kb	bkbdt	novoc	{ kbd' name } xec name w. stdin from console
kb]	kbdtb	novoc	{ kbd' name } xec name w. stdin from console
(kc	pdocasec	novoc	( ix p -- xx ) kernel-{case:} runtime
ndf	ndferd	novoc	undef'd deferred word error
n.i	nimp	novoc	'not implemented' in kernel
sgb	rsigb	novoc	exitting signals hnd
sgt	rsigt	novoc	messaging/lib4th active signal hnd
ts	ts	novoc	{to-stg} runtime
t+s	tps	novoc	{+to-stg} runtime
ucopy	usercopy	hidden	copy user-vari from owner to cloned job
(vl	pdoval	novoc	fetch a kernel-def'd value
(vr	pdovar	novoc	fetch a kernel-def'd vari
<with	ltwith	forth	n.i. (defn rules inheritage, re idx>do)