PFE 0.33.71

Homepage
SourceForge
Download
Documentation
-Overview
-The PFE Manual
old manual / (book)
-ChangeLog
-Authors
-License (LGPL)
-Wordsets / (book)
-Functions .. (book)
-Dp of ANS Forth
-The 4thTutor
-Forthprimer.pdf
- Old Wordsets
- Old Words List
Forth Links
* Forth Repository
* Taygeta Compilation
* TinyBoot FirmWare
* FiCL, Free Forth
* Research Vienna
* Research Bournemouth
* zForth WebRing
Other Links
* Tektronix/MPT
* Forth Org. (FIG)
* Forth Inc.
* MPE Ltd. Forths
* SF Win32Forth
* PD Win32Forth
* Neil Bawd

generated
(C) Guido U. Draheim
guidod@gmx.de

## Usual

> Forth extensions

`C+!``( n addr -- )``` => `"FORTH"`

  Add the low-order byte of _n_ to the byte at _addr_, removing both from the stack.

  primitive code = [p4_c_plus_store]

`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

  primitive code = [p4_vocabulary]

`BOUNDS``( str len -- str+len str )``` => `"FORTH"`

  Convert _str len_ to range for DO-loop.

        : BOUNDS  ( str len -- str+len str )  OVER + SWAP ;

  primitive code = [p4_bounds]

`OFF!``` => `"FORTH"`

  (no description)

  primitive code = [p4_off_store]

`ON!``( addr -- )``` => `"FORTH"`

  Store -1 at _addr_. Defined in f83 as `ON`. See antonym `OFF!`.

         : ON!  ( addr -- )  -1 SWAP ! ;

  primitive code = [p4_on_store]

`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 ;

  primitive code = [p4_place]

`+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+! ;

  primitive code = [p4_append]

`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! ;

  primitive code = [p4_append_char]

`@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 ;

  primitive code = [p4_fetch_execute]

`?LEAVE``( cond -- )``` => `"FORTH"`

  leave a (innermost) loop if condition is true

  compiling word = [p4_question_leave]

`NOOP``( -- )``` => `"FORTH"`

  do nothing, used as a place-holder where an execution word is needed

  primitive code = [p4_noop]

`RP@``( -- addr )``` => `"FORTH"`

  returns the return stack pointer

        example:
          : R@ RP@ @ ;

  compiling word = [p4_r_p_fetch]

`RP!``( addr -- )``` => `"FORTH"`

  sets the return stack pointer, reverse of `RP@`

  primitive code = [p4_r_p_store]

`SP!``( ... addr -- )``` => `"FORTH"`

  sets the stack pointer, reverse of `SP@`

  primitive code = [p4_s_p_store]

`-ROT``( a b c -- c a b )``` => `"FORTH"`

  inverse of `ROT`

  primitive code = [p4_dash_rot]

`CSET``( n addr -- )``` => `"FORTH"`

  set bits in byte at given address

        simulate:
          : CSET  TUCK @ SWAP OR SWAP ! ;

  primitive code = [p4_c_set]

`CRESET``( n addr -- )``` => `"FORTH"`

  reset bits in byte at given address

        simulate:
          : CRESET  TUCK @ SWAP NOT AND SWAP ! ;

  primitive code = [p4_c_reset]

`CTOGGLE``( n addr -- )``` => `"FORTH"`

  toggle bits in byte at given address

        simulate:
          : CTOGGLE  TUCK @ SWAP XOR SWAP ! ;

  primitive code = [p4_c_toggle]

`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 ;

  primitive code = [p4_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 ;

  primitive code = [p4_three_dup]

`3DROP``( x y z -- )``` => `"FORTH"`

  Drop the top three elements from the stack.

        : 3DROP   DROP 2DROP ;

  primitive code = [p4_three_drop]

`4DUP``( a b c d -- a b c d a b c d )``` => `"FORTH"`

        simulate:
         : 4DUP  4 PICK 4 PICK 4 PICK 4 PICK ;

  primitive code = [p4_four_dup]

`4DROP``( x y z -- )``` => `"FORTH"`

  Drop the top three elements from the stack.

        : 4DROP   2DROP 2DROP ;

  primitive code = [p4_four_drop]

`TOUPPER``( c1 -- c2 )``` => `"FORTH"`

  convert a single character to upper case

          : TOUPPER  >R _toupper ;

  primitive code = [p4_toupper]

`UPPER``( addr cnt -- )``` => `"FORTH"`

  convert string to upper case

        simulate:
          : UPPER  0 DO  DUP I +  DUP C@ UPC SWAP C!  LOOP  DROP ;

  primitive code = [p4_upper]

`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 ;

  primitive code = [p4_lower]

`ASCII``( [word] -- val )``` => `"FORTH"`

  state smart version of `CHAR` or `[CHAR]` resp.

        simulate:
          : ASCII  [COMPILE] [CHAR]
                   STATE @ IF [COMPILE] LITERAL THEN ;

  compiling word = [p4_ascii]

`CONTROL``( [word] -- val )``` => `"FORTH"`

  see `ASCII`, but returns char - '@'

        simulate:
          : CONTROL  [COMPILE] [CHAR]  [CHAR] @ -
                     STATE @ IF [COMPILE] LITERAL THEN ;

  compiling word = [p4_control]

`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 .

  primitive code = [p4_number_question]

`VOCS``( -- )``` => `"FORTH"`

  list all vocabularies in the system

        simulate:
          : VOCS VOC-LINK @ BEGIN DUP WHILE
                                  DUP ->WORDLIST.NAME @ ID.
                                  ->WORDLIST.LINK @
                            REPEAT DROP ;

  primitive code = [p4_vocs]

`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 ;

  primitive code = [p4_emits]

`FILE-CHECK``( n -- )``` => `"FORTH"`

  Check for file access error.

        \ : FILE-CHECK    ( n -- )  THROW ;
        : FILE-CHECK      ( n -- )  ABORT" File Access Error " ;

  primitive code = [p4_file_check]

`MEMORY-CHECK``( n -- )``` => `"FORTH"`

  Check for memory allocation error.

        \ : MEMORY-CHECK  ( n -- )  THROW ;
        : MEMORY-CHECK    ( n -- )  ABORT" Memory Allocation Error " ;

  primitive code = [p4_memory_check]

`++``( addr -- )``` => `"FORTH"`

  Increment the value at _addr_.

        : ++  ( addr -- )  1 SWAP +! ;

  primitive code = [p4_plus_plus]

`@++``( addr -- addr' x )``` => `"FORTH"`

  Fetch the value _x_ from _addr_, and increment the address by one cell.

        : @++  ( addr -- addr' x )  DUP CELL+ SWAP  @ ;

  primitive code = [p4_fetch_plus_plus]

`!++``( addr x -- addr' )``` => `"FORTH"`

  Store the value _x_ into _addr_, and increment the address by one cell.

        : !++  ( addr x -- addr' )  OVER !  CELL+ ;

  primitive code = [p4_store_plus_plus]

`>WORDLIST``( xt -- wordl* )``` => `"EXTENSIONS"`

  convert a `VOCABULARY`-xt into its wordlist reference (as in win32forth)

  primitive code = [p4_to_wordlist]