18. Another FORTH program: the textinterpreter

As a summary of what has been learned so far, we will look at how the FORTH interpreter works.
After loading, the control is given to the word COLD (cold start). COLD clears block buffers, sets virtual memory and terminal data, some USER variables are called so called. fill parameters with standard initial values. Then call ABORT. ABORT's text speaks for itself:

: ABORT    SP! (The primitive pit emptying)    DECIMAL    ? STACK    CR .CPU (fill out the processor type)    "FORTH fig- 1.1g."    FORTH    DEFINITIOS    QUIT ;

The textinterpreter is mobilized by QUIT. QUIT after initializing the corresponding variables reads rows from the terminal in cycle and passes them to the word INTERPRET. Scanning is done by QUERY. QUERY calls EXPECT, configuring to place the line read from the keyboard into the command buffer; In addition, it sets IN to 0:

: QUERY    TIB @    80    EXPECT    0 IN! ;

(the title to which EXPECT will be scanned) (text) (maximum text length for EXPECT)

In addition to QUERY and INTERPRET, the RP! primitives; it restores the virus to its initial, empty state.

: QUIT    0 BLK!    [COMPILE] [    BEGIN PR      CR      QUERY      INTERPRET      STATE @	(read from the terminal) (enter the execution state ) (new line) (command line scanning) (command line execution)
0 = IF "ok" ENDIF (if not in the middle of the fdefinition)
;	(there is a row, the reason may be)

The textinterpreter is roughly the same as the word INTERPRET. 1NTERPRET processes the influence I speak of (spoken by BLK and IN system variables). Of course, WORD makes wording, which is included in the INTERPRET text in -FIND.
If -FIND successfully searches for the dictionary, the interpreter must decide whether or not to execute or translate the dictionary word. This decision (if the possible values of the STATE are cleverly chosen) can be compressed into a single comparison: the length of the word field of the word is compared to the STATE values.
If you are interested in "bits": STATE, if not 0 (ie not executing state), is hexadecimal C0, binary 1100 0000. In the length of the word field of the words, the first bit is always 1. Thus, in executing state, the STATE value is always smaller will be like longitude byte. In the translation state, the value of the STATE will be less than the length of the immediate words length (the second bits of the longitude bit, the precedence bit 1). So the word should be executed if the STATE value is less than the length of the word.
If the word is not found in the dictionary, NUMBER will handle it, so try to convert it. If it does not go, the NUMBER will be flown with 0 ERROR (going back to QUIT). After a successful conversion, you only have to decide whether it is a one-word or double-count value (whether it was a decimal point), so LITERAL or DLITERAL gets the job. Both do nothing if they are in translation.
INTERPRET checks the word "STACK" to see if we have not used more items than we used to stack or did not stack the stack (because it is finite). In both cases, STACK causes an error message and goes back to QUIT.

: INTERPRET   BEGIN     -FIND     IF       STATE @ <       IF         CFA,       ELSE	(the tag is false) (the word is FALSE if STATE 0,) (or the word is immediate) ( translate ) (put the start address to HERE) (execution)
CFA EXECUTE
ENDIF       ? STACK     ALWAYS       HERE NUMBER       DPL @ 1+       IF	(there is no element with this name) (conversion) (here we get when the conversion is successful ) (NUMER has failed) (DPL is not -1, it was a decimal point)
[COMPILE] DLITERAL
ELSE         DROP	(one-word value)
[COMPILE] LITERAL
ENDIF       ? STACK     ENDIF   AGAIN ;

What happens if the text to be interpreted brings you from the command buffer to translate a shadow? The LOAD text will give you the answer:

: LOAD    BLK @> R    IN @> R    0 IN!    B / SCR *    BLK!    INTERPRET    R> IN!    R> BLK! ;

(the queue number) (note where we left) (the text containing the LOAD ) (begin with the beginning of the block) (the first block of the screen)

So a LOAD calls another INTERPRET, that is, a new BEGIN ... AGAIN cycle (this time the word blocks starts from the blocks of blocks). Whichever (external, internal, or even more) BEGIN ... AGAIN cycle is concerned, one must once complete the interpretation of all the nodes and command lines. The term word is null (its name is used in dictionary lists and documentation x), which is called a single binary zero byte. Therefore, it is good that EXPECT (that is QUIT called QUERY) will cause binary zero or zero after the scanned text; therefore (although not so far) is also binary at the end of the block buffers. Binary 0 (in addition to always delimiting the WORD) is a dictionary word.

Null is a term not only for interpretation but also for this book. Good luck and good work for FORTH!

  .