by [ name | topic | voc ] [ glos | files | xref ] [ notation | dpans94 | syscalls ] [ bot | top ]
Text formatted for the lynx html-browser and for plain text printing, 132 chars/line|
Name Asm-Label Wordlist Comment (imed)
<> nequal ans ( n1 n2 -- f ) ff if @tos = @nos -> tov ans -re- {to} for "pforth" (etc) ' atick ans fetch xec token ix by name ['] tick ans cpl xec token ix fetched by name +> pltov ans -re- {to} for "pforth" (etc) [0=] izeq ans immediate flag inversion, {0=} 0<> zneq ans ( n -- f ) tf if non-zero sing 2! twostoa ans ( d p -- ) sto double to mem, BIG ENDIAN (ANS!) 2/ shr2 ans signed shift sing right by one 2@ twofetcha ans ( p -- d ) fetch double, BIG ENDIAN (ANS!) 2literal adliteral ans cpl ANS mode (big endian) double literal 2>R ator2 ans ( n1 n2 -- )(R -- n1 n2 ) push to r-stack, BIG ENDIAN 2R> arfrom2 ans (R d -- )( -- d ) pop double from rstack,BIG ENDIAN 2R@ ar2f ans (R d -- d )( -- d ) copy double from rstack, BIG ENDIAN abits mul8 ans mul by no. of bits per address unit ABS aabs ans two-s cpl if sing -ve, '-0' unchanged anew marker ans {marker}, for 'common useage' compatibility... a-number anumber ans convert stg to number - ANS-mode CASE case ans begin a CASE decision sequence CELL/ cellby ans floored div sing by bytes per cell (4) CELLS mul4 ans mul sing by bytes per cell (4) CHAR char ans cpl character value literal [CHAR] char ans compile character value literal close-dir closef ans close a directory-file ;CODE scode ans terminate colon defn, continue 'lo level' CONVERT converta ans convert stg to number - ANS-mode COUNT count ans ( p1 -- p2 u ) chars(bytes?) count of a counted string D<> dneq ans tf if doubles not equal D0<> dzneq ans ff if double @tos is zero DEFAULT noop ans last alternative in CASE sequence - a noop [DEFINED] defined ans re {defined} DFALIGN dfalign ans ( -- ) 12.6.2.1205 12.6.2.1205 DFALIGNED dfaligned ans ( p1 -- p2 ) 12.6.2.1207 12.6.2.1207 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 ?DUP qdup ans ( n -- n n | 0 ) dup if dup endif ; {-dup} ENDCASE endcase ans terminate CASE sequence ENDOF endof ans terminate OF-part in CASE sequence FALIGN falign ans ( -- ) 12.6.1.1479 12.6.1.1479 FALIGNED faligned ans ( p1 -- p2 ) 12.6.1.1483 12.6.1.1483 [FALSE] zero ans immediate cons 0 FILE-STATUS afstatf ans file state by name -re- linux {file-status} FLOAT float ans ans-voc, real numbers 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 GET-ORDER gorder ans content + count of voc-stack (LOCAL) plocalp ans local wordheader by supplied stg ?ms qms ans time in milli-seconds since host startup ?NEGATE spm ans ( n1 n2 -- n3 ) apply sign of sing n2 to sing n1 NIP sdrop ans ( n1 n2 -- n2 ) ; swap drop NUMBER anumber ans convert stg to double - ANS-mode OF of ans begin true decision part in a CASE sequence POSTPONE bcb ans delay execution RP! arpstore ans ( p -- )(R -- ) rst returnstack-ptr to ptr S>D s2dn ans signed sing to double SEARCH-WORDLIST swlist ans find a name in given wordlist 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 SP! aspstore ans ( p -- ) set datastack-ptr to kref'd supplied value THEN endif ans terminate IF/ELSE sequence [TRUE] true ans immediate cons -1 TUCK sover ans ( n1 n2 -- n2 n1 n2 ) ; swap over U>D u2dn ans sing to unsigned double UNLOOP unloop ans at runtime discard loop control data WHILE whilea ans if @tos = 0 leave BEGIN structure WORDLIST? wordlq ans item no of stacked wordlist by wid, or -1 WRITE-FILE awritefile ans write no. of bytes from buffer to file, ans-mode 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 * } 16*+ mp16 assembler ( n -- n ) { 16 * + } asm-hidden asmhidden assembler root-voc, native code cpl. words <call> lcallg assembler x86 op-code, call pc-rel (;code) pscodep assembler runtime for 'does>' (;code@) pscodefp assembler runtime for '@does>' 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 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) (n.) pndotp bignum convert signed counted int to stg n^ npow bignum ( n.N m -- p.P ) n.N to the power of m n<# nlth bignum prepare counted int stg conversion n= neq bignum signed compare two bignums n- nsub bignum normalize & subtract two bignums n-> ntoq bignum signed reduce bignum to minimal cell size n! nstore bignum store counted integer n!+ nstorep bignum store counted int, leave advanced ptr n/ nby bignum signed divide two counted ints n. ndot bignum send numeric bignum stg to stdout n@ nfetch bignum fetch counted integer n@+ nfetchp bignum fetch counted int, leave advanced ptr n* nmul bignum multiply two counted ints 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+ nadd bignum normalize & add two bignums n+- npm bignum apply sign of sing to bignum ?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 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 n2dup nn2dup bignum dup double counted int nabs nabs bignum abs value of counted int ncmp ncmp bignum ret sign of subtraction of two bignums ?ncmp qncmp bignum non-destr. ret sgn(diff of two counted ints) ndrop ndrop bignum drop counted int ngcd ngcd bignum ret greatest common divisor of two bignums ninteger ninteger bignum counted int alterable constant ninvert ninvert bignum 1's cpl counted int nliteral nliteral bignum cpl multi-cell literal nlshift nlshift bignum shift left counted int n#max nhmax bignum max size for counted int to stg 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 nn->dd n22d bignum bignum pair to data nndrop nndrop bignum drop a number of counted ints nndup nndup bignum dup counted int nnegate nminus bignum negate counted int nnorm nnorm bignum normalize top two bignums to equal size 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 nnumber nnumber bignum convert stg to counted int n>number ntonumber bignum convert stg to bignum until invalid char n->q n2q bignum bignum to quad nrshift nrshift bignum ( n1.N n2 -- n2.M ) shift right counted int n#s nhs bignum convert bignum to numeric chars nsgn nsgn bignum ( n1.N -- n2 ) signum of a counted int nshift nshift bignum ( n1.N n2 -- n3.N ) shift bignum +n2 left, -n2 right n#size nhsize bignum memory requirement for num to stg conversion nsqrt nsqrt bignum ( n1 -- n2.N ) square root of a counted int n-top pdovar bignum memtop for bignum to stg conversion n->un n2un bignum modify bignum to unsigned q->n q2n bignum ( q1 -- n1.N ) quad to bignum s>nfactorial s2nfac bignum ( n1 -- n2.N ) counted int factorial of a sing (un.) pundotp bignum convert unsigned counted int to stg un. undot bignum ( .n1.N -- ) send unsigned numeric bignum stg to stdout 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 un->un untoun bignum ( n1.N M -- n2.M ) unsigned extend counted int blk>buf blk2buf blkfile ptr to screenfile buffer by blk# blk>head blk2head blkfile ptr to header of screenfile block by blk# blkhead-size pdoval blkfile size of a per screenfile block header blk>lnk blk2lnk blkfile ptr to buffer-block by block-no. block-lk pdovar blkfile base link of screenfile storage blocks (boot) pdovar blkfile dft -re- {l-load} library file buf>blk buf2blk blkfile block no. assigned to a screenfile buffer buf>head buf2head blkfile ptr to header of screenfile block by ptr bufhead-size pdoval blkfile size of a (kernel-)block buffer header 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 editting eding blkfile modify screenfile access to r/w empty-blk emblk blkfile invalidate a single blockfile buffer [first] pdoval blkfile bot. of 1st block buffer, 0 if unassigned 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] pdoval blkfile top+1 of last block buffer, 0 if unassigned 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. nextbuf nextbuf blkfile {+buf} wrt by -re- {source-id} used blocks [prev] pdoval blkfile ptr to most recently used block buffer reading rding blkfile modify screenfile access to r/o 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 } scrfpos scrfpos blkfile scr-chan file-ptr at scr@+r#@ update? updateq blkfile flag whether blk -re- {update}d update-off updateoff blkfile clear screenfile buffer update flag [use] pdoval blkfile ptr to block buffer to use next [;] bsemib compiler return address adjustmt, -re- {;r} runtime [:] bcolonb compiler code-space adjustmt for safe return, by {:r} [[ llbrac compiler dec cpl nesting level by two, interpret if < 1 ]] rrbrac compiler enter structure compiling state asciz hasciz compiler cpl next stg in asciz-mode call, c_call compiler ( -- ) call dword disp call-by-disp cbdisp compiler cpl relative calls by disp call-by-uot cbuot compiler cpl indirect call by address in uot casedep casedep compiler set latest word to case-dependent find mode cdepth cdepth compiler depth of compile-stack doubles cmac hcmac compiler h-flg, enable macroes cpl cmc? cmcq compiler state of optimizing token counter (cp) uprevcp compiler by {compile,} previously used code-ptr [debug] bdebugb compiler default (debug) opr dlit, c_dlit compiler ( d -- ) cpl double literal dodoes, c_dds compiler ( -- ) cpl dodoes, pfa to be patched to start+2 end-macro cendmacro compiler terminate macro code-expansion cpl flg>head flg2head compiler ( n ix -- n ) set/clr header flag flit, c_flit compiler ( f -- ) cpl double precision f.p. literal (n.i.) imed himed compiler h-flg, xec immediately imed? imedq compiler tf if word (by lfa) is immediate inif hinif compiler h-flg, init from header fields at system startup [interpret] binterpretb compiler default (interpret) opr ]interpret binter compiler xec (]interpret) interpret[ interb compiler xec (interpret[) 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 litp, c_litp compiler ( n -- ) cpl single literal, add eax,dword n locp, c_locp compiler ( n -- ) cpl ptr to a local "value", locrmv locrmv compiler intermediate local values de-allocation 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 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" 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 smud hsmud compiler h-flg, sumudged ("find" disabled) 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" tospull, c_tospull compiler ( -- ) TOSPULL(1), dec PS by one cell tospush, c_tospush compiler ( -- ) TOSPUSH(1), inc PS by one cell 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 1line e1line editor find in curs-line B eB editor backup by text len in pad b/c bbyc editor bytes per character (8) C eC editor indsert text CLEAR clear editor fill screen w/ blanks 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 [edit] beditb editor {edit} default opr. F eF editor find text [f] bfb editor -find w/ forth voc preferrence FIND efind editor find stg at pad in screen H eH editor copy line to pad 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 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 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 r#@ rnf editor { r# @ } get cursor count readm-c/l readmcl editor ( p u -- p' u' p1 u1 ) c/l chars(=bytes) from mem #rmg pdoval editor editor screen & printing, right margin S eSe editor ins empty line scr! scrs editor { scr ! } sto screen no. scr@ scrf editor { scr @ } fetch screen no. T eT editor type and copy line to pad text text editor fetch by char delimited text to pad -text mtext editor find text in stg TILL till editor erase till text end TOP etop editor cursor to top left TRUNCATE truncate editor set size of screenfile X eX editor delete text Y eY editor insert stg ADDRESS-UNIT-BITS aub environment consecutive bits per address unit BLOCK bcore environment wordset availabilty flag BLOCK-EXT bcorex environment wordset availabilty flag 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 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 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 2! twosto fig ( d p -- ) sto double to mem 2@ twofetch fig ( p -- d ) fetch double 2not dnot fig ( d1 -- d2 ) one-s complement a double blanks blanks fig ( p +u -- ) fill memory w. blanks b/scr bbyscr fig buffer blocks per screen(1) +buf plusbuf fig next buffer c/l cbyl fig chars per line (64) convert convert fig convert stg to number - f.i.g.-mode dminus dnegate fig ( d1 -- d2 ) negate a double editor editor fig fig-forth-voc, editting enclose enclose fig isolate a word from tib -?- first first fig bot. of 1st block buffer, 0 if unassigned f-number fnumber fig convert stg to double - f.i.g-mode in xin fig parsed terminal input count leave xleave fig unconditionally leave DO-loop at next LOOP -leave dleave fig LEAVE if @tos =/= 0 limit limit fig top+1 of last block buffer, 0 if unassigned minus negate fig ( n1 -- n2 ) negate sing number fnumber fig convert stg to double - f.i.g-mode [number] bnumberb fig f.i.g. mode stg to number conversion offset pdoval fig block disp by multiple of -re- {b/scr} (1) prev prev fig screenfile blockbuffer currently in use sign sign fig fig-variant, sign cell 3rd from tos smudge smudge fig toggle find-ability of latest word sp! fspstore fig ( -- .xx. ) rst datastack-ptr from uvari {r0} toggle toggle fig ( p c -- ) xor byte in memory - fig, reversed opr true pone fig cons 1 true= ftequ fig ( n -- f ) tf if cell is f.i.g.-mode 'true' value use use fig least recently used screenfile blockbuffer word xword fig fetch text enclosed by supplied char to {here} DEG>RAD deg2rad float ( f1 -- f2 ) convert degrees to radians D>F dtof float ( d1 -- f2 ) 12.6.1.1130 12.6.1.1130 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 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" 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 ) END fend float ( -- ) terminate FOR-loop at next NEXT 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. fdot float ( f1 -- ) 12.6.2.1427 12.6.2.1427 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 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 FE. fedot float n.i. - 12.6.2.1513 12.6.2.1513 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-op floatop float {FLOAT}-subvoc w. un-praefixed names 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 float ( f1 -- ) begin FOR .. NEXT loop, set range 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 float ( f1 -- ) set FOR-loop start +FROM pfrom float ( f1 -- ) modify FOR-loop start & limit by disp f1 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 FS. fsdot float n.i. - 12.6.2.1613 12.6.2.1613 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 float ( -- f1 ) innermost FOR-loop index !IDX sidx float ( 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 float ( -- f1 ) FOR-loop increment !INC sinc float ( f1 -- ) store FOR-loop increment LIM flim float ( -- f1 ) FOR-loop limit NEXT next float ( -- ) terminate a FOR-loop NX nx float ( n -- f1 ) n-th level FOR-loop index @NX fnx float ( -- p ) ptr to n-th level FOR-loop ctrl data 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 REPRESENT frepresent float ( f1 p u -- n1 flg1 flg2 ) 12.6.1.2143 12.6.1.2143 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 STEP step float ( f1 -- ) set FOR-loop increment ^ 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 . fdot floatop ( f1 -- ) 12.6.2.1427 12.6.2.1427 @ 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! dfstore floatop ( f1 p -- ) 12.6.2.1203 12.6.2.1203 2/ f2by floatop ( f1 f2 -- f3 ) div by two 2@ dffetch floatop ( p -- df1 ) 12.6.2.1204 12.6.2.1204 2* f2mul floatop ( f1 f2 -- f3 ) mul by two 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 ) 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 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 DEPTH fdepth floatop ( -- n ) 12.6.1.1497 12.6.1.1497 DROP fdrop floatop ( f1 -- ) 12.6.1.1500 12.6.1.1500 D>S dftof floatop ( df1 -- f2 ) 12.6.1.1130 12.6.1.1130 DUP fdup floatop ( f1 -- f1 f1 ) 12.6.1.1510 12.6.1.1510 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 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 OVER fover floatop ( f1 f2 -- f1 f2 f1 ) 12.6.1.1600 12.6.1.1600 PICK fpick floatop ( f1... n1 -- f1 ) +/- pick float RANDOM frandom floatop ( f1 -- f2 ) random number in range [0,f1) 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 S>D ftodf floatop ( f1 -- df2 ) convert float to double size 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 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 ^ pow forth ( n1 n2 -- d ) double, sing to the power of sing < less forth ( n1 n2 -- f ) tf if @tos smaller than @nos <# ltsharp forth begin number to stg conversion = equal forth ( n1 n2 -- f ) tf if @tos = @nos =: valdef forth store integer to known or create new {value} =/= nequal forth ( n1 n2 -- f ) ff if @tos = @nos > greater forth ( n1 n2 -- f ) tf if @tos greater than @nos >< 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 >/ nlt forth ( n1 n2 -- f ) tf if @tos greater than @nos - ssub forth ( n1 n2 -- n3 ) subtract sings , comma forth compile sing (4 bytes) to data-space ; semi forth terminate colon defn, clr locals, check : colon forth begin a 'colon definition' ! 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 ? ques forth ( p - ) display numeric content of cell at ptr / by forth ( n1 n2 -- n3q ) div sings, leave quot . dot forth ( n -- ) display signed sing ." dotquote forth display string ' tick forth fetch xec token ix by name as a literal " qte forth cpl stg, ret ptr to stg [-->] bnxldb forth dft for {load} or, for immediate xec ] rbrac forth enter cpl state, inc nesting level by one { loccb forth cpl locals list, un-/initiated & comment @ 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) $. hexdot forth ( u -- ) sedecimal display unsigned sing * smul forth ( n1 n2 -- n3 ) mul sings */ mulby forth ( n1 n2 n3 -- n5q ) n1 / n2 * n3, qot n4 &. octdot forth ( u -- ) octal display unsigned sing # sharp forth extract l.s. digit char from a double #> sharpgt forth terminate number to stg conversion #. decdot forth ( u -- ) decimal display unsigned sing %. bindot forth ( u -- ) binary display unsigned sing + plus forth ( n1 n2 -- n3 ) add sings +- spm forth ( n1 n2 -- n3 ) apply sign of sing @tos to sing +! plsto forth ( n p -- ) add sing to cell in memory -0 mzero forth cons $80000000 -0= mzeq forth tf if only sign-bit set -0. dmzero forth dcons "-ve zero", 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= 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 0. dzero forth dcons zero \< ngt forth ( n1 n2 -- f ) tf if @tos smaller than @nos 0drop zdrop forth -dup drop ; discard zero cell @tos -0exit dzexit forth if ff leave current word 0max zmax forth 0 max ; not less than 0 -1. dmone forth dcons -1 (1-) b1mb forth ( p -- ) sub 1 from cell at ptr (1+) b1pb forth ( p -- ) add 1 to cell at ptr 1- sub1 forth dec sing by one 1, cpl1 forth compile byte to c-here 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 1/string s1string forth adjust stg parameters by 1 2^ pow2 forth ( n1 -- d1 ) 2^n sing -> double 2- sub2 forth dec sing by two 2, cpl2 forth compile l.s. half sing (2 bytes) to c-here 2! twosto forth ( d p -- ) sto double to mem 2!! twoxsto forth ( p1 p2 -- ) xchange doubles in memory 2/ div2 forth div sing by two 2@ twofetch forth ( p -- d ) fetch double 2@! twofsto forth ( p1 p2 -- ) copy double from/to memory 2* mul2 forth mul sing by two 2+ add2 forth inc sing by two 2+! twoplsto forth ( d p -- ) add double to double in memory 2and and2 forth ( d1 d2 -- d3 ) bitwise AND doubles 2constant twocons forth define non-alterable double constant 2drop drop2 forth ( d -- ) drop two cells 2dropd dropd2 forth ( d1 d2 -- d1 d1 ) ; 2drop 2dup 2dup dup2 forth ( d -- d d ) duplicate double 2integer integer2 forth immediately compiled double cons 2invert dnot forth ( d1 -- d2 ) bitwise complement a double 2literal dliteral forth cpl double literal 2lshift dlshift forth ( d1 n -- d2 ) shift left a double 2or or2 forth ( d1 d2 -- d3 ) bitwise OR doubles 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 2r r2 forth (R d -- d )( -- d ) double from return-stack 2>r tor2 forth ( n1 n2 -- )(R -- n2 n1 ) push double to return-stack 2r> rfrom2 forth (R d -- )( -- d ) pop double from return-stack 2r>>2r r2xchg forth ( d1 -- d2 )(R d2 -- d1 ) ; 2r> 2swap 2>r 2rdrop rdrop2 forth (R dn -- ) ; 2r> 2drop 2roll roll2 forth ( .dd. n -- .. dn ) roll doubles 2rot rot2 forth ( d1 d2 d3 -- d2 d3 d1 ) roll by 2 2-rot mrot2 forth ( d1 d2 d3 -- d3 d1 d2 ) ; 2rot 2rot 2rotd rotd2 forth ( d1 d2 d3 -- d2 d3 ) ; 2rot 2drop 2rots rots2 forth ( d1 d2 d3 -- d3 d2 d1 ) ; 2rot 2swap 2>rr torr2 forth ( d -- )(R -- d ) copy double to return-stack 2rshift drshift forth ( d1 n -- d2 ) shift right a double 2rshifta drshifta forth ( d1 n -- d2 ) sign preserving shift right a double 2rswap rswap2 forth (R d1 d2 -- d2 d1 ) ; 2r> 2r> 2swap 2>r 2>r 2sdrop sdrop2 forth ( d1 d2 -- d2 ) ; 2swap 2drop 2sdup sdup2 forth ( d1 d2 -- d2 d1 d1 ) ; 2swap 2dup 2sover sover2 forth ( d1 d2 -- d2 d1 d2 ) ; 2swap 2over 2srot srot2 forth ( d1 d2 d3 -- d3 d2 d1 ) ; 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 2to to2 forth store to alterable double cons 2value value2 forth double alterable 'constant' 2variable twovari forth (un)initiated double variable 2xor xor2 forth ( d1 d2 -- d3 ) bitwise XOR doubles 3* mul3 forth mul sing by three 3drop drop3 forth ( n1 n2 n3 -- ) ; 2drop drop 3dup dup3 forth ( d1 n1 -- d1 n1 d1 n1 ) ; dup 2over rot 4- sub4 forth dec sing by four 4, cpl4 forth compile sing (4 bytes) to c-here 4! store4 forth ( q1 p -- ) sto quad to memory 4!! qxsto forth ( p1 p2 -- ) xchange quads in memory 4/ div4 forth div sing by four 4@ fetch4 forth ( p -- q1 ) fetch quad from memory 4* mul4 forth mul sing by four 4+ add4 forth inc sing by four 4constant qconstant forth define non-alterable quad constant 4drop drop4 forth ( q1 -- ) drop 4 cells 4dup dup4 forth ( q1 -- q1 q1 ) duplicate quad @tos -4dup qdup4 forth ( q1 -- q1 q1 | q0 ) 4dup @tos if non-zero 4integer integer4 forth immediately compiled quad cons 4literal qliteral forth cpl quad literal 4not not4 forth ( q1 -- q2 ) bitwise complement top 4 cells 4over over4 forth ( q1 q2 -- q1 q2 q1 ) push quad @nos to tos 4pick pick4 forth ( qx..qn..q0 n -- qx..qn..q0 qn) +/- pick quad 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 4roll roll4 forth ( qn .. q1 n -- .. q1 qn | q1 qn .. ) +/- roll quads 4rot rot4 forth ( q1 q2 q3 -- q2 q3 q1 ) rot quads 4-rot mrot4 forth ( q1 q2 q3 -- q3 q1 q2 ) reverse rot quad 4rotd rot4d forth ( q1 q2 q3 -- q2 q3 ) rot drop quads 4sdrop sdrop4 forth ( q1 q2 -- q2 ) ; 4swap 4drop 4sover sover4 forth ( q1 q2 -- q2 q1 q2 ) ; 4swap 4over 4swap swap4 forth ( q1 q2 -- q2 q1 ) exchange top two quads 4th>abs fth2abs forth ptr to address 4variable qvari forth (un)initiated quad variable 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 8drop drop8 forth ( o1 -- ) drop top 8 cells, quad ranum 8dup dup8 forth ( o1 -- o1 o1 ) dup top 8 cells item, quad ranum 8over over8 forth ( o1 o2 -- o1 o2 o1 ) over 8 cells item, quad ranum 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 8sover sover8 forth ( o1 o2 -- o1 o2 o1 ) swap over quad ranums 8swap swap8 forth ( o1 o2 -- o2 o1 ) swap 8-cells items 9* mul9 forth mul sing by nine a! astore forth ( n a -- ) sto cell to true addr a@ afetch forth ( a -- n ) fetch cell from true addr a-base abase forth determine stg to number conversion radix abort" abtqte forth if tf abort and prnt message abs cabs forth two-s cpl if sing -ve, '-0' -> 0 abs>4th abs2fth forth address to ptr accept vaccept forth ( p u -- u' ) input from stdin, edittable if terminal again again forth terminate endless loop after BEGIN ahead ahead forth prepare forward branch disp alarm calarm forth send alarm signal after given time in seconds align xalign forth align data-ptr up to next multiple of 4 aligned aligned forth align sing up to next multiple of 4 allocate allocatem forth allocate data-space, extends into .bss section allot allot forth reserve space in data-memory and aand forth ( n1 n2 -- n3 ) bitwise AND sings and! ands forth ( n p -- ) and to cell in memory andx andx forth ( n1 n2 n3 -- n4 ) n1 n2 AND n3 XOR ans ans forth forth-voc, words specific to ANS-4th ascii char forth fetch character value literal associative: assocc forth cpl an {associative:} list at-xy atxy forth hor and vert. cursor posn by chars b, bcomma forth compile l.s. byte of sing to data-space 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. bdot forth ( n1 n2 -- ) display n1 at radix n2 b@ bfetch forth ( p -- c ) fetch byte from memory b@+ bfetchp forth ( p1 -- p2 c ) nos=tos+1,tos=c@kref(tos) back back forth cpl backward disp to {here} base base forth number conversion radix base! bases forth sto to {base} base@ basef forth fetch {base} base value b/buf bbybuf forth bytes per buffer-block (1K) b->d b2dn forth combine 8 cells ls.bytes to a double beep beep forth controllable noise.. begin begin forth begin a repeat/until/again structure bel bel forth noise.. bignum bignum forth forth-voc, unlimited praecision integers bin binf forth useless, but ANS required file open modifier binary binary forth store 2 to base bl bbl forth cons 32 blank blanks forth ( p +u -- ) fill memory w. blanks +blanks pblanks forth right align a string by blanks blk blk forth screenfile block number -n.i.- blk@ blkfetch forth fetch {blk} blkfile blkfile forth forth-voc, block-file special words block block forth xec.vec bl.r bldotr forth ( p n1 n2 -- p n1 ) right algn'd fill w/ leading <bl>s bounds bounds forth ( n1 n2 -- n1+n2 n1 ) ; over + swap bs bs forth backspace, backup cursor by one column b->s b2sn forth combine 4 cells ls.bytes to a sing bsf bsff forth bit scan forward bsfm bsfm forth {bsf} memory bsfr bsfr forth {bsf} register bslice bslice forth string slice by byte positions bsr bsrf forth bit scan reverse bsrm bsrm forth {bsr} memory bsrr bsrr forth {bsr} register bswap bbswap forth swap bytes of a dword buffer buffer forth xec.vec c, ccomma forth compile char (1 byte) to data-space 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" cqte forth ptr to stg 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 c0 c0 forth ptr to base of code-space calign calign forth align code-ptr up to next multiple of 4 call-by-disp? cbdispq forth query cpl mode c-allot callot forth code-space & module non-modifyable data can? canq forth test input for <can> sequence caps? capsq forth tf if text interpreting letter-case dependently ?case qcase forth enter true part if @tos = @nos #case ncase forth case-list index by which a word was called case: caseco forth cpl a {case:} list #cases ncases forth items in a {case:}, {range:}, {associative:} list cc4cc! cc4ths forth sto ctrl char xec vector cc4cc@ cc4thf forth fetch ctrl char xec vector cc4th cc4th forth xec vectored control character 4th actions cell pfour forth count of bytes per cell cell- sub4 forth dec sing by no. of bytes per cell (4) cell+ add4 forth inc sing by no. of bytes per cell (4) cfalign cfalign forth align code-ptr up to next multiple of 8 c-fence cfence forth ptr to fenced code-space channel channel forth id and i/o-flags 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) c-here chere forth ptr to available code-space ch-name chname forth a channel's file name close-file closef forth close a file c>lower c2lower forth convert char to lower-case cls cls forth clear console screen & home clsc clsc forth clear console screen cmove xcmove forth ( p1 p2 +u ) copy memory contents w/ ascending ptrs cmove> cmovegt forth ( p1 p2 +u ) copy memory contents w/ descending ptrs cnalign cnalign forth align code-ptr up to next multiple supplied sing code code forth begin lo-level word -useless w/ lib4th- (code) pcodep forth terminate colon defn, continue lo-level ?comp qcomp forth abort if not in permanently compiling state compare compare forth compare two stgs 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 cons? consq forth tf if channel is console cons+ consp forth define constant increment constant constant forth define non-alterable constant context context forth 1st wordlist in search order convert converta forth convert stg to number - ANS-mode copy-file copyf forth directly copy by names one file to another count ccount forth ( p1 -- p2 u ) ptr to 1st char and count cp cp forth storage of ptr into code-space cplb cplb forth complement bit .cpu dotcpu forth display cpu type 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 create create forth build a 'variable'-type header create-file creaf forth overwriting open a file c->s c2sn forth l.s.byte to sing (cell) cs-depth csdepth forth ( -- n ) cpl-stack depth, less count from <colon> cs-drop csdrop forth drop (double) item from compile-stack csearch csearch forth search by supplied char delimited stg cslice cslice forth string slice by chars csp csp forth compiling state saved data-stack ptr !csp scsp forth store sp to csp ?csp qcsp forth abort if data-stack out of balance cs-pick cspick forth pick (double) item from compile-stack cs-roll csroll forth roll double on compile-stack cstg cstg4 forth defines a counted string value c+stg cstgps forth append char to stg value c-top ctop forth ptr to top of available code-space c>upper c2upper forth convert char to upper-case current current forth current defining vocabulary c-xchg cxchg forth ( p1 p2 +u -- ) xchange memory content d< dless forth tf if double @tos smaller than @nos 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 d- dsub forth ( d1 d2 -- d3 ) subtract doubles d/ dby forth ( d1 d2 -- d3 ) d3=quot of div d. ddot forth display signed double d* dmul forth ( d1 d2 -- d3 ) d3=prod of mul d+ dplus forth ( d1 d2 -- d3 ) add doubles d+- dpm forth ( d1 n -- d2 ) apply sign of sing to double @nos d0 d0 forth ptr to base of data-space ?d0= qdzeq forth ( dn -- dn f ) tf if double @tos is zero d0< dzless forth tf if double @tos -ve 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 (d1-) bd1mb forth ( p -- ) sub 1 from double cell at ptr (d1+) bd1pb forth ( p -- ) add 1 to double cell at ptr 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 d2dup d2dup forth ( d -- d d d ) ; 2dup 2dup 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 date date4 forth system time in seconds "date sdate4 forth stg w. system date day day4 forth day of system time "day sday4 forth stg w. day of system time daystg daystg forth convert day no. to text d->b d2bn forth extract 8 bytes from double ddup ddup forth ( n -- n n n ) ; dup dup decimal decimal forth sto 10 to base default-is defaultis forth re-define a deferred word's default action defer defer forth stored true address or ix executing vari ?deferred qdferd forth abort if xt is not of a deferred word deferred? dferdq forth tf if xt is of a deferred word defined defined forth immediate tf if name found delete-file deletf forth delete (not erase) a file depth depth forth ( -- n ) count of cells on data-stack -depth mdepth forth ( -- n ) cells free in data-stack ?depth qdepth forth abort if unsufficient data on stack depth? depthq forth tf if sufficient data on stack df/mod dfbym forth floored div doubles w/ remainder dgcd dgcd forth ( d1 d2 -- d3 ) greatest common denominator, doubles digit digit forth convert char to digit + flag dliteral dliteral forth cpl double literal dm* dmmul forth ( d1 d2 -- d3 n ) mul doubles, leave 3-cells prod. 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 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 do do forth begin counted loop ?do qdo forth enter DO-loop if start =/= limit does> doesgt forth begin runtime part of defining word does@> fdoesgt forth begin runtime part of defining word dp dp forth ptr to available data-space #dp pdoval forth floating pt. fraction marker char, dft="," dparity dparity forth ff if odd no of set bits in a double dpl dpl forth decimal point location of just converted number dpl@ dplfetch forth fetch dpl d->q d2qn forth double to quad d.r ddotr forth right aligned display signed double dr0 dr0c forth activate 1st screenfile channel dr1 dr1c forth activate 2nd screenfile channel 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 d>s d2sn forth double to sing d->s d2sn forth double to sing dsgn dsgn forth ( dn -- f ) f=signum(dn) dslbits dslbits forth ( d1 -- d1 n ) no. of top zero-bits less 2 ds-pick dspick forth pick sing wrt saved data-stack d-top dtop forth ptr to top of available data-space du< duless forth td if double @tos unsigned smaller than @nos du> dugreat forth td if double @tos unsigned smaller than @nos dump dump forth dump memory at ptr dup cdup forth ( n -- n n ) duplicate @tos, { 0 pick } -dup qdup forth ( n | 0 -- n n | 0 ) dup @tos if non-zero e\stg estg forth convert escaped chars in stg echo-off echof forth suppress kbd input echo echo-on echon forth enable kbd input echo edlin edlin forth {accept}, after 1st <tab> edit text at buffer edpl@ edplfetch forth fetch optional num. input exponent value ekey ekey forth get input byte ?ekey qekey forth ( -- c f ) tf if input byte available ekey? ekeyq forth test and get input byte and 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 else else forth enter IF "false" alternative else; elses forth opt, subst. { .. exit else } 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 emms emmsf forth clr cpu mmx/fp state empty empty forth forget all above fence empty-buffers embufs forth close scr-chan, make buffers available enclose enclose4 forth isolate a word from tib -?- endif endif forth terminate IF/ELSE sequence endif; endifs forth opt, subst. { ... exit endif } 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 #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 ?eol qeol forth tf if display posn grater than window width erase erase forth ( p +u -- ) fill memory range w/ <nul> bytes errno erno forth cnv error name to number errno? ernoq forth display known error names ?error qerror forth abort if flag indicates an error errstg errs forth cnv err number to name esc? escq forth tf if key <esc>, wait after <bl> until next 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 exit exitf forth leave hi-level word, resolve locals -exit dexit forth if tf leave current word expect expect forth accept max buffer size input, then terminate f" fqte forth fname" w/ buffer at pad f8dir f8dir forth path to installed suppl. lib4th library files factorial factorial forth ( u1 -- ud2 ) double factorial of u1, -1 < u1 < 21 false zero forth cons 0 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 fig fig forth forth-voc, words specific f.i.g.-style 4th 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. fill fill forth ( p +u n -- ) fill memory range w/ supplied byte 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) fld ufld forth user vari in dump, else free flt? fltq forth ( -- n ) cells count if last num was a float flush flush forth save updated blocks flush-file flushf forth store cached buffers back to file by channel no. fm/mod fmbymod forth ( d1 n2 -- n3r n4q ) floored double by sing [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 forget forget forth forget name and all newer words :forget colforget forth define a word-specific forget-action forget> forgetgt forth link a word to {forket-lk} chain forget, fgcomma forth link a word to {forket-lk} chain #fplaces pdoval forth max no. of {f.} fraction digits, dft=14 free freem forth link mem back to .bss section gcd gcd forth ( n1 n2 -- n3 ) greatest common denominator h>a h2a forth convert char to numeric value here here forth fetch dp, ptr to data-space hex hex forth sto 16 to base hld hld forth ptr to bot. of used number conversion buffer hold hold forth store char to number conversion stg buffer i i forth ( -- n ) copy loop index to tos id. iddot forth display a word's name by lfa or ix if if forth begin an IF/ELSE sequence i-fence ifence forth fenced no. next to rsp u.o.t. index >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. in-cons? inconsq forth tf if stdin is console ?input qinput forth ( ch -- c f ) key/char input query by channel integer integer forth immediately compiled cons interpret interpret forth evaluate input stream invert invert forth ( n1 -- n2 ) 1-s complement io-cons siocons forth determine i/o mode io-cons? ioconsq forth query i/o mode is is forth re-define a deferred word is? isq forth display xec word of a deferred word is@ isf forth dft and xec ix's by ix of a deferred word is-case iscase forth ccc( n1 n2 -- ) re-define item #n2 to n1 is-chan ischan forth copy {work}-channel description to supplied is-default isdefault forth reset deferred word to default action j j forth ( -- n ) copy 2nd order loop index to tos 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-emit kbdemit forth send a char to keyboard 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 key forth wait until character input ?key qkey forth ( -- c f ) tf if char available key! keysto forth store last input char back (if char-buf empty) key? keyq forth tf if input char available l-allot lallot forth local data-space l-and land forth ( n1 n2 -- f ) ; logic AND last lastu forth global last words nfa in dictionary latest latest forth last words nfa in {current} voc. lcase@ lcasef forth stg comparison letter case dependency flg LCASE@ lcasef forth stg comparison letter case dependency flg lc-depend lcdepend forth stg comparison in letter case dependent mode leave xleave forth unconditionally leave DO-loop at next LOOP lfa>idx lfa2idx forth uot index from lfa lfa>nfa lfa2nfa forth ptr to name from lfa lfa>pfa lfa2pfa forth ptr to execution ptr from lfa lg2 lg2 forth numerus of log at base 2 of item @tos lg(base) lgbase forth numerus of log at @base of item @nos li li forth ( n1 -- n2 ) n1-st order loop limit to tos list elist forth list screen literal literal forth cpl single literal load pdodefer forth input from current screenfile, -re- {using} >loc toloc forth de-/allocation 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-ptr locptr forth ptr to local data-space { s0 @ loc-body @ - } locref{ locref forth define locals referring list log log forth numerus of log at base @tos of item @nos loop xloop forth terminate a DO-loop sequence +loop ploop forth LOOP by explicit increment l-or lor forth ( n1 n2 -- f ) ; logic OR lshift lshift forth ( n1 n2 -- n3 ) shift left @lshift mlshift forth ( p n -- ) left shift cell in memory 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 m+! mplsto forth ( n p -- ) sign extended add sing to double in memory mark mark forth prepare back reference marker marker forth save/restore current dictionary ptrs max max forth ( n1 n2 -- f ) leave the greater of top two sings md* mdmul forth ( d1 d2 -- q ) mul doubles, leave quad prod. message message forth display system message message? messageq forth display system message if arg =/= 0 min min forth ( n1 n2 -- f ) leave the smaller of top two sings m/mod mbym forth ( d1 n2 -- n3r n4q ) vectored sm/rem(dft) or fm/mod 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 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 ms ms forth halt caller for given time in milliseconds m>s mtos forth mem bytes to data-stack msgstg msgstg forth fetch system message stg naligned naligned forth align sing up to next multiple of supplied sing nand nand forth binary AND 2 groups of cells ndrop ndrop forth drop n cells ndup ndup forth dup n cells negate negate forth ( n1 -- n2 ) negate sing new-chan newchan forth get next free channel no. nfa>lfa nfa2lfa forth ptr to linkfield from nfa ni ni forth ( n1 -- n2 ) n1-st order loop index to tos :noname noname forth begin a header-less hi-level word non-mmx nonmmx forth forth-voc, non-mmx substitutes nor nor forth binary OR 2 groups of cells not invert forth ( n1 -- n2 ) flag inversion, bitwise invert, cpu opr 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 nswap nswap forth swap blocks of n cells ?null qnull forth abort-14 if 4th ptr is zero true address number number forth vectored stg to double conversion >number tonumber forth convert stg to number till non-valid char [number] abnumberb forth ANS mode stg to number conversion nxor nxor forth binary XOR 2 groups of cells o-cr odcr forth <lf> if stdout is console octal octal forth sto 8 to base off off forth sto 0 to ptr on on forth sto -1 to ptr open-file openf forth open a file by supplied name or oor forth ( n1 n2 -- n3 ) bitwise OR sings or! ors forth ( n p -- ) or to cell in memory oswap oswap forth ( n1 n2 -- n1 n1 n2 ) ; over swap out nout forth count of bytes sent after latest <eol> out-cons? outconsq forth tf if stdout is console over over forth ( n1 n2 -- n1 n2 n1 ) copy @nos to tos over- overm forth over - over+ overp forth over + pack pack forth byte to packed nib pad pad forth ptr to tmp. buffer in data-space pad2 pad2 forth ptr to tmp. string-buffer in data-space pad-size padsize forth size of tmp. buffers in data-space page ff forth ff ?pairs qpairs forth abort if stacked compile-flags dont match parity parity forth ff if odd no of set bits in a sing parse parse forth isolate input field by (trailing) delimiter parsec parsec forth parse from supplied string path epath forth PATH env. vari at prog startup time perform perform forth execute from lfa pick pick forth ( .xx. n -- .xx. xn ) fetch cell wrt tos -pick mpick forth ( nn ... n2 n1 m -- nn..n1..n2 ) ; store into stack place place forth ( p1 +u1 p2 -- ) store stg to supplied buffer +place pplace forth ( p1 n p2 -- ) pre-/append stg in memory place-size placesize forth ( -- n ) max. stg size for -re- {place}, {+place} pop-io popio forth restore i/o from tor pow2? pow2q forth tf if item is a power of 2 forth display stg, whether counted or <nul> terminated printing? printingq forth tf if entire stg is printing chars ?prog qprog forth abort if ptr not in program or kernel space push-io pushio forth save i/o to tor, assign local tib q< qless forth ( q1 -- f ) tf if quad @tos less than @nos q= qeq forth ( q1 q2 -- f ) tf if top two quads equal q- qsub forth ( q1 q2 -- q3 ) subtract quad numbers q/ qby forth ( q1 q2 -- q3q ) quot of quad div q. qdot forth signed display a quad q* qmul forth ( q1 q2 -- o3 ) signed mul quad by quad to 8 cells prod q# qsharp forth extract l.s. digit from a quad q#> qsharpgt forth terminate quad to stg conversion q+ qplus forth ( q1 q2 -- q3 ) add quad numbers q+- qpm forth ( q1 n2 -- q3 ) apply sign of sing n1 to quad ?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 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 qdfm/mod qdfmbym forth ( q1 d2 -- d3r d4q ) floored q by d, ret doubles 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 q.r qdotr forth ( q1 n2 -- ) signed display a quad right aligned qrshift qrshift forth ( q1 n2 -- q3 ) unsigned shift quad right q#s qsharps forth convert quad to chars in {hld} buffer 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 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 query query forth {accept} until <lf> r r forth ( -- n )(R n -- n ) push @tor to @tos >r tor forth ( n -- ) push sing to return-stack ;r semir forth -re- {;} with return address adjustmt :r colonr forth -re- codespace adjustmt for safe return .r dotr forth ( n1 n2 -- ) right aligned display signed sing n1 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 r0 r0 forth ptr to return-stack bottom range: rangec forth cpl a {range:} list rdrop rdrop forth (R n -- ) ; r> drop 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> readmc readmc forth ( p u u2 -- p' u' p1 u1 ) u2 chars(=bytes) from mem readml readml forth ( p u -- p' u' p1 u1 ) next line from mem recurse recurse forth call the caller refill refill forth fill tib from input stream until <eof> rename-file renamf forth assign new name to a file by names repeat repeat forth terminate BEGIN/WHILE, loop back to BEGIN replace replace forth replace text section in a string reposition-file reposnf forth set file ptr to supplied posn resb resb4 forth reset (clear) bit resize resizem forth alloc/link back, w/o loss of data (as possible) ?resize qresizem forth allocate if required for -re- {allot} resize-file resizef forth truncate file at supplied posn >resolve toresolve forth resolve forward branch restore-input restoreinput forth restore saved input r>m rtom forth return-stack bytes to mem r/o rbyof forth ( -- n ) file open mode modifier r-ok rok forth ( -- n ) file access query modifier 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 rotd2s rotd2s forth ( n1 n2 n3 -- n1 n1 n2 n3 ) ; rot dup 2swap rot-l rotl forth bitwise rotate cell left rot-r rotr forth bitwise rotate cell right rots rots forth ( n1 n2 n3 -- n2 n1 n3 ) ; rot swap rows rows forth count of lines sent after latest {open} 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 rscan rscan forth reverse scan stg for character rshift rshift forth ( n1 n2 -- n3 ) right shift @rshift mrshift forth ( p n -- ) right shift cell in memory rshifta rshifta forth ( n1 n2 -- n3 ) arithmetic shift @rshifta mrshifta forth ( p n -- ) arithmetic shift cell in memory rskip rskip forth reverse skip characters from stg rswap rswap forth (R n1 n2 -- n2 n1 ) swap on returnstack r/w rbywf forth ( -- n ) file open mode modifier rw? rwq forth ( c -- er ) whether a file is open in r/w mode ;s semis forth terminate an execution sequence .s dots forth dispay datastack content #s sharps forth convert a double to numeric chars s= compare forth compare always case dependently s= seq forth -re- {compare}, always case dependently s" sqte forth ptr to 1st cahr of stg and count s#. sdecdot forth signed #. s0 s0 forth ptr to data-stack bottom save-buffers sbufs forth save updated blocks, "unassign" last buffer block save-input saveinput forth save input descriptors s->b s2bn forth extract 4 bytes from sing s->c s2cn forth signed sing to byte scan scan forth scan stg for character scr scr forth 'screen' no. of current screenfile scr-chan pdoval forth no. of screenfile channel s->d s2dn forth signed sing to double sdrop sdrop forth ( n1 n2 -- n2 ) ; swap drop (a 'nip') sdup sdup forth ( n1 n2 -- n2 n1 n1 ) ; swap dup search search forth search for a string in memory search-file searchf forth search file for a string see see forth de-compiler selected selected forth ccc{ -- ) activate {words} selection setb setb4 forth set bit sgn sgn forth ( n1 -- n2 ) sign of sing shift shift forth ( n1 n2 -- n3 ) shift left SIGN asign forth sign cell on tos skip skip forth skip characters from stg slist slists forth cpl by suppl. char dlm. ref/subst stg :slist colslist forth init ref/subst-list for {substitute} 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 sliteral sliteral forth cpl supplied stg s>lower s2lower forth convert stg to lower-case s>m stom forth stack bytes to mem sm/rem smbyrem forth ( d1 n2 -- n3r n4q ) div round near zero source source forth current input source descriptor source-chan sourcechan forth channel of current input source source-id sourceid forth input source flags sover sover forth ( n1 n2 -- n2 n1 n2 ) ; swap over (a 'tuck') sp> fspstore forth ( .xx. -- ) clr data-stack sp! spstore forth ( .. -- .. ) vectored to fig or ans mode, dft fig sp@ spfetch forth fetch datastack-ptr space space forth send a blank space spaces spaces forth multiply send a blank space span span forth #tib span@ spanf forth no. of last input chars srot srot forth ( n1 n2 n3 -- n3 n2 n1 ) ; swap rot sslice sslice forth string slice by enclosing strings ?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) 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. stg stg4 forth defines a string value string stng forth cpl by supplied char delimited stg /string sstring forth adjust stg parameters substitute substitute forth substitute text from -re- {:slist}s s>upper s2upper forth convert stg to upper-case s->w s2wn forth signed sing to word swap swap forth ( n1 n2 -- n2 n1 ) exchange sings @tos w/ @nos swap- swsub forth { swap - } ; reversed cells subtract swap2s swap2s forth ( n1 n2 n3 n4 -- n4 n3 n2 n1 ) revert cells order swapn swapn forth swap tos w. n-th cell szlit, szlitc forth allot & store <nul>-terminated stg in data-space szliteral szliteral forth cpl supplied <nul>-terminated stg tab tab forth emit a <tab> char, adjust @out tab-to tabto forth set cursor column, not less current posn task task forth traditionally the forth kernel top word... ?terminal qterminal forth ( -- n ) basic keyboard input query from stdin third third forth ( n1 n2 n3 -- n1 n2 n3 n1 ) ; 2 pick thru thru forth {load} a range of screens, xec only tib tib forth ptr to terminal input buffer #tib ntib forth ( -- n ) no. of chars fetched to tib ti-cal tical forth measured cpu clock rate tick>s tic2s forth convert cpu clock count to seconds time time4 forth syscall gettimeofday "time stime4 forth stg w. time >time&date totida forth cnv dn date to time&date format .time&date dotimedate forth display full size system date "time&date stimedate forth stg w. full size system date time&date timedate forth time & date in standard format to tov forth store sing to alterable cons +to pltov forth add @tos to a value to-chan tochan forth copy a channel description tools tools forth forth-voc, debugging top-mblock topmblock forth allocate data-space, extends into .bss section +to-stg stgps forth append stg to stg value to-stg stgs forth sto new stg value -trailing mtrailing forth truncate stg from trailing blanks true true forth cons -1 true= tequ forth ( n -- f ) tf if cell is ANS-mode 'true' value tstb tstb forth test bit type type forth send a string u^ upow forth ( u1 u2 -- ud3 ) unsigned double, n1 to the power of n2 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 u? uques forth unsigned display numeric content of cell at ptr u. udot forth unsigned display a sing 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 uc< ucless forth ( c1 c2 -- f ) tf if unsigned byte @tos < byte @nos u->d u2dn forth sing to unsigned double ud/ udby forth div doubles, leave double quot ud. uddot forth unsigned display a double ud* udmul forth mul doubles, leave double prod ?udcmp qudcmp forth ( d1 d2 -- d1 d2 f ) f=(d1 u< d2)-(d2 u< d1) udisp? udispq forth ( n -- n f ) uot disp range check 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 ud/mod udbym forth div doubles, leave double quot & rmd ud.r uddotr forth unsigned right aligned display a double udsqrt udsqrt forth ( d1 -- d2 n ) +ve double square root, sing 'j'-flag 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 umax umax forth ( n1 n2 -- n3 ) leave unsigned greater of top two sings umd* umdmul forth ( ud1 d2 -- uq3 ) umin umin forth ( n1 n2 -- n3 ) leave unsigned smaller of top two sings 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 unpack unpack forth packed nib to byte until until forth REPEAT if @tos = 0 else leave BEGIN structure unused unused forth ( -- n ) free space in data-memory up up forth ptr to next available user vari up+ upplus forth add disp to ptr to uservari-space update pdodefer forth mark buffer to save before re-useage uq. uqdot forth unsigned display a quad 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 ?uqcmp quqcmp forth ( q1 q2 -- q1 q2 f ) unsgnd compare, f=1 if q2 u< q1 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 uqmax uqmax forth ( q1 q2 -- q3 ) unsigned greater of two quads uqmin uqmin forth ( q1 q2 -- q3 ) unsigned smaller of two quads uqm/mod uqmbym forth ( q1 d2 -- d3r q4q ) q by d, quad quot, double rmd uq/mod uqbym forth ( q1 q2 -- q3r q4q ) uq.r uqdotr forth ( q1 n2 -- ) unsigned right aligned display a quad 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 u.r udotr forth unsigned right aligned display a sing using using forth screenfile for {load} opr. util utility forth forth-voc, forth utiliy words uv@ uvfetch forth fetch uvari by disp uwithin? uwithinq forth unsigned test & adjust 3rd w/ range of 2nd..1st 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 vlist vlist forth sequentially list context vocabulary vocabulary vocabulary forth define a vocabulary by name voc-link voclink forth wordlists and vocabularies link-ptr #vocs nvocs forth max no. of items in voc-stack vt vt forth forth-voc, vt..-control ?vt qvt forth query terminal type w, wcomma forth compile l.s. half sing (2 bytes) to data-space 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) wait sleeps forth wait given no. of seconds w-close wclose forth close the work-channel while while forth if @tos = 0 leave BEGIN structure width width forth max count of a 4th name -n.i.- <with ltwith forth n.i. (defn rules inheritage, re idx>do) within within forth un/signed test 3rd w/ range of 2nd..1st within? withinq forth signed test & adjust 3rd w/ range of 2nd..1st w/o wbyof forth file open mode modifier w-ok wok forth file access query modifier word XWORD forth fetch text enclosed by supplied char, ret ptr wordlist wordlist forth define a 'wordlist' words words forth sorted list context vocabulary work workc forth work-channel no. (for file opr's) write-char writechar forth write (multi-byte) char to channel write-file writefile forth write no. of bytes from buffer to file write-line writeline forth write send string to file & append <lf> code w->s w2sn forth l.s.word to sing wswap wswap forth ( n1 -- n2 ) swap hi & lo half of cell @tos xec? xecq forth ( n -- a f ) xec-addr from ix/ptr xg-chan xgchan forth exchange two channel descriptions x-ok xok forth file access query modifier xor xxor forth ( n1 n2 -- n3 ) bitwise XOR sings xor! xors forth ( n p -- ) xor to cell in memory xy xy forth fetch cursor posn z" zqte forth <nul>-terminated stg literal zcount zcount forth ( p1 -- p2 u ) {count} wrt <nul>-terminated stg zprint zprint forth display <nul> terminated stg (.") pdotqtep hidden runtime display stg (") pqtep hidden runtime ptr to stg 0and dng hidden ( n -- 0 ) replace @tos w/ 0 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 (-0exit) pdzexitp hidden runtime if ff leave current word 0if nif hidden opt, subst. { ... if else } 0m pdodefer hidden re-display screenfile listing [0m] bm0b hidden scr re-listing after {m} dft opr. ?1branch nzdb hidden runtime branch and dup if flg =/= 0 1or dgt hidden ( n -- 0 ) replace @tos w/ 0 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 8not not8 hidden ( o1 -- o2 ) bitwise complement top 8-cells item [abort] babortb hidden deferred {abort} dft (accept) uaccept hidden xec. vec [accept] osaccept hidden dft accept a-heap aheap hidden allocated heap memory linkage base -n.i.- (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# (aux) pauxp hidden i/o flags (bits) bbitsb hidden system flags blbl blbl hidden cons 8224 (double bl) (block) ublock hidden xec. vec [block] bblockb hidden {block} default opr. body>lfa body2lfa hidden ptr to lfa from data-"body" (bootp) ubootp hidden ptr to xec's data area (bot) mbot hidden base job true addr of .bss bottom 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 (buffer) ubuffer hidden xec. vec [buffer] bbufb hidden {buffer} default opr. build build hidden cpl a linked header name (can) ucan hidden <can> code casehead-size caseheadsz hidden ( -- n ) size in bytes of {case:}-list header cases, casesc hidden ( -- ) {case:} &c, cpl ix or sing until {;} cbytes cbytes4 hidden count of l.s. significant chars/cell (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 cpl cpl hidden make compiled code permanent cpl; csemis hidden terminate permanent code compilation @csp fcsp hidden restore sp from @csp csp@ cspf hidden fetch stored sp from csp to tos [ctype] bctypeb hidden dft non-escaping type data? dataq hidden tf if ptr points to data space ([debug]) updebugp hidden xec. vec, initially zero i.e. a noop defer-lk pdovar hidden base link of deferred words dlit dlit hidden runtime dliteral (?do) pqdop hidden runtime ?do (do) pdop hidden runtime {do} (dpl) pdplp hidden i/o flags (d.r) pddotrp hidden stg to right aligned display a signed double drop;s drops hidden combined drop and ;s dsp>xec dsp2xec hidden xec ptr from pc-rel ref at ptr (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 [emit] bemitb hidden dft emit environment environment hidden hidden-voc, ansi-ish environment queries envp envpp hidden ptr to program's environmental vari (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 [?error] bqerrb hidden dft ?error [error] berrb hidden dft error (escc) uescc hidden escape symbol for {etype} (esi) uesi hidden initial reg storage (esp) uesp hidden initial reg storage [etype] betypeb hidden dft escaping type (eval) ueval hidden xec. vec [eval] bevalb hidden dft evaluate (-exit) pdexitp hidden runtime if tf leave current word fav pdodefer hidden {find}-mode, internal to {help} f-heap fheap hidden free heap memory linkage base -n.i.- (find) pfindp hidden runtime find in specified vocabulary flit flit hidden runtime ANS dliteral [fn pfnamep hidden [fname] runtime code forget-lk pdovar hidden base link of specific forget actions get-vocflags gvocflags hidden fetch vocabulary-specific flags at voc-stack head head hidden build a word header (head) pheadp hidden cpl head-ptr (hichar) phicharp hidden upper case char codes (hi>lo) uhi2lo hidden ptr to table of lower case characters hld0 hld0 hidden initial hld after <# idx>do idx2do hidden does>-entry per ix 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 (ierr) ierr hidden input opr. error code ifa>lfa ifa2lfa hidden ptr to uot index from lfa iforget iforget hidden forget by ix (inchp) pinchpp hidden chp of latest used input channel (]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 (ioacc) uioacc hidden received vt.. control chars -n.i.- (iolink) iolink hidden i/o redirection linkage kernel? kernelq hidden tf if ptr points to kernel space kmessage kmessage hidden send message txt to STDOUT, uninitated kprog? kprogq hidden tf if ptr points to kernel or program space (-leave) pmleavep hidden runtime -leave (leave) pleavep hidden runtime leave 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>ifa lfa2ifa hidden ptr to uot index from lfa lfa>mfa lfa2mfa hidden macro field from lfa lfa>wid lfa2wid hidden vocabulary linkfield lfa>xec lfa2xec hidden execution ptr from lfa lit lit hidden runtime literal (lkindex) plkindexp hidden cpl next u.o.t. index [load] bloadb hidden dft for deferred -re- {load} local local hidden hidden-voc, local memory control & names local: locol hidden def. a local alterable constant (locb) locb hidden uvari, bytecount [locdef] blocdefb hidden [_] also [_] local definitions (lochar) plocharp hidden lower case char codes (locn) locn hidden uvari, items per defn count (lo>hi) ulo2hi hidden ptr to table of upper case characters (+loop) pploopp hidden runtime +loop (loop) ploopp hidden runtime loop (m/mod) upmbymp hidden xec. vec name name hidden fetch a <bl>-enclosed filename, { bl word count } nlit nlit hidden runtime bliteral nos-4not not4n hidden ( q1 qx -- q2 qx ) bitwise complement quad @nos 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 n@sp nnposn hidden cells disp to indexed 'bignum' null? nullq hidden tf if 4th ptr is zero true address (>number) utonum hidden xec. vec >number (number) unumber hidden xec. vec [>number] btonumb hidden dft >number o- osub hidden ( o1 o2 -- o3 ) subtract 8-cells numbers o+ oplus hidden ( o1 o2 -- o3 ) add 8-cells numbers o0= ozeq hidden ( o1 -- flg ) test eight-cells for zero o1+ o1p hidden ( o1 -- o2 ) inc eight-cells integer by one ocontext ocontext hidden previous {context}, 2nd in search order ocurrent ocurrent hidden previous {current} (oerr) oerr hidden output opr. error code (ok) upokp hidden xec. vec [ok] bokb hidden dft ok onegate onegate hidden ( o1 -- o2 ) negate eight-cells integer (outchp) poutchpp hidden chp of latest used output channel (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 (pchr) pchr hidden 4 bytes ranges of printing chars pfa>lfa pfa2lfa hidden lfa from pfa prog? progq hidden tf if ptr points to program space (q.) pqdotp hidden ( q sgn fmt -- ) quad to string qlit qlit hidden runtime qliteral (quit) uquit hidden xec. vec [quit] bquitb hidden dft quit !r storer hidden ( p -- )(R n -- ) ; r> swap ! (r) prp hidden formatted output fill char(s) r+ rplus hidden fetch next cell from 2ndary subroutne level root-wordlist rootwl hidden wid of {root} (s") psqtep hidden runtime sliteral scanvocs scanvocs hidden execute a vector by ix on all wordlists [scanvocs] bscanvb hidden execute vector by xec ptr on all wordlists (scanwl) uscanwl hidden xec. vec scanwlist scanwlist hidden execute a vector on stacked wordlists set-cal setcal hidden calibrate timer, find cpu clock rate set-vocflags svocflags hidden (re)store vocabulary-specific flags at voc-stack sforget sforget hidden forget by supplied string and top ix (source) usource hidden xec.vec of {source}, dft [source] [source] bsourceb hidden dft xec vec for {source} (source-id) psourceidp hidden saved source-id (sp!) ustosp hidden xec. vec [squit] bsquitb hidden dft quit entry after segfault (sstop) sstop hidden base job true addr of .bss top (stimo) ustimo hidden wait4.. timeout value (#tab) pntabp hidden tab spacing (tail) ptailp hidden cpl tail-ptr (tattr) utattr hidden modified console attributes (tattr-s) ustattr hidden saved console attributes (?terminal) uqterminal hidden xec. vec ?terminal testvoc testvoc hidden hidden-voc, (praeliminary tests) (#tib) pntibp hidden #tib storage (tib) ptibp hidden ptr to terminal input buffer (t.i.b.) tib-dft tibdft hidden default t.i.b. location (tib-max) ptibmaxp hidden space of tib tib-max tibmax hidden storage size of t.i.b. (tick) ptickp hidden cpu-clocks per second <top> utop hidden top address of user-vari space - don't read,store! (top) mtop hidden global true addr of .bss top (type) utype hidden xec. vec [type] pdodefer hidden deferred, string to stdout ucopy usercopy hidden copy user-vari from owner to cloned job (ud.r) puddotrp hidden stg to right aligned display an unsigned double uds>idx uds2idx hidden index from compiled disp to uot-ptr (ulink) plinkp hidden uvari link (unloop) rdrop2 hidden runtime unloop (uot) ultab hidden "user offset table" 4th words' true xec addr. uot>idx uot2idx hidden index from uot-ptr [upd] bupdb hidden dft opr for {update} (vbot) vbot hidden end of user area (vpal) uvpalette hidden initial console colours storage (vtim) uiovtim hidden keyboard input timeout, "VTIME" & "VMAX" values wdw-lk pdovar hidden double linkage of window defn's 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 (alarm) pdodefer linux SIGALRM redirection, dft { .s } alcjob allocjob linux -/- app appf linux file open modifier, "append" argstg argstg linux prog args by no. bye-r byer linux xit program with code n 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-size cdtsize linux size of channel defn storage cdt-xptr cdtxptr linux disp of channel extn ptr to channel defn ptr 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 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. cre cref linux file open modifier, "create" create-dir cread linux create directory by supplied name ctag pdovar linux global channel open tag cwd@ cwdf linux get current working directory path-name dir dirf linux file open modifier, "type directory" envstg envstg linux env vari by no. err-id errid linux channel-id of error channel faccess faccessfd linux by channel test file access permissions fcntl cfcntl linux syscall, files acces &c fd>chan fd2ch linux sto file descriptor to channel file-status fstatf linux file state by name -re- ans {FILE-STATUS} (fperm) ufperm linux default new file access permissions 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 getenv gtenv linux env vari by strg getgot getgot linux ptr to lib's ELF global offset table gid! gids linux set process group id gid@ gidf linux fetch process group id hash11 hash11 linux ELF standard hash figure heaphead-size hpheads linux size of a heap/device description header in-id inid linux channel-id of input channel ioctl cioctl linux syscall, limited i/o ports range iomode iomode linux check and (re)set i/o-channel flags ioperm sysioperm linux syscall, i/o permissions, interrupts iopl sysiopl linux set i/o priority (root user, only) kbd-chan kbdchan linux keyboard channel constant kbd-id kbdid linux identifier of keyboard channel 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 lxstg lxstg linux control strings by indices 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 mm-a mma linux MAP_ANONYMOUS 0x20, don't use a file 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. 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 mopen-file mopenf linux open file w/ supplied access mode by supplied stg mprotect mprot linux memory access permissions mremap mremap linux ( p1 u1 u2 flg -- p3 ) change memory mapping 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 msync msync linux sync. memory data w/ mapped file munmap munmap linux detach {mmap}ped file from memory nbl nblf linux file access modifier to non-blocking nof noff linux file access modifier to not following links open-dir opendirf linux open directory-file by supplied name open-pipe opipe linux open a pipe, ret i/o channels otty otty linux open stdin at tty out-id outid linux channel-id of output channel out-pty? outptyq linux tf if stdout is a pty device p! ps linux store 32bit item to port p@ pf linux fetch 32bit item from port page-size pagesize linux Linux kernel constant paligned palignp linux page align to next multiple of page size paligned- palignm linux page align (truncate) path+file pthfile linux find file in PATH, ret fully qualified path path-max pathmax linux max len of path string 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 pid@ pidf linux fetch own process id pread preadf linux read text at given fileptr 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 prt-chan pdoval linux no. of printer channel p!s pss linux store multiple 32bit items to port p@s pfs linux fetch multiple 32bit items from port pty? ptyq linux tf if channel is a pty device pw! pws linux store 16bit item to port pw@ pwf linux fetch 16bit item from port pwd pwd linux ( -- ) print working directory pwrite pwritef linux write text to given fileptr pw!s pwss linux store multiple 16bit items to port pw@s pwfs linux fetch multiple 16bit items from port readlink readlk linux read a linked files' source name rstty rstty linux reset stdin-console to initial state set-chan setchan linux store channel description from data-stack setty setty linux prepare stdin console to single-key input (sighnd) sigh linux base of signal handlers def.blocks sighnd-size sighsz linux size of a signal hnd definition block sigmsg sigmsg linux send messgae, leave msg-no. at nos signo signo linux convert signal name to number signo? signoq linux display known signal names sigstg sigs linux convert signal number to name 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 stat-size statsize linux size in bytes of file-status required buffer stty-s sttys linux simulates Linux cmd 'stty sane' syn synf linux file access modifier to blocking mode sys sys linux execute syscall by name (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 term eterm linux TERM env vari timezone tz4 linux 'timezone' figure from <gettimeofday> "timezone stz4 linux stg w. numeric 'timezone' trn trnf linux file access modifier to truncate after open uc-map uclm linux map keyboard input to lower chars uc-unmap uclu linux do not map keyboard input to lower chars 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 unlock-file unlockf linux unlock file from preventing write access 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 wait4kbd wait4kbd linux sys_select for keyboard stdin timeout wait4ti wait4ti linux sys_select for any channel's timeout wait4x wait4x linux xec by xt w/ temp. timeout work-chan pdoval linux default {work} channel no. work-id workid linux work-channel identifier work-num worknum linux actual {work} no. xg-io xgio linux exchange stdin and stdout channel descriptions 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 loc-body locbody local >body wrt local value, ptr to disp wrt @s0 field lp lp local local memory running ptr 2!! twoxstof nonmmx xchg doubles 2@! twofstof nonmmx copy double 2lshift dlshiftf nonmmx 2lshift 2rot rot2f nonmmx 2rot 2rotd rotd2f nonmmx 2rot 2drop, duplicate 3rd on tos 2rshift drshiftf nonmmx 2rshift 2rshifta drshiftaf nonmmx 2rshifta 2sdup twosdupf nonmmx 2swap 2dup 2sover twosoverf nonmmx 2swap 2over 2srot srot2f nonmmx 2swap 2rot 3dup dup3f nonmmx dup 2over rot 4!! qxstof nonmmx xchg quad 4dup dup4f nonmmx 4dup 4over over4f nonmmx 4over 4rot rot4f nonmmx 2 4roll 4-rot mrot4f nonmmx -2 4roll 4rotd rot4df nonmmx 2 4roll 4drop 4sdrop sdrop4f nonmmx 4swap 4drop 4sover sover4f nonmmx 4swap 4over 4swap swap4f nonmmx 4swap 8dup dup8f nonmmx 4over 4over = 8 ndup 8over over8f nonmmx ( o1 o2 -- o1 o2 o1 ) 8sdrop sdrop8f nonmmx ( o1 o2 -- o2 ) 8sover sover8f nonmmx ( o1 o2 -- o2 o1 o2 ) femms femmsf nonmmx clr fp & mmx state, sync cpu rotd2s rotd2sf nonmmx 2 pick -rot, duplicate 3rd on tos udsqrt fudsqrt nonmmx +ve double square root of double, sing 'j'-flag blw BLWORD novoc { bl word find }, kernel only bwf blwf novoc { bl word find }, kernel only (cd pcdp novoc {cd} runtime (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 eud erudot novoc unsigned error no., message eum erumsg novoc 4th message eus erustg novoc send a text fga fga novoc {alias} forget-handler fgb fgb novoc screenfile buffer blocks forget handler fgl fgl novoc forget> 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 (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 l!! dolxsto novoc xchg 2 locals la: doloca novoc allocate local values' memory ;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 ndf ndferd novoc undef'd deferred word error (next) pnextp novoc runtime ranum {NEXT} n.i nimp novoc 'not implemented' in kernel sgb rsigb novoc exitting signals hnd sgt rsigt novoc messaging/lib4th active signal hnd srd psortedp novoc by {sorted} compiled runtime (step) pstepp novoc runtime ranum {STEP} ts ts novoc {to-stg} runtime t+s tps novoc {+to-stg} runtime (vl pdoval novoc fetch a kernel-def'd value (vr pdovar novoc fetch a kernel-def'd vari wzo writezo novoc send asciz-string 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 1/qv qvrecip rahidden ( dv1 -- dv2 ) abs(1 div by dv1) atg(qv) atgqv rahidden ( qv1 -- qv2 ) arcus tg >ch gtch rahidden ( p u c -- n ) find 1st occurrence of char c cos(qv) cosqv rahidden ( qv1 -- qv2 ) cosinus d>qv d2qv rahidden ( dn -- qv ) double int signed to quad ranum <#dv#> ltdvgt rahidden ( dv -- p u ) convert dv to rational num stg <#dvf#> ltdvfgt rahidden ( dv -- p u ) convert dv to floating pt num stg dv>udv? dv2udvq rahidden ( dv -- udv flg ) |dv| and sign flag dv>uqv dv2uqv rahidden ( dv1 -- qv2 ) unsigned expand double to quad qv2 dv>uqv? dv2uqvq rahidden ( dv -- +qv f ) |dv| to quad and sign flag e^qv epowqv rahidden ( qv1 -- qv2 ) quad e to the power of qv1 #fd pdoval rahidden ranum integral part delimiter, dft=<bl> n>qv n2qv rahidden ( n.N -- qv ) counted int trunc/signed to quad ranum #n!v pdoval rahidden max+1 for sing factorial calculations, dft=13 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>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= qveq rahidden ( qv1 qv2 -- f ) tf if q1 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 ?qv0= qqvzeq rahidden ( qv -- qv f ) tf if qv is zero. 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>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 sincos(qv) sincosqv rahidden ( qv1 -- qv2 qv3 ) sinus qv2, cosinus qv3 sin(qv) sinqv rahidden ( qv1 -- qv2 ) sinus small? smallq rahidden ( dv -- f ) tf if "normal"izeable tg(qv) tgqv rahidden ( qv1 -- qv2 ) tangens 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 vdigits> vdigitsgt rahidden ( -- un ) largest num w/ no. {digits} digits <#vf#> ltvfgt rahidden ( v -- p u ) convert v to floating pt num stg v>uv? v2uvq rahidden ( v -- +v f ) |v| and sign flag 10^dv powdv10 rational ( dv1 -- dv2 ) dv1 to the power of ten 1/dv dvrecip rational ( dv1 -- dv2 ) abs(1 div by dv1) 1/v vrecip rational ( v1 -- v2 ) abs(1 div by v1) acos(dv) acosdv rational ( dv1 -- dv2 ) arcus cosinus asin(dv) asindv rational ( dv1 -- dv2 ) arcus sinus atg(dv) atgdv rational ( dv1 -- dv2 ) arcus tg cons racons rational rational-voc, all sizes' constants cos(dv) cosdv rational ( dv1 -- dv2 ) cosinus d>dv d2dv rational ( dn -- dv ) double int signed to double ranum deg>rad deg2rad rational ( dv1 -- dv2 ) convert degrees to radians df. dvdotf rational ( dv -- ) display ranum in floating pt format df#. dfdecdot rational ( dv -- ) display ranum in floating pt format, decimal df.j dvdotfj rational ( dv left right -- ) justified disp. fp-ranum #digits pdoval rational max displayed no. of ranum fractional digits >double todouble rational convert stg to double number #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~ 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 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. dvdot rational ( dv -- ) display rational number 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 dv0< dvzlt rational ( dv -- f ) tf if dv is -ve. dv0= dvzeq rational ( dv -- f ) tf if dv zero. 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 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>ieee f2ieee rational ( f1 -- d2 ) ranum to ieee format dv>int dv2int rational ( dv1 -- dv2 ) signed integral value dvinteger dvinteger rational ( -- dv ) constant, alterable before being cpl'd dv.j dvdotj rational ( left right dv -- ) justified disp. ranum 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 ) dv>v dv2v rational ( dv -- v ) convert double to sing ranum dvvariable dvvariable rational ( -- p ) 'ranum' (i.e. double) variable e^dv epowdv rational ( dv1 -- dv2 ) double e to the power of dv1 END fend rational ( -- ) terminate FOR-loop at next NEXT e^v epowv rational ( v1 -- v2 ) v2 <- e^v1 f. vdotf rational ( v -- ) display ranum in floating pt format f.j vdotfj rational ( left right v -- ) justified disp. fp-ranum FOR for rational ( f1 -- ) begin a FOR .. NEXT loop FROM from rational ( f1 -- ) modify FOT-loop start +FROM pfrom rational ( f1 -- ) modify FOR-loop start and limit by disp #fround pdoval rational -ve(dft) or no. of f.p. fractional digits hidden rahidden rational rational-voc, support and quad ranum IDX fidx rational ( -- f1 ) innermost level FOR-loop index !IDX sidx rational ( f1 -- ) store FOR-loop index ieee>dv ieee2f rational ( f1 -- d2 ) ieee to ranum format INC fstep rational ( -- f1 ) FOR-loop increment !INC sinc rational ( f1 -- ) store FOR-loop increment lg(dv) lgdv rational ( dv1 -- dv2 ) double ranum log dec. LIM flim rational ( -- f1 ) FOR-loop limit ln(dv) lndv rational ( dv1 -- dv2 ) double ranum log naturalis ln(qv) lnqv rational ( qv1 -- qv2 ) log naturalis 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 qv>dv qv2dv rational ( qv -- dv ) reduce quad, truncate, ret double ranum qv>v qv2v rational ( qv -- v ) reduce quad, truncate, ret sing ranum rad>deg rad2deg rational ( dv1 -- dv2 ) convert radians to sexagesimal degrees represent frepresent rational ( dv p u -- n flg1 flg2 ) ranum normalized text repr. s>dv s2dv rational ( n -- dv ) sing int signed to double ranum s>dvfactorial s2dvfac rational ( +n -- dv ) factorial of n sincos(dv) sincosdv rational ( dv1 -- dv2 dv3 ) sinus dv2, cosinus dv3 sin(dv) sindv rational ( dv1 -- dv2 ) sinus s>qv s2qv rational ( n -- qv ) sing int signed to quad ranum STEP step rational ( f1 -- ) modify FOR-loop increment stg>qv todfloat rational convert stg to quad ranum, i.e. double "float" s>v s2v rational ( n -- v ) signed sing to vulgar s>vfactorial s2vfac rational ( +n -- v ) factorial of n tg(dv) tgdv rational ( dv1 -- dv2 ) tangens truncation pdoval rational suppress trailing zeroes if non-zero(dft) #v sharpv rational ( +v -- 0 0 ) app stg to num output buf, for v. 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. 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 v0< vzlt rational ( v -- f ) tf if v negative. v0= vzeq rational ( v -- f ) tf if v zero. 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 v2dup v2dup rational ( v1 v2 -- v1 v2 v1 v2 ) vabs vabs rational ( v1 -- v2 ) negate if v1 -ve vconstant vconstant rational ( -- v ) non-alterable constant 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 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 ) v>qv v2qv rational ( v1 -- qv2 ) expand sing v1 to quad qv2 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 ) vvariable vvariable rational ( -- p ) 'ranum' (i.e. double) variable -zeroes mzeroes rational ( p u -- p u' ) trucate trailing zeroes -- slsl root active initial args terminator, no-op --> pdodefer root -re- {load} next screen .( commentp root printing comment until next ")" ( paren root in-active comment until next ")" (* paren root synonym "(", comment until next ")" [ lbrac root dec cpl nesting level by one, interpret if < 1 [_] bcb root synonym [compile]/compile/POSTPONE [,] bcompilecb root immediately compile from index #! hb root begin scripting marker, synonym {include} .\ dotbslash root printing comment until <eol> \ bslash root ignore input until <eol> \\ quit root ignore input until <eof> 4th-id fthid root initial job-id abort pdodefer root deferred {abort} also also root push vocs in search order one posn up assembler assembler root root-voc, native code cpl. words big big root fetch next numeric input as a bignum >body tobody root ptr to datafield by ix, for CREATEd words bye bye root xit program w. 0 err code c[ clbrac root dec cpl nesting level by one, interpret if < 1 cd cdf root change cwd cmc-off cmcoff root disable <call> to <jmp> conversion compiler compiler root root-voc, cpl control cpl? cplq root tf if permanently compiling >data todata root ptr to datafield by ix, wrt kernel-vari. definitions definitions root @current to ocurrent, @context to current df ranum root next numeric input is double rational num, single float EDIT pdodefer root the screenfile editor, dft {[edit]} [ELSE] belseb root read input until [then] if flag to [if] was false --env-ini noop root a noop dummy, initially in search order ENVIRONMENT? envirq root ( p u -- .xx. f ) ans-4th environment query err-chan pdoval root channel number of error channel error errorv root vectored {error}, dft deferred {<error>} <error> pdodefer root deferred, dft {[error]} flt fltf root set numeric input mode to double ranum -flt mflt root false(!) flag if double ranum input mode forth forth root root-voc, main forth-wordlist forthwl root wid of {forth} get-current gcurrent root @current get-vocs getvocs root fetch all wid-s + count from voc-stack help help root help-text from glossary --help ihelp root minimalistic help hidden hidden root root-voc, used within other words hv hvstack root {help} mode modifier idx>lfa idx2lfa root lfa from uot index [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 immediate immediate root set latest word to immediately executing in-chan pdoval root channel number of input channel int intf root reset from {flt} to integer numeric input mode lc-ignore lcignore root stg comparison in letter case independent mode LC-IGNORE lcignore root stg comparison in letter case independent mode lib4th lib4th root display l4 cpl date linux linux root root-voc, host access noop noop root no action, just <ret> no-opt noopt root modify latest to not substituting end-ret w/ jump o( ocommentp root comment until next ")" if stdout is console 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 out-chan pdoval root channel number of output channel prevdef prevdef root restore previous {current} previous previous root pop and discard context voc fron voc-stack qf double root next numeric input is quad rational num, double float quad quad root fetch next numeric input as a quad integer quit quit root outer interpreter, exit from loadfiles rational rational root root-voc, real numbers real-user ruser root set process effective to real user id root root root basic voc, essential words, linkage base rs rs root reset console to 'sane' state rvoc rvoc root restore previous {context} set-current scurrent root store wid to {current} set-order sorder root store entire search order set-vocs setvocs root (re)store vocabulary ptrs at voc-stack sf sing root next numeric input is single rational num sh sh root xec a shell command sh| shp root xec shell cmd, pipe output to buf ss ss4 root for #!-execution after exec. name system systm root root-voc, hardware specific [THEN] bthenb root terminate conditional input sequence [if]... tib>dft tib2dft root reset t.i.b. to default location tick tic root get current cpu clock count unsmudge unsmudge root enable finding of latest word v vau root display which wordlist a word is in vers vers root 4 bytes numeric library version version version root display l4-version --version sversion root library version vocs vocs root display all def'd voc-names where where root show error source, afte cpl error x-io xio root exchange stdin,stdout,stderr w. in-chan &c. ctag+ ctagp system inc channel tag kernel vari, ret old. pause cpause system enable re-scheduling of jobs from @(pause) add-link addlink systm ( p1 p2 -- ) link p1 into list p2 b/b bbyb systm bits per byte (8) cpuid cpuidf systm cpu queries --env-ini f8ini systm evluate F8INI env vari f8ini f8ini systm evluate F8INI env vari get-cp getcp systm get ptr into code space, where this word returns. getref getrefb systm restore kernel reference int-ptrace intptrace systm breakpoint for lo-level debugging mtlock mtlock systm lock int's for block opr, enable ports access mtunlock mtunlock systm un-lock int's, disable ports access novoc novoc systm system-voc, non-executeable, dummy names [pause] bpauseb systm dft {pause} pop4th pop4th systm (R regs -- ) rst saved cpu-regs -re- {push4th} push4th push4th systm (R -- regs ) save cpu regs used by L4 kernel rdpmc rdpmcf systm ( -- d ) read perfromance monitoring counters rmv-link rmvlink systm ( p1 p2 -- ) unlink p1 from list p2 sh-argp pdovar systm shell command arguments ptr's static? staticq systm tf if prog statically linked xlock xlock systm exec word w. int's locked adump adump tools dump from true address alias alias tools defining a synonymous word bdump bdump tools dump next, towards preceding addresses #dcm hdcm tools decompile at given ptr dumpa dumpa tools dump at ptr, display true addr. flg flg tools ( -- n ) eflags, display w/ -re- {flg>smb} flg>smb flg2smb tools ( n -- p u )convert eflags bits to symbolic chars ndump ndump tools dump next, towards ascending addr. 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] dotsi tools immediate {.s}, displaying datastack #see hsee tools continue decompiling at @fld tdump tdump tools dump, don't store ptrs which which tools display path+file if in L4 path a-close aclose utility close channels 5 till end of table [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 d! pdodefer utility ( n p -- ) deferred {!} d!! pdodefer utility ( p1 p2 -- ) deferred {!!} d@ pdodefer utility ( p -- n ) deferred {@} 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 precedes pdodefer utility { x1 x2 -- f ) {sort} relation quick quick utility sort datafield seed pdovar utility random, quad vari 'seed' (selected) pdodefer utility { .xx. -- .xx. ) {words} selection [selected] pdodefer utility { .xx. n lfa -- .xx. n lfa ) {words} sort sort utility tag sort array sorted sorted utility tag sort array by relation name voc. vocdot utility by lfa display which wordlist a word is in wvoc wvoc utility vocabulary link by lfa of a word wvoc-r wvocr utility 2ndary vocabulary link by lfa of a word random random utility; uu crea 0, {'random'}, random, utility ; randomize randomize utility; uu crea 0, {'randomize'}, randomize, utility ; abscur abscur vt curs addr wrt top left of screen <bel> lbelg vt ascii ctrl code bg pdoval vt background assignation black pdoval vt colour value blue pdoval vt colour value <bs> lbsg vt ascii ctrl code <can> lcang vt ascii ctrl code cdn cdn vt cursor one row down col col vt get cursor column colour vtcolour vt console display colour, attr, etc. (ECMA-48) <cr> lcrg vt ascii ctrl code <csi> lcsig vt ascii ctrl code 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 del del vt <bs> and delete chr at cursor posn <del> ldelg vt ascii ctrl code <esc> lescg vt ascii ctrl code ff ff vt form feed, <nl> for console <ff> lffg vt ascii ctrl code fg pdoval vt foreground assignation 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 green pdoval vt colour value home home vt cursor to top left <ht> lhtg vt ascii ctrl code [i] pdoval vt latest {ink} colour ink vtink vt set foreground colour/vt-mode <lf> llfg vt ascii ctrl code magenta pdoval vt colour value 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 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 [r] pdoval vt latest reverse video state 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 row row vt get cursor row se pdo2val vt normal intensity set-palette setpalette vt assign a colour value <si> lsig vt ascii ctrl code so pdo2val vt half-bright <so> lsog vt ascii ctrl code <sub> lsubg vt ascii ctrl code to-col tocol vt set cursor column to-row torow vt set cursor row ue pdo2val vt underline off us pdo2val vt underscore <vt> lvtg vt ascii ctrl code vt0 pdo2val vt top of console co-ordinates (-1 unset) 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
by [ name | topic | voc ] [ glos | files | xref ] [ notation | dpans94 | syscalls ] [ bot | top ]