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

## Name

pfe-misc-ext ? Compatibility Miscellaneous words

## Synopsis

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

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

`.LINE ( line# block# -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`UD.R ( x,x# r# -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`UD. ( x,x# -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`ID. ( some-nfa* -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`-ROLL ( x...[n-1] y n# -- y x...[n-1] | num# -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`RANDOM ( n# -- random# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`SRAND ( seed# -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`(UNDER+) ( n1 n2 -- n1+n2 n2 ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

`BUILD-ARRAY ( x#...[dim] dim# -- memsize# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`ACCESS-ARRAY ( x#...[dim#] array* --- array* value# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

`SOURCE-LINE ( -- source-line# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`SOURCE-NAME ( -- source-name-ptr source-name-len ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`TH'POCKET ( pocket# -- pocket-ptr pocket-len ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`POCKET-PAD ( -- pocket-ptr ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`W@ ( some-wchar* -- some-wchar# | some* -- some# [?] ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

`WL-HASH ( buf-ptr buf-len -- buf-hash# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`TOPMOST ( some-wordlist* -- some-topmost-nfa* ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.WORDS ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.PRIMITIVES ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.COLON-DEFS ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.DOES-DEFS ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.CONSTANTS ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.VARIABLES ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.VOCABULARIES ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LS.MARKERS ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`TAB ( tab-n# -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

`?STOP ( -- stop-flag ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

`CLOSE-ALL-FILES ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

`STANDARD-I/O ( -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`HELP ( "name" -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`EDIT-BLOCKFILE ( "name" -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`ARGC ( -- arg-count ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`ARGV ( arg-n# -- arg-ptr arg-len ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`EXPAND-FN ( name-ptr name-len buf-ptr -- buf-ptr buf-len ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`LOAD" ( [filename&lt;"&gt;] -- ??? ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`SYSTEM ( command-ptr command-len -- command-exitcode# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`SYSTEM" ( [command-line&lt;"&gt;] -- command-exitcode# ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`CREATE: ( "name" -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`BUFFER: ( size# "name" -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

`R'! ( x R: a b -- R: x b ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

`R"! ( x R: a b c -- R: x b c ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

`2R! ( x y R: a b -- R: x y ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`DUP>R ( val -- val R: val ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`R>DROP ( R: val -- R: ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

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

`"FORTH"`;
?

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

`"FORTH"`;
?

`+UNDER ( n1 x n2 -- n1+n2 x ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

`EXECUTES ( fkey# [word] -- ) ?=>? (` | `)`; | ?

`"FORTH"`;
?

## Description

RAND_MAX ( -- rand-max ) [ENVIRONMENT] * maximum value for => RANDOM

ok - no description, sorry

COLD ( -- ) [FTH] => "FORTH"

cold abort - reinitialize everything and go to `QUIT` routine ... this routine is implemented as a warm-boot in pfe.

      : COLD [ ALSO ENVIRONMENT ] EMPTY SCRIPT-FILE INCLUDED QUIT ;

LIT - no description, sorry

.LINE ( line# block# -- ) [FTH] => "FORTH"

UD.R ( x,x# r# -- ) [FTH] => "FORTH"

UD. ( x,x# -- ) [FTH] => "FORTH"

see also `UD`.R

ID. ( some-nfa* -- ) [FTH] => "FORTH"

print the name-field pointed to by the nfa-argument. a synonym for .NAME - but this word is more portable due its heritage from fig-forth.

in fig-forth the name-field is effectivly a bstring with some flags, so the nfa's count has to be masked out, e.g.

      : .NAME COUNT 32 AND TYPE ;

in other pfe configurations, the name might not contain the flags it it just a counted string - and there may be even more possibilities.

      : .NAME COUNT TYPE ;

you should more and more convert your code to use the sequence `NAME>STRING` `TYPE` which is widely regarded as the better variant.

-ROLL ( x...[n-1] y n# -- y x...[n-1] | num# -- ) [FTH] => "FORTH"

the inverse of `ROLL`

RANDOM ( n# -- random# ) [FTH] => "FORTH"

returns random number with 0 <= n2 < n1)

      : RANDOM ?DUP IF _random SWAP MOD ELSE _random THEN ;

SRAND ( seed# -- ) [FTH] => "FORTH"

(UNDER+) ( n1 n2 -- n1+n2 n2 ) [FTH] => "FORTH"

quicker than

      : (UNDER+) TUCK + SWAP ; or : (UNDER+) DUP UNDER+ ;

+TO ( val [name] -- ) [FTH] => "FORTH"

add the val to the named `VALUE` or `LOCALS|` value

BUILD-ARRAY ( x#...[dim] dim# -- memsize# ) [FTH] => "FORTH"

writes X, n1, ... nX into the dictionary - returns product n1 * n2 * ... * nX

ACCESS-ARRAY ( x#...[dim#] array* --- array* value# ) [FTH] => "FORTH"

see `BUILD-ARRAY`

.STATUS ( -- ) [FTH] => "FORTH"

display internal variables

      : .STATUS .VERSION .CVERSION .MEMORY .SEARCHPATHS .DICTVARS .REGSUSED ;

SOURCE-LINE ( -- source-line# ) [FTH] => "FORTH"

if `SOURCE` is from `EVALUATE` (or `QUERY` ) then the result is 0 else the line-numbers start from 1

SOURCE-NAME ( -- source-name-ptr source-name-len ) [FTH] => "FORTH"

if `SOURCE` is from `INCLUDE` then the result is the filename, otherwise a generic name for the SOURCE-ID is given.

TH'POCKET ( pocket# -- pocket-ptr pocket-len ) [FTH] => "FORTH"

returns the specified pocket as a `S"` string reference

POCKET-PAD ( -- pocket-ptr ) [FTH] => "FORTH"

This function Returns the next pocket. A pocket has usually the size of a maxstring, see `ENVIRONMENT /STRING` (but can be configured to be different, mostly when MAXPATH > /STRING ) Note that a pocket is a temporary and forth internal functions do sometimes call `POCKET-PAD` too, especially when building filenames and getting a literal (but temporary) string from the keyboard. Functions are not expected to hold references to this transient area any longer than building a name and calling another word with it.

Usage of a pocket pad is a good way to make local temporary buffers superfluous that are only used to construct a temporary string that usually gets swallowed by another function.

      depracated code:
        create temp-buffer 255 allot
        : make-temp ( str buf )
               temp-buffer place  " .tmp" count temp-buffer append
               temp-buffer count make-file ;
      replace with this:
        : make-temp ( str buf )
             pocket-pad &gt;r
             r place  " .tmp" count r append
             r&gt; count make-file
        ;

W@ ( some-wchar* -- some-wchar# | some* -- some# [?] ) [FTH] => "FORTH"

fetch a 2byte-val from address

W! ( value# some-wchar* -- | value# wchar* -- [?] ) [FTH] => "FORTH"

store a 2byte-val at addressed 2byte-value

W+! ( value# some-wchar* -- | value# wchar* -- [?] ) [FTH] => "FORTH"

add a 2byte-val to addressed 2byte-value

WL-HASH ( buf-ptr buf-len -- buf-hash# ) [FTH] => "FORTH"

calc hash-code for selection of thread in a threaded-vocabulary

TOPMOST ( some-wordlist* -- some-topmost-nfa* ) [FTH] => "FORTH"

that last valid word in the specified vocabulary

LS.WORDS ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.PRIMITIVES ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.COLON-DEFS ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.DOES-DEFS ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.CONSTANTS ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.VARIABLES ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.VOCABULARIES ( -- ) [FTH] => "FORTH"

see `WORDS`

LS.MARKERS ( -- ) [FTH] => "FORTH"

see `WORDS`

TAB ( tab-n# -- ) [FTH] => "FORTH"

jump to next column divisible by n

BACKSPACE ( -- ) [FTH] => "FORTH"

reverse of `SPACE`

?STOP ( -- stop-flag ) [FTH] => "FORTH"

check for 'q' pressed - see => ?CR

START?CR ( -- ) [FTH] => "FORTH"

initialized for more-like effect - see => ?CR

?CR ( -- cr-flag ) [FTH] => "FORTH"

like `CR` , stop 25 lines past `START`?CR

CLOSE-ALL-FILES ( -- ) [FTH] => "FORTH"

.MEMORY ( -- ) [FTH] => "FORTH"

(EMIT) - no description, sorry

(EXPECT) - no description, sorry

(KEY) - no description, sorry

(TYPE) - no description, sorry

STANDARD-I/O ( -- ) [FTH] => "FORTH"

initialize `*TYPE*` , `*EMIT*` , `*EXPECT*` and `*KEY*` to point directly to the screen I/O routines, namely `(TYPE)` , `(EMIT)` , `(EXPECT)` , `(KEY)`

HELP ( "name" -- ) [FTH] [EXEC] => "FORTH"

will load the help module in the background and hand over the parsed name to `(HELP)` to be resolved. If no `(HELP)` word can be loaded, nothing will happen.

EDIT-BLOCKFILE ( "name" -- ) [FTH] [EXEC] => "FORTH"

will load the edit module in the background and look for a word called `EDIT-BLOCK` that could be used to edit the blockfile. If no `EDIT-BLOCKFILE` word can be loaded, nothing will happen. Otherwise, `OPEN-BLOCKFILE` is called followed by `0` `EDIT-BLOCK` to start editing the file at the first block.

ARGC ( -- arg-count ) [FTH] => "FORTH"

ARGV ( arg-n# -- arg-ptr arg-len ) [FTH] => "FORTH"

EXPAND-FN ( name-ptr name-len buf-ptr -- buf-ptr buf-len ) [FTH] => "FORTH"

      : e.g. s" includefile" POCKET-PAD EXPAND-FN ;

LOAD" ( [filename&lt;"&gt;] -- ??? ) [FTH] [OLD] => "FORTH"

load the specified file - this word can be compiled into a word-definition obsolete! use `OPEN-BLOCKFILE` name `LOAD`

SYSTEM ( command-ptr command-len -- command-exitcode# ) [FTH] => "FORTH"

run a shell command (note: embedded systems have no shell)

SYSTEM" ( [command-line&lt;"&gt;] -- command-exitcode# ) [FTH] [OLD] => "FORTH"

run a shell command (note:embedded systems have no shell) obsolete! use `S"` string" `SYSTEM`

CREATE: ( "name" -- ) [FTH] => "FORTH"

this creates a name with the `VARIABLE` runtime. Note that this is the FIG-implemenation of `CREATE` whereas in ANS-Forth mode we have a `CREATE` identical to FIG-style `<BUILDS`

      : CREATE: BL WORD $HEADER DOVAR A, ;

BUFFER: ( size# "name" -- ) [FTH] => "FORTH"

this creates a name with the `VARIABLE` runtime and `ALLOT`s memory

      : BUFFER: BL WORD $HEADER DOVAR A, ALLOT ;

R'@ ( R: a b -- a R: a b ) [FTH] => "FORTH"

fetch the next-under value from the returnstack. used to interpret the returnstack to hold two `LOCALS|` values. ( `R@` / `2R@` / `R>DROP` / `R"@`)

R'! ( x R: a b -- R: x b ) [FTH] => "FORTH"

store the value into the next-under value in the returnstack. used to interpret the returnstack to hold two `LOCALS|` values. see `R'@` for inverse operation

R"@ ( R: a b c -- a R: a b c ) [FTH] => "FORTH"

fetch the second-under value from the returnstack. used to interpret the returnstack to hold three `LOCALS|` values. see `R"!` for inverse operation ( `R'@` `R@` / `2R@` / `R>DROP` )

R"! ( x R: a b c -- R: x b c ) [FTH] => "FORTH"

store the value into the second-under value in the returnstack. used to interpret the returnstack to hold three `LOCALS|` values. see `R"@` for inverse operation

R! ( x R: a -- R: x ) [FTH] => "FORTH"

store the value as the topmost value in the returnstack. see `R@` for inverse operation ( `R'@` / `R"@` / `2R@` / `2R!`)

2R! ( x y R: a b -- R: x y ) [FTH] => "FORTH"

store the value as the topmost value in the returnstack. see `2R@` for inverse operation ( `R'@` / `R"@` / `2R@` / `2R!`)

DUP>R ( val -- val R: val ) [FTH] => "FORTH"

shortcut, see `R>DROP` note again that the following will fail:

      : DUP&gt;R DUP &gt;R ;

R>DROP ( R: val -- R: ) [FTH] => "FORTH"

shortcut (e.g. in CSI-Forth) note that the access to R is configuration dependent - only in a traditional fig-forth each NEST will be one cell wide - in case that there are no `LOCALS|` of course. And remember, the word above reads like the sequence `R>` and `DROP` but that is not quite true.

      : R&gt;DROP R&gt; DROP ; ( is bad - correct might be )  : R&gt;DROP R&gt; R&gt; DROP &gt;R ;

2R>2DROP ( R: a b -- R: ) [FTH] => "FORTH"

this is two times `R>DROP` but a bit quicker. it is however really quick compared to the sequence `2R>` and `2DROP`

CLEARSTACK ( -- ) [FTH] => "FORTH"

reset the parameter stack to be empty

      : CLEARSTACK  S0 SP! ;

+UNDER ( n1 x n2 -- n1+n2 x ) [EXT] => "FORTH"

quicker than

      : UNDER+  ROT + SWAP ;

Note: the old pfe version of UNDER+ is obsolete as it is in conflict with a comus word of the same name. The behavior of this word will continue to exist under the name of `(UNDER+)`. Users are encouraged to use the comus behavior of UNDER+ which does already exist under the name of `+UNDER`. In the future pfe will be changed to pick up the comus behavior making UNDER+ and +UNDER to be synonyms. In the current version there will be load-time warning on usages of "UNDER+".

EXECUTES ( fkey# [word] -- ) [EXT] => "FORTH"

stores the execution token of following word into the callback pointer for the specified function-key

Prev? | Up | ?Next
pfe-memory-ext? | Home | ?pfe-module-ext