PFE - Portable Forth Environment - pfe Forth Wordsets

  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]