1.4
 glossary may include NON_USER words "words" hides.			
 H3m is case-sensitive. Booleans OR, AND, XOR and NOT are uppercase.	
 H3m abbreviation/pronounciation  conventions:			
 
	@	!	->	.	&	'	$		
	fetch	store	to	print	append	tick	segment		
 
 & (append) is analagous to Forth `comma'.				
 @ 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".		
 if* words like if, ifchar etc. produce flagpytes.			
 format		(optional fields, optional order)		
 name		`pronounced'   stacks effects	 "parsing syntax"   other  
 
	ATOMS... 
 address	(P --- ptr ) !rsi  action of named data, Forth VARIABLE 
 AND		( pytea pyteb ---  aANDb ) the bitwise Boolean		
 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		1 -> Size		
 bbytesd	bump 1->Size drop      
 bcellsd	bump sizeof(int)->Size drop	 
 cells		sizeof(int) -> Size		
 drop		( pyte --- )			
 dup		( pytea ||| ---	 pytea )  i.e.	  ( a --- a a )	   
 downshift	( shiftee amount --- shifted ) down-significance bitshift
 double		up-roll Size by 1, > 256 wraps	
 doHNC		(P &HNC	 --- ) (R; --- RET|null) execute word given &HNC 
 emit		(pyte --- )  ascii print lsB. not buffered.    
 ell		unconditional branch to address in next thread cell 
 false		( --- 0flagpyte )  fast false lsB  
 @		(P ptr ||| --- ) ( --- pyte ) fetch pyte at ptr at Size 
 @+		(P ptr --- ptr+Size ) ( --- pyte )		 
 getSize	(P --- Size )	 
 gap		(P a b ||| ) ( --- a-b ) bytes between addresses 
 halve		down-roll Size by 1 bit, i.e. Size=Size/2 usually
 H3sm		no-op. No action besides increment VM instruction pointer 
 if		( pyte --- flagpyte ) OR pyte into lsB, make it a flag 
 ifcontents=	(P &a &b ||| ) ( ---  flag ) compare pointed-to pytes	
 if=		( a b --- flagpyte ) 0xXX..ff (true) if a = b  
 ifpositive	( a  --- flagpyte )  0 considered positive  
 ip+		( ip_index --- ) execution-array mechanism, computed goto 
 literal	( --- pyte )  in-thread literal pyte number to ds
 max		( a b --- maxab ) Min's hubby.			
 min		( a b --- min_ab) Max's better half.		
 maskbyte	( a --- a&0x00...00ff ) mask off all but lsB   
 move		(P from to |||) (cnt ---)  move cnt bytes, overlaps are OK.
 -?r		( --- flagpyte )  (R c --- c-1) is TOR nonzero before decrement?
 NOT		( pyte --- !pyte )   bitwise NOT of all bits	
 negate		( a --- 2's_complement_negative_a )	
 no		( flagpyte --- ) branch to address in ip (the next cell) if 0  
 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 --- pyteaORb ) bitwise Booolean OR    
 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 by Size	
 p+1		(P a --- a+1 )	index a pointer by one		
 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		(P ptr --- ptr+1 ) decrement a pointer			
 p->		(P a --- ) ( --- a_low[a_hi] ) if (Size > cellsize) then 0-pad	
 p->r		(P a --- ) (R; --- a ) 
 p->S		(P Size --- )  !Size   superceeded?	
 p!		`pea store' (P p  store	 |||  ) p goes in store, no pdrops  
 pswap		(P a b --- b a )	
 pup		(P ---	oldptr )		       
 return		(R; xt	--- )  VMST rts to calling thread   
 rdrop		(R; a --- ) 
 rpcopy		(R; a ||| ) (P --- a ) dup r to p   
 <-r		(R; val --- ) ( --- 0000val )  4 live bytes written to ds  
 r->p		(R; ptr --- ) (P --- ptr ) symmetrical with p->r. 
 r->s		(R; size --- )	!SIZE 
 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 
 sub		(R; --- ip+ ) ip!   go subthread, other uses. Essence of VMST	
 ->r		(R; --- val ) ( val --- ) Forth >r, ish. 4 bytes moved. 
 ->code		(P &HNC --- Code_Body_Cell ) 
 ->link		(P &HNC --- Link_Cell ) 
 ->p		(P --- CELL ) ( a --- ) CELLSIZE worth of a is moved  
 true		( --- true_flagpyte ) 0xXXX...XXff, true flag pyte constant  
 2pdrop		(P  A B --- )  drop 2 pointers. 
 upshift	( shiftee amount ---  up-shifted-lo [up-shifted-high] ) 
 x		( pyte --- ) print & drop a pyte, Forth . but hex only	  
 XOR		( pytea pyteb --- pyteaXORb )		
 yes		( flagpyte --- )  branch if lsB of TOS is true	
 zero		( --- 0 )   0 as a fast pyte-constant  
 
	SYSCALLS ...
 Sbecome	(P  path argv envp ||| ) ( --- GONE|fail=-1) unix execve  
 close		( FD --- ret )	lose and release a file descriptor 
 Schroot	(P  path |||) ( --- ret) change apparent root directory 
 dupFD		(old_FD --- new_FID|-1)	  unix dup()	
 dirents	( FD  count --- red|-1|0 )  (P	buff ||| ) unix getdents()  
 FDcontrol	( FD CMD  --- ret )  (P [arg] |||)  unix fcntl()
 fork		parent.. ( ---PID_of_child_or-1)	child.. (--- 0)
 fflush		( FD --- flag )	 unix fsync()		
 flush		( --- 0 )	unix sync()	
 Sgettimeofday	(P timeval |||) ( --- flag)  simplified 
 link		(P  old new ||| )   ( --- flag )   unix link()	
 ioctl		( FD  ioctl --- ret) (P	 argp --- ) note the pdrop 
 ioperm		( level --- flag )	Linux iopl()	
 makedir	(P name ||| )	( --- flag)	unix mkdir(), perms==0	
 mount		(P special dir fstype|NULL data |||) (rwflags --- flag) 
 nanosleep	(P  timespec remaining ||| )	( --- flag )  
 owner		(P path |||)   ( UID  GID --- ret)  unix chown() 
 permit		(P path |||)   ( mode --- ret)	 unix chmod()	
 pause		( --- -1 )	wait for a signal 
 pipe		(P ptr_to_int[2] |||)  ( --- flag) 2 FD's in given array 
 parent		( --- parent_PID )	unix getppid()		
 quit		unix exit(), Forth bye, H3m quit. q. works. 
 read		( FD --- red ) (P buf ||| )  always requests 2048 bytes	 
 rename		(P old new |||) ( --- flag ) basis of mv     
 resize		(P end_data_segment ) ( --- ret )   unix brk(), basis of malloc 
 reboot		(P btparm --*POW!!* REBOOT LINUX. With EXTREME prejudice. 
 sys_open	(P name |||)  ( flags perms --- FD ) see open thread  
 todir		(P path --- ) (--- ret)	 unix chdir(), cd  
 rmdir		(P name ||| )	( --- flag )  remove empty dir	
 readlink	(P name buff ||| ) ( bufsize --- flag )	 unix readlink	
 stat		(P name buff ||| ) ( --- flag)	get a file's stat data 
 seek		( FD o/s whence --- o/s0 ) unix lseek(), Forth reposition-file 
 settimeofday	(P timeval |||) ( --- flag)   simplified	
 sigaction	( sig# --- flag ) (P action old |||) install a signal handler 
 socketcall	( call --- flag )  (P args ||| )  Linux socket calls entry 
 statfs		(P name buff ||| ) ( --- flag)	get a filesys stat data 
 settime	(P timestruct ||| )   ( --- flag) set sec. elapsed in epoch 
 swapoff	(P name ||| )	( --- flag )	
 swapon		(P name ||| )	( --- flag )	
 special	(P name |||)	( mode dev --- flag )	unix mknod()	
 signal		( PID signal --- ret)	unix kill	
 symlink	(P exists new |||)  ( --- flag )	
 syslog		( type	len --- flag )	(P buf ||| ) read/tweak kbuffer 
 truncate	(P fname || )  ( len --- flag ) truncate fname to len  
 trace		( request PID addr data --- flag)  unix ptrace() 
 unlink		(P name ||| ) ( --- flag) rm a name, maybe the data
 unmount	(P name ||| )	( --- flag) unix umount() 
 write		( FDbyte  request --- red )   (P name ||| )  
 waitpid	(pid options --- ret )	simplified	
 
	NAMED DATA... 
 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 ) 
 epa		(P --- &epa )  End Parse Area		
 hexdigits	(P  ---	 &array )  ascii val is/not a hex digit	  
 latest		(P --- &HNC )  &HNC of most recent definition  
 pvar		(P --- &pvar)	scratch pointer for thread resolver  
 source		(P --- &input_FD) FD of source of interpreter input 
 thispointer	(P --- &this ) current address in buffered parse area	
 toklen		token length	
 targetstack	space for 8 addresses to resolve branches to 
 tb		(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  
 &word		(P &HNC ||| )  append a word's CFA.   
 &pliteral	thread-time -> "&pliteral lit# " THREADING	 
 &p		(P bla |||  )	append pointer bla to dictionary  !dp	
 abs		( A --- |A| )			
 allot		( o/s --- )  move dp up o/s bytes. iffy at > 256
 ascii->digit	( --- nybble )	(P char	 ||| )	  
 beep		emit a 7, ASCII `bel', C \a		
 bench		bogoloop, 100,000 empty loop iterations.  
 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
 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			
 ifchar		(p; str --- )  ( --- flag )  true if byte > 32	
 ifword		(P ---	HNC|null) ( --- flag )	
 ifabbreviation	(P --- HNC|NULL)  ( --- flag ) "'abbreviation toke. "
 ifatom		(P &HNC |||)   ( --- flag ) true if HNC is an atom 
 ifhexnumber	( --- flag )  @'s toklen and tb 
 iffile		STUB ( --- flag ) "iffile  token "	
 ifthreader	(P &HNC |||) ( --- flag ) true if threader word 
 ifpending	(--- flag) true if not finished refill	  @this @epa	
 if$=		(P beg.	 beg. ||| --- ) ( len ||| --- flag ) are memory segments =? 
 ifbyte$=	(P beg.	 beg. ||| --- ) ( len ||| --- flag )  255 max len 
 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 
 -		( a b ---  a-b )  minus		
 name		"name newname "	   part of :			
 open		( flags perms --- FD|err )  "open  filename " @!tb	
 postpone 	"postpone bla " CFA of bla will be appended by child 
 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	
 .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   buffered 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. 
 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 ;
 tab		emit a tab, ASCII 9		
 (O)		`target' ( --- keep_THREDING) set branch target 1 2 3 or 4
 threadtoken	( --- keep_going? )  called after "token"	
 threadloop	called by :. Build the body of a thread. Stops after ;.	
 '		(P --- HNC|null)  (--- flag) "' wordname "  Forth `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-term. str. in situ 
 words		( cnt --- ) print cnt wordnames from latest 
 0-terminate	() 	C-ify a token in tb.  !tb	
 zygote		top endless loop, do argv[], then loop over input 
