The Core Wordset contains the most of the essential words for ANS Forth.
! ( val addr -- )
# ( n.n -- n.n' )
#> ( n.n -- str-addr str-len )
#S ( n.n -- n.n )
f
' name ( -- xt )
( comment) ( -- )
* ( a b -- a*b )
*\/ ( a b c -- a*b/c )
*\/MOD ( a b c -- m n )
+ ( a b -- a+b )
+! ( val addr -- )
+LOOP ( increment -- )
, ( val -- )
- ( a b -- a-b )
. ( val -- )
." string" ( -- )
/ ( a b -- a/b )
/MOD ( a b -- m n )
0< ( val -- cond )
0= ( val -- cond )
1+ ( val -- val+1 )
1- ( val -- val-1 )
2! ( a,a addr -- )
2* ( a -- a*2 )
2/ ( a -- a/2 )
2@ ( addr -- a,a )
2DROP ( a b -- )
2DUP ( a,a -- a,a a,a )
2OVER ( a,a b,b -- a,a b,b a,a )
2SWAP ( a,a b,b -- b,b a,a )
: name ( -- )
; ( -- )
< ( a b -- cond )
<# ( -- )
= ( a b -- cond )
> ( a b -- cond )
>BODY ( addr -- addr' )
>IN
>NUMBER ( a,a str-adr str-len -- a,a' str-adr' str-len)
>R ( value -- )
?DUP ( value -- value|[nothing] )
@ ( addr -- value )
ABORT ( -- )
no-return
ABORT" what" ( -- )
no-return
ABS ( value -- value' )
ACCEPT ( a n -- n' )
ALIGN ( -- )
ALIGNED ( addr -- addr' )
ALLOT ( count -- )
AND ( val mask -- val' )
BASE
BEGIN ( -- ) compie-time: ( -- cs-marker )
C! ( value address -- )
C, ( value -- )
C@ ( addr -- value )
CELL+ ( value -- value' )
CELLS ( value -- value' )
CHAR a ( -- value )
CHAR+ ( value -- value' )
CHARS ( value -- value' )
CONSTANT name ( value -- )
COUNT ( counted-string -- string-pointer string-length )
CR ( -- )
CREATE name ( -- )
DECIMAL ( -- )
DEPTH ( -- value )
DO .. LOOP ( end start -- )
DOES> ( -- pfa )
DROP ( a -- )
DUP ( a -- a a )
ELSE ( -- )
EMIT ( char -- )
ENVIRONMENT? ( string[str/len] -- false | prop true )
EVALUATE ( str-ptr str-len -- )
EXECUTE ( xt -- )
EXIT ( -- )
FILL ( mem-addr mem-length char -- )
FIND ( bstring -- cfa|bstring -1|0|1 )
FM/MOD ( n1.n1 n2 -- m n )
HERE ( -- dp-value )
HOLD ( char -- )
I ( -- value )
IF .. THEN ( value -- )
IMMEDIATE ( -- )
INVERT ( value -- value' )
J ( -- value )
KEY ( -- char )
LEAVE ( -- )
LITERAL ( value -- )
LOOP ( -- )
LSHIFT ( value shift-val -- value' )
M* ( a b -- m,m )
MAX ( a b -- c )
MIN ( a b -- c )
MOD ( a b -- c )
MOVE ( from to length -- )
NEGATE ( value -- value' )
OR ( a b -- ab )
OVER ( a b -- a b a )
POSTPONE word ( -- )
QUIT ( -- )
no-return
R> ( -- value )
R@ ( -- value )
RECURSE ( ? -- ? )
REPEAT ( -- )
ROT ( a b c -- b c a )
RSHIFT ( value shift-val -- value' )
S" string" ( -- string-address string-length)
S>D ( a -- a,a' )
SIGN ( a -- )
SM/REM ( a.a b -- c d )
SOURCE ( -- buffer IN-offset )
SPACE ( -- )
SPACES ( n -- )
STATE
SWAP ( a b -- b a )
THEN ( -- )
TYPE ( string-pointer string-length -- )
U. ( value )
U< ( a b -- cond )
UM* ( a b -- c,c )
UM/MOD ( a b -- c,c )
UNLOOP ( -- )
UNTIL ( cond -- )
VARIABLE name ( -- )
WHILE ( cond -- )
WORD ( delimiter-char -- )
XOR ( a b -- ab )
[ ( -- )
['] name ( -- )
immediate
[CHAR] charword ( -- char )
] ( -- )
#TIB
.( message) ( -- )
.R ( val prec -- )
0<> ( value -- cond )
0> ( value -- cond )
2>R ( a,a -- )
2R> ( -- a,a )
2R@ ( -- a,a )
:NONAME ( -- cs.value )
<>
?DO .. LOOP ( end start -- )
AGAIN ( -- )
C" string" ( -- bstring )
CASE ( comp-value -- comp-value )
COMPILE, ( xt -- )
CONVERT ( a b -- a b )
ENDCASE ( comp-value -- )
ENDOF ( -- )
ERASE
EXPECT ( str-adr str-len -- )
FALSE
HEX ( -- )
MARKER name
NIP ( a b -- b )
OF .. ENDOF ( comp-value case-value -- comp-value )
PAD ( -- addr )
PARSE ( buffer-start buffer-count delim-char -- )
PICK ( n -- value )
QUERY
REFILL ( -- flag )
RESTORE-INPUT ( xn ... x1 -- )
ROLL ( xn xm ... x1 n -- xm ... x1 xn )
SAVE-INPUT ( -- xn .. x1 )
SOURCE-ID
SPAN
TIB
TO name ( value -- )
TRUE
TUCK ( a b -- b a b )
U.R ( value prec -- )
U> ( a b -- ab )
UNUSED ( -- val )
VALUE name ( value -- )
WITHIN ( a b c -- cond )
[COMPILE] word ( -- )
\ comment ( -- )
ENVIRONMENT?? ( -- )
" string" ( -- bstring ) or sometimes ( -- string-ptr string-count )
! ( val addr -- )
reference: p4_store in ../src/core.c:0116, export CO !
# ( n.n -- n.n' )
HOLD
PRINTF
BASE
<#
#>
reference: p4_sh in ../src/core.c:0129, export CO #
#> ( n.n -- str-addr str-len )
HOLD
PRINTF
reference: p4_sh_greater in ../src/core.c:0140, export CO #>
#S ( n.n -- n.n )
f HOLD
PRINTF
#
<#
#>
reference: p4_sh_s in ../src/core.c:0153, export CO #S
' name ( -- xt )
[']
'>
reference: p4_tick in ../src/core.c:0168, export CO '
( comment) ( -- )
reference: p4_paren in ../src/core.c:0177, export CI (
* ( a b -- a*b )
reference: p4_star in ../src/core.c:0197, export CO *
*\/ ( a b c -- a*b/c )
*
/
reference: p4_star_slash in ../src/core.c:0209, export CO */
*\/MOD ( a b c -- m n )
*
/MOD
reference: p4_star_slash_mod in ../src/core.c:0222, export CO */MOD
+ ( a b -- a+b )
reference: p4_plus in ../src/core.c:0231, export CO +
+! ( val addr -- )
simulate: : +! TUCK @ + SWAP ! ;
reference: p4_plus_store in ../src/core.c:0242, export CO +!
+LOOP ( increment -- )
((+LOOP))
DO
LOOP
reference: p4_plus_loop in ../src/core.c:0268, export CS +LOOP
, ( val -- )
simulate: : , DP 1 CELLS DP +! ! ;
reference: p4_comma in ../src/core.c:0282, export CO ,
- ( a b -- a-b )
reference: p4_minus in ../src/core.c:0290, export CO -
. ( val -- )
BASE
reference: p4_dot in ../src/core.c:0299, export CO .
." string" ( -- )
reference: p4_dot_quote in ../src/core.c:0319, export CS ."
/ ( a b -- a/b )
reference: p4_slash in ../src/core.c:0337, export CO /
/MOD ( a b -- m n )
reference: p4_slash_mod in ../src/core.c:0348, export CO /MOD
0< ( val -- cond )
simulate: : 0< 0 < ;
reference: p4_zero_less in ../src/core.c:0358, export CO 0<
0= ( val -- cond )
simulate: : 0= 0 = ;
reference: p4_zero_equal in ../src/core.c:0368, export CO 0=
1+ ( val -- val+1 )
simulate: : 1+ 1 + ;
reference: p4_one_plus in ../src/core.c:0378, export CO 1+
1- ( val -- val-1 )
simulate: : 1- 1 - ;
reference: p4_one_minus in ../src/core.c:0388, export CO 1-
2! ( a,a addr -- )
reference: p4_two_store in ../src/core.c:0396, export CO 2!
2* ( a -- a*2 )
simulate: : 2* 2 * ; ( canonic) : 2* 1 LSHIFT ; ( usual)
reference: p4_two_star in ../src/core.c:0408, export CO 2*
2/ ( a -- a/2 )
simulate: : 2/ 2 / ; ( canonic) : 2/ 1 RSHIFT ; ( usual)
reference: p4_two_slash in ../src/core.c:0419, export CO 2/
2@ ( addr -- a,a )
reference: p4_two_fetch in ../src/core.c:0427, export CO 2@
2DROP ( a b -- )
reference: p4_two_drop in ../src/core.c:0437, export CO 2DROP
2DUP ( a,a -- a,a a,a )
simulate: : 2DUP OVER OVER ; ( wrong would be : 2DUP DUP DUP ; !!)
reference: p4_two_dup in ../src/core.c:0448, export CO 2DUP
2OVER ( a,a b,b -- a,a b,b a,a )
OVER
2DUP
simulate: : 2OVER SP@ 2 CELLS + 2@ ;
reference: p4_two_over in ../src/core.c:0460, export CO 2OVER
2SWAP ( a,a b,b -- b,b a,a )
SWAP
2DUP
simulate: : 2SWAP LOCALS| B1 B2 A1 A2 | B2 B1 A2 A1 ;
reference: p4_two_swap in ../src/core.c:0472, export CO 2SWAP
: name ( -- )
;
EXIT
reference: p4_colon in ../src/core.c:0499, export CO :
; ( -- )
((;))
EXIT
:
:NONAME
reference: p4_semicolon in ../src/core.c:0523, export CS ;
< ( a b -- cond )
reference: p4_less_than in ../src/core.c:0543, export CO <
<# ( -- )
HOLD
PRINTF
reference: p4_less_sh in ../src/core.c:0554, export CO <#
= ( a b -- cond )
reference: p4_equals in ../src/core.c:0562, export CO =
> ( a b -- cond )
reference: p4_greater_than in ../src/core.c:0571, export CO >
>BODY ( addr -- addr' )
reference: p4_to_body in ../src/core.c:0583, export CO >BODY
>IN
no documentation available (input.to_in)
reference: input.to_in in ../src/core.c:2622, export DV >IN
>NUMBER ( a,a str-adr str-len -- a,a' str-adr' str-len)
BASE
reference: p4_to_number in ../src/core.c:0592, export CO >NUMBER
>R ( value -- )
DO
WHILE
R>
R@
>R
reference: p4_to_r in ../src/core.c:0610, export CO >R
?DUP ( value -- value|[nothing] )
DROP
example: : XX BEGIN ?DUP WHILE DUP . 2/ REPEAT ; instead of : XX BEGIN DUP WHILE DUP . 2/ REPEAT DROP ;
reference: p4_Q_dup in ../src/core.c:0628, export CO ?DUP
@ ( addr -- value )
reference: p4_fetch in ../src/core.c:0637, export CO @
ABORT ( -- )
no-returnreference: p4_abort in ../src/core.c:0645, export CO ABORT
ABORT" what" ( -- )
no-return ABORT
reference: p4_abort_quote in ../src/core.c:0666, export CS ABORT"
ABS ( value -- value' )
reference: p4_abs in ../src/core.c:0677, export CO ABS
ACCEPT ( a n -- n' )
reference: p4_accept in ../src/core.c:0688, export CO ACCEPT
ALIGN ( -- )
ALIGNED
reference: p4_align in ../src/core.c:0698, export CO ALIGN
ALIGNED ( addr -- addr' )
CELLS
ALIGN
reference: p4_aligned in ../src/core.c:0710, export CO ALIGNED
ALLOT ( count -- )
CREATE
VARIABLE
VALUE
CELLS
reference: p4_allot in ../src/core.c:0723, export CO ALLOT
AND ( val mask -- val' )
reference: p4_and in ../src/core.c:0732, export CO AND
BASE
no documentation available (base)
reference: base in ../src/core.c:2635, export DV BASE
BEGIN ( -- ) compie-time: ( -- cs-marker )
WHILE
REPEAT
reference: p4_begin in ../src/core.c:0741, export CS BEGIN
C! ( value address -- )
!
reference: p4_c_store in ../src/core.c:0752, export CO C!
C, ( value -- )
,
reference: p4_c_comma in ../src/core.c:0762, export CO C,
C@ ( addr -- value )
@
reference: p4_c_fetch in ../src/core.c:0770, export CO C@
CELL+ ( value -- value' )
CELLS
reference: p4_cell_plus in ../src/core.c:0779, export CO CELL+
CELLS ( value -- value' )
ALLOT
reference: p4_cells in ../src/core.c:0789, export CO CELLS
CHAR a ( -- value )
reference: p4_char in ../src/core.c:0798, export CO CHAR
CHAR+ ( value -- value' )
CHARS
reference: p4_char_plus in ../src/core.c:0815, export CO CHAR+
CHARS ( value -- value' )
ALLOT
reference: p4_chars in ../src/core.c:0826, export CO CHARS
CONSTANT name ( value -- )
CREATE
((CONSTANT))
VALUE
reference: p4_constant in ../src/core.c:0847, export CO CONSTANT
COUNT ( counted-string -- string-pointer string-length )
TYPE
reference: p4_count in ../src/core.c:0856, export CO COUNT
CR ( -- )
reference: p4_cr in ../src/core.c:0870, export CO CR
CREATE name ( -- )
((VAR))
DOES>
reference: p4_create in ../src/core.c:0894, export CO CREATE
DECIMAL ( -- )
BASE
simulate: : DECIMAL 10 BASE ! ;
reference: p4_decimal in ../src/core.c:0904, export CO DECIMAL
DEPTH ( -- value )
SP@
CELLS
reference: p4_depth in ../src/core.c:0913, export CO DEPTH
DO .. LOOP ( end start -- )
>R
LOOP
+LOOP
LEAVE
I
reference: p4_do in ../src/core.c:0940, export CS DO
DOES> ( -- pfa )
CREATE
(DOES>)
DOES>
reference: p4_does in ../src/core.c:0981, export CS DOES>
DROP ( a -- )
DUP
reference: p4_drop in ../src/core.c:0993, export CO DROP
DUP ( a -- a a )
=
DROP
reference: p4_dup in ../src/core.c:1003, export CO DUP
ELSE ( -- )
((ELSE))
BRANCH
THEN
IF
reference: p4_else in ../src/core.c:1023, export CS ELSE
EMIT ( char -- )
reference: p4_emit in ../src/core.c:1037, export CO EMIT
ENVIRONMENT? ( string[str/len] -- false | prop true )
reference: p4_environment_query in ../src/core.c:1111, export CO ENVIRONMENT?
EVALUATE ( str-ptr str-len -- )
INTERPRET
SOURCE
reference: p4_evaluate in ../src/core.c:1200, export CO EVALUATE
EXECUTE ( xt -- )
>EXECUTE
simulate: : EXECUTE >R EXIT ;
reference: p4_execute in ../src/core.c:1215, export CO EXECUTE
EXIT ( -- )
:
;
reference: p4_exit in ../src/core.c:1225, export CS EXIT
FILL ( mem-addr mem-length char -- )
reference: p4_fill in ../src/core.c:1239, export CO FILL
FIND ( bstring -- cfa|bstring -1|0|1 )
reference: p4_find in ../src/core.c:1253, export CO FIND
FM/MOD ( n1.n1 n2 -- m n )
reference: p4_f_m_slash_mod in ../src/core.c:1271, export CO FM/MOD
HERE ( -- dp-value )
WORD
simulate: : HERE DP @ ;
reference: p4_here in ../src/core.c:1282, export CO HERE
HOLD ( char -- )
reference: p4_hold in ../src/core.c:1291, export CO HOLD
I ( -- value )
DO
LOOP
reference: p4_i in ../src/core.c:1299, export CO I
IF .. THEN ( value -- )
IF
ELSE
THEN
reference: p4_if in ../src/core.c:1321, export CS IF
IMMEDIATE ( -- )
LATEST
CREATE
reference: p4_immediate in ../src/core.c:1332, export CO IMMEDIATE
INVERT ( value -- value' )
NEGATE
reference: p4_invert in ../src/core.c:1344, export CO INVERT
J ( -- value )
DO
LOOP
I
K
reference: p4_j in ../src/core.c:1355, export CO J
KEY ( -- char )
reference: p4_key in ../src/core.c:1364, export CO KEY
LEAVE ( -- )
DO
LOOP
LOOP
reference: p4_leave in ../src/core.c:1374, export CO LEAVE
LITERAL ( value -- )
: DCELLS [ 2 CELLS ] LITERAL * ; ( will save a multiplication at runtime)
reference: p4_literal in ../src/core.c:1397, export CS LITERAL
LOOP ( -- )
DO
((LOOP))
reference: p4_loop in ../src/core.c:1424, export CS LOOP
LSHIFT ( value shift-val -- value' )
reference: p4_l_shift in ../src/core.c:1436, export CO LSHIFT
M* ( a b -- m,m )
reference: p4_m_star in ../src/core.c:1445, export CO M*
MAX ( a b -- c )
reference: p4_max in ../src/core.c:1453, export CO MAX
MIN ( a b -- c )
reference: p4_min in ../src/core.c:1463, export CO MIN
MOD ( a b -- c )
reference: p4_mod in ../src/core.c:1473, export CO MOD
MOVE ( from to length -- )
reference: p4_move in ../src/core.c:1483, export CO MOVE
NEGATE ( value -- value' )
simulate: : NEGATE -1 * ;
reference: p4_negate in ../src/core.c:1493, export CO NEGATE
OR ( a b -- ab )
AND
reference: p4_or in ../src/core.c:1502, export CO OR
OVER ( a b -- a b a )
TUCK
reference: p4_over in ../src/core.c:1512, export CO OVER
POSTPONE word ( -- )
POSTPONE
COMPILE
[COMPILE]
reference: p4_postpone in ../src/core.c:1536, export CS POSTPONE
QUIT ( -- )
no-return QUERY
EVALUATE
INTERPRET
THROW
reference: p4_quit in ../src/core.c:1558, export CO QUIT
R> ( -- value )
>R
R@
LOCALS|
reference: p4_r_from in ../src/core.c:1571, export CO R>
R@ ( -- value )
>R
LOCALS|
>R
R>
reference: p4_r_fetch in ../src/core.c:1582, export CO R@
RECURSE ( ? -- ? )
RECURSE
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 ;
reference: p4_recurse in ../src/core.c:1599, export CI RECURSE
REPEAT ( -- )
BEGIN
reference: p4_repeat in ../src/core.c:1611, export CS REPEAT
ROT ( a b c -- b c a )
-ROT
LOCALS|
VAR
reference: p4_rot in ../src/core.c:1628, export CO ROT
RSHIFT ( value shift-val -- value' )
reference: p4_r_shift in ../src/core.c:1641, export CO RSHIFT
S" string" ( -- string-address string-length)
C"
"
reference: p4_s_quote in ../src/core.c:1667, export CS S"
S>D ( a -- a,a' )
reference: p4_s_to_d in ../src/core.c:1699, export CO S>D
SIGN ( a -- )
HOLD
reference: p4_sign in ../src/core.c:1709, export CO SIGN
SM/REM ( a.a b -- c d )
/MOD
FM/MOD
UM/MOD
SM/REM
reference: p4_s_m_slash_rem in ../src/core.c:1718, export CO SM/REM
SOURCE ( -- buffer IN-offset )
REFILL
REFILL
reference: p4_source in ../src/core.c:1734, export CO SOURCE
SPACE ( -- )
SPACES
simulate: : SPACE BL EMIT ;
reference: p4_space in ../src/core.c:1749, export CO SPACE
SPACES ( n -- )
SPACE
reference: p4_spaces in ../src/core.c:1759, export CO SPACES
STATE
no documentation available (state)
reference: state in ../src/core.c:2700, export DV STATE
SWAP ( a b -- b a )
reference: p4_swap in ../src/core.c:1767, export CO SWAP
THEN ( -- )
IF
ELSE
reference: p4_then in ../src/core.c:1778, export CS THEN
TYPE ( string-pointer string-length -- )
COUNT
EMIT
reference: p4_type in ../src/core.c:1789, export CO TYPE
U. ( value )
reference: p4_u_dot in ../src/core.c:1797, export CO U.
U< ( a b -- cond )
<
reference: p4_u_less_than in ../src/core.c:1806, export CO U<
UM* ( a b -- c,c )
reference: p4_u_m_star in ../src/core.c:1815, export CO UM*
UM/MOD ( a b -- c,c )
/MOD
SM/REM
reference: p4_u_m_slash_mod in ../src/core.c:1823, export CO UM/MOD
UNLOOP ( -- )
DO
LOOP
EXIT
reference: p4_unloop in ../src/core.c:1835, export CO UNLOOP
UNTIL ( cond -- )
BEGIN
WHILE
reference: p4_until in ../src/core.c:1843, export CS UNTIL
VARIABLE name ( -- )
CREATE
@
!
reference: p4_variable in ../src/core.c:1858, export CO VARIABLE
WHILE ( cond -- )
BEGIN
WHILE
REPEAT
REPEAT
BEGIN
WHILE
REPEAT
UNTIL
BEGIN
UNTIL
reference: p4_while in ../src/core.c:1872, export CS WHILE
WORD ( delimiter-char -- )
SOURCE
>IN
HERE
PARSE
reference: p4_word in ../src/core.c:1889, export CO WORD
XOR ( a b -- ab )
reference: p4_xor in ../src/core.c:1898, export CO XOR
[ ( -- )
,
LITERAL
]
reference: p4_left_bracket in ../src/core.c:1910, export CI [
['] name ( -- )
immediate '
'>
POSTPONE
reference: p4_bracket_tick in ../src/core.c:1921, export CS [']
[CHAR] charword ( -- char )
CHAR
ASCII
reference: p4_bracket_char in ../src/core.c:1935, export CS [CHAR]
] ( -- )
[
,
LITERAL
reference: p4_right_bracket in ../src/core.c:1949, export CO ]
#TIB
no documentation available (input.number_tib)
reference: input.number_tib in ../src/core.c:2719, export DV #TIB
.( message) ( -- )
."
reference: p4_dot_paren in ../src/core.c:1964, export CI .(
.R ( val prec -- )
reference: p4_dot_r in ../src/core.c:1993, export CO .R
0<> ( value -- cond )
AND
XOR
IF
WHILE
reference: p4_zero_not_equals in ../src/core.c:2008, export CO 0<>
0> ( value -- cond )
simulate: : 0> 0 > ;
reference: p4_zero_greater in ../src/core.c:2017, export CO 0>
2>R ( a,a -- )
>R
reference: p4_two_to_r in ../src/core.c:2025, export CO 2>R
2R> ( -- a,a )
R>
2>R
reference: p4_two_r_from in ../src/core.c:2036, export CO 2R>
2R@ ( -- a,a )
2>R
R@
reference: p4_two_r_fetch in ../src/core.c:2047, export CO 2R@
:NONAME ( -- cs.value )
CREATE
;
reference: p4_colon_noname in ../src/core.c:2061, export CO :NONAME
<>
no forth documentation available (p4_not_equals)
reference: p4_not_equals in ../src/core.c:2074, export CO <>
?DO .. LOOP ( end start -- )
DO
reference: p4_Q_do in ../src/core.c:2096, export CS ?DO
AGAIN ( -- )
BEGIN
WHILE
reference: p4_again in ../src/core.c:2109, export CS AGAIN
C" string" ( -- bstring )
POCKET
S"
"
reference: p4_c_quote in ../src/core.c:2133, export CS C"
CASE ( comp-value -- comp-value )
ENDCASE
OF
reference: p4_case in ../src/core.c:2158, export CS CASE
COMPILE, ( xt -- )
,
COMPILE
[COMPILE]
POSTPONE
:NONAME
reference: p4_compile_comma in ../src/core.c:2175, export CO COMPILE,
CONVERT ( a b -- a b )
>NUMBER
reference: p4_convert in ../src/core.c:2183, export CO CONVERT
ENDCASE ( comp-value -- )
CASE
OF
ENDOF
ENDCASE
ENDOF
ENDCASE
reference: p4_endcase in ../src/core.c:2196, export CS ENDCASE
ENDOF ( -- )
OF
ENDCASE
CASE
reference: p4_endof in ../src/core.c:2212, export CS ENDOF
ERASE
no forth documentation available (p4_erase)
reference: p4_erase in ../src/core.c:2224, export CO ERASE
EXPECT ( str-adr str-len -- )
WORD
PARSE
QUERY
in => SPAN - this word is superceded by => ACCEPT
reference: p4_expect in ../src/core.c:2235, export CO EXPECT
FALSE
no documentation available (P4_FALSE)
reference: P4_FALSE in ../src/core.c:2739, export OC FALSE
HEX ( -- )
BASE
simulate: : HEX 16 BASE ! ;
reference: p4_hex in ../src/core.c:2244, export CO HEX
MARKER name
FORGET
reference: p4_marker in ../src/core.c:2262, export CO MARKER
NIP ( a b -- b )
TUCK
simulate: : NIP SWAP DROP ;
reference: p4_nip in ../src/core.c:2271, export CO NIP
OF .. ENDOF ( comp-value case-value -- comp-value )
CASE
ENDOF
ENDCASE
reference: p4_of in ../src/core.c:2294, export CS OF
PAD ( -- addr )
reference: p4_pad in ../src/core.c:2307, export CO PAD
PARSE ( buffer-start buffer-count delim-char -- )
reference: p4_parse in ../src/core.c:2318, export CO PARSE
PICK ( n -- value )
0 PICK -> DUP 1 PICK -> OVER
reference: p4_pick in ../src/core.c:2346, export CO PICK
QUERY
no documentation available (p4_query)
reference: p4_query in ../src/core.c:2747, export CO QUERY
REFILL ( -- flag )
SOURCE
>IN
EVALUATE
reference: p4_refill in ../src/core.c:2359, export CO REFILL
RESTORE-INPUT ( xn ... x1 -- )
SAVE-INPUT
reference: p4_restore_input in ../src/core.c:2367, export CO RESTORE-INPUT
ROLL ( xn xm ... x1 n -- xm ... x1 xn )
ROT
2 ROLL -> ROT
reference: p4_roll in ../src/core.c:2380, export CO ROLL
SAVE-INPUT ( -- xn .. x1 )
RESTORE-INPUT
reference: p4_save_input in ../src/core.c:2394, export CO SAVE-INPUT
SOURCE-ID
no documentation available (input.source_id)
reference: input.source_id in ../src/core.c:2752, export DC SOURCE-ID
SPAN
no documentation available (span)
reference: span in ../src/core.c:2753, export DV SPAN
TIB
no documentation available (input.tib)
reference: input.tib in ../src/core.c:2754, export DC TIB
TO name ( value -- )
VALUE
LOCALS|
reference: p4_to in ../src/core.c:2413, export CS TO
TRUE
no documentation available (P4_TRUE)
reference: P4_TRUE in ../src/core.c:2756, export OC TRUE
TUCK ( a b -- b a b )
OVER
NIP
simulate: : TUCK SWAP OVER ;
reference: p4_tuck in ../src/core.c:2450, export CO TUCK
U.R ( value prec -- )
.R
reference: p4_u_dot_r in ../src/core.c:2462, export CO U.R
U> ( a b -- ab )
>
reference: p4_u_greater_than in ../src/core.c:2472, export CO U>
UNUSED ( -- val )
HERE
reference: p4_unused in ../src/core.c:2482, export CO UNUSED
VALUE name ( value -- )
CREATE
VARIABLE
CONSTANT
LOCALS|
VAR
reference: p4_value in ../src/core.c:2501, export CO VALUE
WITHIN ( a b c -- cond )
reference: p4_within in ../src/core.c:2512, export CO WITHIN
[COMPILE] word ( -- )
IF
COMPILE
POSTPONE
reference: p4_bracket_compile in ../src/core.c:2524, export CI [COMPILE]
\ comment ( -- )
reference: p4_backslash in ../src/core.c:2535, export CI \\
ENVIRONMENT?? ( -- )
LOADED
reference: p4_environment_dump in ../src/core.c:1047, export CO ENVIRONMENT??
" string" ( -- bstring ) or sometimes ( -- string-ptr string-count )
S"
C"
reference: p4_quote in ../src/core.c:2559, export CS "