#  	ATOMS...
address		(P --- ptr ) ends a thread's action.	KG
AND		( pytea pyteb ---  aANDb ) the bitwise Boolean, pytewise
aint		( flagp --- !flagp ) casual NOT, bitwise on lsB.
align		(P  a  --- a_rounded_up_to_CELLSIZE
bump		( ---  old_pyte ) undrop. Only useful in threads.
BYTES		sizeof(int) -> Size
bbytesd		bump 1->Size drop
cells_bd	bump sizeof(int)->Size drop
cells		sizeof(int) -> Size
drop		( pyte --- )
dup		( pytea ||| ---	 pytea )  i.e.	  ( a --- a a 
dshift	NU	( shiftee amount --- shifted ) down-signif.bitshift
double	NU	up-roll Size by 1, > 256 wraps
doHNC		(P @HNC	 --- )   execute word given @HNC
emit		(pyte --- )  ascii print lsB. Just get it working
false		( --- 0flagpyte )  fast false lsB
@		(P ptr ||| --- ) ( --- pyte ) fetch pyte at ptr at Size
@+		(P ptr --- ptr+Size ) ( --- pyte ) 
flag		( pyte --- flagpyte ) if pyte <>0 lsB of pyte <> 0
getSize		(P --- Size)
gap		(P a b ||| ) ( --- a-b ) assumes Size=4		KG
halve	NU	halve Size. 0 forced to cellsize
H3sm	U	no-op. No action besides incremnt VM instr pointer
?()=		(P &a &b ||| ) ( ---  flag ) comp pointed-to pytes
?=		( a b --- flagpyte ) 0xXX..ff (true) if a = b
?positive	( a  --- flagpyte )  0 considered positive
literal		( --- pyte ) literal pyte
max		( a b --- maxab ) Min's hubby.
min		( a b --- min_ab) Max's better half.
-		( a b --- a-b )	 2's-complement subtraction of pytes
maskbyte	( a --- a&   0...00ff ) mask off all but lsB
move		(P from to |||) (cnt ---) move cnt bytes
nip	  NU	( pytea pyteb --- pyteb )  
-?r		( --- flagpyte )  (R c --- c-1) is TOR nonzero before decrement?
NOT		( pyte --- !pyte ) bitwise NOT of all bits
over		( a b --- a b a ) the Forth usual OVER, but on pytes.
onbits		( --- -1 )  all_ones pyte constant, 2's compl. -1
one		( --- 1	 ) 1 as a pyte constant
OR		( pytea pyteb ---  aORb ) the bitwise Boolean, pytewise
pdrop		(P ptr --- )  decrement pointer stack index
p@		(P ptr1	 ---  ptr2 ) ptr1 overwritten
pdup		(P ptra --- ptra ptra )
pliteral	(P --- lit )	next cell in thread to P.
+		( a b --- a+b )	 2's-complement addition of pytes
pover		`pea over'  (P a b --- a b a ) pointer-stack OVER
p+		( pyte --- ) (P a --- a+(int_part_or_less_of)pyte
p+s		(P a --- a+Size ) index a pointer up by Size
p+1		(P a --- a+1 )	index a pointer by one (byte-addressable
p+c		(P a --- a+cellsize ) index a pointer by cellsize (x86 is 4
p-c		(P a --- a-cellsize ) decrement pointer by cellsize (4 on x86
p-1	NU	(P ptr --- ptr+1 ) decrement a pointer
p->		(P a --- ) ( --- a_low[a_hi]) assumes cellsize 
p->r		(P a --- ) (R; --- a)    
p->s		(P Size --- )  !Size  masked to 8 bits
p!		`pea store' (P    p store ||| )   p --> store
pswap		(P a b --- b a )
pup		(P ---	oldptr )  pointer stack undrop
rdrop		(R; a --- ) 
rpcopy		(R; a ||| ) (P --- a ) dup r to p
r-1	NU	(R. val --- val-1 )  decrement TOR
<-r	NU	(R; val --- ) ( --- XXXXval )  4 live bytes written to ds
r->p		(R; ptr --- ) (P --- ptr ) symmetrical with p->r.
r->s		(R; size --- )	!SIZE   masked to byte    
swap		( pytea pyteb --- pyteb pytea )
setSize		( Size --- )  Silently refuses to set Size to 0.
s->r		(R; --- Size ) Size to Return stack
s->p		(P --- Size )  Size to pointer stack
!		(P ptr ||| ) ( pyte --- ) pointer is not dropped
->r	NU	(R; --- val ) ( val --- ) Forth >r, ish. 4 bytes moved.
->code		(P @HNC --- Code_Body_Cell ) useful in Ha3sm?
->link		(P @HNC --- Link_Cell ) `to link' field
->p		(P --- CELL ) ( a --- ) CELLSIZE worth of a is moved
true		( --- true_flagpyte ) 0xXXX...ff, true flag pyte constant
2pdrop		(P  A B --- )  drop 2 pointers.
upshift		( shiftee amount ---  up-shifted [ushhigh] ) 
x		( pyte --- ) print & drop a pyte, Forth "." but hex only
XOR		( pytea pyteb ---  aORb ) the bitwise Boolean, pytewise
zero		( --- 0 )   0 as a fast pyte-constant
#  	SYSCALLS ...
become		(P  path argv envp ||| ) ( --- GONE|fail=-1) unix execve
chroot		(P  path |||) ( --- ret) change apparent root directory
close		( FD --- ret )  lose and release a filedescriptor
direntries	( FD  count --- red|-1|0 )  (P  buff ||| ) getdents()
dupFD		(old_FD --- new_FID|-1)   unix dup()
fork		parent.. ( ---PID_of_child_or-1)     child.. (--- 0)
mount		(P special dir fstype|NULL data |||)
nanosleep	(P  timespec remaining ||| )    ( --- flag )
owner		(P path |||)   ( UID  GID --- ret)  unix chown()
pause		( --- -1 )      wait for a signal
parent		( --- parent_PID )      unix getppid()
permit		(P path |||)   ( mode --- ret)   unix chmod()
pipe		(P ptr_to_int[2] |||)  ( --- flag) 2 FD's in given
rename		(P old new |||) ( --- flag ) basis of mv
todir		(P path --- ) (--- ret)  unix chdir(), cd
readlink	(P name buff ||| ) ( bufsize --- flag )  unix readlink
response	( sig# --- flag ) (P action old |||) install a signal
socketcall	( call --- flag )  (P args ||| ) socket calls entry
special		(P name |||)    ( mode dev --- flag )   unix mknod
stat		(P name buff ||| ) ( --- flag) get a file's stat
unlink		(P name ||| ) ( --- flag) rm a name, maybe the data
unmount		(P name ||| )   ( --- flag) unix umount()
symlink		(P exists new |||)  ( --- flag )
waitpid		(pid options --- ret )  simplified
reboot		(P btparm --*POW!!* REBOOT LINUX
rmdir		(P name ||| )   ( --- flag )  remove empty dir
seek		( FD o/s whence --- o/s0 ) unix lseek, reposition-file 
signal		( PID signal --- ret)   unix kill
open_		(P name |||)  ( flags perms --- FD ) see open thread
quit		unix exit, Forth bye, H3m quit. q. works.	KG
read		( FD --- red ) (P buf ||| ) requests 2048 bytes
write		( FDbyte  request --- wrote )   (P name ||| )
#  	NAMED DATA...
ARGV		(P --- &argv[] )
block		(P --- begin_buffer) object data buffer(s
buffer		(P --- begin_buffer) "file" input buffer
bsi		counter for branches to resolve
branchstack	space for 16 branches to resolve
digits		(P  ---	 address_of_array ) ascii vals to hex vals map
dp		(P --- dictionary_free-point_pointer )  pointer, unlike HERE
epa		(P --- @epa )  End Parse Area	pointer
ENVP		(P --- &envp[]
hexdigits	(P  ---	 &array )  ascii val is/not a hex digit
latest		(P --- @HNC ) addr. of HNC of most recent definition
pvar		(P --- \&pvar)	scratch pointer for thread resolver
rcfile		(P --- &"rcfile"
SOURCE		(P --- &input_FD) pointer to FD of source of input
thispointer	(P --- &this ) current address in buffered parse area
toklen		token length
targetstack	space for 8 addresses to resolve branches to
tokenbuffer	(P --- &token ) where we stash an input token
tsi		counter for branches to resolve
USize		(P --- @USize ) offstack Size store for interpreter
#  	THREADS...
&		( a --- )  !dp	 `append' a into dictionary at &dp at Size
&literal	`append literal'  ( # --- )   !dp
&$ 		"&$ string!%(!^$ "  append string literal to dict. */ 
&word		(P &HNC ||| ) assemble/append a word token
&pliteral	thread-time -> "&pliteral lit# " THREADING
&p		(P bla |||  )	append pointer bla to dictionary  !dp
allot		( o/s --- )  move dp up o/s bytes. iffy at > 256
asciinybble	( --- nybble )	(P char	 ||| )
?hexnumber	( --- flag )  @'s toklen and tb
?file		STUB ( --- flag ) "iffile  token "
?threader	(P &HNC |||) ( --- flag ) true if threader word
?pending	(--- flag) true if not finished refill	  @this @epa
?$=		(P beg.	 beg. ||| --- ) ( len ||| --- flag ) are memory segments =?
?byte$=		(P beg.	 beg. |||) (len ||| --- flag)255 max len
?char		(p; str --- )  ( --- flag )  true if byte > 32
?word		(P ---	HNC|null) ( --- flag )
beep		emit a 7, ASCII `BEL', C \a		
blank		emit a blank character, 0x20, a space
:		": ccc H3sm.. ; " name/link ccc, set target 0, start threader
cr		emit a (unix) newline
dofile		STUB
dump		(P start --- end ) hexdump 256 bytes, continuable
dumpline	(P a --- a+16 )	 display 16 bytes from a
dpdump		(P --- dp+0xc0 )   dump from dp - 0x80
delimit		(P dest |||) ( delimiter --- count did ) stash input
drowod		(P HNC --- ???) (???)  (R ?????) !USize	 Interpreter only
ell		assemble/append an unconditional branch
finish		( --- EOI) !toklen !tb !this	get rest of token
<-code		`fromcode' (P CFA --- HNC )  ( --- found_flag )
H3m		no-op thread, simplifies commandline handling
hexnumber	( --- # )  from current token
hide 		(P &HNC ||| )  ( toggle hide bit )
ifabbreviation	(P --- HNC|NULL)  ( --- flag ) "'abbreviation toke. "
ifhex		( --- flag ) (P char ||| )
include 	"incl. relative_pathname "
input		( FD --- ) interpret input on FD til exhausted
interpret	interpret one token. Unknown stack effects. EVAL basically.
initresolve	init branch resolver stacks
link		!dp   !latest	  link a word to the dictionary
name		"name newname "	   part of :
negate		( bla --- 2's-complement-negative-bla)
no		assemble/append a branch-on-false conditional
open		( flags perms --- FD|err)  "open  filename " @!tb
( 		"(  whatever      ) "  comment. Use # in defs
\ 		"#  whatever  nl"  one-line comment. works in : ;
postpone 	"postpone bla " child will append CFA (and sub) of bla
p2dup		(P a b ||| --- a b ) dup 2 pointers in-phase
p2+s		(P  ptr	 ptr  --- ptr+s	 ptr+s )
#		see x for Forth "." until H3sm gets BASE
.p		print pointer  non-destructively
.r		print TOR nondestructively
.string		(P begin  ||| ) ( length --- ) print a string
.$ 		(P $+c ||| )    print a $egment
.chars		(P begin  ||| ) ( length --- ) prt 126 > chars > 32
.name		(P   &HNC ||| )	print a word's H3m name
resolve_one	resolve one branch in thread being threaded
refill		( --- got ) @source !this !epa !buffer   more input
resolve		(--- true) @bs @ts, thread all pending branches THREADer
rebmunxeh	(  --- #_in_user_data_stack_context ) The Dreaded Rebmunxeh.
;		( --- stop_THREADer) set a target, resolve, & a return.
spaces		( N --- )  emit N spaces
step		( --- EOI) true if End Of Input on this
snug		( --- EOI) eat whitespace. snug+finish=token. Buffered.
this		( --- current_input_buffer_byte ) interpreter part.
threader	(P HNC |||) toggle word's THREDING bit. IMMEDIATE analogue
token		( --- End_Of_Input ) ?!tb !this
to:		( --- keep_THREADer) set branch to resolve to start of word
to1		( --- keep_THREADing) set branch to first (O) to resolve
to2		( --- keep_THReding) set branch to second (O) to resolve
to3		( --- keep_THREDING) as above, reserve a cell
to4		( --- keep_THREDING) as above. Max (O) + 1 is at ;
to5		( --- keep_THREDING) as above. Max (O) + 1 is at ;
tab		emit a tab, ASCII 9
(O)		`target' ( --- keep_THREaDING) set a branch target 
threadtoken	( --- keep_going? )  called after "token"
threadloop	called by : . Build the body of a thread. Stops after ;.	
'		`tick'
'&		"'& word "  HNCword -> dictionary   !dp	THREDING
'&code		"'&code  word " CFAword->dictionary !dp	 THREDING
'p&		"'p& word " thread does ->  (P --- HNCword ) !dp THREDING
->C		(P --- tb ) "->C string " 0-terminate a token
words		( cnt --- ) print cnt wordnames from latest
yes		assemble/append a branch-on-true conditional
0-terminate	() 	C-ify a token in tb.  !tb
yes			assemble/append a branch-on-true 
zygote		top endless loop, do argv[], do rcfile,  
#
glossary may include THREAD_ words "words" hides.
H3m is case-sensitive. Booleans OR, AND, XOR and NOT are uppercase.
H3m abbreviation/pronounciation  conventions ...
	?      @	!	->	.	&	'	$
	ask    fetch	store	to	print	append	tick	segment
& (append) is to Forth `comma' as assemble is to compile.
(is usually a copy, -> is usually a move or pop, source is dropped.
& in stack comments, e.g. @HNC, sometimes means "address of"
||| means "stuff to the left is required but not changed".
?* words like ?char etc. (and flag) produce flagpytes.
format		(optional fields, optional order
name		`pronounced'  stacks effects  "parsing syntax"  notes
