forth-83 definitions

_paren_COMPILE__ : COMPILE word ( )

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

reference: ../src/forth-83.c:0066

_paren_paren_VOCABULARY__ : ((VOCABULARY)) ( -- )

runtime of a VOCABULARY

reference: ../src/forth-83.c:0078

p4_backward_mark_ : <MARK ( -- DP-mark ) compile-only

memorizes the current DP on the CS-STACK used for <RESOLVE later. Useful for creation of compiling words, eg. BEGIN , see AHEAD 
 simulate:
   : <MARK ?COMP  HERE ;

reference: ../src/forth-83.c:0165

p4_backward_resolve_ : <RESOLVE ( DP-mark -- ) compile-only

resolves a previous <MARK , actually pushes the DP-address memorized at BRANCH or ?BRANCH in compiling words like UNTIL 
 simulate:
   : <RESOLVE ?COMP  , ;

reference: ../src/forth-83.c:0179

p4_body_from_ : BODY> ( pfa -- cfa )

converts a pointer to the parameter-field (PFA) to point then to the corresponding code-field (CFA) 
 implementation-specific simulation:
   : BODY> CELL - ;

reference: ../src/forth-83.c:0392

p4_byte_swap_ : >< ( a -- a' )

byte-swap a word

reference: ../src/forth-83.c:0302

p4_byte_swap_move_ : >MOVE< ( from-addr to-addr count -- )

see MOVE , does byte-swap for each word underway

reference: ../src/forth-83.c:0318

p4_case_sensitive_voc_ : CASE-SENSITIVE-VOC ( -- )

accesses CONTEXT which is generally the last named VOCABULARY . sets a flag in the vocabulary-definition so that words are matched case-sensitive. 
 example: 
    VOCABULARY MY-VOC  MY-VOC CASE-SENSITIVE-VOC

reference: ../src/forth-83.c:0109

p4_compile_ : COMPILE word ( )

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

reference: ../src/forth-83.c:0067

p4_else_execution_ : ((ELSE)) ( -- )

execution compiled by ELSE - just a simple BRANCH

reference: ../src/forth-83.c:0156

p4_fetch_bits_ : @BITS ( addr mask -- value )

see the companion word !BITS 
 simulate:
   : @BITS  SWAP @ AND ;

reference: ../src/forth-83.c:0339

p4_ffa_from_ : FFA> ( ffa -- nfa )

converts a pointer to the flag-field (FFA) to point then to the corresponding name-field (NFA) - in traditinal Forth this is the same address. pfe _can_ do different. 
 implementation-specific configure-dependent simulation:
   : FFA  1+ ;

reference: ../src/forth-83.c:0458

p4_forward_mark_ : MARK> ( -- DP-mark ) compile-only

makes room for a pointer in the dictionary to be resolved through RESOLVE> and does therefore memorize that cell's address on the CS-STACK Mostly used after BRANCH or ?BRANCH in compiling words like IF or ELSE 
 simulate:
   : MARK> ?COMP  HERE 0 , ;

reference: ../src/forth-83.c:0198

p4_forward_resolve_ : RESOLVE> ( DP-mark -- ) compile-only

resolves a pointer created by MARK> Mostly used in compiling words like THEN 
 simulate:
   : RESOLVE> ?COMP  HERE SWAP ! ;

reference: ../src/forth-83.c:0210

p4_if_execution_ :

*********************************************************************

reference: ../src/forth-83.c:0155

p4_k_ : K ( -- counter-val )

the 3rd loop index just like I and J

reference: ../src/forth-83.c:0240

p4_l_to_name_ : L>NAME ( lfa -- nfa )

converts a pointer to the link-field (LFA) to point then to the corresponding name-field (CFA)

reference: ../src/forth-83.c:0421

p4_link_from_ : LINK> ( lfa -- cfa )

converts a pointer to the link-field (LFA) to point then to the corresponding code-field (CFA)

reference: ../src/forth-83.c:0412

p4_n_to_link_ : N>LINK ( nfa -- lfa )

converts a pointer to the name-field (NFA) to point then to the corresponding link-field (LFA) 
 implementation-specific configure-dependent simulation:
   : N>LINK  C@ + ;

reference: ../src/forth-83.c:0432

p4_name_from_ : NAME> ( nfa -- cfa )

converts a pointer to the name-field (NFA) to point then to the corresponding code-field (CFA) 
 implementation-specific simulation:
   : NAME>  N>LINK LINK> ;

reference: ../src/forth-83.c:0403

p4_next_block_ : --> ( -- ) no-return

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

reference: ../src/forth-83.c:0231

p4_octal_ : OCTAL ( -- )

sets BASE to 8. Compare with HEX and DECIMAL 
 simulate:
   : OCTAL  8 BASE ! ;

reference: ../src/forth-83.c:0250

p4_postpone_execution_ : ((POSTPONE)) ( -- )

execution compiled by POSTPONE

reference: ../src/forth-83.c:0072

p4_power_ : ** ( a b -- r )

raise second to top power

reference: ../src/forth-83.c:0290

p4_s_p_fetch_ : SP@ ( -- )

the address of the top of stack. Does save it onto the stack. You could do 
   : DUP  SP@ @ ;

reference: ../src/forth-83.c:0260

p4_seal_ : SEAL ( -- )

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

reference: ../src/forth-83.c:0353

p4_search_also_voc_ : SEARCH-ALSO-VOC ( -- )

binds CONTEXT with CURRENT. If the CURRENT VOCABULARY is in the search-order (later), then the CONTEXT vocabulary will be searched also. If the result of this word could lead into a recursive lookup with FIND it will throw CURRENT_DELETED and leave the CURRENT VOCABULARY unaltered. 
 example:
MY-VOC DEFINITIONS MY-VOC-PRIVATE SEARCH-ALSO-VOC

reference: ../src/forth-83.c:0124

p4_store_bits_ : !BITS ( bits addr mask -- )

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 ;

reference: ../src/forth-83.c:0277

p4_to_ffa_ : >FFA ( nfa -- ffa )

converts a pointer to the name-field (NFA) to point then to the corresponding flag-field (FFA) - in traditinal Forth this is the same address. pfe _can_ do different. 
 implementation-specific configure-dependent simulation:
   : FFA  1- ;

reference: ../src/forth-83.c:0444

p4_to_link_ : >LINK ( cfa -- lfa )

converts a pointer to the code-field (CFA) to point then to the corresponding link-field (LFA)

reference: ../src/forth-83.c:0381

p4_to_name_ : >NAME ( cfa -- nfa )

converts a pointer to the code-field (CFA) to point then to the corresponding name-field (NFA) 
 implementation-specific simulation:
   : >NAME  >LINK L>NAME ;

reference: ../src/forth-83.c:0372

p4_two_minus_ : 2- ( i -- i )

substract 2 from the value on stack (and leave the result there) 
 simulate:
   : 2- 2 - ;

reference: ../src/forth-83.c:0054

p4_two_plus_ : 2+ ( i -- i )

add 2 to the value on stack (and leave the result there) 
 simulate:
   : 2+ 2 + ;

reference: ../src/forth-83.c:0044

p4_vocabulary_ : VOCABULARY name ( -- )

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

reference: ../src/forth-83.c:0096

p4_vocabulary_RT_ : ((VOCABULARY)) ( -- )

runtime of a VOCABULARY

reference: ../src/forth-83.c:0079

p4_find_vocabulary

reference: ../src/forth-83.c:0136

p4_make_wordlist

reference: ../src/forth-83.c:0099