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

## forth_83 forth wordset page

`2+``( a# -- a#' | a* -- a*' | a -- a' [??] )``[FTH]` => `[FORTH]`

  add 2 to the value on stack (and leave the result there)

        simulate:
          : 2+ 2 + ;

  primitive code = [p4_two_plus]

`2-``( a# -- a#' | a* -- a*' | a -- a' [??] )``[FTH]` => `[FORTH]`

  substract 2 from the value on stack (and leave the result there)

        simulate:
          : 2- 2 - ;

  primitive code = [p4_two_minus]

`?TERMINAL``` => `[FORTH]`

  (no description)

  primitive code = [p4_key_question]

`COMPILE``( "word" -- )``[FTH]` => `[FORTH]`

  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 !!! )

  compiling word = [p4_compile]

`-->``( -- )``[FTH]` => `[FORTH]`

  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`

        : --> ?LOADING REFILL ;

  immediate code = [p4_next_block]

`INTERPRET``` => `[FORTH]`

  (no description)

  primitive code = [p4_interpret]

`K``( -- k# )``[FTH]` => `[FORTH]`

  the 3rd loop index just like `I` and `J`

  compiling word = [p4_k]

`OCTAL``( -- )``[FTH]` => `[FORTH]`

  sets `BASE` to 8. Compare with `HEX` and `DECIMAL`

        simulate:
          : OCTAL  8 BASE ! ;

  primitive code = [p4_octal]

`SP@``( -- sp-cell* )``[FTH]` => `[FORTH]`

  the address of the top of stack. Does save it onto the stack. You could do

          : DUP  SP@ @ ;

  primitive code = [p4_s_p_fetch]

`!BITS``( x-bits# x-addr mask# -- )``[FTH]` => `[FORTH]`

  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 ;

  primitive code = [p4_store_bits]

`@BITS``( x-addr mask# -- x-value# )``[FTH]` => `[FORTH]`

  see the companion word => !BITS

        simulate:
          : @BITS  SWAP @ AND ;

  primitive code = [p4_fetch_bits]

`><``( a -- a' )``[FTH] [OLD]` => `[FORTH]`

  byte-swap a word

  depracated: use `NTOHS` which does the same as this word when the local byte-order seems to have no match, and be otherwise a no-op. Note that only the two lower bytes of the top-of-cell are swapped.

  primitive code = [p4_byte_swap]

`>MOVE<``( from-addr* to-addr* count# -- )``[FTH] [OLD]` => `[FORTH]`

  see `MOVE` , does byte-swap for each word underway.

  depracated: this word has not been very useful lately. It does still stem from times of 16bit forth systems that wanted to interchange data blocks. It is better to use functionality based on `NTOHS` or `NTOHL`. Note that this word `>MOVE<` does swap each 2byte. It is not useful for byte-swapping `WCHAR` strings as the count is given in bytes, not wchar items.

  primitive code = [p4_byte_swap_move]

`**``( a# b# -- power-a# )``[FTH]` => `[FORTH]`

  raise second to top power

  primitive code = [p4_power]

`SEAL``( -- )``[FTH]` => `[FORTH]`

  looks through the search-order and kills the ONLY wordset - hence you can't access the primary vocabularies from there.

  primitive code = [p4_seal]