12. Dictionaries

12.1. Chaining the Dictionary Element
As shown in Section 9.2. this section has already been mentioned, all the elements of the dictionary have a chain of fields, this combines the words of the dictionary. The chain field contains a pointer to the name field of the previous word, or 0 (for the "lower" element of the dictionary). If we know the title of a word field in a word, the corresponding FORTH parentheses can also be used to generate the addresses of other fields:

The title field of a word thus obtains the title of the name field of the word defined before:

PFA (Parameter Address)
LFA (chain field address)
@ (chain field content = address field of the previous word)

We can therefore move on the chain; another word to find the front of the chain:

In the name field, the word "almost" is in the form of a FORTH garland; the difference is that the first three bits of the length of the bytes area do not belong to the length, and contain other information. So we do not write the word with COUNT TYPE, but with a special word:

The following is the name of the last word defined:

: TODAY LATEST ID. ;

Now we can even list our dictionary:

: VLIST2    80 OUT!    LATEST    BEGIN       OUT @       70> IF         CR 0 OUT!       ENDIF       DUP ID.       SPACE SPACE       PFA LFA @       DUP 0 =    UNTIL    DROP ;

(the list begins with a new line) (the worm: address) (do not write over lines in a row?) (name spelling) ( next name field address) (if the chain field is 0, end) (the dictionary)

How does this differ from your well-known VLIST? First, it does not stop when you press a key on the keypad. We can easily help you with this

? TERMINAL (--- f)

we must know the word; this will give you a true flag when you press a key on the keyboard (we have not handled it with KEY). Second, it does not list the same vocabulary that VLIST. How should this be understood? It turns out in the next section.

12.2. Search and Chain Dictionary It is
embarrassing to distinguish between the meaning of two words that are equally translated into "vocabulary". One is dictionary dictionary (eg, DP: Dictionary Pointer system name), which is a "physical" vocabulary, the other is vocabulary (known as VLIST, Vocabulary List), which is " logical "vocabulary, with a list of terms with indices. In FORTH, a "physical" dictionary can contain more "logic"; In addition to the FORTH dictionary, there are mostly EDITOR and ASSEMBLER dictionaries. By default, we are in the FORTH dictionary; then, for example, the words of the EDITOR dictionary are simply not found or recognized by the interpreter.
To use the words in the EDITOR dictionary, the EDITOR should be used as a search dictionary. (The "search dictionary" is quite a free translation of the original "context vocabulary", contextual dictionary expression.) At a given moment dictionaries can be a single search dictionary.

Two logical chains, physically mixed

So, for example, the

EDITOR

with the command prompt, you can see the words in the EDITOR dictionary (if loaded before). It is unnecessary to worry about how to get in EDITOR without the FORTH basic vocabulary:

Ultimately, this means that

We see this if we do a VLIST after the word EDITOR is executed. Standard VLIST lists the search dictionary. We can also make sure that our VLIST2 program does not do this, as it does not write the words in the EDITOR dictionary. The word LATEST with which our program starts starts is not the title of the top word of the chaining dictionary, but the search engine.
The chaining (originally current) dictionary is just one at a given moment.

With the name of the dictionary, only the search dictionary will be changed; if you want the chaining dictionary to be the same, then a

DEFINITIONS

use the word that aligns the chaining dictionary to the search engine, the two will agree.
In reverse, the two dictionaries are aligned with the definitions : word: this changes the viewfinder to match the chain.
An old acquaintance, a new feature of FORGET: works only if the search and chaining dictionary is the same, otherwise it is broken by error.

12.3. Our own dictionaries
We can also separate one of the vocabulary from the other, we can create their own dictionaries. Defining the dictionary

Vocabulary

you have to enter the name of the new dictionary (as we have seen in the definitions). After defining a dictionary, you also use the word IMMEDIATE, which we will later discuss (see section 16 ). For example, if you write a user program, but do not want to know the user's nose, what are the auxiliary words written during the program buildup, you can lock these auxiliary words into a separate dictionary:

VOCRBULRRY REJTETT IMMEDIATE

When we write the words "hidden" we will do this as a search and chaining dictionary:

HIDDEN (this made him search)
DEFINITIONS (from a chaining)

If we are ready to write the auxiliary words, we want to create the final result in the FORTH dictionary:

FORTH DEFINITIONS : VEGSO (but you want to use it in the program)         ( READY words)    HIDDEN       (here comes the text of the program) ;

The fact that the REJTETT word is performed while compiling and not running VEGSO is the result of IMMEDIATE.
Since : you stop the search dictionary, if you want to define another word using the READER words, you will need to redefine the search dictionary after the next colon:

: VEGSO2 REJTETT
   (here comes the text of the program)
;

What was that about?
Summary of Chapter 12

The words learned:

Examples

12.1. Write in section 12.1. section of a VLIST2 section that will stop the listing by pressing any key!

: VLIST
   80 OUT!
   LATEST
   BEGIN
      OUT @
      70> IF
        CR 0 OUT!
      ENDIF
      DUP ID.
      SPACE SPACE
      PFA LFA @
      DUP 0 =
      ? TERMINAL OR
   UNTIL
   DROP
;

12.2. Write the names in the dictionary that start with an opening lock, so that it is tabulated so that the number of characters that can be entered can be divisible by 13. If there are more than 51 characters in a row, the next name is written in a new line.

: LIST    80 OUT!    LATEST    BEGIN       DUP 1+       C @       40 = IF	(---) (crossing the lengthbyte) (this is the first character of the name) (if parenthesis)
OUT @ 51> IF           CR 0 OUT!         ENDIF         DUP ID.         13 OUT @ 13 MOD -    SPACE       ENDIF       PFA LFA @       DUP 0 = UNTIL    DROP ;

  .