Name
store:core — ordinary primitive
Synopsis
FORTH
!
( val addr -- )(
)
;
p4:"store";
Description
store value at addr (sizeof CELL)
Name
store-plus:forth_usual.1 — forthword synonym
Synopsis
FORTH
!+
( .. )(
)
;
as:"store-plus";
Description
forthword synonym !+
is doing the same as !++
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
store-plus:toolbelt.1 — ordinary primitive
Synopsis
FORTH
!+
( .. )(
)
;
as:"store-plus";
Description
ordinary primitive !+
an executable word (no special usage info)
or wrapper call around p4_store_plus_plus
Name
store-plus-plus:forth_usual — ordinary primitive
Synopsis
FORTH
!++
( addr x -- addr' )( | ) ; | |
Description
Store the value _x_ into _addr_, and increment the address
by one cell.
: !++ ( addr x -- addr' ) OVER ! CELL+ ;
Name
store-back:your.1 — immediate synonym
Synopsis
EXTENSIONS
!>
( .. )(
)
;
as:"store-back";
Description
immediate synonym !>
is doing the same as TO
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
quote:core — immediate synonym
Synopsis
FORTH
"
( [string<">] -- bstring )or perhaps ( [..] -- str-ptr str-len )( | ) ; | |
Description
This is the non-portable word which is why the ANSI-committee
on forth has created the two other words, namely S" and C" ,
since each implementation (and in pfe configurable) uses another
runtime behaviour. FIG-forth did return bstring which is the configure
default for pfe.
Name
sh:core — ordinary primitive
Synopsis
FORTH
#
( n.n -- n.n' )(
)
;
p4:"sh";
Description
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 #>
Name
ignore-line:posix — ordinary primitive
Synopsis
EXTENSIONS
#!
( "...<eol>" -- )(
)
;
p4:"ignore-line";
Description
ignores the rest of the line,
defining `#!' is used to support forth scripts
executed by the unix kernel
Name
sh-greater:core — ordinary primitive
Synopsis
FORTH
#>
( n.n -- str-addr str-len )( | ) ; | |
Description
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
Name
str-store:dstrings.1 — ordinary primitive
Synopsis
FORTH
$!
( .. )(
)
;
as:"str-store";
Description
ordinary primitive $!
an executable word (no special usage info)
or wrapper call around p4_str_store
Name
str-quote:dstrings — compiling primitive
Synopsis
FORTH
$"
( [ccc<">] -- $: str )(
)
;
p4:"str-quote";
Description
Parse ccc delimited by " (double-quote) and store it in data
space as an mstring. If interpreting, leave the MSA on the
string stack. If compiling, append run-time semantics to the
current definition that leaves the MSA on the string stack.
A program should not alter the stored string. An error is
thrown if the quoted string length is larger than the system
parameter MAX_DATA_STR (see S,).
<ansref>"string-quote"</ansref>
NOTE: In contrast to S", the string stored by $" when
interpreting is not transient.
The implementation is based on PFE code for S".
Name
str-str:shell.1 — obsolete forthword
Synopsis
EXTENSIONS
$$
( .. )(
)
;
as:"str-str";
Description
obsolete forthword $$
is doing the same as $PID
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
str-dot:dstrings — ordinary primitive
Synopsis
FORTH
$.
( $: a$ -- )(
)
;
p4:"str-dot";
Description
Display the string on the terminal. If the system
implementation of TYPE has its output vectored, $. uses the
same vector. <ansref>"string-dot"</ansref>
Name
str-fetch:dstrings — ordinary primitive
Synopsis
FORTH
$@
( $var.pfa -- $: a$ )(
)
;
p4:"str-fetch";
Description
Leave the MSA of the string held by the string variable.
<ansref>"string-fetch"</ansref>
Name
tick:core — forthword synonym
Synopsis
FORTH
'
( 'name' -- xt )(
)
;
p4:"tick";
Description
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 of the same name had returned the PFA (not the CFA)
and was immediate/smart, so beware when porting forth-code
from FIG-forth to ANSI-forth.
Name
tick-from:your — compiling primitive
Synopsis
EXTENSIONS
'>
( [name] -- xt )(
)
;
p4:"tick-from";
Description
get the execution-token, ie the CFA, of the word following.
This word is fully state-smart while the ANSI standard words
namely ' and ['] are not.
Name
paren:core — immediate primitive
Synopsis
FORTH
(
( 'comment<closeparen>' -- )( | ) ; | |
Description
eat everything up to the next closing paren - treat it
as a comment.
Name
note-str:useful.1 — immediate primitive
Synopsis
EXTENSIONS
($
( .. )(
)
;
as:"note-str";
Description
immediate primitive ($
an executable word (no special usage info)
or wrapper call around p4_prefix_begin
Name
note-str-colon:dstrings.1 — immediate primitive
Synopsis
FORTH
($:
( .. )(
)
;
as:"note-str-colon";
Description
immediate primitive ($:
an executable word (no special usage info)
or wrapper call around p4_paren
Name
paren-dot:toolbelt.1 — ordinary primitive
Synopsis
FORTH
(.)
( .. )(
)
;
as:"paren-dot";
Description
ordinary primitive (.)
an executable word (no special usage info)
or wrapper call around p4_paren_dot
Name
done:useful.1 — immediate primitive
Description
immediate primitive )
an executable word (no special usage info)
or wrapper call around p4_prefix_end
Name
star:core — ordinary primitive
Synopsis
FORTH
*
( a b -- a*b )(
)
;
p4:"star";
Description
return the multiply of the two args
Name
power:forth_83 — ordinary primitive
Synopsis
FORTH
**
( a b -- r )(
)
;
p4:"power";
Description
raise second to top power
Name
star-slash:core — ordinary primitive
Synopsis
FORTH
*/
( a b c -- a*b/c )(
)
;
p4:"star-slash";
Description
regard the b/c as element Q - this word
has an advantage over the sequence of *
and / by using an intermediate double-cell
value
Name
plus:core — ordinary primitive
Synopsis
FORTH
+
( a b -- a+b )(
)
;
p4:"plus";
Description
return the sum of the two args
Name
plus-store:core — ordinary primitive
Synopsis
FORTH
+!
( val addr -- )(
)
;
p4:"plus-store";
Description
add val to the value found in addr
simulate:
: +! TUCK @ + SWAP ! ;
Name
plus-plus:forth_usual — ordinary primitive
Synopsis
FORTH
++
( addr -- )(
)
;
p4:"plus-plus";
Description
Increment the value at _addr_.
: ++ ( addr -- ) 1 SWAP +! ;
Name
plus-plus:toolbelt — ordinary primitive
Synopsis
FORTH
++
( addr -- )(
)
;
p4:"plus-plus";
Description
Increment the value at _addr_.
: ++ ( addr -- ) 1 SWAP +! ;
Name
comma:core — ordinary primitive
Synopsis
FORTH
,
( val -- )(
)
;
p4:"comma";
Description
store the value in the dictionary
simulate:
: , DP 1 CELLS DP +! ! ;
Name
comma-quote:toolbelt.1 — immediate primitive
Synopsis
FORTH
,"
( .. )(
)
;
as:"comma-quote";
Description
immediate primitive ,"
an executable word (no special usage info)
or wrapper call around p4_parse_comma_quote
Name
minus:core — ordinary primitive
Synopsis
FORTH
-
( a b -- a-b )(
)
;
p4:"minus";
Description
return the difference of the two arguments
Name
next-block:forth_83 — immediate primitive
Synopsis
FORTH
-->
( -- )no-return(
)
;
p4:"next-block";
Description
does increase BLK and refills the input-buffer
from there. Does hence break interpretation of the
current BLK and starts with the next. Old-style
forth mechanism. You should use INCLUDE
Name
dot:core — ordinary primitive
Description
print the numerical value to stdout - uses BASE
Name
dot-quote:core — compiling primitive
Synopsis
FORTH
."
( [string<">] -- )(
)
;
p4:"dot-quote";
Description
print the string to stdout
Name
dot-paren:core — immediate primitive
Synopsis
FORTH
.(
( [message<closeparen>] -- )( | ) ; | |
Description
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.
Name
slash:core — ordinary primitive
Synopsis
FORTH
/
( a b -- a/b )(
)
;
p4:"slash";
Description
return the quotient of the two arguments
Name
slash-slash:cdecl.1 — immediate synonym
Synopsis
FORTH
//
( .. )(
)
;
as:"slash-slash";
Description
immediate synonym //
is doing the same as \\
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
zero:core_misc.1 — ordinary constant
Description
( 0 ) constant 0
an ordinary constant (no special usage info)
Name
zero-less:core — ordinary primitive
Synopsis
FORTH
0<
( val -- cond )(
)
;
p4:"zero-less";
Description
return a flag that is true if val is lower than zero
simulate:
: 0< 0 < ;
Name
zero-less-equal:core_misc — ordinary primitive
Synopsis
FORTH
0<=
( a -- flag )(
)
;
p4:"zero-less-equal";
Description
simulate : 0<= 0> 0= ;
Name
zero-not-equals:core — ordinary primitive
Description
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.
Name
zero-equal:core — ordinary primitive
Synopsis
FORTH
0=
( val -- cond )(
)
;
p4:"zero-equal";
Description
return a flag that is true if val is just zero
simulate:
: 0= 0 = ;
Name
zero-greater:core — ordinary primitive
Synopsis
FORTH
0>
( value -- cond )(
)
;
p4:"zero-greater";
Description
return value greater than zero
simulate: : 0> 0 > ;
Name
zero-greater-equal:core_misc — ordinary primitive
Description
simulate : 0>= 0< 0= ;
Name
one:core_misc.1 — ordinary constant
Description
( 1 ) constant 1
an ordinary constant (no special usage info)
Name
one-plus:core — ordinary primitive
Synopsis
FORTH
1+
( val -- val+1 )(
)
;
p4:"one-plus";
Description
return the value incremented by one
simulate:
: 1+ 1 + ;
Name
one-minus:core — ordinary primitive
Synopsis
FORTH
1-
( val -- val-1 )(
)
;
p4:"one-minus";
Description
return the value decremented by one
simulate:
: 1- 1 - ;
Name
two:core_misc.1 — ordinary constant
Description
( 2 ) constant 2
an ordinary constant (no special usage info)
Name
two-store:core — ordinary primitive
Synopsis
FORTH
2!
( a,a addr -- )(
)
;
p4:"two-store";
Description
double-cell store
Name
two-star:core — ordinary primitive
Synopsis
FORTH
2*
( a -- a*2 )(
)
;
p4:"two-star";
Description
multiplies the value with two - but it
does actually use a shift1 to be faster
simulate:
: 2* 2 * ; ( canonic) : 2* 1 LSHIFT ; ( usual)
Name
two-plus:forth_83 — ordinary primitive
Synopsis
FORTH
2+
( i -- i )(
)
;
p4:"two-plus";
Description
add 2 to the value on stack (and leave the result there)
simulate:
: 2+ 2 + ;
Name
two-minus:forth_83 — ordinary primitive
Synopsis
FORTH
2-
( i -- i )(
)
;
p4:"two-minus";
Description
substract 2 from the value on stack (and leave the result there)
simulate:
: 2- 2 - ;
Name
two-slash:core — ordinary primitive
Synopsis
FORTH
2/
( a -- a/2 )(
)
;
p4:"two-slash";
Description
divides the value by two - but it
does actually use a shift1 to be faster
simulate:
: 2/ 2 / ; ( canonic) : 2/ 1 RSHIFT ; ( usual)
Name
two-fetch:core — ordinary primitive
Synopsis
FORTH
2@
( addr -- a,a )(
)
;
p4:"two-fetch";
Description
double-cell fetch
Name
three:core_misc.1 — ordinary constant
Description
( 3 ) constant 3
an ordinary constant (no special usage info)
Name
colon:core — definining primitive
Synopsis
FORTH
:
( 'name' -- )(
)
;
p4:"colon";
Description
create a header for a nesting word and go to compiling
mode then. This word is usually ended with ; but
the execution of the resulting colon-word can also
return with EXIT
Name
colon:with_spy — forthword synonym
Synopsis
SPY'
:
( 'name' -- )(
)
;
p4:"colon";
Description
create a header for a nesting word and go to compiling
mode then. This word is usually ended with ; but
the execution of the resulting colon-word can also
return with EXIT
Name
semicolon:core — compiling primitive
Synopsis
FORTH
;
( -- )(
)
;
p4:"semicolon";
Description
compiles ((;)) which does EXIT the current
colon-definition. It does then end compile-mode
and returns to execute-mode. See : and :NONAME
Name
semicolon:with_spy — immediate synonym
Synopsis
SPY'
;
( -- )(
)
;
p4:"semicolon";
Description
compiles ((;)) which does EXIT the current
colon-definition. It does then end compile-mode
and returns to execute-mode. See : and :NONAME
Name
less-than:core — ordinary primitive
Synopsis
FORTH
<
( a b -- cond )(
)
;
p4:"less-than";
Description
return a flag telling if a is lower than b
Name
less-sh:core — ordinary primitive
Synopsis
FORTH
<#
( -- )(
)
;
p4:"less-sh";
Description
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.
Name
less-equal:core_misc — ordinary primitive
Synopsis
FORTH
<=
( a b -- flag )(
)
;
p4:"less-equal";
Description
simulate : <= > 0= ;
Name
not-equals:core — ordinary primitive
Synopsis
FORTH
<>
( a b -- cond )(
)
;
p4:"not-equals";
Description
return true if a and b are not equal, see =
Name
equals:core — ordinary primitive
Synopsis
FORTH
=
( a b -- cond )(
)
;
p4:"equals";
Description
return a flag telling if a is equal to b
Name
greater-than:core — ordinary primitive
Synopsis
FORTH
>
( a b -- cond )(
)
;
p4:"greater-than";
Description
return a flag telling if a is greater than b
Name
byte-swap:forth_83 — ordinary primitive
Synopsis
FORTH
><
( a -- a' )(
)
;
p4:"byte-swap";
Description
byte-swap a word
Name
greater-equal:core_misc — ordinary primitive
Synopsis
FORTH
>=
( a b -- flag )(
)
;
p4:"greater-equal";
Description
simulate : >= < 0= ;
Name
question:tools — ordinary primitive
Synopsis
FORTH
?
( addr -- )(
)
;
p4:"question";
Description
Display the (integer) content of at address addr.
This word is sensitive to BASE
simulate:
: ? @ . ;
Name
fetch:core — ordinary primitive
Synopsis
FORTH
@
( addr -- value )(
)
;
p4:"fetch";
Description
fetch the value from the variables address
Name
fetch-plus:forth_usual.1 — forthword synonym
Synopsis
FORTH
@+
( .. )(
)
;
as:"fetch-plus";
Description
forthword synonym @+
is doing the same as @++
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
fetch-plus:toolbelt.1 — ordinary primitive
Synopsis
FORTH
@+
( .. )(
)
;
as:"fetch-plus";
Description
ordinary primitive @+
an executable word (no special usage info)
or wrapper call around p4_fetch_plus_plus
Name
fetch-plus-plus:forth_usual — ordinary primitive
Synopsis
FORTH
@++
( addr -- addr' x )( | ) ; | |
Description
Fetch the value _x_ from _addr_, and increment the address
by one cell.
: @++ ( addr -- addr' x ) DUP CELL+ SWAP @ ;
Name
fetch-from:your — compiling primitive
Synopsis
EXTENSIONS
@>
( [name] -- value )(
)
;
p4:"fetch-from";
Name
left-bracket:core — immediate primitive
Synopsis
FORTH
[
( -- )(
)
;
p4:"left-bracket";
Description
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
bracket-tick:core — compiling primitive
Synopsis
FORTH
[']
( [name] -- )immediate( | ) ; | |
Description
will place the execution token of the following word into
the dictionary. See ' for non-compiling variant.
Name
backslash:core — immediate primitive
Synopsis
FORTH
\
( [comment<eol>] -- )(
)
;
p4:"backslash";
Description
eat everything up to the next end-of-line so that it is
getting ignored by the interpreter.
Name
backslash-backslash:toolbelt — ordinary primitive
Description
Ignore the rest of the input stream.
: \\ BEGIN -1 PARSE 2DROP REFILL 0= UNTIL ;
Name
right-bracket:core — ordinary primitive
Synopsis
FORTH
]
( -- )(
)
;
p4:"right-bracket";
Description
enter compiling mode - often used inside of a colon-definition
to end a previous [ - you may find a , or LITERAL
nearby in example texts.
Name
abort:exception — ordinary primitive
Synopsis
FORTH
ABORT
( -- )no-return(
)
;
p4:"abort";
Description
throw - cleanup some things and go back to the QUIT routine
: ABORT -1 THROW ;
Name
abort-quote:exception — compiling primitive
Synopsis
FORTH
ABORT"
( [string<">] -- )no-return( | ) ; | |
Description
throw like ABORT but print an additional error-message
to stdout telling what has happened.
Name
abort-minus-wordlist:chainlist.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL ABORT-WORDLIST
abort_wl (no special usage info)
Name
abs:core — ordinary primitive
Synopsis
FORTH
ABS
( value -- value' )(
)
;
p4:"abs";
Description
return the absolute value
Name
accept:core — ordinary primitive
Synopsis
FORTH
ACCEPT
( a n -- n' )(
)
;
p4:"accept";
Description
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.
Name
access-array:misc — ordinary primitive
Synopsis
FORTH
ACCESS-ARRAY
( i1 i2 ... iX addr1 --- addr2 n )( | ) ; | |
Name
addr-back-name:debug.1 — ordinary primitive
Synopsis
FORTH
ADDR>NAME
( addr -- nfa|0 )( | ) ; | |
Description
search the next corresponding namefield that address
is next too. If it is not in the base-dictionary, then
just return 0 as not-found.
_export const p4char *
p4_addr_to_name (const p4char* addr)
Name
address-minus-unit-minus-bits:core::environment — ordinary constant
Synopsis
ENVIRONMENT
ADDRESS-UNIT-BITS
( .. )( | ) ; | |
Description
( CHAR_BIT ) constant ADDRESS-UNIT-BITS
an ordinary constant (no special usage info)
Name
again:core — compiling primitive
Synopsis
FORTH
AGAIN
( -- )(
)
;
p4:"again";
Description
ends an infinite loop, see BEGIN and compare with
WHILE
Name
ahead:tools — immediate primitive
Synopsis
FORTH
AHEAD
( -- DP-mark ORIG-magic )compile-only( | ) ; | |
Description
simulate:
: AHEAD MARK> (ORIG#) ;
Name
alias:chainlist — ordinary primitive
Synopsis
EXTENSIONS
ALIAS
( xt "name" -- )(
)
;
p4:"alias";
Description
create a defer word that is initialized with the given x-token.
DO-ALIAS
Name
alias-atexit:chainlist — ordinary primitive
Synopsis
EXTENSIONS
ALIAS-ATEXIT
( xt "name" -- )( | ) ; | |
Description
create a defer word that is initialized with the given x-token.
: ALIAS-ATEXIT ATEXIT-WORDLIST DO-ALIAS ;
ATEXIT-WORDLIST DO-ALL-WORDS
Name
align:core — ordinary primitive
Synopsis
FORTH
ALIGN
( -- )(
)
;
p4:"align";
Description
will make the dictionary aligned, usually to a
cell-boundary, see ALIGNED
Name
aligned:core — ordinary primitive
Synopsis
FORTH
ALIGNED
( addr -- addr' )(
)
;
p4:"aligned";
Description
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
Name
allocate:memory — ordinary primitive
Synopsis
FORTH
ALLOCATE
( size -- ptr|0 code )( | ) ; | |
Description
allocate a chunk of memory from the system heap.
use FREE to release the memory area back to the system. <br>
a code of zero means success.
Name
allot:core — ordinary primitive
Synopsis
FORTH
ALLOT
( count -- )(
)
;
p4:"allot";
Description
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.
Name
also:search — ordinary primitive
Description
a DUP on the search ORDER - each named vocabulary
replaces the topmost ORDER vocabulary. Using ALSO
will make it fixed to the search-order. (but it is
not nailed in trap-conditions as if using DEFAULT-ORDER )
order: vocn ... voc2 voc1 -- vocn ... voc2 voc1 voc1
Name
also-module:module — ordinary primitive
Synopsis
EXTENSIONS
ALSO-MODULE
( "name" -- )( | ) ; | |
Description
affects the search-order, ALSO module-wid CONTEXT !
: ALSO-MODULE
' DUP VOC? ABORT?" is no vocabulary"
ALSO EXECUTE
;
Name
and:core — ordinary primitive
Synopsis
FORTH
AND
( val mask -- val' )(
)
;
p4:"and";
Description
mask with a bitwise and - be careful when applying
it to logical values.
Name
semicolon-and:useful — compiling primitive
Synopsis
EXTENSIONS
;AND
( -- )(
)
;
p4:"semicolon-and";
Description
For the code piece between MAKE and ;AND , this word
will do just an EXIT . For the code outside of
the MAKE construct a branch-around must be resolved then.
Name
andif:toolbelt — compiling primitive
Synopsis
FORTH
ANDIF
( p ... -- flag )(
)
;
p4:"andif";
Description
Given `p ANDIF q THEN`, _q_ will not be performed if
_p_ is false.
: ANDIF S" DUP IF DROP " EVALUATE ; IMMEDIATE
Name
anew:core — ordinary primitive
Synopsis
EXTENSIONS
ANEW
( 'name' -- )(
)
;
p4:"anew";
Description
creates a MARKER if it doesn't exist,
or forgets everything after it if it does. (it just gets executed).
: ANEW BL WORD DUP FIND NIP IF EXECUTE THEN (MARKER) ;
Name
append:forth_usual — forthword synonym
Synopsis
FORTH
APPEND
( str len add2 -- )(
)
;
p4:"append";
Description
Append string _str len_ to the counted string at _addr_.
a.k.a. +PLACE of the PLACE family
: APPEND 2DUP 2>R COUNT + SWAP MOVE ( ) 2R> C+! ;
Append string _str len_ to the counted string at _addr_.
a.k.a. APPEND (being a SYNONYM now)
: +PLACE 2DUP 2>R COUNT + SWAP MOVE ( ) 2R> C+! ;
Name
append:toolbelt — ordinary primitive
Synopsis
FORTH
APPEND
( str len add2 -- )(
)
;
p4:"append";
Description
Append string _str len_ to the counted string at _addr_.
a.k.a. +PLACE of the PLACE family
: APPEND 2DUP 2>R COUNT + SWAP MOVE ( ) 2R> C+! ;
Append string _str len_ to the counted string at _addr_.
a.k.a. APPEND (being a SYNONYM now)
: +PLACE 2DUP 2>R COUNT + SWAP MOVE ( ) 2R> C+! ;
Name
append-char:forth_usual — forthword synonym
Synopsis
FORTH
APPEND-CHAR
( char addr -- )( | ) ; | |
Description
Append _char_ to the counted string at _addr_.
a.k.a. C+PLACE of the PLACE family
: APPEND-CHAR DUP >R COUNT DUP 1+ R> C! + C! ;
Append _char_ to the counted string at _addr_.
a.k.a. APPEND-CHAR (being a SYNONYM now)
: C+PLACE DUP >R COUNT DUP 1+ R> C! + C! ;
Name
append-char:toolbelt — ordinary primitive
Synopsis
FORTH
APPEND-CHAR
( char addr -- )( | ) ; | |
Description
Append _char_ to the counted string at _addr_.
a.k.a. C+PLACE of the PLACE family
: APPEND-CHAR DUP >R COUNT DUP 1+ R> C! + C! ;
Append _char_ to the counted string at _addr_.
a.k.a. APPEND-CHAR (being a SYNONYM now)
: C+PLACE DUP >R COUNT DUP 1+ R> C! + C! ;
Name
appendz:zchar.1 — forthword synonym
Synopsis
FORTH
APPENDZ
( .. )(
)
;
as:"appendz";
Description
forthword synonym APPENDZ
is doing the same as +ZPLACE
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
application:misc.1 — threadstate variable
Synopsis
FORTH
APPLICATION
( .. )(
)
;
as:"application";
Description
threadstate variable APPLICATION
application (no special usage info)
Name
argc:misc — ordinary primitive
Synopsis
FORTH
ARGC
( -- n )(
)
;
p4:"argc";
Name
args-brace:dstrings — immediate primitive
Synopsis
FORTH
ARGS{
( arg1'$ ... argN'$ "arg1 ... argN <}>" -- )( | ) ; | |
Description
compilation: ( -- $: arg1$ ... argN$ )
Immediate and compilation-only.
Copy the argument strings to the string buffer, push them
onto the string stack with "argN" the most accessible, and
make them into the top compile-time string stack frame.
Compile the run-time code to make an argument frame out of
the N most accessible run-time string stack entries. Inform
the system text interpreter that it should compile run-time
code for any white-space delimited argument encountered in
the text of the definition, that concatenates the
corresponding string in the run-time frame. At the semicolon
terminating the definition, drop the compile-time argument
frame and compile code to drop the run-time argument frame.
<ansref>"args-brace"</ansref>
Syntax for defining a string macro GEORGE:
: george ($: a$ b$ c$ -- cat$ )
args{ arg1 arg2 arg3 }
cat" This is arg1: " arg1 cat" ." ENDCAT ;
The blank following the last argument is required. For a
macro with no arguments, ARGS{ } does nothing but add
useless overhead and should be omitted. Two of the
arguments in this example are ignored and could have been
left out. Words intended only as steps in building a macro
would omit ENDCAT, which terminates concatenation and
leaves the concatenated string on the string stack.
Sample syntax using the string macro GEORGE:
$" bill" $" sue" $" marie" george $.
The resulting display is:
This is arg1: bill.
NOTE: Macro argument labels must be distinct from each other
and from any local labels that appear in the same definition,
and there is no check for that.
NOTE: At the moment the semantics of ARGS{ is undefined
before DOES>.
Name
argv:misc — ordinary primitive
Synopsis
FORTH
ARGV
( n -- addr u )(
)
;
p4:"argv";
Name
array-of:struct — ordinary primitive
Synopsis
EXTENSIONS
ARRAY-OF
( some-offset n len "name" -- some-offset )( | ) ; | |
Description
a FIELD-array
: ARRAY-OF * FIELD ;
Name
array-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
ARRAY:
( .. )(
)
;
as:"array-colon";
Description
ordinary primitive ARRAY:
an executable word (no special usage info)
or wrapper call around p4_array_of
Name
ascii:forth_usual — compiling primitive
Synopsis
FORTH
ASCII
( [word] -- val )(
)
;
p4:"ascii";
Description
state smart version of CHAR or [CHAR] resp.
simulate:
: ASCII [COMPILE] [CHAR]
STATE @ IF [COMPILE] LITERAL THEN ;
Name
assume-dumbterm:term — ordinary primitive
Synopsis
EXTENSIONS
ASSUME_DUMBTERM
( -- )( | ) ; | |
Description
load hardwired DUMBTERM-termcap into the terminal-driver
Name
assume-vt100:term — ordinary primitive
Synopsis
EXTENSIONS
ASSUME_VT100
( -- )(
)
;
p4:"assume-vt100";
Description
load hardwired VT100-termcap into the terminal-driver
Name
at-x-y:facility — ordinary primitive
Synopsis
FORTH
AT-XY
( col row -- )(
)
;
p4:"at-x-y";
Description
move the cursor position to the given row and column
of the screen. If the output device is not a terminal
this will have no effect but can still send an
escape sequence.
Name
atexit-minus-wordlist:chainlist.1 — - loader type P4_DVaL
Synopsis
EXTENSIONS
ATEXIT-WORDLIST
( .. )( | ) ; | |
Description
- loader type P4_DVaL ATEXIT-WORDLIST
atexit_wl (no special usage info)
Name
audio-s-sixteen:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
AUDIO_S16
( .. )(
)
;
as:"audio-s-sixteen";
Description
( AUDIO_S16 ) constant AUDIO_S16
an ordinary constant (no special usage info)
Name
audio-s-sixteen-lsb:lib_sdl.1 — ordinary constant
Description
( AUDIO_S16LSB ) constant AUDIO_S16LSB
an ordinary constant (no special usage info)
Name
audio-s-sixteen-msb:lib_sdl.1 — ordinary constant
Description
( AUDIO_S16MSB ) constant AUDIO_S16MSB
an ordinary constant (no special usage info)
Name
audio-s-sixteen-sys:lib_sdl.1 — ordinary constant
Description
( AUDIO_S16SYS ) constant AUDIO_S16SYS
an ordinary constant (no special usage info)
Name
audio-s-eight:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
AUDIO_S8
( .. )(
)
;
as:"audio-s-eight";
Description
( AUDIO_S8 ) constant AUDIO_S8
an ordinary constant (no special usage info)
Name
audio-u-sixteen:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
AUDIO_U16
( .. )(
)
;
as:"audio-u-sixteen";
Description
( AUDIO_U16 ) constant AUDIO_U16
an ordinary constant (no special usage info)
Name
audio-u-sixteen-lsb:lib_sdl.1 — ordinary constant
Description
( AUDIO_U16LSB ) constant AUDIO_U16LSB
an ordinary constant (no special usage info)
Name
audio-u-sixteen-msb:lib_sdl.1 — ordinary constant
Description
( AUDIO_U16MSB ) constant AUDIO_U16MSB
an ordinary constant (no special usage info)
Name
audio-u-sixteen-sys:lib_sdl.1 — ordinary constant
Description
( AUDIO_U16SYS ) constant AUDIO_U16SYS
an ordinary constant (no special usage info)
Name
audio-u-eight:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
AUDIO_U8
( .. )(
)
;
as:"audio-u-eight";
Description
( AUDIO_U8 ) constant AUDIO_U8
an ordinary constant (no special usage info)
Name
b-slash-buf:block_misc.1 — ordinary constant
Synopsis
EXTENSIONS
B/BUF
( .. )(
)
;
as:"b-slash-buf";
Description
( P4_BPBUF ) constant B/BUF
an ordinary constant (no special usage info)
Name
back:toolbelt — ordinary primitive
Synopsis
FORTH
BACK
( str len char -- str len-i )( | ) ; | |
Description
Look for a particular character in the string from the
back toward the front.
: BACK
>R BEGIN DUP WHILE
1- 2DUP + C@ R@ =
UNTIL 1+ THEN
R> DROP ;
Name
backspace:misc — ordinary primitive
Synopsis
FORTH
BACKSPACE
( -- )(
)
;
p4:"backspace";
Description
reverse of SPACE
Name
sharp-backspace-minus-char:forth_usual.1 — ordinary constant
Synopsis
FORTH
#BACKSPACE-CHAR
( .. )( | ) ; | |
Description
( '\b' ) constant #BACKSPACE-CHAR
an ordinary constant (no special usage info)
Name
sharp-backspace-minus-char:toolbelt.1 — ordinary constant
Synopsis
FORTH
#BACKSPACE-CHAR
( .. )( | ) ; | |
Description
( '\b' ) constant #BACKSPACE-CHAR
an ordinary constant (no special usage info)
Name
base:core.1 — threadstate variable
Description
threadstate variable BASE
base (no special usage info)
Name
begin:core — compiling primitive
Synopsis
FORTH
BEGIN
( -- )compile-time: ( -- cs-marker )( | ) ; | |
Name
behavior:header — ordinary primitive
Synopsis
EXTENSIONS
BEHAVIOR
( xt1 -- xt2 )(
)
;
p4:"behavior";
Description
get the execution token xt2 that would be executed by the DEFER
identified by xt1.
This command is used to obtain the execution contents of a deferred
word. A typical use would be to retrieve and save the execution
behavior of the deferred word, set the deferred word to a new behavior,
and then later restore the old behavior.
If the deferred word identified by _xt1_ is associated with some
other deferred word, _xt2_ is the execution token of that other
deferred word. To retrieve the execution token of the word currently
associated with that other deferred word, use the phrase BEHAVIOR BEHAVIOR .
Experience:
Many years of use in OpenBoot and OpenFirmware systems.
(Proposed for ANS Forth 2001)
In PFE it is the inverse of an IS operation and it will never fail
if applied to a word with atleast a body. That's just like IS can
be applied to almost every DOES> word where BEHAVIOR will get
the value back.
Name
dot-bell:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.BELL
( .. )(
)
;
as:"dot-bell";
Description
ordinary primitive .BELL
an executable word (no special usage info)
or wrapper call around p4_dot_bell
Name
bin:file — ordinary primitive
Synopsis
FORTH
BIN
( access-mode -- access-mode' )( | ) ; | |
Description
modify the give file access-mode to be a binary-mode
Name
store-bits:forth_83 — ordinary primitive
Synopsis
FORTH
!BITS
( bits addr mask -- )( | ) ; | |
Description
at the cell pointed to by addr, change only the bits that
are enabled in mask
simulate:
: !BITS >R 2DUP @ R NOT AND SWAP R> AND OR SWAP ! DROP ;
Name
fetch-bits:forth_83 — ordinary primitive
Synopsis
FORTH
@BITS
( addr mask -- value )( | ) ; | |
Description
see the companion word !BITS
simulate:
: @BITS SWAP @ AND ;
Name
bl:core.1 — ordinary constant
Description
( ' ' ) constant BL
an ordinary constant (no special usage info)
Name
bl-scan:toolbelt — ordinary primitive
Synopsis
FORTH
BL-SCAN
( str len -- str+i len-i )( | ) ; | |
Description
Look for white space from start of string
: BL-SCAN
BEGIN DUP WHILE OVER C@ IS-WHITE NOT
WHILE 1 /STRING REPEAT THEN ;
Name
bl-skip:toolbelt — ordinary primitive
Synopsis
FORTH
BL-SKIP
( str len -- str+i len-i )( | ) ; | |
Description
Skip over white space at start of string.
: BL-SKIP
BEGIN DUP WHILE OVER C@ IS-WHITE
WHILE 1 /STRING REPEAT THEN ;
Name
blank:string — ordinary primitive
Synopsis
FORTH
BLANK
( str-ptr str-len -- )(
)
;
p4:"blank";
Description
FILL a given buffer with BL blanks
Name
dot-blinking:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.BLINKING
( .. )(
)
;
as:"dot-blinking";
Description
ordinary primitive .BLINKING
an executable word (no special usage info)
or wrapper call around p4_dot_blink
Name
dot-blinking-dot-off:term.1 — ordinary primitive
Description
ordinary primitive .BLINKING.OFF
an executable word (no special usage info)
or wrapper call around p4_dot_blink_off
Name
blk:block.1 — threadstate variable
Description
threadstate variable BLK
input.blk (no special usage info)
Name
block:block — ordinary primitive
Synopsis
FORTH
BLOCK
( u -- addr )(
)
;
p4:"block";
Description
load the specified block into a block buffer
and return the address of that block buffer
- see also BUFFER
Name
block-minus-ext:block::environment — ordinary constant
Synopsis
ENVIRONMENT
BLOCK-EXT
( .. )(
)
;
as:"block-minus-ext";
Description
( 1994 ) constant BLOCK-EXT
an ordinary constant (no special usage info)
Name
block-minus-file:block_misc.1 — - loader type P4_DVaL
Synopsis
EXTENSIONS
BLOCK-FILE
( .. )(
)
;
as:"block-minus-file";
Description
- loader type P4_DVaL BLOCK-FILE
input.block_file (no special usage info)
Name
to-body:core — ordinary primitive
Synopsis
FORTH
>BODY
( addr -- addr' )(
)
;
p4:"to-body";
Description
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 +"
Name
body-from:header — ordinary primitive
Synopsis
FORTH
BODY>
( pfa -- cfa )(
)
;
p4:"body-from";
Description
trying to convert a pointer to the parameter-field (PFA) to point
then to the corresponding code-field (CFA) - note that this is not
necessarily the inverse of >BODY instead it is a fast implementation
assuming a VARIABLE thing had been used. Every use of "BODY>" is
warned in the logfile.
implementation-specific simulation:
: BODY> CELL - ;
Name
boot-script-colon:host_k12 — ordinary primitive
Synopsis
FORTH
BOOT-SCRIPT:
( "string" -- )( | ) ; | |
Description
DO NOT USE! will vanish w/o warning in the next version!
see BOOT-SCRIPT@
Name
boot-script-fetch:host_k12 — ordinary primitive
Synopsis
FORTH
BOOT-SCRIPT@
( -- s-a s-n )( | ) ; | |
Description
the file that will be include on next COLD boot
DO NOT USE! will vanish w/o warning in the next version!
Name
bounds:forth_usual — ordinary primitive
Synopsis
FORTH
BOUNDS
( str len -- str+len str )( | ) ; | |
Description
Convert _str len_ to range for DO-loop.
: BOUNDS ( str len -- str+len str ) OVER + SWAP ;
Name
bounds:toolbelt — ordinary primitive
Synopsis
FORTH
BOUNDS
( str len -- str+len str )( | ) ; | |
Description
Convert _str len_ to range for DO-loop.
: BOUNDS ( str len -- str+len str ) OVER + SWAP ;
Name
branch:system.1 — ordinary primitive
Synopsis
FORTH
BRANCH
( .. )(
)
;
as:"branch";
Description
ordinary primitive BRANCH
an executable word (no special usage info)
or wrapper call around p4_else_execution
Name
question-branch:system.1 — ordinary primitive
Synopsis
FORTH
?BRANCH
( .. )(
)
;
as:"question-branch";
Description
ordinary primitive ?BRANCH
an executable word (no special usage info)
or wrapper call around p4_if_execution
Name
str-break:dstrings.1 — ordinary primitive
Synopsis
FORTH
$BREAK
( .. )(
)
;
as:"str-break";
Description
ordinary primitive $BREAK
an executable word (no special usage info)
or wrapper call around str_break
Name
str-buffer:dstrings.1 — ordinary primitive
Synopsis
FORTH
$BUFFER
( .. )(
)
;
as:"str-buffer";
Description
ordinary primitive $BUFFER
an executable word (no special usage info)
or wrapper call around str_buffer
Name
buffer:block — ordinary primitive
Synopsis
FORTH
BUFFER
( u -- addr )(
)
;
p4:"buffer";
Description
get the block buffer address for the specified
block - if it had not been loaded already it
is not filled with data from the disk
unlike BLOCK does.
Name
buffer-var:misc — ordinary primitive
Synopsis
FORTH
BUFFER:
( size 'name' -- )( | ) ; | |
Description
this creates a name with the VARIABLE runtime and ALLOTs memory
: BUFFER: BL WORD $HEADER DOVAR A, ALLOT ;
Name
build-array:misc — ordinary primitive
Synopsis
FORTH
BUILD-ARRAY
( n1 n2 ... nX X --- n )( | ) ; | |
Description
writes X, n1, ... nX into the dictionary -
returns product n1 * n2 * ... * nX
Name
builds:core — definining primitive
Synopsis
FORTH
<BUILDS
( 'name' -- )(
)
;
p4:"builds";
Description
make a HEADER whose runtime will be changed later
using DOES>
note that ans'forth does not define <BUILDS and
it suggests to use CREATE directly.
... if you want to write FIG-programs in pure pfe then you have
to use CREATE: to get the FIG-like meaning of CREATE whereas
the ans-forth CREATE is the same as <BUILDS
: <BUILDS BL WORD HEADER DOCREATE A, 0 A, ;
Name
bye:tools — ordinary primitive
Synopsis
FORTH
BYE
( -- )no-return(
)
;
p4:"bye";
Description
should quit the forth environment completly
Name
c-store:core — ordinary primitive
Synopsis
FORTH
C!
( value address -- )(
)
;
p4:"c-store";
Description
store the byte-value at address, see !
Name
c-quote:core — compiling primitive
Synopsis
FORTH
C"
( [string<">] -- bstring )( | ) ; | |
Description
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"
Name
c-plus-store:forth_usual — ordinary primitive
Synopsis
FORTH
C+!
( n addr -- )(
)
;
p4:"c-plus-store";
Description
Add the low-order byte of _n_ to the byte at _addr_,
removing both from the stack.
Name
c-plus-store:toolbelt — ordinary primitive
Synopsis
FORTH
C+!
( n addr -- )(
)
;
p4:"c-plus-store";
Description
Add the low-order byte of _n_ to the byte at _addr_,
removing both from the stack.
Name
c-plus-place:forth_usual.1 — ordinary primitive
Synopsis
FORTH
C+PLACE
( .. )(
)
;
as:"c-plus-place";
Description
ordinary primitive C+PLACE
an executable word (no special usage info)
or wrapper call around p4_append_char
Name
c-comma:core — ordinary primitive
Synopsis
FORTH
C,
( value -- )(
)
;
p4:"c-comma";
Description
store a new byte-value in the dictionary, implicit 1 ALLOT,
see ,
Name
c-fetch:core — ordinary primitive
Synopsis
FORTH
C@
( addr -- value )(
)
;
p4:"c-fetch";
Description
fetch a byte-value from the address, see @
Name
call-minus-c:dlfcn.1 — ordinary primitive
Synopsis
EXTENSIONS
CALL-C
( .. )(
)
;
as:"call-minus-c";
Description
ordinary primitive CALL-C
an executable word (no special usage info)
or wrapper call around p4_call_c
Name
case:core — compiling primitive
Synopsis
FORTH
CASE
( comp-value -- comp-value )( | ) ; | |
Description
start a CASE construct that ends at ENDCASE
and compares the value on stack at each OF place
Name
case-sensitive-voc:useful — ordinary primitive
Synopsis
EXTENSIONS
CASE-SENSITIVE-VOC
( -- )( | ) ; | |
Description
accesses CONTEXT which is generally the last named VOCABULARY .
sets a flag in the vocabulary-definition so that words are matched
case-sensitive.
example:
VOCABULARY MY-VOC MY-VOC CASE-SENSITIVE-VOC
OBSOLETE! use DEFS-ARE-CASE-SENSITIVE
Name
case-minus-sensitive-question:environ::environment — ordinary primitive
Synopsis
ENVIRONMENT
CASE-SENSITIVE?
( .. )( | ) ; | |
Description
ordinary primitive CASE-SENSITIVE?
an executable word (no special usage info)
or wrapper call around p__case_sensitive_Q
Name
case-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
CASE_MAGIC
( .. )(
)
;
as:"case-magic";
Description
( P4_CASE_MAGIC ) constant CASE_MAGIC
an ordinary constant (no special usage info)
Name
cat:dstrings — ordinary primitive
Synopsis
FORTH
CAT
($: a$ -- )(
)
;
p4:"cat";
Description
Append the string body to the end of the string currently
being concatenated as the last string in the string buffer,
and update its count field. If there is no concatenating
string, start one. An error is thrown if the size of the
combined string would be larger than MAX_MCOUNT or if there
is not enough room in string space even after a garbage
collection.
If garbage collection occurs, a$ remains valid even when
it is in the string buffer.
When there is a concatenating string, concatenation is the
only basic string operation that can copy a string into the
string buffer. <ansref>"cat"</ansref>
NOTE: It is left to the user to define special concatenating
words like:
: \n-cat ( -- ) \n$ cat ;
Name
cat-quote:dstrings — compiling primitive
Synopsis
FORTH
CAT"
( "ccc<quote>" -- )(
)
;
p4:"cat-quote";
Description
This word has only compile-time semantics, just like CAT`.
It appends run-time semantics to the current definition that
concatenates the quoted string according to the specification
for CAT. An error is thrown if the length of the quoted
string is longer than the system parameter MAX_DATA_STR (see
S,). <ansref>"cat-quote"</ansref>
Name
catch:exception — ordinary primitive
Synopsis
FORTH
CATCH
( xt -- 0|n )(
)
;
p4:"catch";
Description
execute the given execution-token and catch
any exception that can be caught therein.
software can arbitrarily raise an exception
using THROW - the value 0 means there
was no exception, other denote implementation
dependent exception-codes.
Name
cat-back-tick:dstrings — compiling primitive
Synopsis
FORTH
CAT`
( "ccc<backtick>" -- )( | ) ; | |
Description
This word has only compile-time semantics, just like
CAT". It appends run-time semantics to the current
definition that concatenates the back-ticked string according
to the specification for CAT. An error is thrown if the
length of the quoted string is longer than the system
parameter MAX_DATA_STR (see S,).
<ansref>"cat-back-tick"</ansref>
Name
cd:shell.1 — obsolete forthword
Description
obsolete forthword CD
is doing the same as CHDIR
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
slash-cell:misc.1 — ordinary constant
Synopsis
FORTH
/CELL
( .. )(
)
;
as:"slash-cell";
Description
( sizeof (p4cell) ) constant /CELL
an ordinary constant (no special usage info)
Name
cell:toolbelt.1 — ordinary constant
Description
( sizeof(p4cell) ) constant CELL
an ordinary constant (no special usage info)
Name
minus-cell:toolbelt.1 — ordinary constant
Synopsis
FORTH
-CELL
( .. )(
)
;
as:"minus-cell";
Description
( - sizeof(p4cell) ) constant -CELL
an ordinary constant (no special usage info)
Name
cell-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
CELL%
( .. )(
)
;
as:"cell-percent";
Description
ordinary primitive CELL%
an executable word (no special usage info)
or wrapper call around p4_cell_mod
Name
cell-plus:core — ordinary primitive
Synopsis
FORTH
CELL+
( value -- value' )(
)
;
p4:"cell-plus";
Description
adjust the value by adding a single Cell's width
- the value is often an address or offset, see CELLS
Name
cell-minus:toolbelt — ordinary primitive
Synopsis
FORTH
CELL-
( addr -- addr' )(
)
;
p4:"cell-minus";
Description
Decrement address by one cell
: CELL- ( addr -- addr' ) CELL - ;
Name
cell-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
CELL:
( .. )(
)
;
as:"cell-colon";
Description
ordinary primitive CELL:
an executable word (no special usage info)
or wrapper call around p4_cell_colon
Name
cells:core — ordinary primitive
Synopsis
FORTH
CELLS
( value -- value' )(
)
;
p4:"cells";
Description
scale the value by the sizeof a Cell
the value is then often applied to an address or
fed into ALLOT
Name
cells-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
CELLS:
( .. )(
)
;
as:"cells-colon";
Description
ordinary primitive CELLS:
an executable word (no special usage info)
or wrapper call around p4_cells_colon
Name
cfa-tick:core.1 — ordinary primitive
Synopsis
FORTH
CFA'
( .. )(
)
;
as:"cfa-tick";
Description
ordinary primitive CFA'
an executable word (no special usage info)
or wrapper call around p4_tick
Name
dot-chain:chain — ordinary primitive
Synopsis
EXTENSIONS
.chain
( chain* -- )(
)
;
p4:"dot-chain";
Description
show chain - compare with WORDS
Name
chain-add:chain — ordinary primitive
Synopsis
EXTENSIONS
chain-add
( chain* "word-to-add" -- )( | ) ; | |
Description
add chain item, for normal setup, at end of do-chain
: chain-add ' >r begin dup @ while @ repeat here swap ! 0 , r> , ;
( chain-add begin dup @ while @ repeat here swap ! 0, ' , )
Name
chain-add-before:chain — ordinary primitive
Synopsis
EXTENSIONS
chain-add-before
( chain* "word-to-add" -- )( | ) ; | |
Description
add chain item, for reverse chain like BYE
: chain-add-before ' >r here over @ , r> , swap ! ;
( chain-add-before link, ' , )
Name
chain-minus-link:chain.1 — threadstate variable
Synopsis
EXTENSIONS
chain-link
( .. )(
)
;
as:"chain-minus-link";
Description
threadstate variable chain-link
chain_link (no special usage info)
Name
chain-minus-wordlists:search::environment — ordinary constant
Synopsis
ENVIRONMENT
CHAIN-WORDLISTS
( .. )( | ) ; | |
Description
( P4_TRUE ) constant CHAIN-WORDLISTS
an ordinary constant (no special usage info)
Name
gforth-chained:gforth — ordinary primitive
Synopsis
gforth'
chained
( xt list -- )\ gforth( | ) ; | |
Description
generic chains
: chained linked , ;
Name
gforth-chainperform:gforth — ordinary primitive
Synopsis
gforth'
chainperform
( list -- )\ gforth( | ) ; | |
Description
: chainperform BEGIN @ dup WHILE dup cell+ perform REPEAT drop ;
Name
dot-chains:chain — ordinary primitive
Synopsis
EXTENSIONS
.chains
( -- )(
)
;
p4:"dot-chains";
Description
show all chains registered in the system - compare with VLIST
Name
slash-char:useful.1 — ordinary constant
Synopsis
EXTENSIONS
/CHAR
( .. )(
)
;
as:"slash-char";
Description
( sizeof(p4char) ) constant /CHAR
an ordinary constant (no special usage info)
Name
char:core — ordinary primitive
Synopsis
FORTH
CHAR
( 'word' -- value )(
)
;
p4:"char";
Description
return the (ascii-)value of the following word's
first character.
Name
char-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
CHAR%
( .. )(
)
;
as:"char-percent";
Description
ordinary primitive CHAR%
an executable word (no special usage info)
or wrapper call around p4_char_mod
Name
char-plus:core — ordinary primitive
Synopsis
FORTH
CHAR+
( value -- value' )(
)
;
p4:"char-plus";
Description
increment the value by the sizeof one char
- the value is often a pointer or an offset,
see CHARS
Name
char-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
CHAR:
( .. )(
)
;
as:"char-colon";
Description
ordinary primitive CHAR:
an executable word (no special usage info)
or wrapper call around p4_char_colon
Name
chars:core — ordinary primitive
Synopsis
FORTH
CHARS
( value -- value' )(
)
;
p4:"chars";
Description
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?)
Name
sharp-chars-slash-line:toolbelt.1 — ordinary constant
Description
( 80 ) constant #CHARS/LINE
an ordinary constant (no special usage info)
Name
chars-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
CHARS:
( .. )(
)
;
as:"chars-colon";
Description
ordinary primitive CHARS:
an executable word (no special usage info)
or wrapper call around p4_chars_colon
Name
bracket-char:core — compiling primitive
Synopsis
FORTH
[CHAR]
( [word] -- char )( | ) ; | |
Description
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
Name
chdir:shell — ordinary primitive
Synopsis
EXTENSIONS
CHDIR
( bstring -- )(
)
;
p4:"chdir";
Description
change the current directory. <br>
Note
(under VxWorks it is global! do not use in scripts!!)
Name
clearstack:misc — ordinary primitive
Synopsis
FORTH
CLEARSTACK
( -- )(
)
;
p4:"clearstack";
Description
reset the parameter stack to be empty
: CLEARSTACK S0 SP! ;
Name
clk-tck:posix::environment — ordinary primitive
Synopsis
ENVIRONMENT
CLK_TCK
( .. )(
)
;
as:"clk-tck";
Description
ordinary primitive CLK_TCK
an executable word (no special usage info)
or wrapper call around p4__clk_tck
Name
clock:posix — ordinary primitive
Synopsis
EXTENSIONS
CLOCK
( --- ticks )(
)
;
"clock";
Description
return clock()
Name
close-all-files:misc — ordinary primitive
Synopsis
FORTH
CLOSE-ALL-FILES
( -- )( | ) ; | |
Name
close-blockfile:block_misc — ordinary primitive
Synopsis
FORTH
CLOSE-BLOCKFILE
( -- )w32for( | ) ; | |
Description
w32for-implementation:
blockhandle -1 <> if flush close-file drop then
-1 set-blockfile
in pfe:
: CLOSE-BLOCKFILE
BLOCK-FILE ?DUP IF FLUSH CLOSE-FILE DROP THEN
OFF> BLOCK-FILE ;
Name
gforth-close-dir:gforth — ordinary primitive
Synopsis
gforth'
close-dir
( wdirid -- wior )gforth close_dir( | ) ; | |
Description
will vanish without warning. see gforth documentation.
Name
close-file:file — ordinary primitive
Synopsis
FORTH
CLOSE-FILE
( file -- code )( | ) ; | |
Description
close the file and return the status-code
Name
close-terminal-logfile:host_k12 — ordinary primitive
Synopsis
EXTENSIONS
CLOSE-TERMINAL-LOGFILE
( -- )( | ) ; | |
Name
dot-clreol:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.CLREOL
( .. )(
)
;
as:"dot-clreol";
Description
ordinary primitive .CLREOL
an executable word (no special usage info)
or wrapper call around p4_dot_clreol
Name
dot-clrscr:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.CLRSCR
( .. )(
)
;
as:"dot-clrscr";
Description
ordinary primitive .CLRSCR
an executable word (no special usage info)
or wrapper call around p4_dot_clrscr
Name
cls:term.1 — ordinary primitive
Description
ordinary primitive CLS
an executable word (no special usage info)
or wrapper call around p4_dot_clrscr
Name
cmove:string — ordinary primitive
Synopsis
FORTH
CMOVE
( from-ptr to-ptr len -- )( | ) ; | |
Description
memcpy an area from->to for len bytes, starting at
the lower addresses, see CMOVE>
Name
cmove-up:string — ordinary primitive
Synopsis
FORTH
CMOVE>
( from-ptr to-ptr len -- )( | ) ; | |
Description
memcpy an area from->to for len bytes, starting
with the higher addresses, see CMOVE
Name
cold:misc — ordinary primitive
Description
cold abort - reinitialize everything and go to QUIT routine
... this routine is implemented as a warm-boot in pfe.
: WARM FENCE @ (FORGET) INCLUDE-FILE ?DUP IF COUNT INCLUDED THEN QUIT ;
Name
collect-str-garbage:dstrings — ordinary primitive
Synopsis
FORTH
COLLECT-$GARBAGE
( -- collected-flag )( | ) ; | |
Description
If string space is not marked as containing garbage, return
false. If there is garbage, throw an error when garbage
collection is disabled. Otherwise remove the garbage and return
true. Garbage collection is "transparent", so the user would
not normally use this word.
<ansref>"collect-string-garbage"</ansref>
Name
cols:term.1 — threadstate variable
Description
threadstate variable COLS
cols (no special usage info)
Name
come-back:debug — ordinary primitive
Synopsis
FORTH
COME_BACK
( -- )(
)
;
p4:"come-back";
Description
show the return stack before last exception
along with the best names as given by ADDR>NAME
Name
Q-comp:tools_misc — ordinary primitive
Synopsis
FORTH
?COMP
( -- )(
)
;
p4:"Q-comp";
Description
check that the current STATE is compiling
otherwise THROW
<br> often used in control-words
Name
compare:string — ordinary primitive
Synopsis
FORTH
COMPARE
( str-ptr1 str-len1 str-ptr2 str-len2 -- n )( | ) ; | |
Description
compare both str-buffers, return 0 if they are equal,
-1 if lower or shorter, and 1 if greater or longer
Name
compile:forth_83 — compiling primitive
Synopsis
FORTH
COMPILE
( 'word' -- )(
)
;
p4:"compile";
Description
compile the next word. The next word should not be immediate,
in which case you would have to use [COMPILE]. For this
reason, you should use the word POSTPONE, which takes care
it.
simulate:
: COMPILE R> DUP @ , CELL+ >R ; ( not immediate !!! )
Name
to-compile:useful — ordinary primitive
Synopsis
EXTENSIONS
>COMPILE
( xt -- )(
)
;
p4:"to-compile";
Description
does the work of POSTPONE on the execution token that
you got from somewhere else - so it checks if the name
(that correspond to the execution-token argument) is
actually immediate, so it has to be executed to compile
something, e.g. IF or THEN - see also POSTPONE ,
COMPILE , [COMPILE] , INTERPRET
Name
compile-comma:core — ordinary primitive
Synopsis
FORTH
COMPILE,
( xt -- )(
)
;
p4:"compile-comma";
Description
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
Name
bracket-compile:core — immediate primitive
Synopsis
FORTH
[COMPILE]
( [word] -- )( | ) ; | |
Description
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
Name
constant:core — definining primitive
Synopsis
FORTH
CONSTANT
( value 'name' -- )( | ) ; | |
Description
CREATE a new word with runtime ((CONSTANT))
so that the value placed here is returned everytime
the constant's name is used in code. See VALUE
for constant-like names that are expected to change
during execution of the program. In a ROM-able
forth the CONSTANT-value may get into a shared
ROM-area and is never copied to a RAM-address.
Name
two-constant:double — definining primitive
Synopsis
FORTH
2CONSTANT
( x1 x2 "name" -- )( | ) ; | |
Description
create a word that contains the specified twocell number in its body.
when the name is executed, these numbers are left on the stack
12. 2CONSTANT X .s
<emtpy stack> ok
X .s
0 12 ok
Name
str-constant:dstrings — definining primitive
Synopsis
FORTH
$CONSTANT
( "name" $: a$ -- )( | ) ; | |
Description
Create a definition for "name" with the execution semantics
"name" execution: ($: -- a$ )
It is assumed that the input string resides as a measured,
unchanging string outside of string space.
<ansref>"string-constant"</ansref>
For example:
$" This is a sample string." $constant sample$
Name
offset-constant:useful — definining primitive
Synopsis
EXTENSIONS
+CONSTANT
( offset "name" -- )( | ) ; | |
Description
create a new offsetword. The word is created and upon execution
it adds the offset, ie. compiling the OFFSET-RT runtime:
( address -- address+offset )
This word is just a convenience word, just use the word +FIELD
directly and choose a DROP to flag the end of a current
offset-field declaration series. See also /FIELD series to
declare simple structures which end with a final CONSTANT to
memorize the complete size. The /FIELD style is more traditional.
Name
context:system.1 — - loader type P4_DVaL
Synopsis
FORTH
CONTEXT
( .. )(
)
;
as:"context";
Description
- loader type P4_DVaL CONTEXT
context (no special usage info)
Name
context-Q:useful — ordinary primitive
Synopsis
EXTENSIONS
CONTEXT?
( -- number )(
)
;
p4:"context-Q";
Description
GET-CONTEXT and count how many times it is in the order but
the CONTEXT variable itself. The returned number is therefore
minus one the occurences in the complete search-order.
usage:
ALSO EXTENSIONS CONTEXT? [IF] PREVIOUS [THEN]
ALSO DEF' DEFAULT-ORDER
: CONTEXT?
0 LVALUE _count
GET-ORDER 1- SWAP LVALUE _context
0 ?DO _context = IF 1 +TO _count THEN LOOP
_count
;
Name
control:forth_usual — compiling primitive
Synopsis
FORTH
CONTROL
( [word] -- val )(
)
;
p4:"control";
Description
see ASCII, but returns char - '@'
simulate:
: CONTROL [COMPILE] [CHAR] [CHAR] @ -
STATE @ IF [COMPILE] LITERAL THEN ;
Name
convert:core — ordinary primitive
Synopsis
FORTH
CONVERT
( a b -- a b )(
)
;
p4:"convert";
Description
digit conversion, obsolete, superseded by >NUMBER
Name
copy-file:file_misc — ordinary primitive
Synopsis
FORTH
COPY-FILE
( src-str src-strlen dst-str dst-strlen -- errno|0 )( | ) ; | |
Description
like RENAME-FILE, copies the file from src-name to dst-name
and returns an error-code or null
Name
core-minus-ext:core::environment — ordinary constant
Synopsis
ENVIRONMENT
CORE-EXT
( .. )(
)
;
as:"core-minus-ext";
Description
( 1994 ) constant CORE-EXT
an ordinary constant (no special usage info)
Name
count:core — ordinary primitive
Synopsis
FORTH
COUNT
( counted-string -- string-pointer string-length )( | ) ; | |
Description
usually before calling TYPE
Name
slash-counted-minus-string:core::environment — ordinary constant
Synopsis
ENVIRONMENT
/COUNTED-STRING
( .. )( | ) ; | |
Description
( UCHAR_MAX ) constant /COUNTED-STRING
an ordinary constant (no special usage info)
Name
cp:shell.1 — compiling primitive
Description
compiling primitive CP
an executable word (no special usage info)
or wrapper call around p4_cp
Name
cr:core — ordinary primitive
Description
print a carriage-return/new-line on stdout
Name
Q-cr:misc — ordinary primitive
Synopsis
FORTH
?CR
( -- flag )(
)
;
p4:"Q-cr";
Description
like CR , stop 25 lines past START?CR
Name
create:core.1 — forthword synonym
Synopsis
FORTH
CREATE
( .. )(
)
;
as:"create";
Description
forthword synonym CREATE
is doing the same as <BUILDS
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
create-blockfile:block_misc — ordinary primitive
Synopsis
FORTH
CREATE-BLOCKFILE
( n "filename" -- )w32for( | ) ; | |
Description
w32for-implementation:
close-blockfile
parse-word r/w create-file abort" failed to create block-file"
set-blockfile
dup b/buf m* blockhandle resize-file
abort" unable to create a file of that size"
empty-buffers
0 do i wipe loop
flush
pfe does not wipe the buffers
Name
create-file:file — ordinary primitive
Synopsis
FORTH
CREATE-FILE
( str-adr str-len mode -- file code )( | ) ; | |
Description
create the file with the given name and open
it - returns the file id and a status code.
A code of zero means success. An existing file
of the same name is truncated upon open.
Name
create-var:misc — ordinary primitive
Synopsis
FORTH
CREATE:
( 'name' -- )(
)
;
p4:"create-var";
Description
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, ;
Name
c-reset:forth_usual — ordinary primitive
Synopsis
FORTH
CRESET
( n addr -- )(
)
;
p4:"c-reset";
Description
reset bits in byte at given address
simulate:
: CRESET TUCK @ SWAP NOT AND SWAP ! ;
Name
cs-minus-drop:tools_misc.1 — ordinary primitive
Synopsis
FORTH
CS-DROP
( .. )(
)
;
as:"cs-minus-drop";
Description
ordinary primitive CS-DROP
an executable word (no special usage info)
or wrapper call around p4_two_drop
Name
cs-pick:tools — ordinary primitive
Synopsis
FORTH
CS-PICK
( 2a 2b 2c ... n -- 2a 2b 2c ... 2a )( | ) ; | |
Description
pick a value in the compilation-stack - note that the compilation
stack _can_ be seperate in some forth-implemenations. In PFE
the parameter-stack is used in a double-cell fashion, so CS-PICK
would 2PICK a DP-mark and a COMP-magic, see PICK
Name
cs-roll:tools — ordinary primitive
Synopsis
FORTH
CS-ROLL
( 2a 2b 2c ... n -- 2b 2c ... 2a )( | ) ; | |
Description
roll a value in the compilation-stack - note that the compilation
stack _can_ be seperate in some forth-implemenations. In PFE
the parameter-stack is used in a double-cell fashion, so CS-ROLL
would 2ROLL a DP-mark and a COMP-magic, see ROLL
Name
cs-minus-swap:tools_misc.1 — ordinary primitive
Synopsis
FORTH
CS-SWAP
( .. )(
)
;
as:"cs-minus-swap";
Description
ordinary primitive CS-SWAP
an executable word (no special usage info)
or wrapper call around p4_two_swap
Name
c-set:forth_usual — ordinary primitive
Synopsis
FORTH
CSET
( n addr -- )(
)
;
p4:"c-set";
Description
set bits in byte at given address
simulate:
: CSET TUCK @ SWAP OR SWAP ! ;
Name
csp:tools_misc.1 — threadstate variable
Description
threadstate variable CSP
csp (no special usage info)
Name
store-csp:tools_misc — ordinary primitive
Synopsis
FORTH
!CSP
( -- )(
)
;
p4:"store-csp";
Description
put SP into CSP
<br> used in control-words
Name
Q-csp:tools_misc — ordinary primitive
Synopsis
FORTH
?CSP
( -- )(
)
;
p4:"Q-csp";
Description
check that SP == CSP otherwise THROW
<br> used in control-words
Name
c-toggle:forth_usual — ordinary primitive
Synopsis
FORTH
CTOGGLE
( n addr -- )(
)
;
p4:"c-toggle";
Description
toggle bits in byte at given address
simulate:
: CTOGGLE TUCK @ SWAP XOR SWAP ! ;
Name
current:system.1 — threadstate variable
Synopsis
FORTH
CURRENT
( .. )(
)
;
as:"current";
Description
threadstate variable CURRENT
current (no special usage info)
Name
dot-date:core_misc — ordinary primitive
Synopsis
FORTH
.CVERSION
( -- )(
)
;
p4:"dot-date";
Description
show the compile date of the current PFE system
: .CVERSION [ ENVIRONMENT ] FORTH-NAME TYPE FORTH-DATE TYPE ;
Name
cwd:shell — ordinary primitive
Synopsis
EXTENSIONS
$CWD
( -- str-ptr str-len )(
)
;
p4:"cwd";
Description
calls system's
getcwd
Name
c-backslash-quote:zchar.1 — compiling primitive
Synopsis
FORTH
C\"
( .. )(
)
;
as:"c-backslash-quote";
Description
compiling primitive C\"
an executable word (no special usage info)
or wrapper call around p4_c_backslash_quote
Name
d-plus:double — ordinary primitive
Synopsis
FORTH
D+
( d1.ud1 d2.ud2 -- d3.ud3 )( | ) ; | |
Description
the double-cell sum operation ( + )
Name
d-minus:double.1 — ordinary primitive
Synopsis
FORTH
D-
( .. )(
)
;
as:"d-minus";
Description
ordinary primitive D-
an executable word (no special usage info)
or wrapper call around p4_d_minus
Name
d-dot:double — ordinary primitive
Synopsis
FORTH
D.
( d1.d1 -- )(
)
;
p4:"d-dot";
Description
freefield output for a double-cell number ( . )
Name
d-dot-r:double — ordinary primitive
Synopsis
FORTH
D.R
( d1.d1 n -- )(
)
;
p4:"d-dot-r";
Description
aligned output for a double-cell number ( .R )
Name
d-zero-less:double — ordinary primitive
Synopsis
FORTH
D0<
( d1.d1 -- flag )(
)
;
p4:"d-zero-less";
Description
the double-cell less-than-zero operation ( 0< )
Name
d-zero-equals:double — ordinary primitive
Synopsis
FORTH
D0=
( d1.d1 -- flag )(
)
;
p4:"d-zero-equals";
Description
the double-cell equal-to-zero operation ( 0= )
Name
d-two-star:double — ordinary primitive
Synopsis
FORTH
D2*
( d1.d1 -- d1.d1' )(
)
;
p4:"d-two-star";
Description
the double-cell arithmetic shiftleft-by-1 operation ( 2* )
Name
d-two-slash:double — ordinary primitive
Synopsis
FORTH
D2/
( d1.d1 -- d1.d1' )(
)
;
p4:"d-two-slash";
Description
the double-cell arithmetic shiftright-by-1 operation ( 2/ )
Name
d-less:double — ordinary primitive
Synopsis
FORTH
D<
( d1.d1 d2.d2 -- flag )(
)
;
p4:"d-less";
Description
the double-cell is-less operation ( < )
Name
d-equals:double — ordinary primitive
Synopsis
FORTH
D=
( d1.d1 d2.d2 -- flag )(
)
;
p4:"d-equals";
Description
the double-cell is-equal operation ( = )
Name
d-back-f:floating.1 — ordinary primitive
Synopsis
FORTH
D>F
( .. )(
)
;
as:"d-back-f";
Description
ordinary primitive D>F
an executable word (no special usage info)
or wrapper call around p4_d_to_f
Name
d-back-f:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
D>F
( .. )(
)
;
as:"d-back-f";
Description
ordinary primitive D>F
an executable word (no special usage info)
or wrapper call around p4_nofp_d_to_f
Name
d-to-s:double — ordinary primitive
Synopsis
FORTH
D>S
( d.d -- n )(
)
;
p4:"d-to-s";
Description
result is the numeric equivalent of d. If the double number was
greater than what could fit into a single cell number, the
modulo cellsize will be left since the higher-significant bits
are just DROPed
Name
d-abs:double — ordinary primitive
Synopsis
FORTH
DABS
( d1.d1 -- d1.d1' )(
)
;
p4:"d-abs";
Description
the double-cell abs operation ( ABS )
Name
debug:debug — ordinary primitive
Synopsis
FORTH
DEBUG
( 'word' -- )(
)
;
p4:"debug";
Description
this word will place an debug-runtime into
the CFA of the following word. If the
word gets executed later, the user will
be prompted and can decide to single-step
the given word. The debug-stepper is
interactive and should be self-explanatory.
(use NO-DEBUG to turn it off again)
Name
decimal:core — ordinary primitive
Synopsis
FORTH
DECIMAL
( -- )(
)
;
p4:"decimal";
Description
set the BASE to 10
simulate:
: DECIMAL 10 BASE ! ;
Name
def-tick:useful.1 — obsolete immediate
Synopsis
EXTENSIONS
DEF'
( .. )(
)
;
as:"def-tick";
Description
obsolete immediate DEF'
is doing the same as [DEF]
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
default-order:search — ordinary primitive
Synopsis
FORTH
DEFAULT-ORDER
( -- )(
)
;
p4:"default-order";
Description
nail the current search ORDER so that it will even
survive a trap-condition. This default-order can be
explicitly loaded with RESET-ORDER
Name
defer:header — definining primitive
Synopsis
EXTENSIONS
DEFER
( 'word' -- )(
)
;
p4:"defer";
Description
create a new word with ((DEFER))-semantics
simulate:
: DEFER CREATE 0, DOES> ( the ((DEFER)) runtime )
@ ?DUP IF EXECUTE THEN ;
: DEFER DEFER-RT HEADER 0 , ;
declare as <c>"DEFER deferword"</c> <br>
and set as <c>"['] executionword IS deferword"</c>
(in pfe, you can also use
TO deferword
to set the execution)
Name
sharp-define:cdecl.1 — ordinary primitive
Synopsis
FORTH
#DEFINE
( .. )(
)
;
as:"sharp-define";
Description
ordinary primitive #DEFINE
an executable word (no special usage info)
or wrapper call around p4_sh_define
Name
defined:core_misc.1 — ordinary primitive
Synopsis
FORTH
DEFINED
( .. )(
)
;
as:"defined";
Description
ordinary primitive DEFINED
an executable word (no special usage info)
or wrapper call around p4_defined
Name
defined:tools_misc.1 — ordinary primitive
Synopsis
FORTH
DEFINED
( .. )(
)
;
as:"defined";
Description
ordinary primitive DEFINED
an executable word (no special usage info)
or wrapper call around p4_defined
Name
defined:core_misc — immediate primitive
Synopsis
FORTH
[DEFINED]
( [name] -- flag )( | ) ; | |
Description
Search the dictionary for _name_. If _name_ is found,
return TRUE; otherwise return FALSE. Immediate for use in
definitions.
This word will actually return what FIND returns (the NFA).
does check for the word using find (so it does not throw like ' )
and puts it on stack. As it is immediate it does work in compile-mode
too, so it places its argument in the cs-stack then. This is most
useful with a directly following [IF] clause, so that sth. like
an
[IFDEF] word
can be simulated through
[DEFINED] word [IF]
: [DEFINED] DEFINED ; IMMEDIATE
: [DEFINED] BL WORD COUNT (FIND-NFA) ; IMMEDIATE
Name
defined:toolbelt — immediate primitive
Synopsis
FORTH
[DEFINED]
( [name] -- flag )( | ) ; | |
Description
Search the dictionary for _name_. If _name_ is found,
return TRUE; otherwise return FALSE. Immediate for use in
definitions.
This word will actually return what FIND returns (the NFA).
does check for the word using find (so it does not throw like ' )
and puts it on stack. As it is immediate it does work in compile-mode
too, so it places its argument in the cs-stack then. This is most
useful with a directly following [IF] clause, so that sth. like
an
[IFDEF] word
can be simulated through
[DEFINED] word [IF]
: [DEFINED] DEFINED ; IMMEDIATE
: [DEFINED] BL WORD COUNT (FIND-NFA) ; IMMEDIATE
Name
defined:tools_misc — immediate primitive
Synopsis
FORTH
[DEFINED]
( [name] -- flag )( | ) ; | |
Description
Search the dictionary for _name_. If _name_ is found,
return TRUE; otherwise return FALSE. Immediate for use in
definitions.
This word will actually return what FIND returns (the NFA).
does check for the word using find (so it does not throw like ' )
and puts it on stack. As it is immediate it does work in compile-mode
too, so it places its argument in the cs-stack then. This is most
useful with a directly following [IF] clause, so that sth. like
an
[IFDEF] word
can be simulated through
[DEFINED] word [IF]
: [DEFINED] DEFINED ; IMMEDIATE
: [DEFINED] BL WORD COUNT (FIND-NFA) ; IMMEDIATE
Name
definitions:search — ordinary primitive
Synopsis
FORTH
DEFINITIONS
( -- )(
)
;
p4:"definitions";
Description
make the current context-vocabulary the definition-vocabulary,
that is where new names are declared in. see ORDER
Name
defs-are-case-sensitive:useful — ordinary primitive
Synopsis
EXTENSIONS
DEFS-ARE-CASE-SENSITIVE
( -- )( | ) ; | |
Description
accesses CURRENT which is generally the last wordlist that the
DEFINTIONS shall go in. sets there a flag in the vocabulary-definition
so that words are matched case-sensitive.
example:
VOCABULARY MY-VOC MY-VOC DEFINITIONS DEFS-ARE-CASE-SENSITIVE
Name
defs-are-searched-also:useful — ordinary primitive
Synopsis
EXTENSIONS
DEFS-ARE-SEARCHED-ALSO
( -- )( | ) ; | |
Description
binds CONTEXT with CURRENT. If the CURRENT VOCABULARY is in
the search-order (later), then the CONTEXT vocabulary will
be searched also. If the result of this word could lead into
a recursive lookup with FIND it will throw
CURRENT_DELETED
and leave the CURRENT VOCABULARY unaltered.
example:
MY-VOC DEFINITIONS MY-VOC-PRIVATE DEFS-ARE-SEARCHED-ALSO
Name
bracket-def:useful — immediate primitive
Synopsis
EXTENSIONS
[DEF]
( -- )(
)
;
p4:"bracket-def";
Description
immediatly set topmost CONTEXT voc to CURRENT compilation voc.
: DEF' CURRENT @ CONTEXT ! ; IMMEDIATE
note that in PFE most basic vocabularies are immediate, so that
you can use a sequence of
FORTH ALSO DEFINITIONS
[DEF] : GET-FIND-3 [ANS] ['] FIND [FIG] ['] FIND [DEF] ['] FIND ;
where the first wordlist to be searched via the search order are
[ANS] and [FIG] and FORTH (in this order) and which may or may not
yield different flavours of the FIND routine (i.e. different XTs)
Name
delete-file:file — ordinary primitive
Synopsis
FORTH
DELETE-FILE
( str-adr str-len -- code )( | ) ; | |
Description
delete the named file and return a status code
Name
depth:core — ordinary primitive
Synopsis
FORTH
DEPTH
( -- value )(
)
;
p4:"depth";
Description
return the depth of the parameter stack before
the call, see SP@ - the return-value is in CELLS
Name
str-depth:dstrings — ordinary primitive
Synopsis
FORTH
$DEPTH
( -- n )(
)
;
p4:"str-depth";
Description
Leave the number of items on the string stack.
<ansref>"string-depth"</ansref>
Name
dest-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
DEST_MAGIC
( .. )(
)
;
as:"dest-magic";
Description
( P4_DEST_MAGIC ) constant DEST_MAGIC
an ordinary constant (no special usage info)
Name
df-store:floating.1 — ordinary primitive
Synopsis
FORTH
DF!
( .. )(
)
;
as:"df-store";
Description
ordinary primitive DF!
an executable word (no special usage info)
or wrapper call around p4_f_store
Name
df-store:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
DF!
( .. )(
)
;
as:"df-store";
Description
ordinary primitive DF!
an executable word (no special usage info)
or wrapper call around p4_nofp_f_store
Name
df-fetch:floating.1 — ordinary primitive
Synopsis
FORTH
DF@
( .. )(
)
;
as:"df-fetch";
Description
ordinary primitive DF@
an executable word (no special usage info)
or wrapper call around p4_f_fetch
Name
df-fetch:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
DF@
( .. )(
)
;
as:"df-fetch";
Description
ordinary primitive DF@
an executable word (no special usage info)
or wrapper call around p4_nofp_f_fetch
Name
dfalign:floating.1 — ordinary primitive
Synopsis
FORTH
DFALIGN
( .. )(
)
;
as:"dfalign";
Description
ordinary primitive DFALIGN
an executable word (no special usage info)
or wrapper call around p4_d_f_align
Name
dfalign:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
DFALIGN
( .. )(
)
;
as:"dfalign";
Description
ordinary primitive DFALIGN
an executable word (no special usage info)
or wrapper call around p4_nofp_d_f_align
Name
dfaligned:floating.1 — ordinary primitive
Synopsis
FORTH
DFALIGNED
( .. )(
)
;
as:"dfaligned";
Description
ordinary primitive DFALIGNED
an executable word (no special usage info)
or wrapper call around p4_d_f_aligned
Name
dfaligned:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
DFALIGNED
( .. )(
)
;
as:"dfaligned";
Description
ordinary primitive DFALIGNED
an executable word (no special usage info)
or wrapper call around p4_nofp_d_f_aligned
Name
dfloat-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
DFLOAT%
( .. )(
)
;
as:"dfloat-percent";
Description
ordinary primitive DFLOAT%
an executable word (no special usage info)
or wrapper call around p4_dfloat_mod
Name
dfloat-plus:floating.1 — ordinary primitive
Synopsis
FORTH
DFLOAT+
( .. )(
)
;
as:"dfloat-plus";
Description
ordinary primitive DFLOAT+
an executable word (no special usage info)
or wrapper call around p4_d_float_plus
Name
dfloat-plus:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
DFLOAT+
( .. )(
)
;
as:"dfloat-plus";
Description
ordinary primitive DFLOAT+
an executable word (no special usage info)
or wrapper call around p4_nofp_d_float_plus
Name
dfloats:floating.1 — ordinary primitive
Synopsis
FORTH
DFLOATS
( .. )(
)
;
as:"dfloats";
Description
ordinary primitive DFLOATS
an executable word (no special usage info)
or wrapper call around p4_d_floats
Name
dfloats:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
DFLOATS
( .. )(
)
;
as:"dfloats";
Description
ordinary primitive DFLOATS
an executable word (no special usage info)
or wrapper call around p4_nofp_d_floats
Name
dictfence:tools_misc.1 — threadstate variable
Synopsis
EXTENSIONS
DICTFENCE
( .. )(
)
;
as:"dictfence";
Description
threadstate variable DICTFENCE
dict (no special usage info)
Name
paren-dictfence:tools_misc.1 — ordinary primitive
Synopsis
EXTENSIONS
(DICTFENCE)
( .. )(
)
;
as:"paren-dictfence";
Description
ordinary primitive (DICTFENCE)
an executable word (no special usage info)
or wrapper call around p4_paren_dictfence
Name
dictlimit:tools_misc.1 — threadstate variable
Synopsis
EXTENSIONS
DICTLIMIT
( .. )(
)
;
as:"dictlimit";
Description
threadstate variable DICTLIMIT
dictlimit (no special usage info)
Name
paren-dictlimit:tools_misc.1 — ordinary primitive
Synopsis
EXTENSIONS
(DICTLIMIT)
( .. )(
)
;
as:"paren-dictlimit";
Description
ordinary primitive (DICTLIMIT)
an executable word (no special usage info)
or wrapper call around p4_paren_dictlimit
Name
dlcall:dlfcn.1 — obsolete immediate
Synopsis
FORTH
DLCALL
( .. )(
)
;
as:"dlcall";
Description
obsolete immediate DLCALL
is doing the same as LOCAL-DLCALL
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
dlsym:dlfcn.1 — obsolete immediate
Synopsis
FORTH
DLSYM
( .. )(
)
;
as:"dlsym";
Description
obsolete immediate DLSYM
is doing the same as LOCAL-DLSYM
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
d-max:double — ordinary primitive
Synopsis
FORTH
DMAX
( d1.d1 d2.d2 -- d1.d1|d2.d2 )( | ) ; | |
Description
the double-cell max operation ( MAX )
Name
d-min:double — ordinary primitive
Synopsis
FORTH
DMIN
( d1.d1 d2.d2 -- d1.d1|d2.d2 )( | ) ; | |
Description
the double-cell max operation ( MIN )
Name
d-negate:double — ordinary primitive
Synopsis
FORTH
DNEGATE
( d1.d1 -- d1.d1' )( | ) ; | |
Description
the double-cell arithmetic negate operation ( NEGATE )
Name
do:core — compiling primitive
Synopsis
FORTH
DO
( end start -- )... LOOP(
)
;
p4:"do";
Description
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
Name
Q-do:core — compiling primitive
Synopsis
FORTH
?DO
( end start -- ).. LOOP(
)
;
p4:"Q-do";
Description
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.
Name
do-alias:chainlist — ordinary primitive
Synopsis
EXTENSIONS
DO-ALIAS
( exec-token wordlist* "do-name" -- )( | ) ; | |
Description
create an ALIAS with the exec-token in the specified wordlist
: DO-ALIAS GET-CURRENT SWAP SET-CURRENT SWAP ALIAS SET-CURRENT ;
DO-SYNONYM
Name
do-all-words:chainlist — ordinary primitive
Synopsis
EXTENSIONS
DO-ALL-WORDS
( wordlist* -- )( | ) ; | |
Description
EXECUTE each entry in the wordlist in the reverse order defined
: DO-ALL-WORDS
0 FIRST-NAME
BEGIN ?DUP WHILE
DUP NAME> EXECUTE
NAME-NEXT
REPEAT
;
to run the NEW-WORDLIST in original order, use REDO-ALL-WORDS
Name
do-all-words-while:chainlist — compiling primitive
Synopsis
EXTENSIONS
DO-ALL-WORDS-WHILE
( wordlist* "word" -- )( | ) ; | |
Description
EXECUTE each entry in the wordlist in the reverse order defined
but only as long as after EXECUTE of "word" a TRUE flag is left
on the stack. The wordlist execution is cut when a FALSE flag is seen.
(the current wordlist entry is _not_ on the stack!)
: DO-ALL-WORDS-WHILE '
STATE @ IF LITERAL, COMPILE DO-ALL-WORDS-WHILE-LOOP EXIT THEN
>R 0 FIRST-NAME
BEGIN ?DUP WHILE
R@ EXECUTE 0= IF R>DROP DROP EXIT THEN
DUP NAME> EXECUTE
NAME-NEXT
REPEAT R>DROP
;
to run the NEW-WORDLIST in original order, use REDO-ALL-WORDS
Name
do-all-words-while-loop:chainlist — ordinary primitive
Synopsis
EXTENSIONS
DO-ALL-WORDS-WHILE-LOOP
( wordlist* xt -- )( | ) ; | |
Description
EXECUTE each entry in the wordlist in the reverse order defined
but only as long as after EXECUTE of "word" a TRUE flag is left
on the stack. The wordlist execution is cut when a FALSE flag is seen.
(the current wordlist entry is _not_ on the stack!)
: DO-ALL-WORDS-WHILE-LOOP >R
0 FIRST-NAME
BEGIN ?DUP WHILE
R@ EXECUTE 0= IF R>DROP DROP EXIT THEN
DUP NAME> EXECUTE
NAME-NEXT
REPEAT R>DROP
;
compare with DO-ALL-WORDS-WHILE
Name
do-chain:chain — ordinary primitive
Synopsis
EXTENSIONS
do-chain
( chain* -- )(
)
;
p4:"do-chain";
Description
execute chain
: do-chain being @ ?dup while dup>r cell+ @execute r> repeat ;
Name
do-synonym:chainlist — ordinary primitive
Synopsis
EXTENSIONS
DO-SYNONYM
( wordlist* "do-name" "orig-name" -- )( | ) ; | |
Name
doer:useful.1 — ordinary primitive
Description
ordinary primitive DOER
an executable word (no special usage info)
or wrapper call around p4_defer
Name
does:core — compiling primitive
Synopsis
FORTH
DOES>
( -- pfa )(
)
;
p4:"does";
Description
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)
Name
double-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
DOUBLE%
( .. )(
)
;
as:"double-percent";
Description
ordinary primitive DOUBLE%
an executable word (no special usage info)
or wrapper call around p4_double_mod
Name
double-minus-ext:double::environment — ordinary constant
Synopsis
ENVIRONMENT
DOUBLE-EXT
( .. )(
)
;
as:"double-minus-ext";
Description
( 1994 ) constant DOUBLE-EXT
an ordinary constant (no special usage info)
Name
double-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
DOUBLE:
( .. )(
)
;
as:"double-colon";
Description
ordinary primitive DOUBLE:
an executable word (no special usage info)
or wrapper call around p4_two_cell_colon
Name
dp:misc.1 — threadstate variable
Description
threadstate variable DP
dp (no special usage info)
Name
dpl:forth_83.1 — threadstate variable
Description
threadstate variable DPL
dpl (no special usage info)
Name
drop:core — ordinary primitive
Synopsis
FORTH
DROP
( a -- )(
)
;
p4:"drop";
Description
just drop the word on the top of stack, see DUP
Name
two-drop:core — ordinary primitive
Synopsis
FORTH
2DROP
( a b -- )(
)
;
p4:"two-drop";
Description
double-cell drop, also used to drop two items
Name
str-drop:dstrings — ordinary primitive
Synopsis
FORTH
$DROP
( $: a$ -- )(
)
;
p4:"str-drop";
Description
Drop the topmost string stack entry, marking it as garbage if
it is initially bound to the top of the string stack.
<ansref>"string-drop"</ansref>
Name
str-two-drop:dstrings — ordinary primitive
Synopsis
FORTH
$2DROP
( $: a$ b$ -- )( | ) ; | |
Description
Drop the two topmost string stack entries, marking them as
garbage if appropriate. <ansref>"string-two-drop"</ansref>
Name
three-drop:forth_usual — ordinary primitive
Synopsis
FORTH
3DROP
( x y z -- )(
)
;
p4:"three-drop";
Description
Drop the top three elements from the stack.
: 3DROP DROP 2DROP ;
Name
four-drop:forth_usual — ordinary primitive
Synopsis
FORTH
4DROP
( x y z -- )(
)
;
p4:"four-drop";
Description
Drop the top three elements from the stack.
: 4DROP 2DROP 2DROP ;
Name
three-drop:toolbelt — ordinary primitive
Synopsis
FORTH
3DROP
( x y z -- )(
)
;
p4:"three-drop";
Description
Drop the top three elements from the stack.
: 3DROP DROP 2DROP ;
Name
drop-str-frame:dstrings — ordinary primitive
Synopsis
FORTH
DROP-$FRAME
( -- )(
)
;
p4:"drop-str-frame";
Description
Drop the topmost string frame from the string frame stack and
string stack. Errors are thrown if either stack would
underflow or if the string frame does not begin at the top of
the string stack. The case where the frame has zero entries
on the string stack is handled properly.
<ansref>"drop-string-frame"</ansref>
Name
paren-drop-minus-str-frame:dstrings.1 — compiling primitive
Description
compiling primitive (DROP-$FRAME)
an executable word (no special usage info)
or wrapper call around p4_do_drop_str_frame
Name
dstrings:dstrings.1 — threadstate variable
Synopsis
FORTH
DSTRINGS
( .. )(
)
;
as:"dstrings";
Description
threadstate variable DSTRINGS
dstrings (no special usage info)
Name
dstrings-minus-ext:dstrings::environment — ordinary constant
Description
( 20627 ) constant DSTRINGS-EXT
an ordinary constant (no special usage info)
Name
dstrings-minus-loaded:dstrings::environment — constructor primitive
Synopsis
ENVIRONMENT
DSTRINGS-LOADED
( .. )( | ) ; | |
Description
constructor primitive DSTRINGS-LOADED
an executable word (no special usage info)
or wrapper call around dstrings_init
Name
d-u-less:double_misc — ordinary primitive
Synopsis
FORTH
DU<
( d1,d1 d2,d2 -- flag )( | ) ; | |
Description
the double-cell unsigned-is-less operation ( U< )
Name
dump:tools — ordinary primitive
Synopsis
FORTH
DUMP
( addr len -- )(
)
;
p4:"dump";
Description
show a hex-dump of the given area, if it's more than a screenful
it will ask using ?CR
You can easily cause a segmentation fault of something like that
by accessing memory that does not belong to the pfe-process.
Name
dup:core — ordinary primitive
Synopsis
FORTH
DUP
( a -- a a )(
)
;
p4:"dup";
Description
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
Name
two-dup:core — ordinary primitive
Synopsis
FORTH
2DUP
( a,a -- a,a a,a )(
)
;
p4:"two-dup";
Description
double-cell duplication, also used to duplicate
two items
simulate:
: 2DUP OVER OVER ; ( wrong would be : 2DUP DUP DUP ; !!)
Name
Q-dup:core — ordinary primitive
Synopsis
FORTH
?DUP
( value -- value|[nothing] )( | ) ; | |
Description
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 ;
Name
str-dup:dstrings — ordinary primitive
Synopsis
FORTH
$DUP
( $: a$ -- a$ a$ )(
)
;
p4:"str-dup";
Description
Leave a copy of the topmost string stack entry. The string
value is not copied. <ansref>"string-dupe"</ansref>
Name
str-two-dup:dstrings — ordinary primitive
Synopsis
FORTH
$2DUP
( $: a$ b$ -- a$ b$ a$ b$ )( | ) ; | |
Description
Leave copies of the two topmost string stack entries. The string
values are not copied. <ansref>"string-two-dupe"</ansref>
Name
three-dup:forth_usual — ordinary primitive
Synopsis
FORTH
3DUP
( x y z -- x y z x y z )( | ) ; | |
Description
Copy top three elements on the stack onto top of stack.
: 3DUP THIRD THIRD THIRD ;
or
: 3DUP 3 PICK 3 PICK 3 PICK ;
Name
four-dup:forth_usual — ordinary primitive
Synopsis
FORTH
4DUP
( a b c d -- a b c d a b c d )( | ) ; | |
Description
simulate:
: 4DUP 4 PICK 4 PICK 4 PICK 4 PICK ;
Name
three-dup:toolbelt — ordinary primitive
Synopsis
FORTH
3DUP
( x y z -- x y z x y z )( | ) ; | |
Description
Copy top three elements on the stack onto top of stack.
: 3DUP THIRD THIRD THIRD ;
or
: 3DUP 3 PICK 3 PICK 3 PICK ;
Name
dup-to-r:misc — compiling primitive
Synopsis
FORTH
DUP>R
( val -- val )(
)
;
p4:"dup-to-r";
Description
shortcut, see R>DROP
<br> note again that the following will fail:
: DUP>R DUP >R ;
Name
slash-dynamic-minus-string:dstrings::environment — ordinary constant
Synopsis
ENVIRONMENT
/DYNAMIC-STRING
( .. )( | ) ; | |
Description
( MAX_MCOUNT ) constant /DYNAMIC-STRING
an ordinary constant (no special usage info)
Name
edit-block:edit — ordinary primitive
Synopsis
EXTENSIONS
EDIT-BLOCK
( blk -- )(
)
;
p4:"edit-block";
Description
start the internal block-editor on the assigned block
Name
edit-minus-block-minus-start:edit.1 — ordinary primitive
Synopsis
FORTH
EDIT-BLOCK-START
( .. )( | ) ; | |
Description
ordinary primitive EDIT-BLOCK-START
an executable word (no special usage info)
or wrapper call around p4_edit_block
Name
edit-blockfile:misc — ordinary primitive
Synopsis
FORTH
EDIT-BLOCKFILE
( name -- )( | ) ; | |
Description
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.
Name
edit-error:edit — ordinary primitive
Synopsis
EXTENSIONS
EDIT-ERROR
( -- )(
)
;
p4:"edit-error";
Description
if an error occured, this routine can be called to invoke
an appropriate EDITOR (see also EDIT-BLOCK)
Name
to-from-edit-minus-init-back-back:edit.1 — constructor primitive
Description
constructor primitive <<edit-init>>
an executable word (no special usage info)
or wrapper call around p4_edit_init
Name
edit-minus-text:edit.1 — ordinary primitive
Synopsis
EXTENSIONS
EDIT-TEXT
( .. )(
)
;
as:"edit-minus-text";
Description
ordinary primitive EDIT-TEXT
an executable word (no special usage info)
or wrapper call around p4_edit_text
Name
ekey:facility — ordinary primitive
Synopsis
FORTH
EKEY
( -- keycode )(
)
;
p4:"ekey";
Description
return a keyboard event, the encoding may differ, esp.
that it can contain special keys.
Name
ekey-to-char:facility — ordinary primitive
Synopsis
FORTH
EKEY>CHAR
( keycode -- keycode false | char true )( | ) ; | |
Name
ekey-question:facility — ordinary primitive
Synopsis
FORTH
EKEY?
( -- flag )(
)
;
p4:"ekey-question";
Description
check if a character is available from the keyboard
to be received - unlike KEY? it will not discard
non-visible codes.
Name
sh-else:cdecl — immediate primitive
Synopsis
FORTH
#ELSE
( -- )(
)
;
p4:"sh-else";
Description
The implementation of #ELSE is done in C for speed and
being less error prone. Better use the ANSI-compatible
[IF] [ELSE] [THEN] construct.
Name
else:core — compiling primitive
Description
will compile an ((ELSE)) BRANCH that performs an
unconditional jump to the next THEN - and it resolves
an IF for the non-true case
Name
bracket-else:tools — immediate primitive
Synopsis
FORTH
[ELSE]
( -- )(
)
;
p4:"bracket-else";
Description
eat up everything upto and including the next [THEN]. count
nested [IF] ... [THEN] constructs. see [IF]
this word provides a simple pre-compiler mechanism
Name
emit:core — ordinary primitive
Synopsis
FORTH
EMIT
( char -- )(
)
;
p4:"emit";
Description
print the char-value on stack to stdout
Name
paren-emit:misc.1 — ordinary primitive
Synopsis
FORTH
(EMIT)
( .. )(
)
;
as:"paren-emit";
Description
ordinary primitive (EMIT)
an executable word (no special usage info)
or wrapper call around p4_paren_emit
Name
star-emit-star:misc.1 — threadstate variable
Synopsis
FORTH
*EMIT*
( .. )(
)
;
as:"star-emit-star";
Description
threadstate variable *EMIT*
emit (no special usage info)
Name
emit-question:facility — ordinary primitive
Synopsis
FORTH
EMIT?
( -- flag )(
)
;
p4:"emit-question";
Description
if EMIT can safely output characters without
blocking the forth by waiting for an indefinite time.
Name
emits:forth_usual — ordinary primitive
Synopsis
FORTH
EMITS
( n char -- )(
)
;
p4:"emits";
Description
Emit _char_ _n_ times.
: EMITS ( n char -- )
SWAP 0 ?DO DUP EMIT LOOP DROP ;
also compare
: SPACES BL EMITS ;
: SPACE BL EMIT ;
Name
emits:toolbelt — ordinary primitive
Synopsis
FORTH
EMITS
( n char -- )(
)
;
p4:"emits";
Description
Emit _char_ _n_ times.
: EMITS ( n char -- )
SWAP 0 ?DO DUP EMIT LOOP DROP ;
also compare
: SPACES BL EMITS ;
: SPACE BL EMIT ;
Name
empty:toolbelt — ordinary primitive
Synopsis
FORTH
EMPTY
( -- )(
)
;
p4:"empty";
Description
Reset the dictionary to a predefined golden state,
discarding all definitions and releasing all allocated
data space beyond that state.
Name
empty-str:dstrings — ordinary primitive
Synopsis
FORTH
EMPTY$
( $: -- empty$ )(
)
;
p4:"empty-str";
Description
Push the MSA of a fixed, external representation of the empty
string onto the string stack. <ansref>"empty-string"</ansref>
Name
empty-buffers:block — ordinary primitive
Synopsis
FORTH
EMPTY-BUFFERS
( -- )(
)
;
p4:"empty-buffers";
Description
unassign all block buffers, does not even UPDATE
Name
end-module:module — ordinary primitive
Synopsis
EXTENSIONS
END-MODULE
( old-current -- )( | ) ; | |
Description
clean up the cs-stack from the last MODULE
definition. Effectivly, MODULE definitions can
be nested.
: END-MODULE ( old-current )
PREVIOUS PREVIOUS CURRENT !
Name
end-struct:struct — ordinary primitive
Synopsis
EXTENSIONS
END-STRUCT
( here some-offset -- )( | ) ; | |
Description
terminate definition of a new structure (mpe.000)
: END-STRUCT SWAP ! ?CSP ;
Name
end-subrecord:struct — ordinary primitive
Synopsis
EXTENSIONS
END-SUBRECORD
( outer-offset here some-offset -- outer-offset+some )( | ) ; | |
Description
end definition of a subrecord (mpe.000)
: END-SUBRECORD TUCK SWAP ! + ;
Name
end-variant:struct — ordinary primitive
Synopsis
EXTENSIONS
END-VARIANT
( outer-offset here some-offset -- outer-offset )( | ) ; | |
Description
terminate definition of a new variant (mpe.000)
: END-STRUCT TUCK SWAP ! 2DUP < IF NIP ELSE DROP THEN ;
Name
endcase:core — compiling primitive
Synopsis
FORTH
ENDCASE
( comp-value -- )(
)
;
p4:"endcase";
Description
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
Name
endcat:dstrings — ordinary primitive
Synopsis
FORTH
ENDCAT
( -- $: cat$ | empty$ )( | ) ; | |
Description
If there is no concatenating string, do nothing but leave the
empty string. If there is, leave it as a string bound to the
top of the string stack, and terminate concatenation,
permitting normal copies into the string buffer.
<ansref>"end-cat"</ansref>
Name
endif:forth_usual.1 — immediate synonym
Synopsis
FORTH
ENDIF
( .. )(
)
;
as:"endif";
Description
immediate synonym ENDIF
is doing the same as THEN
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
sh-endif:cdecl — immediate primitive
Synopsis
FORTH
#ENDIF
( -- )(
)
;
p4:"sh-endif";
Description
end of #IF #IFDEF #IFNOTDEF and #ELSE contructs
(a dummy word that does actually nothing, but #ELSE may look for it)
Name
endof:core — compiling primitive
Synopsis
FORTH
ENDOF
( -- )(
)
;
p4:"endof";
Description
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 )
Name
ends-Q:toolbelt — ordinary primitive
Synopsis
FORTH
ENDS?
( str len pattern len2 -- str len flag )( | ) ; | |
Description
Check end of string.
: ENDS? DUP >R 2OVER DUP R> - /STRING COMPARE 0= ;
Name
endstructure:struct — ordinary primitive
Synopsis
EXTENSIONS
ENDSTRUCTURE
( here some-offset -- )( | ) ; | |
Description
finalize a previously started STRUCTURE definition
: ENDSTRUCTURE SWAP ! ?CSP ;
Name
environ-minus-ext:environ::environment — ordinary constant
Description
( 2000 ) constant ENVIRON-EXT
an ordinary constant (no special usage info)
Name
environment-minus-wordlist:environ.1 — - loader type P4_DVaL
Synopsis
FORTH
ENVIRONMENT-WORDLIST
( .. )( | ) ; | |
Description
- loader type P4_DVaL ENVIRONMENT-WORDLIST
environ_wl (no special usage info)
Name
environment-Q-core:core — ordinary primitive
Synopsis
FORTH
ENVIRONMENT?
( a1 n1 -- false | ?? true )( | ) ; | |
Description
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 >WORDLIST SEARCH-WORDLIST
IF EXECUTE TRUE ELSE FALSE THEN ;
Name
environment-Q-core:environ — ordinary primitive
Synopsis
FORTH
ENVIRONMENT?
( a1 n1 -- false | ?? true )( | ) ; | |
Description
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 >WORDLIST SEARCH-WORDLIST
IF EXECUTE TRUE ELSE FALSE THEN ;
Name
sharp-eol-minus-char:toolbelt.1 — ordinary constant
Description
( EOL_CHAR ) constant #EOL-CHAR
an ordinary constant (no special usage info)
Name
erase:core — ordinary primitive
Synopsis
FORTH
ERASE
( ptr len -- )(
)
;
p4:"erase";
Description
fill an area will zeros.
2000 CREATE DUP ALLOT ERASE
Name
geteuid:shell — ordinary primitive
Synopsis
EXTENSIONS
$EUID
( -- val )(
)
;
p4:"geteuid";
Description
calls system's
geteuid
Name
evaluate:core — ordinary primitive
Synopsis
FORTH
EVALUATE
( str-ptr str-len -- )( | ) ; | |
Name
exception-minus-ext:exception::environment — ordinary constant
Description
( 1994 ) constant EXCEPTION-EXT
an ordinary constant (no special usage info)
Name
exception-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
EXCEPTION_MAGIC
( .. )( | ) ; | |
Description
( P4_EXCEPTION_MAGIC ) constant EXCEPTION_MAGIC
an ordinary constant (no special usage info)
Name
Q-exec:tools_misc — ordinary primitive
Synopsis
FORTH
?EXEC
( -- )(
)
;
p4:"Q-exec";
Description
check that the current STATE is executing
otherwise THROW
<br> often used in control-words
Name
execute:core — ordinary primitive
Synopsis
FORTH
EXECUTE
( xt -- )(
)
;
p4:"execute";
Description
run the execution-token on stack - this will usually
trap if it was null for some reason, see >EXECUTE
simulate:
: EXECUTE >R EXIT ;
Name
fetch-execute:forth_usual — ordinary primitive
Synopsis
FORTH
@EXECUTE
( xt -- ? )(
)
;
p4:"fetch-execute";
Description
same as @ EXECUTE , but checks for null as xt and
silently ignores it. Same as in most forths where defined.
simulate:
: @EXECUTE @ ?DUP IF EXECUTE THEN ;
Name
executes:misc — ordinary primitive
Synopsis
FORTH
EXECUTES
( n [word] -- )(
)
;
p4:"executes";
Description
stores the execution token of following word into
the callback pointer for the specified function-key
Name
exit:core — compiling primitive
Description
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 ;
Name
exit:with_spy — immediate synonym
Description
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 ;
Name
exitcode:misc.1 — threadstate variable
Synopsis
FORTH
EXITCODE
( .. )(
)
;
as:"exitcode";
Description
threadstate variable EXITCODE
exitcode (no special usage info)
Name
expand-fn:misc — ordinary primitive
Synopsis
FORTH
EXPAND-FN
( addr1 u1 addr2 -- addr2 cnt2 )( | ) ; | |
Name
expect:core — ordinary primitive
Synopsis
FORTH
EXPECT
( str-adr str-len -- )( | ) ; | |
Description
input handling, see WORD and PARSE and QUERY
the input string is placed at str-adr and its length
in SPAN - this word is superceded by ACCEPT
Name
paren-expect:misc.1 — ordinary primitive
Synopsis
FORTH
(EXPECT)
( .. )(
)
;
as:"paren-expect";
Description
ordinary primitive (EXPECT)
an executable word (no special usage info)
or wrapper call around p4_paren_expect
Name
star-expect-star:misc.1 — threadstate variable
Synopsis
FORTH
*EXPECT*
( .. )(
)
;
as:"star-expect-star";
Description
threadstate variable *EXPECT*
expect (no special usage info)
Name
export:module — ordinary primitive
Synopsis
EXTENSIONS
EXPORT
( old-current "name" -- old-current )( | ) ; | |
Description
the named word in the hidden dictionary (i.e.
the wordlist referenced in CURRENT) is exported
into the public wordlist of it (i.e. which is in
this implementation CONTEXT[1]). The actual
implemenation will create a DEFER-word in the
public wordlist withits parameter area pointing
to the cfa of the hidden implementation.
: EXPORT
CURRENT @ CONTEXT CELL+ @ CURRENT !
DEFER CURRENT !
LATEST COUNT CURRENT @ SEARCH-WORDLIST
IF LATEST NAME> >BODY ! ELSE ABORT" can't find word to export" THEN
;
Name
expose-module:module — ordinary primitive
Synopsis
EXTENSIONS
EXPOSE-MODULE
( "name" -- )( | ) ; | |
Description
affects the search order, ALSO module-wid CONTEXT ! hidden'
: EXPOSE-MODULE
ALSO S" HIDDEN'"
' DUP VOC? ABORT?" is no vocabulary" >VOC
SEARCH-WORDLIST 0= IF " no hidden vocabulary found" THEN
DUP VOC? ABORT?" hidden is no vocabulary" EXECUTE
;
Name
f-store:floating.1 — ordinary primitive
Synopsis
FORTH
F!
( .. )(
)
;
as:"f-store";
Description
ordinary primitive F!
an executable word (no special usage info)
or wrapper call around p4_f_store
Name
f-store:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F!
( .. )(
)
;
as:"f-store";
Description
ordinary primitive F!
an executable word (no special usage info)
or wrapper call around p4_nofp_f_store
Name
f-star:floating.1 — ordinary primitive
Description
ordinary primitive F*
an executable word (no special usage info)
or wrapper call around p4_f_star
Name
f-star:fpnostack.1 — ordinary primitive
Description
ordinary primitive F*
an executable word (no special usage info)
or wrapper call around p4_nofp_f_star
Name
f-star-star:floating.1 — ordinary primitive
Synopsis
FORTH
F**
( .. )(
)
;
as:"f-star-star";
Description
ordinary primitive F**
an executable word (no special usage info)
or wrapper call around p4_f_star_star
Name
f-star-star:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F**
( .. )(
)
;
as:"f-star-star";
Description
ordinary primitive F**
an executable word (no special usage info)
or wrapper call around p4_nofp_f_star_star
Name
f-plus:floating.1 — ordinary primitive
Description
ordinary primitive F+
an executable word (no special usage info)
or wrapper call around p4_f_plus
Name
f-plus:fpnostack.1 — ordinary primitive
Description
ordinary primitive F+
an executable word (no special usage info)
or wrapper call around p4_nofp_f_plus
Name
f-minus:floating.1 — ordinary primitive
Synopsis
FORTH
F-
( .. )(
)
;
as:"f-minus";
Description
ordinary primitive F-
an executable word (no special usage info)
or wrapper call around p4_f_minus
Name
f-minus:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F-
( .. )(
)
;
as:"f-minus";
Description
ordinary primitive F-
an executable word (no special usage info)
or wrapper call around p4_nofp_f_minus
Name
f-dot:floating.1 — ordinary primitive
Description
ordinary primitive F.
an executable word (no special usage info)
or wrapper call around p4_f_dot
Name
f-dot:fpnostack.1 — ordinary primitive
Description
ordinary primitive F.
an executable word (no special usage info)
or wrapper call around p4_nofp_f_dot
Name
f-slash:floating.1 — ordinary primitive
Synopsis
FORTH
F/
( .. )(
)
;
as:"f-slash";
Description
ordinary primitive F/
an executable word (no special usage info)
or wrapper call around p4_f_slash
Name
f-slash:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F/
( .. )(
)
;
as:"f-slash";
Description
ordinary primitive F/
an executable word (no special usage info)
or wrapper call around p4_nofp_f_slash
Name
f-zero:floating_misc.1 — threadstate variable
Description
threadstate variable F0
f0 (no special usage info)
Name
f-zero-from:floating.1 — ordinary primitive
Synopsis
FORTH
F0<
( .. )(
)
;
as:"f-zero-from";
Description
ordinary primitive F0<
an executable word (no special usage info)
or wrapper call around p4_f_zero_less
Name
f-zero-from:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F0<
( .. )(
)
;
as:"f-zero-from";
Description
ordinary primitive F0<
an executable word (no special usage info)
or wrapper call around p4_nofp_f_zero_less
Name
f-zero-equal:floating.1 — ordinary primitive
Synopsis
FORTH
F0=
( .. )(
)
;
as:"f-zero-equal";
Description
ordinary primitive F0=
an executable word (no special usage info)
or wrapper call around p4_f_zero_equal
Name
f-zero-equal:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F0=
( .. )(
)
;
as:"f-zero-equal";
Description
ordinary primitive F0=
an executable word (no special usage info)
or wrapper call around p4_nofp_f_zero_equal
Name
f-from:floating.1 — ordinary primitive
Description
ordinary primitive F<
an executable word (no special usage info)
or wrapper call around p4_f_less_than
Name
f-from:fpnostack.1 — ordinary primitive
Description
ordinary primitive F<
an executable word (no special usage info)
or wrapper call around p4_nofp_f_less_than
Name
f-from-equal:floating_misc.1 — ordinary primitive
Synopsis
FORTH
F<=
( .. )(
)
;
as:"f-from-equal";
Description
ordinary primitive F<=
an executable word (no special usage info)
or wrapper call around p4_f_less_than_or_equal
Name
f-from-equal:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F<=
( .. )(
)
;
as:"f-from-equal";
Description
ordinary primitive F<=
an executable word (no special usage info)
or wrapper call around p4_nofp_f_less_than_or_equal
Name
f-from-back:floating_misc.1 — ordinary primitive
Synopsis
FORTH
F<>
( .. )(
)
;
as:"f-from-back";
Description
ordinary primitive F<>
an executable word (no special usage info)
or wrapper call around p4_f_not_equal
Name
f-from-back:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F<>
( .. )(
)
;
as:"f-from-back";
Description
ordinary primitive F<>
an executable word (no special usage info)
or wrapper call around p4_nofp_f_not_equal
Name
f-equal:floating_misc.1 — ordinary primitive
Synopsis
FORTH
F=
( .. )(
)
;
as:"f-equal";
Description
ordinary primitive F=
an executable word (no special usage info)
or wrapper call around p4_f_equal
Name
f-equal:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F=
( .. )(
)
;
as:"f-equal";
Description
ordinary primitive F=
an executable word (no special usage info)
or wrapper call around p4_nofp_f_equal
Name
f-back:floating_misc.1 — ordinary primitive
Description
ordinary primitive F>
an executable word (no special usage info)
or wrapper call around p4_f_greater_than
Name
f-back:fpnostack.1 — ordinary primitive
Description
ordinary primitive F>
an executable word (no special usage info)
or wrapper call around p4_nofp_f_greater_than
Name
f-back-equal:floating_misc.1 — ordinary primitive
Synopsis
FORTH
F>=
( .. )(
)
;
as:"f-back-equal";
Description
ordinary primitive F>=
an executable word (no special usage info)
or wrapper call around p4_f_greater_than_or_equal
Name
f-back-equal:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F>=
( .. )(
)
;
as:"f-back-equal";
Description
ordinary primitive F>=
an executable word (no special usage info)
or wrapper call around p4_nofp_f_greater_than_or_equal
Name
f-back-d:floating.1 — ordinary primitive
Synopsis
FORTH
F>D
( .. )(
)
;
as:"f-back-d";
Description
ordinary primitive F>D
an executable word (no special usage info)
or wrapper call around p4_f_to_d
Name
f-back-d:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F>D
( .. )(
)
;
as:"f-back-d";
Description
ordinary primitive F>D
an executable word (no special usage info)
or wrapper call around p4_nofp_f_to_d
Name
f-fetch:floating.1 — ordinary primitive
Synopsis
FORTH
F@
( .. )(
)
;
as:"f-fetch";
Description
ordinary primitive F@
an executable word (no special usage info)
or wrapper call around p4_f_fetch
Name
f-fetch:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
F@
( .. )(
)
;
as:"f-fetch";
Description
ordinary primitive F@
an executable word (no special usage info)
or wrapper call around p4_nofp_f_fetch
Name
fabs:floating.1 — ordinary primitive
Description
ordinary primitive FABS
an executable word (no special usage info)
or wrapper call around p4_f_abs
Name
fabs:fpnostack.1 — ordinary primitive
Description
ordinary primitive FABS
an executable word (no special usage info)
or wrapper call around p4_nofp_f_abs
Name
facility-minus-ext:facility::environment — ordinary constant
Description
( 1994 ) constant FACILITY-EXT
an ordinary constant (no special usage info)
Name
facos:floating.1 — ordinary primitive
Synopsis
FORTH
FACOS
( .. )(
)
;
as:"facos";
Description
ordinary primitive FACOS
an executable word (no special usage info)
or wrapper call around p4_f_acos
Name
facos:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FACOS
( .. )(
)
;
as:"facos";
Description
ordinary primitive FACOS
an executable word (no special usage info)
or wrapper call around p4_nofp_f_acos
Name
facosh:floating.1 — ordinary primitive
Synopsis
FORTH
FACOSH
( .. )(
)
;
as:"facosh";
Description
ordinary primitive FACOSH
an executable word (no special usage info)
or wrapper call around p4_f_acosh
Name
facosh:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FACOSH
( .. )(
)
;
as:"facosh";
Description
ordinary primitive FACOSH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_acosh
Name
falign:floating.1 — ordinary primitive
Synopsis
FORTH
FALIGN
( .. )(
)
;
as:"falign";
Description
ordinary primitive FALIGN
an executable word (no special usage info)
or wrapper call around p4_d_f_align
Name
falign:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FALIGN
( .. )(
)
;
as:"falign";
Description
ordinary primitive FALIGN
an executable word (no special usage info)
or wrapper call around p4_nofp_d_f_align
Name
faligned:floating.1 — ordinary primitive
Synopsis
FORTH
FALIGNED
( .. )(
)
;
as:"faligned";
Description
ordinary primitive FALIGNED
an executable word (no special usage info)
or wrapper call around p4_d_f_aligned
Name
faligned:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FALIGNED
( .. )(
)
;
as:"faligned";
Description
ordinary primitive FALIGNED
an executable word (no special usage info)
or wrapper call around p4_nofp_d_f_aligned
Name
falog:floating.1 — ordinary primitive
Synopsis
FORTH
FALOG
( .. )(
)
;
as:"falog";
Description
ordinary primitive FALOG
an executable word (no special usage info)
or wrapper call around p4_f_alog
Name
falog:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FALOG
( .. )(
)
;
as:"falog";
Description
ordinary primitive FALOG
an executable word (no special usage info)
or wrapper call around p4_nofp_f_alog
Name
false:core.1 — ordinary constant
Synopsis
FORTH
FALSE
( .. )(
)
;
as:"false";
Description
( P4_FALSE ) constant FALSE
an ordinary constant (no special usage info)
Name
fasin:floating.1 — ordinary primitive
Synopsis
FORTH
FASIN
( .. )(
)
;
as:"fasin";
Description
ordinary primitive FASIN
an executable word (no special usage info)
or wrapper call around p4_f_asin
Name
fasin:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FASIN
( .. )(
)
;
as:"fasin";
Description
ordinary primitive FASIN
an executable word (no special usage info)
or wrapper call around p4_nofp_f_asin
Name
fasinh:floating.1 — ordinary primitive
Synopsis
FORTH
FASINH
( .. )(
)
;
as:"fasinh";
Description
ordinary primitive FASINH
an executable word (no special usage info)
or wrapper call around p4_f_asinh
Name
fasinh:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FASINH
( .. )(
)
;
as:"fasinh";
Description
ordinary primitive FASINH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_asinh
Name
fatan:floating.1 — ordinary primitive
Synopsis
FORTH
FATAN
( .. )(
)
;
as:"fatan";
Description
ordinary primitive FATAN
an executable word (no special usage info)
or wrapper call around p4_f_atan
Name
fatan:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FATAN
( .. )(
)
;
as:"fatan";
Description
ordinary primitive FATAN
an executable word (no special usage info)
or wrapper call around p4_nofp_f_atan
Name
fatan-two:floating.1 — ordinary primitive
Synopsis
FORTH
FATAN2
( .. )(
)
;
as:"fatan-two";
Description
ordinary primitive FATAN2
an executable word (no special usage info)
or wrapper call around p4_f_atan2
Name
fatan-two:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FATAN2
( .. )(
)
;
as:"fatan-two";
Description
ordinary primitive FATAN2
an executable word (no special usage info)
or wrapper call around p4_nofp_f_atan2
Name
fatanh:floating.1 — ordinary primitive
Synopsis
FORTH
FATANH
( .. )(
)
;
as:"fatanh";
Description
ordinary primitive FATANH
an executable word (no special usage info)
or wrapper call around p4_f_atanh
Name
fatanh:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FATANH
( .. )(
)
;
as:"fatanh";
Description
ordinary primitive FATANH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_atanh
Name
str-fbreak:dstrings.1 — ordinary primitive
Synopsis
FORTH
$FBREAK
( .. )(
)
;
as:"str-fbreak";
Description
ordinary primitive $FBREAK
an executable word (no special usage info)
or wrapper call around sf_break
Name
fconstant:floating.1 — definining primitive
Synopsis
FORTH
FCONSTANT
( .. )(
)
;
as:"fconstant";
Description
definining primitive FCONSTANT
an executable word (no special usage info)
or wrapper call around p4_f_constant
Name
fconstant:fpnostack.1 — definining primitive
Synopsis
EXTENSIONS
FCONSTANT
( .. )(
)
;
as:"fconstant";
Description
definining primitive FCONSTANT
an executable word (no special usage info)
or wrapper call around p4_nofp_f_constant
Name
fcos:floating.1 — ordinary primitive
Description
ordinary primitive FCOS
an executable word (no special usage info)
or wrapper call around p4_f_cos
Name
fcos:fpnostack.1 — ordinary primitive
Description
ordinary primitive FCOS
an executable word (no special usage info)
or wrapper call around p4_nofp_f_cos
Name
fcosh:floating.1 — ordinary primitive
Synopsis
FORTH
FCOSH
( .. )(
)
;
as:"fcosh";
Description
ordinary primitive FCOSH
an executable word (no special usage info)
or wrapper call around p4_f_cosh
Name
fcosh:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FCOSH
( .. )(
)
;
as:"fcosh";
Description
ordinary primitive FCOSH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_cosh
Name
fdepth:floating.1 — ordinary primitive
Synopsis
FORTH
FDEPTH
( .. )(
)
;
as:"fdepth";
Description
ordinary primitive FDEPTH
an executable word (no special usage info)
or wrapper call around p4_f_depth
Name
fdepth:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FDEPTH
( .. )(
)
;
as:"fdepth";
Description
ordinary primitive FDEPTH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_depth
Name
fdrop:floating.1 — ordinary primitive
Synopsis
FORTH
FDROP
( .. )(
)
;
as:"fdrop";
Description
ordinary primitive FDROP
an executable word (no special usage info)
or wrapper call around p4_f_drop
Name
fdrop:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FDROP
( .. )(
)
;
as:"fdrop";
Description
ordinary primitive FDROP
an executable word (no special usage info)
or wrapper call around p4_nofp_f_drop
Name
fdup:floating.1 — ordinary primitive
Description
ordinary primitive FDUP
an executable word (no special usage info)
or wrapper call around p4_f_dup
Name
fdup:fpnostack.1 — ordinary primitive
Description
ordinary primitive FDUP
an executable word (no special usage info)
or wrapper call around p4_nofp_f_dup
Name
fe-dot:floating.1 — ordinary primitive
Synopsis
FORTH
FE.
( .. )(
)
;
as:"fe-dot";
Description
ordinary primitive FE.
an executable word (no special usage info)
or wrapper call around p4_f_e_dot
Name
fe-dot:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FE.
( .. )(
)
;
as:"fe-dot";
Description
ordinary primitive FE.
an executable word (no special usage info)
or wrapper call around p4_nofp_f_e_dot
Name
fence:tools_misc.1 — threadstate variable
Synopsis
EXTENSIONS
FENCE
( .. )(
)
;
as:"fence";
Description
threadstate variable FENCE
fence (no special usage info)
Name
fexp:floating.1 — ordinary primitive
Description
ordinary primitive FEXP
an executable word (no special usage info)
or wrapper call around p4_f_exp
Name
fexp:fpnostack.1 — ordinary primitive
Description
ordinary primitive FEXP
an executable word (no special usage info)
or wrapper call around p4_nofp_f_exp
Name
fexpm-one:floating.1 — ordinary primitive
Synopsis
FORTH
FEXPM1
( .. )(
)
;
as:"fexpm-one";
Description
ordinary primitive FEXPM1
an executable word (no special usage info)
or wrapper call around p4_f_expm1
Name
fexpm-one:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FEXPM1
( .. )(
)
;
as:"fexpm-one";
Description
ordinary primitive FEXPM1
an executable word (no special usage info)
or wrapper call around p4_nofp_f_expm1
Name
to-ffa:header — ordinary primitive
Synopsis
EXTENSIONS
>FFA
( nfa -- ffa )obsolete(
)
;
p4:"to-ffa";
Description
converts a pointer to the name-field (NFA) to point
then to the corresponding flag-field (FFA) - in traditinal
Forth this is the same address. pfe _can_ do different.
implementation-specific configure-dependent simulation:
: FFA 1- ;
Name
ffa-from:header — ordinary primitive
Synopsis
EXTENSIONS
FFA>
( ffa -- nfa )obsolete( | ) ; | |
Description
converts a pointer to the flag-field (FFA) to point
then to the corresponding name-field (NFA) - in traditinal
Forth this is the same address. pfe _can_ do different.
implementation-specific configure-dependent simulation:
: FFA 1+ ;
Name
field:struct — definining primitive
Synopsis
EXTENSIONS
FIELD
( offset size "name" -- offset+size )( | ) ; | |
Description
create a field - the workhorse for both STRUCT and STRUCTURE
implementations. The created fieldname is an OFFSET:-word
that memorizes the current offset in its PFA and will add
that offset on runtime. This forth-word does *not* align.
: FIELD CREATE
OVER ,
+
DOES>
@ +
;
Name
plus-field:useful — ordinary primitive
Synopsis
EXTENSIONS
+FIELD
( offset "name" -- offset )( | ) ; | |
Description
created a new name with an OFFSET-RT runtime using the given offset.
Leave the offset-value untouched, so it can be modified with words
like CHAR+ and CELL+ and SFLOAT+ ; This word is the simplest way
to declared structure access words in forth - the two STRUCT modules
contain a more elaborate series of words. Use this one like:
0 ( a fresh definition is started )
+FIELD zapp.a+ CHAR+ ( zero offset from the base of the struct )
+FIELD zapp.b+ CELL+ ( no alignment, starts off at 1 from base )
+FIELD zapp+ DROP ( store size of complete zap structure )
0 zapp+ ( extend the zap structure )
+FIELD zappx.c+ CELL+ ( a new field )
+FIELD zappx+ DROP ( and save it again )
CREATE zapp1 0 zapp+ ALLOT ( a way to allocate a strucutre )
zapp2 zapp.b+ @ ( read a value from the field )
16 zapp2 zapp.b+ ! ( store a value in there )
this form is not the traditional form used in forth, it is however
quite simple. Use the simplefield declaration with /FIELD to
be compatible with traditional styles that build on top of sizeof
constants in forth (which are not part of the ANS Forth standard).
Name
slash-field:useful — ordinary primitive
Synopsis
EXTENSIONS
/FIELD
( offset size "name" -- offset+size )( | ) ; | |
Description
created a new +FIELD name with an OFFSET-RT
of offset. Then add the size value to the offset so that
the next /FIELD declaration will start at the end of the
field currently declared. This word is the simplest way to
declared structure access words in forth - the two STRUCT modules
contain a more elaborate series of words. This one is used like:
0 ( a fresh definition is started )
/CHAR /FIELD ->zapp.a ( zero offset from the base of the struct )
/CELL /FIELD ->zapp.b ( no alignment, starts off at 1 from base )
CONSTANT /zapp ( store size of complete zap structure )
/zapp ( extend the zap structure )
/CELL /FIELD ->zappx.c ( a new field )
CONSTANT /zappx ( and save it again )
CREATE zapp1 /zapp ALLOT ( a way to allocate a strucutre )
/zapp BUFFER: zapp2 ( another way to do it, semi-standard )
zapp2 ->zapp.b @ ( read a value from the field )
16 zapp2 ->zapp.b ! ( store a value in there )
compare also with /CHAR /WCHAR /CELL /DCELL
and use +FIELD as the lowlevel word, can simulate as
: /FIELD SWAP +FIELD + ;
Name
field-minus-offset:useful.1 — forthword synonym
Description
forthword synonym FIELD-OFFSET
is doing the same as +CONSTANT
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
fig-minus-word:your.1 — obsolete forthword
Synopsis
EXTENSIONS
FIG-WORD
( .. )(
)
;
as:"fig-minus-word";
Description
obsolete forthword FIG-WORD
is doing the same as HERE-WORD
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
Q-file:tools_misc — ordinary primitive
Synopsis
FORTH
?FILE
( file-id -- )(
)
;
p4:"Q-file";
Description
check the file-id otherwise (fixme)
Name
file-block:file_misc — ordinary primitive
Synopsis
FORTH
FILE-BLOCK
( a file-id -- c )( | ) ; | |
Name
file-buffer:file_misc — ordinary primitive
Synopsis
FORTH
FILE-BUFFER
( a file-id -- c )( | ) ; | |
Name
file-check:forth_usual — ordinary primitive
Synopsis
FORTH
FILE-CHECK
( n -- )(
)
;
p4:"file-check";
Description
Check for file access error.
\ : FILE-CHECK ( n -- ) THROW ;
: FILE-CHECK ( n -- ) ABORT" File Access Error " ;
Name
file-check:toolbelt — ordinary primitive
Synopsis
FORTH
FILE-CHECK
( n -- )(
)
;
p4:"file-check";
Description
Check for file access error.
\ : FILE-CHECK ( n -- ) THROW ;
: FILE-CHECK ( n -- ) ABORT" File Access Error " ;
Name
file-empty-buffers:file_misc — ordinary primitive
Synopsis
FORTH
FILE-EMPTY-BUFFERS
( file-id -- )( | ) ; | |
Name
file-minus-ext:file::environment — ordinary constant
Synopsis
ENVIRONMENT
FILE-EXT
( .. )(
)
;
as:"file-minus-ext";
Description
( 1994 ) constant FILE-EXT
an ordinary constant (no special usage info)
Name
file-flush:file_misc — ordinary primitive
Synopsis
FORTH
FILE-FLUSH
( file-id -- )( | ) ; | |
Description
simulate : FILE-FLUSH DUP FILE-SAVE-BUFFERS FILE-EMTPY-BUFFERS ;
Name
file-list:file_misc — ordinary primitive
Synopsis
FORTH
FILE-LIST
( x file-id -- )( | ) ; | |
Name
file-load:file_misc — ordinary primitive
Synopsis
FORTH
FILE-LOAD
( x file-id -- )( | ) ; | |
Name
file-position:file — ordinary primitive
Synopsis
FORTH
FILE-POSITION
( file -- p.pos code )( | ) ; | |
Description
return the current position in the file and
return a status code. A code of zero means success.
Name
file-rw:file_misc — ordinary primitive
Synopsis
FORTH
FILE-R/W
( addr blk f fid -- )( | ) ; | |
Description
like FIG-Forth
R/W
Name
file-save-buffers:file_misc — ordinary primitive
Synopsis
FORTH
FILE-SAVE-BUFFERS
( file-id -- )( | ) ; | |
Name
file-size:file — ordinary primitive
Synopsis
FORTH
FILE-SIZE
( file -- s.size code )( | ) ; | |
Description
return the current size of the file and
return a status code. A code of zero means success.
Name
file-status:file — ordinary primitive
Synopsis
FORTH
FILE-STATUS
( str-adr str-len -- sub-code code )( | ) ; | |
Description
check the named file - if it exists
the status code is zero. The sub-code
is implementation-specific.
Name
file-thru:file_misc — ordinary primitive
Synopsis
FORTH
FILE-THRU
( lo hi file-id -- )( | ) ; | |
Name
file-update:file_misc — ordinary primitive
Synopsis
FORTH
FILE-UPDATE
( file-id -- )( | ) ; | |
Name
fill:core — ordinary primitive
Synopsis
FORTH
FILL
( mem-addr mem-length char -- )( | ) ; | |
Description
fill a memory area with the given char, does now
simply call memset()
Name
find:core — ordinary primitive
Synopsis
FORTH
FIND
( bstring -- cfa|bstring -1|0|1 )( | ) ; | |
Description
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 if the word had
been immediate, -1 otherwise.
Name
find-arg:dstrings — ordinary primitive
Synopsis
FORTH
FIND-ARG
( s -- i true | false )( | ) ; | |
Description
Leave true and its index i in the top string frame if the
Forth string matches an element of the frame, else leave
false. The index of the top frame element is zero.
<ansref>"find-arg"</ansref>
Name
flit:floating_misc.1 — ordinary primitive
Description
ordinary primitive FLIT
an executable word (no special usage info)
or wrapper call around p4_f_literal_execution
Name
fliteral:floating.1 — compiling primitive
Synopsis
FORTH
FLITERAL
( .. )(
)
;
as:"fliteral";
Description
compiling primitive FLITERAL
an executable word (no special usage info)
or wrapper call around p4_f_literal
Name
fliteral:fpnostack.1 — compiling primitive
Synopsis
EXTENSIONS
FLITERAL
( .. )(
)
;
as:"fliteral";
Description
compiling primitive FLITERAL
an executable word (no special usage info)
or wrapper call around p4_nofp_f_literal
Name
fln:floating.1 — ordinary primitive
Description
ordinary primitive FLN
an executable word (no special usage info)
or wrapper call around p4_f_ln
Name
fln:fpnostack.1 — ordinary primitive
Description
ordinary primitive FLN
an executable word (no special usage info)
or wrapper call around p4_nofp_f_ln
Name
flnp-one:floating.1 — ordinary primitive
Synopsis
FORTH
FLNP1
( .. )(
)
;
as:"flnp-one";
Description
ordinary primitive FLNP1
an executable word (no special usage info)
or wrapper call around p4_f_lnp1
Name
flnp-one:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FLNP1
( .. )(
)
;
as:"flnp-one";
Description
ordinary primitive FLNP1
an executable word (no special usage info)
or wrapper call around p4_nofp_f_lnp1
Name
back-float:floating.1 — ordinary primitive
Synopsis
FORTH
>FLOAT
( .. )(
)
;
as:"back-float";
Description
ordinary primitive >FLOAT
an executable word (no special usage info)
or wrapper call around p4_to_float
Name
back-float:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
>FLOAT
( .. )(
)
;
as:"back-float";
Description
ordinary primitive >FLOAT
an executable word (no special usage info)
or wrapper call around p4_nofp_to_float
Name
float-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
FLOAT%
( .. )(
)
;
as:"float-percent";
Description
ordinary primitive FLOAT%
an executable word (no special usage info)
or wrapper call around p4_float_mod
Name
float-plus:floating.1 — ordinary primitive
Synopsis
FORTH
FLOAT+
( .. )(
)
;
as:"float-plus";
Description
ordinary primitive FLOAT+
an executable word (no special usage info)
or wrapper call around p4_d_float_plus
Name
float-plus:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FLOAT+
( .. )(
)
;
as:"float-plus";
Description
ordinary primitive FLOAT+
an executable word (no special usage info)
or wrapper call around p4_nofp_d_float_plus
Name
float-minus-input:floating_misc.1 — threadstate variable
Description
threadstate variable FLOAT-INPUT
float_input (no special usage info)
Name
float-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
FLOAT:
( .. )(
)
;
as:"float-colon";
Description
ordinary primitive FLOAT:
an executable word (no special usage info)
or wrapper call around p4_float_colon
Name
floating:fpnostack::environment — ordinary constant
Synopsis
ENVIRONMENT
FLOATING
( .. )(
)
;
as:"floating";
Description
( 1994 ) constant FLOATING
an ordinary constant (no special usage info)
Name
floating-minus-ext:floating::environment — ordinary constant
Description
( 1994 ) constant FLOATING-EXT
an ordinary constant (no special usage info)
Name
floating-minus-loaded:floating::environment — constructor primitive
Synopsis
ENVIRONMENT
FLOATING-LOADED
( .. )( | ) ; | |
Description
constructor primitive FLOATING-LOADED
an executable word (no special usage info)
or wrapper call around floating_init
Name
floating-minus-stack:floating::environment — ordinary primitive
Description
ordinary primitive FLOATING-STACK
an executable word (no special usage info)
or wrapper call around p__floating_stack
Name
floats:floating.1 — ordinary primitive
Synopsis
FORTH
FLOATS
( .. )(
)
;
as:"floats";
Description
ordinary primitive FLOATS
an executable word (no special usage info)
or wrapper call around p4_d_floats
Name
floats:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FLOATS
( .. )(
)
;
as:"floats";
Description
ordinary primitive FLOATS
an executable word (no special usage info)
or wrapper call around p4_nofp_d_floats
Name
flog:floating.1 — ordinary primitive
Description
ordinary primitive FLOG
an executable word (no special usage info)
or wrapper call around p4_f_log
Name
flog:fpnostack.1 — ordinary primitive
Description
ordinary primitive FLOG
an executable word (no special usage info)
or wrapper call around p4_nofp_f_log
Name
floor:floating.1 — ordinary primitive
Synopsis
FORTH
FLOOR
( .. )(
)
;
as:"floor";
Description
ordinary primitive FLOOR
an executable word (no special usage info)
or wrapper call around p4_floor
Name
floor:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FLOOR
( .. )(
)
;
as:"floor";
Description
ordinary primitive FLOOR
an executable word (no special usage info)
or wrapper call around p4_nofp_floor
Name
floored:core::environment — ordinary constant
Synopsis
ENVIRONMENT
FLOORED
( .. )(
)
;
as:"floored";
Description
( P4_TRUE ) constant FLOORED
an ordinary constant (no special usage info)
Name
flush:block — ordinary primitive
Synopsis
FORTH
FLUSH
( -- )(
)
;
p4:"flush";
Name
flush-file:file — ordinary primitive
Synopsis
FORTH
FLUSH-FILE
( file -- code )( | ) ; | |
Description
flush all unsaved buffers of the file to disk.
A status code of zero means success.
Name
f-m-slash-mod:core — ordinary primitive
Synopsis
FORTH
FM/MOD
( n1.n1 n2 -- m n )( | ) ; | |
Description
divide the double-cell value n1 by n2 and return
both (floored) quotient n and remainder m
Name
fmax:floating.1 — ordinary primitive
Description
ordinary primitive FMAX
an executable word (no special usage info)
or wrapper call around p4_f_max
Name
fmax:fpnostack.1 — ordinary primitive
Description
ordinary primitive FMAX
an executable word (no special usage info)
or wrapper call around p4_nofp_f_max
Name
fmin:floating.1 — ordinary primitive
Description
ordinary primitive FMIN
an executable word (no special usage info)
or wrapper call around p4_f_min
Name
fmin:fpnostack.1 — ordinary primitive
Description
ordinary primitive FMIN
an executable word (no special usage info)
or wrapper call around p4_nofp_f_min
Name
fnegate:floating.1 — ordinary primitive
Synopsis
FORTH
FNEGATE
( .. )(
)
;
as:"fnegate";
Description
ordinary primitive FNEGATE
an executable word (no special usage info)
or wrapper call around p4_f_negate
Name
fnegate:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FNEGATE
( .. )(
)
;
as:"fnegate";
Description
ordinary primitive FNEGATE
an executable word (no special usage info)
or wrapper call around p4_nofp_f_negate
Name
forget:tools — ordinary primitive
Synopsis
FORTH
FORGET
( "word" -- )(
)
;
p4:"forget";
Description
simulate:
: FORGET [COMPILE] ' >NAME (FORGET) ; IMMEDIATE
Name
paren-forget:tools_misc.1 — ordinary primitive
Synopsis
EXTENSIONS
(FORGET)
( .. )(
)
;
as:"paren-forget";
Description
ordinary primitive (FORGET)
an executable word (no special usage info)
or wrapper call around p4_paren_forget
Name
forth-minus-contact:environ::environment — ordinary primitive
Description
ordinary primitive FORTH-CONTACT
an executable word (no special usage info)
or wrapper call around p__forth_contact
Name
forth-minus-license:environ::environment — ordinary primitive
Description
ordinary primitive FORTH-LICENSE
an executable word (no special usage info)
or wrapper call around p__forth_license
Name
forth-minus-name:environ::environment — ordinary primitive
Synopsis
ENVIRONMENT
FORTH-NAME
( .. )(
)
;
as:"forth-minus-name";
Description
ordinary primitive FORTH-NAME
an executable word (no special usage info)
or wrapper call around p__forth_name
Name
forth-minus-version:environ::environment — ordinary primitive
Description
ordinary primitive FORTH-VERSION
an executable word (no special usage info)
or wrapper call around p__forth_version
Name
forth-minus-wordlist:search.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL FORTH-WORDLIST
forth_wl (no special usage info)
Name
fourth:toolbelt — ordinary primitive
Synopsis
FORTH
FOURTH
( w x y z -- w x y z w )( | ) ; | |
Description
Copy fourth element on the stack onto top of stack.
: FOURTH 3 PICK ;
Name
fover:floating.1 — ordinary primitive
Synopsis
FORTH
FOVER
( .. )(
)
;
as:"fover";
Description
ordinary primitive FOVER
an executable word (no special usage info)
or wrapper call around p4_f_over
Name
fover:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FOVER
( .. )(
)
;
as:"fover";
Description
ordinary primitive FOVER
an executable word (no special usage info)
or wrapper call around p4_nofp_f_over
Name
f-p-store:floating_misc — ordinary primitive
Synopsis
FORTH
FP!
( addr -- )(
)
;
p4:"f-p-store";
Description
sets the floating point stack pointer -
this is the inverse of FP@
Name
f-p-fetch:floating_misc — ordinary primitive
Synopsis
FORTH
FP@
( -- addr )(
)
;
p4:"f-p-fetch";
Description
returns the floating point stack pointer
Name
fpnostack-minus-ext:fpnostack::environment — ordinary constant
Description
( 1994 ) constant FPNOSTACK-EXT
an ordinary constant (no special usage info)
Name
fpnostack-minus-loaded:fpnostack::environment — constructor primitive
Synopsis
ENVIRONMENT
FPNOSTACK-LOADED
( .. )( | ) ; | |
Description
constructor primitive FPNOSTACK-LOADED
an executable word (no special usage info)
or wrapper call around fpnostack_init
Name
str-frame:dstrings — ordinary primitive
Synopsis
FORTH
$FRAME
( u -- )(
)
;
p4:"str-frame";
Description
Push the description of a string stack frame starting at the
top of the string stack and containing u entries onto the
string frame stack. Errors are thrown if the frame stack
would overflow or if the depth of the string stack above the
top frame, if there is one, is less than u. The value u = 0
is allowed. <ansref>"string-frame"</ansref>
NOTE: The current implementation pushes u and the string
stack pointer onto the frame stack.
Name
str-frame-minus-depth:dstrings.1 — ordinary primitive
Description
ordinary primitive $FRAME-DEPTH
an executable word (no special usage info)
or wrapper call around frame_depth
Name
slash-frame-minus-stack:dstrings.1 — ordinary primitive
Description
ordinary primitive /FRAME-STACK
an executable word (no special usage info)
or wrapper call around per_frame_stack
Name
sharp-frames:dstrings.1 — ordinary primitive
Synopsis
FORTH
#FRAMES
( .. )(
)
;
as:"sharp-frames";
Description
ordinary primitive #FRAMES
an executable word (no special usage info)
or wrapper call around num_frames
Name
free:memory — ordinary primitive
Synopsis
FORTH
FREE
( ptr -- code )(
)
;
p4:"free";
Description
free the memory from ALLOCATE
a code of zero means success.
Name
frot:floating.1 — ordinary primitive
Description
ordinary primitive FROT
an executable word (no special usage info)
or wrapper call around p4_f_rot
Name
frot:fpnostack.1 — ordinary primitive
Description
ordinary primitive FROT
an executable word (no special usage info)
or wrapper call around p4_nofp_f_rot
Name
fround:floating.1 — ordinary primitive
Synopsis
FORTH
FROUND
( .. )(
)
;
as:"fround";
Description
ordinary primitive FROUND
an executable word (no special usage info)
or wrapper call around p4_f_round
Name
fround:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FROUND
( .. )(
)
;
as:"fround";
Description
ordinary primitive FROUND
an executable word (no special usage info)
or wrapper call around p4_nofp_f_round
Name
fs-dot:floating.1 — ordinary primitive
Synopsis
FORTH
FS.
( .. )(
)
;
as:"fs-dot";
Description
ordinary primitive FS.
an executable word (no special usage info)
or wrapper call around p4_f_s_dot
Name
fs-dot:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FS.
( .. )(
)
;
as:"fs-dot";
Description
ordinary primitive FS.
an executable word (no special usage info)
or wrapper call around p4_nofp_f_s_dot
Name
fsin:floating.1 — ordinary primitive
Description
ordinary primitive FSIN
an executable word (no special usage info)
or wrapper call around p4_f_sin
Name
fsin:fpnostack.1 — ordinary primitive
Description
ordinary primitive FSIN
an executable word (no special usage info)
or wrapper call around p4_nofp_f_sin
Name
fsincos:floating.1 — ordinary primitive
Synopsis
FORTH
FSINCOS
( .. )(
)
;
as:"fsincos";
Description
ordinary primitive FSINCOS
an executable word (no special usage info)
or wrapper call around p4_f_sincos
Name
fsincos:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FSINCOS
( .. )(
)
;
as:"fsincos";
Description
ordinary primitive FSINCOS
an executable word (no special usage info)
or wrapper call around p4_nofp_f_sincos
Name
fsinh:floating.1 — ordinary primitive
Synopsis
FORTH
FSINH
( .. )(
)
;
as:"fsinh";
Description
ordinary primitive FSINH
an executable word (no special usage info)
or wrapper call around p4_f_sinh
Name
fsinh:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FSINH
( .. )(
)
;
as:"fsinh";
Description
ordinary primitive FSINH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_sinh
Name
str-fsp:dstrings.1 — ordinary primitive
Synopsis
FORTH
$FSP
( .. )(
)
;
as:"str-fsp";
Description
ordinary primitive $FSP
an executable word (no special usage info)
or wrapper call around sf_sp
Name
str-fsp-zero:dstrings.1 — ordinary primitive
Synopsis
FORTH
$FSP0
( .. )(
)
;
as:"str-fsp-zero";
Description
ordinary primitive $FSP0
an executable word (no special usage info)
or wrapper call around sf_sp0
Name
fsqrt:floating.1 — ordinary primitive
Synopsis
FORTH
FSQRT
( .. )(
)
;
as:"fsqrt";
Description
ordinary primitive FSQRT
an executable word (no special usage info)
or wrapper call around p4_f_sqrt
Name
fsqrt:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FSQRT
( .. )(
)
;
as:"fsqrt";
Description
ordinary primitive FSQRT
an executable word (no special usage info)
or wrapper call around p4_nofp_f_sqrt
Name
fswap:floating.1 — ordinary primitive
Synopsis
FORTH
FSWAP
( .. )(
)
;
as:"fswap";
Description
ordinary primitive FSWAP
an executable word (no special usage info)
or wrapper call around p4_f_swap
Name
fswap:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FSWAP
( .. )(
)
;
as:"fswap";
Description
ordinary primitive FSWAP
an executable word (no special usage info)
or wrapper call around p4_nofp_f_swap
Name
ftan:floating.1 — ordinary primitive
Description
ordinary primitive FTAN
an executable word (no special usage info)
or wrapper call around p4_f_tan
Name
ftan:fpnostack.1 — ordinary primitive
Description
ordinary primitive FTAN
an executable word (no special usage info)
or wrapper call around p4_nofp_f_tan
Name
ftanh:floating.1 — ordinary primitive
Synopsis
FORTH
FTANH
( .. )(
)
;
as:"ftanh";
Description
ordinary primitive FTANH
an executable word (no special usage info)
or wrapper call around p4_f_tanh
Name
ftanh:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
FTANH
( .. )(
)
;
as:"ftanh";
Description
ordinary primitive FTANH
an executable word (no special usage info)
or wrapper call around p4_nofp_f_tanh
Name
fvariable:floating.1 — definining primitive
Synopsis
FORTH
FVARIABLE
( .. )(
)
;
as:"fvariable";
Description
definining primitive FVARIABLE
an executable word (no special usage info)
or wrapper call around p4_f_variable
Name
fvariable:fpnostack.1 — definining primitive
Synopsis
EXTENSIONS
FVARIABLE
( .. )(
)
;
as:"fvariable";
Description
definining primitive FVARIABLE
an executable word (no special usage info)
or wrapper call around p4_nofp_f_variable
Name
f-like:floating.1 — ordinary primitive
Description
ordinary primitive F~
an executable word (no special usage info)
or wrapper call around p4_f_proximate
Name
f-like:fpnostack.1 — ordinary primitive
Description
ordinary primitive F~
an executable word (no special usage info)
or wrapper call around p4_nofp_f_proximate
Name
garbage-Q:dstrings — ordinary primitive
Synopsis
FORTH
$GARBAGE?
( -- flag )(
)
;
str:"garbage-Q";
Description
Leave true if there is garbage in the current string space.
Not normally used, since garbage collection is transparent.
<ansref>"string-garbage-question"</ansref>
Name
str-gc-minus-off:dstrings.1 — ordinary primitive
Synopsis
FORTH
$GC-OFF
( .. )(
)
;
as:"str-gc-minus-off";
Description
ordinary primitive $GC-OFF
an executable word (no special usage info)
or wrapper call around p4_str_gc_off
Name
str-gc-minus-on:dstrings.1 — ordinary primitive
Synopsis
FORTH
$GC-ON
( .. )(
)
;
as:"str-gc-minus-on";
Description
ordinary primitive $GC-ON
an executable word (no special usage info)
or wrapper call around p4_str_gc_on
Name
get-current:search — ordinary primitive
Synopsis
FORTH
GET-CURRENT
( -- voc )(
)
;
p4:"get-current";
Description
return the current definition vocabulary, see DEFINITIONS
Name
get-order:search — ordinary primitive
Synopsis
FORTH
GET-ORDER
( -- vocn ... voc1 n )( | ) ; | |
Description
get the current search order onto the stack, see SET-ORDER
Name
gettimeofday:posix — ordinary primitive
Synopsis
EXTENSIONS
GETTIMEOFDAY
( -- double-time )( | ) ; | |
Description
returns SVR/BSD gettimeofday(2).
Never defined on 16-bit systems, hence
TIME&DATE is more portable.
Name
gforth-minus-dir:gforth::environment — ordinary constant
Synopsis
ENVIRONMENT
GFORTH-DIR
( .. )(
)
;
as:"gforth-minus-dir";
Description
( 500 ) constant GFORTH-DIR
an ordinary constant (no special usage info)
Name
getgid:shell — ordinary primitive
Synopsis
EXTENSIONS
$GID
( -- val )(
)
;
p4:"getgid";
Description
calls system's
getgid
Name
gotoxy:term — ordinary primitive
Synopsis
EXTENSIONS
GOTOXY
( x y -- )(
)
;
p4:"gotoxy";
Description
move the cursor to the specified position on the screen -
this is usually done by sending a corresponding esc-sequence
to the terminal.
Name
h-sh:toolbelt — immediate primitive
Synopsis
FORTH
H#
( "hexnumber" -- n )(
)
;
p4:"h-sh";
Description
Get the next word in the input stream as a hex
single-number literal. (Adopted from Open Firmware.)
: H# ( "hexnumber" -- n ) \ Simplified for easy porting.
0 0 BL WORD COUNT
BASE @ >R HEX >NUMBER R> BASE !
ABORT" Not Hex " 2DROP ( n)
STATE @ IF POSTPONE LITERAL THEN
; IMMEDIATE
Name
dot-h2:your — ordinary primitive
Synopsis
EXTENSIONS
.H2
( value -- )(
)
;
p4:"dot-h2";
Description
print hexadecimal, but with per-byte 0-padding
0x0 -> 00
0xf -> 0f
0x12 -> 12
0x123 -> 0123
0x1234 -> 1234
0x12345 -> 012345
Name
header:header.1 — obsolete forthword
Synopsis
EXTENSIONS
HEADER
( .. )(
)
;
as:"header";
Description
obsolete forthword HEADER
is doing the same as $HEADER
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
str-header:header — ordinary primitive
Synopsis
EXTENSIONS
$HEADER
( bstring -- )(
)
;
p4:"str-header";
Description
CREATE a new header in the dictionary from the given string
with the variable runtime (see HEADER, and CREATE:)
usage: : VARIABLE BL WORD $HEADER ;
Name
header-comma:header — ordinary primitive
Synopsis
EXTENSIONS
HEADER,
( str-ptr str-len -- )( | ) ; | |
Description
CREATE a new header in the dictionary from the given string, without CFA
usage: : VARIABLE BL WORD COUNT HEADER, DOVAR , ;
Name
header-minus-ext:header::environment — ordinary constant
Synopsis
ENVIRONMENT
HEADER-EXT
( .. )(
)
;
as:"header-minus-ext";
Description
( 1983 ) constant HEADER-EXT
an ordinary constant (no special usage info)
Name
help:misc — ordinary primitive
Synopsis
FORTH
HELP
( name -- )(
)
;
p4:"help";
Description
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.
Name
paren-help:help.1 — ordinary primitive
Synopsis
FORTH
(HELP)
( .. )(
)
;
as:"paren-help";
Description
ordinary primitive (HELP)
an executable word (no special usage info)
or wrapper call around p4_paren_help
Name
here:core — ordinary primitive
Synopsis
FORTH
HERE
( -- dp-value )(
)
;
p4:"here";
Description
used with WORD and many compiling words
simulate: : HERE DP @ ;
Name
here-word:your — ordinary primitive
Synopsis
EXTENSIONS
HERE-WORD
( char "name<char>" -- )( | ) ; | |
Description
a FIG-compatible WORD. Where ANSI says "skip leading delimiters"
this one acts as "skip leading whitespace". And it will not return
anything and have the string parsed to HERE
Name
hex:core — ordinary primitive
Description
set the input/output BASE to hexadecimal
simulate: : HEX 16 BASE ! ;
Name
dot-highlight:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.HIGHLIGHT
( .. )(
)
;
as:"dot-highlight";
Description
ordinary primitive .HIGHLIGHT
an executable word (no special usage info)
or wrapper call around p4_dot_highlight
Name
dot-highlight-dot-off:term.1 — ordinary primitive
Description
ordinary primitive .HIGHLIGHT.OFF
an executable word (no special usage info)
or wrapper call around p4_dot_highlight_off
Name
hiword:toolbelt — ordinary primitive
Synopsis
FORTH
HIWORD
( xxyy -- xx )(
)
;
p4:"hiword";
Description
The high half of the value.
: HIWORD ( xxyy -- xx ) 16 RSHIFT ;
Name
hld:misc.1 — threadstate variable
Description
threadstate variable HLD
hld (no special usage info)
Name
slash-hold:core::environment — ordinary constant
Synopsis
ENVIRONMENT
/HOLD
( .. )(
)
;
as:"slash-hold";
Description
( MIN_HOLD ) constant /HOLD
an ordinary constant (no special usage info)
Name
hold:core — ordinary primitive
Synopsis
FORTH
HOLD
( char -- )(
)
;
p4:"hold";
Description
the old-style forth-formatting system -- this
word adds a char to the picutred output string.
Name
dot-home:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.HOME
( .. )(
)
;
as:"dot-home";
Description
ordinary primitive .HOME
an executable word (no special usage info)
or wrapper call around p4_dot_home
Name
home:shell — ordinary primitive
Synopsis
EXTENSIONS
$HOME
( -- str-ptr str-len )(
)
;
p4:"home";
Description
calls system's
getenv(HOME)
Name
host-minus-system:environ::environment — ordinary primitive
Description
ordinary primitive HOST-SYSTEM
an executable word (no special usage info)
or wrapper call around p__host_system
Name
htonl:posix.1 — ordinary primitive
Synopsis
EXTENSIONS
HTONL
( .. )(
)
;
as:"htonl";
Description
ordinary primitive HTONL
an executable word (no special usage info)
or wrapper call around p4_ntohl
Name
htons:posix.1 — ordinary primitive
Synopsis
EXTENSIONS
HTONS
( .. )(
)
;
as:"htons";
Description
ordinary primitive HTONS
an executable word (no special usage info)
or wrapper call around p4_ntohs
Name
i:core — compiling primitive
Description
returns the index-value of the innermost DO .. LOOP
Name
id-dot:misc — ordinary primitive
Synopsis
FORTH
ID.
( nfa -- )(
)
;
p4:"id-dot";
Description
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 possibility.
: .NAME COUNT TYPE ;
you should more and more convert your code to use the sequence
NAME>STRING TYPE
Name
sh-if:cdecl — immediate primitive
Description
( -- state-save mfth-if-magic )
prepares for a following #IS_TRUE or #IS_FALSE,
does basically switch off compile-mode for the enclosed
code. <br>
better use the ANSI style [IF] [ELSE] [THEN] construct.
Name
if:core — compiling primitive
Synopsis
FORTH
IF
( value -- ).. THEN(
)
;
p4:"if";
Description
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.
Name
sh-ifdef:cdecl — immediate primitive
Synopsis
FORTH
#IFDEF
( "word" -- )(
)
;
p4:"sh-ifdef";
Description
better use
[DEFINED] word [IF]
- the word [IF]
is ANSI-conform.
Name
sharp-ifndef:cdecl.1 — immediate primitive
Synopsis
FORTH
#IFNDEF
( .. )(
)
;
as:"sharp-ifndef";
Description
immediate primitive #IFNDEF
an executable word (no special usage info)
or wrapper call around p4_sh_ifnotdef
Name
sh-ifnotdef:cdecl — immediate primitive
Synopsis
FORTH
#IFNOTDEF
( "word" -- )(
)
;
p4:"sh-ifnotdef";
Description
better use
[DEFINED] word [NOT] [IF]
- the word [IF]
and [ELSE] are ANSI-conform, while #IFDEF #ELSE are not.
Name
bracket-if:tools — immediate primitive
Synopsis
FORTH
[IF]
( flag -- )(
)
;
p4:"bracket-if";
Description
check the condition in the CS-STACK. If true let the following
text flow into INTERPRET , otherwise eat up everything upto
and including the next [ELSE] or [THEN] . In case of
skipping, count nested [IF] ... [THEN] constructs.
this word provides a simple pre-compiler mechanism
Name
immediate:core — ordinary primitive
Synopsis
FORTH
IMMEDIATE
( -- )(
)
;
p4:"immediate";
Name
paren-immediate-sharp:header.1 — obsolete forthword
Description
obsolete forthword (IMMEDIATE#)
is doing the same as IMMEDIATE-MASK
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
immediate-minus-mask:header.1 — ordinary constant
Description
( P4xIMMEDIATE ) constant IMMEDIATE-MASK
an ordinary constant (no special usage info)
Name
back-in:core.1 — threadstate variable
Synopsis
FORTH
>IN
( .. )(
)
;
as:"back-in";
Description
threadstate variable >IN
input.to_in (no special usage info)
Name
include:file_misc — ordinary primitive
Synopsis
FORTH
INCLUDE
( 'filename' -- ? )(
)
;
p4:"include";
Description
load the specified file, see also LOAD" filename"
Name
include-file:file — ordinary primitive
Synopsis
FORTH
INCLUDE-FILE
( file -- )( | ) ; | |
Name
included:file — ordinary primitive
Synopsis
FORTH
INCLUDED
( str-adr str-len -- )( | ) ; | |
Name
input-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
INPUT_MAGIC
( .. )(
)
;
as:"input-magic";
Description
( P4_INPUT_MAGIC ) constant INPUT_MAGIC
an ordinary constant (no special usage info)
Name
instance:struct — ordinary primitive
Synopsis
EXTENSIONS
INSTANCE
( len "name" -- )(
)
;
p4:"instance";
Description
Create a named instance of a named structure.
: INSTANCE CREATE ALLOT ;
Name
instance-addr:struct — ordinary primitive
Synopsis
EXTENSIONS
INSTANCE-ADDR
( len -- addr )( | ) ; | |
Description
Create nameless instance of a structure and return base address.
: INSTANCE-ADDR HERE SWAP ALLOT ;
Name
integer-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
INTEGER:
( .. )(
)
;
as:"integer-colon";
Description
ordinary primitive INTEGER:
an executable word (no special usage info)
or wrapper call around p4_cell_colon
Name
dot-intensity:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.INTENSITY
( .. )(
)
;
as:"dot-intensity";
Description
ordinary primitive .INTENSITY
an executable word (no special usage info)
or wrapper call around p4_dot_intensity
Name
dot-intensity-dot-off:term.1 — ordinary primitive
Description
ordinary primitive .INTENSITY.OFF
an executable word (no special usage info)
or wrapper call around p4_dot_intensity_off
Name
interpret:forth_83.1 — ordinary primitive
Synopsis
FORTH
INTERPRET
( .. )(
)
;
as:"interpret";
Description
ordinary primitive INTERPRET
an executable word (no special usage info)
or wrapper call around p4_interpret
Name
into:your — compiling primitive
Synopsis
EXTENSIONS
INTO
( [name] -- pfa )(
)
;
p4:"into";
Description
will return the parameter-field address of the following word.
Unlike others, this word will also return the address of
LOCALS| and local LVALUE - so in fact a
TO A
and
INTO A !
are the same. This word is most useful when calling
C-exported function with a temporary local-VAR as a return-place
argument - so the address of a local has to be given as an arg.
Beware that you should not try to save the address anywhere else,
since a local's address does always depend of the RP-depth -
EXIT from a colon-word and the value may soon get overwritten.
(see also TO )
Name
invert:core — ordinary primitive
Synopsis
FORTH
INVERT
( value -- value' )(
)
;
p4:"invert";
Description
make a bitwise negation of the value on stack.
see also NEGATE
Name
is:header — compiling primitive
Synopsis
EXTENSIONS
IS
( xt-value [word] -- )(
)
;
p4:"is";
Description
set a DEFER word
(in pfe: set the DOES-field - which is the BODY-field in ans-mode
and therefore the same as TO / in fig-mode the DOES-field is
one cell higher up than for a CREATE: VARIABLE
Use IS freely on each DOES-words in both modes).
: IS '
STATE @ IF LITERAL, POSTPONE >DOES-BODY POSTPONE !
ELSE >DOES-BODY ! THEN
; IMMEDIATE
Name
is-alnum:toolbelt — ordinary primitive
Synopsis
FORTH
IS-ALNUM
( char -- flag )(
)
;
p4:"is-alnum";
Description
Test _char_ for alphanumeric [A-Za-z0-9].
: IS-ALNUM
DUP IS-ALPHA ORIF DUP IS-DIGIT THEN NIP ;
Name
is-alpha:toolbelt — ordinary primitive
Synopsis
FORTH
IS-ALPHA
( char -- flag )(
)
;
p4:"is-alpha";
Description
Test _char_ for alphabetic [A-Za-z].
: IS-ALPHA 32 OR [CHAR] a - 26 U< ;
Name
is-digit:toolbelt — ordinary primitive
Synopsis
FORTH
IS-DIGIT
( char -- flag )(
)
;
p4:"is-digit";
Description
Test _char_ for digit [0-9].
: IS-DIGIT [CHAR] 0 - 10 U< ;
Name
is-white:toolbelt — ordinary primitive
Synopsis
FORTH
IS-WHITE
( char -- flag )(
)
;
p4:"is-white";
Description
Test char for white space.
: IS-WHITE 33 - 0< ;
Name
sh-is-false:cdecl — immediate primitive
Synopsis
FORTH
#IS_FALSE
( flag -- )(
)
;
p4:"sh-is-false";
Description
( state-save mfth-if-magic flag -- )
checks the condition on the
CS-STACK
. <br>
Pairs with #IF <br>
better use the ANSI style [IF] [ELSE] [THEN] construct.
Name
sh-is-true:cdecl — immediate primitive
Synopsis
FORTH
#IS_TRUE
( flag -- )(
)
;
p4:"sh-is-true";
Description
( state-save mfth-if-magic flag -- )
checks the condition on the
CS-STACK
. <br>
Pairs with #IF <br>
better use the ANSI style [IF] [ELSE] [THEN] construct.
Name
j:core — compiling primitive
Description
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
Name
k:forth_83 — compiling primitive
Synopsis
FORTH
K
( -- counter-val )(
)
;
p4:"k";
Description
the 3rd loop index just like I and J
Name
k-minus-down:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-DOWN
( .. )(
)
;
as:"k-minus-down";
Description
( P4_KEY_kd ) constant K-DOWN
an ordinary constant (no special usage info)
Name
k-minus-end:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-END
( .. )(
)
;
as:"k-minus-end";
Description
( P4_KEY_kH ) constant K-END
an ordinary constant (no special usage info)
Name
k-minus-home:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-HOME
( .. )(
)
;
as:"k-minus-home";
Description
( P4_KEY_kh ) constant K-HOME
an ordinary constant (no special usage info)
Name
k-minus-left:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-LEFT
( .. )(
)
;
as:"k-minus-left";
Description
( P4_KEY_kl ) constant K-LEFT
an ordinary constant (no special usage info)
Name
k-minus-next:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-NEXT
( .. )(
)
;
as:"k-minus-next";
Description
( P4_KEY_kN ) constant K-NEXT
an ordinary constant (no special usage info)
Name
k-minus-prior:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-PRIOR
( .. )(
)
;
as:"k-minus-prior";
Description
( P4_KEY_kP ) constant K-PRIOR
an ordinary constant (no special usage info)
Name
k-minus-right:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-RIGHT
( .. )(
)
;
as:"k-minus-right";
Description
( P4_KEY_kr ) constant K-RIGHT
an ordinary constant (no special usage info)
Name
k-minus-up:term.1 — ordinary constant
Synopsis
EXTENSIONS
K-UP
( .. )(
)
;
as:"k-minus-up";
Description
( P4_KEY_ku ) constant K-UP
an ordinary constant (no special usage info)
Name
k-one:term.1 — ordinary constant
Description
( P4_KEY_k1 ) constant K1
an ordinary constant (no special usage info)
Name
k-ten:term.1 — ordinary constant
Description
( P4_KEY_k0 ) constant K10
an ordinary constant (no special usage info)
Name
sharp-k-twelve-ninetyseven-minus-g-twenty:host_k12.1 — ordinary constant
Description
( _K12_SOURCE+100 ) constant #K1297-G20
an ordinary constant (no special usage info)
Name
k-two:term.1 — ordinary constant
Description
( P4_KEY_k2 ) constant K2
an ordinary constant (no special usage info)
Name
k-three:term.1 — ordinary constant
Synopsis
EXTENSIONS
K3
( .. )(
)
;
as:"k-three";
Description
( P4_KEY_k3 ) constant K3
an ordinary constant (no special usage info)
Name
k-four:term.1 — ordinary constant
Description
( P4_KEY_k4 ) constant K4
an ordinary constant (no special usage info)
Name
k-five:term.1 — ordinary constant
Description
( P4_KEY_k5 ) constant K5
an ordinary constant (no special usage info)
Name
k-six:term.1 — ordinary constant
Description
( P4_KEY_k6 ) constant K6
an ordinary constant (no special usage info)
Name
k-seven:term.1 — ordinary constant
Synopsis
EXTENSIONS
K7
( .. )(
)
;
as:"k-seven";
Description
( P4_KEY_k7 ) constant K7
an ordinary constant (no special usage info)
Name
k-eight:term.1 — ordinary constant
Synopsis
EXTENSIONS
K8
( .. )(
)
;
as:"k-eight";
Description
( P4_KEY_k8 ) constant K8
an ordinary constant (no special usage info)
Name
k-nine:term.1 — ordinary constant
Description
( P4_KEY_k9 ) constant K9
an ordinary constant (no special usage info)
Name
key:core — ordinary primitive
Synopsis
FORTH
KEY
( -- char )(
)
;
p4:"key";
Description
return a single character from the keyboard - the
key is not echoed.
Name
paren-key:misc.1 — ordinary primitive
Synopsis
FORTH
(KEY)
( .. )(
)
;
as:"paren-key";
Description
ordinary primitive (KEY)
an executable word (no special usage info)
or wrapper call around p4_paren_key
Name
star-key-star:misc.1 — threadstate variable
Synopsis
FORTH
*KEY*
( .. )(
)
;
as:"star-key-star";
Description
threadstate variable *KEY*
key (no special usage info)
Name
key-question:facility — ordinary primitive
Synopsis
FORTH
KEY?
( -- flag )(
)
;
p4:"key-question";
Description
if a character is available from the keyboard, return true.
The KEY word will retrieve the actual character.
Name
l-to-name:header — ordinary primitive
Synopsis
FORTH
L>NAME
( lfa -- nfa )(
)
;
p4:"l-to-name";
Description
converts a pointer to the link-field (LFA) to point
then to the corresponding name-field (CFA) - this one is one of
the slowest operation available. One should always use the inverse
operation "N>LINK" and cache an older value if that is needed.
Some words might be linked but they do not have a name-field (just
the other fields) but this word can not detect that and will try to look
into the bits of the dictionary anway in the assumption that there is
something - and if done in the wrong place it might even segfault.
Only in fig-mode and for traditional fig-mode programs, this word may
possibly have enough extra assertions to be somewhat reliable.
(and fig-mode did not know about SYNONYMs - see note at LINK>).
implementation-specific configure-dependent fig-only simulation:
: L>NAME BEGIN DUP C@ 128 AND 0= WHILE 1- REPEAT ;
Name
last:header.1 — threadstate variable
Description
threadstate variable LAST
last (no special usage info)
Name
latest:header — ordinary primitive
Synopsis
FORTH
LATEST
( -- nfa )(
)
;
p4:"latest";
Description
return the NFA of the lateset definition in the
CURRENT vocabulary
Name
local-buffer-var:locals — compiling primitive
Synopsis
EXTENSIONS
LBUFFER:
( size [name] -- )( | ) ; | |
Description
declares a single local VALUE using (LOCAL) - which
will hold the address of an area like BUFFER: but carved
from the return-stack (as in C with alloca). This local buffer
will be automatically given up at the end of the word. The
return-stack-pointer will be increased only at the time of
this function (and the address assigned to the LVALUE)
so that the provided size gets determined at runtime. Note
that in some configurations the forth-return-stack area is
quite small - for large string operations you should consider
to use a POCKET-PAD in pfe.
: LBUFFER:
STATE @ IF
BUFFER:
ELSE
:NONAME ( size -- rp* ) R> RP@ - DUP RP! SWAP >R ;NONAME
COMPILE, POSTPONE LVALUE
THEN
; IMMEDIATE
Name
leave:core — compiling primitive
Synopsis
FORTH
LEAVE
( -- )(
)
;
p4:"leave";
Description
quit the innermost DO .. LOOP - it does even
clean the return-stack and branches to the place directly
after the next LOOP
Name
question-leave:forth_usual — compiling primitive
Synopsis
FORTH
?LEAVE
( cond -- )(
)
;
p4:"question-leave";
Description
leave a (innermost) loop if condition is true
Name
lexeme:toolbelt — ordinary primitive
Synopsis
FORTH
LEXEME
( "name" -- str len )(
)
;
p4:"lexeme";
Description
Get the next word on the line as a character string.
If it's a single character, use it as the delimiter to
get a phrase.
: LEXEME
BL WORD ( addr) DUP C@ 1 =
IF CHAR+ C@ WORD THEN
COUNT ;
Name
license:core_misc — ordinary primitive
Synopsis
FORTH
LICENSE
( -- )(
)
;
p4:"license";
Description
show a lisence info - the basic PFE system is licensed under the terms
of the LGPL (Lesser GNU Public License) - binary modules loaded into
the system and hooking into the system may carry another LICENSE
: LICENSE [ ENVIRONMENT ] FORTH-LICENSE TYPE ;
Name
dot-line:misc — ordinary primitive
Synopsis
FORTH
.LINE
( line# block# -- )(
)
;
p4:"dot-line";
Name
to-link:header — ordinary primitive
Synopsis
FORTH
>LINK
( cfa -- lfa )(
)
;
p4:"to-link";
Description
converts a pointer to the code-field (CFA) to point
then to the corresponding link-field (LFA) - in some configurations
this can be a very slow operation since the system might need to walk
through all header-words in the system, looking for a >NAME that
has the cfa and *then* returning the "N>LINK" result here - which might
be none at all if the word is a :NONAME. Use always >NAME and
treat this word as non-portable just like any assumption about the
contents of the >LINK-field.
Only in fig-mode and for traditional fig-mode programs, this word may
possibly have enough extra assertions to be somewhat reliable.
(and fig-mode did not know about SYNONYMs - see note at LINK>).
Name
link-comma:chain — ordinary primitive
Synopsis
EXTENSIONS
link,
( list -- )(
)
;
p4:"link-comma";
Description
: link, here over @ a, swap ! ;
Name
link-from:header — ordinary primitive
Synopsis
FORTH
LINK>
( lfa -- cfa )(
)
;
p4:"link-from";
Description
converts a pointer to the link-field (LFA) to point
then to the corresponding code-field (CFA)
BEWARE: this one does not care about SYNONYMs and it is the
only way to get at the data of a SYNONYM. Therefore, if you have
a synonym called A for an old word B then there is a different
result using "NAME>" on an A-nfa or using "N>LINK LINK>" since the
first "NAME>" will return the xt of B while the latter will return
the xt of A - but executing an xt of A is an error and it will THROW
this difference is intentional to allow knowledgable persons to
do weird things looking around in the dictionary. The forth standard
words will not give you much of a chance to get hold of the nfa of
a SYNONYM word anyway - asking FIND for a word A will return
the execution token of B immediatly and "NAME>" on that one lead to
the nfa of B and not that of A.
Name
gforth-linked:gforth — ordinary primitive
Synopsis
gforth'
linked
( list -- )\ gforth( | ) ; | |
Description
: linked here over @ a, swap ! ;
(note: win32forth calls it "link," )
Name
list:block — ordinary primitive
Synopsis
FORTH
LIST
( u -- )(
)
;
p4:"list";
Description
display the block
Name
lit:misc.1 — ordinary primitive
Description
ordinary primitive LIT
an executable word (no special usage info)
or wrapper call around p4_literal_execution
Name
literal:core — compiling primitive
Synopsis
FORTH
LITERAL
( value -- )immediate( | ) ; | |
Description
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)
Name
two-literal:double — compiling primitive
Synopsis
FORTH
2LITERAL
( x1 x2 -- )immediate( | ) ; | |
Description
compile a double-cell number to the current definition. When
run, the doubele-cell is left on the stack for execution.
( -- x1 x2 )
(in most configurations this word is statesmart and it will do nothing
in interpret-mode. See 2LITERAL, for a non-immediate variant)
Name
literal-comma:double_misc — ordinary primitive
Synopsis
FORTH
LITERAL,
( value -- )(
)
;
p4:"literal-comma";
Description
take the value from stack (or cs-stack) and compile a runtime-code and
the value as for LITERAL ... this word is never state-smart, it
is not immediate, and has therefore no complications with POSTPONE
(compare also with COMPILE, to make a call-stub with an exectoken)
Name
two-literal-comma:double_misc — ordinary primitive
Synopsis
FORTH
2LITERAL,
( x1,x2 -- )( | ) ; | |
Description
take the double-value from stack (or cs-stack) and compile a runtime-code
and the value as for 2LITERAL ... this word is never state-smart, it
is not immediate, and has therefore no complications with POSTPONE
(compare also with COMPILE, to make a call-stub with an exectoken)
Name
ll:shell.1 — compiling primitive
Description
compiling primitive LL
an executable word (no special usage info)
or wrapper call around p4_ll
Name
ln:shell.1 — compiling primitive
Description
compiling primitive LN
an executable word (no special usage info)
or wrapper call around p4_link
Name
load:block — ordinary primitive
Synopsis
FORTH
LOAD
( u -- )(
)
;
p4:"load";
Name
load-quote:misc — compiling primitive
Synopsis
FORTH
LOAD"
( [filename<">] -- ? )obsolete ( | ) ; | |
Description
load the specified file - this word can be compiled into a word-definition
obsolete! use OPEN-BLOCKFILE name LOAD
Name
loadf:useful — ordinary primitive
Synopsis
EXTENSIONS
LOADF
( "filename" -- )(
)
;
p4:"loadf";
Description
loads a file just like INCLUDE but does also put
a MARKER in the LOADED dictionary that you can
do a FORGET on to kill everything being loaded
from that file.
Name
loadf-locate:useful — ordinary primitive
Synopsis
EXTENSIONS
LOADF-LOCATE
( "name" -- )( | ) ; | |
Description
look for the filename created by LOADF that had been
defining the given name. LOADF has created a marker
that is above the INCLUDED file and that
marker has a body-value just below the
INCLUDED file. Hence the symbol was defined during
LOADF execution of that file.
: LOADF-LOCATE ?EXEC POSTPONE ' (LOADF-LOCATE) .NAME ;
Name
paren-loadf-minus-locate:useful.1 — ordinary primitive
Description
ordinary primitive (LOADF-LOCATE)
an executable word (no special usage info)
or wrapper call around p4_paren_loadf_locate
Name
Q-loading:tools_misc — ordinary primitive
Synopsis
FORTH
?LOADING
( -- )(
)
;
p4:"Q-loading";
Description
check that the currently interpreted text is
from a file/block, otherwise THROW
Name
loadm:dlfcn — ordinary primitive
Synopsis
FORTH
LOADM
( 'filename' -- )(
)
;
p4:"loadm";
Description
dlmap the shared object (or share an already mapped object)
and run the per-thread initialization code. This is the
user-convenient function, otherwise use (LOADM)
simulate:
: LOADM BL WORD
((IS_MODULE_LOADED)) IF EXIT THEN
HERE (LOADM) 0= IF ." -- load failed: " HERE COUNT TYPE CR THEN ;
Name
paren-loadm:dlfcn.1 — ordinary primitive
Synopsis
FORTH
(LOADM)
( .. )(
)
;
as:"paren-loadm";
Description
ordinary primitive (LOADM)
an executable word (no special usage info)
or wrapper call around p4_paren_loadm
Name
to-from-load-signals-back-back:signals.1 — constructor primitive
Synopsis
EXTENSIONS
<<load_signals>>
( .. )( | ) ; | |
Description
constructor primitive <<load_signals>>
an executable word (no special usage info)
or wrapper call around p4_load_signals
Name
paren-local:locals.1 — compiling primitive
Synopsis
FORTH
(LOCAL)
( .. )(
)
;
as:"paren-local";
Description
compiling primitive (LOCAL)
an executable word (no special usage info)
or wrapper call around p4_paren_local
Name
local-minus-dlcall:dlfcn.1 — immediate primitive
Description
immediate primitive LOCAL-DLCALL
an executable word (no special usage info)
or wrapper call around p4_local_dlcall
Name
local-dlsym:dlfcn — immediate primitive
Synopsis
FORTH
LOCAL-DLSYM
( [symbolname] -- address )exec-only( | ) ; | |
Description
lookup the symbol that follows and leave the address (or null)
Name
sharp-locals:locals::environment — ordinary constant
Synopsis
ENVIRONMENT
#LOCALS
( .. )(
)
;
as:"sharp-locals";
Description
( MAX_LOCALS ) constant #LOCALS
an ordinary constant (no special usage info)
Name
locals-minus-ext:locals::environment — ordinary constant
Synopsis
ENVIRONMENT
LOCALS-EXT
( .. )(
)
;
as:"locals-minus-ext";
Description
( 1994 ) constant LOCALS-EXT
an ordinary constant (no special usage info)
Name
locals-minus-loaded:locals::environment — constructor primitive
Description
constructor primitive LOCALS-LOADED
an executable word (no special usage info)
or wrapper call around locals_init
Name
locals-bar:locals — compiling primitive
Synopsis
FORTH
LOCALS|
( xN ... x2 x1 [name1 .. nameN <|>] -- )( | ) ; | |
Description
create local identifiers to be used in the current definition.
At runtime, each identifier will be assigned a value from
the parameter stack. <br>
The identifiers may be treated as if being a VALUE , it does
also implement the ansi TO extensions for locals. Note that
the identifiers are only valid inside the currently compiled
word, the SEE decompiled word will show them as
<A> <B> ... <N> a.s.o. <br>
see also LVALUE
Name
loop:core — compiling primitive
Description
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.
Name
plus-loop:core — compiling primitive
Synopsis
FORTH
+LOOP
( increment -- )(
)
;
p4:"plus-loop";
Description
compile ((+LOOP)) which will use the increment
as the loop-offset instead of just 1. See the
DO and LOOP construct.
Name
loop-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
LOOP_MAGIC
( .. )(
)
;
as:"loop-magic";
Description
( P4_LOOP_MAGIC ) constant LOOP_MAGIC
an ordinary constant (no special usage info)
Name
lower:forth_usual — ordinary primitive
Synopsis
FORTH
LOWER
( addr cnt -- )(
)
;
p4:"lower";
Description
convert string to lower case
This is not in L&P's F83 but provided for symmetry
simulate:
: LOWER 0 DO DUP I + DUP C@ >R _tolower SWAP C! LOOP DROP ;
Name
lower-minus-case:misc.1 — threadstate variable
Synopsis
FORTH
LOWER-CASE
( .. )(
)
;
as:"lower-minus-case";
Description
threadstate variable LOWER-CASE
wordl_flag (no special usage info)
Name
lower-minus-case-minus-fn:misc.1 — threadstate variable
Description
threadstate variable LOWER-CASE-FN
lower_case_fn (no special usage info)
Name
lower-minus-case-minus-fn-question:misc.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL LOWER-CASE-FN?
lower_case_fn (no special usage info)
Name
loword:toolbelt — ordinary primitive
Synopsis
FORTH
LOWORD
( xxyy -- yy )(
)
;
p4:"loword";
Description
The low half of the value.
: LOWORD ( xxyy -- yy ) 65535 AND ;
Name
ls:shell.1 — compiling primitive
Description
compiling primitive LS
an executable word (no special usage info)
or wrapper call around p4_ls
Name
ls-cdefs:misc — ordinary primitive
Synopsis
FORTH
LS.COLON-DEFS
( -- )(
)
;
p4:"ls-cdefs";
Name
ls-constants:misc — ordinary primitive
Synopsis
FORTH
LS.CONSTANTS
( -- )(
)
;
p4:"ls-constants";
Name
ls-ddefs:misc — ordinary primitive
Synopsis
FORTH
LS.DOES-DEFS
( -- )(
)
;
p4:"ls-ddefs";
Name
ls-markers:misc — ordinary primitive
Synopsis
FORTH
LS.MARKERS
( -- )(
)
;
p4:"ls-markers";
Name
ls-primitives:misc — ordinary primitive
Synopsis
FORTH
LS.PRIMITIVES
( -- )(
)
;
p4:"ls-primitives";
Name
ls-variables:misc — ordinary primitive
Synopsis
FORTH
LS.VARIABLES
( -- )(
)
;
p4:"ls-variables";
Name
ls-vocabularies:misc — ordinary primitive
Synopsis
FORTH
LS.VOCABULARIES
( -- )( | ) ; | |
Name
ls-words:misc — ordinary primitive
Synopsis
FORTH
LS.WORDS
( -- )(
)
;
p4:"ls-words";
Name
l-shift:core — ordinary primitive
Synopsis
FORTH
LSHIFT
( value shift-val -- value' )( | ) ; | |
Description
does a bitwise left-shift on value
Name
lt-dlcose:dlfcn — ordinary primitive
Synopsis
EXTENSIONS
lt_dlclose
( handle -- ior )( | ) ; | |
Name
lt-dlerror:dlfcn — ordinary primitive
Synopsis
EXTENSIONS
lt_dlerror
( -- z-string* )( | ) ; | |
Name
lt-dlinit:dlfcn — ordinary primitive
Synopsis
EXTENSIONS
lt_dlinit
( -- ior )(
)
;
p4:"lt-dlinit";
Description
initialiize library, usually open the program itself so that its
handles can be found under "0"
Name
lt-dlopenext:dlfcn — ordinary primitive
Synopsis
EXTENSIONS
lt_dlopenext
( name-ptr,len -- handle-ptr|0 )( | ) ; | |
Description
walk the searchpath for dlopen and try to open a binary module
under the given name with the usual file extension for the
current system.
Name
lt-dlsym:dlfcn — ordinary primitive
Synopsis
EXTENSIONS
lt_dlsym
( name-ptr,len handle -- symbol-addr|0)( | ) ; | |
Description
try to find the name in the binary module denoted by its handle
.. if handle is null, use the main body of the program
Name
local-value:locals — compiling primitive
Synopsis
EXTENSIONS
LVALUE
( value [name] -- )( | ) ; | |
Description
declares a single local VALUE using (LOCAL) - a
sequence of LVALUE declarations can replace a
LOCALS| argument, ie.
LOCALS| a b c |
is the same as
LVALUE a LVALUE b LVALUE c
.
This should also clarify the runtime stack behaviour of
LOCALS| where the stack parameters seem to be
assigned in reverse order as opposed to their textual
identifier declarations. <br>
compare with VALUE and the pfe's convenience word
VAR.
: LVALUE
STATE @ IF
VALUE
ELSE
BL WORD COUNT DUP (LOCAL) (TO)
THEN
; IMMEDIATE
Name
paren-m-str-colon:dstrings.1 — compiling primitive
Synopsis
FORTH
(M$:)
( .. )(
)
;
as:"paren-m-str-colon";
Description
compiling primitive (M$:)
an executable word (no special usage info)
or wrapper call around p4_marg_execution
Name
m-star:core — ordinary primitive
Synopsis
FORTH
M*
( a b -- m,m )(
)
;
p4:"m-star";
Description
multiply and return a double-cell result
Name
m-star-slash:double — ordinary primitive
Synopsis
FORTH
M*/
( d1.d1 n1 +n2 -- d2.d2 )( | ) ; | |
Description
the double-cell multiply-divide operation
using a triple-cell intermediate result for '*'
( *\/ )
Name
m-plus:double — ordinary primitive
Synopsis
FORTH
M+
( d1.d1 n1 -- d2.d2 )(
)
;
p4:"m-plus";
Description
the double-cell mixed-operand sum operation ( + / D+ )
Name
make:useful — compiling primitive
Synopsis
EXTENSIONS
MAKE
( [word] -- )... ;AND(
)
;
p4:"make";
Description
make a seperated piece of code between MAKE and ;AND
and on execution of the MAKE the named word is twisted
to point to this piece of code. The word is usually
a DOER but the current implementation works
on DEFER just as well, just as it does on other words who
expect to find an execution-token in its PFA. You could even
create a colon-word that starts with NOOP and can then make
that colon-word be prefixed with the execution of the code piece.
This MAKE
does even work on LOCALS| and VAR but it is uncertain
what that is good for.
Name
make-str-space:dstrings — ordinary primitive
Synopsis
FORTH
MAKE-$SPACE
( size #frames -- addr )( | ) ; | |
Description
Allocate and initialize a string space with size bytes
available for the string buffer including the string stack,
and with a string frame stack for frame description entries
holding up to #frames. The size is rounded up to cell
alignment, and the buffer begins and ends with cell alignment.
Return addr, the address of the string space. The standard
word FREE with addr as input can be used to release the space.
<ansref>"make-string-space"</ansref>
Name
backward-mark:system — ordinary primitive
Synopsis
FORTH
<MARK
( -- DP-mark )compile-only( | ) ; | |
Description
memorizes the current DP on the CS-STACK
used for <RESOLVE later. Useful for creation of
compiling words, eg. BEGIN , see AHEAD
simulate:
: <MARK ?COMP HERE ;
Name
forward-mark:system — ordinary primitive
Synopsis
FORTH
MARK>
( -- DP-mark )compile-only( | ) ; | |
Description
makes room for a pointer in the dictionary to
be resolved through RESOLVE> and does therefore
memorize that cell's address on the CS-STACK
Mostly used after BRANCH or ?BRANCH in compiling
words like IF or ELSE
simulate:
: MARK> ?COMP HERE 0 , ;
Name
marker:core — ordinary primitive
Synopsis
FORTH
MARKER
( 'name' -- )(
)
;
p4:"marker";
Description
create a named marker that you can use to FORGET ,
running the created word will reset the dict/order variables
to the state at the creation of this name.
: MARKER PARSE-WORD (MARKER) ;
see also ANEW which is not defined in ans-forth but which uses
the MARKER functionality in the way it should have been defined.
Name
paren-marker:core — ordinary primitive
Synopsis
EXTENSIONS
(MARKER)
( str-ptr str-len -- )( | ) ; | |
Description
create a named marker that you can use to FORGET ,
running the created word will reset the dict/order variables
to the state at the creation of this name.
: (MARKER) (CREATE) HERE ,
GET-ORDER DUP , 0 DO ?DUP IF , THEN LOOP 0 ,
...
DOES> DUP @ (FORGET)
...
;
Name
max:core — ordinary primitive
Synopsis
FORTH
MAX
( a b -- c )(
)
;
p4:"max";
Description
return the maximum of a and b
Name
max-minus-char:core::environment — ordinary constant
Synopsis
ENVIRONMENT
MAX-CHAR
( .. )(
)
;
as:"max-minus-char";
Description
( UCHAR_MAX ) constant MAX-CHAR
an ordinary constant (no special usage info)
Name
max-minus-d:double::environment — ordinary primitive
Synopsis
ENVIRONMENT
MAX-D
( .. )(
)
;
as:"max-minus-d";
Description
ordinary primitive MAX-D
an executable word (no special usage info)
or wrapper call around p__max_d
Name
max-minus-files:file::environment — ordinary primitive
Synopsis
ENVIRONMENT
MAX-FILES
( .. )(
)
;
as:"max-minus-files";
Description
ordinary primitive MAX-FILES
an executable word (no special usage info)
or wrapper call around p__max_files
Name
max-minus-float:floating::environment — ordinary primitive
Synopsis
ENVIRONMENT
MAX-FLOAT
( .. )(
)
;
as:"max-minus-float";
Description
ordinary primitive MAX-FLOAT
an executable word (no special usage info)
or wrapper call around p__max_float
Name
max-minus-float:fpnostack::environment — ordinary primitive
Synopsis
ENVIRONMENT
MAX-FLOAT
( .. )(
)
;
as:"max-minus-float";
Description
ordinary primitive MAX-FLOAT
an executable word (no special usage info)
or wrapper call around p__nofp_max_float
Name
max-minus-n:toolbelt.1 — ordinary constant
Synopsis
FORTH
MAX-N
( .. )(
)
;
as:"max-minus-n";
Description
( CELL_MAX ) constant MAX-N
an ordinary constant (no special usage info)
Name
max-minus-n:core::environment — ordinary constant
Synopsis
ENVIRONMENT
MAX-N
( .. )(
)
;
as:"max-minus-n";
Description
( CELL_MAX ) constant MAX-N
an ordinary constant (no special usage info)
Name
max-minus-u:core::environment — ordinary constant
Synopsis
ENVIRONMENT
MAX-U
( .. )(
)
;
as:"max-minus-u";
Description
( UCELL_MAX ) constant MAX-U
an ordinary constant (no special usage info)
Name
max-minus-ud:double::environment — ordinary primitive
Synopsis
ENVIRONMENT
MAX-UD
( .. )(
)
;
as:"max-minus-ud";
Description
ordinary primitive MAX-UD
an executable word (no special usage info)
or wrapper call around p__max_ud
Name
dot-memory:misc — ordinary primitive
Synopsis
FORTH
.MEMORY
( -- )(
)
;
p4:"dot-memory";
Name
memory-minus-alloc-minus-ext:memory::environment — ordinary constant
Synopsis
ENVIRONMENT
MEMORY-ALLOC-EXT
( .. )( | ) ; | |
Description
( 1994 ) constant MEMORY-ALLOC-EXT
an ordinary constant (no special usage info)
Name
memory-check:forth_usual — ordinary primitive
Synopsis
FORTH
MEMORY-CHECK
( n -- )(
)
;
p4:"memory-check";
Description
Check for memory allocation error.
\ : MEMORY-CHECK ( n -- ) THROW ;
: MEMORY-CHECK ( n -- ) ABORT" Memory Allocation Error " ;
Name
memory-check:toolbelt — ordinary primitive
Synopsis
FORTH
MEMORY-CHECK
( n -- )(
)
;
p4:"memory-check";
Description
Check for memory allocation error.
\ : MEMORY-CHECK ( n -- ) THROW ;
: MEMORY-CHECK ( n -- ) ABORT" Memory Allocation Error " ;
Name
min:core — ordinary primitive
Synopsis
FORTH
MIN
( a b -- c )(
)
;
p4:"min";
Description
return the minimum of a and b
Name
mkdir:shell.1 — compiling primitive
Synopsis
EXTENSIONS
MKDIR
( .. )(
)
;
as:"mkdir";
Description
compiling primitive MKDIR
an executable word (no special usage info)
or wrapper call around p4_md
Name
mod:core — ordinary primitive
Synopsis
FORTH
MOD
( a b -- c )(
)
;
p4:"mod";
Description
return the module of "a mod b"
Name
star-slash-mod:core — ordinary primitive
Synopsis
FORTH
*/MOD
( a b c -- m n )( | ) ; | |
Description
has an adavantage over the sequence of *
and /MOD by using an intermediate double-cell
value.
Name
slash-mod:core — ordinary primitive
Synopsis
FORTH
/MOD
( a b -- m n )(
)
;
p4:"slash-mod";
Description
divide a and b and return both
quotient n and remainder m
Name
module:module — ordinary primitive
Synopsis
EXTENSIONS
MODULE
( "name" -- old-current )( | ) ; | |
Description
create a new WORDLIST with the given name. It
will also have an implicit hidden vocabulary just as
well and all DEFINITIONS will go into that
hidden wordlist. Therefore the old CURRENT is
memorized on the cs-stack.
effectivly, CONTEXT[1] will have the wordlist-id
of the public wordlist "name" and CONTEXT[0] will
have the hidden wordlist contained in "name" - the
hidden wordlist will always be known as HIDDEN' so
that it can be re-referenced without need to use
ALSO just to access a single definition from
just another vocabulary. Note that HIDDEN' is
defined immediate (a VOCABULARY' ) to modify
the ORDER inside a colon definition.
: MODULE
CURRENT @ ( -- old-current )
VOCABULARY
ALSO LATEST NAME> EXECUTE ALSO DEFINITIONS
C" HIDDEN'" $CREATE WORDLIST CONTEXT !
;
Name
move:core — ordinary primitive
Synopsis
FORTH
MOVE
( from to length -- )(
)
;
p4:"move";
Description
memcpy an area
Name
move-file:file_misc — ordinary primitive
Synopsis
FORTH
MOVE-FILE
( src-str src-strlen dst-str dst-strlen -- errno|0 )( | ) ; | |
Description
like RENAME-FILE, but also across-volumes <br>
moves the file from src-name to dst-name and returns an
error-code or null
Name
byte-swap-move:forth_83 — ordinary primitive
Synopsis
FORTH
>MOVE<
( from-addr to-addr count -- )( | ) ; | |
Description
see MOVE , does byte-swap for each word underway
Name
ms:facility — ordinary primitive
Description
wait at least the specified milliseconds
(suspend the forth tasklet)
Name
mv:shell.1 — compiling primitive
Description
compiling primitive MV
an executable word (no special usage info)
or wrapper call around p4_mv
Name
newline-str:dstrings — ordinary primitive
Synopsis
FORTH
\n$
( $: -- newline$ )(
)
;
p4:"newline-str";
Description
Push the MSA of a fixed, external string whose body is the
Unix newline character onto the string stack.
<ansref>"newline-string"</ansref>
Name
n-to-link:header — ordinary primitive
Synopsis
FORTH
N>LINK
( nfa -- lfa )(
)
;
p4:"n-to-link";
Description
converts a pointer to the name-field (NFA) to point
then to the corresponding link-field (LFA) - this operation
is quicker than the inverse L>NAME. This word is a specific
implementation detail and should not be used by normal users - instead
use always NAME> which is much more portable. Many systems may
possibly not even have a >LINK-field in the sense that a @ on
this adress will lead to another >NAME. Any operation on the
resulting >LINK-adress is even dependent on the current configuration
of PFE - only in fig-mode you are asserted to have the classic detail.
(and fig-mode did not know about SYNONYMs - see note at LINK>).
implementation-specific configure-dependent fig-only simulation:
: N>LINK C@ + ;
Name
dot-name:misc.1 — forthword synonym
Synopsis
FORTH
.NAME
( .. )(
)
;
as:"dot-name";
Description
forthword synonym .NAME
is doing the same as ID.
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
to-name:header — ordinary primitive
Synopsis
FORTH
>NAME
( cfa -- nfa )(
)
;
p4:"to-name";
Description
converts a pointer to the code-field (CFA) to point
then to the corresponding name-field (NFA)
implementation-specific simulation:
: >NAME >LINK L>NAME ;
Name
name-flags-store:header — ordinary primitive
Synopsis
EXTENSIONS
NAME-FLAGS!
( nfa-flags nfa -- )( | ) ; | |
Description
set the nfa-flags of nfa given. Note that in the fig-style the nfa-flags
would include the nfa-count in the lower bits - therefore this should only
set bits that had been previously retrieved with NAME-FLAGS@
: IMMEDIATE LAST @ NAME-FLAGS@ IMMEDIATE-MASK OR LAST @ NAME-FLAGS! ;
Name
name-flags-fetch:header — ordinary primitive
Synopsis
EXTENSIONS
NAME-FLAGS@
( nfa -- nfa-flags )( | ) ; | |
Description
get the nfa-flags that corresponds to the nfa given. Note that
in the fig-style would include the nfa-count in the lower bits.
(see NAME-FLAGS!)
Name
name-from:header — ordinary primitive
Synopsis
FORTH
NAME>
( nfa -- cfa )(
)
;
p4:"name-from";
Description
converts a pointer to the name-field (NFA) to point
then to the corresponding code-field (CFA)
(in all cases but a SYNONYM the pfe will behave not unlike the
original fig-forth did - being identical to N>LINK LINK> )
Name
name-to-string:header — ordinary primitive
Synopsis
FORTH
NAME>STRING
( name-token -- str-ptr str-len )( | ) ; | |
Description
convert a name-token into a string-span, used to detect the
name for a word and print it. The word ID. can be defined as
: ID. NAME>STRING TYPE ;
the implementation of NAME>STRING depends on the header layout
that is defined during the configuration of the forth system.
: NAME>STRING COUNT 31 AND ; ( for fig-like names )
: NAME>STRING COUNT ; ( default, name is a simple counted string )
: NAME>STRING @ ZCOUNT ; ( name-token is a pointer to a C-level string )
: NAME>STRING COUNT 31 AND ( hybrid of fig-like and zero-terminated )
DUP 31 = IF DROP 1+ ZCOUNT THEN
;
: NAME>STRING HEAD:: COUNT CODE:: PAD PLACE PAD ; ( different i86 segments )
Name
needs-environment:environ — ordinary primitive
Synopsis
FORTH
NEEDS
( name -- )(
)
;
p4:"needs-environment";
Description
A self-parsing variant of an environment-query check. It is similar
to a simulation like
: NEEDS PARSE-WORD 2DUP ENVIRONMENT?
IF DROP ( extra value ) 2DROP ( success - be silent )
ELSE TYPE ." not available " CR THEN ;
however that would only match those worset-envqueries which return a
single extra item under the uppermost TRUE flag in the success case.
Instead it works more like
: NEEDS PARSE-WORD 2DUP ENVIRONMENT-WORDLIST SEARCH-WORDLIST
IF 2DROP ( success - be silent and just drop the parsed word )
ELSE TYPE ." not available " CR THEN ;
however we add the same extension as in ENVIRONMENT? as that
it can automatically load a wordset module to fullfil a query
that looks like "[wordsetname]-ext". Therefore, the following
two lines are pretty much identical:
LOADM floating
NEEDS floating-ext
the difference between the two: if somebody did provide a forth
level implementation of floating-ext then that implementation might
have registered a hint "floating-ext" in the environment-wordlist.
This extra-hint will inhibit loading of the binary module even if
it exists and not been loaded so far. The LOADM however will
not check the ENVIRONMENT-WORDLIST and only check its loadlist
of binary wordset modules in the system.
It is therefore recommended to use NEEDS instead of LOADM
unless you know you want the binary module, quickly and uncondtionally.
Name
negate:core — ordinary primitive
Synopsis
FORTH
NEGATE
( value -- value' )(
)
;
p4:"negate";
Description
return the arithmetic negative of the (signed) cell
simulate: : NEGATE -1 * ;
Name
new-chain:chain — definining primitive
Synopsis
EXTENSIONS
new-chain
( "name" -- )(
)
;
p4:"new-chain";
Description
create a new chain and register in chain-link
: new-chain create: 0 , ['] noop , chain-link link, ;
layout of a chain:
/cell field ->chain.link
/cell field ->chain.exec
/cell field ->chain.next
Name
new-minus-sys-minus-chain:chain.1 — forthword synonym
Description
forthword synonym new-sys-chain
is doing the same as new-chain
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
new-wordlist:chainlist — ordinary primitive
Synopsis
EXTENSIONS
NEW-WORDLIST
( "name" -- )( | ) ; | |
Description
create a new WORDLIST and a "name" with a runtime of ( -- wordlist* )
: NEW-WORDLIST WORDLIST VALUE ;
: NEW-WORDLIST CREATE: WORDLIST ;
usually used for DO-ALL-WORDS / DO-SYNONYM
Name
next-minus-exception:exception.1 — threadstate variable
Description
threadstate variable NEXT-EXCEPTION
next_exception (no special usage info)
Name
next-word:toolbelt — ordinary primitive
Synopsis
FORTH
NEXT-WORD
( -- str len )(
)
;
p4:"next-word";
Description
Get the next word across line breaks as a character
string. _len_ will be 0 at end of file.
: NEXT-WORD
BEGIN BL WORD COUNT ( str len )
DUP IF EXIT THEN
REFILL
WHILE 2DROP ( ) REPEAT ;
Name
nip:core — ordinary primitive
Synopsis
FORTH
NIP
( a b -- b )(
)
;
p4:"nip";
Description
drop the value under the top of stack, inverse of TUCK
simulate: : NIP SWAP DROP ;
Name
str-nip:dstrings — ordinary primitive
Synopsis
FORTH
$NIP
($: a$ b$ -- b$ )(
)
;
p4:"str-nip";
Description
Drop the next to top item from the string stack.
<ansref>"string-nip"</ansref>
NOTE: Because of essential string space bookkeeping, the
system level implementation can be little more efficient than
the high-level definition:
: $NIP $SWAP $DROP ;
Name
two-nip:toolbelt — ordinary primitive
Synopsis
FORTH
2NIP
( w x y z -- y z )(
)
;
p4:"two-nip";
Description
Drop the third and fourth elements from the stack.
: 2NIP 2SWAP 2DROP ;
Name
store-no:useful.1 — forthword synonym
Synopsis
EXTENSIONS
!NO
( .. )(
)
;
as:"store-no";
Description
forthword synonym !NO
is doing the same as FALSE
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
no-debug:debug — ordinary primitive
Synopsis
FORTH
NO-DEBUG
( 'word' -- )(
)
;
p4:"no-debug";
Description
the inverse of " DEBUG word "
Name
colon-noname:core — definining primitive
Synopsis
FORTH
:NONAME
( -- cs.value )( | ) ; | |
Description
start a colon nested-word but do not use CREATE - so no name
is given to the colon-definition that follows. When the definition
is finished at the corresponding ; the start-address (ie.
the execution token) can be found on the outer cs.stack that may
be stored used elsewhere then.
Name
noop:forth_usual.1 — ordinary primitive
Description
ordinary primitive NOOP
an executable word (no special usage info)
or wrapper call around p4_noop
Name
dot-normal:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.NORMAL
( .. )(
)
;
as:"dot-normal";
Description
ordinary primitive .NORMAL
an executable word (no special usage info)
or wrapper call around p4_dot_normal
Name
not:forth_83.1 — compiling primitive
Description
compiling primitive NOT
an executable word (no special usage info)
or wrapper call around p4_not
Name
not:toolbelt.1 — ordinary primitive
Description
ordinary primitive NOT
an executable word (no special usage info)
or wrapper call around p4_zero_equal
Name
bracket-not:useful — immediate primitive
Synopsis
EXTENSIONS
[NOT]
( a -- a' )(
)
;
p4:"bracket-not";
Description
executes 0= but this word is immediate so that it does
affect the cs-stack while compiling rather than compiling
anything. This is useful just before words like [IF] to
provide semantics of an
[IFNOT]
. It is most useful in
conjunction with "[DEFINED] word" as it the sequence
"
[DEFINED] word [NOT] [IF]
" can simulate "
[IFNOTDEF] word
"
Name
ntohl:posix — ordinary primitive
Synopsis
EXTENSIONS
NTOHL
( l -- l' )(
)
;
p4:"ntohl";
Description
if current host-encoding is bigendian, this is a NOOP
otherwise byteswap the lower 32-bit bits of the topofstack.
see L@ and L! (being usually just @ and ! )
(on some platforms, the upper bits are erased, on others not)
Name
ntohs:posix — ordinary primitive
Synopsis
EXTENSIONS
NTOHS
( w -- w' )(
)
;
p4:"ntohs";
Description
if current host-encoding is bigendian, this is a NOOP
otherwise byteswap the lower 16-bit bits of the topofstack.
see W@ and W!
(on some platforms, the upper bits are erased, on others not)
Name
to-number:core — ordinary primitive
Synopsis
FORTH
>NUMBER
( a,a str-adr str-len -- a,a' str-adr' str-len)( | ) ; | |
Description
try to convert a string into a number, and place
that number at a,a respeciting BASE
Name
number-question:forth_usual — ordinary primitive
Synopsis
FORTH
NUMBER?
( addr -- d flag )( | ) ; | |
Description
convert counted string to number - used in inner interpreter
( INTERPRET ), flags if conversion was successful
example:
BL WORD HERE NUMBER? 0= IF ." not a number " THEN .
Name
octal:forth_83 — ordinary primitive
Synopsis
FORTH
OCTAL
( -- )(
)
;
p4:"octal";
Description
sets BASE to 8. Compare with HEX and DECIMAL
simulate:
: OCTAL 8 BASE ! ;
Name
and-of:your.1 — immediate synonym
Synopsis
EXTENSIONS
&OF
( .. )(
)
;
as:"and-of";
Description
immediate synonym &OF
is doing the same as INTO
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
of:core — compiling primitive
Synopsis
FORTH
OF
( comp-value case-value -- comp-value ).. ENDOF( | ) ; | |
Description
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
Name
off-store:forth_usual — forthword synonym
Synopsis
FORTH
OFF
( addr -- )(
)
;
p4:"off-store";
Description
Store 0 at _addr_. Defined in f84 as OFF. See antonym ON!.
: OFF ( addr -- ) 0 SWAP ! ;
Name
off-store:toolbelt — ordinary primitive
Synopsis
FORTH
OFF
( addr -- )(
)
;
p4:"off-store";
Description
Store 0 at _addr_. Defined in f84 as OFF. See antonym ON!.
: OFF ( addr -- ) 0 SWAP ! ;
Name
off-store:forth_usual.1 — ordinary primitive
Synopsis
FORTH
OFF!
( .. )(
)
;
as:"off-store";
Description
ordinary primitive OFF!
an executable word (no special usage info)
or wrapper call around p4_off_store
Name
offset-colon:useful.1 — forthword synonym
Synopsis
EXTENSIONS
OFFSET:
( .. )(
)
;
as:"offset-colon";
Description
forthword synonym OFFSET:
is doing the same as +CONSTANT
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
of-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
OF_MAGIC
( .. )(
)
;
as:"of-magic";
Description
( P4_OF_MAGIC ) constant OF_MAGIC
an ordinary constant (no special usage info)
Name
ok:misc.1 — ordinary primitive
Description
ordinary primitive ok
an executable word (no special usage info)
or wrapper call around p4_ok
Name
on:forth_usual.1 — forthword synonym
Description
forthword synonym ON
is doing the same as ON!
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
on:toolbelt.1 — ordinary primitive
Description
ordinary primitive ON
an executable word (no special usage info)
or wrapper call around p4_on_store
Name
on-store:forth_usual — ordinary primitive
Synopsis
FORTH
ON!
( addr -- )(
)
;
p4:"on-store";
Description
Store -1 at _addr_. Defined in f83 as ON. See antonym OFF!.
: ON! ( addr -- ) -1 SWAP ! ;
Name
open-blockfile:block_misc — ordinary primitive
Synopsis
FORTH
OPEN-BLOCKFILE
( "filename" -- )w32for( | ) ; | |
Description
w32for-implementation:
close-blockfile
parse-word r/w open-file abort" failed to open block-file"
set-blockfile
empty-buffers
Name
gforth-open-dir:gforth — ordinary primitive
Synopsis
gforth'
open-dir
( c_addr u -- wdirid wior )gforth open_dir( | ) ; | |
Description
will vanish without warning. see gforth documentation.
Name
open-file:file — ordinary primitive
Synopsis
FORTH
OPEN-FILE
( str-adr str-len mode -- file code )( | ) ; | |
Description
open the named file with mode. returns the
file id and a status code. A code of zero
means success.
Name
open-terminal-logfile:host_k12 — ordinary primitive
Synopsis
EXTENSIONS
OPEN-TERMINAL-LOGFILE
( s-buf s-len -- )( | ) ; | |
Description
open terminal logfile named by the string-buffer
all further output to the terminal window is also logged into
this file. This is especially useful in embedded environments
where the terminal connection is often not used or it is
directed to a different location that does not easily allow to
redirect the forth output to a file for further examination.
Name
option-minus-ext:option::environment — ordinary constant
Synopsis
ENVIRONMENT
OPTION-EXT
( .. )(
)
;
as:"option-minus-ext";
Description
( 2001 ) constant OPTION-EXT
an ordinary constant (no special usage info)
Name
or:core — ordinary primitive
Synopsis
FORTH
OR
( a b -- ab )(
)
;
p4:"or";
Description
return the bitwise OR of a and b - unlike AND this
is usually safe to use on logical values
Name
order:search — ordinary primitive
Synopsis
FORTH
ORDER
( -- )(
)
;
p4:"order";
Description
show the current search-order, followed by
the CURRENT DEFINITIONS vocabulary
and the ONLY base vocabulary
Name
orif:toolbelt — compiling primitive
Synopsis
FORTH
ORIF
( p ... -- flag )(
)
;
p4:"orif";
Description
Given `p ORIF q THEN`, _q_ will not be performed if
_p_ is true.
: ORIF S" DUP 0= IF DROP " EVALUATE ; IMMEDIATE
Name
orig-magic:tools_misc.1 — ordinary constant
Synopsis
EXTENSIONS
ORIG_MAGIC
( .. )(
)
;
as:"orig-magic";
Description
( P4_ORIG_MAGIC ) constant ORIG_MAGIC
an ordinary constant (no special usage info)
Name
out:misc.1 — threadstate variable
Description
threadstate variable OUT
out (no special usage info)
Name
out:toolbelt.1 — threadstate variable
Description
threadstate variable OUT
out (no special usage info)
Name
over:core — ordinary primitive
Synopsis
FORTH
OVER
( a b -- a b a )(
)
;
p4:"over";
Description
get the value from under the top of stack. The inverse
operation would be TUCK
Name
two-over:core — ordinary primitive
Synopsis
FORTH
2OVER
( a,a b,b -- a,a b,b a,a )( | ) ; | |
Description
double-cell over, see OVER and 2DUP
simulate:
: 2OVER SP@ 2 CELLS + 2@ ;
Name
str-over:dstrings — ordinary primitive
Synopsis
FORTH
$OVER
( $: a$ b$ -- a$ b$ a$ )( | ) ; | |
Description
Leave a copy of the next most accessible string stack entry
on top of the string stack. The string value is not copied.
<ansref>"string-over"</ansref>
Name
slash-pad:core::environment — ordinary constant
Synopsis
ENVIRONMENT
/PAD
( .. )(
)
;
as:"slash-pad";
Description
( MIN_PAD ) constant /PAD
an ordinary constant (no special usage info)
Name
pad:core — ordinary primitive
Synopsis
FORTH
PAD
( -- addr )(
)
;
p4:"pad";
Description
transient buffer region
Name
page:facility.1 — ordinary primitive
Description
ordinary primitive PAGE
an executable word (no special usage info)
or wrapper call around p4_dot_clrscr
Name
Q-pairs:tools_misc — ordinary primitive
Synopsis
FORTH
?PAIRS
( a b -- )(
)
;
p4:"Q-pairs";
Description
if compiling, check that the two magics on
the CS-STACK are identical, otherwise throw
<br> used in control-words
Name
parse:core — ordinary primitive
Synopsis
FORTH
PARSE
( delim-char -- buffer-start buffer-count )( | ) ; | |
Description
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.
Name
parse-comma:core_misc — ordinary primitive
Synopsis
FORTH
PARSE,
( "chars<">" -- )( | ) ; | |
Description
Store a char-delimited string in data space as a counted
string. As seen in Bawd's
: ," [CHAR] " PARSE STRING, ; IMMEDIATE
this implementation is much different from Bawd's
: PARSE, PARSE STRING, ;
Name
parse-comma-quote:core_misc — immediate primitive
Synopsis
FORTH
PARSE,"
( "chars<">" -- )( | ) ; | |
Description
Store a quote-delimited string in data space as a counted
string.
: ," [CHAR] " PARSE STRING, ; IMMEDIATE
implemented here as
: PARSE," [CHAR] " PARSE, ; IMMEDIATE
Name
parse-word:core — ordinary primitive
Synopsis
FORTH
PARSE-WORD
( "chars" -- c-addr u )( | ) ; | |
Description
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.
Name
perform:forth_usual.1 — obsolete forthword
Synopsis
EXTENSIONS
PERFORM
( .. )(
)
;
as:"perform";
Description
obsolete forthword PERFORM
is doing the same as @EXECUTE
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
dot-pfe-minus-date:core_misc.1 — forthword synonym
Synopsis
FORTH
.PFE-DATE
( .. )(
)
;
as:"dot-pfe-minus-date";
Description
forthword synonym .PFE-DATE
is doing the same as .CVERSION
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
pfe-minus-debug:debug::environment — threadstate valueGET
Synopsis
ENVIRONMENT
PFE-DEBUG
( .. )(
)
;
as:"pfe-minus-debug";
Description
threadstate valueGET PFE-DEBUG
maxlevel (no special usage info)
Name
printf:useful — ordinary primitive
Synopsis
EXTENSIONS
PFE-PRINTF
( args ... format$ -- )( | ) ; | |
Description
uses SPRINTF to print to a temporary 256-char buffer
and prints it to stdout afterwards. See the example
at SPRINTF of what it does internally.
Name
sprintf:useful — ordinary primitive
Synopsis
EXTENSIONS
PFE-SPRINTF
( args ... format$ dest$ -- len-dest )( | ) ; | |
Description
just like the standard sprintf() function in C, but
the format is a counted string and accepts %#s to
be the format-symbol for a forth-counted string.
The result is a zeroterminated string at dest$ having
a length being returned. To create a forth-counted
string, you could use:
variable A 256 ALLOT
15 " example" " the %#s value is %i" A 1+ SPRINTF A C!
A COUNT TYPE
Name
pick:core — ordinary primitive
Synopsis
FORTH
PICK
( n -- value )(
)
;
p4:"pick";
Description
pick the nth value from under the top of stack and push it
note that
0 PICK -> DUP 1 PICK -> OVER
Name
str-pick:dstrings — ordinary primitive
Synopsis
FORTH
$PICK
( u $: au$ ... a0$ -- au$ ... a0$ au$ )( | ) ; | |
Description
Copy the u-th string stack entry to the top of the string
stack. The string value is not copied. Throw an error if
the input string stack does not have at least u+1 items.
<ansref>"string-pick"</ansref>
Name
getpid:shell — ordinary primitive
Synopsis
EXTENSIONS
$PID
( -- pid )(
)
;
p4:"getpid";
Description
calls system's
getpid
Name
plus-place:forth_usual.1 — ordinary primitive
Synopsis
FORTH
+PLACE
( .. )(
)
;
as:"plus-place";
Description
ordinary primitive +PLACE
an executable word (no special usage info)
or wrapper call around p4_append
Name
place:forth_usual — ordinary primitive
Synopsis
FORTH
PLACE
( str len addr -- )(
)
;
p4:"place";
Description
Place the string _str len_ at _addr_, formatting it as a
counted string.
: PLACE 2DUP 2>R 1+ SWAP MOVE 2R> C! ;
: PLACE 2DUP C! 1+ SWAP CMOVE ;
Name
place:toolbelt — ordinary primitive
Synopsis
FORTH
PLACE
( str len addr -- )(
)
;
p4:"place";
Description
Place the string _str len_ at _addr_, formatting it as a
counted string.
: PLACE 2DUP 2>R 1+ SWAP MOVE 2R> C! ;
: PLACE 2DUP C! 1+ SWAP CMOVE ;
Name
pocket-pad:misc — ordinary primitive
Synopsis
FORTH
POCKET-PAD
( -- addr )(
)
;
p4:"pocket-pad";
Description
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 >r
r place " .tmp" count r append
r> count make-file
;
Name
pointer-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
POINTER:
( .. )(
)
;
as:"pointer-colon";
Description
ordinary primitive POINTER:
an executable word (no special usage info)
or wrapper call around p4_cell_colon
Name
bracket-possibly:useful — immediate primitive
Synopsis
EXTENSIONS
[POSSIBLY]
( [name] -- ?? )( | ) ; | |
Description
check if the name exists, and execute it immediatly
if found. Derived from POSSIBLY as seen in other forth systems.
: [POSSIBLY] (') ?DUP IF EXECUTE THEN ; IMMEDIATE
Name
postpone:core — compiling primitive
Synopsis
FORTH
POSTPONE
( [word] -- )(
)
;
p4:"postpone";
Description
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)
Name
sharp-pragma:cdecl.1 — ordinary primitive
Synopsis
FORTH
#PRAGMA
( .. )(
)
;
as:"sharp-pragma";
Description
ordinary primitive #PRAGMA
an executable word (no special usage info)
or wrapper call around p4_sh_pragma
Name
precision:floating.1 — - loader type P4_DVaL
Synopsis
FORTH
PRECISION
( .. )(
)
;
as:"precision";
Description
- loader type P4_DVaL PRECISION
precision (no special usage info)
Name
precision:fpnostack.1 — - loader type P4_DVaL
Synopsis
EXTENSIONS
PRECISION
( .. )(
)
;
as:"precision";
Description
- loader type P4_DVaL PRECISION
precision (no special usage info)
Name
previous:search — ordinary primitive
Synopsis
FORTH
PREVIOUS
( -- )(
)
;
p4:"previous";
Description
the invers of ALSO , does a DROP on the search ORDER
of vocabularies.
order: vocn ... voc2 voc1 -- vocn ... voc2
example: ALSO PRIVATE-VOC DEFINTIONS (...do some...) PREVIOUS DEFINITIONS
Name
printf:useful.1 — obsolete forthword
Synopsis
EXTENSIONS
PRINTF
( .. )(
)
;
as:"printf";
Description
obsolete forthword PRINTF
is doing the same as PFE-PRINTF
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
prompt-minus-wordlist:chainlist.1 — - loader type P4_DVaL
Synopsis
EXTENSIONS
PROMPT-WORDLIST
( .. )( | ) ; | |
Description
- loader type P4_DVaL PROMPT-WORDLIST
prompt_wl (no special usage info)
Name
pwd:shell — ordinary primitive
Description
calls system's
getcwd
and prints it to the screen
: PWD $CWD TYPE ;
Name
query:core — ordinary primitive
Synopsis
FORTH
QUERY
( -- )(
)
;
p4:"query";
Description
source input: read from terminal using _accept_ with the
returned string to show up in TIB of /TIB size.
Name
quit:core — ordinary primitive
Synopsis
FORTH
QUIT
( -- )no-return(
)
;
p4:"quit";
Description
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 ;
Name
quoted-minus-parse-question:misc.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL QUOTED-PARSE?
quoted_parse (no special usage info)
Name
dot-r:core — ordinary primitive
Synopsis
FORTH
.R
( val prec -- )(
)
;
p4:"dot-r";
Description
print with precision - that is to fill
a field of the give prec-with with
right-aligned number from the converted value
Name
two-to-r:core — compiling primitive
Synopsis
FORTH
2>R
( a,a -- R: a,a )(
)
;
p4:"two-to-r";
Description
save a double-cell value onto the return-stack, see >R
Name
to-r:core — compiling primitive
Synopsis
FORTH
>R
( value -- )(
)
;
p4:"to-r";
Description
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
Name
r-store:misc — compiling primitive
Synopsis
FORTH
R!
( x R: a -- R: x )(
)
;
p4:"r-store";
Description
store the value as the topmost value in the returnstack.
see R@ for inverse operation ( R'@ / R"@ / 2R@ / 2R! )
Name
two-r-store:misc — compiling primitive
Synopsis
FORTH
2R!
( x y R: a b -- R: x y )( | ) ; | |
Description
store the value as the topmost value in the returnstack.
see R@ for inverse operation ( R'@ / R"@ / 2R@ / 2R! )
Name
r-quote-store:misc — compiling primitive
Synopsis
FORTH
R"!
( x R: a b c -- R: x b c )( | ) ; | |
Description
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
Name
r-quote-fetch:misc — compiling primitive
Synopsis
FORTH
R"@
( R: a b c -- a R: a b c )( | ) ; | |
Description
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 )
Name
r-tick-store:misc — compiling primitive
Synopsis
FORTH
R'!
( x R: a b -- R: x b )( | ) ; | |
Description
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
Name
r-tick-fetch:misc — compiling primitive
Synopsis
FORTH
R'@
( R: a b -- a R: a b )( | ) ; | |
Description
fetch the next-under value from the returnstack.
used to interpret the returnstack to hold two LOCALS| values.
( R@ / 2R@ / R>DROP / R"@ )
Name
r-tick-fetch:toolbelt — ordinary primitive
Synopsis
FORTH
R'@
( R: a b -- a R: a b )( | ) ; | |
Description
fetch the next-under value from the returnstack.
used to interpret the returnstack to hold two LOCALS| values.
( R@ / 2R@ / R>DROP / R"@ )
Name
r-slash-o:file.1 — ordinary constant
Synopsis
FORTH
R/O
( .. )(
)
;
as:"r-slash-o";
Description
( FMODE_RO ) constant R/O
an ordinary constant (no special usage info)
Name
r-slash-w:file.1 — ordinary constant
Synopsis
FORTH
R/W
( .. )(
)
;
as:"r-slash-w";
Description
( FMODE_RW ) constant R/W
an ordinary constant (no special usage info)
Name
r-zero:misc.1 — threadstate variable
Description
threadstate variable R0
r0 (no special usage info)
Name
r-from:core — compiling primitive
Synopsis
FORTH
R>
( R: a -- a R: )(
)
;
p4:"r-from";
Description
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.
Name
two-r-from:core — compiling primitive
Synopsis
FORTH
2R>
( R: a,a -- a,a R: )(
)
;
p4:"two-r-from";
Description
pop back a double-cell value from the return-stack, see R>
and the earlier used 2>R
Name
two-r-from-drop:misc — compiling primitive
Synopsis
FORTH
2R>2DROP
( -- )(
)
;
p4:"two-r-from-drop";
Description
this is two times R>DROP but a bit quicker.
it is however really quick compared to the sequence 2R> and 2DROP
Name
r-from-drop:misc — compiling primitive
Synopsis
FORTH
R>DROP
( -- )(
)
;
p4:"r-from-drop";
Description
shortcut (e.g. in CSI-Forth)
<br> 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>DROP R> DROP ; ( is bad - correct might be ) : R>DROP R> R> DROP >R ;
Name
r-fetch:core — compiling primitive
Synopsis
FORTH
R@
( R: a -- a R: a )(
)
;
p4:"r-fetch";
Description
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!
Name
two-r-fetch:core — compiling primitive
Synopsis
FORTH
2R@
( R: a,a -- a,a R: a,a )( | ) ; | |
Description
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"@
Name
raise:misc — ordinary primitive
Synopsis
FORTH
RAISE
( n -- )(
)
;
p4:"raise";
Description
send a SIGNAL to self
Name
random:misc — ordinary primitive
Synopsis
FORTH
RANDOM
( n1 -- n2 )(
)
;
p4:"random";
Description
returns random number with 0 <= n2 < n1)
: RANDOM ?DUP IF _random SWAP MOD ELSE _random THEN ;
Name
rand-max:misc::environment — ordinary constant
Synopsis
ENVIRONMENT
RAND_MAX
( .. )(
)
;
as:"rand-max";
Description
( RAND_MAX ) constant RAND_MAX
an ordinary constant (no special usage info)
Name
gforth-read-dir:gforth — ordinary primitive
Synopsis
gforth'
read-dir
( c_addr u1 wdirid -- u2 flag wior )gforth read_dir( | ) ; | |
Description
will vanish without warning. see gforth documentation.
Name
read-file:file — ordinary primitive
Synopsis
FORTH
READ-FILE
( str-adr str-len file -- count code )( | ) ; | |
Description
fill the given string buffer with characters
from the buffer. A status code of zero means
success and the returned count gives the
number of bytes actually read. If an error
occurs the number of already transferred bytes
is returned.
Name
read-line:file — ordinary primitive
Synopsis
FORTH
READ-LINE
( str-adr str-len file -- count flag code )( | ) ; | |
Description
fill the given string buffer with one line
from the file. A line termination character
(or character sequence under WIN/DOS) may
also be placed in the buffer but is not
included in the final count. In other respects
this function performs a READ-FILE
Name
recurse:core — immediate primitive
Synopsis
FORTH
RECURSE
( ? -- ? )(
)
;
p4:"recurse";
Description
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 ;
Name
recursive:header.1 — immediate primitive
Synopsis
EXTENSIONS
RECURSIVE
( .. )(
)
;
as:"recursive";
Description
immediate primitive RECURSIVE
an executable word (no special usage info)
or wrapper call around p4_reveal
Name
redefined-minus-msg:misc.1 — threadstate variable
Description
threadstate variable REDEFINED-MSG
redefined_msg (no special usage info)
Name
redefined-minus-msg-question:misc.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL REDEFINED-MSG?
redefined_msg (no special usage info)
Name
redo-all-words:chainlist — ordinary primitive
Synopsis
EXTENSIONS
REDO-ALL-WORDS
( wordlist* -- )( | ) ; | |
Description
EXECUTE each entry in the wordlist in the original order defined
: REDO-ALL-WORDS
0 FIRST-NAME
0 SWAP ( under )
BEGIN ?DUP WHILE
DUP NAME> SWAP ( under )
NAME-NEXT
REPEAT
BEGIN ?DUP WHILE
EXECUTE
REPEAT
;
to run the NEW-WORDLIST in last-run-first order, use DO-ALL-WORDS
Name
refill:core — ordinary primitive
Synopsis
FORTH
REFILL
( -- flag )(
)
;
p4:"refill";
Description
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
Name
rename-file:file — ordinary primitive
Synopsis
FORTH
RENAME-FILE
( str-adr1 str-len1 str-adr2 str-len2 -- code )( | ) ; | |
Description
rename the file named by string1 to the name of string2.
returns a status-code
Name
repeat:core — compiling primitive
Synopsis
FORTH
REPEAT
( -- )(
)
;
p4:"repeat";
Description
ends an unconditional loop, see BEGIN
Name
replace-in:useful — ordinary primitive
Synopsis
EXTENSIONS
REPLACE-IN
( to-xt from-xt n "name" -- )( | ) ; | |
Description
will handle the body of the named word as a sequence of cells (or tokens)
and replaces the n'th occurences of from-xt into to-xt. A negative value
will change all occurences. A zero value will not change any.
Name
reposition-file:file — ordinary primitive
Synopsis
FORTH
REPOSITION-FILE
( o.offset file -- code )( | ) ; | |
Description
reposition the file offset - the next FILE-POSITION
would return o.offset then. returns a status code.
Name
represent:floating.1 — ordinary primitive
Synopsis
FORTH
REPRESENT
( .. )(
)
;
as:"represent";
Description
ordinary primitive REPRESENT
an executable word (no special usage info)
or wrapper call around p4_represent
Name
represent:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
REPRESENT
( .. )(
)
;
as:"represent";
Description
ordinary primitive REPRESENT
an executable word (no special usage info)
or wrapper call around p4_nofp_represent
Name
required:environ — ordinary primitive
Synopsis
FORTH
REQUIRED
( ... str-ptr str-len -- ??? )( | ) ; | |
Description
the filename argument is loaded via INCLUDED as
an extension package to the current system. The filename
is registered in the current ENVIRONMENT so that it is
only INCLUDED once (!!) if called multiple times via
REQUIRED or REQUIRES
Name
requires:environ — ordinary primitive
Synopsis
FORTH
REQUIRES
( ... "name" -- ??? )( | ) ; | |
Name
reset-order:search — ordinary primitive
Synopsis
FORTH
RESET-ORDER
( -- )(
)
;
p4:"reset-order";
Description
load the DEFAULT-ORDER into the current search ORDER
- this is implicitly done when a trap is encountered.
Name
reset-minus-order-minus-is:search.1 — threadstate variable
Description
threadstate variable RESET-ORDER-IS
reset_order (no special usage info)
Name
resize:memory — ordinary primitive
Synopsis
FORTH
RESIZE
( ptr newsize -- ptr' code )( | ) ; | |
Description
resize the system memory chunk.
a code of zero means success.
Name
resize-file:file — ordinary primitive
Synopsis
FORTH
RESIZE-FILE
( s.size file -- code )( | ) ; | |
Description
resize the give file, returns a status code.
Name
backward-resolve:system — ordinary primitive
Synopsis
FORTH
<RESOLVE
( DP-mark -- )compile-only( | ) ; | |
Description
resolves a previous <MARK , actually pushes
the DP-address memorized at <MARK into the dictionary.
Mostly used after BRANCH or ?BRANCH in compiling
words like UNTIL
simulate:
: <RESOLVE ?COMP , ;
Name
forward-resolve:system — ordinary primitive
Synopsis
FORTH
RESOLVE>
( DP-mark -- )compile-only( | ) ; | |
Description
resolves a pointer created by MARK>
Mostly used in compiling words like THEN
simulate:
: RESOLVE> ?COMP HERE SWAP ! ;
Name
restore-input:core — ordinary primitive
Synopsis
FORTH
RESTORE-INPUT
( xn ... x1 -- )( | ) ; | |
Name
return-minus-stack-minus-cells:core::environment — ordinary primitive
Synopsis
ENVIRONMENT
RETURN-STACK-CELLS
( .. )( | ) ; | |
Description
ordinary primitive RETURN-STACK-CELLS
an executable word (no special usage info)
or wrapper call around p__return_stack_cells
Name
reveal:header — ordinary primitive
Synopsis
EXTENSIONS
REVEAL
( -- )(
)
;
p4:"reveal";
Description
the FIG definition toggles the SMUDGE bit, and not all systems have
a smudge bit - instead one should use REVEAL or HIDE
: REVEAL LAST @ FLAGS@ SMUDGE-MASK INVERT AND LAST @ FLAGS! ;
: REVEAL LAST @ CHAIN-INTO-CURRENT ;
Name
dot-reverse:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.REVERSE
( .. )(
)
;
as:"dot-reverse";
Description
ordinary primitive .REVERSE
an executable word (no special usage info)
or wrapper call around p4_dot_reverse
Name
dot-reverse-dot-off:term.1 — ordinary primitive
Description
ordinary primitive .REVERSE.OFF
an executable word (no special usage info)
or wrapper call around p4_dot_reverse_off
Name
rewind-file:toolbelt — ordinary primitive
Synopsis
FORTH
REWIND-FILE
( file-id -- ior )( | ) ; | |
Description
Rewind the file.
: REWIND-FILE ( file-id -- ior )
0 0 ROT REPOSITION-FILE ;
Name
rm:shell.1 — compiling primitive
Description
compiling primitive RM
an executable word (no special usage info)
or wrapper call around p4_remove
Name
rmdir:shell.1 — compiling primitive
Synopsis
EXTENSIONS
RMDIR
( .. )(
)
;
as:"rmdir";
Description
compiling primitive RMDIR
an executable word (no special usage info)
or wrapper call around p4_rmdir
Name
roll:core — ordinary primitive
Synopsis
FORTH
ROLL
( xn xm ... x1 n -- xm ... x1 xn )( | ) ; | |
Description
the extended form of ROT
2 ROLL -> ROT
Name
dash-roll:misc — ordinary primitive
Synopsis
FORTH
-ROLL
( xn ... x2 x1 n -- x1 xn ... x2 )( | ) ; | |
Description
the inverse of ROLL
Name
rot:core — ordinary primitive
Synopsis
FORTH
ROT
( a b c -- b c a )(
)
;
p4:"rot";
Description
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.
Name
two-rot:double_misc — ordinary primitive
Synopsis
FORTH
2ROT
( d1,d1 d2,d2 d3,d3 -- d2,d2 d3,d3 d1,d1 )( | ) ; | |
Description
the double-cell ROT operation.
actively moves six cells, i.e.
( x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2 )
Name
dash-rot:forth_usual — ordinary primitive
Synopsis
FORTH
-ROT
( a b c -- c a b )(
)
;
p4:"dash-rot";
Description
inverse of ROT
Name
rows:term.1 — threadstate variable
Description
threadstate variable ROWS
rows (no special usage info)
Name
r-p-store:forth_usual — ordinary primitive
Synopsis
FORTH
RP!
( addr -- )(
)
;
p4:"r-p-store";
Description
sets the return stack pointer, reverse of RP@
Name
r-p-fetch:forth_usual — compiling primitive
Synopsis
FORTH
RP@
( -- addr )(
)
;
p4:"r-p-fetch";
Description
returns the return stack pointer
example:
: R@ RP@ @ ;
Name
r-shift:core — ordinary primitive
Synopsis
FORTH
RSHIFT
( value shift-val -- value' )( | ) ; | |
Description
does a bitwise logical right-shift on value
(ie. the value is considered to be unsigned)
Name
sh-s:core — ordinary primitive
Synopsis
FORTH
#S
( n.n -- n.n )f(
)
;
p4:"sh-s";
Description
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 #>
Name
to-str-s:dstrings — ordinary primitive
Synopsis
FORTH
>$S
( a.str -- $: a$ )(
)
;
p4:"to-str-s";
Description
Push the external Forth string a.str onto the string stack,
without copying the string value into the string buffer. It
is an unchecked error if the Forth string a.str is not stored
as an external measured string.
<ansref>"to-string-s"</ansref>
WARNING: If the string value of a.str is actually in the
string buffer and not external, the push operation may
generate a garbage collection that invalidates its MSA.
Name
dot-s:tools — ordinary primitive
Description
print the stack content in vertical nice format.
tries to show cell-stack and float-stack side-by-side,
Depending on configuration,
there are two parameter stacks: for integers and for
floating point operations. If both stacks are empty, .S
will display the message <code><stacks empty></code>.
If only the floating point stack is empty, .S displays
the integer stack items in one column, one item per line,
both in hex and in decimal like this (the first item is topmost):
12345 HEX 67890 .S
424080 [00067890]
12345 [00003039] ok
If both stacks ar not empty, .S displays both stacks, in two
columns, one item per line
HEX 123456.78E90 ok
DECIMAL 123456.78E90 .S
291 [00000123] 1.234568E+95
1164414608 [45678E90] ok
Confusing example? Remember that floating point input only works
when the BASE number is DECIMAL. The first number looks like
a floating point but it is a goodhex double integer too - the number
base is HEX. Thus it is accepted as a hex number. Second try
with a decimal base will input the floating point number.
If only the integer stack is empty, .S shows two columns, but
he first columns is called <tt><stack empty></tt>, and the
second column is the floating point stack, topmost item first.
Name
s-quote:core — compiling primitive
Synopsis
FORTH
S"
( [string<">] -- string-address string-length)( | ) ; | |
Description
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 "
Name
s-comma:dstrings — ordinary primitive
Synopsis
FORTH
S,
( addr len -- addr' len )( | ) ; | |
Description
ALLOT room and store the Forth string into data space as an
mstring, leaving data space aligned; and leave the length and
new body address. It is assumed that len is unsigned. An
error is thrown if len is larger than the system parameter
MAX_DATA_STR. <ansref>"s-comma"</ansref>
NOTE: MAX_DATA_STR is returned by
S" /SCOPY" ENVIRONMENT?
Perhaps this restriction should be removed in favor of a
normal data space overflow error.
NOTE: S, is the same as STRING, in Wil Baden's Tool Belt,
except it stores a measured string instead of a counted
string.
Name
s-cat:dstrings — ordinary primitive
Synopsis
FORTH
S-CAT
( a.str -- )(
)
;
p4:"s-cat";
Description
Append the Forth string body to the end of the string
currently being concatenated as the last string in the string
buffer, and update its count field. If there is no
concatenating string, start one. An error is thrown if the
size of the combined string would be larger than MAX_MCOUNT
or if there is not enough room in string space even after a
garbage collection.
S-CAT is most commonly used on external strings, not assumed
to exist as mstrings. In contrast to CAT, garbage
collection could invalidate a.str if it is a dynamic string
in the string buffer. S-CAT can be used in that situation if
garbage collection is turned off with $GC-OFF.
When there is a concatenating string, concatenation is the
only basic string operation that can copy a string into the
string buffer. <ansref>"s-cat"</ansref>
Name
to-str-s-copy:dstrings — ordinary primitive
Synopsis
FORTH
>$S-COPY
( a.str -- $: a$ )( | ) ; | |
Description
Copy the external string value whose body address and count
are on the parameter stack into the string buffer and push it
onto the string stack. Errors are thrown if the count is
larger than MAX_MCOUNT, if there is not enough room in string
space, even after garbage collection, or if there is an
unterminated string concatenation. The input external string
need not exist as a measured string.
<ansref>"to-string-s-copy"</ansref>
NOTE: MAX_MCOUNT is the largest size the count field of a
measured string can hold, e.g., 255, 64K-1, or 4,096M-1. It
is returned by: S" /DYNAMIC-STRING" ENVIRONMENT?
WARNING: This word should not be used when the input string
is a bound string because the copy operation may generate a
garbage collection which invalidates its MSA.
Name
s-minus-k-one:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K1
( .. )(
)
;
as:"s-minus-k-one";
Description
( P4_KEY_F1 ) constant S-K1
an ordinary constant (no special usage info)
Name
s-minus-k-ten:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K10
( .. )(
)
;
as:"s-minus-k-ten";
Description
( P4_KEY_FA ) constant S-K10
an ordinary constant (no special usage info)
Name
s-minus-k-two:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K2
( .. )(
)
;
as:"s-minus-k-two";
Description
( P4_KEY_F2 ) constant S-K2
an ordinary constant (no special usage info)
Name
s-minus-k-three:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K3
( .. )(
)
;
as:"s-minus-k-three";
Description
( P4_KEY_F3 ) constant S-K3
an ordinary constant (no special usage info)
Name
s-minus-k-four:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K4
( .. )(
)
;
as:"s-minus-k-four";
Description
( P4_KEY_F4 ) constant S-K4
an ordinary constant (no special usage info)
Name
s-minus-k-five:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K5
( .. )(
)
;
as:"s-minus-k-five";
Description
( P4_KEY_F5 ) constant S-K5
an ordinary constant (no special usage info)
Name
s-minus-k-six:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K6
( .. )(
)
;
as:"s-minus-k-six";
Description
( P4_KEY_F6 ) constant S-K6
an ordinary constant (no special usage info)
Name
s-minus-k-seven:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K7
( .. )(
)
;
as:"s-minus-k-seven";
Description
( P4_KEY_F7 ) constant S-K7
an ordinary constant (no special usage info)
Name
s-minus-k-eight:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K8
( .. )(
)
;
as:"s-minus-k-eight";
Description
( P4_KEY_F8 ) constant S-K8
an ordinary constant (no special usage info)
Name
s-minus-k-nine:term.1 — ordinary constant
Synopsis
EXTENSIONS
S-K9
( .. )(
)
;
as:"s-minus-k-nine";
Description
( P4_KEY_F9 ) constant S-K9
an ordinary constant (no special usage info)
Name
s-zero:misc.1 — threadstate variable
Description
threadstate variable S0
s0 (no special usage info)
Name
str-s-from:dstrings — ordinary primitive
Synopsis
FORTH
$S>
( $: a$ -- S: a.str )( | ) ; | |
Description
Drop a$ from the string stack and leave it as a Forth string
a.str, without copying. <ansref>"string-s-from"</ansref>
WARNING: If a$ is a bound string, it may move or disappear
at the next garbage collection, making a.str invalid. This
can be avoided by sandwiching sections of code where this
could occur between $GC-OFF and $GC-ON.
Name
str-s-from-copy:dstrings — ordinary primitive
Synopsis
FORTH
$S>-COPY
( $: a$ -- S: a.str )( | ) ; | |
Description
Drop a$ from the string stack, copy it into data space as a
measured string, and leave it as a Forth string a.str. An
error is thrown if the string length is larger than the
system parameter MAX_DATA_STR (see S,).
<ansref>"string-s-from-copy"</ansref>
Name
s-to-d:core — ordinary primitive
Synopsis
FORTH
S>D
( a -- a,a' )(
)
;
p4:"s-to-d";
Description
signed extension of a single-cell value to a double-cell value
Name
str-s-fetch:dstrings — ordinary primitive
Synopsis
FORTH
$S@
( $: a$ -- a$ S: a.str )( | ) ; | |
Description
Leave the string stack unchanged, and leave the string body
address and length on the data stack.
<ansref>"string-s-fetch"</ansref>
NOTE: In earlier versions this was call $S@S. The trailing
"S" is superfluous if it is understood that the only string
format that usually appears on the data stack is the Forth
string format.
WARNING: If a$ is a bound string, it may move at the next
garbage collection, making a.str invalid. This can be
avoided by sandwiching sections of code where this could
occur between $GC-OFF and $GC-ON.
Name
save-buffers:block — ordinary primitive
Synopsis
FORTH
SAVE-BUFFERS
( -- )(
)
;
p4:"save-buffers";
Description
write all modified buffer to
the disk, see UPDATE and
FLUSH
Name
save-input:core — ordinary primitive
Synopsis
FORTH
SAVE-INPUT
( -- xn .. x1 )( | ) ; | |
Description
fetch the current state of the input-channel which
may be restored with RESTORE-INPUT later
Name
scan:toolbelt — ordinary primitive
Synopsis
FORTH
SCAN
( str len char -- str+i len-i )( | ) ; | |
Description
Look for a particular character in the specified string.
: SCAN
>R BEGIN DUP WHILE OVER C@ R@ -
WHILE 1 /STRING REPEAT THEN
R> DROP ;
ie.
scan for first occurence of c in string
: SCAN >R BEGIN DUP OVER C@ R@ = 0= OR WHILE
1- SWAP 1- SWAP REPEAT R> DROP ;
Name
slash-scopy:dstrings::environment — ordinary constant
Synopsis
ENVIRONMENT
/SCOPY
( .. )(
)
;
as:"slash-scopy";
Description
( MAX_DATA_STR ) constant /SCOPY
an ordinary constant (no special usage info)
Name
scr:block.1 — threadstate variable
Description
threadstate variable SCR
scr (no special usage info)
Name
sdl-allocrw:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_AllocRW
( .. )(
)
;
as:"sdl-allocrw";
Description
ordinary primitive SDL_AllocRW
an executable word (no special usage info)
or wrapper call around SDL_AllocRW
Name
slash-sdl-audiocvt:lib_sdl.1 — ordinary constant
Description
( sizeof(SDL_AudioCVT) ) constant /SDL_AudioCVT
an ordinary constant (no special usage info)
Name
minus-back-sdl-audiocvt-dot-buf:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.buf
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.buf
offsetof(SDL_AudioCVT,buf) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-dst-format:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.dst_format
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.dst_format
offsetof(SDL_AudioCVT,dst_format) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-len:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.len
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.len
offsetof(SDL_AudioCVT,len) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-len-cvt:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.len_cvt
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.len_cvt
offsetof(SDL_AudioCVT,len_cvt) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-len-mult:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.len_mult
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.len_mult
offsetof(SDL_AudioCVT,len_mult) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-len-ratio:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.len_ratio
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.len_ratio
offsetof(SDL_AudioCVT,ratio) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-needed:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.needed
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.needed
offsetof(SDL_AudioCVT,needed) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-rate-incr:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.rate_incr
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.rate_incr
offsetof(SDL_AudioCVT,rate_incr) (no special usage info)
Name
minus-back-sdl-audiocvt-dot-src-format:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioCVT.src_format
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioCVT.src_format
offsetof(SDL_AudioCVT,scr_format) (no special usage info)
Name
sdl-audiodrivername:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_AudioDriverName
( .. )( | ) ; | |
Description
ordinary primitive SDL_AudioDriverName
an executable word (no special usage info)
or wrapper call around SDL_AudioDriverName
Name
sdl-audioinit:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_AudioInit
( .. )(
)
;
as:"sdl-audioinit";
Description
ordinary primitive SDL_AudioInit
an executable word (no special usage info)
or wrapper call around SDL_AudioInit
Name
sdl-audioquit:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_AudioQuit
( .. )(
)
;
as:"sdl-audioquit";
Description
ordinary primitive SDL_AudioQuit
an executable word (no special usage info)
or wrapper call around SDL_AudioQuit
Name
slash-sdl-audiospec:lib_sdl.1 — ordinary constant
Description
( sizeof(SDL_AudioSpec) ) constant /SDL_AudioSpec
an ordinary constant (no special usage info)
Name
minus-back-sdl-audiospec-dot-channels:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioSpec.channels
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioSpec.channels
offsetof(SDL_AudioSpec,channels) (no special usage info)
Name
minus-back-sdl-audiospec-dot-format:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioSpec.format
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioSpec.format
offsetof(SDL_AudioSpec,format) (no special usage info)
Name
minus-back-sdl-audiospec-dot-freq:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioSpec.freq
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioSpec.freq
offsetof(SDL_AudioSpec,freq) (no special usage info)
Name
minus-back-sdl-audiospec-dot-samples:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioSpec.samples
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioSpec.samples
offsetof(SDL_AudioSpec,samples) (no special usage info)
Name
minus-back-sdl-audiospec-dot-silence:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioSpec.silence
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioSpec.silence
offsetof(SDL_AudioSpec,silence) (no special usage info)
Name
minus-back-sdl-audiospec-dot-size:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_AudioSpec.size
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_AudioSpec.size
offsetof(SDL_AudioSpec,size) (no special usage info)
Name
sdl-audio-paused:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_AUDIO_PAUSED
( .. )( | ) ; | |
Description
( SDL_AUDIO_PAUSED ) constant SDL_AUDIO_PAUSED
an ordinary constant (no special usage info)
Name
sdl-audio-playing:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_AUDIO_PLAYING
( .. )( | ) ; | |
Description
( SDL_AUDIO_PLAYING ) constant SDL_AUDIO_PLAYING
an ordinary constant (no special usage info)
Name
sdl-audio-stopped:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_AUDIO_STOPPED
( .. )( | ) ; | |
Description
( SDL_AUDIO_STOPPED ) constant SDL_AUDIO_STOPPED
an ordinary constant (no special usage info)
Name
sdl-buildaudiocvt:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_BuildAudioCVT
( .. )( | ) ; | |
Description
ordinary primitive SDL_BuildAudioCVT
an executable word (no special usage info)
or wrapper call around SDL_BuildAudioCVT
Name
sdl-clearerror:lib_sdl.1 — ordinary primitive
Description
ordinary primitive SDL_ClearError
an executable word (no special usage info)
or wrapper call around SDL_ClearError
Name
CompiledVersion:lib_sdl — ordinary primitive
Synopsis
[SDL]
SDL_CompiledVersion
( -- SDL_versionnum )( | ) ; | |
Description
This function gets the version of the SDL library headers the PFE
has been linked with. It returns the compact code from SDL_VERSIONNUM
macro
Name
sdl-convertcvt:lib_sdl.1 — ordinary primitive
Description
ordinary primitive SDL_ConvertCVT
an executable word (no special usage info)
or wrapper call around SDL_ConvertCVT
Name
sdl-delay:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_Delay
( .. )(
)
;
as:"sdl-delay";
Description
ordinary primitive SDL_Delay
an executable word (no special usage info)
or wrapper call around SDL_Delay
Name
sdl-false:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_FALSE
( .. )(
)
;
as:"sdl-false";
Description
( SDL_FALSE ) constant SDL_FALSE
an ordinary constant (no special usage info)
Name
sdl-freerw:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_FreeRW
( .. )(
)
;
as:"sdl-freerw";
Description
ordinary primitive SDL_FreeRW
an executable word (no special usage info)
or wrapper call around SDL_FreeRW
Name
sdl-freewav:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_FreeWAV
( .. )(
)
;
as:"sdl-freewav";
Description
ordinary primitive SDL_FreeWAV
an executable word (no special usage info)
or wrapper call around SDL_FreeWAV
Name
sdl-getaudiostatus:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_GetAudioStatus
( .. )( | ) ; | |
Description
ordinary primitive SDL_GetAudioStatus
an executable word (no special usage info)
or wrapper call around SDL_GetAudioStatus
Name
GetError:lib_sdl — ordinary primitive
Synopsis
[SDL]
SDL_GetError
( -- str-ptr str-len )( | ) ; | |
Description
get it, based on
char * SDL_GetError(void);
Name
sdl-gettick:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_GetTick
( .. )(
)
;
as:"sdl-gettick";
Description
ordinary primitive SDL_GetTick
an executable word (no special usage info)
or wrapper call around SDL_GetTick
Name
sdl-init:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_init
( .. )(
)
;
as:"sdl-init";
Description
ordinary primitive SDL_init
an executable word (no special usage info)
or wrapper call around SDL_init
Name
sdl-initsubsystem:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_InitSubSystem
( .. )( | ) ; | |
Description
ordinary primitive SDL_InitSubSystem
an executable word (no special usage info)
or wrapper call around SDL_InitSubSystem
Name
sdl-init-audio:lib_sdl.1 — ordinary constant
Description
( SDL_INIT_AUDIO ) constant SDL_INIT_AUDIO
an ordinary constant (no special usage info)
Name
sdl-init-cdrom:lib_sdl.1 — ordinary constant
Description
( SDL_INIT_CDROM ) constant SDL_INIT_CDROM
an ordinary constant (no special usage info)
Name
sdl-init-eventthread:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_INIT_EVENTTHREAD
( .. )( | ) ; | |
Description
( SDL_INIT_EVENTTHREAD ) constant SDL_INIT_EVENTTHREAD
an ordinary constant (no special usage info)
Name
sdl-init-everything:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_INIT_EVERYTHING
( .. )( | ) ; | |
Description
( SDL_INIT_EVERYTHING ) constant SDL_INIT_EVERYTHING
an ordinary constant (no special usage info)
Name
sdl-init-joystick:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_INIT_JOYSTICK
( .. )( | ) ; | |
Description
( SDL_INIT_JOYSTICK ) constant SDL_INIT_JOYSTICK
an ordinary constant (no special usage info)
Name
sdl-init-noparachute:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_INIT_NOPARACHUTE
( .. )( | ) ; | |
Description
( SDL_INIT_NOPARACHUTE ) constant SDL_INIT_NOPARACHUTE
an ordinary constant (no special usage info)
Name
sdl-init-timer:lib_sdl.1 — ordinary constant
Description
( SDL_INIT_TIMER ) constant SDL_INIT_TIMER
an ordinary constant (no special usage info)
Name
sdl-init-video:lib_sdl.1 — ordinary constant
Description
( SDL_INIT_VIDEO ) constant SDL_INIT_VIDEO
an ordinary constant (no special usage info)
Name
LinkedVersion:lib_sdl — ordinary primitive
Synopsis
[SDL]
SDL_LinkedVersion
( -- SDL_versionnum )( | ) ; | |
Description
This function gets the version of the dynamically linked SDL library.
it should NOT be used to fill a version structure, instead you should
use the SDL_Version() macro. see SDL_LinkedVersion
implementation applies the SDL_VERSIONNUM macro to
extern DECLSPEC const SDL_version * SDL_Linked_Version(void);
Name
sdl-linked-version:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_Linked_Version
( .. )( | ) ; | |
Description
ordinary primitive SDL_Linked_Version
an executable word (no special usage info)
or wrapper call around SDL_Linked_Version
Name
sdl-loadwav:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_LoadWAV
( .. )(
)
;
as:"sdl-loadwav";
Description
ordinary primitive SDL_LoadWAV
an executable word (no special usage info)
or wrapper call around SDL_LoadWAV
Name
sdl-loadwav-rw:lib_sdl.1 — ordinary primitive
Description
ordinary primitive SDL_LoadWAV_RW
an executable word (no special usage info)
or wrapper call around SDL_LoadWAV_RW
Name
sdl-lockaudio:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_LockAudio
( .. )(
)
;
as:"sdl-lockaudio";
Description
ordinary primitive SDL_LockAudio
an executable word (no special usage info)
or wrapper call around SDL_LockAudio
Name
sdl-lockaudio:lib_sdl.2 — ordinary primitive
Synopsis
[SDL]
SDL_LockAudio
( .. )(
)
;
as:"sdl-lockaudio";
Description
ordinary primitive SDL_LockAudio
an executable word (no special usage info)
or wrapper call around SDL_LockAudio
Name
sdl-mixaudio:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_MixAudio
( .. )(
)
;
as:"sdl-mixaudio";
Description
ordinary primitive SDL_MixAudio
an executable word (no special usage info)
or wrapper call around SDL_MixAudio
Name
sdl-openaudio:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_OpenAudio
( .. )(
)
;
as:"sdl-openaudio";
Description
ordinary primitive SDL_OpenAudio
an executable word (no special usage info)
or wrapper call around SDL_OpenAudio
Name
sdl-pressed:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_PRESSED
( .. )(
)
;
as:"sdl-pressed";
Description
( SDL_PRESSED ) constant SDL_PRESSED
an ordinary constant (no special usage info)
Name
sdl-quit:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_Quit
( .. )(
)
;
as:"sdl-quit";
Description
ordinary primitive SDL_Quit
an executable word (no special usage info)
or wrapper call around SDL_Quit
Name
sdl-quitsubsystem:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_QuitSubSystem
( .. )( | ) ; | |
Description
ordinary primitive SDL_QuitSubSystem
an executable word (no special usage info)
or wrapper call around SDL_QuitSubSystem
Name
sdl-released:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_RELEASED
( .. )(
)
;
as:"sdl-released";
Description
( SDL_RELEASED ) constant SDL_RELEASED
an ordinary constant (no special usage info)
Name
sdl-rwclose:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWclose
( .. )(
)
;
as:"sdl-rwclose";
Description
ordinary primitive SDL_RWclose
an executable word (no special usage info)
or wrapper call around SDL_RWclose
Name
sdl-rwfromfile:lib_sdl.1 — ordinary primitive
Description
ordinary primitive SDL_RWFromFile
an executable word (no special usage info)
or wrapper call around SDL_RWFromFile
Name
sdl-rwfromfp:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWFromFP
( .. )(
)
;
as:"sdl-rwfromfp";
Description
ordinary primitive SDL_RWFromFP
an executable word (no special usage info)
or wrapper call around SDL_RWFromFP
Name
sdl-rwfrommem:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWFromMem
( .. )(
)
;
as:"sdl-rwfrommem";
Description
ordinary primitive SDL_RWFromMem
an executable word (no special usage info)
or wrapper call around SDL_RWFromMem
Name
sdl-rwread:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWread
( .. )(
)
;
as:"sdl-rwread";
Description
ordinary primitive SDL_RWread
an executable word (no special usage info)
or wrapper call around SDL_RWread
Name
sdl-rwseek:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWseek
( .. )(
)
;
as:"sdl-rwseek";
Description
ordinary primitive SDL_RWseek
an executable word (no special usage info)
or wrapper call around SDL_RWseek
Name
sdl-rwtell:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWtell
( .. )(
)
;
as:"sdl-rwtell";
Description
ordinary primitive SDL_RWtell
an executable word (no special usage info)
or wrapper call around SDL_RWtell
Name
sdl-rwwrite:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_RWwrite
( .. )(
)
;
as:"sdl-rwwrite";
Description
ordinary primitive SDL_RWwrite
an executable word (no special usage info)
or wrapper call around SDL_RWwrite
Name
SetError:lib_sdl — ordinary primitive
Synopsis
[SDL]
SDL_SetError
( str-ptr str-len -- )( | ) ; | |
Description
set it, based on
void SDL_SetError(const char *fmt, ...);
Name
sdl-true:lib_sdl.1 — ordinary constant
Synopsis
[SDL]
SDL_TRUE
( .. )(
)
;
as:"sdl-true";
Description
( SDL_TRUE ) constant SDL_TRUE
an ordinary constant (no special usage info)
Name
sdl-unlockaudio:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_UnLockAudio
( .. )( | ) ; | |
Description
ordinary primitive SDL_UnLockAudio
an executable word (no special usage info)
or wrapper call around SDL_UnLockAudio
Name
sdl-unlockaudio:lib_sdl.2 — ordinary primitive
Synopsis
[SDL]
SDL_UnlockAudio
( .. )( | ) ; | |
Description
ordinary primitive SDL_UnlockAudio
an executable word (no special usage info)
or wrapper call around SDL_UnlockAudio
Name
minus-back-sdl-version-dot-major:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_version.major
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_version.major
offsetof(SDL_version,major) (no special usage info)
Name
minus-back-sdl-version-dot-minor:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_version.minor
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_version.minor
offsetof(SDL_version,minor) (no special usage info)
Name
minus-back-sdl-version-dot-patch:lib_sdl.1 — ordinary offsetval
Synopsis
[SDL]
->SDL_version.patch
( .. )( | ) ; | |
Description
ordinary offsetval ->SDL_version.patch
offsetof(SDL_version,patch) (no special usage info)
Name
sdl-wasinit:lib_sdl.1 — ordinary primitive
Synopsis
[SDL]
SDL_WasInit
( .. )(
)
;
as:"sdl-wasinit";
Description
ordinary primitive SDL_WasInit
an executable word (no special usage info)
or wrapper call around SDL_WasInit
Name
seal:forth_83 — ordinary primitive
Description
looks through the search-order and kills the ONLY wordset -
hence you can't access the primary vocabularies from there.
Name
search:string — ordinary primitive
Synopsis
FORTH
SEARCH
( str-ptr1 str-len1 str-ptr2 str-len2 -- str-ptr1' str-len1' flag )( | ) ; | |
Description
search the str-buffer1 for the text of str-buffer2,
if it is contained return TRUE and return buffer-values that
point to the contained string, otherwise return FALSE and
leave the original str-buffer1.
Name
search-minus-also-minus-voc:useful.1 — obsolete forthword
Synopsis
EXTENSIONS
SEARCH-ALSO-VOC
( .. )( | ) ; | |
Description
obsolete forthword SEARCH-ALSO-VOC
is doing the same as DEFS-ARE-SEARCHED-ALSO
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
search-minus-loaded:search::environment — constructor primitive
Description
constructor primitive SEARCH-LOADED
an executable word (no special usage info)
or wrapper call around p4_search_init
Name
search-minus-order-minus-ext:search::environment — ordinary constant
Synopsis
ENVIRONMENT
SEARCH-ORDER-EXT
( .. )( | ) ; | |
Description
( 1994 ) constant SEARCH-ORDER-EXT
an ordinary constant (no special usage info)
Name
search-wordlist:search — ordinary primitive
Synopsis
FORTH
SEARCH-WORDLIST
( str-ptr str-len voc -- 0 | xt 1 | xt -1 )( | ) ; | |
Description
almost like FIND or (FIND) -- but searches only the
specified vocabulary.
Name
see:tools.1 — ordinary primitive
Description
ordinary primitive SEE
an executable word (no special usage info)
or wrapper call around p4_see
Name
paren-see:debug.1 — ordinary primitive
Synopsis
FORTH
(SEE)
( .. )(
)
;
as:"paren-see";
Description
ordinary primitive (SEE)
an executable word (no special usage info)
or wrapper call around p4_paren_see
Name
set-blockfile:block_misc — ordinary primitive
Synopsis
EXTENSIONS
SET-BLOCKFILE
( fid -- )win32for( | ) ; | |
Description
win32forth uses a system-filedescriptor where -1 means unused
in the BLOCKHANDLE, but we use a "FILE*"-like structure, so NULL
means NOT-IN-USE. Here we set it.
Name
set-current:search — ordinary primitive
Synopsis
FORTH
SET-CURRENT
( voc -- )(
)
;
p4:"set-current";
Description
set the definition-vocabulary. see DEFINITIONS
Name
set-order:search — ordinary primitive
Synopsis
FORTH
SET-ORDER
( vocn ... voc1 n -- )( | ) ; | |
Description
set the search-order -- probably saved beforehand using
GET-ORDER
Name
set-minus-precision:floating.1 — ordinary primitive
Description
ordinary primitive SET-PRECISION
an executable word (no special usage info)
or wrapper call around p4_set_precision
Name
set-minus-precision:fpnostack.1 — ordinary primitive
Description
ordinary primitive SET-PRECISION
an executable word (no special usage info)
or wrapper call around p4_nofp_set_precision
Name
sf-store:floating.1 — ordinary primitive
Synopsis
FORTH
SF!
( .. )(
)
;
as:"sf-store";
Description
ordinary primitive SF!
an executable word (no special usage info)
or wrapper call around p4_s_f_store
Name
sf-store:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
SF!
( .. )(
)
;
as:"sf-store";
Description
ordinary primitive SF!
an executable word (no special usage info)
or wrapper call around p4_nofp_s_f_store
Name
sf-fetch:floating.1 — ordinary primitive
Synopsis
FORTH
SF@
( .. )(
)
;
as:"sf-fetch";
Description
ordinary primitive SF@
an executable word (no special usage info)
or wrapper call around p4_s_f_fetch
Name
sf-fetch:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
SF@
( .. )(
)
;
as:"sf-fetch";
Description
ordinary primitive SF@
an executable word (no special usage info)
or wrapper call around p4_nofp_s_f_fetch
Name
sfalign:floating.1 — ordinary primitive
Synopsis
FORTH
SFALIGN
( .. )(
)
;
as:"sfalign";
Description
ordinary primitive SFALIGN
an executable word (no special usage info)
or wrapper call around p4_align
Name
sfalign:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
SFALIGN
( .. )(
)
;
as:"sfalign";
Description
ordinary primitive SFALIGN
an executable word (no special usage info)
or wrapper call around p4_align
Name
sfaligned:floating.1 — ordinary primitive
Synopsis
FORTH
SFALIGNED
( .. )(
)
;
as:"sfaligned";
Description
ordinary primitive SFALIGNED
an executable word (no special usage info)
or wrapper call around p4_aligned
Name
sfaligned:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
SFALIGNED
( .. )(
)
;
as:"sfaligned";
Description
ordinary primitive SFALIGNED
an executable word (no special usage info)
or wrapper call around p4_aligned
Name
sfloat-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
SFLOAT%
( .. )(
)
;
as:"sfloat-percent";
Description
ordinary primitive SFLOAT%
an executable word (no special usage info)
or wrapper call around p4_sfloat_mod
Name
sfloat-plus:floating.1 — ordinary primitive
Synopsis
FORTH
SFLOAT+
( .. )(
)
;
as:"sfloat-plus";
Description
ordinary primitive SFLOAT+
an executable word (no special usage info)
or wrapper call around p4_s_float_plus
Name
sfloat-plus:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
SFLOAT+
( .. )(
)
;
as:"sfloat-plus";
Description
ordinary primitive SFLOAT+
an executable word (no special usage info)
or wrapper call around p4_nofp_s_float_plus
Name
sfloats:floating.1 — ordinary primitive
Synopsis
FORTH
SFLOATS
( .. )(
)
;
as:"sfloats";
Description
ordinary primitive SFLOATS
an executable word (no special usage info)
or wrapper call around p4_s_floats
Name
sfloats:fpnostack.1 — ordinary primitive
Synopsis
EXTENSIONS
SFLOATS
( .. )(
)
;
as:"sfloats";
Description
ordinary primitive SFLOATS
an executable word (no special usage info)
or wrapper call around p4_nofp_s_floats
Name
show-minus-status:misc.1 — forthword synonym
Description
forthword synonym SHOW-STATUS
is doing the same as .STATUS
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
show-control-strings:term — ordinary primitive
Synopsis
EXTENSIONS
SHOW-TERM-CONTROLS
( -- )for debugging( | ) ; | |
Description
show the current mappings for the terminal output
may give hints about what is wrong if the output
seems to miss some functionality
Name
show-rawkey-strings:term — ordinary primitive
Synopsis
EXTENSIONS
SHOW-TERM-ESC-KEYS
( -- )for debugging( | ) ; | |
Description
show the current mappings for the terminal input
may give hints about what is wrong if the input
seems to miss some functionality
Name
show-termcap:term — ordinary primitive
Synopsis
EXTENSIONS
SHOW-TERMCAP
( -- )for debugging( | ) ; | |
Description
print the termcap strings used for input and output
may give hints about what is wrong if the terminal
seems to miss some functionality
Name
sign:core — ordinary primitive
Synopsis
FORTH
SIGN
( a -- )(
)
;
p4:"sign";
Description
put the sign of the value into the hold-space, this is
the forth-style output formatting, see HOLD
Name
signal:misc — ordinary primitive
Synopsis
FORTH
SIGNAL
( xt1 n -- xt2 )(
)
;
p4:"signal";
Description
install signal handler
- return old signal handler
Name
sizeof:struct.1 — compiling primitive
Synopsis
EXTENSIONS
SIZEOF
( "name" -- size )(
)
;
as:"sizeof";
Description
get the size-value from a previous structure definition
: SIZEOF ' >BODY @ STATE @ IF [COMPILE] LITERAL THEN ; IMMEDIATE
FCode_XE (p4_sizeof_XT)
Name
skip:toolbelt — ordinary primitive
Synopsis
FORTH
SKIP
( str len char -- str+i len-i )( | ) ; | |
Description
Advance past leading characters in the specified string.
: SKIP
>R BEGIN DUP WHILE OVER C@ R@ =
WHILE 1 /STRING REPEAT THEN
R> DROP ;
ie.
skip leading characters c
: SKIP >R BEGIN DUP OVER C@ R@ = OR WHILE
1- SWAP 1- SWAP REPEAT R> DROP ;
Name
sliteral:string — compiling primitive
Synopsis
FORTH
SLITERAL
( -- string )(
)
;
p4:"sliteral";
Description
compile-time: ( CS: str-ptr str-len -- )
this word does almost the same as LITERAL - it takes
an S" string as specified in the CS-STACK at compile
time and compiles into the current definition where it is
returned as if there were a direct string-literal. This
can be used to compute a string-literal at compile-time
and hardwire it.
example:
: ORIGINAL-HOME [ $HOME COUNT ] SLITERAL ; ( -- str-ptr str-len )
Name
s-m-slash-rem:core — ordinary primitive
Synopsis
FORTH
SM/REM
( a.a b -- c d )( | ) ; | |
Name
smart-interpret-store:smart_go — ordinary primitive
Synopsis
EXTENSIONS
SMART-INTERPRET!
( -- )( | ) ; | |
Description
enables/disables the SMART-INTERPRET extension in INTERPRET ,
(actually stores an XT in DEFER inside the mainloop interpreter)
Name
smart-interpret-init:smart_go — ordinary primitive
Synopsis
EXTENSIONS
SMART-INTERPRET-INIT
( -- )( | ) ; | |
Description
creates a set of interpret-words that are used in the inner
interpreter, so if a word is unknown to the interpreter-loop
it will use the first char of that word, attach it to an
"interpret-" prefix, and tries to use that IMMEDIATE-DEFER-word
on the rest of the word. This SMART-INTERPRET-INIT will set up
words like interpret-" so you can write
<c>"hello"</c> instead of <c>" hello"</c>
and it creates interpret-\ so that words like
\if-unix
are
ignoring the line if the word
\if-unknown
is unknown in itself.
This is usually not activated on startup.
Name
smart-minus-interpret-minus-loaded:smart_go::environment — constructor primitive
Synopsis
ENVIRONMENT
SMART-INTERPRET-LOADED
( .. )( | ) ; | |
Description
constructor primitive SMART-INTERPRET-LOADED
an executable word (no special usage info)
or wrapper call around smart_interpret_init
Name
smudge:header.1 — ordinary primitive
Synopsis
EXTENSIONS
SMUDGE
( .. )(
)
;
as:"smudge";
Description
ordinary primitive SMUDGE
an executable word (no special usage info)
or wrapper call around p4_smudge
Name
paren-smudge-sharp:header.1 — obsolete forthword
Synopsis
EXTENSIONS
(SMUDGE#)
( .. )(
)
;
as:"paren-smudge-sharp";
Description
obsolete forthword (SMUDGE#)
is doing the same as SMUDGE-MASK
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
smudge-minus-mask:header.1 — ordinary constant
Description
( P4xSMUDGED ) constant SMUDGE-MASK
an ordinary constant (no special usage info)
Name
source:core — ordinary primitive
Synopsis
FORTH
SOURCE
( -- buffer IN-offset )( | ) ; | |
Description
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
Name
source-minus-id:core.1 — - loader type P4_DVaL
Synopsis
FORTH
SOURCE-ID
( .. )(
)
;
as:"source-minus-id";
Description
- loader type P4_DVaL SOURCE-ID
input.source_id (no special usage info)
Name
source-line:misc — ordinary primitive
Synopsis
FORTH
SOURCE-LINE
( -- n )(
)
;
p4:"source-line";
Description
if SOURCE is from EVALUATE (or QUERY ) then
the result is 0 else the line-numbers start from 1
Name
source-name:misc — ordinary primitive
Synopsis
FORTH
SOURCE-NAME
( -- str-ptr str-len )( | ) ; | |
Description
if SOURCE is from INCLUDE then the result is the filename,
otherwise a generic name for the SOURCE-ID is given.
Name
str-sp:dstrings.1 — ordinary primitive
Synopsis
FORTH
$SP
( .. )(
)
;
as:"str-sp";
Description
ordinary primitive $SP
an executable word (no special usage info)
or wrapper call around str_sp
Name
s-p-store:forth_usual — ordinary primitive
Synopsis
FORTH
SP!
( ... addr -- )(
)
;
p4:"s-p-store";
Description
sets the stack pointer, reverse of SP@
Name
str-sp-zero:dstrings.1 — ordinary primitive
Synopsis
FORTH
$SP0
( .. )(
)
;
as:"str-sp-zero";
Description
ordinary primitive $SP0
an executable word (no special usage info)
or wrapper call around str_sp0
Name
s-p-fetch:forth_83 — ordinary primitive
Synopsis
FORTH
SP@
( -- )(
)
;
p4:"s-p-fetch";
Description
the address of the top of stack. Does save it onto
the stack. You could do
: DUP SP@ @ ;
Name
slash-str-space:dstrings.1 — ordinary primitive
Synopsis
FORTH
/$SPACE
( .. )(
)
;
as:"slash-str-space";
Description
ordinary primitive /$SPACE
an executable word (no special usage info)
or wrapper call around per_str_space
Name
zero-str-space:dstrings.1 — ordinary primitive
Synopsis
FORTH
0$SPACE
( .. )(
)
;
as:"zero-str-space";
Description
ordinary primitive 0$SPACE
an executable word (no special usage info)
or wrapper call around zero_str_space
Name
space:core — ordinary primitive
Synopsis
FORTH
SPACE
( -- )(
)
;
p4:"space";
Description
print a single space to stdout, see SPACES
simulate: : SPACE BL EMIT ;
Name
slash-str-space-minus-header:dstrings.1 — ordinary primitive
Description
ordinary primitive /$SPACE-HEADER
an executable word (no special usage info)
or wrapper call around per_str_space_header
Name
spaces:core — ordinary primitive
Synopsis
FORTH
SPACES
( n -- )(
)
;
p4:"spaces";
Description
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.
Name
span:core.1 — threadstate variable
Description
threadstate variable SPAN
span (no special usage info)
Name
div-split:toolbelt — ordinary primitive
Synopsis
FORTH
/SPLIT
( a m a+i m-i -- a+i m-i a i )( | ) ; | |
Description
Split a character string _a m_ at place given by _a+i m-i_.
Called "cut-split" because "slash-split" is a tongue
twister.
: /SPLIT DUP >R 2SWAP R> - ;
Name
split-next-line:toolbelt — ordinary primitive
Synopsis
FORTH
SPLIT-NEXT-LINE
( src . -- src' . str len )( | ) ; | |
Description
Split the next line from the string.
: SPLIT-NEXT-LINE
2DUP #EOL-CHAR SCAN
DUP >R 1 /STRING 2SWAP R> - ;
FIXME: inform Neil Bawd that this is probably
not what he wanted. replace /STRING with /SPLIT here.
Name
sprintf:useful.1 — obsolete forthword
Synopsis
EXTENSIONS
SPRINTF
( .. )(
)
;
as:"sprintf";
Description
obsolete forthword SPRINTF
is doing the same as PFE-SPRINTF
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
spy-semicolon:with_spy — compiling primitive
Synopsis
EXTENSIONS
;SPY
( -- )(
)
;
p4:"spy-semicolon";
Description
compiles ((;)) which does EXIT the current
colon-definition. It does then end compile-mode
and returns to execute-mode. See : and :NONAME
Name
spy-minus-enter:with_spy.1 — - loader type P4_DVaL
Synopsis
EXTENSIONS
SPY-ENTER
( .. )(
)
;
as:"spy-minus-enter";
Description
- loader type P4_DVaL SPY-ENTER
spy_enter (no special usage info)
Name
spy-exit:with_spy — ordinary primitive
Synopsis
EXTENSIONS
SPY-EXIT
( -- )(
)
;
p4:"spy-exit";
Description
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 ;
Name
spy-minus-leave:with_spy.1 — - loader type P4_DVaL
Synopsis
EXTENSIONS
SPY-LEAVE
( .. )(
)
;
as:"spy-minus-leave";
Description
- loader type P4_DVaL SPY-LEAVE
spy_leave (no special usage info)
Name
spy-colon:with_spy — definining primitive
Synopsis
EXTENSIONS
SPY:
( name -- )(
)
;
p4:"spy-colon";
Description
create a header for a nesting word and go to compiling
mode then. This word is usually ended with ; but
the execution of the resulting colon-word can also
return with EXIT
this is the spy-version SPY_ON
Name
spy-off:with_spy — ordinary primitive
Synopsis
EXTENSIONS
SPY_OFF
( -- )(
)
;
p4:"spy-off";
Description
disable SPY_ON nest-trace.
Name
spy-on:with_spy — ordinary primitive
Synopsis
EXTENSIONS
SPY_ON
( -- )(
)
;
p4:"spy-on";
Description
change the runtime-code of (NEST)
to call a special word that prints info
to the screen whenever a colon word is
entered. It will print the name and
the current stack, and results in a kind
of execution trace over SPY' :-colon nested
words.
Name
srand:misc — ordinary primitive
Synopsis
FORTH
SRAND
( n -- )(
)
;
p4:"srand";
Name
Q-stack:tools_misc — ordinary primitive
Synopsis
FORTH
?STACK
( -- )(
)
;
p4:"Q-stack";
Description
check all stacks for underflow and overflow conditions,
and if such an error condition is detected THROW
Name
stack-minus-cells:core::environment — ordinary primitive
Description
ordinary primitive STACK-CELLS
an executable word (no special usage info)
or wrapper call around p__stack_cells
Name
standard-io:misc — ordinary primitive
Synopsis
FORTH
STANDARD-I/O
( -- )(
)
;
p4:"standard-io";
Name
start-Q-cr:misc — ordinary primitive
Synopsis
FORTH
START?CR
( -- )(
)
;
p4:"start-Q-cr";
Description
initialized for more-like effect
- see ?CR
Name
starts-Q:toolbelt — ordinary primitive
Synopsis
FORTH
STARTS?
( str len pattern len2 -- str len flag )( | ) ; | |
Description
Check start of string.
: STARTS? DUP >R 2OVER R> MIN COMPARE 0= ;
Name
state:core.1 — threadstate variable
Synopsis
FORTH
STATE
( .. )(
)
;
as:"state";
Description
threadstate variable STATE
state (no special usage info)
Name
dot-status:misc — ordinary primitive
Synopsis
FORTH
.STATUS
( -- )(
)
;
p4:"dot-status";
Description
display internal variables
: .STATUS .VERSION .CVERSION .MEMORY .SEARCHPATHS .DICTVARS .REGSUSED ;
Name
stderr:misc.1 — - loader type P4_DVaL
Synopsis
FORTH
STDERR
( .. )(
)
;
as:"stderr";
Description
- loader type P4_DVaL STDERR
stdErr (no special usage info)
Name
stdin:misc.1 — - loader type P4_DVaL
Synopsis
FORTH
STDIN
( .. )(
)
;
as:"stdin";
Description
- loader type P4_DVaL STDIN
stdIn (no special usage info)
Name
stdout:misc.1 — - loader type P4_DVaL
Synopsis
FORTH
STDOUT
( .. )(
)
;
as:"stdout";
Description
- loader type P4_DVaL STDOUT
stdOut (no special usage info)
Name
Q-stop:misc — ordinary primitive
Synopsis
FORTH
?STOP
( -- flag )(
)
;
p4:"Q-stop";
Description
check for 'q' pressed
- see ?CR
Name
slash-string:string — ordinary primitive
Synopsis
FORTH
/STRING
( str-ptr str-len n -- str-ptr' str-len' )( | ) ; | |
Description
shorten the buffer from the beginning by n characters, i.e.
str-ptr += n ;
str-len -= n;
Name
string-comma:core_misc — ordinary primitive
Synopsis
FORTH
STRING,
( str len -- )(
)
;
p4:"string-comma";
Description
Store a string in data space as a counted string.
: STRING, HERE OVER 1+ ALLOT PLACE ;
Name
string-comma:toolbelt — ordinary primitive
Synopsis
FORTH
STRING,
( str len -- )(
)
;
p4:"string-comma";
Description
Store a string in data space as a counted string.
: STRING, HERE OVER 1+ ALLOT PLACE ;
Name
string-minus-ext:string::environment — ordinary constant
Synopsis
ENVIRONMENT
STRING-EXT
( .. )(
)
;
as:"string-minus-ext";
Description
( 1994 ) constant STRING-EXT
an ordinary constant (no special usage info)
Name
zero-strings:dstrings — ordinary primitive
Synopsis
FORTH
0STRINGS
( -- )(
)
;
p4:"zero-strings";
Description
Set all string variables holding bound string values in string
space to the empty string, and clear string space, including
the string buffer, string stack, and string stack frames.
<ansref>"zero-strings"</ansref>
NOTE: If used for under the hood development, this word must
be executed only when string space is in a valid state.
Name
struct:struct — ordinary primitive
Synopsis
EXTENSIONS
STRUCT
( "name" -- here zero-offset )( | ) ; | |
Description
begin definition of a new structure (mpe.000)
: STRUCT CREATE !CSP
HERE
0 DUP ,
DOES>
@
;
Name
struct-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
STRUCT:
( .. )(
)
;
as:"struct-colon";
Description
ordinary primitive STRUCT:
an executable word (no special usage info)
or wrapper call around p4_field
Name
structure:struct.1 — definining primitive
Synopsis
EXTENSIONS
STRUCTURE
( "name" -- here zero-offset )exec( | ) ; | |
Description
start a structure definition
: STRUCTURE: CREATE !CSP
HERE
0 DUP ,
DOES>
CREATE @ ALLOT
;
FCode_RT (p4_structure_RT)
Name
semicolon-structure:structs.1 — ordinary primitive
Description
ordinary primitive ;STRUCTURE
an executable word (no special usage info)
or wrapper call around p4_endstructure
Name
structure-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
STRUCTURE:
( .. )(
)
;
as:"structure-colon";
Description
ordinary primitive STRUCTURE:
an executable word (no special usage info)
or wrapper call around p4_structure
Name
subrecord:struct — ordinary primitive
Synopsis
EXTENSIONS
SUBRECORD
( outer-offset "name" -- outer-offset here zero-offset )( | ) ; | |
Description
begin definition of a subrecord (mpe.000)
: STRUCT CREATE
HERE
0 DUP ,
DOES>
@
;
Name
str-swap:dstrings.1 — ordinary primitive
Synopsis
FORTH
$SWAP
( .. )(
)
;
as:"str-swap";
Description
ordinary primitive $SWAP
an executable word (no special usage info)
or wrapper call around p4_str_swap
Name
swap:core — ordinary primitive
Synopsis
FORTH
SWAP
( a b -- b a )(
)
;
p4:"swap";
Description
exchanges the value on top of the stack with the value beneath it
Name
two-swap:core — ordinary primitive
Synopsis
FORTH
2SWAP
( a,a b,b -- b,b a,a )( | ) ; | |
Description
double-cell swap, see SWAP and 2DUP
simulate:
: 2SWAP LOCALS| B1 B2 A1 A2 | B2 B1 A2 A1 ;
Name
synonym:header — definining primitive
Synopsis
EXTENSIONS
SYNONYM
( "newname" "oldname" -- )( | ) ; | |
Description
make an name-alias for a word - this is very different from a DEFER
since a DEFER will resolve at runtime. Changing the target of a
DEFER via IS will result in changing the BEHAVIOR of all
words defined earlier and containing the name of the DEFER.
A SYNONYM however does not have any data field (theoretically not
even an execution token), instead it gets resolved at compile time.
In theory, you can try to FIND the name of the SYNONYM but as
soon as you apply NAME> the execution token of the end-point is
returned. This has also the effect that using the inverse ">NAME"
operation will result in the name-token of the other name.
SYNONYM CREATE <BUILDS ( like it is in ANS Forth )
: FOO CREATE DOES> @ ;
SEE FOO
: foo <builds
does> @ ;
SYNONYM CREATE CREATE:
: BAR CREATE 10 ALLOT ;
SEE BAR
: bar create: 10 allot ;
(only LINK> does not care about SYNONYMs)
Name
synonym-minus-obsoleted:header.1 — definining primitive
Synopsis
EXTENSIONS
SYNONYM-OBSOLETED
( .. )( | ) ; | |
Description
definining primitive SYNONYM-OBSOLETED
an executable word (no special usage info)
or wrapper call around p4_obsoleted
Name
system:misc — ordinary primitive
Synopsis
FORTH
SYSTEM
( addr u -- ret-val )(
)
;
p4:"system";
Description
run a shell command (note: embedded systems have no shell)
Name
system-quote:misc — compiling primitive
Synopsis
FORTH
SYSTEM"
( [commandline<">] -- ret-val )obsolete( | ) ; | |
Description
run a shell command (note:embedded systems have no shell)
obsolete! use S" string" SYSTEM
Name
system-minus-ext:system::environment — ordinary constant
Synopsis
ENVIRONMENT
SYSTEM-EXT
( .. )(
)
;
as:"system-minus-ext";
Description
( 1983 ) constant SYSTEM-EXT
an ordinary constant (no special usage info)
Name
s-backslash-quote:zchar.1 — compiling primitive
Synopsis
FORTH
S\"
( .. )(
)
;
as:"s-backslash-quote";
Description
compiling primitive S\"
an executable word (no special usage info)
or wrapper call around p4_s_backslash_quote
Name
tab:misc — ordinary primitive
Description
jump to next column divisible by n
Name
sharp-tab-minus-char:toolbelt.1 — ordinary constant
Description
( '\t' ) constant #TAB-CHAR
an ordinary constant (no special usage info)
Name
question-terminal:forth_83.1 — ordinary primitive
Synopsis
FORTH
?TERMINAL
( .. )(
)
;
as:"question-terminal";
Description
ordinary primitive ?TERMINAL
an executable word (no special usage info)
or wrapper call around p4_key_question
Name
terminal-answer-link:host_k12 — ordinary primitive
Synopsis
EXTENSIONS
TERMINAL-ANSWER-LINK
( -- sap#* )( | ) ; | |
Description
send terminal-output as a data-message to the specified link sap.
Unlike TERMINAL-OUTPUT-LINE the data-messages are in line-mode.
The flushed characters are buffered until a non-printable character
is seen. This is somewhat more useful when treating pfe as a print
service and testing machine, but can not provide for interactivity.
60 TERMINAL-ANSWER-LINK !
...
TERMINAL-ANSWER-LINK OFF
Name
terminal-emulation-state:host_k12 — ordinary primitive
Synopsis
EXTENSIONS
TERMINAL-EMULATION-STATE
( -- state* )( | ) ; | |
Description
returns the address of the emulations state variable so it can be
read and explicitly changed to another value from forth text. This is
a very questionable thing to do as the emulation-state is actually
an enumerated value, the ESE will just show question-marks setting
this variable to something not understood.
Name
terminal-input-link:host_k12 — ordinary primitive
Synopsis
EXTENSIONS
TERMINAL-INPUT-LINK
( -- sap#* )( | ) ; | |
Description
let the forth stdin-handling look for data-messages on this link too.
These will be interpreted like messages that come from the interactive
forth terminal. This can be used in an embedded systems for a terminal
session simulation. setting zero-sap will disable interpreting these
incoming data-frames as keyboard-strings (so that the zero sap is
therefore not usable for an input-link!). The startup default is zero.
60 TERMINAL-INPUT-LINK !
...
TERMINAL-INPUT-LINK OFF
Name
terminal-output-link:host_k12 — ordinary primitive
Synopsis
EXTENSIONS
TERMINAL-OUTPUT-LINK
( -- sap#* )( | ) ; | |
Description
send terminal-output as a data-message to the specified link sap.
This can be used in an embedded systems for a terminal session simulation.
setting zero-sap will disable sending message-frames (the zero sap is
therefore not usable for output-to-link). The startup default is zero.
60 TERMINAL-OUTPUT-LINK !
...
TERMINAL-OUTPUT-LINK OFF
Name
tick-th:toolbelt — compiling primitive
Synopsis
FORTH
'th
( n "addr" -- &addr[n] )( | ) ; | |
Description
Address `n CELLS addr +`.
: 'th ( n "addr" -- &addr[n] )
S" 2 LSHIFT " EVALUATE
BL WORD COUNT EVALUATE
S" + " EVALUATE
; IMMEDIATE
Name
th-pocket:misc — ordinary primitive
Synopsis
FORTH
TH'POCKET
( n -- addr u )(
)
;
p4:"th-pocket";
Description
returns the specified pocket as a S" string reference
Name
then:core — compiling primitive
Description
does resolve a branch coming from either IF or ELSE
Name
bracket-then:tools.1 — immediate primitive
Synopsis
FORTH
[THEN]
( .. )(
)
;
as:"bracket-then";
Description
immediate primitive [THEN]
an executable word (no special usage info)
or wrapper call around p4_noop
Name
third:toolbelt — ordinary primitive
Synopsis
FORTH
THIRD
( x y z -- x y z x )(
)
;
p4:"third";
Description
Copy third element on the stack onto top of stack.
: THIRD 2 PICK ;
Name
throw:exception — ordinary primitive
Synopsis
FORTH
THROW
( n -- )(
)
;
p4:"throw";
Description
raise an exception - it will adjust the depth
of all stacks and start interpreting at the point
of the latest CATCH <br>
if n is null nothing happens, the -1 (ie. FALSE )
is the raise-code of ABORT - the other codes
are implementation dependent and will result in
something quite like ABORT
Name
thru:block — ordinary primitive
Synopsis
FORTH
THRU
( u1 u2 -- )(
)
;
p4:"thru";
Description
LOAD a number of block in sequence.
Name
tib:core.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL TIB
input.tib (no special usage info)
Name
sharp-tib:core.1 — threadstate variable
Synopsis
FORTH
#TIB
( .. )(
)
;
as:"sharp-tib";
Description
threadstate variable #TIB
input.number_tib (no special usage info)
Name
time-and-date:facility.1 — ordinary primitive
Synopsis
FORTH
TIME&DATE
( .. )(
)
;
as:"time-and-date";
Description
ordinary primitive TIME&DATE
an executable word (no special usage info)
or wrapper call around p4_time_and_date
Name
to:core — compiling primitive
Synopsis
FORTH
TO
( value [name] -- )(
)
;
p4:"to";
Description
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|
Name
plus-to:misc — compiling primitive
Synopsis
FORTH
+TO
( val [name] -- )(
)
;
p4:"plus-to";
Name
toggle:forth_usual — ordinary primitive
Synopsis
FORTH
TOGGLE
( c-addr charmask -- )( | ) ; | |
Description
toggle the bits given in charmask, see also SMUDGE and = UNSMUDGE
example: the fig-style SMUDGE had been defined such
: FIG-SMUDGE LATEST >FFA (SMUDGE#) TOGGLE ;
Name
toolbelt-minus-ext:toolbelt::environment — ordinary constant
Description
( 1999 ) constant TOOLBELT-EXT
an ordinary constant (no special usage info)
Name
tools-minus-ext:tools::environment — ordinary constant
Synopsis
ENVIRONMENT
TOOLS-EXT
( .. )(
)
;
as:"tools-minus-ext";
Description
( 1994 ) constant TOOLS-EXT
an ordinary constant (no special usage info)
Name
topmost:misc — ordinary primitive
Synopsis
FORTH
TOPMOST
( wid -- a-addr )(
)
;
p4:"topmost";
Description
that last valid word in the specified vocabulary
Name
touch:shell.1 — compiling primitive
Synopsis
EXTENSIONS
TOUCH
( .. )(
)
;
as:"touch";
Description
compiling primitive TOUCH
an executable word (no special usage info)
or wrapper call around p4_touch
Name
toupper:forth_usual — ordinary primitive
Synopsis
FORTH
TOUPPER
( c1 -- c2 )(
)
;
p4:"toupper";
Description
convert a single character to upper case
: TOUPPER >R _toupper ;
Name
dash-trailing:string — ordinary primitive
Synopsis
FORTH
-TRAILING
( str-ptr str-len -- str-ptr str-len' )( | ) ; | |
Description
check the given buffer if it contains whitespace at its end.
If so, shorten str-len to meet the last non-whitespace
character in the buffer.
Name
trim:toolbelt — ordinary primitive
Synopsis
FORTH
TRIM
( str len -- str len-i )(
)
;
p4:"trim";
Description
Trim white space from end of string.
: TRIM
BEGIN DUP WHILE
1- 2DUP + C@ IS-WHITE NOT
UNTIL 1+ THEN ;
Name
true:core.1 — ordinary constant
Description
( P4_TRUE ) constant TRUE
an ordinary constant (no special usage info)
Name
tuck:core — ordinary primitive
Synopsis
FORTH
TUCK
( a b -- b a b )(
)
;
p4:"tuck";
Description
shove the top-value under the value beneath. See OVER
and NIP
simulate: : TUCK SWAP OVER ;
Name
str-tuck:dstrings — ordinary primitive
Synopsis
FORTH
$TUCK
($: a$ b$ -- b$ a$ b$ )( | ) ; | |
Description
Copy the top string stack item just below the second item. The
string value is not copied. <ansref>"string-tuck"</ansref>
NOTE: Because of essential string space bookkeeping, the
system level implementation can be little more efficient than
the high-level definition:
: $TUCK $SWAP $OVER ;
Name
str-type:dstrings.1 — ordinary primitive
Synopsis
FORTH
$TYPE
( .. )(
)
;
as:"str-type";
Description
ordinary primitive $TYPE
an executable word (no special usage info)
or wrapper call around p4_str_dot
Name
type:core — ordinary primitive
Synopsis
FORTH
TYPE
( string-pointer string-length -- )( | ) ; | |
Description
prints the string-buffer to stdout, see COUNT and EMIT
Name
paren-type:misc.1 — ordinary primitive
Synopsis
FORTH
(TYPE)
( .. )(
)
;
as:"paren-type";
Description
ordinary primitive (TYPE)
an executable word (no special usage info)
or wrapper call around p4_paren_type
Name
star-type-star:misc.1 — threadstate variable
Synopsis
FORTH
*TYPE*
( .. )(
)
;
as:"star-type-star";
Description
threadstate variable *TYPE*
type (no special usage info)
Name
u-dot:core.1 — ordinary primitive
Description
ordinary primitive U.
an executable word (no special usage info)
or wrapper call around p4_u_dot
Name
u-dot-r:core — ordinary primitive
Synopsis
FORTH
U.R
( value prec -- )(
)
;
p4:"u-dot-r";
Description
print right-aligned in a prec-field, treat value to
be unsigned as opposed to .R
Name
u-less-than:core — ordinary primitive
Synopsis
FORTH
U<
( a b -- cond )(
)
;
p4:"u-less-than";
Description
unsigned comparison, see <
Name
u-less-equal:core_misc — ordinary primitive
Synopsis
FORTH
U<=
( a b -- flag )(
)
;
p4:"u-less-equal";
Description
simulate : U<= U> 0= ;
Name
u-greater-than:core — ordinary primitive
Synopsis
FORTH
U>
( a b -- ab )(
)
;
p4:"u-greater-than";
Description
unsigned comparison of a and b, see >
Name
u-greater-equal:core_misc — ordinary primitive
Synopsis
FORTH
U>=
( a b -- flag )(
)
;
p4:"u-greater-equal";
Description
simulate : U>= U< 0= ;
Name
u-d-dot:misc — ordinary primitive
Synopsis
FORTH
UD.
( 2val -- )(
)
;
p4:"u-d-dot";
Description
see also UD.R
Name
u-d-dot-r:misc — ordinary primitive
Synopsis
FORTH
UD.R
( 2val r -- )(
)
;
p4:"u-d-dot-r";
Name
getuid:shell — ordinary primitive
Synopsis
EXTENSIONS
$UID
( -- val )(
)
;
p4:"getuid";
Description
calls system's
getuid
Name
u-m-star:core — ordinary primitive
Synopsis
FORTH
UM*
( a b -- c,c )(
)
;
p4:"u-m-star";
Description
unsigned multiply returning double-cell value
Name
u-m-slash-mod:core — ordinary primitive
Synopsis
FORTH
UM/MOD
( a b -- c,c )(
)
;
p4:"u-m-slash-mod";
Name
umask:shell — ordinary primitive
Synopsis
EXTENSIONS
UMASK
( val -- ret )(
)
;
p4:"umask";
Description
calls system's
umask
Name
u-max:core_misc — ordinary primitive
Synopsis
FORTH
UMAX
( a b -- max )(
)
;
p4:"u-max";
Name
u-min:core_misc — ordinary primitive
Synopsis
FORTH
UMIN
( a b -- min )(
)
;
p4:"u-min";
Name
undefined:core_misc — immediate primitive
Synopsis
FORTH
[UNDEFINED]
( [name] -- flag )( | ) ; | |
Description
Search the dictionary for _name_. If _name_ is found,
return FALSE; otherwise return TRUE. Immediate for use in
definitions.
see [DEFINED]
: [UNDEFINED] DEFINED 0= ; IMMEDIATE
Name
undefined:toolbelt — immediate primitive
Synopsis
FORTH
[UNDEFINED]
( [name] -- flag )( | ) ; | |
Description
Search the dictionary for _name_. If _name_ is found,
return FALSE; otherwise return TRUE. Immediate for use in
definitions.
see [DEFINED]
: [UNDEFINED] DEFINED 0= ; IMMEDIATE
Name
undefined:tools_misc — immediate primitive
Synopsis
FORTH
[UNDEFINED]
( [name] -- flag )( | ) ; | |
Description
Search the dictionary for _name_. If _name_ is found,
return FALSE; otherwise return TRUE. Immediate for use in
definitions.
see [DEFINED]
: [UNDEFINED] DEFINED 0= ; IMMEDIATE
Name
under-plus:misc — ordinary primitive
Synopsis
FORTH
UNDER+
( n1 n2 -- n1+n2 n2 )( | ) ; | |
Description
quicker than
: UNDER+ TUCK + SWAP ;
Name
dot-underline:term.1 — ordinary primitive
Synopsis
EXTENSIONS
.UNDERLINE
( .. )(
)
;
as:"dot-underline";
Description
ordinary primitive .UNDERLINE
an executable word (no special usage info)
or wrapper call around p4_dot_underline
Name
dot-underline-dot-off:term.1 — ordinary primitive
Description
ordinary primitive .UNDERLINE.OFF
an executable word (no special usage info)
or wrapper call around p4_dot_underline_off
Name
unloop:core — compiling primitive
Synopsis
FORTH
UNLOOP
( -- )(
)
;
p4:"unloop";
Description
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.
Name
unsmudge:header.1 — obsolete forthword
Synopsis
EXTENSIONS
UNSMUDGE
( .. )(
)
;
as:"unsmudge";
Description
obsolete forthword UNSMUDGE
is doing the same as REVEAL
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
until:core — compiling primitive
Synopsis
FORTH
UNTIL
( cond -- )(
)
;
p4:"until";
Description
ends an control-loop, see BEGIN and compare with WHILE
Name
str-unused:dstrings.1 — ordinary primitive
Synopsis
FORTH
$UNUSED
( .. )(
)
;
as:"str-unused";
Description
ordinary primitive $UNUSED
an executable word (no special usage info)
or wrapper call around p4_str_unused
Name
unused:core — ordinary primitive
Synopsis
FORTH
UNUSED
( -- val )(
)
;
p4:"unused";
Description
return the number of cells that are left to be used
above HERE
Name
upc:forth_usual.1 — obsolete forthword
Description
obsolete forthword UPC
is doing the same as TOUPPER
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
update:block — ordinary primitive
Synopsis
FORTH
UPDATE
( -- )(
)
;
p4:"update";
Description
mark the current block buffer as modified,
see FLUSH
Name
upper:forth_usual — ordinary primitive
Synopsis
FORTH
UPPER
( addr cnt -- )(
)
;
p4:"upper";
Description
convert string to upper case
simulate:
: UPPER 0 DO DUP I + DUP C@ UPC SWAP C! LOOP DROP ;
Name
upper-minus-case-question:misc.1 — - loader type P4_DVaL
Description
- loader type P4_DVaL UPPER-CASE?
wordl_flag (no special usage info)
Name
store-use:useful.1 — forthword synonym
Synopsis
EXTENSIONS
!USE
( .. )(
)
;
as:"store-use";
Description
forthword synonym !USE
is doing the same as TRUE
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
uselibrary:dlfcn.1 — ordinary primitive
Synopsis
EXTENSIONS
USELIBRARY
( .. )(
)
;
as:"uselibrary";
Description
ordinary primitive USELIBRARY
an executable word (no special usage info)
or wrapper call around p4_uselibrary
Name
user:shell — ordinary primitive
Synopsis
EXTENSIONS
$USER
( -- str-ptr str-len )(
)
;
p4:"user";
Description
calls system's
getenv(USER)
Name
using:block_misc — ordinary primitive
Synopsis
EXTENSIONS
USING
( 'filename' -- )obsolete( | ) ; | |
Description
use filename as a block file
OBSOLETE!! use OPEN-BLOCKFILE
Name
using-new:block_misc — ordinary primitive
Synopsis
EXTENSIONS
USING-NEW
( 'filename' -- )obsolete( | ) ; | |
Name
value:core — definining primitive
Synopsis
FORTH
VALUE
( value 'name' -- )(
)
;
p4:"value";
Description
CREATE a word and initialize it with value. Using it
later will push the value back onto the stack. Compare with
VARIABLE and CONSTANT - look also for LOCALS| and
VAR
Name
variable:core — definining primitive
Synopsis
FORTH
VARIABLE
( 'name' -- )(
)
;
p4:"variable";
Description
CREATE a new variable, so that everytime the variable is
name, the address is returned for using with @ and !
- be aware that in FIG-forth VARIABLE did take an argument
being the initial value. ANSI-forth does different here.
Name
two-variable:double — definining primitive
Synopsis
FORTH
2VARIABLE
( -- )(
)
;
p4:"two-variable";
Description
CREATE a new variable definition. When executed leave
the >BODY address on stack. In pfe, the data area
of a 2VARIABLE is ERASEd initially.
Name
str-variable:dstrings — ordinary primitive
Synopsis
FORTH
$VARIABLE
( "name" -- )( | ) ; | |
Description
"name" execution: ( -- dfa )
Create an ordinary Forth variable and initialize it to the
address of a fixed, external, measured representation of the
empty string, such as that pushed onto the string stack by
EMPTY$. <ansref>"string-variable"</ansref>"
Name
variant:struct — ordinary primitive
Synopsis
EXTENSIONS
VARIANT
( outer-offset "name" -- outer-offset here zero-offset )( | ) ; | |
Description
Variant records describe an alternative view of the
current record or subrecord from the start to the current point.
The variant need not be of the same length, but the larger is taken
: VARIANT SUBRECORD ;
Name
dot-version:core_misc — ordinary primitive
Synopsis
FORTH
.VERSION
( -- )(
)
;
p4:"dot-version";
Description
show the version of the current PFE system
: .VERSION [ ENVIRONMENT ] FORTH-NAME TYPE FORTH-VERSION TYPE ;
Name
view-next-line:toolbelt — ordinary primitive
Synopsis
FORTH
VIEW-NEXT-LINE
( src . str len -- src . str len str2 len2 )( | ) ; | |
Description
Copy next line above current line.
: VIEW-NEXT-LINE
2OVER 2DUP #EOL-CHAR SCAN NIP - ;
Name
vlist:tools_misc — ordinary primitive
Synopsis
FORTH
VLIST
( -- )(
)
;
p4:"vlist";
Description
The VLIST command had been present in FIG and other forth
implementations. It has to list all accessible words. In PFE
it list all words in the search order. Well, the point is,
that we do really just look into the search order and are
then calling WORDS on that Wordl. That way you can see
all accessible words in the order they might be found.
Uses ?CR
Name
vocabulary:forth_83 — ordinary primitive
Synopsis
FORTH
VOCABULARY
( 'name' -- )(
)
;
p4:"vocabulary";
Description
create a vocabulary of that name. If the named vocabulary
is called later, it will run ((VOCABULARY)) , thereby
putting it into the current search order.
Special pfe-extensions are accessible via
CASE-SENSITIVE-VOC and SEARCH-ALSO-VOC
simulate:
: VOCABULARY CREATE ALLOT-WORDLIST
DOES> ( the ((VOCABULARY)) runtime )
CONTEXT !
; IMMEDIATE
Name
vocabulary:forth_usual — ordinary primitive
Synopsis
FORTH
VOCABULARY
( 'name' -- )(
)
;
p4:"vocabulary";
Description
create a vocabulary of that name. If the named vocabulary
is called later, it will run ((VOCABULARY)) , thereby
putting it into the current search order.
Special pfe-extensions are accessible via
CASE-SENSITIVE-VOC and SEARCH-ALSO-VOC
simulate:
: VOCABULARY CREATE ALLOT-WORDLIST
DOES> ( the ((VOCABULARY)) runtime )
CONTEXT !
; IMMEDIATE
Name
vocabulary:toolbelt — ordinary primitive
Synopsis
FORTH
VOCABULARY
( 'name' -- )(
)
;
p4:"vocabulary";
Description
create a vocabulary of that name. If the named vocabulary
is called later, it will run ((VOCABULARY)) , thereby
putting it into the current search order.
Special pfe-extensions are accessible via
CASE-SENSITIVE-VOC and SEARCH-ALSO-VOC
simulate:
: VOCABULARY CREATE ALLOT-WORDLIST
DOES> ( the ((VOCABULARY)) runtime )
CONTEXT !
; IMMEDIATE
Name
vocabulary-tick:useful.1 — obsolete forthword
Synopsis
EXTENSIONS
VOCABULARY'
( .. )(
)
;
as:"vocabulary-tick";
Description
obsolete forthword VOCABULARY'
is doing the same as [VOCABULARY]
This word should be replaced. It will be deleted in the near future. Instead use the (newer) synonym word given above.
Name
bracket-vocabulary:useful — ordinary primitive
Synopsis
EXTENSIONS
[VOCABULARY]
( "name" -- )( | ) ; | |
Description
create an immediate vocabulary. Provides for basic
modularization.
: [VOCABULARY] VOCABULARY IMMEDIATE ;
Name
vocs:forth_usual — ordinary primitive
Description
list all vocabularies in the system
simulate:
: VOCS VOC-LINK @ BEGIN DUP WHILE
DUP ->WORDLIST.NAME @ ID.
->WORDLIST.LINK @
REPEAT DROP ;
Name
bracket-void:core_misc.1 — immediate constant
Synopsis
FORTH
[VOID]
( .. )(
)
;
as:"bracket-void";
Description
( 0 ) constant [VOID]
an immediate constant (no special usage info)
Name
bracket-void:toolbelt.1 — immediate constant
Synopsis
FORTH
[VOID]
( .. )(
)
;
as:"bracket-void";
Description
( 0 ) constant [VOID]
an immediate constant (no special usage info)
Name
bracket-void:tools_misc.1 — immediate constant
Synopsis
FORTH
[VOID]
( .. )(
)
;
as:"bracket-void";
Description
( 0 ) constant [VOID]
an immediate constant (no special usage info)
Name
w-store:misc — ordinary primitive
Synopsis
FORTH
W!
( w-val addr -- )(
)
;
p4:"w-store";
Description
store a 2byte-val at addressed 2byte-value
Name
w-plus-store:misc — ordinary primitive
Synopsis
FORTH
W+!
( w-val addr -- )(
)
;
p4:"w-plus-store";
Description
add a 2byte-val to addressed 2byte-value
Name
w-slash-o:file.1 — ordinary constant
Synopsis
FORTH
W/O
( .. )(
)
;
as:"w-slash-o";
Description
( FMODE_WO ) constant W/O
an ordinary constant (no special usage info)
Name
w-fetch:misc — ordinary primitive
Synopsis
FORTH
W@
( addr -- w-val )(
)
;
p4:"w-fetch";
Description
fetch a 2byte-val from address
Name
warranty:core_misc — ordinary primitive
Synopsis
FORTH
WARRANTY
( -- )(
)
;
p4:"warranty";
Description
show a warranty info - the basic PFE system is licensed under the terms
of the LGPL (Lesser GNU Public License) - which exludes almost any
liabilities whatsoever - however loadable binary modules may hook into
the system and their functionality may have different WARRANTY infos.
Name
slash-wchar:useful.1 — ordinary constant
Synopsis
EXTENSIONS
/WCHAR
( .. )(
)
;
as:"slash-wchar";
Description
( sizeof(short) ) constant /WCHAR
an ordinary constant (no special usage info)
Name
wchar-percent:struct.1 — ordinary primitive
Synopsis
EXTENSIONS
WCHAR%
( .. )(
)
;
as:"wchar-percent";
Description
ordinary primitive WCHAR%
an executable word (no special usage info)
or wrapper call around p4_wchar_mod
Name
wchar-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
WCHAR:
( .. )(
)
;
as:"wchar-colon";
Description
ordinary primitive WCHAR:
an executable word (no special usage info)
or wrapper call around p4_wchar_colon
Name
wchars-colon:structs.1 — ordinary primitive
Synopsis
EXTENSIONS
WCHARS:
( .. )(
)
;
as:"wchars-colon";
Description
ordinary primitive WCHARS:
an executable word (no special usage info)
or wrapper call around p4_wchars_colon
Name
while:core — compiling primitive
Synopsis
FORTH
WHILE
( cond -- )(
)
;
p4:"while";
Description
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)
Name
sharp-with-minus-fig:useful.1 — ordinary constant
Description
( PFE_WITH_FIG+100 ) constant #WITH-FIG
an ordinary constant (no special usage info)
Name
sharp-with-minus-no-minus-ffa:useful.1 — ordinary constant
Description
( WITH_NO_FFA+100 ) constant #WITH-NO-FFA
an ordinary constant (no special usage info)
Name
within:core — ordinary primitive
Synopsis
FORTH
WITHIN
( a b c -- cond )(
)
;
p4:"within";
Description
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
Name
wl-hash:misc — ordinary primitive
Synopsis
FORTH
WL-HASH
( c-addr n1 -- n2 )(
)
;
p4:"wl-hash";
Description
calc hash-code for selection of thread
in a threaded-vocabulary
Name
word:core — ordinary primitive
Synopsis
FORTH
WORD
( delimiter-char -- here-addr )( | ) ; | |
Description
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.
Name
to-wordlist:forth_usual — ordinary primitive
Synopsis
EXTENSIONS
>WORDLIST
( xt -- wordl* )( | ) ; | |
Description
convert a VOCABULARY-xt into its wordlist reference
(as in win32forth)
Name
wordlist:search — ordinary primitive
Synopsis
FORTH
WORDLIST
( -- voc )(
)
;
p4:"wordlist";
Description
return a new vocabulary-body for private definitions.
Name
dot-words:chainlist — ordinary primitive
Synopsis
EXTENSIONS
.WORDS
( wordlist* -- )(
)
;
p4:"dot-words";
Name
words:tools — ordinary primitive
Synopsis
FORTH
WORDS
( -- )(
)
;
p4:"words";
Description
uses CONTEXT and lists the words defined in that vocabulary.
usually the vocabulary to list is named directly in before.
example:
FORTH WORDS or LOADED WORDS
Name
write-file:file — ordinary primitive
Synopsis
FORTH
WRITE-FILE
( str-adr str-len file -- code )( | ) ; | |
Description
write characters from the string buffer to a file,
returns a status code.
Name
write-line:file — ordinary primitive
Synopsis
FORTH
WRITE-LINE
( str-adr str-len file -- code )( | ) ; | |
Description
write characters from the string buffer to a file,
and add the line-terminator to the end of it.
returns a status code.
Name
wsize:misc.1 — forthword synonym
Synopsis
FORTH
WSIZE
( .. )(
)
;
as:"wsize";
Description
forthword synonym WSIZE
is doing the same as /CELL
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
x-quote:useful — compiling primitive
Synopsis
EXTENSIONS
X"
( "hex-q" -- bstring )(
)
;
p4:"x-quote";
Description
places a counted string on stack
containing bytes specified by hex-string
- the hex string may contain spaces which will delimit the bytes
example:
X" 41 42 4344" COUNT TYPE ( shows ABCD )
Name
xdo-minus-chain:chain.1 — forthword synonym
Synopsis
EXTENSIONS
xdo-chain
( .. )(
)
;
as:"xdo-minus-chain";
Description
forthword synonym xdo-chain
is doing the same as do-chain
this word is provided only for compatibility with common forth usage in programs. Thegiven synonym should be preferred however.
Name
xmax:term.1 — threadstate variable
Description
threadstate variable XMAX
xmax (no special usage info)
Name
xor:core — ordinary primitive
Synopsis
FORTH
XOR
( a b -- ab )(
)
;
p4:"xor";
Description
return the bitwise-or of the two arguments - it may be unsafe
use it on logical values. beware.
Name
question-xy:term — ordinary primitive
Synopsis
EXTENSIONS
?XY
( -- x y )(
)
;
p4:"question-xy";
Description
returns the cursor position on screen, on a real unix system
this includes a special call to the screen driver, in remote
systems this can be the expected position as seen on the
client side's terminal driver.
Name
ymax:term.1 — threadstate variable
Description
threadstate variable YMAX
ymax (no special usage info)
Name
z-quote:zchar — compiling primitive
Synopsis
FORTH
Z"
( [chars<">] -- z* )(
)
;
p4:"z-quote";
Description
scan the input to the next doublequote and create a buffer
that holds the chars - return the address of that zero-terminated
string-buffer, either A'POCKET or ALLOTed into the dictionary.
Name
zchar-minus-ext:zchar::environment — ordinary constant
Synopsis
ENVIRONMENT
ZCHAR-EXT
( .. )(
)
;
as:"zchar-minus-ext";
Description
( 2000 ) constant ZCHAR-EXT
an ordinary constant (no special usage info)
Name
zcount:zchar — ordinary primitive
Synopsis
FORTH
ZCOUNT
( z* -- z* len )(
)
;
p4:"zcount";
Description
push length of z-string, additionally to the string addr itself.
: ZSTRLEN ZCOUNT NIP ;
(see libc strlen(3)) / compare with COUNT / ZSTRLEN
Name
zmove:zchar — ordinary primitive
Synopsis
FORTH
ZMOVE
( zsrc* zdest* -- )(
)
;
p4:"zmove";
Description
copy a zero terminated string
(see libc strcpy(3)) / compare with ZSTRLEN / COUNT
Name
plus-zplace:zchar.1 — ordinary primitive
Synopsis
FORTH
+ZPLACE
( .. )(
)
;
as:"plus-zplace";
Description
ordinary primitive +ZPLACE
an executable word (no special usage info)
or wrapper call around p4_appendz
Name
zplace:zchar — ordinary primitive
Synopsis
FORTH
ZPLACE
( addr* len zaddr* -- )( | ) ; | |
Description
copy string and place as 0 terminated
(see libc strncpy(3)) / see also +ZPLACE / Z+PLACE
Name
zstrlen:zchar — ordinary primitive
Synopsis
FORTH
ZSTRLEN
( z* -- len )(
)
;
p4:"zstrlen";
Description
push length of z-string.
: ZSTRLEN ZCOUNT NIP ;
(see libc strlen(3)) / compare with ZMOVE / CMOVE
Name
z-backslash-quote:zchar.1 — compiling primitive
Synopsis
FORTH
Z\"
( .. )(
)
;
as:"z-backslash-quote";
Description
compiling primitive Z\"
an executable word (no special usage info)
or wrapper call around p4_z_backslash_quote