Benutzer-Werkzeuge

Webseiten-Werkzeuge


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

l

oading 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.

          Bill Kibler
          Kibler Electronics
          PO BOX 487
          Cedarville, CA 96104

I do use the Sacramento Micro Users Group RBBS and can get messages there: 300/1200 24 hrs (916)722-9337

 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 
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
                                                                     
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 von 127.0.0.1