pfe-core-ext
Prev? | pfe Forth Wordset List | ?Next

## Name

pfe-core-ext ? Core words + extensions

## Synopsis

`! ( value some-cell* -- | value addr* -- [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`# ( n,n -- n,n' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`#> ( n,n -- hold-str-ptr hold-str-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`#S ( n,n -- 0,0 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`( ( 'comment&lt;closeparen&gt;' -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`* ( a# b# -- mul-a#' | a b -- mul-a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`*/ ( a# b# c# -- scale-a#' | a b c -- scale-a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`*/MOD ( a# b# c# -- div-a# mod-a# | a b c -- div-a mod-a [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`+ ( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a b -- a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`+! ( value# some-cell* -- | value some* -- [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`+LOOP ( increment# R: some,loop -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`, ( value* -- | value# -- | value -- [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`- ( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a* b* -- diff-b#' | a b -- a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`. ( value# -- | value* -- [?] | value -- [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`." ( [string&lt;"&gt;] -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`/ ( a# b# -- a#' | a b -- a' [???] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`/MOD ( a# b# -- div-a#' mod-a#' | a b -- div-a' mod-a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`0< ( value -- test-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`0= ( 0 -- test-flag! | value! -- 0 | value -- test-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`1+ ( value -- value' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`1- ( value -- value' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2! ( x,x variable* -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2* ( a# -- a#' | a -- a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2/ ( a# -- a#' | a -- a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2@ ( variable* -- x,x ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2DROP ( a b -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2DUP ( a,a -- a,a a,a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2OVER ( a,a b,b -- a,a b,b a,a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2SWAP ( a,a b,b -- b,b a,a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`; ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`< ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`<# ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`= ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`> ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`>BODY ( some-xt* -- some-body* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`>NUMBER ( a,a str-ptr str-len -- a,a' str-ptr' str-len) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`>R ( value -- R: value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`?DUP ( 0 -- 0 | value! -- value! value! | value -- 0 | value! value! ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`@ ( value* -- value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ABS ( value# -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ACCEPT ( buffer-ptr buffer-max -- buffer-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ALIGN ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ALIGNED ( addr -- addr' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ALLOT ( allot-count -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`AND ( value mask -- value' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`BEGIN ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`C! ( value# variable#* -- | value# variable* [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`C, ( value# -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`C@ ( value#* -- value# | value* -- value# [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CELL+ ( value -- value' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CELLS ( value# -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CHAR ( 'word' -- char# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CHAR+ ( value -- value' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CHARS ( value# -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`COUNT ( string-bstr* -- string-ptr' string-len | some* -- some*' some-len [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CR ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DECIMAL ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DEPTH ( -- depth# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DO ( end# start# | end* start* -- R: some,loop ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DOES> ( -- does* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DROP ( a -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`DUP ( a -- a a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ELSE ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`EMIT ( char# -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ENVIRONMENT? ( name-ptr name-len -- 0 | ?? name-flag! ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`EVALUATE ( str-ptr str-len -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`EXECUTE ( some-xt* -- ??? ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`EXIT ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`FILL ( mem-ptr mem-len char# -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`FIND ( name-bstr* -- name-bstr* 0 | name-xt* -1|1 ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`FM/MOD ( n1,n1# n2# -- div-n1# mod-n1# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`HERE ( -- here* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`HOLD ( char# -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`I ( R: some,loop -- S: i# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`IF ( value -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`IMMEDIATE ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`INVERT ( value# -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`J ( R: some,loop -- S: j# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`KEY ( -- char# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`LEAVE ( R: some,loop -- R: some,loop ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`LITERAL ( C: value -- S: value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`LOOP ( R: some,loop -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`LSHIFT ( value# shift-count -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`M* ( a# b# -- a,a#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`MAX ( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`MIN ( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`MOD ( a# b# -- mod-a# | a b# -- mod-a# [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`MOVE ( from-ptr to-ptr move-len -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`NEGATE ( value# -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`OR ( a b# -- a' | a# b -- b' | a b -- a' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`OVER ( a b -- a b a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`POSTPONE ( [word] -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`QUIT ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`R> ( R: a -- a R: ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`R@ ( R: a -- a R: a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`RECURSE ( ? -- ? ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`REPEAT ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ROT ( a b c -- b c a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`RSHIFT ( value# shift-count# -- value#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`S" ( [string&lt;"&gt;] -- string-ptr string-len) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`S>D ( a# -- a,a#' | a -- a,a#' [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SIGN ( a# -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SM/REM ( a,a# b# -- div-a# rem-a# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SOURCE ( -- buffer* IN-offset# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SPACE ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SPACES ( space-count -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SWAP ( a b -- b a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`THEN ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`TYPE ( string-ptr string-len -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`U. ( value# -- | value -- [?] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`U< ( a b -- test-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`UM* ( a# b# -- a,a#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`UM/MOD ( a,a# b# -- div-a#' mod-a#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`UNLOOP ( R: some,loop -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`UNTIL ( test-flag -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`WHILE ( test-flag -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`WORD ( delimiter-char# -- here* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`XOR ( a# b# -- a#' ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`[ ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`['] ( [name] -- name-xt* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`[CHAR] ( [word] -- char# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`] ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`.( ( [message&lt;closeparen&gt;] -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`.R ( value# precision# -- | value precision# -- [??] ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`0<> ( 0 -- 0 | value! -- value-flag! | value -- value-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`0> ( 0 -- 0 | value! -- value-flag! | value -- value-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2>R ( a,a -- R: a,a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2R> ( R: a,a -- a,a R: ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`2R@ ( R: a,a -- a,a R: a,a ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`<> ( a b -- a-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`?DO ( end# start# | end* start* -- R: some,loop ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`AGAIN ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`C" ( [string&lt;"&gt;] -- string-bstr* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CASE ( value -- value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`COMPILE, ( some-xt* -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CONVERT ( a,a# string-bstr* -- a,a# a-len# ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ENDCASE ( value -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ENDOF ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ERASE ( buffer-ptr buffer-len -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`EXPECT ( str-ptr str-len -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`HEX ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`NIP ( a b -- b ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`OF ( value test -- value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`PAD ( -- pad* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`PARSE ( delim-char# -- buffer-ptr buffer-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`PICK ( value ...[n-1] n -- value ...[n-1] value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`QUERY ( -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`REFILL ( -- refill-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`RESTORE-INPUT ( input...[input-len] input-len -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`ROLL ( value ...[n-1] n -- ...[n-1] value ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`SAVE-INPUT ( -- input...[input-len] input-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`TO ( value [name] -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`TUCK ( a b -- b a b ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`U.R ( value# precision# -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`U> ( a b -- a-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`UNUSED ( -- unused-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`WITHIN ( a# b# c# -- a-flag | a* b* c* -- a-flag ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`[COMPILE] ( [word] -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`\ ( [comment&lt;eol&gt;] -- ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`PARSE-WORD ( "chars" -- buffer-ptr buffer-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`PARSE-NAME ( "chars" -- buffer-ptr buffer-len ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`CFA' ( 'name' -- name-xt* ) ?=>? (` | `)`; | ?

`"[ANS] FORTH"`;
?

`STACK-CELLS ?=>? (` | `)`; | ?

`"ENVIRONMENT"`;
?

`RETURN-STACK-CELLS ?=>? (` | `)`; | ?

`"ENVIRONMENT"`;
?

## Description

! ( value some-cell* -- | value addr* -- [?] ) [ANS] => "[ANS] FORTH"

store value at addr (sizeof `CELL`)

# ( n,n -- n,n' ) [ANS] => "[ANS] FORTH"

see also `HOLD` for old-style forth-formatting words and `PRINTF` of the C-style formatting - this word divides the argument by `BASE` and add it to the picture space - it should be used inside of `<#` and `#>`

#> ( n,n -- hold-str-ptr hold-str-len ) [ANS] => "[ANS] FORTH"

see also `HOLD` for old-style forth-formatting words and `PRINTF` of the C-style formatting - this word drops the argument and returns the picture space buffer

#S ( n,n -- 0,0 ) [ANS] => "[ANS] FORTH"

see also `HOLD` for old-style forth-formatting words and `PRINTF` of the C-style formatting - this word does repeat the word `#` for a number of times, until the argument becomes zero. Hence the result is always null - it should be used inside of `<#` and `#>`

( ( 'comment&lt;closeparen&gt;' -- ) [ANS] => "[ANS] FORTH"

eat everything up to the next closing paren - treat it as a comment.

* ( a# b# -- mul-a#' | a b -- mul-a' [??] ) [ANS] => "[ANS] FORTH"

return the multiply of the two args

*/ ( a# b# c# -- scale-a#' | a b c -- scale-a' [??] ) [ANS] => "[ANS] FORTH"

regard the b/c as element Q - this word has an advantage over the sequence of `*` and `/` by using an intermediate double-cell value

*/MOD ( a# b# c# -- div-a# mod-a# | a b c -- div-a mod-a [??] ) [ANS] => "[ANS] FORTH"

has an adavantage over the sequence of `*` and `/MOD` by using an intermediate double-cell value.

+ ( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a b -- a' [??] ) [ANS] => "[ANS] FORTH"

return the sum of the two args

+! ( value# some-cell* -- | value some* -- [?] ) [ANS] => "[ANS] FORTH"

add val to the value found in addr

      simulate:
        : +! TUCK @ + SWAP ! ;

+LOOP ( increment# R: some,loop -- ) [ANS] => "[ANS] FORTH"

compile `((+LOOP))` which will use the increment as the loop-offset instead of just 1. See the `DO` and `LOOP` construct.

, ( value* -- | value# -- | value -- [?] ) [ANS] => "[ANS] FORTH"

store the value in the dictionary

      simulate:
        : , DP  1 CELLS DP +!  ! ;

- ( a* b# -- a*' | a# b* -- b*' | a# b# -- a#' | a* b* -- diff-b#' | a b -- a' [??] ) [ANS] => "[ANS] FORTH"

return the difference of the two arguments

. ( value# -- | value* -- [?] | value -- [??] ) [ANS] => "[ANS] FORTH"

print the numerical value to stdout - uses `BASE`

." ( [string&lt;"&gt;] -- ) [ANS] => "[ANS] FORTH"

print the string to stdout

/ ( a# b# -- a#' | a b -- a' [???] ) [ANS] => "[ANS] FORTH"

return the quotient of the two arguments

/MOD ( a# b# -- div-a#' mod-a#' | a b -- div-a' mod-a' [??] ) [ANS] => "[ANS] FORTH"

divide a and b and return both quotient n and remainder m

0< ( value -- test-flag ) [ANS] => "[ANS] FORTH"

return a flag that is true if val is lower than zero

      simulate:
       : 0&lt; 0 &lt; ;

0= ( 0 -- test-flag! | value! -- 0 | value -- test-flag ) [ANS] => "[ANS] FORTH"

return a flag that is true if val is just zero

      simulate:
       : 0= 0 = ;

1+ ( value -- value' ) [ANS] => "[ANS] FORTH"

return the value incremented by one

      simulate:
       : 1+ 1 + ;

1- ( value -- value' ) [ANS] => "[ANS] FORTH"

return the value decremented by one

      simulate:
        : 1- 1 - ;

2! ( x,x variable* -- ) [ANS] => "[ANS] FORTH"

double-cell store

2* ( a# -- a#' | a -- a' [??] ) [ANS] => "[ANS] FORTH"

multiplies the value with two - but it does actually use a shift1 to be faster

      simulate:
       : 2* 2 * ; ( canonic) : 2* 1 LSHIFT ; ( usual)

2/ ( a# -- a#' | a -- a' [??] ) [ANS] => "[ANS] FORTH"

divides the value by two - but it does actually use a shift1 to be faster

      simulate:
       : 2/ 2 / ; ( canonic) : 2/ 1 RSHIFT ; ( usual)

2@ ( variable* -- x,x ) [ANS] => "[ANS] FORTH"

double-cell fetch

2DROP ( a b -- ) [ANS] => "[ANS] FORTH"

double-cell drop, also used to drop two items

2DUP ( a,a -- a,a a,a ) [ANS] => "[ANS] FORTH"

double-cell duplication, also used to duplicate two items

      simulate:
        : 2DUP OVER OVER ; ( wrong would be : 2DUP DUP DUP ; !!)

2OVER ( a,a b,b -- a,a b,b a,a ) [ANS] => "[ANS] FORTH"

double-cell over, see `OVER` and `2DUP`

      simulate:
        : 2OVER SP@ 2 CELLS + 2@ ;

2SWAP ( a,a b,b -- b,b a,a ) [ANS] => "[ANS] FORTH"

double-cell swap, see `SWAP` and `2DUP`

      simulate:
        : 2SWAP LOCALS| B1 B2 A1 A2 | B2 B1 A2 A1 ;

; ( -- ) [ANS] [EXIT] [END] => "[ANS] FORTH"

compiles `((;))` which does `EXIT` the current colon-definition. It does then end compile-mode and returns to execute-mode. See `:` and `:NONAME`

< ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) [ANS] => "[ANS] FORTH"

return a flag telling if a is lower than b

<# ( -- ) [ANS] => "[ANS] FORTH"

see also `HOLD` for old-style forth-formatting words and `PRINTF` of the C-style formatting - this word does initialize the pictured numeric output space.

= ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) [ANS] => "[ANS] FORTH"

return a flag telling if a is equal to b

> ( a* b* -- test-flag | a# b# -- test-flag | a b -- test-flag [?] ) [ANS] => "[ANS] FORTH"

return a flag telling if a is greater than b

>BODY ( some-xt* -- some-body* ) [ANS] => "[ANS] FORTH"

adjust the execution-token (ie. the CFA) to point to the parameter field (ie. the PFA) of a word. this is not a constant operation - most words have their parameters at "1 CELLS +" but CREATE/DOES-words have the parameters at "2 CELLS +" and ROM/USER words go indirect with a rom'ed offset i.e. "CELL + @ UP +"

>NUMBER ( a,a str-ptr str-len -- a,a' str-ptr' str-len) [ANS] => "[ANS] FORTH"

try to convert a string into a number, and place that number at a,a respeciting `BASE`

>R ( value -- R: value ) [ANS] => "[ANS] FORTH"

save the value onto the return stack. The return stack must be returned back to clean state before an exit and you should note that the return-stack is also touched by the `DO` ... `WHILE` loop. Use `R>` to clean the stack and `R@` to get the last value put by `>R`

?DUP ( 0 -- 0 | value! -- value! value! | value -- 0 | value! value! ) [ANS] => "[ANS] FORTH"

one of the rare words whose stack-change is condition-dependet. This word will duplicate the value only if it is not zero. The usual place to use it is directly before a control-word that can go to different places where we can spare an extra `DROP` on the is-null-part. This makes the code faster and often a little easier to read.

      example:
        : XX BEGIN ?DUP WHILE DUP . 2/ REPEAT ; instead of
        : XX BEGIN DUP WHILE DUP . 2/ REPEAT DROP ;

@ ( value* -- value ) [ANS] => "[ANS] FORTH"

fetch the value from the variables address

ABS ( value# -- value#' ) [ANS] => "[ANS] FORTH"

return the absolute value

ACCEPT ( buffer-ptr buffer-max -- buffer-len ) [ANS] => "[ANS] FORTH"

get a string from terminal into the named input buffer, returns the number of bytes being stored in the buffer. May provide line-editing functions.

ALIGN ( -- ) [ANS] => "[ANS] FORTH"

will make the dictionary aligned, usually to a cell-boundary, see `ALIGNED`

ALIGNED ( addr -- addr' ) [ANS] => "[ANS] FORTH"

uses the value (being usually a dictionary-address) and increment it to the required alignment for the dictionary which is usually in `CELLS` - see also `ALIGN`

ALLOT ( allot-count -- ) [ANS] => "[ANS] FORTH"

make room in the dictionary - usually called after a `CREATE` word like `VARIABLE` or `VALUE` to make for an array of variables. Does not initialize the space allocated from the dictionary-heap. The count is in bytes - use `CELLS` ALLOT to allocate a field of cells.

AND ( value mask -- value' ) [ANS] => "[ANS] FORTH"

mask with a bitwise and - be careful when applying it to logical values.

BEGIN ( -- ) [ANS] [LOOP] => "[ANS] FORTH"

start a control-loop, see `WHILE` and `REPEAT`

C! ( value# variable#* -- | value# variable* [?] ) [ANS] => "[ANS] FORTH"

store the byte-value at address, see => !

C, ( value# -- ) [ANS] => "[ANS] FORTH"

store a new byte-value in the dictionary, implicit 1 ALLOT, see => ,

C@ ( value#* -- value# | value* -- value# [?] ) [ANS] => "[ANS] FORTH"

fetch a byte-value from the address, see `@`

CELL+ ( value -- value' ) [ANS] => "[ANS] FORTH"

adjust the value by adding a single Cell's width - the value is often an address or offset, see `CELLS`

CELLS ( value# -- value#' ) [ANS] => "[ANS] FORTH"

scale the value by the sizeof a Cell the value is then often applied to an address or fed into `ALLOT`

CHAR ( 'word' -- char# ) [ANS] => "[ANS] FORTH"

return the (ascii-)value of the following word's first character.

CHAR+ ( value -- value' ) [ANS] => "[ANS] FORTH"

increment the value by the sizeof one char - the value is often a pointer or an offset, see `CHARS`

CHARS ( value# -- value#' ) [ANS] => "[ANS] FORTH"

scale the value by the sizeof a char - the value is then often applied to an address or fed into `ALLOT` (did you expect that sizeof(p4char) may actually yield 2 bytes?)

COUNT ( string-bstr* -- string-ptr' string-len | some* -- some*' some-len [?] ) [ANS] => "[ANS] FORTH"

usually before calling `TYPE`

(as an unwarranted extension, this word does try to be idempotent).

CR ( -- ) [ANS] => "[ANS] FORTH"

print a carriage-return/new-line on stdout

DECIMAL ( -- ) [ANS] => "[ANS] FORTH"

set the `BASE` to 10

      simulate:
        : DECIMAL 10 BASE ! ;

DEPTH ( -- depth# ) [ANS] => "[ANS] FORTH"

return the depth of the parameter stack before the call, see `SP@` - the return-value is in `CELLS`

DO ( end# start# | end* start* -- R: some,loop ) [ANS] [LOOP] => "[ANS] FORTH"

pushes $end and $start onto the return-stack ( `>R` ) and starts a control-loop that ends with `LOOP` or `+LOOP` and may get a break-out with `LEAVE` . The loop-variable can be accessed with `I`

DOES> ( -- does* ) [ANS] [END] [NEW] => "[ANS] FORTH"

does twist the last `CREATE` word to carry the `(DOES>)` runtime. That way, using the word will execute the code-piece following `DOES>` where the pfa of the word is already on stack. (note: FIG option will leave pfa+cell since does-rt is stored in pfa)

DROP ( a -- ) [ANS] => "[ANS] FORTH"

just drop the word on the top of stack, see `DUP`

DUP ( a -- a a ) [ANS] => "[ANS] FORTH"

duplicate the cell on top of the stack - so the two topmost cells have the same value (they are equal w.r.t `=` ) , see `DROP` for the inverse

ELSE ( -- ) [HIDDEN] => "[ANS] FORTH"

will compile an `((ELSE))` `BRANCH` that performs an unconditional jump to the next `THEN` - and it resolves an `IF` for the non-true case

EMIT ( char# -- ) [ANS] => "[ANS] FORTH"

print the char-value on stack to stdout

ENVIRONMENT? ( name-ptr name-len -- 0 | ?? name-flag! ) [ANS] => "[ANS] FORTH"

check the environment for a property, usually a condition like questioning the existance of specified wordset, but it can also return some implementation properties like "WORDLISTS" (the length of the search-order) or "#LOCALS" (the maximum number of locals)

Here it implements the environment queries as a `SEARCH-WORDLIST` in a user-visible vocabulary called `ENVIRONMENT`

      : ENVIRONMENT?
        ['] ENVIRONMENT &gt;WORDLIST SEARCH-WORDLIST
        IF  EXECUTE TRUE ELSE  FALSE THEN ;

EVALUATE ( str-ptr str-len -- ) [ANS] => "[ANS] FORTH"

`INTERPRET` the given string, `SOURCE` id is -1 during that time.

EXECUTE ( some-xt* -- ??? ) [ANS] => "[ANS] FORTH"

run the execution-token on stack - this will usually trap if it was null for some reason, see `>EXECUTE`

      simulate:
       : EXECUTE &gt;R EXIT ;

EXIT ( -- ) [ANS] [EXIT] => "[ANS] FORTH"

will unnest the current colon-word so it will actually return the word calling it. This can be found in the middle of a colon-sequence between `:` and `;`

FILL ( mem-ptr mem-len char# -- ) [ANS] => "[ANS] FORTH"

fill a memory area with the given char, does now simply call p4_memset()

FIND ( name-bstr* -- name-bstr* 0 | name-xt* -1|1 ) [ANS] => "[ANS] FORTH"

looks into the current search-order and tries to find the name string as the name of a word. Returns its execution-token or the original-bstring if not found, along with a flag-like value that is zero if nothing could be found. Otherwise it will be 1 (a positive value) if the word had been immediate, -1 otherwise (a negative value).

FM/MOD ( n1,n1# n2# -- div-n1# mod-n1# ) [ANS] => "[ANS] FORTH"

divide the double-cell value n1 by n2 and return both (floored) quotient n and remainder m

HERE ( -- here* ) [ANS] => "[ANS] FORTH"

used with `WORD` and many compiling words

      simulate:   : HERE DP @ ;

HOLD ( char# -- ) [ANS] => "[ANS] FORTH"

the old-style forth-formatting system -- this word adds a char to the picutred output string.

I ( R: some,loop -- S: i# ) [ANS] => "[ANS] FORTH"

returns the index-value of the innermost `DO` .. `LOOP`

IF ( value -- ) [ANS] => "[ANS] FORTH"

checks the value on the stack (at run-time, not compile-time) and if true executes the code-piece between `IF` and the next `ELSE` or `THEN` . Otherwise it has compiled a branch over to be executed if the value on stack had been null at run-time.

IMMEDIATE ( -- ) [ANS] => "[ANS] FORTH"

make the `LATEST` word immediate, see also `CREATE`

INVERT ( value# -- value#' ) [ANS] => "[ANS] FORTH"

make a bitwise negation of the value on stack. see also `NEGATE`

J ( R: some,loop -- S: j# ) [ANS] => "[ANS] FORTH"

get the current `DO` ... `LOOP` index-value being the not-innnermost. (the second-innermost...) see also for the other loop-index-values at `I` and `K`

KEY ( -- char# ) [ANS] => "[ANS] FORTH"

return a single character from the keyboard - the key is not echoed.

LEAVE ( R: some,loop -- R: some,loop ) [ANS] => "[ANS] FORTH"

quit the innermost `DO` .. `LOOP` - it does even clean the return-stack and branches to the place directly after the next `LOOP`

LITERAL ( C: value -- S: value ) [ANS] => "[ANS] FORTH"

if compiling this will take the value from the compiling-stack and puts in dictionary so that it will pop up again at the run-time of the word currently in creation. This word is used in compiling words but may also be useful in making a hard-constant value in some code-piece like this:

      : DCELLS [ 2 CELLS ] LITERAL * ; ( will save a multiplication at runtime)

(in most configurations this word is statesmart and it will do nothing in interpret-mode. See `LITERAL,` for a non-immediate variant)

LOOP ( R: some,loop -- ) [ANS] [REPEAT] => "[ANS] FORTH"

resolves a previous `DO` thereby compiling `((LOOP))` which does increment/decrement the index-value and branch back if the end-value of the loop has not been reached.

LSHIFT ( value# shift-count -- value#' ) [ANS] => "[ANS] FORTH"

does a bitwise left-shift on value

M* ( a# b# -- a,a#' ) [ANS] => "[ANS] FORTH"

multiply and return a double-cell result

MAX ( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] ) [ANS] => "[ANS] FORTH"

return the maximum of a and b

MIN ( a# b# -- a#|b# | a* b* -- a*|b* | a b -- a|b [??] ) [ANS] => "[ANS] FORTH"

return the minimum of a and b

MOD ( a# b# -- mod-a# | a b# -- mod-a# [??] ) [ANS] => "[ANS] FORTH"

return the module of "a mod b"

MOVE ( from-ptr to-ptr move-len -- ) [ANS] => "[ANS] FORTH"

p4_memcpy an area

NEGATE ( value# -- value#' ) [ANS] => "[ANS] FORTH"

return the arithmetic negative of the (signed) cell

      simulate:   : NEGATE -1 * ;

OR ( a b# -- a' | a# b -- b' | a b -- a' [??] ) [ANS] => "[ANS] FORTH"

return the bitwise OR of a and b - unlike `AND` this is usually safe to use on logical values

OVER ( a b -- a b a ) [ANS] => "[ANS] FORTH"

get the value from under the top of stack. The inverse operation would be `TUCK`

POSTPONE ( [word] -- ) [ANS] => "[ANS] FORTH"

will compile the following word at the run-time of the current-word which is a compiling-word. The point is that `POSTPONE` takes care of the fact that word may be an IMMEDIATE-word that flags for a compiling word, so it must be executed (and not pushed directly) to compile sth. later. Choose this word in favour of `COMPILE` (for non-immediate words) and `[COMPILE]` (for immediate words)

QUIT ( -- ) [EXIT] => "[ANS] FORTH"

this will throw and lead back to the outer-interpreter. traditionally, the outer-interpreter is called QUIT in forth itself where the first part of the QUIT-word had been to clean the stacks (and some other variables) and then turn to an endless loop containing `QUERY` and `EVALUATE` (otherwise known as `INTERPRET` ) - in pfe it is defined as a `THROW` ,

      : QUIT -56 THROW ;

R> ( R: a -- a R: ) [ANS] => "[ANS] FORTH"

get back a value from the return-stack that had been saved there using `>R` . This is the traditional form of a local var space that could be accessed with `R@` later. If you need more local variables you should have a look at `LOCALS|` which does grab some space from the return-stack too, but names them the way you like.

R@ ( R: a -- a R: a ) [ANS] => "[ANS] FORTH"

fetch the (upper-most) value from the return-stack that had been saved there using `>R` - This is the traditional form of a local var space. If you need more local variables you should have a look at `LOCALS|` , see also `>R` and `R>` . Without LOCALS-EXT there are useful words like `2R@` `R'@` `R"@` `R!`

RECURSE ( ? -- ? ) [ANS] => "[ANS] FORTH"

when creating a colon word the name of the currently-created word is smudged, so that you can redefine a previous word of the same name simply by using its name. Sometimes however one wants to recurse into the current definition instead of calling the older defintion. The `RECURSE` word does it exactly this.

        traditionally the following code had been in use:
        : GREAT-WORD [ UNSMUDGE ] DUP . 1- ?DUP IF GREAT-WORD THEN ;
        now use
        : GREAT-WORD DUP . 1- ?DUP IF RECURSE THEN ;

REPEAT ( -- ) [ANS] [REPEAT] => "[ANS] FORTH"

ends an unconditional loop, see `BEGIN`

ROT ( a b c -- b c a ) [ANS] => "[ANS] FORTH"

rotates the three uppermost values on the stack, the other direction would be with `-ROT` - please have a look at `LOCALS|` and `VAR` that can avoid its use.

RSHIFT ( value# shift-count# -- value#' ) [ANS] => "[ANS] FORTH"

does a bitwise logical right-shift on value (ie. the value is considered to be unsigned)

S" ( [string&lt;"&gt;] -- string-ptr string-len) [ANS] => "[ANS] FORTH"

if compiling then place the string into the currently compiled word and on execution the string pops up again as a double-cell value yielding the string's address and length. To be most portable this is the word to be best being used. Compare with `C"` and non-portable `"`

S>D ( a# -- a,a#' | a -- a,a#' [??] ) [ANS] => "[ANS] FORTH"

signed extension of a single-cell value to a double-cell value

SIGN ( a# -- ) [ANS] => "[ANS] FORTH"

put the sign of the value into the hold-space, this is the forth-style output formatting, see `HOLD`

SM/REM ( a,a# b# -- div-a# rem-a# ) [ANS] => "[ANS] FORTH"

see `/MOD` or `FM/MOD` or `UM/MOD` or `SM/REM`

SOURCE ( -- buffer* IN-offset# ) [ANS] => "[ANS] FORTH"

the current point of interpret can be gotten through SOURCE. The buffer may flag out TIB or BLK or a FILE and IN gives you the offset therein. Traditionally, if the current SOURCE buffer is used up, `REFILL` is called that asks for another input-line or input-block. This scheme would have made it impossible to stretch an [IF] ... [THEN] over different blocks, unless [IF] does call `REFILL`

SPACE ( -- ) [ANS] => "[ANS] FORTH"

print a single space to stdout, see `SPACES`

      simulate:    : SPACE  BL EMIT ;

SPACES ( space-count -- ) [ANS] => "[ANS] FORTH"

print n space to stdout, actually a loop over n calling `SPACE` , but the implemenation may take advantage of printing chunks of spaces to speed up the operation.

SWAP ( a b -- b a ) [ANS] => "[ANS] FORTH"

exchanges the value on top of the stack with the value beneath it

THEN ( -- ) [ANS] => "[ANS] FORTH"

does resolve a branch coming from either `IF` or `ELSE`

TYPE ( string-ptr string-len -- ) [ANS] => "[ANS] FORTH"

prints the string-buffer to stdout, see `COUNT` and `EMIT`

U. ( value# -- | value -- [?] ) [ANS] => "[ANS] FORTH"

print unsigned number to stdout

U< ( a b -- test-flag ) [ANS] => "[ANS] FORTH"

unsigned comparison, see `<`

UM* ( a# b# -- a,a#' ) [ANS] => "[ANS] FORTH"

unsigned multiply returning double-cell value

UM/MOD ( a,a# b# -- div-a#' mod-a#' ) [ANS] => "[ANS] FORTH"

see `/MOD` and `SM/REM`

UNLOOP ( R: some,loop -- ) [ANS] => "[ANS] FORTH"

drop the `DO` .. `LOOP` runtime variables from the return-stack, usually used just in before an `EXIT` call. Using this multiple times can unnest multiple nested loops.

UNTIL ( test-flag -- ) [ANS] [REPEAT] => "[ANS] FORTH"

ends an control-loop, see `BEGIN` and compare with `WHILE`

WHILE ( test-flag -- ) [ANS] => "[ANS] FORTH"

middle part of a `BEGIN` .. `WHILE` .. `REPEAT` control-loop - if cond is true the code-piece up to `REPEAT` is executed which will then jump back to `BEGIN` - and if the cond is null then `WHILE` will branch to right after the `REPEAT` (compare with `UNTIL` that forms a `BEGIN` .. `UNTIL` loop)

WORD ( delimiter-char# -- here* ) [ANS] => "[ANS] FORTH"

read the next `SOURCE` section (thereby moving `>IN` ) up to the point reaching $delimiter-char - the text is placed at `HERE` - where you will find a counted string. You may want to use `PARSE` instead.

XOR ( a# b# -- a#' ) [ANS] => "[ANS] FORTH"

return the bitwise-or of the two arguments - it may be unsafe use it on logical values. beware.

[ ( -- ) [ANS] => "[ANS] FORTH"

leave compiling mode - often used inside of a colon-definition to make fetch some very constant value and place it into the currently compiled colon-defintion with => , or `LITERAL` - the corresponding unleave word is `]`

['] ( [name] -- name-xt* ) [ANS] => "[ANS] FORTH"

will place the execution token of the following word into the dictionary. See `'` for non-compiling variant.

[CHAR] ( [word] -- char# ) [ANS] => "[ANS] FORTH"

in compile-mode, get the (ascii-)value of the first charachter in the following word and compile it as a literal so that it will pop up on execution again. See `CHAR` and forth-83 `ASCII`

] ( -- ) [ANS] => "[ANS] FORTH"

enter compiling mode - often used inside of a colon-definition to end a previous `[` - you may find a => , or `LITERAL` nearby in example texts.

.( ( [message&lt;closeparen&gt;] -- ) [ANS] => "[ANS] FORTH"

print the message to the screen while reading a file. This works too while compiling, so you can whatch the interpretation/compilation to go on. Some Forth-implementations won't even accept a => ." message" outside compile-mode while the (current) pfe does.

.R ( value# precision# -- | value precision# -- [??] ) [ANS] => "[ANS] FORTH"

print with precision - that is to fill a field of the give prec-with with right-aligned number from the converted value

0<> ( 0 -- 0 | value! -- value-flag! | value -- value-flag ) [ANS] => "[ANS] FORTH"

returns a logical-value saying if the value was not-zero. This is most useful in turning a numerical value into a boolean value that can be fed into bitwise words like `AND` and `XOR` - a simple `IF` or `WHILE` doesn't need it actually.

0> ( 0 -- 0 | value! -- value-flag! | value -- value-flag ) [ANS] => "[ANS] FORTH"

return value greater than zero

      simulate:    : 0&gt; 0 &gt; ;

2>R ( a,a -- R: a,a ) [ANS] => "[ANS] FORTH"

save a double-cell value onto the return-stack, see `>R`

2R> ( R: a,a -- a,a R: ) [ANS] => "[ANS] FORTH"

pop back a double-cell value from the return-stack, see `R>` and the earlier used `2>R`

2R@ ( R: a,a -- a,a R: a,a ) [ANS] => "[ANS] FORTH"

fetch a double-cell value from the return-stack, that had been previously been put there with `2>R` - see `R@` for single value. This can partly be a two-cell `LOCALS|` value, without LOCALS-EXT there are alos other useful words like `2R!` `R'@` `R"@`

<> ( a b -- a-flag ) [ANS] => "[ANS] FORTH"

return true if a and b are not equal, see `=`

?DO ( end# start# | end* start* -- R: some,loop ) [ANS] => "[ANS] FORTH"

start a control-loop just like `DO` - but don't execute atleast once. Instead jump over the code-piece if the loop's variables are not in a range to allow any loop.

AGAIN ( -- ) [ANS] [REPEAT] => "[ANS] FORTH"

ends an infinite loop, see `BEGIN` and compare with `WHILE`

C" ( [string&lt;"&gt;] -- string-bstr* ) [ANS] => "[ANS] FORTH"

in compiling mode place the following string in the current word and return the address of the counted string on execution. (in exec-mode use a `POCKET` and leave the bstring-address of it), see `S"` string" and the non-portable `"` string"

CASE ( value -- value ) [ANS] => "[ANS] FORTH"

start a CASE construct that ends at `ENDCASE` and compares the value on stack at each `OF` place

COMPILE, ( some-xt* -- ) [ANS] => "[ANS] FORTH"

place the execution-token on stack into the dictionary - in traditional forth this is not even the least different than a simple => , but in call-threaded code there's a big difference - so COMPILE, is the portable one. Unlike `COMPILE` , `[COMPILE]` and `POSTPONE` this word does not need the xt to have actually a name, see `:NONAME`

CONVERT ( a,a# string-bstr* -- a,a# a-len# ) [ANS] [OLD] => "[ANS] FORTH"

digit conversion, obsolete, superseded by `>NUMBER`

ENDCASE ( value -- ) [ANS] => "[ANS] FORTH"

ends a `CASE` construct that may surround multiple sections of `OF` ... `ENDOF` code-portions. The `ENDCASE` has to resolve the branches that are necessary at each `ENDOF` to point to right after `ENDCASE`

ENDOF ( -- ) [ANS] => "[ANS] FORTH"

resolve the branch need at the previous `OF` to mark a code-piece and leave with an unconditional branch at the next `ENDCASE` (opened by `CASE` )

ERASE ( buffer-ptr buffer-len -- ) [ANS] => "[ANS] FORTH"

fill an area will zeros.

      2000 CREATE DUP ALLOT ERASE

EXPECT ( str-ptr str-len -- ) [ANS] [OLD] => "[ANS] FORTH"

input handling, see `WORD` and `PARSE` and `QUERY` the input string is placed at str-adr and its length

      in =&gt; SPAN - this word is superceded by =&gt; ACCEPT

HEX ( -- ) [ANS] => "[ANS] FORTH"

set the input/output `BASE` to hexadecimal

      simulate:        : HEX 16 BASE ! ;

NIP ( a b -- b ) [ANS] => "[ANS] FORTH"

drop the value under the top of stack, inverse of `TUCK`

      simulate:        : NIP SWAP DROP ;

OF ( value test -- value ) [ANS] => "[ANS] FORTH"

compare the case-value placed lately with the comp-value being available since `CASE` - if they are equal run the following code-portion up to `ENDOF` after which the case-construct ends at the next `ENDCASE`

PAD ( -- pad* ) [ANS] => "[ANS] FORTH"

transient buffer region

PARSE ( delim-char# -- buffer-ptr buffer-len ) [ANS] => "[ANS] FORTH"

parse a piece of input (not much unlike WORD) and place it into the given buffer. The difference with word is also that `WORD` would first skip any delim-char while `PARSE` does not and thus may yield that one. In a newer version, `PARSE` will not copy but just return the word-span being seen in the input-buffer - therefore a transient space.

PICK ( value ...[n-1] n -- value ...[n-1] value ) [ANS] => "[ANS] FORTH"

pick the nth value from under the top of stack and push it note that

        0 PICK -&gt; DUP         1 PICK -&gt; OVER

QUERY ( -- ) => "[ANS] FORTH"

source input: read from terminal using `_accept_` with the returned string to show up in `TIB` of `/TIB` size.

REFILL ( -- refill-flag ) [ANS] => "[ANS] FORTH"

try to get a new input line from the `SOURCE` and set `>IN` accordingly. Return a flag if sucessful, which is always true if the current input comes from a terminal and which is always false if the current input comes from `EVALUATE` - and may be either if the input comes from a file

RESTORE-INPUT ( input...[input-len] input-len -- ) [ANS] => "[ANS] FORTH"

inverse of `SAVE-INPUT`

ROLL ( value ...[n-1] n -- ...[n-1] value ) [ANS] => "[ANS] FORTH"

the extended form of `ROT`

         2 ROLL -&gt; ROT

SAVE-INPUT ( -- input...[input-len] input-len ) [ANS] => "[ANS] FORTH"

fetch the current state of the input-channel which may be restored with `RESTORE-INPUT` later

TO ( value [name] -- ) [ANS] => "[ANS] FORTH"

set the parameter field of name to the value, this is used to change the value of a `VALUE` and it can be also used to change the value of `LOCALS|`

TUCK ( a b -- b a b ) [ANS] => "[ANS] FORTH"

shove the top-value under the value beneath. See `OVER` and `NIP`

      simulate:    : TUCK  SWAP OVER ;

U.R ( value# precision# -- ) [ANS] => "[ANS] FORTH"

print right-aligned in a prec-field, treat value to be unsigned as opposed to => .R

U> ( a b -- a-flag ) [ANS] => "[ANS] FORTH"

unsigned comparison of a and b, see `>`

UNUSED ( -- unused-len ) [ANS] => "[ANS] FORTH"

return the number of cells that are left to be used above `HERE`

WITHIN ( a# b# c# -- a-flag | a* b* c* -- a-flag ) [ANS] => "[ANS] FORTH"

a widely used word, returns ( b <= a && a < c ) so that is very useful to check an index a of an array to be within range b to c

[COMPILE] ( [word] -- ) [ANS] => "[ANS] FORTH"

while compiling the next word will be place in the currently defined word no matter if that word is immediate (like `IF` ) - compare with `COMPILE` and `POSTPONE`

\ ( [comment&lt;eol&gt;] -- ) [ANS] => "[ANS] FORTH"

eat everything up to the next end-of-line so that it is getting ignored by the interpreter.

PARSE-WORD ( "chars" -- buffer-ptr buffer-len ) [ANS] => "[ANS] FORTH"

the ANS'94 standard describes this word in a comment under `PARSE`, section A.6.2.2008 - quote:

Skip leading spaces and parse name delimited by a space. c-addr is the address within the input buffer and u is the length of the selected string. If the parse area is empty, the resulting string has a zero length.

If both `PARSE` and `PARSE-WORD` are present, the need for `WORD` is largely eliminated. Note that Forth200x calls it `PARSE-NAME` and clarifies that non-empty whitespace-only input is returned as a zero length string as well.

PARSE-NAME ( "chars" -- buffer-ptr buffer-len ) [Forth200x] => "[ANS] FORTH"

This word is identical with the PFE implementation `PARSE-WORD`

The only difference between the 1994 ANS-Forth PARSE-WORD and the 2005 Forth200x PARSE-NAME is in the explicit condition of whitespace-only - while 1994 reads "If the parse area is empty, the resulting string has a zero length." you will find that the 2005 version says "If the parse area is empty or contains only white space, the resulting string has length zero."

CFA' ( 'name' -- name-xt* ) [FTH] => "[ANS] FORTH"

return the execution token of the following name. This word is _not_ immediate and may not do what you expect in compile-mode. See `[']` and `'>` - note that in FIG-forth the word `'` had returned the PFA (not the CFA) and therefore this word was introduced being the `SYNONYM` of the ans-like word `'`

STACK-CELLS - no description, sorry

RETURN-STACK-CELLS - no description, sorry

Prev? | Up | ?Next
pfe-complex-ext? | Home | ?pfe-core-misc-ext