PFE-SMART Kernel extensions
This wordset is the place to add any additional primitives
you might wish. A set of words do already live here that
must be bound statically into the main pfe-object to
work out smart and nicely.
(IMMEDIATE#) ( -- bit-mask )
returns the bit-mask to check if a found word is immediate
" my-word" FIND IF >FFA C@ (IMMEDIATE#) AND
IF ." immediate" THEN ELSE DROP THEN
reference: p4_immediate_bit in ../src/yours.c:0100, export CO (IMMEDIATE#)
(SMUDGE#) ( -- bit-mask )
returns the bit-mask to check if a found word is smudge
" my-word" FIND IF >FFA C@ (SMUDGE#) AND
IF ." smudge" THEN ELSE DROP THEN
reference: p4_smudge_bit in ../src/yours.c:0110, export CO (SMUDGE#)
>COMPILE ( xt -- )
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
THEN - see also
reference: p4_to_compile in ../src/yours.c:0135, export CO >COMPILE
($ word ( -- cs-token ) compile-only
takes the execution token of the following word and
saves it on the compile-stack. The correspondig closing
) will then feed it into
>COMPILE - so this pair
of word provides you with a prefix-operation syntax
that you may have been seen in lisp-like languages.
($ IF ($ 0= A1 @ )) ($ THEN ." hello " )
Note that an opening simple
( paren is a comment.
reference: p4_prefix_begin in ../src/yours.c:0152, export CI ($
) ( cs-token -- )
takes the execution-token from
($ and compiles
reference: p4_prefix_end in ../src/yours.c:0163, export CI )
@> name ( -- value )
does fetch the value from the PFA of the named item, which
may be about everything, including a
reference: p4_fetch_from in ../src/yours.c:0199, export CS @>
!> name ( value -- )
actually a synonym for
TO but very common amongst
reference: p4_store_to in ../src/yours.c:0696, export CS !>
'> name ( -- xt )
get the execution-token, ie the CFA, of the word following.
This word is fully state-smart while the ANSI standard words
['] are not.
reference: p4_tick_from in ../src/yours.c:0679, export CS '>
INTO word ( -- pfa )
will return the parameter-field address of the following word.
Unlike others, this word will also return the address of
LOCALS| and local
VAR - 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.
reference: p4_into in ../src/yours.c:0733, export CS INTO
VAR name ( -- )
a fully state-smart version, that does either create a
LVALUE and does always initialize it with null - so
LVALUE this word does not take
reference: p4_var in ../src/yours.c:0780, export CS VAR
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
on the rest of the word. This
SMART-INTERPRET-INIT will set up
words like interpret-" so you can write
"hello" instead of
and it creates interpret-\ so that words like
ignoring the line if the word
\if-unknown is unknown in itself.
This is usually not activated on startup.
reference: p4_smart_interpret_init in ../src/yours.c:0298, export CO SMART-INTERPRET-INIT
disables the SMART-INTERPRET extension in
reference: p4_smart_interpret_off in ../src/yours.c:0317, export CO SMART-INTERPRET-OFF
enables the SMART-INTERPRET extension in
SMART-INTERPRET-INIT - the default for smart-interpret
is always off
reference: p4_smart_interpret_on in ../src/yours.c:0327, export CO SMART-INTERPRET-ON
<<CPU>> ( -- )
the goto-cpu feature will vanish. It had been used to create a
multi-forth in a non-threaded environment. This word
creates a number of CPU*-immediates that will switch the
QUIT-interpret loop to use the other cpu's dictionary.
reference: p4_load_cpus in ../src/yours.c:0357, export CX __cpus__
CPU# ( -- )
the goto-cpu feature will vanish. It is used to create a
multi-forth in a non-threaded environment. This word
returns the number of the cpu-dictionary that is
currently in use.
reference: p4_cpu_nr in ../src/yours.c:0379, export CO CPU#
.H2 ( value -- )
print hexadecimal, but with per-byte 0-padding
0x0 -> 00
0xf -> 0f
0x12 -> 12
0x123 -> 0123
0x1234 -> 1234
0x12345 -> 012345
reference: p4_dot_h2 in ../src/yours.c:0523, export CO .H2
PRINTF ( args ... format$ -- )
SPRINTF to print to a temporary 256-char buffer
and prints it to stdout afterwards. See the example
SPRINTF of what it does internally.
reference: p4_printf in ../src/yours.c:0507, export CO PRINTF
SPRINTF ( args ... format$ dest$ -- len-dest )
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
reference: p4_sprintf in ../src/yours.c:0497, export CO SPRINTF
LOADF filename ( -- )
loads a file just like
INCLUDE but does also put
MARKER in the
LOADED dictionary that you can
FORGET on to kill everything being loaded
from that file.
reference: p4_loadf in ../src/yours.c:0552, export CO LOADF
DEFER word ( -- )
create a new word with ((DEFER))-semantics
: DEFER CREATE 0, DOES> ( the ((DEFER)) runtime )
@ ?DUP IF EXECUTE THEN ;
and set as
"['] executionword TO deferword"
reference: p4_defer in ../src/lpf83.c:0386, export CO DOER
MAKE word ... ;AND ( -- )
make a seperated piece of code between
and on execution of the
MAKE the named word is twisted
to point to this piece of code. The word is usually
DOER but the current implementation works
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.
does even work on
VAR but it is uncertain
what that is good for.
reference: p4_make in ../src/yours.c:0617, export CS MAKE
;AND ( -- )
For the code piece between
;AND , this word
will do just an
EXIT . For the code outside of
MAKE construct a branch-around must be resolved then.
reference: p4_semicolon_and in ../src/yours.c:0653, export CS ;AND
[DEFINED] word ( -- nfa|0 ) immediate
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
[IFDEF] word can be simulated through
[DEFINED] word [IF]
reference: p4_bracket_defined in ../src/yours.c:0803, export CI [DEFINED]
[NOT] ( a -- a' )
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
provide semantics of an
[IFNOT]. It is most useful in
conjunction with "
[DEFINED] word" as it the sequence
[DEFINED] word [NOT] [IF]" can simulate "
reference: p4_bracket_not in ../src/yours.c:0821, export CI [NOT]