After the name, there will be a zero byte if necessary to have the link field
 start on an even-numbered address.  Making the dummy byte a zero makes it
 easier to find the NFA given the LFA when we allow characters above 7F in
 names.  The name field can start on any addr.  [Edit: It especially makes SEE,
 the de-compiling word easier.]

 LINK FIELD:    A two-byte address (low byte first, as usual) of the name
                field of the previous word in the vocabulary.  Link field always
                starts on an even address.

 CODE FIELD     A two-byte address of the code to execute for this word.  For a:
                primitive: it points to the parameter field (its own addr + 2).
                secondary: it points to the CFA of nest.
                constant:  it points to the addr of const runtime routine.
                variable when the word is in RAM:  it points to the addr of
                   create (not CREATE ).
                variable when the word is in ROM:  it works the same as a
                   constant that gives the applicable RAM addr.
                (etc.  Also see explanations of DOES> does ;code etc.)

 PARAMETER FIELD  (body)  This could be machine-language code (in the case of a
                primitive), a string of two-byte Forth code field addresses (in
                the case of a secondary), data (in the case of a constant,
                array, etc) or combinations of these.  Some words may not even
                have a parameter field, as is the case with DROP for example,
                whose code field points to the POP routine, which has no need to
                look back at DROP's parameter field for any information.

If code is compiled without headers, the name field and link field will be
absent.  This saves memory, and if all the code is compiled without headers, it
will be nearly impossible for someone else to look at your compiled program and
figure it out, ie, reverse-engineer it.  Headerless code may be acceptable for
systems where further compilation (requiring searching the dictionary for names)
is not needed.

Note that a runtime routine (or runtime, for short) is not a Forth word per se,
and not only has no header, but no CFA either.  Other words' CFAs will point to
the address where the runtime routine starts.  An example would be const , the
runtime for constants.  const knows how to get the next cell (the only cell in
the parameter field of a word created by CONSTANT ) and put it on the stack.

Code fragments like POP2 and PUSH_FALSE are not particularly runtime routines,
but can be used as such by being called by the CFA of other words.  In this
particular case, the address of POP2 is pointed to by the CFA of 2DROP , and the
address of PUSH_FALSE is pointed to by DUMMYCELL and a couple others.  Usually
primitives will end by jumping to these fragments to save some memory when doing
things that a lot of primitives do at the end.

: INTERPRETER           ( str_addr -- )                    \ Common Forth    FIG
   FIND                         \ ^ addr f      (f=0 if not found)
   IF    EXECUTE                \ EXECUTE if word found.
   ELSE  #INT 0=                \ Else, see if it's a valid number.
         IF DROP THEN           \ DROP the high cell if not double-precision.
   THEN  ?STACK         ;


: COMPILER      ( str_addr -- )
   FIND  ?DUP           IF      \ TOS<>0 if word was found.
   0< IF ,  EXIT THEN           \ -1 means not IMMEDIATE , so compile it.
   EXECUTE  EXIT        THEN    \ Else it's IMMEDIATE , so execute it.
                                \ If word was not found, see
   #INT          IF             \ if string is a valid number.  If a decimal
   2LITERAL EXIT THEN           \ point was found, make a double literal; else
   DROP LITERAL         ;       \ drop the high cell and make a single literal.


: INTERPRET             ( -- )          \     18 CELLS                 SF283-286
   BEGIN   BL WORD                      \ ^ addr
      DUP C@ 0<>                        \ ^ addr f
   WHILE   STATE @                      \ ^ addr f
      IF COMPILER ELSE INTERPRETER THEN \ ^ empty
   REPEAT  DROP         ;