Benutzer-Werkzeuge

Webseiten-Werkzeuge

Übersetzungen dieser Seite:

projects:f83_tutor

F83 TUTOR by BILL KIBLER

© 1986, 1987

INTRODUCTION

F83 TUTOR is a self paced tutorial for the public domain Forth program F83. F83 is a Forth based operating system and programing language. This version contains the standard word set Forth-83 making the program structure different from previous standards. Major changes between F83 and older versions of Forth (FIG AND 79) make it necessary for all users, both users new to Forth and FIG or Forth-79 users, to study and understand these differences. This program, TUTOR, will help new users of F83 learn to use it more efficiently and faster.

The „CHAPTERS“ are organized with the understanding that a user will have a copy of „STARTING FORTH“ by Leo Brodie. Each chapter consists of a GLOSSARY, LIST OF TERMS, and TEXT ( in that order) based on the books organization. Enough text is provided to get an understanding of the topic and the book should not be required by experienced Forth programmers. Experienced programmers will find the GLOSSARY section to be the most important aspect of this program. The program is based on the F83 word set and not those of FIG or Forth-79.

TUTOR is very easy to use and can be modified to add more infor mation or scanning functions. Experienced Forth programmers can use this program by entering the following:

          A>F83
          OPEN TUTOR.BLK  
          1 LOAD

Use the space bar to scan through the screens of information, and then choose a chapter to start your review. For novice or new users of Forth a more detailed introduction follows in the next section.

GETTING STARTED

Forth is both a programming language and a operating system. TUTOR is a simple F83 tutorial consisting of „WORDS“ that handle the information and tutorial screens based on the book „STARING FORTH“. All new or novice users should use this book, as they will find the tutor text information to be too brief for develo ping a good understanding of Forth. The screens of information will help you understand Forth and will help point out the diffe rence between F83 and the FIRST EDITION of the book. As you follow through the screens you will notice that some glossary words will be different from those in the book, these represent the new word set as specified in the Forth-83 standard. Those readers using the SECOND EDITION of „STARTING FORTH“ will find tutor to be an on disk review of the book.

To better understand this program an introduction to Forth and its structure is needed. Forth is a stack oriented language. Values are placed on the stack and then WORDS are entered to perform actions on these values. The most simple use would be the addition of two numbers. To add the numbers 4 and 7 you would enter 4 7 + . and Forth would return 11 ok. Considerable problems occur for new Forth users over the use of text type symbols to represent words or commands. The sample used a . to denote the command to print the top item of the stack on the computers screen. In displaying information about Forth it is very hard in a document to prevent confusion between Forth WORDS and the text used to display them. Until you can know which words are Forth WORDS and which are text words, reference to the text book is needed. The book puts a block around each word when described in the text, an option not available on all computer systems.

This problem of variations in computer systems and languages has been handled by the FORTH INTEREST GROUP in respect to Forth. The term FIG Forth refers to an early set of Forth WORDS that the interest group established as the first standard Forth system. The next standards meeting in 1979 made some changes and established a new Forth standard called Forth-79. The latest and one that this tutorial is intended to help is the 1983 standards meeting version, this word set is called Forth-83. The program this tutorial is for is F83 which is a public domain version of Forth containing the Forth-83 word set.

Although a few words have been changed between standards a considerable amount of similarity exists between the standards. F83 is very popular because of its cost and utilities contained within the program. F83 contains not only the normal screen editor and assembler, but also debugger, disassembler, and multi- tasker utilities. There are many commercial and public domain versions of Forth, in fact there is a version of Forth available for almost all the operating systems and computer hardware systems currently being produced. Forth is a small, fast, and extensible operating environment. It has been used in numerous special applications, such as space vehicles, where speed and reliability are major concerns. The extensible nature of Forth is its most important aspect.

LOADING TUTOR AND EXTENSIONS

The Forth system can be stand-alone or work within an existing operating system. All Forths store information in SCREENS which are 1K in size ( 1024 bytes). When a screen is displayed it can consist of 60 characters across and 16 lines down ( one character is equal to one byte of information). The F83 operating system stores the screens on disk as BLOCKS of data (1 screen is 1 block). Typically the file name will have an extension of BLK to indicate Forth information. The TUTOR program is stored as „TUTOR.BLK“ on most systems. Starting F83 would be done by typing F83 at the system prompt and using „RETURN“ on most MSDOS or CPM systems.

To load the TUTOR program after starting F83, the file must first be OPENED, you do this by typing „OPEN TUTOR.BLK“ and a return. Next it is necessary to LOAD the Forth extensions which are used by the TUTOR program. You type „1 LOAD“ and return, this will start the TUTOR program and give you more information about F83. Should your system be different or you are new to computers, you may need to review and use programs supplied by the system manu facturer until you understand and feel comfortable with your new computer. Some versions of F83 use different words to open and load files (due to operating system designs), check with your own documentation on specific instructions.

The „1 LOAD“ command loads screen 1 into memory and then starts compiling the new word definitions contained in it. These words are extensions to the orginal F83 word set. After being compiled they are part of the Forth DICTIONARY and can be used as if they were part of the original program. This ability to add words and EXTEND the dictionary is the source of the term „extensibility“. Programs are created by extending the dictionary with new functions and routines. The TUTORS new words are contained in 4 of the first 10 screens and can be changed should you desire some special way of handling the tutor screens.

TUTOR WORDS

The new words are:

  • HELP Loads the information about the tutor program and general F83 words. The last screen lists words used by tutor and relating to „STARTING FORTH“.
  • START-TUTOR Will start displaying the introduction to tutorial information.
  • REPT This command will display screens from the beginning of the most recent chapter or group of screens. If CHP1 had been entered and you exited the listings to try a F83 operation REPT will restarted at the first screen of CHP1.
  • GET GET will start displaying screens at the next one in sequence. Using REPTs sample, if you had typed GET instead of REPT you would get displayed the next screen of information in CHP1.
  • 21 TUTOR Typing this will start displaying tutor screens starting with screen 21 and continuing till the screen contains

    $$. When you type CHP1 this word loads the number of the first screen of chapter 1  on the stack and then goes to TUTOR.
  * PRTSCR    This word will display the current GET and REPT pointers.
  * LIST      Forths normal internal word for displaying screens of information. Use this word whenever you want to view a single screen. TUTOR uses a modified version of LIST for displaying multiple screens.
  * 10 90 INDEX    Use this input command line to get a list of "INDEX" lines (line 0 and NOT printed by tutor) of screens 10 through 90 (the text screens). Line 0 is generally used as a descriptive line of what the screen contains.
  * ESC       Using the ESCAPE key will end the display of information, so that you can then tryout some of what you just learned in the text.


== ADVANCED INFORMATION ==

TUTOR uses most of the normal F83 words to perform its functions. 
A  major advantage of the tutor program is to retain easy  access 
to  the  normal F83 functions.  The tutor program will display  a 
series of screens starting with glossary information. Experienced 
programmers will find this part most helpful in learning the  new 
F83 words.  When finished displaying text screens, the F83 prompt 
"ok" will indicate completion of the lesson.  At this point  any 
F83  commands can be used.  Individual screens can be repeated by 
using the list function.

A  number  of blank screens have been provided at the end of  the 
program  for use during the learning sessions.  As new words  are 
created  in the lesson,  they can be saved in these screens  and 
auto loaded by adding "nn LOAD" to screen 5 (nn being first  used 
screen).  To  tie screens together use --> and F83 will  continue 
loading the next screen.

For  educators  and programmers,  they will find TUTOR to  be  an 
excellent  example of how to create a tutorial program in  Forth. 
It  is very hard to create a tutorial program in which  the  user 
has  enough control over the training structure that it can  meet 
their  needs adequately.  Most users of tutorials get  frustrated 
when  they can not exit or reenter the program at  will.  Usually 
lacking in tutorials is the ability to add sorting of information 
or  the creation of summary details.  Forth appears to handle all 
these  problems easily. Once the user understands Forths  use  of 
words it is possible to customize the tutorial for their personal 
needs.  An example of this would be the creation of a new word to 
keep  track of exiting and saving the screens pointers  to  disk. 
When  returning,  the user would type RESTART and the disk stored 
pointers would be restored,  and the next screen would be  loaded 
for viewing.

Although  not  shown  here,  interactive  uses  of  training  are 
possible. Forth has numerous words to allow for trapping of input 
data  and evaluating this information for correct  response.  The 
use of screens provides a simple way of grouping information such 
that  a  student who misses a concept (as found through  testing, 
see  screen  39)  could  be directed  back  to  that  information 
automatically. A new feature in F83 is the use of SHADOW screens. 
These  screens are from the original file UTILITY.BLK of F83  and 
contain  the  authors  comments on words in the  source  screens. 
Words  are  available  to toggle between these  screens  and  the 
source  screens.  Use of this feature may be helpful in  tutorial 
programs,  where  background or detailed discussions outside  the 
normal flow of instruction is needed.

== CONCLUSION ==

The  creation  of  this  program was two  fold;  to  show  Forths 
abilities  in  creating  tutorials,   and  to  provide  on   disk 
information about F83. This project was part of a masters program 
in Computers and Education.  This is by no means a complete study 
of  using Forth for tutorials, of F83, or Forth.  I have released 
this version of TUTOR.BLK into public domain solely to help those 
who have had problems getting to understand the new words of F83. 
One  reason I feel that Forth has had problems being accepted  is 
the  lack  of tutorials accompanying new releases.  When I  first 
tried  F83,  I found the on disk documentation to be  inadequate. 
Although the use of shadow screens is an improvement, they do not 
equal the benefits of a good tutorial or disk based glossary. 

I am interested in your comments concerning this program and  any 
information  that  could make it better.  My  time  currently  is 
limited  and thus I can only take written queries.  I retain  all 
commercial rights to the screens 1 through 10,  as they represent 
the  idea  behind the tutorial,  as well as the information  con
tained  within  the  text  screens  not  directly  attributed  to 
"STARTING  FORTH" by Leo Brodie.  I am available  for  commercial 
activities  and would be willing to assist in developing  commer
cial tutorials.
<code>
          Bill Kibler
          Kibler Electronics
          PO BOX 487
          Cedarville, CA 96104
</code>
I  do  use  the  Sacramento Micro Users Group RBBS  and  can  get 
messages there: 300/1200 24 hrs (916)722-9337

<code>
 ok
OPEN TUTOR.BLK  ok
1 LOAD 











































                                       *
                                      ***
                                     *****
                                    *******
                                   *********
                                  ***********
                                 *************
                                ***************
                               *****************
                              *******************
                             *********************
                            ***********************
                                       *
                                       *

               PLEASE WAIT WHILE LOADING TUTOR SCREENS..TUTOR.BLK 





               Scr # 6         C:TUTOR.BLK 
                                                                     
               FORTH-83 TUTOR PROGRAM AND HELP SCREENS               
                     WRITTEN  BY   BILL KIBLER                       
                          (c) 1987                                   
                    ALL COMMERCIAL RIGHTS RESERVED                   
                                                                     
                                                                     
        This program will help beginners and past FORTH users        
     alike. The screens contain information on FORTH-83 and are      
     related to the  book " STARTING FORTH "  by Leo Brodie, which   
     should be used as a textbook with this program. Each chapter    
     or series of screens is organized to present the words used in  
     the chapter in a glossary form. Forth users will find this      
     glossary important to see the differences between F83 and other 
     versions. Typing HELP will repeat these screens, then type      
     the chapter number for the area of help needed. Typing ESC key  
     will exit the screens and return to the system prompt.  GET will
     display next chapter of  information, while REPT will start     
     with the first screen of the chapter again. START-TUTOR will    
     start with the introduction chapter.                            
                          NEW F83 WORDS                              
     The following words are important utilities in F83 and may be   
     different from previous versions. WORDS will display a list of  
     F83 words used. OPEN allows use of an existing file, 10 MORE is 
     used to add 10 screens, and 30 CREATE-FILE NAME.BLK (opens 30   
     screens). INDEX displays a list of line 0, 1 20 INDEX will list 
     screens 1 to 20. 1 30 SHOW will print 6 screens to a page on    
     your printer in condensed mode ( use:  ' EPSON IS INIT-PR for   
     epson printers). 1 30 TRIAD prints three to a page if condensed 
     print is not available. 1 30 SHADOW SHOW  will print both the   
     regular screens and the information screens on a page (not used 
     in TUTOR but in UTILITY.BLK). SEE xxxx disassembles the word    
     xxxx, while VIEW will open the source file ( on A: drive) and   
     list the screen it is in. VOCS will list the vocabularies in    
     the dictionary, while ORDER displays the path of the directory  
     search. Use DOS WORDS to see a list of the DOS dictionary words.
     CAPACITY will print the number of screens in a open file. A L   
     will toggle between the shadow and the source screens. N L will 
     display the next screen, L will list current screen, B L will   
     list previous screen. 1 EDIT will invoke the line editor with   
     screen 1 ready to edit. 0 NEW will start editing at line 0      
     and allow the text to be entered one line after the other. HEX  
     100 80 DUMP will do a hex dump of memory location 100h to 180h. 
     DEBUG LIST will allow stepping through list when used next as   
     in 1 LIST. Use BYE to exit to DOS.                                                                                    
                           TUTOR WORDS                               
       INTRO = introduction        CHP1 = fundamentals               
       CHP2 = RPN and STACK        CHP3 = editor commands            
       CHP4 = conditionals, nests  CHP5 = fixed point operations     
       CHP6 = loops  ( & nested)   CHP7 = number types               
       CHP8 = var. const. arrays   CHP9 = F83 structure              
       CHP10= Input/Output         CHP11= extensions                 
                                                                     
       GET = next chapter          REPT = begin chapter again        
       HELP = repeat these screens START-TUTOR = start at INTRO      
       SPACE BAR = next screen     ESC = stops display               
       BYE = EXITS to DOS          MENU = displays this screen       
       PRTSCR = GET and REPT pointers                                
                                                               $$

ok GET

             Scr # 10         C:TUTOR.BLK 
                          INTODUCTION                              
      Forth is a stack oriented language, a hardware independent   
   programming language and operating system. F-83 is based on the 
   Forth-83 Standard with enhancements to make it a full operating 
   environment.                                                    
          F-83 contains the Forth-83 word set, plus words for      
   debugging, editing, disassembly, assembly, DOS functions and a  
   multitasking system.                                            
         The F-83 system is available on all standard computers    
   currently being manufactured; providing a complete set of       
   portable system utilities that are independent of hardware.     
           Use this tutor program to learn F-83 and the differences
   between this version and past or commercial versions of Forth.  
   HELP will display a summary of information about F-83 and this  
   tutor program.                                                  
   This tutorial uses the well known and popular text "STARING
    FORTH" by Leo Brodie. Many references are made to the text and 
   it should be used to obtain detailed information about Forth.   
   The program does not cover everything about F83, but only       
   attempts to provide on line help information and instruction.   
       There are two versions of "STARTING FORTH" currently being  
   used.  The first edition did not contain any reference to F83   
   and was printed before 1982. This tutorial will help people with
   the first edition see the differences between FIG, Forth-79     
   and the new F83 (Forth-83).                                     
       The second edition is mostly the same information with      
   changes for the newer Forth-83. Some minor text changes have    
   been added to improve the understanding of some terms. All the  
   other changes are related to the new or different commands used 
   by F83 or contained in the Forth-83 standard.       $$          

ok GET

             Scr # 12         C:TUTOR.BLK 
                    GLOSSARY OF CHAPTER 1                          
   : xxx  yyy ; ( - )  Creates word xxx which does word yyy        
   CR   ( -- )      Do a carriage return and line feed             
   SPACES  (n -- )  Print n number of spaces                       
   SPACE   ( -- )   Print one blank space                          
   EMIT   (c -- )   Transmit a character to output device          
   ." zzz"   ( -- ) Print the output string zzz at terminal        
   +    (n1 n2 -- sum)  Adds n1 to n2 and leaves sum on stack      
   .    (n -- )     Print number on top of stack followed by space 
   ( xxx)    ( - )  Comment, ignored by the text interpreter       
                      TERMS IN CHAPTER 1                           
   COMPILE          To generate a dictionary word                  
   DICTIONARY       Forths list of words or operations             
   EXECUTE          To do the operations a word stands for         
   EXTENSIBILITY    Ability to modify, add or change words         
   GLOSSARY   A list of words defined and explaned in Forth terms  
   INFIX NOTATION   Using operators between operands               
   INPUT STREAM     Text to be read by TEXT interpreter            
   INTERPRET        To compare input text to FORTH words           
   LIFO             Last In First Out..how the stack works         
   POSTFIX OPERATION   The way FORTH operates..RPN                 
   STACK            A section of memory used as a data stack       
   STACK OVERFLOW   Stack operations used all allocated stack      
   STACK UNDERFLOW  Operations tried to read data from empty stack 
   WORD             The name of a FORTH definition                 
                                                                   
                 CHAPTER 1 FUNDAMENTAL FORTH                       
      FORTH has two main features, EXTENSIBILITY and INTERACTION.  
   New functions are added to the language by creating new words   
   and adding them to the dictionary of existing words. This       
   operation is called extending the dictionary, and thus the term 
   "extensibility".  As each new word is created it can be used    
   immeadiately to see if it functions properly. This instant      
   adding and execution of the word is the reason behind the term  
   "interactive".                                                  
        When Forth is waiting for your input, your terminal will   
   have displayed "ok" on the previous line. This means the        
   interpreter is waiting for your next input. That input can      
   be  a direct command such as 42 EMIT which will output the      
   ASCII character * (star) to your terminal.                      
        To make a new word for the dictionary, you need to follow  
   the definition structure, this is a colon (:), a space, the     
   name of your word (star), a space, the definitions, a space,    
   and lastly a semicolon indicating the end of the word. Follow   
   the semicolon (;) with the return key and the action you have   
   defined will take place.                                        
       FORTH is stack oriented, the input string is processed      
   and input which is not a defined word, is assumed to be a       
   numeric input and is pushed onto the stack.  Numbers are pushed 
   until a word is found, where upon the functions defined will be 
   performed on the numbers on the stack from the top down.        
      In the line  2 4 + . we have the numbers 2 and 4, a plus sign
   to add the two number on the stack, and a period which prints   
   the top value on the stack. This means 2 is pushed first, then  
   4 is on top, the + sign is interpreted and Forth adds the 2 and 
   4 getting 6, and places six on the stack. The next command, the 
   . removes the 6 from the stack and converts it to the ASCII     
   equivalent, before outputting it to the screen. The screen can  
   not print numbers directly, but there is a standard number which
   is used to represent the number 6, this is ASCII number 54.     
   To display the manner in which your word handles the stack 
   a standardized convention is used. The ( n1 n2 -- sum ) is      
   used to indicate that the first number ( n1 ) is push on the    
   stack first, followed by n2, the second number. Forth then      
   ( -- ) reads the word and performs the function, placing the    
   results ( sum ) on the stack. The right most item is the one    
   currently on top of the stack, or you read from left to right   
   which corresponds to bottom of stack to the top.                
        This has been a brief summary of fundamental forth as was  
   presented in "Starting Forth", please study it for more details.
   You can now try some of the samples listed in the book, just    
   wait for the "ok" prompt after you hit the space bar again. Try 
   inputting the line displayed below, to define the new word GREET
          : GREET   CR  ."   HELLO, I SPEAK FORTH   " ;            
                                                                   
   Create a word that asks for your name.                        
                                                                   
                                                                   
                    
  
  
             Scr # 18         C:TUTOR.BLK 
               GLOSSARY OF CHAPTER 2                               
   +   (n1 n2 -- sum )   adds two stack items, leave sum on top    
   -   (n1 n2 -- diff)   subtract n2 from n1, results on top       
   *   (n1 n2 -- prod)   multiplies n1 times n2                    
   /   (n1 n2 -- quot)   divides n1 by n2, quotient on top         
   /MOD  (n1 n2 -- u-rem  u-quot)                                  
                divides and leaves quot on top, remainder below it 
   MOD  (n1 n2 -- u-rem) divides and leaves only the remainder     
   SWAP  (n1 n2 -- n2 n1) swap the order of the top two items      
   DUP  (n -- n n)   make the top two items the same               
   OVER  (n1 n2 -- n1 n2 n1) copy second item on top of stack      
   ROT  (n1 n2 n3 -- n2 n3 n1) puts third item on top of stack     
   DROP (n -- )  throw away top stack item                         
   2SWAP  (d1 d2 -- d2 d1) swap the top two PAIRS of numbers       
   2DUP   (d -- d d)  duplicates the top PAIRS of numbers          
   2OVER  (d1 d2 -- d1 d2 d1)  copy second PAIR, push on top       
   2DROP  (d -- )  drop the top PAIR of number off of stack        
                                                                   
                TERMS IN CHAPTER 2                                 
   DOUBLE LENGTH NUMBERS  Twice the length of the hardwares normal 
         word length. In 16 bit words that would be a 32 bit number
         and typically is a value of plus or minus 2 Billion       
                                                                   
   SINGLE LENGTH NUMBERS   The normal length of words used by this 
         version of Forth, typically -32768 to +32767. These are   
         intergers or whole numbers (no decimal points allowed)    
                                                                   
                                                                   
                                                                   
                                                                   
              Chapter 2 How to get results                          
                                                                   
      Forth arithmetic is similar to a number of calculators one   
   can buy. These calculator are usually called RPN or Reverse     
   Pollish Notation calculators. They operate on a stack type      
   structure and require at least two items on the stack before    
   you can add, subract, multiply, or divide. Forth uses the +     
   (plus) sign for addition, - (minus) sign for subtraction, *     
   (star) for multiplication, and / (slash) for division.          
       These procedures are used with interger math, or whole      
   numbers only. On most Forths these are +32767 to -32768. This   
   interger math requires some thought on the users view point.    
   Numbers larger than these require other words or double length  
   operators, which are covered in chapter 7. For now lets look at 
   using whole numbers in division.                                
   Interger math requires more than one step when dividing. What
   happens is the results and the remainder are treated as two     
   separate whole numbers. The operation 20 4 / will divide 4 into 
   20 and produce the whole results 5. 22 4 / will also produce    
   the same answer 5, the remainder 2 is lost. If we use 22 4 MOD  
   we get remainder only 2. To get both the results and remainder  
   you can use /MOD as in 22 4 /MOD  puts 5 on top of the stack    
   the remainder below it. Remeber the . will print the top stack  
   item and make the second item the top element.                  
      In most math operations there is a means of specifing the    
   order of operations. With forth being stack oriented order is   
   determined by placement in the stack. A infix presentation of   
   4+(17*12) would be presented in forth as 17 12 * 4 + . with     
   208 being displayed. Numbers are pushed onto the stack while    
   the operators are performed in a left to right manner. We see   
   that 4 17 12 * + is the same as the previous problem. The * is  
   performed first on the top items (17 and 12) then the + is      
   used on the top (204) element and the second, now 4. The . will 
   print the results of 208.                                       
      There are several ways of handling the stack order and making
   changes to it. If you want the results of a math operation to be
   printed but still available for the next operation, you  DUP    
   the results before printing it. DUP takes and pushes the top    
   item on the stack down one and makes a copy of it on the top of 
   the stack. OVER will make a copy of the second item and place it
   on the top, or DUP the second item. To reverse the top two items
   on the stack you would use SWAP. To get the third item on top   
   and make items 1 and 2 now 2 and 3 respectiviely you use ROT. If
   you want to remove the top item we just DROP it off the stack.  
   Later on we will deal with double length number (larger than    
   32768), we also have double word or item operators, these are   
   2SWAP, 2DUP, 2OVER, 2DROP. These perform the same operation as  
   their single counterparts, they just work on two stack items at 
   a time. 2DROP will DROP the first and second items off the      
   stack.                                                          
       For more samples of these operations check the book, or play
   around with forth when you see the ok after this screen. Here   
   are some sample problems:                                       
    if a=4 and b=8 what is a*(a+b) there are two ways to do this   
    if c=3 then evaluate  ab - bc   again two ways here too        
                                                                   
     make a new word that will return the number of kilometers when
     the top stack item is number of miles.                        
                                                                   
     Try these problems or make up some of your own...             
    In this screen...number 24                                     
                                                                   
 
  
             Scr # 25         C:TUTOR.BLK 
               CHAPTER 3 GLOSSARY ( EDITOR )                       
                                                                   
   LIST  (n -)  Display screen n and make it current screen        
   LOAD  (n -)  Load n screen and interpret into dictionary        
   FLUSH        SAVE-BUFFERS and de-allocate buffers in memory     
   SAVE-BUFFERS   Write all buffers to disk files ( also use W )   
   UPDATE       Mark current screen for save to disk               
   L            Display current screen                             
   N L          Display Next screen                                
   B L          Display previous (Back one) screen                 
   A L          Toggle between current and shadow screens          
   T   (n -)    Make n the current line to edit                    
   P xxxx       Put the string xxx in the current line             
   U xxxx       Insert the string xxxx under the current line      
   K  ( -)      Exchanges the contents of insert and find buffers  
   X            Delete current line                                
   NEW   (n -)  Input multiple lines starting at n                 
   F xxxx       Find and move to END of xxxx                       
   D xxxx       Delete string xxxx and leave cursor at string      
   TILL xxxx    Delete all text from cursor to end of xxxx         
   J xxxx       Delete till begining of string xxxx                
   EDIT  (n -)  Invokes editor on n screen                         
   EDITOR       Makes the editor vocabulary current vocabulary     
   DONE         Do flush and return from editor vocabulary         
   ED           Return to editing current screen                   
   FIX xxxx     Find xxxx in unknown screen and start editing it   
   OPEN xxxx    Open file xxxx.xxx and make it current file        
   MORE (n -)   Add n more screens to the end of current file      
   COPY         Copy screens from one file to another              
   CONVEY       Move screens around within file                    
   FORGET name     Removes all word definitions back to name       
   THRU  (lo hi -) Loads all blocks between lo and hi inclusive    
   TRIAD  (n -)    Print three blocks around n on a page           
   SHOW  (lo hi -) Print 6 blocks to a page in condensed mode      
   VIEW  name      Find name in source screen and list it          
   WIPE  ( -)      Blanks the entire screen when editing           
   G   ( blk ln -)  Gets copy of line from block and insert above  
                    current line pushing lines down                
   BRING  ( blk lo hi -) GETS range of lines                       
   S xxx (n - n)  Searches for xxx in blocks n up if found n on top
   LISTING name   Print entire open file including shadows         
   KT xxx     Put all text between cursor and xxx in insert buffer 
   O xxx          Overwrites xxx onto text of current line         
   SPLIT          Breaks current line in two at the cursor         
   JOIN           Puts a copy of next line after the cursor        
   QUIT           Exit editor WITHOUT updating buffers to disk     
                                                                   
              CHAPTER 3 TERMS  ( EDITOR )                          
   BLOCK   The means of which files are divided, 1024 characters   
           is one block (BLK) and is used as screens (SCR) in forth
   BUFFER  Temporary space set aside in memory to hold BLKs or SCRs
   DISK    A short term for floppy disk and data stored there      
   EDITOR  The forth vocabulary that contains words used by editor 
   FIND BUFFER   The buffer containing the find string             
   INSERT BUFFER The buffer containing the insert string           
   LOAD BLOCK    The block which loads other blocks or screens     
   NULL DEFINITION  A word that has no action, a marker            
   OVERLAY       Data that will replace previous data or words     
   POINTER       A value or location that points to other data     
   SOURCE TEXT  The text which is the original definition of a word
                        
                 CHAPTER 3 THE EDITOR                              
      Forth contains a built in line or screen editor. This editor 
   is not like some commercial word processors, but more like the  
   line editors which come with most operating systems. Forth      
   stores all the source code for itself as plain text in screens. 
   The plain text statements are compiled through a special META   
   compiler to produce the F83 machine code program. Two files     
   contain most of the source code for F83, they are UTILITY.BLK   
   and KERNELxx.BLK. UTILITY contains the higher level utility     
   functions which you use, such as the editor's source code. The  
   KERNELxx contains all the screens necessary for making the main 
   F83 kernel as would be used on xx processor. The xx stands      
   for 86, a short way of saying 8088/86 CPU which is used in the  
   IBM PC line of computers.                                       
        Suppose you want to change some printer directives, which   
   are in the utility files. Currently F83 uses Epson printer codes
   when invoking condensed modes of printing. Your printer uses    
   different codes from the Epson. To find the screen where this   
   code is we use FIX EPSON, after the file has been opened using  
   OPEN UTILITY.BLK. This will display the screen (44) which has   
   the source code word EPSON, and position the editor after this  
   word. You can now use the editor commands to change the control 
   code invoked using the word EPSON. When you have made the change
   DONE will exit the editor saving changes. Reloading the sytem   
   will give you the new printer commands. Also you could have     
   entered the minor changes directly from the terminal, but you   
   would have to do this each time you loaded the system.          
       In creating this tutor program, I have created a number of  
   blank blocks by typing 30 CREATE-FILE TUTOR.BLK. This then      
   allows me to do 1 EDIT and start creating the source code for   
   this program. The editor will then ask me for the ID........    
   and I will type my initials and current date. Becuse not all    
   forths reconize the back slash as comment line I use the ) as my
   last item in the ID line. I start my screen with 0 NEW and will 
   type the first entry starting with a (  indicating a comment    
   is next. At this point you can type text one line after the     
   other, watching for the end of the line, the editor does not. 2 
   blank lines denotes end of NEW lines and you can then go back   
   and correct any mistakes.                                       
       Some samples of editing are; 3 T to select line 3 to edit.  
   Using P NOW will put NOW on line 3. U NEXT will put NEXT on line
   4. If we type F T the cursor will be after the T on line 4. Now 
   you can type I TIME and line 4 will have NEXTTIME on it. To get 
   space between the Ts go 4 T again to get back to the begining of
   the line, then F again (no T needed, buffer still has it) and   
   the cursor will be after the first T, do I  with two spaces, the
   return will then put a space between the Ts. You can of course  
   start a line with spaces or any items. The editor is not very   
   fancy, but it is in most versions of forth, meaning once learned
   you can use it on any machine your forth is running on.         
      The instructions in the text are similar and do cover the    
   main commands used in most forth editors. F83 uses different    
   commands to move screens around. To load screens from the       
   utility file to this (which is already open and is the current  
   file) you would type FROM UTILITY.BLK 1 10 COPY this will copy  
   screen 1 of utility to screen 10 of TUTOR. Now to copy a string 
   of files you use CONVEY, such as 11 HOP 1 6 CONVEY to copy      
   screens 1 to 6 of TUTOR to 12 to 17 of TUTOR. The HOP means to  
   jump over 11 screen from the first one and start the copying    
   there. 1 6 TO 12 CONVEY does the same as 11 HOP. For moving     
   screens between files, we would use the FROM UTILITY.BLK command
   (after the OPEN TUTOR.BLK) and then 1 20 TO 30 CONVEY and this  
   will copy screens 1 to 20 of utility to 30 to 50 of tutor. You  
   may need to do 20 MORE first, which adds 20 empty screens to the
   currently opened file.                                          
       If you have made backups of the TUTOR.BLK files, now would  
   be a good time to try editing. If you use 25 35 INDEX you will  
   find out which screens are blanks and you could use one of them.
   The last screens are blank and ready for your playing around.   
   Try creating some new words and then LOAD the screen, which will
   add the words to the dictionary. Another way to find empty      
   screens is 1 IND this will give the index or line 0 of each     
   screen starting with 1 until end of file is reached or you hit  
   the ESC key. Use QUIT if you dont want to save edits........ $$ 
 
  
             Scr # 34         C:TUTOR.BLK 
               CHAPTER 4 GLOSSARY ( DECISIONS )                    
                                                                   
   IF xxx   IF: (f -) If f is true execute xxx, otherwise do yyy   
     ELSE yyy         continue with zzz regardless, the ELSE yyy   
     THEN zzz         is optional.                                 
   =   (n1 n2 - f)    Return a true flag if n1 and n2 are equal    
   <>  (n1 n2 - dif)  Returns true if n1 and n2 are not equal      
   <   (n1 n2 - f)    Returns true if n1 is less than n2           
   >   (n1 n2 - f)    Returns true if n1 is greater than n2        
   0=  (n - f)        Returns true if n equals zero                
   0<  (n - f)        Returns true if n is negative                
   0>  (n - f)        Returns true if n is positive                
   NOT (f - f)        Reverse the results of the last test (0=)    
   AND (n1 n2 - and)  Returns the logical AND of n1 and n2         
   OR  (n1 n2 - or)   Returns the logical OR of n1 and n2          
   ?DUP   (n - nn) or (0 -0)  Duplicate only if n is nonzero       
   ABORT" xxx "       Abort operation and print xxx error message  
             (f -)    also clear users stacks, if false no action  
   XOR   (n1 n2 -xor)  Exclusive or, true if both n not true       
                                                                   
               CHAPTER 4 TERMS ( DECISIONS )                       
   ABORT     Abruptly cease operation if procedure isn't acceptable
   AND       Output is true if both inputs are true                
   BRANCHING If input condition occurs jump to another routine     
   COMPARISON  Check and flag if two items are the same            
   CONDITIONAL  Different operation if flag true than when false   
   FLAG      A variable when set equals true, reset equals false   
   LOGIC     Using operators like AND, OR, NOT to make statements  
   NESTING   Branching routines within branching routines          
   OR        If either of two inputs are true the results is true  
                                                       
            CHAPTER 4 DECISIONS, CONDITIONALS                      
       In any computer language, terms are used to express math    
   forms and types. We like to compare items and say how one is    
   larger or smaller than an other. You may also base an action    
   on the results of such a comparison. Forth can also do the      
   same types of comparisons. We can tell forth to do something IF 
   some condition is met. The proper term for this is IF THEN      
   statements. To help make these comparisons there are several    
   operators we can use. They can be = for equals, < 2nd stack item
   is less than top item, > 2nd item is greater than top item, 0=  
   the top item is equal to zero, 0< the top is less than zero, 0> 
   the top is greater than zero.                                   
       All of these operations depend on setting a FLAG variable.  
   This flag is a special indicator set as either true or false.   
   IF THEN logic operations work by checking the flag to see if it 
   is true or false. If true THEN do xxx ELSE if false do zzz.     
   The IF statement can be any form of testing, including regular  
   math operations. A sample math operation is comparison <> where 
   if two items are the same, the results will be zero, and so the 
   flag will be set false (treated as subtraction).                
       There are non math operators that can do comparison based on
   logic operations. These logic operators are AND, OR, and NOT.   
   AND sets the true flag if both stack items are also true, OR if 
   either stack items is true, while NOT reverses the flag setting.
   Forth has some words which contain conditional tests within them
   ABORT" and ?STACK. ABORT" print the statement contained within  
   the " " if the flag is set, leaves the current program and      
   resets all stacks before  the Forth ok. ?STACK flags true if    
   the stack is empty, as when waiting for keyboard input.         
   Lets do a simple IF THEN routine to show the forth way of   
   handling conditionals. Lets test to see if a pupil answers a    
   question correctly when faced with four choices;                
      : ckansw   ( check the answer and prompt accordingly )       
           DUP  1 = IF ." WRONG" CR  12 TUTOR     ELSE             
           DUP  2 = IF ." CLOSE BUT REREAD QUESTION " ELSE         
           DUP  3 = IF ." GOOD CHOICE "          ELSE              
           DUP  4 = IF ." BETTER LUCK NEXT TIME.. " ELSE           
                       ." ENTER VALUE OF 1 2 3 or 4 ONLY "         
                    THEN THEN THEN THEN DROP ;                     
   This new word CKANSW, checks the item on top of the stack to see
   if it matches or equals the value we want. If it does, print the
   statement and then continue checking unitl last "then" is used. 
   When a non match occurs the prompt to enter a new value is now  
   displayed. Try your own conditional program in SCR # 39.....    
      ( here it is for you to change or use )                       
                                                                   
      : ckansw   ( check the answer and promt accordingly )        
           DUP  1 = IF ." WRONG" CR  12 TUTOR     ELSE             
           DUP  2 = IF ." CLOSE BUT REREAD QUESTION " ELSE         
           DUP  3 = IF ." GOOD CHOICE "          ELSE              
           DUP  4 = IF ." BETTER LUCK NEXT TIME.. " ELSE           
                       ." ENTER VALUE OF 1 2 3 or 4 ONLY "         
                    THEN THEN THEN THEN DROP ;                     
                                                                   
                                                                   
             Scr # 40         C:TUTOR.BLK 
             CHAPTER 5 GLOSSARY ( INTERGER MATH )                  
                                                                   
   1+    (n - n+1)  Adds one to n                                  
   1-    (n - n-1)  Subtracts one from n                           
   2+    (n - n+2)  Adds two to n                                  
   2-    (n - n-2)  Subtracts two from n                           
   2*    (n - n*2)  Multiplies n by two (shift left )              
   2/    (n - n/2)  Divides n by two ( shift right )               
   ABS   (n - |n|)  Returns absolute value of n                    
   NEGATE (n - -n)  Changes the sign of n                          
   MIN   (n1 n2 - n-min)  Returns the minimum n (either n1 or n2)  
   MAX   (n1 n2 - n-max)  Returns the maximum n (either n1 or n2)  
   >R    (n - )   Place stack top item on return stack top         
   R>    ( - n)   Load top of stack with top of return stack       
   R@    ( - n)   Make a copy of return stack, put on top of stack 
   */   (n1 n2 n3 - n)  Multiplies then divides (n1*n2/n3)         
   */MOD (n1 n2 n3 - n-rem n-result) Get remainder, quotient on top
                                                                   
                                                                   
             CHAPTER 5 TERMS ( INTERGER MATH )                     
                                                                   
   Double length intermediate result   Steps within an operation in
         which the number size has twice the normal digits, inorder
         to minimize errors.                                       
   Fractional arithmetic    The handling of numbers without the    
         decimal point, using whole numbers, and later returning   
         the decimal point to its proper place.  FIXED POINT can be
         used inplace of fractional, they mean the same.           
   Floating point math     Number containing the decimal point     
         and requiring adjustments before use by a computer.       
  Parameter stack    The main data stack which is used to pass    
         data between operations of the forth machine. Generally   
         referred to simply as STACK or data stack.                
   Return stack      The stack used by forth for keeping return    
         addresses on during operations. Can be used for holding   
         data from stack (parameter) only WITHIN a definition.     
         Always referred to as RETURN STACK, never stack!          
   Scaling    The adjustment of floating-point numbers such that   
         all number are represent as intergers and with the same   
         relevant relationship in respect to the decimal point.    
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
             CHAPTER 5 INTERGER MATH                           
                                                                   
      Forth has a number of words that help perform math operations
   quickly and easily. All of these operations work on INTERGER    
   MATH concepts, or interger numbers. Typically these are signed  
   numbers between +32768 and -32767. To add numbers that have a   
   decimal point we mentally multiply the number by a power of ten 
   enter those numbers and then replace the decimal point after the
   operation. Some versions of Forth contain routines that will do 
   this for you, they are called floating point utilities. They can
   slow down Forth considerably and waste memory.                  
      Most Forth users prefer to use interger math for the speed   
   and memory savings. There are two words that help make interger 
    math easier */ (star slash) and */MOD (star slash MOD).        
   These words perform a multiply and then a divide (MOD produces  
   a remainder). Scaling is the method used in forth to change a   
   value so that it can be used in interger math. To use numbers   
   we scale them before use, then rescale the results back into the
   same ratio. We can use PI not as 3.1416 but 31416 10000 / and   
   when used in a formula like PI * Dia for area we use */ as in   
   4 31416 10000 */ . and we get the area of a 4 foot circle. We   
   have made the results of 4 * 31416 be 10000 time larger than in 
   you would using PI as 3.1416, but by dividing our results by    
   10000 we return it to proper scale. PI however has more places  
   than four shown and will produce some error. There are fractions
   which can represent a more accurate means of expressing this and
   other numbers, they are called rational approximations, here are
   a few: PI 355/ 113, SQRT of 2  19601/13860, SQRT of 3  18817/   
   10864, .001Deg./22-bit rev.  18118/21109.                       
       To find our answer to the area of a 4 foot circle use the   
   values of PI: 4 355 113 */ . this will be more accurate than    
   before. */ does not produce a remainder and the area of the last
   problem is more than 12 square feet. Using */MOD will provide   
   the remainder as the second item on the stack. When using the   
   remainder we can then see the difference between dividing by    
   10000 and using 355/113, which is .0736. For a more detailed and
   illustrated review of this topic check chapter 5 in STARTING    
   FORTH.                                                          
       The return stack is used by Forth to store return  addresses
   of definitions (semicolons). It can be used within a definition 
   to help shuffle values around. A good example of that would be a
   problem that uses a constant several times. Instead of dupping  
   the number and a ROT or SWAP it may be faster to copy it to the 
   return stack and make copies of it each time you need it. You   
   must remember to clear the return stack by the end or ; .       
   To help moving between the return stack and parameter stack 
   use >R to push on R< to get off and back onto the stack. R@     
   makes a copy of top of return stack and places it on top of     
   data stack.                                                     
       In most programs there are several operations that occur    
   frequently and Forth has words to help out with them. Many  a   
   time we need to add or subtract by 1 or 2, and thus the words   
   1+ 1- 2+ 2- 2* 2/ . Filtering of values is also important, so we
   have ABS for absolute value, NEGATE for changing signs, MIN and 
   MAX to find the relationship between 2 values.                  
       Try these problems or write a new word in screen 47 for each
   of these inputs,0 degrees F and 45 degrees C. Use these formulas
    C= (f-32)/1.8   and F= (C*1.8)+32 . Try and find the radius of 
   a circle with a circumferance of 23 feet.                       
                                                                   
                                                           
   What is the area of circle 12.5 feet in diameter?               
     Scr # 48         C:TUTOR.BLK 
             GLOSSARY CHAPTER 6 ( LOOPS )                          
                                                                   
   DO ... LOOP  DO: (limit start -- ) LOOP: ( -- )  This word      
             sets up a finite loop, with a starting value and      
             a ending or limit value ( loop does no action         
             accept return to begining of DO).                     
   DO ... +LOOP  DO: (limit start -- ) +LOOP: (n -- ) Same as      
             plain loop, but adds n to value each time it loops.   
   LEAVE  ( - )  Terminates loop at next LOOP or +LOOP.            
   BEGIN .. UNTIL    UNTIL: (f - )  Loops until f becomes true.    
   BEGIN xxx WHILE yyy REPEAT   WHILE: (f - )   Loop doing xxx     
             while yyy remainds true, leave when f is false.       
   .R  (n width -- )   Prints unsigned value right justified       
             within specified field width.                         
   PAGE  ( - )   Send a form feed to the terminal or printer       
   QUIT  ( - )   Kills current execution and returns to terminal.  
 
 
                                                                   
               CHAPTER 6 TERMS ( LOOPS )                           
                                                                   
 
   DEFINITE LOOP    A looping routine which will execute as many   
              times as needed to reach a fixed value after starting
              from some preset value.                              
   INFINITE LOOP   More often called a LOCKED UP COMPUTER, one that
              will never reach a determined value.                 
   INDEFINITE LOOP    Not to be confused with a infinite loop, this
              loop ends when some predetermined value is reached.  
              Changes in flags or values will end these loops. This
              loop starts with BEGIN, while definite loops use DO. 
                                                                   
                                                                   
              CHAPTER 6 LOOPS                                     
                                                                   
    Loops are an extension of branching, it's just that they will
   branch back to the begining of the word DO or BEGIN. A DO loop  
   takes values off the stack, the starting value on top and the   
   ending value below. The staring value is increased by one each  
   time through the loop until  it equals the ending value. The    
   operations contained within the DO and LOOP are performed until 
   the items are equal. These items are not kept on the data stack 
   but stored on the return stack, which you can copy and print by 
   using the word I (see last chapter for more info). This value   
   is called the index and can be used within the loop to create   
   new values or pointers.                                         
       +LOOP takes the value off the stack and increments the loop 
   counter by this amount. +LOOPs can then count by steps to the   
   limit value, which is the second value on the return stack (use 
   I' to copy to data stack). Be careful of using 0  in loops,     
   becuse you could end up multiplying by 0 and never reach your   
   ending value, this is an infinite loops, never ends.            
       The other form of looping is the indefinite loop which      
   starts with BEGIN and ends with UNTIL. This loop will repeat    
   what is between the BEGIN and UNTIL, as long as the flag remains
   true. This means you must perform some test within the loop     
   that will change the flag. A modified version of this loop is   
   BEGIN WHILE REPEAT loop. This loop works just the opposite of   
   the BEGIN UNTIL loop, it works only while the flag is true.     
   When the flag goes false this loop ends.                        
       A regular DO LOOP can be ended early by LEAVEing it. Using  
   LEAVE within the loop will terminate the loop, so to prevent an 
   unwanted leave, enclose the term LEAVE within an IF THEN        
   statement. The IF is checked and as long as the condition is not
   true, the loop will not be terminated by LEAVE but continue on  
   with THEN.                                                      
        The text has several good examples of DO LOOPs and how to  
   use them. The text omits any BEGIN UNTIL loop problems, so lets 
   see if we can create a word using this loop. If printing stars  
   on the screen remember to clear it first with PAGE. Now lets    
   see if you can create a christmas tree using stars when the     
   stack contains the height or width as a value.                  
       Should you want to see a sample of printing a tree with     
   the lowest branch value used as width, displayed at begining,   
   then enter 25 TREE for a tree with 25 stars accross the bottom. 
   If you want you can try and make the value enterd equal the     
   number of branches ( not stars ) by editing screen 53. Try it   
   first before looking at screen 53, it is more fun.....  $$      

ok GET

             Scr # 53         C:TUTOR.BLK 
                                                                   
   : STAR     42  EMIT  ;  ( print star )                          
   : STARS   0 DO STAR LOOP  ;  ( print many stars )               
                                                                   
   : TREE    ( n -- )  ( expects width to be on top of stack )     
             2/ 2* 1 +  ( guarantee it is odd )                    
          PAGE    CR CR   ( clear screen and move down  )          
          1 39  DUP  SPACES  STAR  ( get set and do a star )       
       BEGIN  CR  1 - DUP SPACES  ( start and move across )        
          SWAP 2  + DUP  STARS ( set star count do it )            
          ROT SWAP >R DUP  R> SWAP >R DUP >R  ROT                  
           R> R>  =  UNTIL  ( shuffle  and check star to count )   
         CR 39 SPACES STAR CR 39 SPACES STAR CR CR ;               
     (  the last line draws the tree stock and moves ok down )     
           (   $$     )                                            

ok GET

             Scr # 54         C:TUTOR.BLK 
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
             CHAPTER 7 GLOSSARY ( NUMBERS )                       
                                                                   
   ASCII  ( - c)  Translate character into ASCII equivalent        
   U.   (u - )  Prints unsigned number and one space               
   U.R  (u wdth -) Display right justified unsigned number         
   U<   (u1 u2 - f) Flag true if u1 < u2, single length unsigned   
   HEX  ( - )   Set number base to sixteen                         
   OCTAL  ( - ) Set number base to eight ( not on all systems )    
   DECIMAL ( - ) Set number base to ten                            
   <#           Begins number conversion, unsigned double length   
   #            Converts digit to output character string          
   #S           Convert number until result is zero                
   c HOLD       Insert an ASCII character in string at HOLD point  
   n SIGN       Inserts minus if n is negative in string           
   #>           Leaves number string and stack ready for TYPE      
   D+  (d1 d2 - d-sum)  Adds two 32 bit numbers                    
   D-  (d1 d2 - d-diff) Subtract two 32 bit numbers                
   DNEGATE (d - -d)     Change sign of 32 bit number               
   DABS  (d - |d|)      Returns absolute 32 bit value              
   DMAX  (d1 d2 - dmax) Returns maximum of two 32 bit numbers      
   DMIN  (d1 d2 - dmin) Returns minimum of two 32 bit numbers      
   D=    (d1 d2 - f)    Flags true if d1 and d2 are equal          
   D0=   (d - f)        Flag true if d equal zero                  
   D<    (d1 d2 - f)    Flag true if d1 less than d2               
   DU< (ud1 ud2 - f)    Flag true if unsigned d1 < unsigned d2     
   D.  ( d - )          Prints signed 32 bit number                
   D.R ( d width - )    Prints signed 32 bit right justified       
   UM* (u1 u2 - ud)     Multiply two 16 bit, gets 32 bit unsigned  
   UM/MOD (ud u1-u2 u3) Divides 32b by 16b, gets 16b rem and quot. 
   M*  (n1 n2 -d-prod)  Multiplies two 16b gets 32 bit result      
   M+  (d n - d-sum)  Adds a 32b to 16b, returns 32bit number      
   M/  (d n - n-quot) Divides 32b by 16b, get 16b signed results   
   M*/ (d n u - d )   Multiplies then divides 32 by 16 get 32 bit  
                                                                   
                                                                   
             CHAPTER 7 TERMS ( NUMBERS )                           
                                                                   
   ARITHMETIC SHIFTS   Process of moving bit left or right, which  
             is same as multiplying or dividing by two.            
   ASCII     The standard system of representing characters with   
             numbers, eight bits in length.                        
   BINARY    Number base of two, either on or off                  
   BYTE      Term for 8 bit value                                  
   CELL      A Forth term for 16 bit value                         
   DECIMAL   The number base of 10                                 
   HEXADECIMAL   Number base of 16                                 
   LITERAL       A number that appears inside a definition         
   MASK          A means of filtering out unwanted bits            
   NUMBER FORMATTING  Changing binary number to display characters 
   OCTAL         Number base of 8                                  
   SIGN BIT      A bit used to indicate sign in signed numbers     
   TWO'S COMPLIMENT   The binary method used to add negative values
   UNSIGNED NUMBER    A positive number                            
   UNSIGNED SINGLE LENGTH NUMBER  An interger between 0 and 65535  
   WORD          In Forth the defined dictionary entry that will   
                 perform some function or command                  
                                                                   
                                                                   
                                                                   
                                                                   
               CHAPTER 7  NUMBERS                               
                                                                   
       Computers have only one way to handle numbers, that is the  
   BINARY method. Everything inside computers is either a one or   
   zero, a on or off, or combinations of these two states. Binary  
   is the term for this type of handling data. Humans however have 
   considerable trouble understanding these on and offs values, so 
   we have created number systems for the different ways we want to
   represent data.                                                 
       In a previous screen I indicated that ASCII characters is   
   what a computer uses to display information. A number has been  
   asigned for each character we wish to display. These and any    
   number can be represented in a binary form. To send a carriage  
   return to your screen we send a value of 13 decimal. The binary 
   representation of 13 is 00001101 and is what the computer       
   actually sent to the display. Several shorthand methods are used
   to indicate binary values. Some older computers use OCTAL or    
   base 8. Most new machines use HEXADECIMAL or base 16. Four bits 
   of binary 1 or 0s is used to get the hexadecimal value. Four HEX
   (short for hexadeciaml) values will represent the sixteen bits  
   used in most of Forths single numbers. Double numbers are based 
   on using 32 bits or eight hex values. Remember the hex values   
   are just easy ways to express the 4 places of on and off data.  
       In forth we use normally 16 bits to represent an unsigned   
   number, 15 bits for a signed number with the 16th bit being the 
   sign. When counting in binary that is 65535 for unsigned and a  
   range of +32768 to - 32767 for signed numbers, all 16 bits. For 
   binary arithmetic check the book, it has some good samples      
       There are a number of Forth words which binary understanding
   helps in knowing what they do. ASCII numbers are used by the    
   EMIT word. This command emits an number to the display system.  
   F83 can take a character and automatically convert it to a ASCII
   value. Using ASCII * EMIT will send a star to the display. The  
   same technique is used when changing base number systems. HEX   
   0A 12 + . will produce 1C as the answer. To get a decimal value 
   do HEX 0A 12 + DECIMAL . and it will print 28.                  
       There are many ways to display numbers in Forth. To print   
   unsigned (16bit) numbers U. will print what is on the stack plus
   a space after it. If you want numbers in a column use U.R where 
   stack top has the width of the column, and the second down has  
   the number that will be right justified. For DO LOOP compares on
   unsigned numbers use U< to flag true if U1 is less than U2. We  
   can do the same functions with double length numbers (32bits).  
   D. prints signed numbers, UD. prints unsigned numbers, D.R like 
   U.R for signed 32 bit numbers, and DU< is 32 bit U<.            
   To display numbers it is necessary to format their output.  
   This formatting inserts . or / to indicate money or dates. The  
   method in Forth is to asign positions in a string, relative to  
   digits in the number being printed. The format words are <# # #>
   and HOLD TYPE #S ASCII all can be used within the string. To    
   start a layout use <# then number of numbers used, your period  
   as a number (45) HOLD to hold a place by inserting a .   there  
   and then #S to fill in any remainding numbers. The real problem 
   is the left most #, will be the right most number, or if we have
   4 #s before the hold, it will have four values after the HOLD.  
   We also need to end the string with a #>, followed by TYPE which
   will display the formatted number. No space is printed after    
   TYPE so you may need to follow it with a SPACE or n SPACES. You 
   should try some of the samples in the book to get a better      
   grasp of number formatting.                                     
   There are a few double length operators that help handle    
   relationship between numbers. These are, DNEGATE which changes  
   the sign of a 32 bit number, DABS that returns the absolute     
   value, DMAX and DMIN for minimum and maximum of two numbers, D= 
   set flag true if two doublelength numbers ar equal, D0= if the  
   number is zero, D< true if d1 is less than d2. Remember these   
   operate the same as their single length number, but work on 32  
   bits of data, not 16.                                           
       As with single length number, some operations will require  
   intermediate answers that are longer than 32 bits. In */ the    
   16 bit values used a 32 bit intermediate value to maintain the  
   accuracy. M*/ takes a 32 bit number and multiplies it by a 16   
   bit getting a triple length results (48 bits), and then dividing
   by a 16 bit number, return the answer as a 32 bit value.        
      There are several other MIXED LENGTH OPERATORS, they are UM* 
   mulitplies two 16 bits for a 32 bit answer, UM/MOD divides a 32 
   bit by a 16 bit, getting 16 bit answers all unsigned, M* takes  
   two 16 bits and multiplies for a signed 32 bit value, M+ adds a 
   32 and a 16 bit number for a 32 bit answer, M/ a 32 by 16 for a 
   16 bit answer.                                                  
     One must remember that the number base you are in is used when
   compiling a word. Inserting a HEX will not have the values in   
   the word compiled as hex values if you are in decimal at the    
   time. When words are executed, if they contain a number base,   
   the base will change at that time and interpret the numbers that
   were stored literally into the equivalent base value.           
       The book has more details and some interesting problems. A  
   good problem is creating a BIT mask using a DO LOOP. A good and 
   useful word would be one that display bit patterns for values   
   entered, in both 16 and 32 bit lengths.                         
   Try some large size math problems using the new words from   
   this chapter.                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                             
             Scr # 66         C:TUTOR.BLK 
               CHAPTER 8 GLOSSARY  ( VARIABLES )                   
                                                                   
   CONSTANT xxx  ( n -)  Creates a constant xxx with a value of n  
   VARIABLE xxx  ( - )   Creates a variable xxx, xxx gets address  
   CREATE xxx    ( - )   Creates dictionary header xxx             
   !    ( n a -)   Stores single length number into address        
   @    ( a - n)   Fetches contents of address to stack            
   ?    ( a -  )   Prints contents of address and a space          
   +!   (n a - )   Adds n to contents of address (single length)   
   ALLOT ( n - )   Adds n bytes to the PFA of recently defined word
   ,    ( n - )    Compiles n into next available cell in dict.    
   C,   ( b - )    Compiles b ( byte) into available cell of dict. 
   C!   (b a - )   Store a 8 bit value into address                
   C@   ( a - b)   Fetch an 8 bit value ( byte) from address       
   FILL (a u b -)  Fill memory u bytes long, starting a, with b    
   ERASE  (a u -)   Stores u zeros starting at address a           
   BASE   (  - a)   Variable containing value of number base       
   DUMP   (a u - )  Display u bytes of memory from a address       
   2VARIABLE xxx    Creates double length variable                 
   @CONSTANT xxx    Creates double length constant                 
   2!     ( d a - ) Stores double length number into a address     
   2@     ( a - d ) Fetches double length double from a address    
   0.     ( - 0 0 ) Puts a double length zero on stack             
   FALSE  ( - 0 )   Returns a zero or false condition              
   TRUE   ( - -1)   Returns a -1 or all 16 bits set to one         
                                                                   
                                                                   
                                                                   
               CHAPTER 8 TERMS ( VARIABLES )                       
                                                                   
   ARRAY      A series of memory locations referenced by one name  
   CONSTANT   A fixed value referenced by a single name            
   FACTORING  Pulling out common steps of a program into own words 
   FETCH      To retrieve a value from a memory location           
   INDEX      A number indicating a location within an array       
   INITIALIZE    The setting of an array to known values           
   OFFSET     An value added to address, pointing into an array    
   STORE      Placing a value into memory location                 
   VARIABLE   Memory location for storing changing values          
                                                                   
                                                                   
                                                                   
                                                                   
                  CHAPTER 8 VARIABLES AND ARRAYS                   
                                                                   
   Most programs, including tutor.blk, need to use variables   
   and constants. Variables are pointers, temporary sums, or any   
   values that can be changed. Constants are values that are used  
   by programs and generally are not changed. Forth requires these 
   locations to be declared before use, using either VARIABLE or   
   CONSTANT inplace of the : . This tells the compiler to define a 
   word and allocate memory for it. Constants take a value off the 
   stack and place it in the allocated memory location. When these 
   words are used they return their address to the stack for use   
   by ! @ ? or +! .                                                
      ! means to store a value in location of address on stack with
   value below it. @ gets or fetches value from address on stack.  
   ? is a combination of @ and . to get and print a value. +! adds 
   the number below the address on the stack, to the location of   
   address.                                                        
   There are double words for variables: 2VARIABLE, constants: 
   2CONSTANT, as well as 2! to store a double length variable, and 
   2@ to fetch double length variables or constants.               
       Many programs use arrays, or a number of memory locations   
   that can contain values. Arrays can have fixed values, as in a  
   table of phone numbers, or variables which can keep count of a  
   number of events. To create an array in Forth use the word      
   CREATE and the name assigned to it. The compiler will set as    
   many memory locations aside as you ALLOT to it. An array of two 
   will be defined, unless you allot more. Placing values in or out
   of an array is the same as any variable, it is just the address 
   provided will be for the first entry in the array. If you want  
   the seventh item, you must increment the address by 14 as each  
   location is 2 addresses in length. The same is true for ALLOT   
   you must double the value (10 ALLOT creates 5 16bit locations). 
   An example of an array is your programs memory. Forth has a 
   word for looking at this large array, it is DUMP. Place the     
   starting address on the stack, next push the count or how far   
   you want displayed, then DUMP and watch what is there.          
       As we said before a byte is 8 bits and is the smallest way  
   some machines handle information. You can get data from or into 
   an array in 8 bits at a time. Arrays of characters are all 8 bit
   entries. C! stores 8 bits, while C@ fetch 8 bits, just remember 
   to set the address one step for each location in the array.     
       The , is used to create a constant with values entered at   
   time of compilation. Use values and a , for each entry instead  
   allotting space (do not forget the last , ).                    
       Variables, constants, and arrays are easy to create in Forth
   and just as easy to use. For a problem we can use the topic of  
   last chapter and this to create a telephone listing or array.   
   This array should contain numbers and when queried with an      
   index produce formatted output. Lets give it a try...           
                                                                   
                                                                   

Scr # 73 C:TUTOR.BLK

           CHAPTER 9  GLOSSARY  ( FORTH ENGINE )                   
                                                                   
   ' xxx  ( - a )   Returns dictionary address of xxx              
   [']    ( - a )   Generates literal number used inside the words 
                    definition of the next word used in definition 
   EXECUTE  (a -)   Executes the dictionary entry at address a     
   @EXECUTE (a -)   Executes entry pointed to at address a         
   >BODY  (cfa -pfa)  Returns parameter field from compilation addr
   EXIT   (  -- )   Terminates or returns from definition          
   QUIT   ( --  )   Clears stack, gets control, no ok prompt       
   ABORT  ( --  )   Clears data stack then does QUIT               
   DP      ( - a)   Returns address of dictionary pointer          
   HERE   ( -- a)   Next available dictionary location             
   PAD    ( -- a)   Beginning address of character string buffer   
   SP@    ( -- a)   Pointer to top of data stack                   
   S0    ( -- a)   Returns address of bottom of data stack         
   TIB   ( -- a)   Returns address of text input buffer            
   FORTH  ( -- )   Makes FORTH context vocabulary                  
   EDITOR ( -- )   Makes EDITOR context vocabulary                 
   CONTEXT ( - a)  Returns address of search order variable        
   CURRENT ( - a)  Returns address of new word vocabulary ( vocs)  
   DEFINITIONS     Sets the current vocs to context vocs           
                                                                   
                                                                   
                                                                   
                                                                   
            CHAPTER 9 TERMS ( FORTH ENGINE )                       
                                                                   
   ADDRESS INTERPRETER   Interprets the address from the colon     
             definitions and executes them                         
   BODY      The code and parameter of a dictionary entry          
   BOOT      The basic starting portion of Forth, precompiled Forth
   CFA       Address of code field in a dictionary entry           
   CONTROL TASK   A task that does not converse with Forth         
   CODE POINTER FIELD   The entry in the dictionary that points to 
             the run time code                                     
   DEFINING WORD  A Forth word that creates a dictionary entry     
   ELECTIVES      Optional blocks of words like floating point math
   FORWARD REFERENCE   Refering to undefined words                 
   HEAD      Name and link field of dictionary entry               
   LINK FIELD     Pointer to next entry of vocabulary, search order
   NAME FIELD     Location of name of word, includes word length   
   PAD       Area of memory for intermediate data storage          
   PARAMETER FIELD    The area of the definition in which the      
             actual code or values are contained                   
   PFA         The address of the first entry of parmeter field    
   PRECOMPILED PORTION   The Forth system loaded at boot time with 
               all dictionary words and terms ready to use         
   RUN-TIME CODE     Usually the actual code that is the word      
   SYSTEM VARIABLES  Variables usuable by all users in system      
   TASK        A area of memory set aside for a given activity     
   TERMINAL TASK     A task that has a user talking to Forth       
   TEXT INPUT BUFFER   Memory area containing terminal input data  
   USER VARIABLE     Variable accessible by one user only          
   VECTORED EXECUTION   Executing words by going to a pointer      
   VOCABULARY        An independent linked list of words. In F83   
   SHADOW EDITOR HIDDEN BUG ROOT USER ASSEMBLER  
                     DOS FORTH are vocabularies. Use VOCS to see   
                     this list of vocabularies.                    
                                                                   
                                                           
              CHAPTER 9 FORTH ENGINE                               
                                                                   
       Forth is a THREADED programing language. This means that a  
   action amounts to performing one instruction contained within   
   an instruction. Words which perform the actions are made up of  
   lists of addresses of words that together will perform the      
   desired action. These words within words can also have words    
   within them. If you follow the actual actions it is like a      
   thread linking all the actions together.                        
       In comparing Forth to assembly language it would be like a  
   routine calling a subroutine which calls a subroutine and can   
   call more till it finally does something and then returns back  
   through each of the called routines. That final actual code     
   performing actions makes up the KERNAL of the system.           
   The kernal is written in native code of the machine it is   
   on. The kernal creates the stack and basic operations of Forth. 
   Utilities are then written using Forth words, building blocks   
   until a full system is created. To move the system to another   
   type of processor requires rewritting only the native code of   
   the inner most kernal, not the utilities.                       
       Most computers are made up of CPU or central processor units
   which have a number of registers and instructions to move data  
   between registers and the outside world. What Forth does is to  
   create an artificial processor in software that can be moved    
   to different machines. This created processor can give the user 
   near assembly language performance, while being transportable.  
       In F83 we have the normal kernal using the Forth-83 word set
   as well as many utilities, which create a full system. All these
   abilities are contained in the dictionary. When Forth words are 
   interpreted, FIND searches the dictionary for a match, and then 
   EXECUTES the instructions. What is passed is not actual words   
   but their address. An word contains addresses or machine code.  
   The kernal items are mostly code, while utilities are mostly    
   addresses pointing to code containing words.                    
       Forth has several ways to handle words by the user, one way 
   is ' which returns the address of the word, use U. to see the   
   actual address of a word ( ' SEE U. ). What interpret does is ' 
   the word then does EXECUTE on the address on the stack. This is 
   not the address of the first address of a dictionary entry, but 
   the third. Lets look at how words are arranged.                 
       When you create or define a word, several entries in memory 
   are completed. The word name is stored, up to 32 characters in  
   F83, after a count of the length of the name. Next is the link  
   to the next item in the current vocabulary. This link tells the 
   interpreter where next to look if the current word is not a     
   match. After the link is the CODE FIELD ADDRESS or CFA. This is 
   what is returned by ' and points to the code or code intrepter. 
   The interpreter can be one of three types, variable, constant or
   code. The variable and constant return address or values on to  
   the stack respectively. The code points to either actual machine
   code if it is a kernal item, or more CFA's. What it points to is
   called PARAMETER FIELD or PFA, and given the CFA >BODY will put 
   the PFA on the stack.                                           
       There are other actions that occur while the interpreter is 
   going through the PFA, mainly pushing the next PFA onto the     
   return stack. This is why use of the return stack must be done  
   within the : definition, not doing so destroys the pointer to   
   the next word. You can carefully handle this stack and cause    
   wanted results by dropping off pointers, use caution though!    
   You can officially leave a diffinition, using QUIT ABORT or 
   ABORT" any of these three end the operation. Generally these    
   ways are used inside of IF THEN or DO LOOPs checking for flags  
   or problems. When the last PFA is found the word EXIT is left.  
   This word removes the pointer from the return stack and this is 
   interpreted next. EXIT can not be used inside of DO LOOP as it  
   will return loop counters and not addresses.                    
       There are some ideas and words that you should know which   
   relate to the memory map of a Forth system. Normally from low   
   memory up is the kernal, system variables, utilities, users     
   dictionary space, the PAD, DATA STACK, TIB, RETURN STACK, users 
   variables, and block buffers. The users dictionary grows toward 
   the PAD, while the DATA and RETURN stacks grow down toward low  
   memory. The stack is actually a pointer to memory locations and 
   is lowered each time an entry is made.                          
   To find these locations in memory, use DP to find the last  
   or highest memory location free for new dictionary word entries.
   DP is the pointer while HERE will place the pointer value on the
   stack ( same as DP @ ). To find the true location of the stack  
   use SP@ and it will fetch the pointers value, while S0 will get 
   the starting address of the stack. In higher memory above the   
   data stack is the TIB or Text Input Buffer and it grows  up     
   toward higher memory. TIB fetches the starting address of the   
   buffer. The input line interpreter reads this buffer to find out
   what you have entered.                                          
       To improve speed of interpretation, the dictionary is sorted
   into different lists or vocabularies. When in these vocabularies
   Forth will only search those words through use of the linked    
   address value. Typing the name of a vocabulary puts you into    
   that linked list. These lists can be scanned consectatively if  
   the word is not found in the first list. VOCS will display the  
   list of current vocabualries, while CONTXET shows the search    
   order. CURRENT will print which VOCS you are now in. To see the 
   words contained in one of these list, enter DOS WORDS and you   
   will see all the dictionary entries that relate to the DOS ( and
   are used by Forth when talking to the operating system).        
       Take the time now and do some exploring in F83. Reading the 
   file README will explain some of the system terms and show a    
   memory map of a typical 8080 Forth system. Try reading all the  
   VOCS and check CONTEXT before and after changing vocabularies.  
                                                                   
                                                                   
                                                                   
                                                                   
        Scr # 84         C:TUTOR.BLK 
                    CHAPTER 10 GLOSSARY ( I/O )                    
                                                                   
   UPDATE    ( - )  Marks most recently used block as modified     
   SAVE-BUFFERS     Writes all updated buffers to disk             
   FLUSH            Does save-buffers then frees all buffers       
   EMPTY-BUFFERS    Marks buffers as empty, all data is lost       
   BLOCK  ( u - a)  Put starting address of block u on stack       
   BUFFER ( u - a)  Like block but does not load block from disk   
   TYPE   ( a # -)  Send # characters at addr a to output device   
   -TRAILING  (a #1 - a #2) Changes byte count to reflect blanks   
   >TYPE  ( a # -)  TYPE for multiusers, puts string in PAD first  
   MOVE  (a1 a2 # -)  Moves # of cells from a1 to a2 (low > hi)    
   CMOVE (a1 a2 # -)  Moves # of bytes from a1 to a2 (low > hi)    
   CMOVE> (a1 a2 #-)  Moves # of bytes from a1 to a2 (hi > low)    
   BLANK  ( a # -)  Fill a with # of blank ASCII bytes             
   KEY     ( - c)   Put next available INPUTED ASCII char on stack 
   EXPECT  (a # -)  Awaits # chars or CR from KEY storing at a     
   SPAN    (  - a)  Addrs of number of chars stored by EXPECT      
   WORD    (c - a)  Puts one word from input stream into addrs a   
   COUNT  (a -a+1 #)  Changes stack values of string a for TYPE    
   >IN    ( - a  )  Variable with pointer to next free input space 
   BLK    ( - a  )  Variable pointing to active block, 0= TIB      
   CONVERT (ud1 a1 -ud2 a2)  Convert ASCII string a1 to binary ud2 
   NUMBER ( a -d )  Convert ASCII string a to binary values d      
   -TEXT  (a1 # a2-f)  Flag true if no match in strings # long     
   -MATCH (d # s # -a f) Find match in stings s/d return addrs flag
   "      ( - a  )  Returns address of compiled string             
                                                                   
                                                                   
                                                                   
           CHAPTER 10 TERMS ( I/O )                            
                                                                   
   EXPECTING   Stop computing and wait for keyboard input          
   RELATIVE POINTER  An index into an array used with address to   
               find true location of data                          
   SCANNING    Searching ahead for given characters                
   SUPERSTRING  A string within an array of strings                
   VIRTUAL STRING  Use of disk storage as if it were real memory   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                                                                   
                  CHAPTER 10 I/O                                  
   EMPTY-BUFFERS will clear all pointers without writting to   
   disk. Any data contained within the buffers is lost at the sake 
   of freeing all buffers for more data. Accessing these buffers   
   you use BLOCK to return the address of the first byte in the    
   numbered block. If the block is not already in memory, BLOCK    
   will force it to be read. BUFFER returns a blocks address but   
   will not force a read ( used within BLOCK).                     
       We can get data into the system, either from the blocks or  
   from the input string (keyboard). As indicated before to output 
   characters to the terminal you use EMIT. To send strings you use
   TYPE, with the count on top and string address below. TYPE will 
   print the characters including blanks, -TRAILING will return    
   without the blanks by changing the stack count, then use TYPE.  
       To get these strings into buffers or locations accessible to
   our programs we can MOVE them around. MOVE copies 16 bit cells  
   from locations pointed to by the third stack item to the second 
   stack address, and will move the count value(top stack). CMOVE  
   does the same, but count is now byte moves or 8 bits at a time. 
   These move the data from low memory to higher memory and could  
   over write data yet to be moved. CMOVE> starts from the top or  
   high memory and moves data down, preventing garbage generation. 
       Forth has several ways of getting input from the keyboard   
   into the system. KEY is the basic single character input word.  
   KEY? flags if the keyboard has been used. EXPECT will wait and  
   then store a string of characters from the keyboard.            
       Once we have the data in the TIB, we now need to be able to 
   process it. WORD will scan a string until it finds a given      
   character and then moves this string to a new buffer with the   
   count (length of string) as the first address. We use COUNT to  
   add one to the address and push the count on the stack.         
   When performing your own control over Forth, you will want  
   more control than most programming languages provide. Many of   
   the string commands help you understand how Forth works, and    
   there are  more pointers that may be of interest to you. >IN    
   tells where in the input string the interpreter is at, while BLK
   indicates wether the system is taking input from the TIB or the 
   block buffers. If BLK is zero, input is from TIB, non zero is   
   block buffers.                                                  
     There are two ways to compare strings looking for matches. The
   -TEXT word compares two strings with a given length and will set
   the flag false if they match. -MATCH searches for a match of one
   string and its length within a second string of some length, if 
   a match is found the stack will contain the starting address of 
   the match and the flag set false (in that order).               
      The handling of strings is not difficult in Forth and in fact
   you have more control over how to handle strings than any other 
   programming language. If Forth doesn't do what you want, just   
   write some word that does.                                      
       As a problem, try writing some words that find matches in   
   a block buffer and then change them to random words selected    
   from a second buffer, should be fun and produce some intersting 
   statements.                                                     
                                                                   

Scr # 92 C:TUTOR.BLK

             CHAPTER 11 GLOSSARY  ( EXTENDING )                    
                                                                   
   DOES>   ( -- a)  Separates compile data from run-time portion   
   IMMEDIATE        To be executed not compiled into the word      
   COMPILE xxx      Compile word xxx address into definition       
   LITERAL          A value pushed on stack by a word (binary)     
   [                Leaves compile mode                            
   ]                Starts compile mode                            
   [COMPILE] xxx    Makes a immediate be treated as non-immediate  
   STATE   ( -- a)  True if compiling, false if interpreting       
   INTERPRET        Perform text interpretation of input stream    
                                                                   
                                                                   
                                                                   
                                                                   
             CHAPTER 11  TERMS  ( EXTENDING )                    
                                                                   
   COMPILE-TIME    The action of compiling or generating a new     
            dictionary entry, for later run-time use.              
   COMPILING WORD A word that has action only during the           
            compilation stage, to generate proper run-time action. 
   DEFINING WORD  When executed defines a new dictionary entry     
             that may have compile-time and run-time parts.        
   IMMEDIATE WORD  A word that gets executed during compilation    
             and not compiled into dictionary.                     
   PRECEDENCE BIT  The 16th bit, indicates wether a word should be 
            executed (immediadte) or compiled.                     
   RUN-TIME        The normal action which a word will take, which 
             is what the word DOES>, it's definition.              
                                                                   
                 CHAPTER 11  EXTENDING                            
                                                                   
       It is at this point that we find out how Forth  works.      
   More important it is where we find out how to change Forth to   
   meet our needs. All of this is done by extending the dictionary 
   or when compared to other languages it would be like re-writting
   the compiler so that it has new ways of handling the input. You 
   can never NOT do something in Forth, it may not at present have 
   a way of handling your desires, but learn its insides and you   
   can make it do anything.                                        
       We should remember that Forth has two states or actions     
   possible. The first is interpreting, the other compiling. In the
   interpretive mode we take data from a source and perform actions
   much like basic reads lines of code and acts on them. The other 
   mode creates new words for the interpreter to use. It would be  
   like creating a new print command in basic (something you can't 
   do).                                                            
       The words we use in the interpret mode have all been defined
   and compiled in the kernal of Forth. The UTILITY.BLK and CPU8088
   .BLK have most of the source code words for you to look over. In
   looking these words over we will see two possible actions that  
   can take place in creating the dictionary words. These two are  
   compile-time and run-time activities.                    .      
       When compiling if we used  Forth words that act on the      
   input data immediately, we would get garbage. That is it would  
   output data as the word was being created, not when we are      
   invoking it. Therefore we need to have words that control when  
   words do their thing.                                           
       CREATE is the word that creates the dicitonary entry and    
   puts in link and code addresses. This word is used to define    
   words like CONSTANT and VARIABLE. These words when we use them  
   will CREATE a dictionary input using the name we pass at that   
   time. CREATE doesn't do anything at the time it is used in the  
   defined word, only when we invoke it as part of a new defined   
   word. Now if we want the new defined word that was created by   
   using a word with CREATE in it, we use DOES>. DOES> separates   
   the creation from the activity when it is invoked. This is the  
   difference between compile-time and run-time actions.           
       Compile-time actions occur when the word is being created,  
   while run-time actions occur when the word is being interpreted.
   It is important to understand the two different states of Forth 
   activities. You compile words into the dictionary which when    
   they get invoked will perform certain activities. To compile    
   these words may require some actions which are different from   
   the actions that occur at run-time (interpretation).            
   Interpretation occurs at all times, it just that some of the
   interpreting is used to make new dictionary entries and some is 
   used to handle screen output. You don't want the two actions to 
   become confussed.                                               
       F83 has defined two words which can help show the difference
   between these two states ." and .(  The ." will store a string  
   that is printed when the word is invoke as in error messages.   
   The .( will print the string only while the word is being       
   compiled, or as I have used in the load screen to TUTOR it tells
   you to wait while it is loading new words.                      
       If we want to compute some values that later will be part of
   the new defined word as LITERAL values we would use [ and ] .   
   The [ means interpret now, while ] means to stop interpreting   
   and resume compiling the word. If you are compiling directly    
   from the keyboard ] will continue compilation after a carriage  
   return.                                                         
       The word IMMEDIATE means that  this word is used within a   
   compilation to do its action immediately. The opposite of this  
   is [COMPILE] which delays compiling of the word till used in an 
   other words compilation.                                        
       Keeping track of when and what is being compiled and        
   interpreted takes some time and practice. Use the book for most 
   of this discussion. The samples and charts of when and how the  
   dictionary is changed is too complex for this simple tutorial.  
       To really understand Forth, you must use it and play with it
   understanding how to adapt it to your style of programming. F83 
   and Forth together should be able to solve programming problems 
   with ease once you understand it.                               
      ENJOY.                                                       

Scr # 99 C:TUTOR.BLK

</code>

Source
Screen 0 not modified     
 0 (INTRO TEXT FOR SCREEN ZERO                           BDK112186)
 1 ****************************************************************
 2 ****************************************************************
 3 ****************************************************************
 4 *****                                                     ******
 5 *****         F83 TUTOR AND HELP PROGRAM                  ******
 6 *****         F83 TUTOR AND HELP PROGRAM                  ******
 7 *****                                                     ******
 8 *****                                                     ******
 9 *****          Written   by   Bill Kibler                 ******
10 *****       PO BOX  487  Cedarville, CA 96104             ******
11 *****                                                     ******
12 *****         ALL Commercial rights reserved              ******
13 *****                                                     ******
14 ****************************************************************
15 ****************************************************************


Screen 1 not modified     
 0 ( LOAD BLOCK AND START OF TUROR PROGRAM               BDK012387)
 1        53 load     23  tree      15 spaces                      
 2     .( PLEASE WAIT WHILE LOADING TUTOR SCREENS..TUTOR.BLK )     
 3   CR   CR   CR   CR   CR  ( variables and display  routines  )  
 4 VARIABLE ETUTOR   ( END DISPLAYING  TUTOR SCREENS )             
 5 VARIABLE STUTOR   ( BEGINING SCREEN OF CURRENT GROUP )          
 6 VARIABLE NTUTOR   ( NEXT TUTOR SCREEN OF GROUP  )               
 7 : L$$K    DUP 36 = IF  1 ETUTOR !   THEN  ; ( CHECK FOR $$ )    
 8 : DISPLAY     ( DISPLAY SCREEN OF TEXT )                        
 9        1 ?ENOUGH   DUP SCR !   L/SCR 1                          
10              DO          5 SPACES                               
11         DUP  BLOCK I C/L * + C/L                                
12     TUCK PAD SWAP CMOVE PAD SWAP   ( >TYPE WITHOUT THE TYPE )   
13    0 ?DO   DUP C@  L$$K EMIT 1+ LOOP DROP  ( TYPE WITH L$$K )   
14    CR       KEY?  ?LEAVE       LOOP DROP  ;                     
15      -->                                                        


Screen 2 not modified     
 0  ( go get screens of information - gotutor tutor      bdk012387)
 1 : WTPRT    ." CURRENT SCREEN IS " SCR ? 2 SPACES ." ESC = EXIT "
 2         2  SPACES ." USE SPACE BAR FOR NEXT SCREEN "  ;         
 3 : ESCCHK DUP 27 =  IF 1 ETUTOR ! 32  THEN ;  (  SET ESC FLAG )  
 4 : WAIT     WTPRT  13 EMIT  ( PRINT THEN CR WITHOUT LF )         
 5         BEGIN KEY ESCCHK  32 = UNTIL ; ( LOOP TIL SPACE KEY  )  
 6 : GOTUTOR       ( DISPLAYS SCREEN ON STACK THEN WAITS  )        
 7          CR DUP SCR !  15   SPACES   .SCR CR                    
 8          BEGIN  DISPLAY  WAIT  NTUTOR  @ 1 + DUP                
 9          DUP  NTUTOR ! 1  ETUTOR  @ = UNTIL CR CR  3 SPACES     
10    ." REPT = REPEAT LAST LESSON ...GET = NEXT LESSON  "         
11      ."  MENU = MENU  "  CR CR CR ;                             
12 : TUTOR     ( STORE SCREEN POINTERS THEN GOTUTOR   )            
13           0  ETUTOR   !                                         
14          DUP DUP STUTOR ! NTUTOR ! GOTUTOR ;                    
15      -->                                                        


Screen 3 not modified     
 0 ( INITIALIZE AND START THE LOOPS..GET..REPT..         bdk012987)
 1                                                                 
 2 : GET      ( GO GET NEXT GROUP OF SCREENS   )                   
 3       NTUTOR  @       TUTOR    ;                                
 4                                                                 
 5 : REPT     (  GO BACK AND REPEAT SET OF SCREENS  )              
 6       STUTOR @  TUTOR   ;                                       
 7                                                                 
 8 : START-TUTOR   (  START WITH FIRST SCREEN OF TUTOR  )          
 9            10 TUTOR   ;                                         
10                                                                 
11 : HELP        (  GIVE INTRO MESSAGE   )                         
12           6 TUTOR  ;                                            
13                                                                 
14    -->                                                          
15                                                                 


Screen 4 not modified     
 0 ( DEFINING MODULES OF INFORMATION.....                bdk012387)
 1 : INTRO         10 TUTOR  ;                                     
 2 : CHP1          12 TUTOR  ;                                     
 3 : CHP2          18 TUTOR  ;                                     
 4 : CHP3          25 TUTOR  ;                                     
 5 : CHP4          34 TUTOR  ;                                     
 6 : CHP5          40 TUTOR  ;                                     
 7 : CHP6          48 TUTOR  ;                                     
 8 : CHP7          55 TUTOR  ;                                     
 9 : CHP8          66 TUTOR  ;                                     
10 : CHP9          73 TUTOR  ;                                     
11 : CHP10         84 TUTOR  ;                                     
12 : CHP11         92 TUTOR  ;                                     
13                                                                 
14     -->                                                         
15                                                                 


Screen 5 not modified     
 0 ( MORE ROOM FOR LESSON WORDS....                      bdk012387)
 1                                                                 
 2   : MENU      9 DISPLAY  ;  ( will display infor screen )       
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9  : PRTSCR     CR ." CURRENT GET SCREEN IS " NTUTOR @  .         
10      CR  ." REPT SCREEN OF INFORMATION IS " STUTOR @ . CR  ;    
11                                                                 
12                                                                 
13                                                                 
14     HELP                                                        
15                                                                 


Screen 6 not modified     
 0 (  PRINT SCREENS FOR TUTOR INFORMATION...             bdk012887)
 1                                                                 
 2           FORTH-83 TUTOR PROGRAM AND HELP SCREENS               
 3                 WRITTEN  BY   BILL KIBLER                       
 4                      (c) 1987                                   
 5                ALL COMMERCIAL RIGHTS RESERVED                   
 6                                                                 
 7                                                                 
 8    This program will help beginners and past FORTH users        
 9 alike. The screens contain information on FORTH-83 and are      
10 related to the  book " STARTING FORTH "  by Leo Brodie, which   
11 should be used as a textbook with this program. Each chapter    
12 or series of screens is organized to present the words used in  
13 the chapter in a glossary form. Forth users will find this      
14 glossary important to see the differences between F83 and other 
15 versions. Typing HELP will repeat these screens, then type      


Screen 7 not modified     
 0 ( second intro screen with list of words...           bdk012887)
 1 the chapter number for the area of help needed. Typing ESC key  
 2 will exit the screens and return to the system prompt.  GET will
 3 display next chapter of  information, while REPT will start     
 4 with the first screen of the chapter again. START-TUTOR will    
 5 start with the introduction chapter.                            
 6                      NEW F83 WORDS                              
 7 The following words are important utilities in F83 and may be   
 8 different from previous versions. WORDS will display a list of  
 9 F83 words used. OPEN allows use of an existing file, 10 MORE is 
10 used to add 10 screens, and 30 CREATE-FILE NAME.BLK (opens 30   
11 screens). INDEX displays a list of line 0, 1 20 INDEX will list 
12 screens 1 to 20. 1 30 SHOW will print 6 screens to a page on    
13 your printer in condensed mode ( use:  ' EPSON IS INIT-PR for   
14 epson printers). 1 30 TRIAD prints three to a page if condensed 
15 print is not available. 1 30 SHADOW SHOW  will print both the   


Screen 8 not modified     
 0 ( THIRD  PRINT SCREEN OF TUTOR INFORMATION.....       bdk013087)
 1 regular screens and the information screens on a page (not used 
 2 in TUTOR but in UTILITY.BLK). SEE xxxx disassembles the word    
 3 xxxx, while VIEW will open the source file ( on A: drive) and   
 4 list the screen it is in. VOCS will list the vocabularies in    
 5 the dictionary, while ORDER displays the path of the directory  
 6 search. Use DOS WORDS to see a list of the DOS dictionary words.
 7 CAPACITY will print the number of screens in a open file. A L   
 8 will toggle between the shadow and the source screens. N L will 
 9 display the next screen, L will list current screen, B L will   
10 list previous screen. 1 EDIT will invoke the line editor with   
11 screen 1 ready to edit. 0 NEW will start editing at line 0      
12 and allow the text to be entered one line after the other. HEX  
13 100 80 DUMP will do a hex dump of memory location 100h to 180h. 
14 DEBUG LIST will allow stepping through list when used next as   
15 in 1 LIST. Use BYE to exit to DOS.                              


Screen 9 not modified     
 0 ( last   intro screen with list of words...           bdk013087)
 1                                                                 
 2                       TUTOR WORDS                               
 3   INTRO = introduction        CHP1 = fundamentals               
 4   CHP2 = RPN and STACK        CHP3 = editor commands            
 5   CHP4 = conditionals, nests  CHP5 = fixed point operations     
 6   CHP6 = loops  ( & nested)   CHP7 = number types               
 7   CHP8 = var. const. arrays   CHP9 = F83 structure              
 8   CHP10= Input/Output         CHP11= extensions                 
 9                                                                 
10   GET = next chapter          REPT = begin chapter again        
11   HELP = repeat these screens START-TUTOR = start at INTRO      
12   SPACE BAR = next screen     ESC = stops display               
13   BYE = EXITS to DOS          MENU = displays this screen       
14   PRTSCR = GET and REPT pointers                                
15                                                           $$    


Screen 10 not modified     
 0 (forth tutor program introduction to brodie....      bbdk011687)
 1                        INTODUCTION                              
 2    Forth is a stack oriented language, a hardware independent   
 3 programming language and operating system. F-83 is based on the 
 4 Forth-83 Standard with enhancements to make it a full operating 
 5 environment.                                                    
 6        F-83 contains the Forth-83 word set, plus words for      
 7 debugging, editing, disassembly, assembly, DOS functions and a  
 8 multitasking system.                                            
 9       The F-83 system is available on all standard computers    
10 currently being manufactured; providing a complete set of       
11 portable system utilities that are independent of hardware.     
12         Use this tutor program to learn F-83 and the differences
13 between this version and past or commercial versions of Forth.  
14 HELP will display a summary of information about F-83 and this  
15 tutor program.                                                  


Screen 11 not modified     
 0 ( second intro to brodie...                           bdk011687)
 1      This tutorial uses the well known and popular text "STARING
 2  FORTH" by Leo Brodie. Many references are made to the text and 
 3 it should be used to obtain detailed information about Forth.   
 4 The program does not cover everything about F83, but only       
 5 attempts to provide on line help information and instruction.   
 6     There are two versions of "STARTING FORTH" currently being  
 7 used.  The first edition did not contain any reference to F83   
 8 and was printed before 1982. This tutorial will help people with
 9 the first edition see the differences between FIG, Forth-79     
10 and the new F83 (Forth-83).                                     
11     The second edition is mostly the same information with      
12 changes for the newer Forth-83. Some minor text changes have    
13 been added to improve the understanding of some terms. All the  
14 other changes are related to the new or different commands used 
15 by F83 or contained in the Forth-83 standard.       $$          


Screen 12 not modified     
 0 ( chapter 1 intro to stack operation                  bdk012887)
 1                  GLOSSARY OF CHAPTER 1                          
 2 : xxx  yyy ; ( - )  Creates word xxx which does word yyy        
 3 CR   ( -- )      Do a carriage return and line feed             
 4 SPACES  (n -- )  Print n number of spaces                       
 5 SPACE   ( -- )   Print one blank space                          
 6 EMIT   (c -- )   Transmit a character to output device          
 7 ." zzz"   ( -- ) Print the output string zzz at terminal        
 8 +    (n1 n2 -- sum)  Adds n1 to n2 and leaves sum on stack      
 9 .    (n -- )     Print number on top of stack followed by space 
10 ( xxx)    ( - )  Comment, ignored by the text interpreter       
11                    TERMS IN CHAPTER 1                           
12 COMPILE          To generate a dictionary word                  
13 DICTIONARY       Forths list of words or operations             
14 EXECUTE          To do the operations a word stands for         
15 EXTENSIBILITY    Ability to modify, add or change words         


Screen 13 not modified     
 0 ( CHAPTER 1  MORE WORDS AND TERMS                     bdk011987)
 1 GLOSSARY   A list of words defined and explaned in Forth terms  
 2 INFIX NOTATION   Using operators between operands               
 3 INPUT STREAM     Text to be read by TEXT interpreter            
 4 INTERPRET        To compare input text to FORTH words           
 5 LIFO             Last In First Out..how the stack works         
 6 POSTFIX OPERATION   The way FORTH operates..RPN                 
 7 STACK            A section of memory used as a data stack       
 8 STACK OVERFLOW   Stack operations used all allocated stack      
 9 STACK UNDERFLOW  Operations tried to read data from empty stack 
10 WORD             The name of a FORTH definition                 
11                                                                 
12               CHAPTER 1 FUNDAMENTAL FORTH                       
13    FORTH has two main features, EXTENSIBILITY and INTERACTION.  
14 New functions are added to the language by creating new words   
15 and adding them to the dictionary of existing words. This       


Screen 14 not modified     
 0 ( chapter 1 continued fundamentals                    bdk012887)
 1 operation is called extending the dictionary, and thus the term 
 2 "extensibility".  As each new word is created it can be used    
 3 immeadiately to see if it functions properly. This instant      
 4 adding and execution of the word is the reason behind the term  
 5 "interactive".                                                  
 6      When Forth is waiting for your input, your terminal will   
 7 have displayed "ok" on the previous line. This means the        
 8 interpreter is waiting for your next input. That input can      
 9 be  a direct command such as 42 EMIT which will output the      
10 ASCII character * (star) to your terminal.                      
11      To make a new word for the dictionary, you need to follow  
12 the definition structure, this is a colon (:), a space, the     
13 name of your word (star), a space, the definitions, a space,    
14 and lastly a semicolon indicating the end of the word. Follow   
15 the semicolon (;) with the return key and the action you have   


Screen 15 not modified     
 0 ( more fundamentals of forth..chapter 1               bdk011287)
 1 defined will take place.                                        
 2     FORTH is stack oriented, the input string is processed      
 3 and input which is not a defined word, is assumed to be a       
 4 numeric input and is pushed onto the stack.  Numbers are pushed 
 5 until a word is found, where upon the functions defined will be 
 6 performed on the numbers on the stack from the top down.        
 7    In the line  2 4 + . we have the numbers 2 and 4, a plus sign
 8 to add the two number on the stack, and a period which prints   
 9 the top value on the stack. This means 2 is pushed first, then  
10 4 is on top, the + sign is interpreted and Forth adds the 2 and 
11 4 getting 6, and places six on the stack. The next command, the 
12 . removes the 6 from the stack and converts it to the ASCII     
13 equivalent, before outputting it to the screen. The screen can  
14 not print numbers directly, but there is a standard number which
15 is used to represent the number 6, this is ASCII number 54.     


Screen 16 not modified     
 0 ( more fundamental forth chapter 1                    bdk011987)
 1      To display the manner in which your word handles the stack 
 2 a standardized convention is used. The ( n1 n2 -- sum ) is      
 3 used to indicate that the first number ( n1 ) is push on the    
 4 stack first, followed by n2, the second number. Forth then      
 5 ( -- ) reads the word and performs the function, placing the    
 6 results ( sum ) on the stack. The right most item is the one    
 7 currently on top of the stack, or you read from left to right   
 8 which corresponds to bottom of stack to the top.                
 9      This has been a brief summary of fundamental forth as was  
10 presented in "Starting Forth", please study it for more details.
11 You can now try some of the samples listed in the book, just    
12 wait for the "ok" prompt after you hit the space bar again. Try 
13 inputting the line displayed below, to define the new word GREET
14        : GREET   CR  ."   HELLO, I SPEAK FORTH   " ;            
15                                                                 


Screen 17 not modified     
 0 ( space for more work problems....                    bdk012187)
 1                                                                 
 2   Create a word that asks for your name.                        
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                   (  $$   )                                     


Screen 18 not modified     
 0  ( chapter 2 glossary of new words...                 bdk010587)
 1             GLOSSARY OF CHAPTER 2                               
 2 +   (n1 n2 -- sum )   adds two stack items, leave sum on top    
 3 -   (n1 n2 -- diff)   subtract n2 from n1, results on top       
 4 *   (n1 n2 -- prod)   multiplies n1 times n2                    
 5 /   (n1 n2 -- quot)   divides n1 by n2, quotient on top         
 6 /MOD  (n1 n2 -- u-rem  u-quot)                                  
 7              divides and leaves quot on top, remainder below it 
 8 MOD  (n1 n2 -- u-rem) divides and leaves only the remainder     
 9 SWAP  (n1 n2 -- n2 n1) swap the order of the top two items      
10 DUP  (n -- n n)   make the top two items the same               
11 OVER  (n1 n2 -- n1 n2 n1) copy second item on top of stack      
12 ROT  (n1 n2 n3 -- n2 n3 n1) puts third item on top of stack     
13 DROP (n -- )  throw away top stack item                         
14 2SWAP  (d1 d2 -- d2 d1) swap the top two PAIRS of numbers       
15 2DUP   (d -- d d)  duplicates the top PAIRS of numbers          


Screen 19 not modified     
 0 ( chapter 2 more words and start of text              bdk010587)
 1 2OVER  (d1 d2 -- d1 d2 d1)  copy second PAIR, push on top       
 2 2DROP  (d -- )  drop the top PAIR of number off of stack        
 3                                                                 
 4              TERMS IN CHAPTER 2                                 
 5 DOUBLE LENGTH NUMBERS  Twice the length of the hardwares normal 
 6       word length. In 16 bit words that would be a 32 bit number
 7       and typically is a value of plus or minus 2 Billion       
 8                                                                 
 9 SINGLE LENGTH NUMBERS   The normal length of words used by this 
10       version of Forth, typically -32768 to +32767. These are   
11       intergers or whole numbers (no decimal points allowed)    
12                                                                 
13                                                                 
14                                                                 
15                                                                 


Screen 20 not modified     
 0 ( review of chapter 2 subjects and text               bdk011687)
 1           Chapter 2 How to get results                          
 2                                                                 
 3    Forth arithmetic is similar to a number of calculators one   
 4 can buy. These calculator are usually called RPN or Reverse     
 5 Pollish Notation calculators. They operate on a stack type      
 6 structure and require at least two items on the stack before    
 7 you can add, subract, multiply, or divide. Forth uses the +     
 8 (plus) sign for addition, - (minus) sign for subtraction, *     
 9 (star) for multiplication, and / (slash) for division.          
10     These procedures are used with interger math, or whole      
11 numbers only. On most Forths these are +32767 to -32768. This   
12 interger math requires some thought on the users view point.    
13 Numbers larger than these require other words or double length  
14 operators, which are covered in chapter 7. For now lets look at 
15 using whole numbers in division.                                


Screen 21 not modified     
 0 ( chpt2 text continued div mul                        bdk011287)
 1    Interger math requires more than one step when dividing. What
 2 happens is the results and the remainder are treated as two     
 3 separate whole numbers. The operation 20 4 / will divide 4 into 
 4 20 and produce the whole results 5. 22 4 / will also produce    
 5 the same answer 5, the remainder 2 is lost. If we use 22 4 MOD  
 6 we get remainder only 2. To get both the results and remainder  
 7 you can use /MOD as in 22 4 /MOD  puts 5 on top of the stack    
 8 the remainder below it. Remeber the . will print the top stack  
 9 item and make the second item the top element.                  
10    In most math operations there is a means of specifing the    
11 order of operations. With forth being stack oriented order is   
12 determined by placement in the stack. A infix presentation of   
13 4+(17*12) would be presented in forth as 17 12 * 4 + . with     
14 208 being displayed. Numbers are pushed onto the stack while    
15 the operators are performed in a left to right manner. We see   


Screen 22 not modified     
 0 ( chptr 2 continued order and swaps...                bdk011287)
 1 that 4 17 12 * + is the same as the previous problem. The * is  
 2 performed first on the top items (17 and 12) then the + is      
 3 used on the top (204) element and the second, now 4. The . will 
 4 print the results of 208.                                       
 5    There are several ways of handling the stack order and making
 6 changes to it. If you want the results of a math operation to be
 7 printed but still available for the next operation, you  DUP    
 8 the results before printing it. DUP takes and pushes the top    
 9 item on the stack down one and makes a copy of it on the top of 
10 the stack. OVER will make a copy of the second item and place it
11 on the top, or DUP the second item. To reverse the top two items
12 on the stack you would use SWAP. To get the third item on top   
13 and make items 1 and 2 now 2 and 3 respectiviely you use ROT. If
14 you want to remove the top item we just DROP it off the stack.  
15 Later on we will deal with double length number (larger than    


Screen 23 not modified     
 0 ( last chapter 2 with sample problem                  bdk012187)
 1 32768), we also have double word or item operators, these are   
 2 2SWAP, 2DUP, 2OVER, 2DROP. These perform the same operation as  
 3 their single counterparts, they just work on two stack items at 
 4 a time. 2DROP will DROP the first and second items off the      
 5 stack.                                                          
 6     For more samples of these operations check the book, or play
 7 around with forth when you see the ok after this screen. Here   
 8 are some sample problems:                                       
 9  if a=4 and b=8 what is a*(a+b) there are two ways to do this   
10  if c=3 then evaluate  ab - bc   again two ways here too        
11                                                                 
12   make a new word that will return the number of kilometers when
13   the top stack item is number of miles.                        
14                                                                 
15   Try these problems or make up some of your own...             


Screen 24 not modified     
 0 ( problem space.....                                  bdk011987)
 1                                                                 
 2  In this screen...number 24                                     
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15              (  $$  )                                           


Screen 25 not modified     
 0 ( chapter 3 glossary for editor words                 bdk011987)
 1             CHAPTER 3 GLOSSARY ( EDITOR )                       
 2                                                                 
 3 LIST  (n -)  Display screen n and make it current screen        
 4 LOAD  (n -)  Load n screen and interpret into dictionary        
 5 FLUSH        SAVE-BUFFERS and de-allocate buffers in memory     
 6 SAVE-BUFFERS   Write all buffers to disk files ( also use W )   
 7 UPDATE       Mark current screen for save to disk               
 8 L            Display current screen                             
 9 N L          Display Next screen                                
10 B L          Display previous (Back one) screen                 
11 A L          Toggle between current and shadow screens          
12 T   (n -)    Make n the current line to edit                    
13 P xxxx       Put the string xxx in the current line             
14 U xxxx       Insert the string xxxx under the current line      
15 K  ( -)      Exchanges the contents of insert and find buffers  


Screen 26 not modified     
 0 ( more chpt 3 glossary words...editor                 bdk011187)
 1 X            Delete current line                                
 2 NEW   (n -)  Input multiple lines starting at n                 
 3 F xxxx       Find and move to END of xxxx                       
 4 D xxxx       Delete string xxxx and leave cursor at string      
 5 TILL xxxx    Delete all text from cursor to end of xxxx         
 6 J xxxx       Delete till begining of string xxxx                
 7 EDIT  (n -)  Invokes editor on n screen                         
 8 EDITOR       Makes the editor vocabulary current vocabulary     
 9 DONE         Do flush and return from editor vocabulary         
10 ED           Return to editing current screen                   
11 FIX xxxx     Find xxxx in unknown screen and start editing it   
12 OPEN xxxx    Open file xxxx.xxx and make it current file        
13 MORE (n -)   Add n more screens to the end of current file      
14 COPY         Copy screens from one file to another              
15 CONVEY       Move screens around within file                    


Screen 27 not modified     
 0 ( more glossary words..last screen of them...         bdk011987)
 1 FORGET name     Removes all word definitions back to name       
 2 THRU  (lo hi -) Loads all blocks between lo and hi inclusive    
 3 TRIAD  (n -)    Print three blocks around n on a page           
 4 SHOW  (lo hi -) Print 6 blocks to a page in condensed mode      
 5 VIEW  name      Find name in source screen and list it          
 6 WIPE  ( -)      Blanks the entire screen when editing           
 7 G   ( blk ln -)  Gets copy of line from block and insert above  
 8                  current line pushing lines down                
 9 BRING  ( blk lo hi -) GETS range of lines                       
10 S xxx (n - n)  Searches for xxx in blocks n up if found n on top
11 LISTING name   Print entire open file including shadows         
12 KT xxx     Put all text between cursor and xxx in insert buffer 
13 O xxx          Overwrites xxx onto text of current line         
14 SPLIT          Breaks current line in two at the cursor         
15 JOIN           Puts a copy of next line after the cursor        


Screen 28 not modified     
 0 ( review of chpt 3 terms                              bdk012887)
 1 QUIT           Exit editor WITHOUT updating buffers to disk     
 2                                                                 
 3            CHAPTER 3 TERMS  ( EDITOR )                          
 4 BLOCK   The means of which files are divided, 1024 characters   
 5         is one block (BLK) and is used as screens (SCR) in forth
 6 BUFFER  Temporary space set aside in memory to hold BLKs or SCRs
 7 DISK    A short term for floppy disk and data stored there      
 8 EDITOR  The forth vocabulary that contains words used by editor 
 9 FIND BUFFER   The buffer containing the find string             
10 INSERT BUFFER The buffer containing the insert string           
11 LOAD BLOCK    The block which loads other blocks or screens     
12 NULL DEFINITION  A word that has no action, a marker            
13 OVERLAY       Data that will replace previous data or words     
14 POINTER       A value or location that points to other data     
15 SOURCE TEXT  The text which is the original definition of a word


Screen 29 not modified     
 0 ( chptr 3 text, information on editing                bdk011987)
 1                                                                 
 2               CHAPTER 3 THE EDITOR                              
 3    Forth contains a built in line or screen editor. This editor 
 4 is not like some commercial word processors, but more like the  
 5 line editors which come with most operating systems. Forth      
 6 stores all the source code for itself as plain text in screens. 
 7 The plain text statements are compiled through a special META   
 8 compiler to produce the F83 machine code program. Two files     
 9 contain most of the source code for F83, they are UTILITY.BLK   
10 and KERNELxx.BLK. UTILITY contains the higher level utility     
11 functions which you use, such as the editor's source code. The  
12 KERNELxx contains all the screens necessary for making the main 
13 F83 kernel as would be used on xx processor. The xx stands      
14 for 86, a short way of saying 8088/86 CPU which is used in the  
15 IBM PC line of computers.                                       


Screen 30 not modified     
 0 ( chpt 3 continued editor / changing screens          bdk011987)
 1     Suppose you want to change some printer directives, which   
 2 are in the utility files. Currently F83 uses Epson printer codes
 3 when invoking condensed modes of printing. Your printer uses    
 4 different codes from the Epson. To find the screen where this   
 5 code is we use FIX EPSON, after the file has been opened using  
 6 OPEN UTILITY.BLK. This will display the screen (44) which has   
 7 the source code word EPSON, and position the editor after this  
 8 word. You can now use the editor commands to change the control 
 9 code invoked using the word EPSON. When you have made the change
10 DONE will exit the editor saving changes. Reloading the sytem   
11 will give you the new printer commands. Also you could have     
12 entered the minor changes directly from the terminal, but you   
13 would have to do this each time you loaded the system.          
14     In creating this tutor program, I have created a number of  
15 blank blocks by typing 30 CREATE-FILE TUTOR.BLK. This then      


Screen 31 not modified     
 0 ( more chpt 3 editor and editing files                bdk011287)
 1 allows me to do 1 EDIT and start creating the source code for   
 2 this program. The editor will then ask me for the ID........    
 3 and I will type my initials and current date. Becuse not all    
 4 forths reconize the back slash as comment line I use the ) as my
 5 last item in the ID line. I start my screen with 0 NEW and will 
 6 type the first entry starting with a (  indicating a comment    
 7 is next. At this point you can type text one line after the     
 8 other, watching for the end of the line, the editor does not. 2 
 9 blank lines denotes end of NEW lines and you can then go back   
10 and correct any mistakes.                                       
11     Some samples of editing are; 3 T to select line 3 to edit.  
12 Using P NOW will put NOW on line 3. U NEXT will put NEXT on line
13 4. If we type F T the cursor will be after the T on line 4. Now 
14 you can type I TIME and line 4 will have NEXTTIME on it. To get 
15 space between the Ts go 4 T again to get back to the begining of


Screen 32 not modified     
 0 ( more chpt 3 editing stuff...                        bdk012187)
 1 the line, then F again (no T needed, buffer still has it) and   
 2 the cursor will be after the first T, do I  with two spaces, the
 3 return will then put a space between the Ts. You can of course  
 4 start a line with spaces or any items. The editor is not very   
 5 fancy, but it is in most versions of forth, meaning once learned
 6 you can use it on any machine your forth is running on.         
 7    The instructions in the text are similar and do cover the    
 8 main commands used in most forth editors. F83 uses different    
 9 commands to move screens around. To load screens from the       
10 utility file to this (which is already open and is the current  
11 file) you would type FROM UTILITY.BLK 1 10 COPY this will copy  
12 screen 1 of utility to screen 10 of TUTOR. Now to copy a string 
13 of files you use CONVEY, such as 11 HOP 1 6 CONVEY to copy      
14 screens 1 to 6 of TUTOR to 12 to 17 of TUTOR. The HOP means to  
15 jump over 11 screen from the first one and start the copying    


Screen 33 not modified     
 0 ( last screen of editing chpt 3...                    bdk012187)
 1 there. 1 6 TO 12 CONVEY does the same as 11 HOP. For moving     
 2 screens between files, we would use the FROM UTILITY.BLK command
 3 (after the OPEN TUTOR.BLK) and then 1 20 TO 30 CONVEY and this  
 4 will copy screens 1 to 20 of utility to 30 to 50 of tutor. You  
 5 may need to do 20 MORE first, which adds 20 empty screens to the
 6 currently opened file.                                          
 7     If you have made backups of the TUTOR.BLK files, now would  
 8 be a good time to try editing. If you use 25 35 INDEX you will  
 9 find out which screens are blanks and you could use one of them.
10 The last screens are blank and ready for your playing around.   
11 Try creating some new words and then LOAD the screen, which will
12 add the words to the dictionary. Another way to find empty      
13 screens is 1 IND this will give the index or line 0 of each     
14 screen starting with 1 until end of file is reached or you hit  
15 the ESC key. Use QUIT if you dont want to save edits........ $$ 


Screen 34 not modified     
 0 ( chapter 4 glossary of decision words....           bbdk012887)
 1             CHAPTER 4 GLOSSARY ( DECISIONS )                    
 2                                                                 
 3 IF xxx   IF: (f -) If f is true execute xxx, otherwise do yyy   
 4   ELSE yyy         continue with zzz regardless, the ELSE yyy   
 5   THEN zzz         is optional.                                 
 6 =   (n1 n2 - f)    Return a true flag if n1 and n2 are equal    
 7 <>  (n1 n2 - dif)  Returns true if n1 and n2 are not equal      
 8 <   (n1 n2 - f)    Returns true if n1 is less than n2           
 9 >   (n1 n2 - f)    Returns true if n1 is greater than n2        
10 0=  (n - f)        Returns true if n equals zero                
11 0<  (n - f)        Returns true if n is negative                
12 0>  (n - f)        Returns true if n is positive                
13 NOT (f - f)        Reverse the results of the last test (0=)    
14 AND (n1 n2 - and)  Returns the logical AND of n1 and n2         
15 OR  (n1 n2 - or)   Returns the logical OR of n1 and n2          


Screen 35 not modified     
 0 ( chptr 4 more glossary and terms                     bdk011987)
 1 ?DUP   (n - nn) or (0 -0)  Duplicate only if n is nonzero       
 2 ABORT" xxx "       Abort operation and print xxx error message  
 3           (f -)    also clear users stacks, if false no action  
 4 XOR   (n1 n2 -xor)  Exclusive or, true if both n not true       
 5                                                                 
 6             CHAPTER 4 TERMS ( DECISIONS )                       
 7 ABORT     Abruptly cease operation if procedure isn't acceptable
 8 AND       Output is true if both inputs are true                
 9 BRANCHING If input condition occurs jump to another routine     
10 COMPARISON  Check and flag if two items are the same            
11 CONDITIONAL  Different operation if flag true than when false   
12 FLAG      A variable when set equals true, reset equals false   
13 LOGIC     Using operators like AND, OR, NOT to make statements  
14 NESTING   Branching routines within branching routines          
15 OR        If either of two inputs are true the results is true  


Screen 36 not modified     
 0 ( chptr 4 text on decisions....                       bdk012887)
 1                                                                 
 2          CHAPTER 4 DECISIONS, CONDITIONALS                      
 3     In any computer language, terms are used to express math    
 4 forms and types. We like to compare items and say how one is    
 5 larger or smaller than an other. You may also base an action    
 6 on the results of such a comparison. Forth can also do the      
 7 same types of comparisons. We can tell forth to do something IF 
 8 some condition is met. The proper term for this is IF THEN      
 9 statements. To help make these comparisons there are several    
10 operators we can use. They can be = for equals, < 2nd stack item
11 is less than top item, > 2nd item is greater than top item, 0=  
12 the top item is equal to zero, 0< the top is less than zero, 0> 
13 the top is greater than zero.                                   
14     All of these operations depend on setting a FLAG variable.  
15 This flag is a special indicator set as either true or false.   


Screen 37 not modified     
 0 ( chptr 4 more text..logic, decisions...              bdk012887)
 1 IF THEN logic operations work by checking the flag to see if it 
 2 is true or false. If true THEN do xxx ELSE if false do zzz.     
 3 The IF statement can be any form of testing, including regular  
 4 math operations. A sample math operation is comparison <> where 
 5 if two items are the same, the results will be zero, and so the 
 6 flag will be set false (treated as subtraction).                
 7     There are non math operators that can do comparison based on
 8 logic operations. These logic operators are AND, OR, and NOT.   
 9 AND sets the true flag if both stack items are also true, OR if 
10 either stack items is true, while NOT reverses the flag setting.
11 Forth has some words which contain conditional tests within them
12 ABORT" and ?STACK. ABORT" print the statement contained within  
13 the " " if the flag is set, leaves the current program and      
14 resets all stacks before  the Forth ok. ?STACK flags true if    
15 the stack is empty, as when waiting for keyboard input.         


Screen 38 not modified     
 0 ( some chptr 4 samples/ problems                      bdk012187)
 1     Lets do a simple IF THEN routine to show the forth way of   
 2 handling conditionals. Lets test to see if a pupil answers a    
 3 question correctly when faced with four choices;                
 4    : ckansw   ( check the answer and prompt accordingly )       
 5         DUP  1 = IF ." WRONG" CR  12 TUTOR     ELSE             
 6         DUP  2 = IF ." CLOSE BUT REREAD QUESTION " ELSE         
 7         DUP  3 = IF ." GOOD CHOICE "          ELSE              
 8         DUP  4 = IF ." BETTER LUCK NEXT TIME.. " ELSE           
 9                     ." ENTER VALUE OF 1 2 3 or 4 ONLY "         
10                  THEN THEN THEN THEN DROP ;                     
11 This new word CKANSW, checks the item on top of the stack to see
12 if it matches or equals the value we want. If it does, print the
13 statement and then continue checking unitl last "then" is used. 
14 When a non match occurs the prompt to enter a new value is now  
15 displayed. Try your own conditional program in SCR # 39.....    


Screen 39 not modified     
 0 ( some chptr 4 samples/ problems                      bdk011987)
 1   ( here it is for you to change or use )                       
 2                                                                 
 3    : ckansw   ( check the answer and promt accordingly )        
 4         DUP  1 = IF ." WRONG" CR  12 TUTOR     ELSE             
 5         DUP  2 = IF ." CLOSE BUT REREAD QUESTION " ELSE         
 6         DUP  3 = IF ." GOOD CHOICE "          ELSE              
 7         DUP  4 = IF ." BETTER LUCK NEXT TIME.. " ELSE           
 8                     ." ENTER VALUE OF 1 2 3 or 4 ONLY "         
 9                  THEN THEN THEN THEN DROP ;                     
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15         (   $$   )                                              


Screen 40 not modified     
 0 ( chapter 5 glossary and   interger math              bdk011987)
 1           CHAPTER 5 GLOSSARY ( INTERGER MATH )                  
 2                                                                 
 3 1+    (n - n+1)  Adds one to n                                  
 4 1-    (n - n-1)  Subtracts one from n                           
 5 2+    (n - n+2)  Adds two to n                                  
 6 2-    (n - n-2)  Subtracts two from n                           
 7 2*    (n - n*2)  Multiplies n by two (shift left )              
 8 2/    (n - n/2)  Divides n by two ( shift right )               
 9 ABS   (n - |n|)  Returns absolute value of n                    
10 NEGATE (n - -n)  Changes the sign of n                          
11 MIN   (n1 n2 - n-min)  Returns the minimum n (either n1 or n2)  
12 MAX   (n1 n2 - n-max)  Returns the maximum n (either n1 or n2)  
13 >R    (n - )   Place stack top item on return stack top         
14 R>    ( - n)   Load top of stack with top of return stack       
15 R@    ( - n)   Make a copy of return stack, put on top of stack 


Screen 41 not modified     
 0 ( More chapter 5 glossary and terms                   bdk012887)
 1 */   (n1 n2 n3 - n)  Multiplies then divides (n1*n2/n3)         
 2 */MOD (n1 n2 n3 - n-rem n-result) Get remainder, quotient on top
 3                                                                 
 4                                                                 
 5           CHAPTER 5 TERMS ( INTERGER MATH )                     
 6                                                                 
 7 Double length intermediate result   Steps within an operation in
 8       which the number size has twice the normal digits, inorder
 9       to minimize errors.                                       
10 Fractional arithmetic    The handling of numbers without the    
11       decimal point, using whole numbers, and later returning   
12       the decimal point to its proper place.  FIXED POINT can be
13       used inplace of fractional, they mean the same.           
14 Floating point math     Number containing the decimal point     
15       and requiring adjustments before use by a computer.       


Screen 42 not modified     
 0 ( chapter 5 terms and some text                       bdk011487)
 1 Parameter stack    The main data stack which is used to pass    
 2       data between operations of the forth machine. Generally   
 3       referred to simply as STACK or data stack.                
 4 Return stack      The stack used by forth for keeping return    
 5       addresses on during operations. Can be used for holding   
 6       data from stack (parameter) only WITHIN a definition.     
 7       Always referred to as RETURN STACK, never stack!          
 8 Scaling    The adjustment of floating-point numbers such that   
 9       all number are represent as intergers and with the same   
10       relevant relationship in respect to the decimal point.    
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 


Screen 43 not modified     
 0 ( chapter 5 text INTERGER MATH math                   bdk012887)
 1               CHAPTER 5 INTERGER MATH                           
 2                                                                 
 3    Forth has a number of words that help perform math operations
 4 quickly and easily. All of these operations work on INTERGER    
 5 MATH concepts, or interger numbers. Typically these are signed  
 6 numbers between +32768 and -32767. To add numbers that have a   
 7 decimal point we mentally multiply the number by a power of ten 
 8 enter those numbers and then replace the decimal point after the
 9 operation. Some versions of Forth contain routines that will do 
10 this for you, they are called floating point utilities. They can
11 slow down Forth considerably and waste memory.                  
12    Most Forth users prefer to use interger math for the speed   
13 and memory savings. There are two words that help make interger 
14  math easier */ (star slash) and */MOD (star slash MOD).        
15 These words perform a multiply and then a divide (MOD produces  


Screen 44 not modified     
 0 ( chapter 5 text fixed point                          bdk011987)
 1 a remainder). Scaling is the method used in forth to change a   
 2 value so that it can be used in interger math. To use numbers   
 3 we scale them before use, then rescale the results back into the
 4 same ratio. We can use PI not as 3.1416 but 31416 10000 / and   
 5 when used in a formula like PI * Dia for area we use */ as in   
 6 4 31416 10000 */ . and we get the area of a 4 foot circle. We   
 7 have made the results of 4 * 31416 be 10000 time larger than in 
 8 you would using PI as 3.1416, but by dividing our results by    
 9 10000 we return it to proper scale. PI however has more places  
10 than four shown and will produce some error. There are fractions
11 which can represent a more accurate means of expressing this and
12 other numbers, they are called rational approximations, here are
13 a few: PI 355/ 113, SQRT of 2  19601/13860, SQRT of 3  18817/   
14 10864, .001Deg./22-bit rev.  18118/21109.                       
15     To find our answer to the area of a 4 foot circle use the   


Screen 45 not modified     
 0 ( chapter 5 more fixed point text                     bdk012887)
 1 values of PI: 4 355 113 */ . this will be more accurate than    
 2 before. */ does not produce a remainder and the area of the last
 3 problem is more than 12 square feet. Using */MOD will provide   
 4 the remainder as the second item on the stack. When using the   
 5 remainder we can then see the difference between dividing by    
 6 10000 and using 355/113, which is .0736. For a more detailed and
 7 illustrated review of this topic check chapter 5 in STARTING    
 8 FORTH.                                                          
 9     The return stack is used by Forth to store return  addresses
10 of definitions (semicolons). It can be used within a definition 
11 to help shuffle values around. A good example of that would be a
12 problem that uses a constant several times. Instead of dupping  
13 the number and a ROT or SWAP it may be faster to copy it to the 
14 return stack and make copies of it each time you need it. You   
15 must remember to clear the return stack by the end or ; .       


Screen 46 not modified     
 0 ( chpt 5 some quickies to help out                    bdk011987)
 1     To help moving between the return stack and parameter stack 
 2 use >R to push on R< to get off and back onto the stack. R@     
 3 makes a copy of top of return stack and places it on top of     
 4 data stack.                                                     
 5     In most programs there are several operations that occur    
 6 frequently and Forth has words to help out with them. Many  a   
 7 time we need to add or subtract by 1 or 2, and thus the words   
 8 1+ 1- 2+ 2- 2* 2/ . Filtering of values is also important, so we
 9 have ABS for absolute value, NEGATE for changing signs, MIN and 
10 MAX to find the relationship between 2 values.                  
11     Try these problems or write a new word in screen 47 for each
12 of these inputs,0 degrees F and 45 degrees C. Use these formulas
13  C= (f-32)/1.8   and F= (C*1.8)+32 . Try and find the radius of 
14 a circle with a circumferance of 23 feet.                       
15                                                                 


Screen 47 not modified     
 0 (  problem room....                                   bdk011987)
 1                                                                 
 2 What is the area of circle 12.5 feet in diameter?               
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15    (   $$  )                                                    


Screen 48 not modified     
 0 ( chapter 6 glossary of loop words                    bdk012887)
 1           GLOSSARY CHAPTER 6 ( LOOPS )                          
 2                                                                 
 3 DO ... LOOP  DO: (limit start -- ) LOOP: ( -- )  This word      
 4           sets up a finite loop, with a starting value and      
 5           a ending or limit value ( loop does no action         
 6           accept return to begining of DO).                     
 7 DO ... +LOOP  DO: (limit start -- ) +LOOP: (n -- ) Same as      
 8           plain loop, but adds n to value each time it loops.   
 9 LEAVE  ( - )  Terminates loop at next LOOP or +LOOP.            
10 BEGIN .. UNTIL    UNTIL: (f - )  Loops until f becomes true.    
11 BEGIN xxx WHILE yyy REPEAT   WHILE: (f - )   Loop doing xxx     
12           while yyy remainds true, leave when f is false.       
13 .R  (n width -- )   Prints unsigned value right justified       
14           within specified field width.                         
15 PAGE  ( - )   Send a form feed to the terminal or printer       


Screen 49 not modified     
 0 ( chapter 6 glos and terms..loops...                  bdk011487)
 1 QUIT  ( - )   Kills current execution and returns to terminal.  
 2                                                                 
 3             CHAPTER 6 TERMS ( LOOPS )                           
 4                                                                 
 5 DEFINITE LOOP    A looping routine which will execute as many   
 6            times as needed to reach a fixed value after starting
 7            from some preset value.                              
 8 INFINITE LOOP   More often called a LOCKED UP COMPUTER, one that
 9            will never reach a determined value.                 
10 INDEFINITE LOOP    Not to be confused with a infinite loop, this
11            loop ends when some predetermined value is reached.  
12            Changes in flags or values will end these loops. This
13            loop starts with BEGIN, while definite loops use DO. 
14                                                                 
15                                                                 


Screen 50 not modified     
 0 ( chapter 6 text on loops.....                        bdk011487)
 1             CHAPTER 6 LOOPS                                     
 2                                                                 
 3    Loops are an extension of branching, it's just that they will
 4 branch back to the begining of the word DO or BEGIN. A DO loop  
 5 takes values off the stack, the starting value on top and the   
 6 ending value below. The staring value is increased by one each  
 7 time through the loop until  it equals the ending value. The    
 8 operations contained within the DO and LOOP are performed until 
 9 the items are equal. These items are not kept on the data stack 
10 but stored on the return stack, which you can copy and print by 
11 using the word I (see last chapter for more info). This value   
12 is called the index and can be used within the loop to create   
13 new values or pointers.                                         
14     +LOOP takes the value off the stack and increments the loop 
15 counter by this amount. +LOOPs can then count by steps to the   


Screen 51 not modified     
 0 ( chapter 6 loops and more loops...                   bdk012887)
 1 limit value, which is the second value on the return stack (use 
 2 I' to copy to data stack). Be careful of using 0  in loops,     
 3 becuse you could end up multiplying by 0 and never reach your   
 4 ending value, this is an infinite loops, never ends.            
 5     The other form of looping is the indefinite loop which      
 6 starts with BEGIN and ends with UNTIL. This loop will repeat    
 7 what is between the BEGIN and UNTIL, as long as the flag remains
 8 true. This means you must perform some test within the loop     
 9 that will change the flag. A modified version of this loop is   
10 BEGIN WHILE REPEAT loop. This loop works just the opposite of   
11 the BEGIN UNTIL loop, it works only while the flag is true.     
12 When the flag goes false this loop ends.                        
13     A regular DO LOOP can be ended early by LEAVEing it. Using  
14 LEAVE within the loop will terminate the loop, so to prevent an 
15 unwanted leave, enclose the term LEAVE within an IF THEN        


Screen 52 not modified     
 0 ( chapter 6 last page of loops..                      bdk012887)
 1 statement. The IF is checked and as long as the condition is not
 2 true, the loop will not be terminated by LEAVE but continue on  
 3 with THEN.                                                      
 4      The text has several good examples of DO LOOPs and how to  
 5 use them. The text omits any BEGIN UNTIL loop problems, so lets 
 6 see if we can create a word using this loop. If printing stars  
 7 on the screen remember to clear it first with PAGE. Now lets    
 8 see if you can create a christmas tree using stars when the     
 9 stack contains the height or width as a value.                  
10     Should you want to see a sample of printing a tree with     
11 the lowest branch value used as width, displayed at begining,   
12 then enter 25 TREE for a tree with 25 stars accross the bottom. 
13 If you want you can try and make the value enterd equal the     
14 number of branches ( not stars ) by editing screen 53. Try it   
15 first before looking at screen 53, it is more fun.....  $$      


Screen 53 not modified     
 0 ( tree width begin until                              bdk012887)
 1                                                                 
 2 : STAR     42  EMIT  ;  ( print star )                          
 3 : STARS   0 DO STAR LOOP  ;  ( print many stars )               
 4                                                                 
 5 : TREE    ( n -- )  ( expects width to be on top of stack )     
 6           2/ 2* 1 +  ( guarantee it is odd )                    
 7        PAGE    CR CR   ( clear screen and move down  )          
 8        1 39  DUP  SPACES  STAR  ( get set and do a star )       
 9     BEGIN  CR  1 - DUP SPACES  ( start and move across )        
10        SWAP 2  + DUP  STARS ( set star count do it )            
11        ROT SWAP >R DUP  R> SWAP >R DUP >R  ROT                  
12         R> R>  =  UNTIL  ( shuffle  and check star to count )   
13       CR 39 SPACES STAR CR 39 SPACES STAR CR CR ;               
14   (  the last line draws the tree stock and moves ok down )     
15         (   $$     )                                            


Screen 54 not modified     
 0                                                                 
 1                                                                 
 2                                                                 
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 


Screen 55 not modified     
 0 ( chapter 7 glossary ..numbers                        bdk011987)
 1            CHAPTER 7 GLOSSARY ( NUMBERS )                       
 2                                                                 
 3 ASCII  ( - c)  Translate character into ASCII equivalent        
 4 U.   (u - )  Prints unsigned number and one space               
 5 U.R  (u wdth -) Display right justified unsigned number         
 6 U<   (u1 u2 - f) Flag true if u1 < u2, single length unsigned   
 7 HEX  ( - )   Set number base to sixteen                         
 8 OCTAL  ( - ) Set number base to eight ( not on all systems )    
 9 DECIMAL ( - ) Set number base to ten                            
10 <#           Begins number conversion, unsigned double length   
11 #            Converts digit to output character string          
12 #S           Convert number until result is zero                
13 c HOLD       Insert an ASCII character in string at HOLD point  
14 n SIGN       Inserts minus if n is negative in string           
15 #>           Leaves number string and stack ready for TYPE      


Screen 56 not modified     
 0 ( more number glossary chpt 7                         bdk011987)
 1 D+  (d1 d2 - d-sum)  Adds two 32 bit numbers                    
 2 D-  (d1 d2 - d-diff) Subtract two 32 bit numbers                
 3 DNEGATE (d - -d)     Change sign of 32 bit number               
 4 DABS  (d - |d|)      Returns absolute 32 bit value              
 5 DMAX  (d1 d2 - dmax) Returns maximum of two 32 bit numbers      
 6 DMIN  (d1 d2 - dmin) Returns minimum of two 32 bit numbers      
 7 D=    (d1 d2 - f)    Flags true if d1 and d2 are equal          
 8 D0=   (d - f)        Flag true if d equal zero                  
 9 D<    (d1 d2 - f)    Flag true if d1 less than d2               
10 DU< (ud1 ud2 - f)    Flag true if unsigned d1 < unsigned d2     
11 D.  ( d - )          Prints signed 32 bit number                
12 D.R ( d width - )    Prints signed 32 bit right justified       
13 UM* (u1 u2 - ud)     Multiply two 16 bit, gets 32 bit unsigned  
14 UM/MOD (ud u1-u2 u3) Divides 32b by 16b, gets 16b rem and quot. 
15 M*  (n1 n2 -d-prod)  Multiplies two 16b gets 32 bit result      


Screen 57 not modified     
 0 ( last of glossary chapter 7 numbers...               bdk011987)
 1 M+  (d n - d-sum)  Adds a 32b to 16b, returns 32bit number      
 2 M/  (d n - n-quot) Divides 32b by 16b, get 16b signed results   
 3 M*/ (d n u - d )   Multiplies then divides 32 by 16 get 32 bit  
 4                                                                 
 5                                                                 
 6           CHAPTER 7 TERMS ( NUMBERS )                           
 7                                                                 
 8 ARITHMETIC SHIFTS   Process of moving bit left or right, which  
 9           is same as multiplying or dividing by two.            
10 ASCII     The standard system of representing characters with   
11           numbers, eight bits in length.                        
12 BINARY    Number base of two, either on or off                  
13 BYTE      Term for 8 bit value                                  
14 CELL      A Forth term for 16 bit value                         
15 DECIMAL   The number base of 10                                 


Screen 58 not modified     
 0 ( chpt 7 more terms....                               bdk012887)
 1 HEXADECIMAL   Number base of 16                                 
 2 LITERAL       A number that appears inside a definition         
 3 MASK          A means of filtering out unwanted bits            
 4 NUMBER FORMATTING  Changing binary number to display characters 
 5 OCTAL         Number base of 8                                  
 6 SIGN BIT      A bit used to indicate sign in signed numbers     
 7 TWO'S COMPLIMENT   The binary method used to add negative values
 8 UNSIGNED NUMBER    A positive number                            
 9 UNSIGNED SINGLE LENGTH NUMBER  An interger between 0 and 65535  
10 WORD          In Forth the defined dictionary entry that will   
11               perform some function or command                  
12                                                                 
13                                                                 
14                                                                 
15                                                                 


Screen 59 not modified     
 0 ( chapter 7 text.. numbers..                          bdk012887)
 1                CHAPTER 7  NUMBERS                               
 2                                                                 
 3     Computers have only one way to handle numbers, that is the  
 4 BINARY method. Everything inside computers is either a one or   
 5 zero, a on or off, or combinations of these two states. Binary  
 6 is the term for this type of handling data. Humans however have 
 7 considerable trouble understanding these on and offs values, so 
 8 we have created number systems for the different ways we want to
 9 represent data.                                                 
10     In a previous screen I indicated that ASCII characters is   
11 what a computer uses to display information. A number has been  
12 asigned for each character we wish to display. These and any    
13 number can be represented in a binary form. To send a carriage  
14 return to your screen we send a value of 13 decimal. The binary 
15 representation of 13 is 00001101 and is what the computer       


Screen 60 not modified     
 0 ( chapter 7 numbers more text...                      bdk012887)
 1 actually sent to the display. Several shorthand methods are used
 2 to indicate binary values. Some older computers use OCTAL or    
 3 base 8. Most new machines use HEXADECIMAL or base 16. Four bits 
 4 of binary 1 or 0s is used to get the hexadecimal value. Four HEX
 5 (short for hexadeciaml) values will represent the sixteen bits  
 6 used in most of Forths single numbers. Double numbers are based 
 7 on using 32 bits or eight hex values. Remember the hex values   
 8 are just easy ways to express the 4 places of on and off data.  
 9     In forth we use normally 16 bits to represent an unsigned   
10 number, 15 bits for a signed number with the 16th bit being the 
11 sign. When counting in binary that is 65535 for unsigned and a  
12 range of +32768 to - 32767 for signed numbers, all 16 bits. For 
13 binary arithmetic check the book, it has some good samples      
14     There are a number of Forth words which binary understanding
15 helps in knowing what they do. ASCII numbers are used by the    


Screen 61 not modified     
 0 ( more chapter 7 text..numbers                        bdk012987)
 1 EMIT word. This command emits an number to the display system.  
 2 F83 can take a character and automatically convert it to a ASCII
 3 value. Using ASCII * EMIT will send a star to the display. The  
 4 same technique is used when changing base number systems. HEX   
 5 0A 12 + . will produce 1C as the answer. To get a decimal value 
 6 do HEX 0A 12 + DECIMAL . and it will print 28.                  
 7     There are many ways to display numbers in Forth. To print   
 8 unsigned (16bit) numbers U. will print what is on the stack plus
 9 a space after it. If you want numbers in a column use U.R where 
10 stack top has the width of the column, and the second down has  
11 the number that will be right justified. For DO LOOP compares on
12 unsigned numbers use U< to flag true if U1 is less than U2. We  
13 can do the same functions with double length numbers (32bits).  
14 D. prints signed numbers, UD. prints unsigned numbers, D.R like 
15 U.R for signed 32 bit numbers, and DU< is 32 bit U<.            


Screen 62 not modified     
 0 ( chapter 7 number formatting...                      bdk012187)
 1     To display numbers it is necessary to format their output.  
 2 This formatting inserts . or / to indicate money or dates. The  
 3 method in Forth is to asign positions in a string, relative to  
 4 digits in the number being printed. The format words are <# # #>
 5 and HOLD TYPE #S ASCII all can be used within the string. To    
 6 start a layout use <# then number of numbers used, your period  
 7 as a number (45) HOLD to hold a place by inserting a .   there  
 8 and then #S to fill in any remainding numbers. The real problem 
 9 is the left most #, will be the right most number, or if we have
10 4 #s before the hold, it will have four values after the HOLD.  
11 We also need to end the string with a #>, followed by TYPE which
12 will display the formatted number. No space is printed after    
13 TYPE so you may need to follow it with a SPACE or n SPACES. You 
14 should try some of the samples in the book to get a better      
15 grasp of number formatting.                                     


Screen 63 not modified     
 0 ( chapter 7 double and mixed numbers                  bdk012887)
 1     There are a few double length operators that help handle    
 2 relationship between numbers. These are, DNEGATE which changes  
 3 the sign of a 32 bit number, DABS that returns the absolute     
 4 value, DMAX and DMIN for minimum and maximum of two numbers, D= 
 5 set flag true if two doublelength numbers ar equal, D0= if the  
 6 number is zero, D< true if d1 is less than d2. Remember these   
 7 operate the same as their single length number, but work on 32  
 8 bits of data, not 16.                                           
 9     As with single length number, some operations will require  
10 intermediate answers that are longer than 32 bits. In */ the    
11 16 bit values used a 32 bit intermediate value to maintain the  
12 accuracy. M*/ takes a 32 bit number and multiplies it by a 16   
13 bit getting a triple length results (48 bits), and then dividing
14 by a 16 bit number, return the answer as a 32 bit value.        
15    There are several other MIXED LENGTH OPERATORS, they are UM* 


Screen 64 not modified     
 0 ( last of chapter 7, mixed..definitions..             bdk012187)
 1 mulitplies two 16 bits for a 32 bit answer, UM/MOD divides a 32 
 2 bit by a 16 bit, getting 16 bit answers all unsigned, M* takes  
 3 two 16 bits and multiplies for a signed 32 bit value, M+ adds a 
 4 32 and a 16 bit number for a 32 bit answer, M/ a 32 by 16 for a 
 5 16 bit answer.                                                  
 6   One must remember that the number base you are in is used when
 7 compiling a word. Inserting a HEX will not have the values in   
 8 the word compiled as hex values if you are in decimal at the    
 9 time. When words are executed, if they contain a number base,   
10 the base will change at that time and interpret the numbers that
11 were stored literally into the equivalent base value.           
12     The book has more details and some interesting problems. A  
13 good problem is creating a BIT mask using a DO LOOP. A good and 
14 useful word would be one that display bit patterns for values   
15 entered, in both 16 and 32 bit lengths.                         


Screen 65 not modified     
 0 ( chapter 7 problem area and expansion...             bdk012187)
 1    Try some large size math problems using the new words from   
 2 this chapter.                                                   
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15        (  $$   )                                                


Screen 66 not modified     
 0 ( chapter 8 glossary for variables...                 bdk012187)
 1             CHAPTER 8 GLOSSARY  ( VARIABLES )                   
 2                                                                 
 3 CONSTANT xxx  ( n -)  Creates a constant xxx with a value of n  
 4 VARIABLE xxx  ( - )   Creates a variable xxx, xxx gets address  
 5 CREATE xxx    ( - )   Creates dictionary header xxx             
 6 !    ( n a -)   Stores single length number into address        
 7 @    ( a - n)   Fetches contents of address to stack            
 8 ?    ( a -  )   Prints contents of address and a space          
 9 +!   (n a - )   Adds n to contents of address (single length)   
10 ALLOT ( n - )   Adds n bytes to the PFA of recently defined word
11 ,    ( n - )    Compiles n into next available cell in dict.    
12 C,   ( b - )    Compiles b ( byte) into available cell of dict. 
13 C!   (b a - )   Store a 8 bit value into address                
14 C@   ( a - b)   Fetch an 8 bit value ( byte) from address       
15 FILL (a u b -)  Fill memory u bytes long, starting a, with b    


Screen 67 not modified     
 0 ( chapter 8 more glossary..variables...               bdk012187)
 1 ERASE  (a u -)   Stores u zeros starting at address a           
 2 BASE   (  - a)   Variable containing value of number base       
 3 DUMP   (a u - )  Display u bytes of memory from a address       
 4 2VARIABLE xxx    Creates double length variable                 
 5 @CONSTANT xxx    Creates double length constant                 
 6 2!     ( d a - ) Stores double length number into a address     
 7 2@     ( a - d ) Fetches double length double from a address    
 8 0.     ( - 0 0 ) Puts a double length zero on stack             
 9 FALSE  ( - 0 )   Returns a zero or false condition              
10 TRUE   ( - -1)   Returns a -1 or all 16 bits set to one         
11                                                                 
12                                                                 
13                                                                 
14             CHAPTER 8 TERMS ( VARIABLES )                       
15                                                                 


Screen 68 not modified     
 0 ( chapter 8 terms.. variables ..                      bdk012787)
 1 ARRAY      A series of memory locations referenced by one name  
 2 CONSTANT   A fixed value referenced by a single name            
 3 FACTORING  Pulling out common steps of a program into own words 
 4 FETCH      To retrieve a value from a memory location           
 5 INDEX      A number indicating a location within an array       
 6 INITIALIZE    The setting of an array to known values           
 7 OFFSET     An value added to address, pointing into an array    
 8 STORE      Placing a value into memory location                 
 9 VARIABLE   Memory location for storing changing values          
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                CHAPTER 8 VARIABLES AND ARRAYS                   
15                                                                 


Screen 69 not modified     
 0 ( CHAPTER 8 TEXT .. VARIABLES                         bdk012187)
 1     Most programs, including tutor.blk, need to use variables   
 2 and constants. Variables are pointers, temporary sums, or any   
 3 values that can be changed. Constants are values that are used  
 4 by programs and generally are not changed. Forth requires these 
 5 locations to be declared before use, using either VARIABLE or   
 6 CONSTANT inplace of the : . This tells the compiler to define a 
 7 word and allocate memory for it. Constants take a value off the 
 8 stack and place it in the allocated memory location. When these 
 9 words are used they return their address to the stack for use   
10 by ! @ ? or +! .                                                
11    ! means to store a value in location of address on stack with
12 value below it. @ gets or fetches value from address on stack.  
13 ? is a combination of @ and . to get and print a value. +! adds 
14 the number below the address on the stack, to the location of   
15 address.                                                        


Screen 70 not modified     
 0 ( chapter 8 variable doubled..arrays..text            bdk012187)
 1     There are double words for variables: 2VARIABLE, constants: 
 2 2CONSTANT, as well as 2! to store a double length variable, and 
 3 2@ to fetch double length variables or constants.               
 4     Many programs use arrays, or a number of memory locations   
 5 that can contain values. Arrays can have fixed values, as in a  
 6 table of phone numbers, or variables which can keep count of a  
 7 number of events. To create an array in Forth use the word      
 8 CREATE and the name assigned to it. The compiler will set as    
 9 many memory locations aside as you ALLOT to it. An array of two 
10 will be defined, unless you allot more. Placing values in or out
11 of an array is the same as any variable, it is just the address 
12 provided will be for the first entry in the array. If you want  
13 the seventh item, you must increment the address by 14 as each  
14 location is 2 addresses in length. The same is true for ALLOT   
15 you must double the value (10 ALLOT creates 5 16bit locations). 


Screen 71 not modified     
 0 ( chapter 8 arrays and bytes....                      bdk012187)
 1     An example of an array is your programs memory. Forth has a 
 2 word for looking at this large array, it is DUMP. Place the     
 3 starting address on the stack, next push the count or how far   
 4 you want displayed, then DUMP and watch what is there.          
 5     As we said before a byte is 8 bits and is the smallest way  
 6 some machines handle information. You can get data from or into 
 7 an array in 8 bits at a time. Arrays of characters are all 8 bit
 8 entries. C! stores 8 bits, while C@ fetch 8 bits, just remember 
 9 to set the address one step for each location in the array.     
10     The , is used to create a constant with values entered at   
11 time of compilation. Use values and a , for each entry instead  
12 allotting space (do not forget the last , ).                    
13     Variables, constants, and arrays are easy to create in Forth
14 and just as easy to use. For a problem we can use the topic of  
15 last chapter and this to create a telephone listing or array.   


Screen 72 not modified     
 0  ( chapter 8 problems..telco array                    bdk012187)
 1 This array should contain numbers and when queried with an      
 2 index produce formatted output. Lets give it a try...           
 3                                                                 
 4                                                                 
 5                                                                 
 6                                                                 
 7                                                                 
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                  (  $$  )                                       


Screen 73 not modified     
 0 ( chapter 9..glossary and engines....                 bdk012287)
 1         CHAPTER 9  GLOSSARY  ( FORTH ENGINE )                   
 2                                                                 
 3 ' xxx  ( - a )   Returns dictionary address of xxx              
 4 [']    ( - a )   Generates literal number used inside the words 
 5                  definition of the next word used in definition 
 6 EXECUTE  (a -)   Executes the dictionary entry at address a     
 7 @EXECUTE (a -)   Executes entry pointed to at address a         
 8 >BODY  (cfa -pfa)  Returns parameter field from compilation addr
 9 EXIT   (  -- )   Terminates or returns from definition          
10 QUIT   ( --  )   Clears stack, gets control, no ok prompt       
11 ABORT  ( --  )   Clears data stack then does QUIT               
12 DP      ( - a)   Returns address of dictionary pointer          
13 HERE   ( -- a)   Next available dictionary location             
14 PAD    ( -- a)   Beginning address of character string buffer   
15 SP@    ( -- a)   Pointer to top of data stack                   


Screen 74 not modified     
 0 ( chapter 9 glossary of engine...                     bdk012187)
 1 S0    ( -- a)   Returns address of bottom of data stack         
 2 TIB   ( -- a)   Returns address of text input buffer            
 3 FORTH  ( -- )   Makes FORTH context vocabulary                  
 4 EDITOR ( -- )   Makes EDITOR context vocabulary                 
 5 CONTEXT ( - a)  Returns address of search order variable        
 6 CURRENT ( - a)  Returns address of new word vocabulary ( vocs)  
 7 DEFINITIONS     Sets the current vocs to context vocs           
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12          CHAPTER 9 TERMS ( FORTH ENGINE )                       
13                                                                 
14 ADDRESS INTERPRETER   Interprets the address from the colon     
15           definitions and executes them                         


Screen 75 not modified     
 0 (  chapter 9 terms engines...                         bdk012187)
 1 BODY      The code and parameter of a dictionary entry          
 2 BOOT      The basic starting portion of Forth, precompiled Forth
 3 CFA       Address of code field in a dictionary entry           
 4 CONTROL TASK   A task that does not converse with Forth         
 5 CODE POINTER FIELD   The entry in the dictionary that points to 
 6           the run time code                                     
 7 DEFINING WORD  A Forth word that creates a dictionary entry     
 8 ELECTIVES      Optional blocks of words like floating point math
 9 FORWARD REFERENCE   Refering to undefined words                 
10 HEAD      Name and link field of dictionary entry               
11 LINK FIELD     Pointer to next entry of vocabulary, search order
12 NAME FIELD     Location of name of word, includes word length   
13 PAD       Area of memory for intermediate data storage          
14 PARAMETER FIELD    The area of the definition in which the      
15           actual code or values are contained                   


Screen 76 not modified     
 0 ( chapter 9 terms...forth engine...                   bdk012187)
 1 PFA         The address of the first entry of parmeter field    
 2 PRECOMPILED PORTION   The Forth system loaded at boot time with 
 3             all dictionary words and terms ready to use         
 4 RUN-TIME CODE     Usually the actual code that is the word      
 5 SYSTEM VARIABLES  Variables usuable by all users in system      
 6 TASK        A area of memory set aside for a given activity     
 7 TERMINAL TASK     A task that has a user talking to Forth       
 8 TEXT INPUT BUFFER   Memory area containing terminal input data  
 9 USER VARIABLE     Variable accessible by one user only          
10 VECTORED EXECUTION   Executing words by going to a pointer      
11 VOCABULARY        An independent linked list of words. In F83   
12                   SHADOW EDITOR HIDDEN BUG ROOT USER ASSEMBLER  
13                   DOS FORTH are vocabularies. Use VOCS to see   
14                   this list of vocabularies.                    
15                                                                 


Screen 77 not modified     
 0 ( chapter 9 forth engines text...                     bdk012187)
 1                                                                 
 2            CHAPTER 9 FORTH ENGINE                               
 3                                                                 
 4     Forth is a THREADED programing language. This means that a  
 5 action amounts to performing one instruction contained within   
 6 an instruction. Words which perform the actions are made up of  
 7 lists of addresses of words that together will perform the      
 8 desired action. These words within words can also have words    
 9 within them. If you follow the actual actions it is like a      
10 thread linking all the actions together.                        
11     In comparing Forth to assembly language it would be like a  
12 routine calling a subroutine which calls a subroutine and can   
13 call more till it finally does something and then returns back  
14 through each of the called routines. That final actual code     
15 performing actions makes up the KERNAL of the system.           


Screen 78 not modified     
 0 ( chapter 9 forth engine text.....                    bdk012787)
 1     The kernal is written in native code of the machine it is   
 2 on. The kernal creates the stack and basic operations of Forth. 
 3 Utilities are then written using Forth words, building blocks   
 4 until a full system is created. To move the system to another   
 5 type of processor requires rewritting only the native code of   
 6 the inner most kernal, not the utilities.                       
 7     Most computers are made up of CPU or central processor units
 8 which have a number of registers and instructions to move data  
 9 between registers and the outside world. What Forth does is to  
10 create an artificial processor in software that can be moved    
11 to different machines. This created processor can give the user 
12 near assembly language performance, while being transportable.  
13     In F83 we have the normal kernal using the Forth-83 word set
14 as well as many utilities, which create a full system. All these
15 abilities are contained in the dictionary. When Forth words are 


Screen 79 not modified     
 0 ( chapter 9 forth engine.....                         bdk012787)
 1 interpreted, FIND searches the dictionary for a match, and then 
 2 EXECUTES the instructions. What is passed is not actual words   
 3 but their address. An word contains addresses or machine code.  
 4 The kernal items are mostly code, while utilities are mostly    
 5 addresses pointing to code containing words.                    
 6     Forth has several ways to handle words by the user, one way 
 7 is ' which returns the address of the word, use U. to see the   
 8 actual address of a word ( ' SEE U. ). What interpret does is ' 
 9 the word then does EXECUTE on the address on the stack. This is 
10 not the address of the first address of a dictionary entry, but 
11 the third. Lets look at how words are arranged.                 
12     When you create or define a word, several entries in memory 
13 are completed. The word name is stored, up to 32 characters in  
14 F83, after a count of the length of the name. Next is the link  
15 to the next item in the current vocabulary. This link tells the 


Screen 80 not modified     
 0 ( chapter 9 forth engine.....                         bdk012787)
 1 interpreter where next to look if the current word is not a     
 2 match. After the link is the CODE FIELD ADDRESS or CFA. This is 
 3 what is returned by ' and points to the code or code intrepter. 
 4 The interpreter can be one of three types, variable, constant or
 5 code. The variable and constant return address or values on to  
 6 the stack respectively. The code points to either actual machine
 7 code if it is a kernal item, or more CFA's. What it points to is
 8 called PARAMETER FIELD or PFA, and given the CFA >BODY will put 
 9 the PFA on the stack.                                           
10     There are other actions that occur while the interpreter is 
11 going through the PFA, mainly pushing the next PFA onto the     
12 return stack. This is why use of the return stack must be done  
13 within the : definition, not doing so destroys the pointer to   
14 the next word. You can carefully handle this stack and cause    
15 wanted results by dropping off pointers, use caution though!    


Screen 81 not modified     
 0 ( chapter 9 engine exiting and map...                 bdk012787)
 1     You can officially leave a diffinition, using QUIT ABORT or 
 2 ABORT" any of these three end the operation. Generally these    
 3 ways are used inside of IF THEN or DO LOOPs checking for flags  
 4 or problems. When the last PFA is found the word EXIT is left.  
 5 This word removes the pointer from the return stack and this is 
 6 interpreted next. EXIT can not be used inside of DO LOOP as it  
 7 will return loop counters and not addresses.                    
 8     There are some ideas and words that you should know which   
 9 relate to the memory map of a Forth system. Normally from low   
10 memory up is the kernal, system variables, utilities, users     
11 dictionary space, the PAD, DATA STACK, TIB, RETURN STACK, users 
12 variables, and block buffers. The users dictionary grows toward 
13 the PAD, while the DATA and RETURN stacks grow down toward low  
14 memory. The stack is actually a pointer to memory locations and 
15 is lowered each time an entry is made.                          


Screen 82 not modified     
 0 ( chapter 9 system words..the engine..                bdk012787)
 1     To find these locations in memory, use DP to find the last  
 2 or highest memory location free for new dictionary word entries.
 3 DP is the pointer while HERE will place the pointer value on the
 4 stack ( same as DP @ ). To find the true location of the stack  
 5 use SP@ and it will fetch the pointers value, while S0 will get 
 6 the starting address of the stack. In higher memory above the   
 7 data stack is the TIB or Text Input Buffer and it grows  up     
 8 toward higher memory. TIB fetches the starting address of the   
 9 buffer. The input line interpreter reads this buffer to find out
10 what you have entered.                                          
11     To improve speed of interpretation, the dictionary is sorted
12 into different lists or vocabularies. When in these vocabularies
13 Forth will only search those words through use of the linked    
14 address value. Typing the name of a vocabulary puts you into    
15 that linked list. These lists can be scanned consectatively if  


Screen 83 not modified     
 0 ( chapter 9 last screen...vocs...                     bdk012287)
 1 the word is not found in the first list. VOCS will display the  
 2 list of current vocabualries, while CONTXET shows the search    
 3 order. CURRENT will print which VOCS you are now in. To see the 
 4 words contained in one of these list, enter DOS WORDS and you   
 5 will see all the dictionary entries that relate to the DOS ( and
 6 are used by Forth when talking to the operating system).        
 7     Take the time now and do some exploring in F83. Reading the 
 8 file README will explain some of the system terms and show a    
 9 memory map of a typical 8080 Forth system. Try reading all the  
10 VOCS and check CONTEXT before and after changing vocabularies.  
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                $$                                               


Screen 84 not modified     
 0 ( chapter 10 glossary...I/O...                        bdk012787)
 1                  CHAPTER 10 GLOSSARY ( I/O )                    
 2                                                                 
 3 UPDATE    ( - )  Marks most recently used block as modified     
 4 SAVE-BUFFERS     Writes all updated buffers to disk             
 5 FLUSH            Does save-buffers then frees all buffers       
 6 EMPTY-BUFFERS    Marks buffers as empty, all data is lost       
 7 BLOCK  ( u - a)  Put starting address of block u on stack       
 8 BUFFER ( u - a)  Like block but does not load block from disk   
 9 TYPE   ( a # -)  Send # characters at addr a to output device   
10 -TRAILING  (a #1 - a #2) Changes byte count to reflect blanks   
11 >TYPE  ( a # -)  TYPE for multiusers, puts string in PAD first  
12 MOVE  (a1 a2 # -)  Moves # of cells from a1 to a2 (low > hi)    
13 CMOVE (a1 a2 # -)  Moves # of bytes from a1 to a2 (low > hi)    
14 CMOVE> (a1 a2 #-)  Moves # of bytes from a1 to a2 (hi > low)    
15 BLANK  ( a # -)  Fill a with # of blank ASCII bytes             


Screen 85 not modified     
 0 ( chapter 10 glossary I/O                             bdk012387)
 1 KEY     ( - c)   Put next available INPUTED ASCII char on stack 
 2 EXPECT  (a # -)  Awaits # chars or CR from KEY storing at a     
 3 SPAN    (  - a)  Addrs of number of chars stored by EXPECT      
 4 WORD    (c - a)  Puts one word from input stream into addrs a   
 5 COUNT  (a -a+1 #)  Changes stack values of string a for TYPE    
 6 >IN    ( - a  )  Variable with pointer to next free input space 
 7 BLK    ( - a  )  Variable pointing to active block, 0= TIB      
 8 CONVERT (ud1 a1 -ud2 a2)  Convert ASCII string a1 to binary ud2 
 9 NUMBER ( a -d )  Convert ASCII string a to binary values d      
10 -TEXT  (a1 # a2-f)  Flag true if no match in strings # long     
11 -MATCH (d # s # -a f) Find match in stings s/d return addrs flag
12 "      ( - a  )  Returns address of compiled string             
13                                                                 
14                                                                 
15                                                                 


Screen 86 not modified     
 0 ( chapter 10 terms ..I/O                              bdk012387)
 1             CHAPTER 10 TERMS ( I/O )                            
 2                                                                 
 3 EXPECTING   Stop computing and wait for keyboard input          
 4 RELATIVE POINTER  An index into an array used with address to   
 5             find true location of data                          
 6 SCANNING    Searching ahead for given characters                
 7 SUPERSTRING  A string within an array of strings                
 8 VIRTUAL STRING  Use of disk storage as if it were real memory   
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15                                                                 


Screen 87 not modified     
 0 ( chapter 10 text of I/O....                          bdk012787)
 1                 CHAPTER 10 I/O                                  
 2                                                                 
 3     Forth handles data in blocks or groups of data 1024 bytes   
 4 long. These can be in blocks of data on the disk or blocks of   
 5 data contained in buffers within Forths memory map. These blocks
 6 can have data, screens of source code, text, or grabage. F83 has
 7 a number of ways of handling these blocks of data.              
 8     When we list a screen, F83  checks to see if the block has  
 9 been load from disk, if not it loads it into a free buffer. Then
10 it returns a pointer to this block and LIST then displays it. If
11 we have edited a block or changed it, it will be UPDATEd and    
12 marked for storage to disk. This storage is not done until the  
13 buffer is needed. You can force the storage two ways. FLUSH will
14 empty all updated buffers and clear all pointers, while the word
15 SAVE-BUFFERS writes to disk, but does not clear the pointers.   


Screen 88 not modified     
 0 ( chapter 10 I/O block and stuff....                  bdk012787)
 1     EMPTY-BUFFERS will clear all pointers without writting to   
 2 disk. Any data contained within the buffers is lost at the sake 
 3 of freeing all buffers for more data. Accessing these buffers   
 4 you use BLOCK to return the address of the first byte in the    
 5 numbered block. If the block is not already in memory, BLOCK    
 6 will force it to be read. BUFFER returns a blocks address but   
 7 will not force a read ( used within BLOCK).                     
 8     We can get data into the system, either from the blocks or  
 9 from the input string (keyboard). As indicated before to output 
10 characters to the terminal you use EMIT. To send strings you use
11 TYPE, with the count on top and string address below. TYPE will 
12 print the characters including blanks, -TRAILING will return    
13 without the blanks by changing the stack count, then use TYPE.  
14     To get these strings into buffers or locations accessible to
15 our programs we can MOVE them around. MOVE copies 16 bit cells  


Screen 89 not modified     
 0 ( chapter 10 I/O moves...                             bdk012787)
 1 from locations pointed to by the third stack item to the second 
 2 stack address, and will move the count value(top stack). CMOVE  
 3 does the same, but count is now byte moves or 8 bits at a time. 
 4 These move the data from low memory to higher memory and could  
 5 over write data yet to be moved. CMOVE> starts from the top or  
 6 high memory and moves data down, preventing garbage generation. 
 7     Forth has several ways of getting input from the keyboard   
 8 into the system. KEY is the basic single character input word.  
 9 KEY? flags if the keyboard has been used. EXPECT will wait and  
10 then store a string of characters from the keyboard.            
11     Once we have the data in the TIB, we now need to be able to 
12 process it. WORD will scan a string until it finds a given      
13 character and then moves this string to a new buffer with the   
14 count (length of string) as the first address. We use COUNT to  
15 add one to the address and push the count on the stack.         


Screen 90 not modified     
 0 ( chapter 10 I/O string working...                    bdk012787)
 1     When performing your own control over Forth, you will want  
 2 more control than most programming languages provide. Many of   
 3 the string commands help you understand how Forth works, and    
 4 there are  more pointers that may be of interest to you. >IN    
 5 tells where in the input string the interpreter is at, while BLK
 6 indicates wether the system is taking input from the TIB or the 
 7 block buffers. If BLK is zero, input is from TIB, non zero is   
 8 block buffers.                                                  
 9   There are two ways to compare strings looking for matches. The
10 -TEXT word compares two strings with a given length and will set
11 the flag false if they match. -MATCH searches for a match of one
12 string and its length within a second string of some length, if 
13 a match is found the stack will contain the starting address of 
14 the match and the flag set false (in that order).               
15    The handling of strings is not difficult in Forth and in fact


Screen 91 not modified     
 0 ( chapter 10 last of I/O text...                      bdk012387)
 1 you have more control over how to handle strings than any other 
 2 programming language. If Forth doesn't do what you want, just   
 3 write some word that does.                                      
 4     As a problem, try writing some words that find matches in   
 5 a block buffer and then change them to random words selected    
 6 from a second buffer, should be fun and produce some intersting 
 7 statements.                                                     
 8                                                                 
 9                                                                 
10                                                                 
11                                                                 
12                                                                 
13                                                                 
14                                                                 
15               (  $$   )                                         


Screen 92 not modified     
 0 ( chapter 11 extending....glossary                    bdk012787)
 1           CHAPTER 11 GLOSSARY  ( EXTENDING )                    
 2                                                                 
 3 DOES>   ( -- a)  Separates compile data from run-time portion   
 4 IMMEDIATE        To be executed not compiled into the word      
 5 COMPILE xxx      Compile word xxx address into definition       
 6 LITERAL          A value pushed on stack by a word (binary)     
 7 [                Leaves compile mode                            
 8 ]                Starts compile mode                            
 9 [COMPILE] xxx    Makes a immediate be treated as non-immediate  
10 STATE   ( -- a)  True if compiling, false if interpreting       
11 INTERPRET        Perform text interpretation of input stream    
12                                                                 
13                                                                 
14                                                                 
15                                                                 


Screen 93 not modified     
 0 ( chapter 11 extending..terms..                       bdk012787)
 1             CHAPTER 11  TERMS  ( EXTENDING )                    
 2                                                                 
 3 COMPILE-TIME    The action of compiling or generating a new     
 4          dictionary entry, for later run-time use.              
 5 COMPILING WORD A word that has action only during the           
 6          compilation stage, to generate proper run-time action. 
 7 DEFINING WORD  When executed defines a new dictionary entry     
 8           that may have compile-time and run-time parts.        
 9 IMMEDIATE WORD  A word that gets executed during compilation    
10           and not compiled into dictionary.                     
11 PRECEDENCE BIT  The 16th bit, indicates wether a word should be 
12          executed (immediadte) or compiled.                     
13 RUN-TIME        The normal action which a word will take, which 
14           is what the word DOES>, it's definition.              
15                                                                 


Screen 94 not modified     
 0 ( chapter 11 extending the dictionary..text..         bdk012787)
 1                CHAPTER 11  EXTENDING                            
 2                                                                 
 3     It is at this point that we find out how Forth  works.      
 4 More important it is where we find out how to change Forth to   
 5 meet our needs. All of this is done by extending the dictionary 
 6 or when compared to other languages it would be like re-writting
 7 the compiler so that it has new ways of handling the input. You 
 8 can never NOT do something in Forth, it may not at present have 
 9 a way of handling your desires, but learn its insides and you   
10 can make it do anything.                                        
11     We should remember that Forth has two states or actions     
12 possible. The first is interpreting, the other compiling. In the
13 interpretive mode we take data from a source and perform actions
14 much like basic reads lines of code and acts on them. The other 
15 mode creates new words for the interpreter to use. It would be  


Screen 95 not modified     
 0  ( chapter 11 extending...                            bdk012787)
 1 like creating a new print command in basic (something you can't 
 2 do).                                                            
 3     The words we use in the interpret mode have all been defined
 4 and compiled in the kernal of Forth. The UTILITY.BLK and CPU8088
 5 .BLK have most of the source code words for you to look over. In
 6 looking these words over we will see two possible actions that  
 7 can take place in creating the dictionary words. These two are  
 8 compile-time and run-time activities.                    .      
 9     When compiling if we used  Forth words that act on the      
10 input data immediately, we would get garbage. That is it would  
11 output data as the word was being created, not when we are      
12 invoking it. Therefore we need to have words that control when  
13 words do their thing.                                           
14     CREATE is the word that creates the dicitonary entry and    
15 puts in link and code addresses. This word is used to define    


Screen 96 not modified     
 0 ( chapter 11 extending..                              bdk012787)
 1 words like CONSTANT and VARIABLE. These words when we use them  
 2 will CREATE a dictionary input using the name we pass at that   
 3 time. CREATE doesn't do anything at the time it is used in the  
 4 defined word, only when we invoke it as part of a new defined   
 5 word. Now if we want the new defined word that was created by   
 6 using a word with CREATE in it, we use DOES>. DOES> separates   
 7 the creation from the activity when it is invoked. This is the  
 8 difference between compile-time and run-time actions.           
 9     Compile-time actions occur when the word is being created,  
10 while run-time actions occur when the word is being interpreted.
11 It is important to understand the two different states of Forth 
12 activities. You compile words into the dictionary which when    
13 they get invoked will perform certain activities. To compile    
14 these words may require some actions which are different from   
15 the actions that occur at run-time (interpretation).            


Screen 97 not modified     
 0 ( chapter 11 extending..                              bdk012787)
 1     Interpretation occurs at all times, it just that some of the
 2 interpreting is used to make new dictionary entries and some is 
 3 used to handle screen output. You don't want the two actions to 
 4 become confussed.                                               
 5     F83 has defined two words which can help show the difference
 6 between these two states ." and .(  The ." will store a string  
 7 that is printed when the word is invoke as in error messages.   
 8 The .( will print the string only while the word is being       
 9 compiled, or as I have used in the load screen to TUTOR it tells
10 you to wait while it is loading new words.                      
11     If we want to compute some values that later will be part of
12 the new defined word as LITERAL values we would use [ and ] .   
13 The [ means interpret now, while ] means to stop interpreting   
14 and resume compiling the word. If you are compiling directly    
15 from the keyboard ] will continue compilation after a carriage  


Screen 98 not modified     
 0 ( chapter 11 extending and last text screen           bdk012787)
 1 return.                                                         
 2     The word IMMEDIATE means that  this word is used within a   
 3 compilation to do its action immediately. The opposite of this  
 4 is [COMPILE] which delays compiling of the word till used in an 
 5 other words compilation.                                        
 6     Keeping track of when and what is being compiled and        
 7 interpreted takes some time and practice. Use the book for most 
 8 of this discussion. The samples and charts of when and how the  
 9 dictionary is changed is too complex for this simple tutorial.  
10     To really understand Forth, you must use it and play with it
11 understanding how to adapt it to your style of programming. F83 
12 and Forth together should be able to solve programming problems 
13 with ease once you understand it.                               
14    ENJOY.                                                       
15                                                      ( $$  )    
projects/f83_tutor.txt · Zuletzt geändert: 2013-06-06 21:27 (Externe Bearbeitung)