7. Getting to know the memory

7.1. Byte Operations
The computer memory is a sequence of bytes numbered and numbered by them. The words of the FORTH memory manager make these bytes freely readable and overwritable, regardless of whether they are in the middle of the interpreter code, in the stack, or in a somewhat "gentler" place. The programmer's job is not to get in the wrong places. A good address for skinning, where you can store data temporarily: pad (pronounced ped). The pad means a notepad, a block. The address of the pad is a

PAD (--- title)

word provides.
Caution! The pad is above the dictionary area, at a constant distance from the top of the dictionary (byte from the last word defined). Therefore, when new words are defined or forgotten, the pad position changes. It is best to use the data in the pad in the same word that we put it into. For permanent data retention, the variables are provided, which will be discussed in Chapter 8 .
Words for memory bytes:

In the description of the stack effect, the title means a memory address; type is a one-word, unsigned value.
Write a word that waits for characters from the keyboard, right up to ENTER, and after ENTER, rewrite the resulting string. The backspace character (whose code is 8) responds by deleting the last scanned character. We keep the characters in the pad while we are writing.

: BACK    PAD    BEGIN       KEY DUP 13 -    WHILE	( will be the first character) (vermen is the next character's title) (it will be false if it was ENTER)
(here we get if you have not already ENTER)
DUP 8 =       IF DROP         DUP         PAD -         IF 1 ENDIF       ELSE         OVER C!         1 +       ENDIF    REPEAT	( we do not want to delete more) (how much is there?) (if not) (store the code) (the next code one after the other) (we will have to store it)
(here comes the effect of ENTER)          (the address code of the vermen)
DROP PAD       DO RC @    EMIT LOOP ;	(the first character to be entered)

Typing the characters could also be done with the TYPE key word. TYPE, along with other basic words that handle byte series, can be found in the glossary at the end of this chapter. A convenient way to scan character sequences is

EXPECT (max limit ---)

a word that drops the characters scanned from the keyboard from the specified address to the memory. Scanning characters will take up to the first carriageway or the "max" character scans. By the end of the series, binary zeros are stored in the memory. The backspace character deletes the last character in the series.

7.2. Voice and Dual Operations
Memory is not only 8-bit, that is, bytes, but also words and doubles.
The words used are:

So the

0 PAD 2!

the bytes on the PAD, PAD + 1, PAD + 2 and PAD + 3 addresses are reset.

7.3. Convenient Stack
Management With the words handling memory, you can "go out of the way" to the stack as it is ultimately just a memory space. All you have to do is know what titles the stack is about. The

SP @ (--- title)

refers to the title of the top of the stack (before the execution of SP @), that is, if the stack is not empty, the title of the top element.
So if the stack is not empty then that

SP @ @

series is equivalent to a DUP operation. If we experiment with a bit with the SP8 and SP @, we soon realize that SP @ gives a smaller title, the more elements in the stack.

The address of the stack of the stack, the address given by SP @ in an empty stack, FORTH keeps a permanent address; the latter address is placed on the stack by the word S0. The bottom of the stack is therefore

S0 @

. (See the following figure.)

Now we can write the 1.6. stage , non-standard management stack in words (DEPTH, .STACK, PICK and ROLL). You should read the source texts of those who like to learn from other programs; none of the novelties are provided.

: DEPTH    SP @    S0 @    - MINUS    2 / ;

(--- stack depth) (on the top) (the bottom) (that's bytes pt include elements of the stack) (so many items available)

: STACK (---)    SP @ S0 @ =    IF       CR. "Stack is empty"    ELSE       SP @ S0 @ SWAP (from top to bottom)       DO CR R @ 5 .R 2 + LOOP    ENDIF CR ;

Before we write the words PICK and ROLL, let's wonder: what do we do if someone wants to look too deep in the bottom of the stack? What if someone wants to get the third of the two elements of the stack? Assume that this can only be a programming mistake and protect the programmer from the consequences of his mistake, so stop everything! That's right

QUIT

weave. Quit interrupts almost everything at all levels and returns the control to the external interpreter, which starts to wait for a new command line. Quit with QUIT is not followed by OK.
The text of PICK can be followed without much explanation.

: PICK (n --- n1)    DEPTH 1- (with no nullity)    OVER <    IF (if the stack has fewer than n elements)       "PICK error" QUIT    ELSE       SP @       SWAP 2 * (2 * n)       + @    ENDIF ;

The stack when PICK is started:

The n ROLL (n now refers to the number on the stack) first copies a n-th top element to the top of the stack with a PICK, which is to be "thrown" and then sums up the "old" n- n-1, n-1 to n-2, and so on. Finally, from n-1, all elements are "slid down", and at the top two copies of the n-eds; the excess top is discarded.

: ROLL    DUP> R    PICK	(copy "one copy") (copy element n to the roof)
(Copied in DO ... LOOP cycle)
SP @    DUP 2+    SWAP R> 2 * +    DO       R 2- @       R!    -2 + LOOP    DROP ;	(the title of the original item) (the title of the original item) (copy the item to be copied ) (duplicate) (discard the item n. unnecessary) (copy)

What was that about?
Summary of Chapter 7

The words taught in Chapter 7:

Convenient basics to handle Byte series:

Examples

7.1.a. How to write 2 @ (title-d-content) and 2! (title d ---)?

: 2 @ (title --- d content)    DUP @ (the contents of the first memory word)    SWAP 2+ @ (for the second) ; : 2! (d-content title)    > R (we put the address on the vibe)    R 2 +! (fill the second memory slot first)    R>! (the first one for the second time) ;

7.1.b. How to write TYPE (title length ---)?
FIG version:

: TYPE    -DUP IF       OVER +       SWAP DO         RC @ EMIT       LOOP    ELSE DROP    ENDIF ;

(address length ---) (if the length is not 0) (bytes between the two addresses ) (if it was 0, the address on the vermen is)

7.1.c. How to write CMOVE (from length to length)?
A FORTH solution:

: CMOVE    0 DO      OVER C @      OVER C!      1 + SWAP 1+ SWAP    LOOP    DROP DROP ;

(from the length to ---) (let's get one byte) (let's put it to the other location) (both titles will be added) (the two titles do not have to)

However, in general (like fig-Forth), CMOVE is not in FORTH but in a machine code.

7.1.d. How to write FILL (title length byte ---)?
The FIG solution:

: FILL    SWAP> R    OVER C!    DUP 1+ R> 1-    CMOVE ;

(address length byte ---) (address byte) (address) (address title + 1 length-1)

7.1.e. How to write the words ERASE and BLANKS ?
FIG version:

: ERASE 0 FILL;

: BLANKS BL FILL;

7.2. Why is not DEPTH so good?

: DEPTH (--- verity)
   S0 @ (the bottom)
   SP @ (the top)
   - 2 /
;

The first S0 puts a new element on the stack, SP @ is no longer in the original state. This version is correct:

: DEPTH (--- verity)
   S0 @ (the bottom)
   SP @ (the top)
   - 2 /
   1-
;

7. 3. In many FORTH, there is a word S <> (title1 title2 length --- f) that compares the length length beginning with address1 and address 2 but not in fig-Forth. The returned signal is false, ie 0, if the two characters are the same, positive if the first is greater, negative if the second one. (The two equal lengths are the same if their corresponding characters are the same, and if not, then the comparison of the code of the first non-matching pair of characters gives the relationship between the two.) Write the word S <>.

: S <>    0 PAD!	(title1 title2 length --- f)
(this will be the signal we give back)       (initially assume that the two series)       (same, if not, change it)
0 DO     OVER C @ OVER C @     -DUP IF       PAD!       LEAVE     ENDIF     1+ SWAP 1+ SWAP    LOOP    DROP DROP    PAD @ ;	(the difference between the two characters) (if the two characters are different) (this will be the answer signal) (and finish the operation) (move on with the titles) (titles are no longer needed) ("overwrite"

7.4. If we write a memory area with the words TYPE (title length ---), there are very strange things, since there are all sorts of control characters between them. Write a TYPE2 (title length ---) word that prints the characters between 32 and 126 (punctuation, digit, uppercase, lowercase) and points to the rest.

The program is almost literally the same as TYPE, only the control characters must be replaced by the code of the point (56) before the characters are written:

: TYPE2   -DUP IF     OVER + SWAP DO       RC @       DUP DUP       32 <SWAP 126> OR       IF         DROP 46       ENDIF       EMIT     LOOP   ELSE DROP   ENDIF ;

(title length ---) (if control character) (replace) (write the character)

For example, you can try TYPE2 for example:

PAD 6 65 FILL PAD 3 ERASE PAD 6 TYPE2

The answer is: ... AAA

7.5. Write a BOTTOM (--- n) that copies the bottom of the stack to the top of the stack.

: BOTTOM    SP @ S0 @ - IF (there is something on the stack)       S0 @ 2- @    ELSE. "Stack is empty" QUIT    ENDIF ;

  .