pfe-forth-usual-ext ? Usual Forth extensions
C+! ( n addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;VOCABULARY ( "name" -- ) ?=>? ( | ) ; | ? |
"FORTH"
;BOUNDS ( str len -- str+len str ) ?=>? ( | ) ; | ? |
"FORTH"
;OFF! ?=>? ( | ) ; | ? |
"FORTH"
;ON! ( addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;PLACE ( str len addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;+PLACE ( str len add2 -- ) ?=>? ( | ) ; | ? |
"FORTH"
;C+PLACE ( char addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;@EXECUTE ( xt -- ? ) ?=>? ( | ) ; | ? |
"FORTH"
;?LEAVE ( cond -- ) ?=>? ( | ) ; | ? |
"FORTH"
;NOOP ( -- ) ?=>? ( | ) ; | ? |
"FORTH"
;RP@ ( -- addr ) ?=>? ( | ) ; | ? |
"FORTH"
;RP! ( addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;SP! ( ... addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;-ROT ( a b c -- c a b ) ?=>? ( | ) ; | ? |
"FORTH"
;CSET ( n addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;CRESET ( n addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;CTOGGLE ( n addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;TOGGLE ( c-addr charmask -- ) ?=>? ( | ) ; | ? |
"FORTH"
;3DUP ( x y z -- x y z x y z ) ?=>? ( | ) ; | ? |
"FORTH"
;3DROP ( x y z -- ) ?=>? ( | ) ; | ? |
"FORTH"
;4DUP ( a b c d -- a b c d a b c d ) ?=>? ( | ) ; | ? |
"FORTH"
;4DROP ( x y z -- ) ?=>? ( | ) ; | ? |
"FORTH"
;TOUPPER ( c1 -- c2 ) ?=>? ( | ) ; | ? |
"FORTH"
;UPPER ( addr cnt -- ) ?=>? ( | ) ; | ? |
"FORTH"
;LOWER ( addr cnt -- ) ?=>? ( | ) ; | ? |
"FORTH"
;ASCII ( [word] -- val ) ?=>? ( | ) ; | ? |
"FORTH"
;CONTROL ( [word] -- val ) ?=>? ( | ) ; | ? |
"FORTH"
;NUMBER? ( addr -- d flag ) ?=>? ( | ) ; | ? |
"FORTH"
;VOCS ( -- ) ?=>? ( | ) ; | ? |
"FORTH"
;EMITS ( n char -- ) ?=>? ( | ) ; | ? |
"FORTH"
;FILE-CHECK ( n -- ) ?=>? ( | ) ; | ? |
"FORTH"
;MEMORY-CHECK ( n -- ) ?=>? ( | ) ; | ? |
"FORTH"
;++ ( addr -- ) ?=>? ( | ) ; | ? |
"FORTH"
;@++ ( addr -- addr' x ) ?=>? ( | ) ; | ? |
"FORTH"
;!++ ( addr x -- addr' ) ?=>? ( | ) ; | ? |
"FORTH"
;>WORDLIST ( xt -- wordl* ) ?=>? ( | ) ; | ? |
"EXTENSIONS"
;
C+! ( n addr -- ) => "FORTH"
Add the low-order byte of _n_ to the byte at _addr_, removing both from the stack.
VOCABULARY ( "name" -- ) [FTH] => "FORTH"
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
BOUNDS ( str len -- str+len str ) => "FORTH"
Convert _str len_ to range for DO-loop.
: BOUNDS ( str len -- str+len str ) OVER + SWAP ;
OFF! - no description, sorry
ON! ( addr -- ) => "FORTH"
Store -1 at _addr_. Defined in f83 as ON
. See antonym OFF!
.
: ON! ( addr -- ) -1 SWAP ! ;
PLACE ( str len addr -- ) => "FORTH"
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 ;
+PLACE ( str len add2 -- ) => "FORTH"
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+! ;
C+PLACE ( char addr -- ) => "FORTH"
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! ;
@EXECUTE ( xt -- ? ) => "FORTH"
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 ;
?LEAVE ( cond -- ) => "FORTH"
leave a (innermost) loop if condition is true
NOOP ( -- ) => "FORTH"
do nothing, used as a place-holder where an execution word is needed
RP@ ( -- addr ) => "FORTH"
returns the return stack pointer
example: : R@ RP@ @ ;
RP! ( addr -- ) => "FORTH"
sets the return stack pointer, reverse of RP@
SP! ( ... addr -- ) => "FORTH"
sets the stack pointer, reverse of SP@
-ROT ( a b c -- c a b ) => "FORTH"
inverse of ROT
CSET ( n addr -- ) => "FORTH"
set bits in byte at given address
simulate: : CSET TUCK @ SWAP OR SWAP ! ;
CRESET ( n addr -- ) => "FORTH"
reset bits in byte at given address
simulate: : CRESET TUCK @ SWAP NOT AND SWAP ! ;
CTOGGLE ( n addr -- ) => "FORTH"
toggle bits in byte at given address
simulate: : CTOGGLE TUCK @ SWAP XOR SWAP ! ;
TOGGLE ( c-addr charmask -- ) => "FORTH"
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 ;
3DUP ( x y z -- x y z x y z ) => "FORTH"
Copy top three elements on the stack onto top of stack.
: 3DUP THIRD THIRD THIRD ;
or
: 3DUP 3 PICK 3 PICK 3 PICK ;
3DROP ( x y z -- ) => "FORTH"
Drop the top three elements from the stack.
: 3DROP DROP 2DROP ;
4DUP ( a b c d -- a b c d a b c d ) => "FORTH"
simulate: : 4DUP 4 PICK 4 PICK 4 PICK 4 PICK ;
4DROP ( x y z -- ) => "FORTH"
Drop the top three elements from the stack.
: 4DROP 2DROP 2DROP ;
TOUPPER ( c1 -- c2 ) => "FORTH"
convert a single character to upper case
: TOUPPER >R _toupper ;
UPPER ( addr cnt -- ) => "FORTH"
convert string to upper case
simulate: : UPPER 0 DO DUP I + DUP C@ UPC SWAP C! LOOP DROP ;
LOWER ( addr cnt -- ) => "FORTH"
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 ;
ASCII ( [word] -- val ) => "FORTH"
state smart version of CHAR
or [CHAR]
resp.
simulate: : ASCII [COMPILE] [CHAR] STATE @ IF [COMPILE] LITERAL THEN ;
CONTROL ( [word] -- val ) => "FORTH"
see ASCII
, but returns char - '@'
simulate: : CONTROL [COMPILE] [CHAR] [CHAR] @ - STATE @ IF [COMPILE] LITERAL THEN ;
NUMBER? ( addr -- d flag ) => "FORTH"
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 .
VOCS ( -- ) => "FORTH"
list all vocabularies in the system
simulate: : VOCS VOC-LINK @ BEGIN DUP WHILE DUP ->WORDLIST.NAME @ ID. ->WORDLIST.LINK @ REPEAT DROP ;
EMITS ( n char -- ) => "FORTH"
Emit _char_ _n_ times.
: EMITS ( n char -- ) SWAP 0 ?DO DUP EMIT LOOP DROP ;
also compare
: SPACES BL EMITS ; : SPACE BL EMIT ;
FILE-CHECK ( n -- ) => "FORTH"
Check for file access error.
\ : FILE-CHECK ( n -- ) THROW ; : FILE-CHECK ( n -- ) ABORT" File Access Error " ;
MEMORY-CHECK ( n -- ) => "FORTH"
Check for memory allocation error.
\ : MEMORY-CHECK ( n -- ) THROW ; : MEMORY-CHECK ( n -- ) ABORT" Memory Allocation Error " ;
++ ( addr -- ) => "FORTH"
Increment the value at _addr_.
: ++ ( addr -- ) 1 SWAP +! ;
@++ ( addr -- addr' x ) => "FORTH"
Fetch the value _x_ from _addr_, and increment the address by one cell.
: @++ ( addr -- addr' x ) DUP CELL+ SWAP @ ;
!++ ( addr x -- addr' ) => "FORTH"
Store the value _x_ into _addr_, and increment the address by one cell.
: !++ ( addr x -- addr' ) OVER ! CELL+ ;
>WORDLIST ( xt -- wordl* ) => "EXTENSIONS"
convert a VOCABULARY
-xt into its wordlist reference
(as in win32forth)