14. Dictionary and interpreter

14.1. Colloidal Words
The most basic feature of FORTH programming is to build words that are already existing for words that are closer to our goal so that we can build them later on. Such words, compiled in other words, contain indicators for the words that make up their own; the essence of their operation is the implementation of the words that make up them based on the indicators. This kind of evaluation of the indicators is a small, fast program, the so-called. an internal interpreter or an interpreter. (Much depends on the title interpreter to be fast because it is executed when executing FORTH words.)
If we start a word definition with a colon, then we'll tell you that the new word will be rebuilt from older words. Thus, since the operation of dictionary words is determined by the contents of the code field,

The metrics on which the titleinterpreter has to go is in the parsing of the colon-words; these are the code addresses of the words that make up the word.
Example of a colon definition:

: .PAD PAD C @. ;

The generated element:

Name field:	.PAD
Chain Field:	name field of the previous word
code field:	address interpreter
parameter field:	PAD code field address
	C @ code field address
	. kódmezõcíme
	; S code field address

In the parsing of the colon words, the last code address is : S ; this word returns the title interpreter to the caller word. (The S word in section 2.5. Have been met. Kerny interpretation of the result is complete) The S kódmezõcímét of ; the word is enchanted in the parable of the new word.

14.2. Primitives
The majority of the words FORTH are thus run by the title interpreter: he goes to the addresses where the indicators found in the parsing word are sent. There may be newer metrics to go on. Many of the messaging needs to end once: sooner or later, any word you have called has to figure out what to do. These final words, which therefore do not contain other indicative terms but executable machine codes, are called primitives. In the code field of the primitives, the pointer points to the primitiva's own parser. The parser has a machine code, this is executed when the primitive is run. The existence of primitives is based on the following statement:

Primitives can also be used to call routines of the operating system, so you can integrate the file system or any other feature of that operating system. Of course, a machine-independent CP / M programmer can not do this for all existing machine types, which we should do to the machine we use. If you want to better use the capabilities of your ENTERPRISE operating system, machine - specific IS-FORTH is the right choice.
To create primitives, the words of the ASSEMBLER dictionary serve to make use of mnemonics instead of machine codes so that we can have assembler programming for control structures and so on.

14.3. Variables and constants
All variables work in the same way: the stack is the address where the variable value is. so maybe it's not surprising that the code fields of our variables all contain the same address. More surprisingly, system variables (BLK, IN, DPL, etc.) are not the same. Such special variables:

The system variables (USER, say: variables variables) are in a table. A part of the table is loaded with the word COLD (start of cold start) with the initial values, (with the other key data needed for the operation of the interpreter, so that the original state of the dictionary is returned after COLD, which is usually the deletion of our definitions.Users
can be defined with the word USER, described at the end of the chapter, although it does not matter much to the writers of this "field" user program. USER variables, as we have seen, are the same as ordinary variables, but there is a difference only behind the scenes.
The constants' code field is also the same: it points to the code that puts the parsing content on the stack. Thus, we can conclude from the code field of a dictionary that it is about colon, primitive, or the like.

14.4. Tricky Runs
The usual way to execute a word is by referring to its name, and the interpreter will know what to do with it. However, a word can be done on the basis of its code title, ultimately the interpreter also does. In order to enjoy the fun of it, we must first know how to create a code field (or any other) of a dictionary word. That's right

-FIND

word that tries to find the next word of my influence in the dictionary. If you find it, it returns the parsing address of the word, the longitude marker and a true marker from the name field. If not, it only gives a false sign.

14.4.1. EXECUTE
The

EXECUTE (code field title ---)

is the word that executes another word in the code field specified in the vermin.
Let's say that we only want to write the words of such or somehow characteristic words (primitives, USER variables, etc.). The structure of such list-creation programs is exactly the same - all goes through the dictionary chain and decides whether or not to write that word. This decision is the only detail that changes when we want to list constants instead of primitives. Let's make this decision a separate "decisive word", and we will list the listener on which final word to list.
We assume that the decisive word is waiting for a mark on the vermen and gives a marker that is true for the words to be pronounced, the others will be false. For example, to decrypt the words starting with the closing sign, the decisive word is:

: (WORD (pm address --- f)    NFA (name field address)    1+ C @ (first character of the name)    40 = ;

We write the soloist EZEK-A, after which I will only give the name of the decisive word in my influence, somehow:

EZEK-A (WORD

We will make it easier for us to introduce a variable to store the parsing address of the decisive word:

0 VARIABLE DONTO-PMC

because the DONTO-PMC already contains the prime address of the decisive word, then you can choose one word to write:

: DOES-E (pm title --- f)    DONTO-PMC @ CFA    EXECUTE (execute the word "decisive") ;

Writing a word

: OUTPUT (OUTPUT ---)    OUT @ 35> (lines should not be too long)    IF CR 0 OUT!    ENDIF    NFA ID. ;

The program itself:

: EZEK-A    80 OUT!    -FIND 0 = 5?    DROP DONTO-PMC ERROR !    LATEST    BEGIN      PFA DUP DUP      KELL      -E IF KIIR      ELSE DROP      ENDIF      LFA @    DUP 0 = UNTIL    DROP CR ;

(---) (the Chamber immediately start a new line) ( "fly away" if there is no final word) (word name in the top box title) (next word address field name) (pmcím pmcím pmcím) (pmcím pmcím indicator) (proceed)

14.4.2. Variations for -FIND
Let's say that the former EZEK-A word is a word VALCULE (pmc --- f), which gives a true flag if the given address is a (VARIABLE-defined) variable. We know that the code fields of the variables all contain the same address, but we just do not know which address this is. But we can find out that a single variable is enough:

0 VARIABLE A

In its code field a

-FIND A DROP DROP CFA @

address; if we've been fascinated somehow on the stack, we can build it in a constant way to use it:

CONSTANT A-CIM

So we have easy things to do:

: VALIDES (pm address --- f)
   CFA @ A-CIM =;

The constant introduction of A-CIM can be floated using the word ' word ' . The 'gives the prime word of the next word of my influence, so it works in the same way as -FIND, only:

(This will be more fully understood in Chapter 16. )
Thus, at the moment of definition, you decide whether or not there is such a word; the ' does not even give a tell-tale (otherwise the length band). If we did not search for a dictionary, it simply stops ( calling the ERROR word known in section 13.3 ).
The other version of VALTOZOK for which the A-CIM constant is not to be introduced:

: VALTOZOK (pm address --- f)
   CFA @
   'A CFA @
   =
;

If we do not want to look at the top of the dictionary or do not want to enter the name of the word to search,

(FIND)

which can be found in the appendix .

14.4.3. User-defined Interruption
With the term title, see Section 13.3. section , we encountered standard error handling. If the value of the WARNING variable is -1, then ERROR will give the command word ABORT, which, if nothing is done, executes the word ABORT. We already know this means that the (ABORT) parter has the ABORT code field address. If you want another interrupt procedure, we'll write a word for it, for example:

: SAJAT CR. "En mar nemsokara bucsuzom" ABORT;

and place this code address in the (ABORT) partition:

'SAJAT CFA' (ABORT)!

What was that about?
Summary of Chapter 14

The words learned:

Examples

14.1. Create a list of USER variables. (Such a list can be found at the beginning of this chapter.)

: USEREK (pm address --- f)
   CFA @
   'IN CFA @ =
;

Then the list is populated:

THESE ARE THE USERS

14.2. Make a list of primitives!

Similarly to the previous task, just write the final word. Primitives can be learned from the point where the pointer points to their own parame- ters:

: PRIMITIVAK (pmcím --- f)    DUP CFA @ =;

Then the list is populated:

EZEK-A PRIMITIVAK

14.3. Write a DRAWING (---) word to draw graphs of functions. The functions (x --- y) are vertebrates; if the name of such a word is given after the DRAWING, the DRAW shows us the function between -10 and 10 points. For example:

DRAWING 2 /

or

: F1 DUP * 6/6 - MINUS;
DRAWING F1

To make our life more comfortable, we create a variable for the code field of the function:

0 VARIABLE KMCI

If KMCI already contains the code field address of the function, a function call is in this form:

: FHIV (n1 --- n2)
   KMCI @ EXECUTE;

The function drawing is between the minimum and maximum values recorded between -10 and 10. The program of a line of the graph (the worm waits for the function value corresponding to the line):

: 1SOR (n ---)    CR DUP 3 .R 2 SPACES    11 -10 DO      R FHIV OVER =      IF 42 (if the value fv is correct for the line)      ELSE        DUP 0 = IF (if in line 0)          45 (horizontal line)        ELSE R 0 = IF (if in column 0)          124 (vertical line)          ELSE BL ENDIF               ENDIF      ENDIF      EMIT    LOOP DROP ;

The main program is to execute 1SOR for values for the minimum and maximum function values.

: DRAWING (---)    CR -FIND    IF      DROP CFA KMCI!      0 DUP (minimum and maximum starting value)      11 -10 DO        R FHIV MAX        SWAP R FHIV MIN SWAP      LOOP      DO R 1SOR -1 + LOOP    ELSE "There is no such thing "    ENDIF ;

  .