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)
^ fpow floatop ( f1 f2 -- f3 ) f1 to the power of f2 ^ pow forth ( n1 n2 -- d ) double, sing to the power of sing ~ 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 < less forth ( n1 n2 -- f ) tf if @tos smaller than @nos <> nequal ans ( n1 n2 -- f ) ff if @tos = @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 - fsubf floatop ( f1 f2 -- f3 ) 12.6.1.1425 12.6.1.1425 - ssub forth ( n1 n2 -- n3 ) subtract sings -> tov ans -re- {to} for "pforth" (etc) -- slsl root active initial args terminator, no-op --> pdodefer root -re- {load} next screen , comma forth compile sing (4 bytes) to data-space ; semi forth terminate colon defn, clr locals, check : colon forth begin a 'colon definition' ! fstore floatop ( f1 p -- ) 12.6.1.1400 12.6.1.1400 ! 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 / fby floatop ( f1 f2 -- f3 ) 12.6.1.1430 12.6.1.1430 / by forth ( n1 n2 -- n3q ) div sings, leave quot . fdot floatop ( f1 -- ) 12.6.2.1427 12.6.2.1427 . dot forth ( n -- ) display signed sing ." dotquote forth display string .( commentp root printing comment until next ")" ' atick ans fetch xec token ix by name ' tick forth fetch xec token ix by name as a literal " qte forth cpl stg, ret ptr to stg ( paren root in-active comment until next ")" (.") pdotqtep hidden runtime display stg (") pqtep hidden runtime ptr to stg (* paren root synonym "(", comment until next ")" [ lbrac root dec cpl nesting level by one, interpret if < 1 [_] bcb root synonym [compile]/compile/POSTPONE [-->] bnxldb forth dft for {load} or, for immediate xec [,] bcompilecb root immediately compile from index [;] bsemib compiler return address adjustmt, -re- {;r} runtime [:] bcolonb compiler code-space adjustmt for safe return, by {:r} ['] tick ans cpl xec token ix fetched by name [[ llbrac compiler dec cpl nesting level by two, interpret if < 1 ] rbrac forth enter cpl state, inc nesting level by one ]] rrbrac compiler enter structure compiling state { loccb forth cpl locals list, un-/initiated & comment @ ffetch floatop ( p -- f1 ) 12.6.1.1472 12.6.1.1472 @ 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 * fmulf floatop ( f1 f2 -- f3 ) 12.6.1.1410 12.6.1.1410 * smul forth ( n1 n2 -- n3 ) mul sings */ dvmulby floatop ( f1 f2 f3 -- f4 ) mul f1 by f2 div by f3 */ mulby forth ( n1 n2 n3 -- n5q ) n1 / n2 * n3, qot n4 ** fpow floatop ( f1 f2 -- f3 ) 12.6.2.1415 12.6.2.1415 &. octdot forth ( u -- ) octal display unsigned sing # sharp forth extract l.s. digit char from a double #> sharpgt forth terminate number to stg conversion #! hb root begin scripting marker, synonym {include} #. decdot forth ( u -- ) decimal display unsigned sing % dvvh floatop ( f1 f2 -- f3 ) per 100 %. bindot forth ( u -- ) binary display unsigned sing + fplus floatop ( f1 f2 -- f3 ) 12.6.1.1420 12.6.1.1420 + plus forth ( n1 n2 -- n3 ) add sings +> pltov ans -re- {to} for "pforth" (etc) +- 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=] izeq ans immediate flag inversion, {0=} @0= zeqf forth @ 0= ; tf if cell @ptr = zero 0< fzlt floatop ( f1 -- flg ) 12.6.1.1440 12.6.1.1440 0< zless forth ( n -- f ) tf if -ve sing 0<> zneq ans ( n -- f ) tf if non-zero sing 0= fzeq floatop ( f1 -- flg ) 12.6.1.1450 12.6.1.1450 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 .\ dotbslash root printing comment until <eol> \ bslash root ignore input until <eol> \< ngt forth ( n1 n2 -- f ) tf if @tos smaller than @nos \\ quit root ignore input until <eof> 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 0drop zdrop forth -dup drop ; discard zero cell @tos 0dv v0dv racons ( -- dv ) 0 -0exit dzexit forth if ff leave current word (-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. 0max zmax forth 0 max ; not less than 0 0qv v0qv racons ( -- qv ) 0 0v v0v racons ( -- v ) 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- fonem floatop ( f1 -- f2 ) subtract one 1- sub1 forth dec sing by one 1, cpl1 forth compile byte to c-here 1+ fonep floatop ( f1 -- f2 ) add one 1+ add1 forth inc sing by one 10* mul10 forth mul sing by ten 100dv v100dv racons ( -- dv ) 100 10^(1/2) casqr2n10 racons ( -- v ) 10^dv powdv10 rational ( dv1 -- dv2 ) dv1 to the power of ten 16* mul16 forth mul sing by sixteen 16*+ mp16 assembler ( n -- n ) { 16 * + } 16/mod div16m forth div/mod sing by sixteen 1abs abs1 forth one-s complement if sing -ve ?1branch nzdb hidden runtime branch and dup if flg =/= 0 1dv v1dv racons ( -- dv ) 1 -1dv vm1dv racons ( -- dv ) -1 1/dv dvrecip rational ( dv1 -- dv2 ) abs(1 div by dv1) 1line e1line editor find in curs-line 1or dgt hidden ( n -- 0 ) replace @tos w/ 0 1qv v1qv racons ( -- qv ) 1 -1qv vm1qv racons ( -- qv ) -1 1/qv qvrecip rahidden ( dv1 -- dv2 ) abs(1 div by dv1) 1/string s1string forth adjust stg parameters by 1 1v v1v racons ( -- v ) 1 -1v vm1v racons ( -- v ) -1 1/v vrecip rational ( v1 -- v2 ) abs(1 div by v1) 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! twostoa ans ( d p -- ) sto double to mem, BIG ENDIAN (ANS!) 2! twosto fig ( d p -- ) sto double to mem 2! dfstore floatop ( f1 p -- ) 12.6.2.1203 12.6.2.1203 2! twosto forth ( d p -- ) sto double to mem 2!! twoxsto forth ( p1 p2 -- ) xchange doubles in memory 2!! twoxstof nonmmx xchg doubles 2/ shr2 ans signed shift sing right by one 2/ f2by floatop ( f1 f2 -- f3 ) div by two 2/ div2 forth div sing by two 2@ twofetcha ans ( p -- d ) fetch double, BIG ENDIAN (ANS!) 2@ twofetch fig ( p -- d ) fetch double 2@ dffetch floatop ( p -- df1 ) 12.6.2.1204 12.6.2.1204 2@ twofetch forth ( p -- d ) fetch double 2@! twofsto forth ( p1 p2 -- ) copy double from/to memory 2@! twofstof nonmmx copy double 2* f2mul floatop ( f1 f2 -- f3 ) mul by two 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 2^(1/12) casqr12n2 racons ( -- v ) 2^(1/2) casqr2n2 racons ( -- v ) 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 adliteral ans cpl ANS mode (big endian) double literal 2literal dliteral forth cpl double literal 2lshift dlshift forth ( d1 n -- d2 ) shift left a double 2lshift dlshiftf nonmmx 2lshift 2n->2q n22q bignum bignum pair to quad 2n->2uq n22uq bignum bignum pair unsigned to quad 2not dnot fig ( d1 -- d2 ) one-s complement a double 2or or2 forth ( d1 d2 -- d3 ) bitwise OR doubles 2oswap oswap2 forth ( d1 d2 -- d1 d1 d2 ) ; 2over 2swap 2OVER dfover floatop ( df1 df2 -- df1 df2 df1 ) 2over over2 forth ( d1 d2 -- d1 d2 d1 ) copy double @nos to tos 2PICK dfpick floatop ( df1... n1 -- df1 ) pick double float 2pick pick2 forth ( .dd. n -- .dd. dn ) pick double 2-pick mpick2 forth ( dn ... d2 d1 m -- dn..d1..d2 ) ; 2store into stack 2q->2n q22n bignum quad pair to bignum 2q->2un q22un bignum quad pair unsigned to bignum 2r r2 forth (R d -- d )( -- d ) double from return-stack 2>R ator2 ans ( n1 n2 -- )(R -- n1 n2 ) push to r-stack, BIG ENDIAN 2>r tor2 forth ( n1 n2 -- )(R -- n2 n1 ) push double to return-stack 2R> arfrom2 ans (R d -- )( -- d ) pop double from rstack,BIG ENDIAN 2r> rfrom2 forth (R d -- )( -- d ) pop double from return-stack 2R@ ar2f ans (R d -- d )( -- d ) copy double from rstack, BIG ENDIAN 2r>>2r r2xchg forth ( d1 -- d2 )(R d2 -- d1 ) ; 2r> 2swap 2>r 2rdrop rdrop2 forth (R dn -- ) ; 2r> 2drop 2roll roll2 forth ( .dd. n -- .. dn ) roll doubles 2ROT dfrot floatop ( df1 df2 df3 -- df2 df3 df1 ) 2rot rot2 forth ( d1 d2 d3 -- d2 d3 d1 ) roll by 2 2rot rot2f nonmmx 2rot 2-rot mrot2 forth ( d1 d2 d3 -- d3 d1 d2 ) ; 2rot 2rot 2rotd rotd2 forth ( d1 d2 d3 -- d2 d3 ) ; 2rot 2drop 2rotd rotd2f nonmmx 2rot 2drop, duplicate 3rd on tos 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 2rshift drshiftf nonmmx 2rshift 2rshifta drshifta forth ( d1 n -- d2 ) sign preserving shift right a double 2rshifta drshiftaf nonmmx 2rshifta 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 2sdup twosdupf nonmmx 2swap 2dup 2sover sover2 forth ( d1 d2 -- d2 d1 d2 ) ; 2swap 2over 2sover twosoverf nonmmx 2swap 2over 2srot srot2 forth ( d1 d2 d3 -- d3 d2 d1 ) ; 2swap 2rot 2srot srot2f nonmmx 2swap 2rot 2SWAP dfswap floatop ( df1 df2 -- df2 df1 ) 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 3^(1/2) casqr2n3 racons ( -- v ) 3drop drop3 forth ( n1 n2 n3 -- ) ; 2drop drop 3dup dup3 forth ( d1 n1 -- d1 n1 d1 n1 ) ; dup 2over rot 3dup dup3f nonmmx dup 2over rot 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 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!! qxstof nonmmx xchg quad 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 dup4f nonmmx 4dup -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 4over over4f nonmmx 4over 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 4rot rot4f nonmmx 2 4roll 4-rot mrot4 forth ( q1 q2 q3 -- q3 q1 q2 ) reverse rot quad 4-rot mrot4f nonmmx -2 4roll 4rotd rot4d forth ( q1 q2 q3 -- q2 q3 ) rot drop quads 4rotd rot4df nonmmx 2 4roll 4drop 4sdrop sdrop4 forth ( q1 q2 -- q2 ) ; 4swap 4drop 4sdrop sdrop4f nonmmx 4swap 4drop 4sover sover4 forth ( q1 q2 -- q2 q1 q2 ) ; 4swap 4over 4sover sover4f nonmmx 4swap 4over 4swap swap4 forth ( q1 q2 -- q2 q1 ) exchange top two quads 4swap swap4f nonmmx 4swap 4th>abs fth2abs forth ptr to address 4th-id fthid root initial job-id 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*+ mp8 asmhidden ( n -- n ) { 8 * + } 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 8dup dup8f nonmmx 4over 4over = 8 ndup 8not not8 hidden ( o1 -- o2 ) bitwise complement top 8-cells item 8over over8 forth ( o1 o2 -- o1 o2 o1 ) over 8 cells item, quad ranum 8over over8f nonmmx ( o1 o2 -- o1 o2 o1 ) 8pick pick8 forth ( .. o1 n -- .. o1 on | .. ) +/- pick 8 cells items 8roll roll8 forth ( on .. o1 n -- .. o1 on | o1 on .. ) roll by 8cells 8sdrop sdrop8 forth ( o1 o2 -- o2 ) drop @nos 8-cells item 8sdrop sdrop8f nonmmx ( o1 o2 -- o2 ) 8sover sover8 forth ( o1 o2 -- o1 o2 o1 ) swap over quad ranums 8sover sover8f nonmmx ( o1 o2 -- o2 o1 o2 ) 8swap swap8 forth ( o1 o2 -- o2 o1 ) swap 8-cells items 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 abits mul8 ans mul by no. of bits per address unit abort pdodefer root deferred {abort} [abort] babortb hidden deferred {abort} dft abort" abtqte forth if tf abort and prnt message ABS aabs ans two-s cpl if sing -ve, '-0' unchanged ABS fabsf floatop ( f1 -- f2 ) 12.6.2.1474 12.6.2.1474 abs cabs forth two-s cpl if sing -ve, '-0' -> 0 abs>4th abs2fth forth address to ptr abscur abscur vt curs addr wrt top left of screen accept vaccept forth ( p u -- u' ) input from stdin, edittable if terminal (accept) uaccept hidden xec. vec [accept] osaccept hidden dft accept a-close aclose utility close channels 5 till end of table ACOS facos floatop ( f1 -- f2 ) 12.6.2.1476 12.6.2.1476 acos(dv) acosdv rational ( dv1 -- dv2 ) arcus cosinus ACOSH facosh floatop ( f1 -- f2 ) area cosh, 12.6.2.1477 12.6.2.1477 add-link addlink systm ( p1 p2 -- ) link p1 into list p2 ADDRESS-UNIT-BITS aub environment consecutive bits per address unit adump adump tools dump from true address again again forth terminate endless loop after BEGIN ahead ahead forth prepare forward branch disp a-heap aheap hidden allocated heap memory linkage base -n.i.- alarm calarm forth send alarm signal after given time in seconds (alarm) pdodefer linux SIGALRM redirection, dft { .s } alcjob allocjob linux -/- alias alias tools defining a synonymous word align xalign forth align data-ptr up to next multiple of 4 aligned aligned forth align sing up to next multiple of 4 [all-find] ballfindb utility {find} by counted stg trough all vocabularies all-find allfind utility {find} trough all vocabularies allocate allocatem forth allocate data-space, extends into .bss section allot allot forth reserve space in data-memory all-words allwords utility {vlist} all vocabularies ALOG falogf floatop ( f1 -- f2 ) 12.6.2.1484 12.6.2.1484 also also root push vocs in search order one posn up 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 anew marker ans {marker}, for 'common useage' compatibility... ans ans forth forth-voc, words specific to ANS-4th a-number anumber ans convert stg to number - ANS-mode app appf linux file open modifier, "append" (argc) argc hidden program's arguments count (argn) argn hidden internal, 2nd-ary args count argp argpp hidden ptr to args to program (argp) argp hidden ptr to args to program (args) args hidden 1st in-active arg# argstg argstg linux prog args by no. ascii char forth fetch character value literal asciz hasciz compiler cpl next stg in asciz-mode ASIN fasin floatop ( f1 -- f2 ) 12.6.2.1486 12.6.2.1486 asin(dv) asindv rational ( dv1 -- dv2 ) arcus sinus ASINH fasinh floatop ( f1 -- f2 ) area sinh, 12.6.2.1487 12.6.2.1487 asm-hidden asmhidden assembler root-voc, native code cpl. words assembler assembler root root-voc, native code cpl. words associative: assocc forth cpl an {associative:} list 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 atg(dv) atgdv rational ( dv1 -- dv2 ) arcus tg atg(qv) atgqv rahidden ( qv1 -- qv2 ) arcus tg at-xy atxy forth hor and vert. cursor posn by chars (aux) pauxp hidden i/o flags B eB editor backup by text len in pad 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/b bbyb systm bits per byte (8) b/buf bbybuf forth bytes per buffer-block (1K) b/c bbyc editor bytes per character (8) b->d b2dn forth combine 8 cells ls.bytes to a double bdump bdump tools dump next, towards preceding addresses beep beep forth controllable noise.. begin begin forth begin a repeat/until/again structure bel bel forth noise.. <bel> lbelg vt ascii ctrl code bernulli(v) bernulliv racons ( n -- v ) sing, bernulli'sche zahlen bg pdoval vt background assignation big big root fetch next numeric input as a bignum 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 (bits) bbitsb hidden system flags bl bbl forth cons 32 black pdoval vt colour value blank blanks forth ( p +u -- ) fill memory w. blanks blanks blanks fig ( p +u -- ) fill memory w. blanks +blanks pblanks forth right align a string by blanks blbl blbl hidden cons 8224 (double bl) blk blk forth screenfile block number -n.i.- blk@ blkfetch forth fetch {blk} blk>buf blk2buf blkfile ptr to screenfile buffer by blk# blkfile blkfile forth forth-voc, block-file special words 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 bcore environment wordset availabilty flag block block forth xec.vec (block) ublock hidden xec. vec [block] bblockb hidden {block} default opr. BLOCK-EXT bcorex environment wordset availabilty flag block-lk pdovar blkfile base link of screenfile storage blocks bl.r bldotr forth ( p n1 n2 -- p n1 ) right algn'd fill w/ leading <bl>s blue pdoval vt colour value blw BLWORD novoc { bl word find }, kernel only >body tobody root ptr to datafield by ix, for CREATEd words body>lfa body2lfa hidden ptr to lfa from data-"body" (boot) pdovar blkfile dft -re- {l-load} library file (bootp) ubootp hidden ptr to xec's data area (bot) mbot hidden base job true addr of .bss bottom bounds bounds forth ( n1 n2 -- n1+n2 n1 ) ; over + swap 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 bs bs forth backspace, backup cursor by one column <bs> lbsg vt ascii ctrl code b->s b2sn forth combine 4 cells ls.bytes to a sing b/scr bbyscr fig buffer blocks per screen(1) 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 +buf plusbuf fig next buffer buf>blk buf2blk blkfile block no. assigned to a screenfile buffer buffer buffer forth xec.vec (buffer) ubuffer hidden xec. vec [buffer] bbufb hidden {buffer} default opr. 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. build build hidden cpl a linked header name bwf blwf novoc { bl word find }, kernel only bye bye root xit program w. 0 err code bye-r byer linux xit program with code n C eC editor indsert text c cac racons ( -- v ) speed of light 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[ clbrac root dec cpl nesting level by one, interpret if < 1 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 c0- c0m asmhidden ( n -- n ) { $c0 - } c0+ c0p asmhidden ( n -- n ) { $c0 + } c0-8* c0m8m asmhidden ( n -- n ) { $c0 - 8 * } calign calign forth align code-ptr up to next multiple of 4 <call> lcallg assembler x86 op-code, call pc-rel call, c_call compiler ( -- ) call dword disp call-by-disp cbdisp compiler cpl relative calls by disp call-by-disp? cbdispq forth query cpl mode call-by-uot cbuot compiler cpl indirect call by address in uot c-allot callot forth code-space & module non-modifyable data <can> lcang vt ascii ctrl code (can) ucan hidden <can> code can? canq forth test input for <can> sequence caps? capsq forth tf if text interpreting letter-case dependently CASE case ans begin a CASE decision sequence ?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 casedep casedep compiler set latest word to case-dependent find mode casehead-size caseheadsz hidden ( -- n ) size in bytes of {case:}-list header #cases ncases forth items in a {case:}, {range:}, {associative:} list cases, casesc hidden ( -- ) {case:} &c, cpl ix or sing until {;} cbytes cbytes4 hidden count of l.s. significant chars/cell 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 (cc4th) icc4th hidden xec. vec cd cdf root change cwd (cd pcdp novoc {cd} runtime cdepth cdepth compiler depth of compile-stack doubles cdn cdn vt cursor one row down 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 cell pfour forth count of bytes per cell cell- sub4 forth dec sing by no. of bytes per cell (4) CELL/ cellby ans floored div sing by bytes per cell (4) cell+ add4 forth inc sing by no. of bytes per cell (4) CELLS mul4 ans mul sing by bytes per cell (4) cfalign cfalign forth align code-ptr up to next multiple of 8 c-fence cfence forth ptr to fenced code-space >ch gtch rahidden ( p u c -- n ) find 1st occurrence of char c (ch ccasec novoc ( -- p ) build named list channel channel forth id and i/o-flags (chans) pchansp hidden ptr to base of channel description tables CHAR char ans cpl character value literal [CHAR] char ans compile character value literal 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) 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 c-here chere forth ptr to available code-space ch-flags chflagsf linux channel flags dword ch-id chid linux channel identifier ch-name chname forth a channel's file name chn-num chnnum linux top chan a copy of which is in supplied ch-id ch-omode chomodef linux channel open mode chp chp linux ptr to channel definition table chp>chan chp2ch linux get channel no. by chp ch-perm chpermf linux channel permission bits ch-pipe? chpipeq linux tf if pipe flag set ch-pty? chptyq linux tf if pty-device flag set ch-rnum chrnum linux latest err code ch-stat chstat linux fetch channel state into cdt ch-tag chtag linux channel's tag no. c/l cbyl fig chars per line (64) CLEAR clear editor fill screen w/ blanks close-dir closef ans close a directory-file 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 cmac hcmac compiler h-flg, enable macroes cpl (cmc) ucmc hidden compiler control counter for back-patching bound cmc? cmcq compiler state of optimizing token counter cmc-off cmcoff root disable <call> to <jmp> conversion 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 scode ans terminate colon defn, continue 'lo level' (;code) pscodep assembler runtime for 'does>' (;code@) pscodefp assembler runtime for '@does>' (code) pcodep forth terminate colon defn, continue lo-level col col vt get cursor column colour vtcolour vt console display colour, attr, etc. (ECMA-48) ?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) ucompile hidden xec. vec [compile] bcb forth synonym {postpone} compile, compilec forth compile by supplied ix compiler compiler root root-voc, cpl control cons racons rational rational-voc, all sizes' constants cons? consq forth tf if channel is console cons+ consp forth define constant increment CONSTANT fcons floatop ccc( f1 -- ) 12.6.1.1492 12.6.1.1492 constant constant forth define non-alterable constant context context forth 1st wordlist in search order CONVERT converta ans convert stg to number - ANS-mode convert convert fig convert stg to number - f.i.g.-mode convert converta forth convert stg to number - ANS-mode COPY copy editor copy 1st to 2nd screen copy-file copyf forth directly copy by names one file to another CORE acore environment wordset availabilty flag CORE-EXT acorex environment wordset availabilty flag COS fcosf floatop ( f1 -- f2 ) 12.6.2.1493 12.6.2.1493 cos(dv) cosdv rational ( dv1 -- dv2 ) cosinus COSH fcosh floatop ( f1 -- f2 ) area tanh, 12.6.2.1494 12.6.2.1494 cos(qv) cosqv rahidden ( qv1 -- qv2 ) cosinus COUNT count ans ( p1 -- p2 u ) chars(bytes?) count of a counted string count ccount forth ( p1 -- p2 u ) ptr to 1st char and count /COUNTED-STRING scstg environment max. length of a counted string cp cp forth storage of ptr into code-space (cp) uprevcp compiler by {compile,} previously used code-ptr cpl cpl hidden make compiled code permanent cpl; csemis hidden terminate permanent code compilation cpl? cplq root tf if permanently compiling cplb cplb forth complement bit .cpu dotcpu forth display cpu type cpuid cpuidf systm cpu queries cr cr forth send <lf> to stdout <cr> lcrg vt ascii ctrl code -cr dcr forth ( f -- ) if tf send <lf> to stdout ?cr qcr forth <nl> if no space left in display line cre cref linux file open modifier, "create" create create forth build a 'variable'-type header create-dir cread linux create directory by supplied name create-file creaf forth overwriting open a file c->s c2sn forth l.s.byte to sing (cell) c+s ctps novoc {c+stg} runtime c/scr pdoval editor chars per editor screen (1024) 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 <csi> lcsig vt ascii ctrl code 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 @csp fcsp hidden restore sp from @csp csp@ cspf hidden fetch stored sp from csp to tos cs-pick cspick forth pick (double) item from compile-stack csr csr vt set scrolling region 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 ctag pdovar linux global channel open tag ctag+ ctagp system inc channel tag kernel vari, ret old. c-top ctop forth ptr to top of available code-space [ctype] bctypeb hidden dft non-escaping type cup cup vt cursor one row up c>upper c2upper forth convert char to upper-case 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 current current forth current defining vocabulary cwd@ cwdf linux get current working directory path-name c-xchg cxchg forth ( p1 p2 +u -- ) xchange memory content cyan pdoval vt colour value D eD editor push line to pad d< dless forth tf if double @tos smaller than @nos D<> dneq ans tf if doubles not equal d= deq forth tf if double @tos and @nos equal d=/= dneq forth tf if doubles not equal d> dgreat forth tf if double @tos smaller than @nos d- dsub forth ( d1 d2 -- d3 ) subtract doubles d! pdodefer utility ( n p -- ) deferred {!} d!! pdodefer utility ( p1 p2 -- ) deferred {!!} d/ dby forth ( d1 d2 -- d3 ) d3=quot of div D. dfdotf floatop ( df1 -- ) print double float (quad ranum) d. ddot forth display signed double d@ pdodefer utility ( p -- n ) deferred {@} 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<> dzneq ans ff if double @tos is zero d0= dzeq forth tf if double @tos is zero d0=/= dzneq forth ff if double @tos is zero d0> dzgt forth tf if double @tos -ve (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/ qv2div floatop ( df1 df2 -- df3 ) div by two d2/ dtwoby forth ( d1 -- d2 ) div double by two D2* qv2mul floatop ( df1 -- df2 ) multiply by 2 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 (da doassoc novoc ( n1 p -- n2 ) {associative:} runtime dabs dabs forth ( d1 -- d2 ) two-s cpl doubles if -ve >data todata root ptr to datafield by ix, wrt kernel-vari. data? dataq hidden tf if ptr points to data space DATASTACK-SIZE dss environment cells available for data-stack 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 (dc docasec novoc ( ix p -- xx ) {case:} runtime #dcm hdcm tools decompile at given ptr (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 ddup ddup forth ( n -- n n n ) ; dup dup d>dv d2dv rational ( dn -- dv ) double int signed to double ranum ([debug]) updebugp hidden xec. vec, initially zero i.e. a noop [debug] bdebugb compiler default (debug) opr decimal decimal forth sto 10 to base DEFAULT noop ans last alternative in CASE sequence - a noop default-is defaultis forth re-define a deferred word's default action defer defer forth stored true address or ix executing vari defer-lk pdovar hidden base link of deferred words ?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 [DEFINED] defined ans re {defined} definitions definitions root @current to ocurrent, @context to current DEG>RAD deg2rad float ( f1 -- f2 ) convert degrees to radians deg>rad deg2rad rational ( dv1 -- dv2 ) convert degrees to radians del del vt <bs> and delete chr at cursor posn <del> ldelg vt ascii ctrl code del-buffer fgbblok blkfile remove {latest} buffer block, if possible DELETE delete editor del chars backward delete-file deletf forth delete (not erase) a file DEPTH fdepth floatop ( -- n ) 12.6.1.1497 12.6.1.1497 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 ranum root next numeric input is double rational num, single float 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? dfder novoc undef'd deferred word error if ff DF. dfdotf float ( df1 -- ) print double float (quad ranum) df. dvdotf rational ( dv -- ) display ranum in floating pt format DF@ dffetch float ( p -- df1 ) 12.6.2.1204 12.6.2.1204 df#. dfdecdot rational ( dv -- ) display ranum in floating pt format, decimal DFALIGN dfalign ans ( -- ) 12.6.2.1205 12.6.2.1205 DFALIGNED dfaligned ans ( p1 -- p2 ) 12.6.2.1207 12.6.2.1207 DFATANH dfatanh float ( df1 -- df2 ) area tanh double float DF>F dftof float ( df1 -- f2 ) 12.6.1.1130 12.6.1.1130 dfg dfdfg novoc dft forget action for deferred word df.j dvdotfj rational ( dv left right -- ) justified disp. fp-ranum >DFLOAT todfloat float ( p u -- df2 ) convert stg to quad ranum, d"float" DFLOAT+ dfloatp ans ( n1 -- n2 ) 12.6.2.1208 12.6.2.1208 DFLOATS dfloats ans ( n1 -- n2 ) mul-16, 12.6.2.1209 12.6.2.1209 df/mod dfbym forth floored div doubles w/ remainder 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 ) dgcd dgcd forth ( d1 d2 -- d3 ) greatest common denominator, doubles (di dfi novoc ( n1 p -- n2 ) {default-is} runtime digit digit forth convert char to digit + flag #digits pdoval rational max displayed no. of ranum fractional digits dir dirf linux file open modifier, "type directory" dlit dlit hidden runtime dliteral dlit, c_dlit compiler ( d -- ) cpl double literal 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 dminus dnegate fig ( d1 -- d2 ) negate a double dmod dmod forth div doubles, leave double rmd d/mod dbym forth ( d1 d2 -- d3 ) d3=rmd of div dnegate dnegate forth ( d1 -- d2 ) two-s complement of a double do do forth begin counted loop ?do qdo forth enter DO-loop if start =/= limit (?do) pqdop hidden runtime ?do (do) pdop hidden runtime {do} dodoes, c_dds compiler ( -- ) cpl dodoes, pfa to be patched to start+2 does> doesgt forth begin runtime part of defining word does@> fdoesgt forth begin runtime part of defining word DOUBLE dcore environment wordset availabilty flag >double todouble rational convert stg to double number DOUBLE-EXT dcorex environment wordset availabilty flag 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) pdplp hidden i/o flags dpl@ dplfetch forth fetch dpl d->q d2qn forth double to quad d>qv d2qv rahidden ( dn -- qv ) double int signed to quad ranum (dr dorangec novoc ( n1 p -- n2 ) {range:} runtime (d.r) pddotrp hidden stg to right aligned display a signed double d.r ddotr forth right aligned display signed double dr? schq blkfile whether {scr-chan} is dr0, dr1 or neither one dr0 dr0c forth activate 1st screenfile channel dr1 dr1c forth activate 2nd screenfile channel DROP fdrop floatop ( f1 -- ) 12.6.1.1500 12.6.1.1500 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 drop;s drops hidden combined drop and ;s D>S dftof floatop ( df1 -- f2 ) 12.6.1.1130 12.6.1.1130 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 dsp>xec dsp2xec hidden xec ptr from pc-rel ref at ptr 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 dumpa dumpa tools dump at ptr, display true addr. DUP fdup floatop ( f1 -- f1 f1 ) 12.6.1.1510 12.6.1.1510 dup cdup forth ( n -- n n ) duplicate @tos, { 0 pick } -dup qdup forth ( n | 0 -- n n | 0 ) dup @tos if non-zero ?DUP qdup ans ( n -- n n | 0 ) dup if dup endif ; {-dup} <#dv#> ltdvgt rahidden ( dv -- p u ) convert dv to rational num stg #dv sharpdv rational ( +dv -- 0 0 ) app stg to ranum output buf dv^ dvpowdv rational ( dv1 dv2 -- dv3 ) double dv1 to the power of dv2 dv~ 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 ) dva pdovar novoc pfax'ed value 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 ) 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 <#dvf#> ltdvfgt rahidden ( dv -- p u ) convert dv to floating pt num stg #dvf sharpdvf rational ( +dv -- 0 0 ) app stg to float output buf dv>floor dv2floor rational ( dv1 -- dv2 ) floored integral value dvfrac dvfrac rational ( dv -- dv ) fractional component of dv dvfround dvfround rational ( dv1 -- dv2 ) round for floating point stg dv>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 dv.ln(10) cdvln10 racons ( -- dv ) double, log 10 base e dv.ln(2) cdvln2 racons ( -- dv ) double, log 2 base e 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 dvo dovoc novoc vocabulary dvover dvover rational ( dv1 dv2 -- dv1 dv2 dv1 ) dvoverflow dvoverflow rational ( dv -- f ) tf if dv was overflow indicator value dvovf dvovf racons ( -- dv ) double overflow indicator 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>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 dv>v dv2v rational ( dv -- v ) convert double to sing ranum dvvariable dvvariable rational ( -- p ) 'ranum' (i.e. double) variable E eE editor blank line e cae racons ( -- v ) natuerliche zahl e\stg estg forth convert escaped chars in stg e^10 cae10 racons ( -- v ) 10 * lim (1+1/n)^n e^6 cae6 racons ( -- v ) 6 * lim (1+1/n)^n (eax) ueax hidden initial reg storage (ebp) uebp hidden initial reg storage (ebx) uebx hidden initial reg storage echo-off echof forth suppress kbd input echo echo-on echon forth enable kbd input echo (ecx) uecx hidden initial reg storage (edi) uedi hidden initial reg storage EDIT pdodefer root the screenfile editor, dft {[edit]} [edit] beditb editor {edit} default opr. editor editor fig fig-forth-voc, editting editting eding blkfile modify screenfile access to r/w edlin edlin forth {accept}, after 1st <tab> edit text at buffer edpl@ edplfetch forth fetch optional num. input exponent value e^dv epowdv rational ( dv1 -- dv2 ) double e to the power of dv1 (edx) uedx hidden initial reg storage ekey ekey forth get input byte ?ekey qekey forth ( -- c f ) tf if input byte available (ekey?) uekeyq hidden xec. vec 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 ekm erkmsg novoc uninitiated error message else else forth enter IF "false" alternative [ELSE] belseb root read input until [then] if flag to [if] was false else; elses forth opt, subst. { .. exit else } emit emit forth send a char to stdout (emit) uemit hidden xec. vec [emit] bemitb hidden dft emit 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-blk emblk blkfile invalidate a single blockfile buffer empty-buffers embufs forth close scr-chan, make buffers available enclose enclose fig isolate a word from tib -?- enclose enclose4 forth isolate a word from tib -?- END fend float ( -- ) terminate FOR-loop at next NEXT END fend rational ( -- ) terminate FOR-loop at next NEXT ENDCASE endcase ans terminate CASE sequence end-code endcode assembler terminate -re- {code} defn endif endif forth terminate IF/ELSE sequence endif; endifs forth opt, subst. { ... exit endif } end-macro cendmacro compiler terminate macro code-expansion cpl ENDOF endof ans terminate OF-part in CASE sequence enter nter forth jump to after ENTRY in a BEGIN structure -enter mnter forth conditonally enter BEGIN structure at ENTRY entry ntry forth destination after BEGIN from ENTER #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 --env-ini noop root a noop dummy, initially in search order --env-ini f8ini systm evluate F8INI env vari environment environment hidden hidden-voc, ansi-ish environment queries ENVIRONMENT? envirq root ( p u -- .xx. f ) ans-4th environment query envp envpp hidden ptr to program's environmental vari envstg envstg linux env vari by no. (eof) peofp hidden received chars count, zero at eof ?eol qeol forth tf if display posn grater than window width (eol) ueol hidden <eol> code e^qv epowqv rahidden ( qv1 -- qv2 ) quad e to the power of qv1 erase erase forth ( p +u -- ) fill memory range w/ <nul> bytes err-chan pdoval root channel number of error channel err-id errid linux channel-id of error channel errno erno forth cnv error name to number errno? ernoq forth display known error names error errorv root vectored {error}, dft deferred {<error>} <error> pdodefer root deferred, dft {[error]} ?error qerror forth abort if flag indicates an error (?error) uqerror hidden xec. vec ?error (error) uerror hidden xec. vec [?error] bqerrb hidden dft ?error [error] berrb hidden dft error errstg errs forth cnv err number to name <esc> lescg vt ascii ctrl code esc? escq forth tf if key <esc>, wait after <bl> until next (escc) uescc hidden escape symbol for {etype} (esi) uesi hidden initial reg storage esm ersmsg novoc signed error no., message (esp) uesp hidden initial reg storage [etype] betypeb hidden dft escaping type eud erudot novoc unsigned error no., message euler-c caec racons ( -- v ) euler'sche zahl euler(v) eulerv racons ( n -- v ) sing, euler'sche zahlen eum erumsg novoc 4th message eus erustg novoc send a text e^v epowv rational ( v1 -- v2 ) v2 <- e^v1 (eval) ueval hidden xec. vec [eval] bevalb hidden dft evaluate evaluate evaluate forth interpret supplied string EXCEPTION xcore environment (untested, hi-level substitutes available) EXCEPTION-EXT xcorex environment wordset availabilty flag ?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 (-exit) pdexitp hidden runtime if tf leave current word EXP fexp floatop ( f1 -- f2 ) 12.6.2.1515 12.6.2.1515 expect expect forth accept max buffer size input, then terminate EXPM1 fexpm1 floatop ( f1 -- f2 ) 12.6.2.1516 12.6.2.1516 F eF editor find text [f] bfb editor -find w/ forth voc preferrence 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. vdotf rational ( v -- ) display ranum in floating pt format f" fqte forth fname" w/ buffer at pad 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 ) f8dir f8dir forth path to installed suppl. lib4th library files f8doc f8doc utility path to installed documentation files (f8doc) pdoval utility ptr to default documentation dir f8glo f8glo utility name of l4 glossary file f8gls f8gls utility ( -- p u ) path+name of l4 glossary file (f8gls) pdoval utility ptr to default filename for {help} f8ini f8ini systm evluate F8INI env vari (f8lib) pdoval utility ptr to default support library dir FABS fabsf float ( f1 -- f2 ) 12.6.2.1474 12.6.2.1474 faccess faccessfd linux by channel test file access permissions FACILITY ccore environment wordset availabilty flag FACILITY-EXT ccorex environment wordset availabilty flag 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 factorial factorial forth ( u1 -- ud2 ) double factorial of u1, -1 < u1 < 21 FALIGN falign ans ( -- ) 12.6.1.1479 12.6.1.1479 FALIGNED faligned ans ( p1 -- p2 ) 12.6.1.1483 12.6.1.1483 FALOG falogf float ( f1 -- f2 ) 12.6.2.1484 12.6.2.1484 false zero forth cons 0 [FALSE] zero ans immediate cons 0 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 fav pdodefer hidden {find}-mode, internal to {help} fcntl cfcntl linux syscall, files acces &c 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 #fd pdoval rahidden ranum integral part delimiter, dft=<bl> F>D ftod float ( f1 -- d2 ) 12.6.1.1470 12.6.1.1470 fd>chan fd2ch linux sto file descriptor to channel 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 femms femmsf nonmmx clr fp & mmx state, sync cpu 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 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 ff ff vt form feed, <nl> for console <ff> lffg vt ascii ctrl code fg pdoval vt foreground assignation fga fga novoc {alias} forget-handler fgb fgb novoc screenfile buffer blocks forget handler fgl fgl novoc forget> runtime code f-heap fheap hidden free heap memory linkage base -n.i.- F>IEEE f2ieee float ( f1 -- d2 ) ranum to ieee-754, 12.6.1.1470 12.6.1.1470 fig fig forth forth-voc, words specific f.i.g.-style 4th FILE fcore environment wordset availabilty flag file-access faccessf forth by name test file access permissions FILE-EXT fcorex environment wordset availabilty flag file>file f2file forth directly copy between two files file-position fposf forth ( n1 -- d2 er ) file-pointer by channel no. file-size fsizef forth ( n1 -- n2 ) size of file by channel no. FILE-STATUS afstatf ans file state by name -re- linux {file-status} file-status fstatf linux file state by name -re- ans {FILE-STATUS} fill fill forth ( p +u n -- ) fill memory range w/ supplied byte FIND efind editor find stg at pad in screen 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) pfindp hidden runtime find in specified vocabulary [find] bfindb forth find a word's lfa by stg(p,u) first first fig bot. of 1st block buffer, 0 if unassigned [first] pdoval blkfile bot. of 1st block buffer, 0 if unassigned f.j vdotfj rational ( left right v -- ) justified disp. fp-ranum fld ufld forth user vari in dump, else free flg flg tools ( -- n ) eflags, display w/ -re- {flg>smb} flg>head flg2head compiler ( n ix -- n ) set/clr header flag flg>smb flg2smb tools ( n -- p u )convert eflags bits to symbolic chars flit flit hidden runtime ANS dliteral flit, c_flit compiler ( f -- ) cpl double precision f.p. literal (n.i.) 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 float ans ans-voc, real numbers >FLOAT tofloat float ( p u -- f1 ) 12.6.1.0558 12.6.1.0558 FLOAT+ floatp ans ( p1 -- p2 ) 12.6.1.1555 12.6.1.1555 FLOATING flting environment wordset availabilty flag FLOATING-EXT fltingx environment wordset availabilty flag float-op floatop float {FLOAT}-subvoc w. un-praefixed names FLOATS floats ans ( n1 -- n2 ) mul-8 12.6.1.1556 12.6.1.1556 FLOG flog float ( f1 -- f2 ) 12.6.2.1557 12.6.2.1557 FLOOR floor float ( f1 -- dn ) 12.6.1.1558 12.6.1.1558 FLOORED floored environment flag whether defaul div is 'floored' flt fltf root set numeric input mode to double ranum -flt mflt root false(!) flag if double ranum input mode 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. 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 fm/mod fmbymod forth ( d1 n2 -- n3r n4q ) floored double by sing [fn pfnamep hidden [fname] runtime code [fname] bfnameb forth find file in F8DIR & PATH, ret path+file-name fname" fnmqte forth find file in F8DIR & PATH, ret path+file-name FNEGATE fnegate float ( f1 -- f2 ) 12.6.1.1567 12.6.1.1567 f-number fnumber fig convert stg to double - f.i.g-mode f-ok fok forth file access query modifier fopen fopenf forth open file by fetched name FOR for float ( f1 -- ) begin FOR .. NEXT loop, set range FOR for rational ( f1 -- ) begin a FOR .. NEXT loop (for) pforp novoc runtime ranum {FOR} 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 forget-lk pdovar hidden base link of specific forget actions forth forth root root-voc, main forth-wordlist forthwl root wid of {forth} FOVER fover float ( f1 f2 -- f1 f2 f1 ) 12.6.1.1600 12.6.1.1600 (fperm) ufperm linux default new file access permissions FPICK fpick float ( f1... n1 -- f1 ) +/- pick float #fplaces pdoval forth max no. of {f.} fraction digits, dft=14 fposre fposre linux adjust file-ptr relative to current posn FRANDOM frandom float ( f1 -- f2 ) random number in range [0,f1) free freem forth link mem back to .bss section FROM from float ( f1 -- ) set FOR-loop start FROM from rational ( f1 -- ) modify FOT-loop start (+from) ppfromp novoc runtime ranum {+FROM} (from) pfromp novoc runtime ranum {FROM} +FROM pfrom float ( f1 -- ) modify FOR-loop start & limit by disp f1 +FROM pfrom rational ( f1 -- ) modify FOR-loop start and limit by disp FROT frot float ( f1 f2 f3 -- f2 f3 f1 ) 12.6.1.1610 12.6.1.1610 FROUND fround float ( f1 -- f2 ) nearest int, 12.6.1.1612 12.6.1.1612 #fround pdoval rational -ve(dft) or no. of f.p. fractional digits 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 fstat ffstatf linux file status by channel no. 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 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 gcd gcd forth ( n1 n2 -- n3 ) greatest common denominator get-chan getchan linux fetch channel description data get-cp getcp systm get ptr into code space, where this word returns. get-current gcurrent root @current getenv gtenv linux env vari by strg getgot getgot linux ptr to lib's ELF global offset table GET-ORDER gorder ans content + count of voc-stack getref getrefb systm restore kernel reference get-vocflags gvocflags hidden fetch vocabulary-specific flags at voc-stack get-vocs getvocs root fetch all wid-s + count from voc-stack gid! gids linux set process group id gid@ gidf linux fetch process group id green pdoval vt colour value H eH editor copy line to pad h>a h2a forth convert char to numeric value hash11 hash11 linux ELF standard hash figure head head hidden build a word header (head) pheadp hidden cpl head-ptr head>blk head2blk blkfile ptr to buffer by ptr to header head>buf head2buf blkfile block no. by ptr to header heaphead-size hpheads linux size of a heap/device description header help help root help-text from glossary --help ihelp root minimalistic help here here forth fetch dp, ptr to data-space hex hex forth sto 16 to base (hichar) phicharp hidden upper case char codes hidden rahidden rational rational-voc, support and quad ranum hidden hidden root root-voc, used within other words (hi>lo) uhi2lo hidden ptr to table of lower case characters hld hld forth ptr to bot. of used number conversion buffer hld0 hld0 hidden initial hld after <# hold hold forth store char to number conversion stg buffer /HOLD shold environment size of numeric stg conversion buffer home home vt cursor to top left <ht> lhtg vt ascii ctrl code hv hvstack root {help} mode modifier I eI editor ins line from pad i i forth ( -- n ) copy loop index to tos [i] pdoval vt latest {ink} colour (i1 dointeger novoc {integer} runtime (i2 dointeger2 novoc {2integer} runtime (i4 dointeger4 novoc {4integer} runtime ibbuf ibbuf blkfile initiate/install a buffer w/ 4 blocks (ic doisc novoc ( n1 n2 ix -- ) {iscase} runtime id. iddot forth display a word's name by lfa or ix IDX fidx float ( -- f1 ) innermost FOR-loop index IDX fidx rational ( -- f1 ) innermost level FOR-loop index !IDX sidx float ( f1 -- ) store FOR-loop index !IDX sidx rational ( f1 -- ) store FOR-loop index idx>do idx2do hidden does>-entry per ix idx>lfa idx2lfa root lfa from uot index idx>pfa idx2pfa hidden pfa from uot index idx>uds idx2uds hidden disp to base of uot idx>uot idx2uot hidden ptr to uot entry from index idx>wid idx2wid hidden index to wordlist id idx>xec idx2xec hidden execution ptr from index ieee>dv ieee2f rational ( f1 -- d2 ) ieee to ranum format IEEE>F ieee2f float ( f1 -- d2 ) ieee-754 to ranum, 12.6.1.1470 12.6.1.1470 (ierr) ierr hidden input opr. error code if if forth begin an IF/ELSE sequence [IF] bifb root read input until [else], discard till [then] ifa>lfa ifa2lfa hidden ptr to uot index from lfa i-fence ifence forth fenced no. next to rsp u.o.t. index if-found iffound root discard till eol if name not found if-nfound ifnfound root discard till eol if name found iforget iforget hidden forget by ix if-true iftrue root discard till eol if false flag imed himed compiler h-flg, xec immediately imed? imedq compiler tf if word (by lfa) is immediate immediate immediate root set latest word to immediately executing in xin fig parsed terminal input count >in xin forth parsed terminal input count in@ infetch forth fetch {in} INC fstep float ( -- f1 ) FOR-loop increment INC fstep rational ( -- f1 ) FOR-loop increment !INC sinc float ( f1 -- ) store FOR-loop increment !INC sinc rational ( f1 -- ) store FOR-loop increment in-chan pdoval root channel number of input channel (inchp) pinchpp hidden chp of latest used input channel 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 in-id inid linux channel-id of input channel inif hinif compiler h-flg, init from header fields at system startup ink vtink vt set foreground colour/vt-mode ?input qinput forth ( ch -- c f ) key/char input query by channel int intf root reset from {flt} to integer numeric input mode integer integer forth immediately compiled cons interpret interpret forth evaluate input stream (]interpret) ubinterpret hidden xec. vec, initially zero i.e. a noop (interpret) uinterpret hidden xec. vec (interpret[) uinterpretb hidden xec. vec, initially zero i.e. a noop [interpret] binterpretb compiler default (interpret) opr ]interpret binter compiler xec (]interpret) interpret[ interb compiler xec (interpret[) int-ptrace intptrace systm breakpoint for lo-level debugging invert invert forth ( n1 -- n2 ) 1-s complement (ioacc) uioacc hidden received vt.. control chars -n.i.- io-cons siocons forth determine i/o mode io-cons? ioconsq forth query i/o mode ioctl cioctl linux syscall, limited i/o ports range (iolink) iolink hidden i/o redirection linkage 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) is is forth re-define a deferred word (is dois novoc ( n1 p -- n2 ) {is} runtime 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 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 j j forth ( -- n ) copy 2nd order loop index to tos jccn, c_jccn compiler ( -- ) jcc near disp jccs, c_jccs compiler ( -- ) jcc short disp <jmp> ljmpg assembler x86 op-code, jmp near pc-rel jmpn, c_jmpn compiler ( -- ) jmp near disp jmps, c_jmps compiler ( -- ) jmp short disp <jr> ljrg assembler x86 op-code, jmp short pc-rel [kb bkbdt novoc { kbd' name } xec name w. stdin from console kb] kbdtb novoc { kbd' name } xec name w. stdin from console kbd kbdc forth keyboard input channel no. kbd! kbdsto forth store last kbd char back (if char-buf empty) kbd' kbdt forth xec fetched name w. stdin from console kbd-chan kbdchan linux keyboard channel constant kbd-emit kbdemit forth send a char to keyboard kbd-id kbdid linux identifier of keyboard channel kbd-key kbdkey forth wait until char from keyboard kbd?key kbdqkey forth w/ zero timeout get a char from keyboard kbd-type kbdtype forth send a string to keyboard channel (kc pdocasec novoc ( ix p -- xx ) kernel-{case:} runtime kcall, c_kcall compiler ( disp -- ) call [dword kref (disp)] kernel? kernelq hidden tf if ptr points to kernel space 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 k(h) cakphp racons ( -- v ) CORDIC hyperbolic correction kmessage kmessage hidden send message txt to STDOUT, uninitated kprog? kprogq hidden tf if ptr points to kernel or program space k(t) cakptp racons ( -- v ) CORDIC trigonometric correction 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 L relist editor re-list @{scr} L- relim editor list previous @{scr} l!! dolxsto novoc xchg 2 locals L+ relip editor list next @{scr} la: doloca novoc allocate local values' memory #lag hlag editor ptr & count after curs 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 lc-ignore lcignore root stg comparison in letter case independent mode LC-IGNORE lcignore root stg comparison in letter case independent mode #lead hlead editor ptr & count till curs leave xleave fig unconditionally leave DO-loop at next LOOP leave xleave forth unconditionally leave DO-loop at next LOOP -leave dleave fig LEAVE if @tos =/= 0 (-leave) pmleavep hidden runtime -leave (leave) pleavep hidden runtime leave <lf> llfg vt ascii ctrl code lfa>body lfa2body hidden ptr to data-"body" from lfa lfa>ffa lfa2ffa hidden ptr to compileflags from lfa lfa>head lfa2head hidden beginning of word-header lfa>idx lfa2idx forth uot index from lfa lfa>ifa lfa2ifa hidden ptr to uot index from lfa lfa>mfa lfa2mfa hidden macro field from lfa lfa>nfa lfa2nfa forth ptr to name from lfa lfa>pfa lfa2pfa forth ptr to execution ptr from lfa lfa>wid lfa2wid hidden vocabulary linkfield lfa>xec lfa2xec hidden execution ptr from lfa lg2 lg2 forth numerus of log at base 2 of item @tos lg(2) calg2 racons ( -- v ) log 2 base 10 lg(base) lgbase forth numerus of log at @base of item @nos lg(dv) lgdv rational ( dv1 -- dv2 ) double ranum log dec. lg(e) calge racons ( -- v ) log e base 10 lg(nn) lgnn bignum sing numerus of log(bignum)(sing) li li forth ( n1 -- n2 ) n1-st order loop limit to tos LIB4TH l4e environment flag, "lib4th" present lib4th lib4th root display l4 cpl date LIM flim float ( -- f1 ) FOR-loop limit LIM flim rational ( -- f1 ) FOR-loop limit limit limit fig top+1 of last block buffer, 0 if unassigned [limit] pdoval blkfile top+1 of last block buffer, 0 if unassigned LINE line editor ptr to line or abort-16 .LINE dotline editor display line/screen (line) plinep editor fetch line/screen linux linux root root-voc, host access list elist forth list screen lit lit hidden runtime literal lit, c_lit compiler ( n -- ) cpl single literal; spush, mov eax,dword n LITERAL fliteral floatop ( f1 -- ) 12.6.1.1552 12.6.1.1552 literal literal forth cpl single literal litp, c_litp compiler ( n -- ) cpl single literal, add eax,dword n (lkindex) plkindexp hidden cpl next u.o.t. index llseek llseekf linux abs/rel set posn of file-ptr (syscall) #lmg pdoval editor editor screen & printing, left margin LN fln floatop ( f1 -- f2 ) 12.6.2.1553 12.6.2.1553 ln(10) caln10 racons ( -- v ) log 10 base e ln(2) caln2 racons ( -- v ) log 2 base e ln(dv) lndv rational ( dv1 -- dv2 ) double ranum log naturalis 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. LNP1 flnp1 floatop ( f1 -- f2 ) 12.6.2.1554 12.6.2.1554 ln(qv) lnqv rational ( qv1 -- qv2 ) log naturalis load pdodefer forth input from current screenfile, -re- {using} [load] bloadb hidden dft for deferred -re- {load} >loc toloc forth de-/allocation loc!! locxsto local exchange two local values loc' loctick local find a local values xt by supplied name loc2! loc2s local sto double local; sing -re- {to} loc2@ loc2f local fetch double local; sing by name local local hidden hidden-voc, local memory control & names (LOCAL) plocalp ans local wordheader by supplied stg local: locol hidden def. a local alterable constant LOCALS lcore environment wordset availabilty flag locals locals forth ( -- n ) available cells for local data #LOCALS nlocals environment cells available for local data locals| locbar forth cpl initiated locals list locals? localsq forth tf if suffient no. of local cells available LOCALS-EXT lcorex environment wordset availabilty flag #locate hlocate editor line no, curpos (locb) locb hidden uvari, bytecount loc-body locbody local >body wrt local value, ptr to disp wrt @s0 field [locdef] blocdefb hidden [_] also [_] local definitions (lochar) plocharp hidden lower case char codes lock-file lockf linux lock file, prevent write access (locn) locn hidden uvari, items per defn count locp, c_locp compiler ( n -- ) cpl ptr to a local "value", loc-ptr locptr forth ptr to local data-space { s0 @ loc-body @ - } locref{ locref forth define locals referring list locrmv locrmv compiler intermediate local values de-allocation locto, c_locto compiler ( -n -- ) cpl local "to", locv, c_locv compiler ( n -- ) cpl single local "value", LOG flog floatop ( f1 -- f2 ) 115 115 |12.6.2.1557 log log forth numerus of log at base @tos of item @nos (lo>hi) ulo2hi hidden ptr to table of upper case characters loop xloop forth terminate a DO-loop sequence (+loop) pploopp hidden runtime +loop (loop) ploopp hidden runtime loop +loop ploop forth LOOP by explicit increment l-or lor forth ( n1 n2 -- f ) ; logic OR lp lp local local memory running ptr lshift lshift forth ( n1 n2 -- n3 ) shift left @lshift mlshift forth ( p n -- ) left shift cell in 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. lxfiles lxfiles linux host definitions source-files lxpath lxpath linux path to host definitions source lxstg lxstg linux control strings by indices lz: dolocz novoc zero-init a local value M eM editor move curs 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 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 magenta pdoval vt colour value mark mark forth prepare back reference marker marker forth save/restore current dictionary ptrs match match editor search mem for stg MAX fmax floatop ( f1 f2 -- f3 ) 12.6.1.1562 12.6.1.1562 max max forth ( n1 n2 -- f ) leave the greater of top two sings max-chan maxchan linux max no. of supplied channel description tables 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-lw maxlw editor max stdout line width 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 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 mcreate-dir mcread linux create directory w/ supplied access mode mcreate-file mcreaf linux create file w/ supplied access mode md pdo2val vt bold md* mdmul forth ( d1 d2 -- q ) mul doubles, leave quad prod. me pdo2val vt reset all vt attributes MEMORY-ALLOC mcore environment RESIZE restricted to top alloc. block message message forth display system message message? messageq forth display system message if arg =/= 0 mfopen mfopen linux open file w/ supplied access mode by fetched stg MIN fmin floatop ( f1 f2 -- f3 ) 12.6.1.1565 12.6.1.1565 min min forth ( n1 n2 -- f ) leave the smaller of top two sings minus negate fig ( n1 -- n2 ) negate sing 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 (m/mod) upmbymp hidden xec. vec m/mod mbym forth ( d1 n2 -- n3r n4q ) vectored sm/rem(dft) or fm/mod mm-p mmp linux MAP_PRIVATE 0x02, Changes are private mm-s mms linux MAP_SHARED 0x01, Share changes 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 mopen-file mopenf linux open file w/ supplied access mode by supplied stg move move forth ( p1 p2 +u ) copy non-overwriting >move< movex forth ( p1 p2 +u -- ) copy reversed bytes order -move mmove editor copy from ptr to line mprotect mprot linux memory access permissions mr pdo2val vt reverse video m>r mtor forth mem bytes to return-stack 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 ms forth halt caller for given time in milliseconds ?ms qms ans time in milli-seconds since host startup m>s mtos forth mem bytes to data-stack ms-a msa linux MS_ASYNC 1, sync memory asynchronously msgstg msgstg forth fetch system message stg 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 mtlock mtlock systm lock int's for block opr, enable ports access mtunlock mtunlock systm un-lock int's, disable ports access munmap munmap linux detach {mmap}ped file from memory N eN editor next find (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 naligned naligned forth align sing up to next multiple of supplied sing name name hidden fetch a <bl>-enclosed filename, { bl word count } nand nand forth binary AND 2 groups of cells nbl nblf linux file access modifier to non-blocking ncmp ncmp bignum ret sign of subtraction of two bignums ?ncmp qncmp bignum non-destr. ret sgn(diff of two counted ints) ndf ndferd novoc undef'd deferred word error ndrop ndrop bignum drop counted int ndrop ndrop forth drop n cells ndump ndump tools dump next, towards ascending addr. ndup ndup forth dup n cells NEGATE fnegate floatop ( f1 -- f2 ) 12.6.1.1567 12.6.1.1567 negate negate forth ( n1 -- n2 ) negate sing ?NEGATE spm ans ( n1 n2 -- n3 ) apply sign of sing n2 to sing n1 new-chan newchan forth get next free channel no. NEXT next float ( -- ) terminate a FOR-loop NEXT next rational ( -- ) terminate a FOR .. NEXT loop (next) pnextp novoc runtime ranum {NEXT} nextbuf nextbuf blkfile {+buf} wrt by -re- {source-id} used blocks nfa>lfa nfa2lfa forth ptr to linkfield from nfa ngcd ngcd bignum ret greatest common divisor of two bignums ni ni forth ( n1 -- n2 ) n1-st order loop index to tos n.i nimp novoc 'not implemented' in kernel ninteger ninteger bignum counted int alterable constant ninvert ninvert bignum 1's cpl counted int NIP sdrop ans ( n1 n2 -- n2 ) ; swap drop nlit nlit hidden runtime bliteral nlit, c_nlit compiler ( .x. N -- ) cpl counted integer 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 nof noff linux file access modifier to not following links :noname noname forth begin a header-less hi-level word none pdoval vt noop argument non-mmx nonmmx forth forth-voc, non-mmx substitutes noop noop root no action, just <ret> no-opt noopt root modify latest to not substituting end-ret w/ jump <nop> lnopg assembler x86 op-code, nop nopt hnopt compiler h-flg, non-optimizing nor nor forth binary OR 2 groups of cells 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 not invert forth ( n1 -- n2 ) flag inversion, bitwise invert, cpu opr novoc novoc systm system-voc, non-executeable, dummy names n->q n2q bignum bignum to quad n>qv n2qv rahidden ( n.N -- qv ) counted int trunc/signed to quad ranum 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 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 n@sp nnposn hidden cells disp to indexed 'bignum' nsqrt nsqrt bignum ( n1 -- n2.N ) square root of a counted int nswap nswap forth swap blocks of n cells n-top pdovar bignum memtop for bignum to stg conversion ?null qnull forth abort-14 if 4th ptr is zero true address null? nullq hidden tf if 4th ptr is zero true address NUMBER anumber ans convert stg to double - ANS-mode number fnumber fig convert stg to double - f.i.g-mode number number forth vectored stg to double conversion >number tonumber forth convert stg to number till non-valid char (>number) utonum hidden xec. vec >number (number) unumber hidden xec. vec [>number] btonumb hidden dft >number [number] bnumberb fig f.i.g. mode stg to number conversion [number] abnumberb forth ANS mode stg to number conversion n->un n2un bignum modify bignum to unsigned #n!v pdoval rahidden max+1 for sing factorial calculations, dft=13 NX nx float ( n -- f1 ) n-th level FOR-loop index NX nx rational ( n -- f1 ) n-th level FOR-loop index @NX fnx float ( -- p ) ptr to n-th level FOR-loop ctrl data @NX fnx rational ( n -- p ) indext level ptr to FOR-loop ctrl. data nxor nxor forth binary XOR 2 groups of cells o- osub hidden ( o1 o2 -- o3 ) subtract 8-cells numbers o( ocommentp root comment until next ")" if stdout is console 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 o-cr odcr forth <lf> if stdout is console octal octal forth sto 8 to base ocurrent ocurrent hidden previous {current} (oerr) oerr hidden output opr. error code OF of ans begin true decision part in a CASE sequence off off forth sto 0 to ptr offset pdoval fig block disp by multiple of -re- {b/scr} (1) (ok) upokp hidden xec. vec [ok] bokb hidden dft ok on on forth sto -1 to ptr onegate onegate hidden ( o1 -- o2 ) negate eight-cells integer only only root minimal wordset open-dir opendirf linux open directory-file by supplied name open-file openf forth open a file by supplied name open-pipe opipe linux open a pipe, ret i/o channels or oor forth ( n1 n2 -- n3 ) bitwise OR sings or! ors forth ( n p -- ) or to cell in memory order order root display vocabulary names as in search order order? orderq root item no of stacked voc by ix, or -1 oswap oswap forth ( n1 n2 -- n1 n1 n2 ) ; over swap otty otty linux open stdin at tty out nout forth count of bytes sent after latest <eol> out-chan pdoval root channel number of output channel (outchp) poutchpp hidden chp of latest used output channel out-cons? outconsq forth tf if stdout is console out-id outid linux channel-id of output channel out-pty? outptyq linux tf if stdout is a pty device OVER fover floatop ( f1 f2 -- f1 f2 f1 ) 12.6.1.1600 12.6.1.1600 over over forth ( n1 n2 -- n1 n2 n1 ) copy @nos to tos over- overm forth over - over+ overp forth over + P eP editor put text to line [p] pdoval vt latest {paper} colour p! ps linux store 32bit item to port p@ pf linux fetch 32bit item from port pack pack forth byte to packed nib pad pad forth ptr to tmp. buffer in data-space /PAD spad environment size of {pad} buffer pad2 pad2 forth ptr to tmp. string-buffer in data-space pad-size padsize forth size of tmp. buffers in data-space (padsz) padsz hidden pads' and max+4 input stgs' sizes page ff forth ff page-size pagesize linux Linux kernel constant ?pairs qpairs forth abort if stacked compile-flags dont match paligned palignp linux page align to next multiple of page size paligned- palignm linux page align (truncate) paper vtpaper vt set background colour/vt-mode 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 (path) upath hidden ptr to PATH env. vari path+file pthfile linux find file in PATH, ret fully qualified path path-max pathmax linux max len of path string pause cpause system enable re-scheduling of jobs from @(pause) (pause) upause hidden xec vec after {wait4..} timeout [pause] bpauseb systm dft {pause} pc! pcs linux store 8bit item to port pc@ pcf linux fetch 8bit item from port (pchr) pchr hidden 4 bytes ranges of printing chars #pcol pdoval editor text to file, chars/line pc!s pcss linux store multiple 8bit items to port pc@s pcfs linux fetch multiple 8bit items from port perform perform forth execute from lfa pfa>lfa pfa2lfa hidden lfa from pfa pfax hpfax compiler h-flg, pc-rel xec vector @pfa, data-field(s) follow pi capi racons ( -- v ) pi, kreiszahl PICK fpick floatop ( f1... n1 -- f1 ) +/- pick float pick pick forth ( .xx. n -- .xx. xn ) fetch cell wrt tos -pick mpick forth ( nn ... n2 n1 m -- nn..n1..n2 ) ; store into stack pid@ pidf linux fetch own process id 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} plocto, c_plocto compiler ( -n -- ) cpl local "+to", plsto, c_plsto compiler ( n -- n ) prep add & drop @tos to "value" pop4th pop4th systm (R regs -- ) rst saved cpu-regs -re- {push4th} pop-io popio forth restore i/o from tor POSTPONE bcb ans delay execution pow2? pow2q forth tf if item is a power of 2 pread preadf linux read text at given fileptr precedes pdodefer utility { x1 x2 -- f ) {sort} relation PRECISION fprec float ( -- n ) -re- {fplaces} 12.6.2.2035 12.6.2.2035 prev prev fig screenfile blockbuffer currently in use [prev] pdoval blkfile ptr to most recently used block buffer prevdef prevdef root restore previous {current} previous previous root pop and discard context voc fron voc-stack 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 prog? progq hidden tf if ptr points to program space 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 #prow pdoval editor text to file, rows/page 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 push4th push4th systm (R -- regs ) save cpu regs used by L4 kernel push-io pushio forth save i/o to tor, assign local tib 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 (q.) pqdotp hidden ( q sgn fmt -- ) quad to string 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 qf double root next numeric input is quad rational num, double float 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. 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 qlit qlit hidden runtime qliteral qlit, c_qlit compiler ( q -- ) cpl quad literal 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 q->n q2n bignum ( q1 -- n1.N ) quad to bignum qnegate qnegate forth ( q1 -- q2 ) negate quad q>qv q2qv rahidden ( qn -- qv ) quad int signed to quad ranum 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 quad quad root fetch next numeric input as a quad integer >quad toquad rahidden ccc( -- q d f ) convert stg to quad number query query forth {accept} until <lf> quick quick utility sort datafield quit quit root outer interpreter, exit from loadfiles (quit) uquit hidden xec. vec [quit] bquitb hidden dft quit 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 qv.2/3pi cqv23pi racons ( -- qv ) quad pi*2/3 qv2dup qv2dup rahidden ( qv1 qv2 -- qv1 qv2 qv1 qv2 ) qv.2pi cqv2pi racons ( -- qv ) quad pi*2 qvabs qvabs rahidden ( qv1 -- qv2 ) negate if qv1 -ve qvcmp qvcmp rahidden ( qv1 qv2 -- qv1 qv2 n ) signum of diff. qv1-qv2 qv>d qv2dn rahidden ( qv -- dn ) quad ranum signed to double int qvdround qvdround rahidden ( qv1 +qn -- qv2 ) approx. qv1 to doubles' range qvdup qvdup rahidden ( qv -- qv qv ) duplicate quad ranum qv>dv qv2dv rational ( qv -- dv ) reduce quad, truncate, ret double ranum qv>fq qv2q rahidden ( qv -- qn ) quad ranum floored to quad int qvfrac qvfrac rahidden ( qv1 -- qv2 ) fractional component of qv1 qvinteger qvinteger rahidden ccc(C qv1 -- )(X -- qv ) quad ranum integer qvlit, c_qvlit compiler ( qv -- ) cpl quad ranum literal 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 ) 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 qvpick qvpick rahidden +/- pick quad ranum, re {8pick} qv>q qv2qn rahidden ( qv -- qn ) quad ranum signed to quad int qvrdv qvmdv racons ( -- qn ) quad int limit for qvround to range of double qvreduce qvreduce rahidden ( qv1 -- qv2 ) reduce quad ranum by g.c.d. qvroll qvroll rahidden +/- roll quad ranum, re {8roll} qvrot qvrot rahidden ( qv1 qv2 qv3 -- qv2 qv3 qv1 ) 2 qvroll qv-rot qvmrot rahidden ( qv1 qv2 qv3 -- qv3 qv1 qv2 ) -2 qvroll qvround qvround rahidden ( qv1 +qn -- qv2 ) approximation to qv1 -qvround mqvround rahidden ( qv1 +qn -- qv2 ) approx. qv1 to range of a double qv^s qvpows rahidden ( qv1 n -- qv2 ) qv1 to the power of a sing qv>s qv2n rahidden ( qv -- n ) quad ranum signed to single int qvsgn qvsgn rahidden ( qv1 -- n ) signum of a quad qvsover qvsover rahidden ( qv1 qv2 -- qv2 qv1 qv2 ) swap and over qvsplit qvsplit rahidden ( qv1 -- qv2 qv3 ) integral qv2 and fractional qv3 qvsqrt qvsqrt rahidden ( qv1 -- qv2 ) square root of a quad qvswap qvswap rahidden ( qv1 qv2 -- qv2 qv1 ) qv>uqv? qv2uqvq rahidden ( qv -- uqv f ) |qv| and sign flag qv>v qv2v rational ( qv -- v ) reduce quad, truncate, ret sing ranum R eR editor replace line from pad 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 storer hidden ( p -- )(R n -- ) ; r> swap ! .r dotr forth ( n1 n2 -- ) right aligned display signed sing n1 (r) prp hidden formatted output fill char(s) [r] pdoval vt latest reverse video state 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# unr editor uvari, chars count till cursor r#@ rnf editor { r# @ } get cursor count r+ rplus hidden fetch next cell from 2ndary subroutne level r+! rps forth ( n -- )(R n2 -- n3 ) add to @RS r0 r0 forth ptr to return-stack bottom RAD>DEG rad2deg float ( f1 -- f2 ) convert radians to sexagesimal degrees rad>deg rad2deg rational ( dv1 -- dv2 ) convert radians to sexagesimal degrees RANDOM frandom floatop ( f1 -- f2 ) random number in range [0,f1) random random utility; uu crea 0, {'random'}, random, utility ; randomize randomize utility; uu crea 0, {'randomize'}, randomize, utility ; range: rangec forth cpl a {range:} list rational rational root root-voc, real numbers rdpmc rdpmcf systm ( -- d ) read perfromance monitoring counters rdrop rdrop forth (R n -- ) ; r> drop rdump rdump tools dump again, same range read-char readchar forth read a char from channel read-file readf forth read file until buffer full or <eof> reading rding blkfile modify screenfile access to r/o read-line readl forth read file until <nl> or buffer full or <eof> readlink readlk linux read a linked files' source name readmc readmc forth ( p u u2 -- p' u' p1 u1 ) u2 chars(=bytes) from mem readm-c/l readmcl editor ( p u -- p' u' p1 u1 ) c/l chars(=bytes) from mem readml readml forth ( p u -- p' u' p1 u1 ) next line from mem real-user ruser root set process effective to real user id recurse recurse forth call the caller red pdoval vt colour value refill refill forth fill tib from input stream until <eof> relcur relcur vt curs addr wrt top left of scrolling region 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 REPRESENT frepresent float ( f1 p u -- n1 flg1 flg2 ) 12.6.1.2143 12.6.1.2143 represent frepresent rational ( dv p u -- n flg1 flg2 ) ranum normalized text repr. resb resb4 forth reset (clear) bit reset-palette rstpalette vt rst console colours assignations from dft 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 <ret> lretg assembler x86 op-code, ret ret, c_ret compiler ( disp -- ) return from suroutine call RETURNSTACK-CELLS rsc environment cells available for return-stack 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 r>m rtom forth return-stack bytes to mem #rmg pdoval editor editor screen & printing, right margin rmv-link rmvlink systm ( p1 p2 -- ) unlink p1 from list p2 r/o rbyof forth ( -- n ) file open mode modifier ro? roq blkfile query write protection mode r-ok rok forth ( -- n ) file access query modifier roll roll forth ( .xx. n -- .. xn ) roll cells root root root basic voc, essential words, linkage base root-wordlist rootwl hidden wid of {root} ROT frot floatop ( f1 f2 f3 -- f2 f3 f1 ) 12.6.1.1610 12.6.1.1610 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 rotd2s rotd2sf nonmmx 2 pick -rot, duplicate 3rd on tos 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 ROUND dvfround floatop ( f1 -- f2 ) round to #fround digits after dp row row vt get cursor row rows rows forth count of lines sent after latest {open} RP! arpstore ans ( p -- )(R -- ) rst returnstack-ptr to ptr rp! rpstore forth ( -- .xx. ) restore returnstack-ptr from uvari {r0} rp@ rpfetch forth fetch returnstack-ptr >rr torr forth ( n -- n ) copy sing to return-stack r>>r rxchg forth ( n1 -- n2 )(R n2 -- n1 ) ; r> swap >r rs rs root reset console to 'sane' state .rs dotrs tools display returnstack content [rs] dotrsi tools immediate {.rs}, displaying returnstack 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 rstty rstty linux reset stdin-console to initial state rswap rswap forth (R n1 n2 -- n2 n1 ) swap on returnstack rvoc rvoc root restore previous {context} r/w rbywf forth ( -- n ) file open mode modifier rw! rws blkfile aequivalent to f.i.g. { 0 r/w } rw? rwq forth ( c -- er ) whether a file is open in r/w mode rw@ rwf blkfile aequivalent to f.i.g. { 1 r/w } S eSe editor ins empty line s nsee tools 8 times {#see} ;s semis forth terminate an execution sequence .s dots forth dispay datastack content (s") psqtep hidden runtime sliteral [s] dotsi tools immediate {.s}, displaying datastack #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 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 scr scr forth 'screen' no. of current screenfile scr! scrs editor { scr ! } sto screen no. scr@ scrf editor { scr @ } fetch screen no. scr-chan pdoval forth no. of screenfile channel scrfpos scrfpos blkfile scr-chan file-ptr at scr@+r#@ S>D s2dn ans signed sing to double S>D ftodf floatop ( f1 -- df2 ) convert float to double size 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 s>dv s2dv rational ( n -- dv ) sing int signed to double ranum s>dvfactorial s2dvfac rational ( +n -- dv ) factorial of n se pdo2val vt normal intensity search search forth search for a string in memory search-file searchf forth search file for a string SEARCH-ORDER score environment wordset availabilty flag SEARCH-ORDER-EXT scorex environment wordset availabilty flag SEARCH-WORDLIST swlist ans find a name in given wordlist see see forth de-compiler #see hsee tools continue decompiling at @fld seed pdovar utility random, quad vari 'seed' selected selected forth ccc{ -- ) activate {words} selection (selected) pdodefer utility { .xx. -- .xx. ) {words} selection [selected] pdodefer utility { .xx. n lfa -- .xx. n lfa ) {words} setb setb4 forth set bit set-cal setcal hidden calibrate timer, find cpu clock rate set-chan setchan linux store channel description from data-stack set-current scurrent root store wid to {current} set-order sorder root store entire search order set-palette setpalette vt assign a colour value SET-PRECISION sprec float ( n -- ) 12.6.2.2200 12.6.2.2200 - { to #fplaces } setty setty linux prepare stdin console to single-key input set-vocflags svocflags hidden (re)store vocabulary-specific flags at voc-stack set-vocs setvocs root (re)store vocabulary ptrs at voc-stack sf sing root next numeric input is single rational num SF! sfstore float ( f1 p -- ) 12.6.2.2202 12.6.2.2202 SF@ sffetch float ( p -- f1 ) 12.6.2.2203 12.6.2.2203 SFALIGN sfalign ans ( -- ) 12.6.2.2204 12.6.2.2204 SFALIGNED sfaligned ans ( p1 -- p2 ) 12.6.2.2206 12.6.2.2206 SFLOAT+ sfloatp ans ( n1 -- n2 ) 12.6.2.2207 12.6.2.2207 SFLOATS sfloats ans ( n1 -- n2 ) mul8 12.6.2.2208 12.6.2.2208 sforget sforget hidden forget by supplied string and top ix sgb rsigb novoc exitting signals hnd sgn sgn forth ( n1 -- n2 ) sign of sing sgt rsigt novoc messaging/lib4th active signal hnd sh sh root xec a shell command sh| shp root xec shell cmd, pipe output to buf sh-argp pdovar systm shell command arguments ptr's shift shift forth ( n1 n2 -- n3 ) shift left <si> lsig vt ascii ctrl code (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 sign sign fig fig-variant, sign cell 3rd from tos SIGN asign forth sign cell on tos signo signo linux convert signal name to number signo? signoq linux display known signal names sigstg sigs linux convert signal number to name 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 sincos(dv) sincosdv rational ( dv1 -- dv2 dv3 ) sinus dv2, cosinus dv3 sincos(qv) sincosqv rahidden ( qv1 -- qv2 qv3 ) sinus qv2, cosinus qv3 sin(dv) sindv rational ( dv1 -- dv2 ) sinus SINH fsinh floatop ( f1 -- f2 ) hyperbelsinus, 12.6.2.1617 12.6.2.1617 sin(qv) sinqv rahidden ( qv1 -- qv2 ) sinus skip skip forth skip characters from stg 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 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 small? smallq rahidden ( dv -- f ) tf if "normal"izeable sm/rem smbyrem forth ( d1 n2 -- n3r n4q ) div round near zero smud hsmud compiler h-flg, sumudged ("find" disabled) smudge smudge fig toggle find-ability of latest word s>nfactorial s2nfac bignum ( n1 -- n2.N ) counted int factorial of a sing so pdo2val vt half-bright <so> lsog vt ascii ctrl code sort sort utility tag sort array sorted sorted utility tag sort array by relation name source source forth current input source descriptor (source) usource hidden xec.vec of {source}, dft [source] [source] bsourceb hidden dft xec vec for {source} source-chan sourcechan forth channel of current input source (source-id) psourceidp hidden saved source-id source-id sourceid forth input source flags sover sover forth ( n1 n2 -- n2 n1 n2 ) ; swap over (a 'tuck') (sp!) ustosp hidden xec. vec sp> fspstore forth ( .xx. -- ) clr data-stack SP! aspstore ans ( p -- ) set datastack-ptr to kref'd supplied value sp! fspstore fig ( -- .xx. ) rst datastack-ptr from uvari {r0} sp! spstore forth ( .. -- .. ) vectored to fig or ans mode, dft fig sp@ spfetch forth fetch datastack-ptr 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 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 SQRT fsqrtf floatop ( f1 -- f2 ) 12.6.2.1618 12.6.2.1618 [squit] bsquitb hidden dft quit entry after segfault s>qv s2qv rational ( n -- qv ) sing int signed to quad ranum srd psortedp novoc by {sorted} compiled runtime srot srot forth ( n1 n2 n3 -- n3 n2 n1 ) ; swap rot ss ss4 root for #!-execution after exec. name sslice sslice forth string slice by enclosing strings (sstop) sstop hidden base job true addr of .bss top ?stack qstack forth abort if data-stack out of bounds STACK-CELLS sss environment cells available for data-stack state state forth compiler/interpreter flags state@ statef forth whether interpreting(0) or compiling(=/= 0) static? staticq systm tf if prog statically linked stat-size statsize linux size in bytes of file-status required buffer 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. STEP step float ( f1 -- ) set FOR-loop increment STEP step rational ( f1 -- ) modify FOR-loop increment (step) pstepp novoc runtime ranum {STEP} stg stg4 forth defines a string value stg>qv todfloat rational convert stg to quad ranum, i.e. double "float" (stimo) ustimo hidden wait4.. timeout value sto, c_sto compiler ( n -- n ) prep sto & drop @tos to "value" STRING gcore environment wordset availabilty flag string stng forth cpl by supplied char delimited stg /string sstring forth adjust stg parameters stty-s sttys linux simulates Linux cmd 'stty sane' <sub> lsubg vt ascii ctrl code substitute substitute forth substitute text from -re- {:slist}s s>upper s2upper forth convert stg to upper-case s>v s2v rational ( n -- v ) signed sing to vulgar s>vfactorial s2vfac rational ( +n -- v ) factorial of n s->w s2wn forth signed sing to word SWAP fswap floatop ( f1 f2 -- f2 f1 ) 12.6.1.1620 12.6.1.1620 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 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 system systm root root-voc, hardware specific szlit, szlitc forth allot & store <nul>-terminated stg in data-space szliteral szliteral forth cpl supplied <nul>-terminated stg T eT editor type and copy line to pad tab tab forth emit a <tab> char, adjust @out (#tab) pntabp hidden tab spacing tab-to tabto forth set cursor column, not less current posn (tail) ptailp hidden cpl tail-ptr 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 task task forth traditionally the forth kernel top word... (tattr) utattr hidden modified console attributes (tattr-s) ustattr hidden saved console attributes tdump tdump tools dump, don't store ptrs term eterm linux TERM env vari ?terminal qterminal forth ( -- n ) basic keyboard input query from stdin (?terminal) uqterminal hidden xec. vec ?terminal testvoc testvoc hidden hidden-voc, (praeliminary tests) text text editor fetch by char delimited text to pad -text mtext editor find text in stg tg(dv) tgdv rational ( dv1 -- dv2 ) tangens tg(qv) tgqv rahidden ( qv1 -- qv2 ) tangens THEN endif ans terminate IF/ELSE sequence [THEN] bthenb root terminate conditional input sequence [if]... 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) pntibp hidden #tib storage (tib) ptibp hidden ptr to terminal input buffer (t.i.b.) #tib ntib forth ( -- n ) no. of chars fetched to tib tib>dft tib2dft root reset t.i.b. to default location 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. ti-cal tical forth measured cpu clock rate tick tic root get current cpu clock count (tick) ptickp hidden cpu-clocks per second tick>s tic2s forth convert cpu clock count to seconds TILL till editor erase till text end 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 timezone tz4 linux 'timezone' figure from <gettimeofday> "timezone stz4 linux stg w. numeric 'timezone' to tov forth store sing to alterable cons +to pltov forth add @tos to a value to-chan tochan forth copy a channel description to-col tocol vt set cursor column toggle toggle fig ( p c -- ) xor byte in memory - fig, reversed opr TOOLS tcore environment wordset availabilty flag tools tools forth forth-voc, debugging TOOLS-EXT tcorex environment wordset availabilty flag TOP etop editor cursor to top left <top> utop hidden top address of user-vari space - don't read,store! (top) mtop hidden global true addr of .bss top top-mblock topmblock forth allocate data-space, extends into .bss section to-row torow vt set cursor row tospull, c_tospull compiler ( -- ) TOSPULL(1), dec PS by one cell tospush, c_tospush compiler ( -- ) TOSPUSH(1), inc PS by one cell +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 trn trnf linux file access modifier to truncate after open true pone fig cons 1 true true forth cons -1 [TRUE] true ans immediate cons -1 true= ftequ fig ( n -- f ) tf if cell is f.i.g.-mode 'true' value true= tequ forth ( n -- f ) tf if cell is ANS-mode 'true' value TRUNCATE truncate editor set size of screenfile truncation pdoval rational suppress trailing zeroes if non-zero(dft) ts ts novoc {to-stg} runtime t+s tps novoc {+to-stg} runtime tstb tstb forth test bit TUCK sover ans ( n1 n2 -- n2 n1 n2 ) ; swap over type type forth send a string (type) utype hidden xec. vec [type] pdodefer hidden deferred, string to stdout 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 uc-map uclm linux map keyboard input to lower chars ucopy usercopy hidden copy user-vari from owner to cloned job uc-unmap uclu linux do not map keyboard input to lower chars U>D u2dn ans sing to unsigned double 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>n? ud2nq rahidden ( ud -- +n f ) tf if ud not in range of +ve sing (ud.r) puddotrp hidden stg to right aligned display an unsigned double ud.r uddotr forth unsigned right aligned display a double uds>idx uds2idx hidden index from compiled disp to uot-ptr udsqrt udsqrt forth ( d1 -- d2 n ) +ve double square root, sing 'j'-flag udsqrt fudsqrt nonmmx +ve double square root of double, sing 'j'-flag ue pdo2val vt underline off uid! uids linux set process user id uid@ uidf linux fetch process user id (ulink) plinkp hidden uvari link 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 umask umaskf linux globally set new files default access mode umask? umaskq linux read file creation permissions mask 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 (un.) pundotp bignum convert unsigned counted int to stg un. undot bignum ( .n1.N -- ) send unsigned numeric bignum stg to stdout unlock-file unlockf linux unlock file from preventing write access UNLOOP unloop ans at runtime discard loop control data (unloop) rdrop2 hidden runtime unloop unpack unpack forth packed nib to byte 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 unsmudge unsmudge root enable finding of latest word until until forth REPEAT if @tos = 0 else leave BEGIN structure un->un untoun bignum ( n1.N M -- n2.M ) unsigned extend counted int unused unused forth ( -- n ) free space in data-memory (uot) ultab hidden "user offset table" 4th words' true xec addr. uot>idx uot2idx hidden index from uot-ptr up up forth ptr to next available user vari up+ upplus forth add disp to ptr to uservari-space [upd] bupdb hidden dft opr for {update} update pdodefer forth mark buffer to save before re-useage update? updateq blkfile flag whether blk -re- {update}d update-off updateoff blkfile clear screenfile buffer update flag 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 us pdo2val vt underscore use use fig least recently used screenfile blockbuffer [use] pdoval blkfile ptr to block buffer to use next using using forth screenfile for {load} opr. util utility forth forth-voc, forth utiliy words utod, c_utod compiler ( disp -- ) mov eax,[uref (disp)] utosa, c_utosa compiler ( disp -- ) add eax,[uref (disp)], add uvari uv@ uvfetch forth fetch uvari by disp uwithin? uwithinq forth unsigned test & adjust 3rd w/ range of 2nd..1st v vau root display which wordlist a word is in <#v#> ltvgt rahidden ( v -- p u ) convert v to rational num stg #v sharpv rational ( +v -- 0 0 ) app stg to num output buf, for v. v~ 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 val+ valp forth alterable increment by a.u. valu, c_valu compiler ( n -- ) cpl "value"; spush, mov eax,[kref dword n] value value forth alterable 'constant' varf hvarf compiler h-flg, vari, 2nd header-field disp to dataspace VARIABLE fvari floatop ccc( -- p ) 12.6.1.1630 12.6.1.1630 variable variable forth uninitiated (set to 0) variable (vbot) vbot hidden end of user area vcells+ cellsvp forth alterable increment by cells vconstant vconstant rational ( -- v ) non-alterable constant vdigits> vdigitsgt rahidden ( -- un ) largest num w/ no. {digits} digits vdrop vdrop rational ( v1 -- v1 v1 ) vdup vdup rational ( v1 -- v1 v1 ) v>dv v2dv rational ( v1 -- dv2 ) expand sing v1 to double dv2 vers vers root 4 bytes numeric library version version version root display l4-version --version sversion root library version <#vf#> ltvfgt rahidden ( v -- p u ) convert v to floating pt num stg #vf sharpvf rational ( +v -- 0 0 ) app stg to num output buf, for f. vfrac vfrac rational ( v1 -- +v2 ) fractional component of v1 vinteger vinteger rational ( -- v ) constant, alterable before being cpl'd v.j vdotj rational ( left right v -- ) justified disp. ranum (vl pdoval novoc fetch a kernel-def'd value vlist vlist forth sequentially list context vocabulary 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 voc. vocdot utility by lfa display which wordlist a word is in vocabulary vocabulary forth define a vocabulary by name vocf hvocf compiler h-flg, word is a vocabulary voc-link voclink forth wordlists and vocabularies link-ptr vocs vocs root display all def'd voc-names #vocs nvocs forth max no. of items in voc-stack vover vover rational ( v1 v2 -- v1 v2 v1 ) voverflow voverflow rational ( v -- f ) tf if v was overflow indicator value vovf vovf racons ( -- v ) sing overflow indicator (vpal) uvpalette hidden initial console colours storage vpick vpick rational ( ... n -- ... vn ) v>qv v2qv rational ( v1 -- qv2 ) expand sing v1 to quad qv2 (vr pdovar novoc fetch a kernel-def'd vari 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 ) vt vt forth forth-voc, vt..-control <vt> lvtg vt ascii ctrl code ?vt qvt forth query terminal type 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 (vtim) uiovtim hidden keyboard input timeout, "VTIME" & "VMAX" values !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 v>uv? v2uvq rahidden ( v -- +v f ) |v| and sign flag vvariable vvariable rational ( -- p ) 'ranum' (i.e. double) variable 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 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 wcas hwcas compiler h-flg, search letter-case dependently, only w-close wclose forth close the work-channel wdw-lk pdovar hidden double linkage of window defn's where where root show error source, afte cpl error which which tools display path+file if in L4 path WHILE whilea ans if @tos = 0 leave BEGIN structure while while forth if @tos = 0 leave BEGIN structure white pdoval vt colour value wid>idx wid2idx hidden wordlist id to index wid>lfa wid2lfa hidden word-lfa from voc-link posn width width forth max count of a 4th name -n.i.- wid>top wid2top hidden ptr to top header in voc from voc-link posn <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 fig fetch text enclosed by supplied char to {here} word XWORD forth fetch text enclosed by supplied char, ret ptr wordlist wordlist forth define a 'wordlist' WORDLIST? wordlq ans item no of stacked wordlist by wid, or -1 words words forth sorted list context vocabulary work workc forth work-channel no. (for file opr's) work-chan pdoval linux default {work} channel no. work-id workid linux work-channel identifier work-num worknum linux actual {work} no. write-char writechar forth write (multi-byte) char to channel WRITE-FILE awritefile ans write no. of bytes from buffer to file, ans-mode write-file writefile forth write no. of bytes from buffer to file write-line writeline forth write send string to file & append <lf> code w->s w2sn forth l.s.word to sing wswap wswap forth ( n1 -- n2 ) swap hi & lo half of cell @tos wvoc wvoc utility vocabulary link by lfa of a word wvoc-r wvocr utility 2ndary vocabulary link by lfa of a word wzo writezo novoc send asciz-string X eX editor delete text xcall, c_xcall compiler ( disp -- ) call [uref uv.ultab+(disp)] xcalla, c_xcalla compiler ( -- ) call [uref 4*reg+uv.ultab] xec? xecq forth ( n -- a f ) xec-addr from ix/ptr 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 xg-chan xgchan forth exchange two channel descriptions xg-io xgio linux exchange stdin and stdout channel descriptions x-io xio root exchange stdin,stdout,stderr w. in-chan &c. xjmp, c_xjmp compiler ( disp -- ) jmp [uref uv.ultab+(disp)] xlock xlock systm exec word w. int's locked 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 xtos, c_xtos compiler ( disp -- ) mov eax,[uref uv.ultab+(disp) xwfl hxwfl compiler h-flg, count of parameter fields, no-exec flag xy xy forth fetch cursor posn Y eY editor insert stg yellow pdoval vt colour value z" zqte forth <nul>-terminated stg literal zcount zcount forth ( p1 -- p2 u ) {count} wrt <nul>-terminated stg -zeroes mzeroes rational ( p u -- p u' ) trucate trailing zeroes zprint zprint forth display <nul> terminated stg
by [ name | topic | voc ] [ glos | files | xref ] [ notation | dpans94 | syscalls ] [ bot | top ]