Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- papierkorb:f83_tutor [2025-08-16 19:10] – ↷ Seite von projects:f83_tutor nach papierkorb:f83_tutor verschoben mka
+++ papierkorb:f83_tutor [Unbekanntes Datum] (aktuell) – gelöscht - Externe Bearbeitung (Unbekanntes Datum) 127.0.0.1
@@ Zeile 1: / Zeile 1: @@
-=== F83 TUTOR by BILL KIBLER ===
-(c) 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
-) 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:
-<code>
-          A>F83
-          OPEN TUTOR.BLK
-LOAD
-</code>
-Use the space bar to scan through the screens of information, and
-then  choose  a chapter to start your review.  For novice or  new
-users  of Forth a more detailed introduction follows in the  next
-section.
-== GETTING STARTED ==
-Forth  is  both a programming language and  a  operating  system.
-TUTOR  is a simple F83 tutorial consisting of "WORDS" that handle
-the  information and tutorial screens based on the book  "STARING
-FORTH".  All  new or novice users should use this book,  as  they
-will find the tutor text information to be too brief for  develo
-ping  a good understanding of Forth.  The screens of  information
-will help you understand Forth and will help point out the diffe
-rence  between  F83  and the FIRST EDITION of the  book.  As  you
-follow  through  the screens you will notice that  some  glossary
-words will be different from those in the book,  these  represent
-the  new  word set as specified in the Forth-83  standard.  Those
-readers  using the SECOND EDITION of "STARTING FORTH"  will  find
-tutor to be an on disk review of the book.
-To  better  understand this program an introduction to Forth  and
-its  structure  is needed.  Forth is a stack  oriented  language.
-Values  are  placed on the stack and then WORDS  are  entered  to
-perform actions on these values. The most simple use would be the
-addition  of  two numbers.  To add the numbers 4 and 7 you  would
-enter 4 7 + . and Forth would return 11 ok. Considerable problems
-occur  for new Forth users over the use of text type  symbols  to
-represent  words or commands.  The sample used a .  to denote the
-command  to  print  the top item of the stack  on  the  computers
-screen.  In displaying information about Forth it is very hard in
-a document to prevent confusion between Forth WORDS and the  text
-used  to display them.  Until you can know which words are  Forth
-WORDS  and  which are text words,  reference to the text book  is
-needed.  The book puts a block around each word when described in
-the text, an option not available on all computer systems.
-This problem of variations in computer  systems and languages has
-been handled by the FORTH INTEREST GROUP in respect to Forth. The
-term  FIG  Forth refers to an early set of Forth WORDS  that  the
-interest  group  established as the first standard Forth  system.
-The  next  standards  meeting  in  1979  made  some  changes  and
-established a new Forth standard called Forth-79.  The latest and
-one that this tutorial is intended to help is the 1983  standards
-meeting version,  this word  set is called Forth-83.  The program
-this  tutorial is for is F83 which is a public domain version  of
-Forth containing the Forth-83 word set.
-Although  a  few  words  have been changed  between  standards  a
-considerable  amount of similarity exists between the  standards.
-F83  is very popular because of its cost and  utilities contained
-within  the  program.  F83  contains not only the  normal  screen
-editor and assembler, but also debugger, disassembler, and multi-
-tasker  utilities.  There are many commercial and  public  domain
-versions of Forth,  in fact there is a version of Forth available
-for  almost  all  the  operating systems  and  computer  hardware
-systems currently being produced.  Forth is a  small,  fast,  and
-extensible  operating environment.   It has been used in numerous
-special  applications,  such as space vehicles,  where speed  and
-reliability are major concerns. The extensible nature of Forth is
-its most important aspect.
-== LOADING TUTOR AND EXTENSIONS ==
-The  Forth  system can be stand-alone or work within an  existing
-operating system.  All Forths store information in SCREENS  which
-are  1K in size ( 1024 bytes).  When a screen is displayed it can
-consist of 60 characters across and 16 lines down ( one character
-is  equal to one byte of information).  The F83 operating  system
-stores  the  screens  on disk as BLOCKS of data (1  screen  is  1
-block).  Typically the file name will have an extension of BLK to
-indicate  Forth  information.  The  TUTOR program  is  stored  as
-"TUTOR.BLK" on most systems. Starting F83 would be done by typing
-F83 at the system prompt and using "RETURN"  on most MSDOS or CPM
-systems.
-To load the TUTOR program after starting F83, the file must first
-be OPENED,  you do this by typing "OPEN TUTOR.BLK" and a  return.
-Next  it is necessary to LOAD the Forth extensions which are used
-by  the TUTOR program.  You type  "1 LOAD" and return, this  will
-start the TUTOR program and give you more information about  F83.
-Should your system be different or you are new to computers,  you
-may  need to review and use programs supplied by the system manu
-facturer until you understand and feel comfortable with your  new
-computer.  Some  versions of F83 use different words to open  and
-load files (due to operating system designs), check with your own
-documentation on specific instructions.
-The   "1 LOAD" command loads screen 1 into memory and then starts
-compiling the new word definitions contained in it.  These  words
-are extensions to the orginal F83 word set.  After being compiled
-they  are part of the Forth DICTIONARY and can be used as if they
-were part of the original program. This ability to add words  and
-EXTEND  the dictionary is the source of the term "extensibility".
-Programs  are  created  by  extending  the  dictionary  with  new
-functions  and routines. The TUTORS new words are contained in  4
-of the first 10 screens and can be changed should you desire some
-special way of handling the tutor screens.
-== TUTOR WORDS ==
-The new words are:
-  * HELP Loads the information about the tutor program and general F83 words. The last screen lists words used by tutor and relating to "STARTING FORTH".
-  * START-TUTOR   Will start displaying the introduction to tutorial information.
-  * REPT   This command will display screens from the beginning of the most recent chapter or group of screens. If CHP1 had been entered and you exited the listings to try a F83 operation REPT will restarted at the first screen of CHP1.
-  * GET       GET will start displaying screens at the next one in sequence. Using REPTs sample, if you had typed GET instead of REPT you would get displayed the next screen of information in CHP1.
-  * 21 TUTOR  Typing this will start displaying tutor screens starting with screen 21 and continuing till the screen contains $$. When you type CHP1 this word loads the number of the first screen of chapter 1  on the stack and then goes to TUTOR.
-  * PRTSCR    This word will display the current GET and REPT pointers.
-  * LIST      Forths normal internal word for displaying screens of information. Use this word whenever you want to view a single screen. TUTOR uses a modified version of LIST for displaying multiple screens.
-  * 10 90 INDEX    Use this input command line to get a list of "INDEX" lines (line 0 and NOT printed by tutor) of screens 10 through 90 (the text screens). Line 0 is generally used as a descriptive line of what the screen contains.
-  * ESC       Using the ESCAPE key will end the display of information, so that you can then tryout some of what you just learned in the text.
-== ADVANCED INFORMATION ==
-TUTOR uses most of the normal F83 words to perform its functions.
-A  major advantage of the tutor program is to retain easy  access
-to  the  normal F83 functions.  The tutor program will display  a
-series of screens starting with glossary information. Experienced
-programmers will find this part most helpful in learning the  new
-F83 words.  When finished displaying text screens, the F83 prompt
-"ok" will indicate completion of the lesson.  At this point  any
-F83  commands can be used.  Individual screens can be repeated by
-using the list function.
-A  number  of blank screens have been provided at the end of  the
-program  for use during the learning sessions.  As new words  are
-created  in the lesson,  they can be saved in these screens  and
-auto loaded by adding "nn LOAD" to screen 5 (nn being first  used
-screen).  To  tie screens together use --> and F83 will  continue
-loading the next screen.
-For  educators  and programmers,  they will find TUTOR to  be  an
-excellent  example of how to create a tutorial program in  Forth.
-It  is very hard to create a tutorial program in which  the  user
-has  enough control over the training structure that it can  meet
-their  needs adequately.  Most users of tutorials get  frustrated
-when  they can not exit or reenter the program at  will.  Usually
-lacking in tutorials is the ability to add sorting of information
-or  the creation of summary details.  Forth appears to handle all
-these  problems easily. Once the user understands Forths  use  of
-words it is possible to customize the tutorial for their personal
-needs.  An example of this would be the creation of a new word to
-keep  track of exiting and saving the screens pointers  to  disk.
-When  returning,  the user would type RESTART and the disk stored
-pointers would be restored,  and the next screen would be  loaded
-for viewing.
-Although  not  shown  here,  interactive  uses  of  training  are
-possible. Forth has numerous words to allow for trapping of input
-data  and evaluating this information for correct  response.  The
-use of screens provides a simple way of grouping information such
-that  a  student who misses a concept (as found through  testing,
-see  screen  39)  could  be directed  back  to  that  information
-automatically. A new feature in F83 is the use of SHADOW screens.
-These  screens are from the original file UTILITY.BLK of F83  and
-contain  the  authors  comments on words in the  source  screens.
-Words  are  available  to toggle between these  screens  and  the
-source  screens.  Use of this feature may be helpful in  tutorial
-programs,  where  background or detailed discussions outside  the
-normal flow of instruction is needed.
-== CONCLUSION ==
-The  creation  of  this  program was two  fold;  to  show  Forths
-abilities  in  creating  tutorials,   and  to  provide  on   disk
-information about F83. This project was part of a masters program
-in Computers and Education.  This is by no means a complete study
-of  using Forth for tutorials, of F83, or Forth.  I have released
-this version of TUTOR.BLK into public domain solely to help those
-who have had problems getting to understand the new words of F83.
-One  reason I feel that Forth has had problems being accepted  is
-the  lack  of tutorials accompanying new releases.  When I  first
-tried  F83,  I found the on disk documentation to be  inadequate.
-Although the use of shadow screens is an improvement, they do not
-equal the benefits of a good tutorial or disk based glossary.
-I am interested in your comments concerning this program and  any
-information  that  could make it better.  My  time  currently  is
-limited  and thus I can only take written queries.  I retain  all
-commercial rights to the screens 1 through 10,  as they represent
-the  idea  behind the tutorial,  as well as the information  con
-tained  within  the  text  screens  not  directly  attributed  to
-"STARTING  FORTH" by Leo Brodie.  I am available  for  commercial
-activities  and would be willing to assist in developing  commer
-cial tutorials.
-<code>
-          Bill Kibler
-          Kibler Electronics
-          PO BOX 487
-          Cedarville, CA 96104
-</code>
-I  do  use  the  Sacramento Micro Users Group RBBS  and  can  get
-messages there: 300/1200 24 hrs (916)722-9337
-<code>
- ok
-OPEN TUTOR.BLK  ok
-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
-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
-is on top, the + sign is interpreted and Forth adds the 2 and
-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
-SWAP  (d1 d2 -- d2 d1) swap the top two PAIRS of numbers
-DUP   (d -- d d)  duplicates the top PAIRS of numbers
-OVER  (d1 d2 -- d1 d2 d1)  copy second PAIR, push on top
-DROP  (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
-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
-+(17*12) would be presented in forth as 17 12 * 4 + . with
-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
-), we also have double word or item operators, these are
-SWAP, 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
-. 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
-=  (n - f)        Returns true if n equals zero
-<  (n - f)        Returns true if n is negative
->  (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 )
-+    (n - n+1)  Adds one to n
--    (n - n-1)  Subtracts one from n
-+    (n - n+2)  Adds two to n
--    (n - n-2)  Subtracts two from n
-*    (n - n*2)  Multiplies n by two (shift left )
-/    (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
-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
-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/
-, .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
-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- 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* 1 +  ( guarantee it is odd )
-            PAGE    CR CR   ( clear screen and move down  )
-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
-A 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
-#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
-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
-and a 16 bit number for a 32 bit answer, M/ a 32 by 16 for a
-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
-VARIABLE xxx    Creates double length variable
-     @CONSTANT xxx    Creates double length constant
-!     ( d a - ) Stores double length number into a address
-@     ( a - d ) Fetches double length double from a address
-.     ( - 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:
-CONSTANT, as well as 2! to store a double length variable, and
-@ to fetch double length variables or constants.
-         Many programs use arrays, or a number of memory locations
-     that can contain values. Arrays can have fixed values, as in a
-     table of phone numbers, or variables which can keep count of a
-     number of events. To create an array in Forth use the word
-     CREATE and the name assigned to it. The compiler will set as
-     many memory locations aside as you ALLOT to it. An array of two
-     will be defined, unless you allot more. Placing values in or out
-     of an array is the same as any variable, it is just the address
-     provided will be for the first entry in the array. If you want
-     the seventh item, you must increment the address by 14 as each
-     location is 2 addresses in length. The same is true for ALLOT
-     you must double the value (10 ALLOT creates 5 16bit locations).
-     An example of an array is your programs memory. Forth has a
-     word for looking at this large array, it is DUMP. Place the
-     starting address on the stack, next push the count or how far
-     you want displayed, then DUMP and watch what is there.
-         As we said before a byte is 8 bits and is the smallest way
-     some machines handle information. You can get data from or into
-     an array in 8 bits at a time. Arrays of characters are all 8 bit
-     entries. C! stores 8 bits, while C@ fetch 8 bits, just remember
-     to set the address one step for each location in the array.
-         The , is used to create a constant with values entered at
-     time of compilation. Use values and a , for each entry instead
-     allotting space (do not forget the last , ).
-         Variables, constants, and arrays are easy to create in Forth
-     and just as easy to use. For a problem we can use the topic of
-     last chapter and this to create a telephone listing or array.
-     This array should contain numbers and when queried with an
-     index produce formatted output. Lets give it a try...
-               Scr # 73         C:TUTOR.BLK
-             CHAPTER 9  GLOSSARY  ( FORTH ENGINE )
-     ' xxx  ( - a )   Returns dictionary address of xxx
-     [']    ( - a )   Generates literal number used inside the words
-                      definition of the next word used in definition
-     EXECUTE  (a -)   Executes the dictionary entry at address a
-     @EXECUTE (a -)   Executes entry pointed to at address a
-     >BODY  (cfa -pfa)  Returns parameter field from compilation addr
-     EXIT   (  -- )   Terminates or returns from definition
-     QUIT   ( --  )   Clears stack, gets control, no ok prompt
-     ABORT  ( --  )   Clears data stack then does QUIT
-     DP      ( - a)   Returns address of dictionary pointer
-     HERE   ( -- a)   Next available dictionary location
-     PAD    ( -- a)   Beginning address of character string buffer
-     SP@    ( -- a)   Pointer to top of data stack
-     S0    ( -- a)   Returns address of bottom of data stack
-     TIB   ( -- a)   Returns address of text input buffer
-     FORTH  ( -- )   Makes FORTH context vocabulary
-     EDITOR ( -- )   Makes EDITOR context vocabulary
-     CONTEXT ( - a)  Returns address of search order variable
-     CURRENT ( - a)  Returns address of new word vocabulary ( vocs)
-     DEFINITIONS     Sets the current vocs to context vocs
-              CHAPTER 9 TERMS ( FORTH ENGINE )
-     ADDRESS INTERPRETER   Interprets the address from the colon
-               definitions and executes them
-     BODY      The code and parameter of a dictionary entry
-     BOOT      The basic starting portion of Forth, precompiled Forth
-     CFA       Address of code field in a dictionary entry
-     CONTROL TASK   A task that does not converse with Forth
-     CODE POINTER FIELD   The entry in the dictionary that points to
-               the run time code
-     DEFINING WORD  A Forth word that creates a dictionary entry
-     ELECTIVES      Optional blocks of words like floating point math
-     FORWARD REFERENCE   Refering to undefined words
-     HEAD      Name and link field of dictionary entry
-     LINK FIELD     Pointer to next entry of vocabulary, search order
-     NAME FIELD     Location of name of word, includes word length
-     PAD       Area of memory for intermediate data storage
-     PARAMETER FIELD    The area of the definition in which the
-               actual code or values are contained
-     PFA         The address of the first entry of parmeter field
-     PRECOMPILED PORTION   The Forth system loaded at boot time with
-                 all dictionary words and terms ready to use
-     RUN-TIME CODE     Usually the actual code that is the word
-     SYSTEM VARIABLES  Variables usuable by all users in system
-     TASK        A area of memory set aside for a given activity
-     TERMINAL TASK     A task that has a user talking to Forth
-     TEXT INPUT BUFFER   Memory area containing terminal input data
-     USER VARIABLE     Variable accessible by one user only
-     VECTORED EXECUTION   Executing words by going to a pointer
-     VOCABULARY        An independent linked list of words. In F83
-     SHADOW EDITOR HIDDEN BUG ROOT USER ASSEMBLER
-                       DOS FORTH are vocabularies. Use VOCS to see
-                       this list of vocabularies.
-                CHAPTER 9 FORTH ENGINE
-         Forth is a THREADED programing language. This means that a
-     action amounts to performing one instruction contained within
-     an instruction. Words which perform the actions are made up of
-     lists of addresses of words that together will perform the
-     desired action. These words within words can also have words
-     within them. If you follow the actual actions it is like a
-     thread linking all the actions together.
-         In comparing Forth to assembly language it would be like a
-     routine calling a subroutine which calls a subroutine and can
-     call more till it finally does something and then returns back
-     through each of the called routines. That final actual code
-     performing actions makes up the KERNAL of the system.
-     The kernal is written in native code of the machine it is
-     on. The kernal creates the stack and basic operations of Forth.
-     Utilities are then written using Forth words, building blocks
-     until a full system is created. To move the system to another
-     type of processor requires rewritting only the native code of
-     the inner most kernal, not the utilities.
-         Most computers are made up of CPU or central processor units
-     which have a number of registers and instructions to move data
-     between registers and the outside world. What Forth does is to
-     create an artificial processor in software that can be moved
-     to different machines. This created processor can give the user
-     near assembly language performance, while being transportable.
-         In F83 we have the normal kernal using the Forth-83 word set
-     as well as many utilities, which create a full system. All these
-     abilities are contained in the dictionary. When Forth words are
-     interpreted, FIND searches the dictionary for a match, and then
-     EXECUTES the instructions. What is passed is not actual words
-     but their address. An word contains addresses or machine code.
-     The kernal items are mostly code, while utilities are mostly
-     addresses pointing to code containing words.
-         Forth has several ways to handle words by the user, one way
-     is ' which returns the address of the word, use U. to see the
-     actual address of a word ( ' SEE U. ). What interpret does is '
-     the word then does EXECUTE on the address on the stack. This is
-     not the address of the first address of a dictionary entry, but
-     the third. Lets look at how words are arranged.
-         When you create or define a word, several entries in memory
-     are completed. The word name is stored, up to 32 characters in
-     F83, after a count of the length of the name. Next is the link
-     to the next item in the current vocabulary. This link tells the
-     interpreter where next to look if the current word is not a
-     match. After the link is the CODE FIELD ADDRESS or CFA. This is
-     what is returned by ' and points to the code or code intrepter.
-     The interpreter can be one of three types, variable, constant or
-     code. The variable and constant return address or values on to
-     the stack respectively. The code points to either actual machine
-     code if it is a kernal item, or more CFA's. What it points to is
-     called PARAMETER FIELD or PFA, and given the CFA >BODY will put
-     the PFA on the stack.
-         There are other actions that occur while the interpreter is
-     going through the PFA, mainly pushing the next PFA onto the
-     return stack. This is why use of the return stack must be done
-     within the : definition, not doing so destroys the pointer to
-     the next word. You can carefully handle this stack and cause
-     wanted results by dropping off pointers, use caution though!
-     You can officially leave a diffinition, using QUIT ABORT or
-     ABORT" any of these three end the operation. Generally these
-     ways are used inside of IF THEN or DO LOOPs checking for flags
-     or problems. When the last PFA is found the word EXIT is left.
-     This word removes the pointer from the return stack and this is
-     interpreted next. EXIT can not be used inside of DO LOOP as it
-     will return loop counters and not addresses.
-         There are some ideas and words that you should know which
-     relate to the memory map of a Forth system. Normally from low
-     memory up is the kernal, system variables, utilities, users
-     dictionary space, the PAD, DATA STACK, TIB, RETURN STACK, users
-     variables, and block buffers. The users dictionary grows toward
-     the PAD, while the DATA and RETURN stacks grow down toward low
-     memory. The stack is actually a pointer to memory locations and
-     is lowered each time an entry is made.
-     To find these locations in memory, use DP to find the last
-     or highest memory location free for new dictionary word entries.
-     DP is the pointer while HERE will place the pointer value on the
-     stack ( same as DP @ ). To find the true location of the stack
-     use SP@ and it will fetch the pointers value, while S0 will get
-     the starting address of the stack. In higher memory above the
-     data stack is the TIB or Text Input Buffer and it grows  up
-     toward higher memory. TIB fetches the starting address of the
-     buffer. The input line interpreter reads this buffer to find out
-     what you have entered.
-         To improve speed of interpretation, the dictionary is sorted
-     into different lists or vocabularies. When in these vocabularies
-     Forth will only search those words through use of the linked
-     address value. Typing the name of a vocabulary puts you into
-     that linked list. These lists can be scanned consectatively if
-     the word is not found in the first list. VOCS will display the
-     list of current vocabualries, while CONTXET shows the search
-     order. CURRENT will print which VOCS you are now in. To see the
-     words contained in one of these list, enter DOS WORDS and you
-     will see all the dictionary entries that relate to the DOS ( and
-     are used by Forth when talking to the operating system).
-         Take the time now and do some exploring in F83. Reading the
-     file README will explain some of the system terms and show a
-     memory map of a typical 8080 Forth system. Try reading all the
-     VOCS and check CONTEXT before and after changing vocabularies.
-          Scr # 84         C:TUTOR.BLK
-                      CHAPTER 10 GLOSSARY ( I/O )
-     UPDATE    ( - )  Marks most recently used block as modified
-     SAVE-BUFFERS     Writes all updated buffers to disk
-     FLUSH            Does save-buffers then frees all buffers
-     EMPTY-BUFFERS    Marks buffers as empty, all data is lost
-     BLOCK  ( u - a)  Put starting address of block u on stack
-     BUFFER ( u - a)  Like block but does not load block from disk
-     TYPE   ( a # -)  Send # characters at addr a to output device
-     -TRAILING  (a #1 - a #2) Changes byte count to reflect blanks
-     >TYPE  ( a # -)  TYPE for multiusers, puts string in PAD first
-     MOVE  (a1 a2 # -)  Moves # of cells from a1 to a2 (low > hi)
-     CMOVE (a1 a2 # -)  Moves # of bytes from a1 to a2 (low > hi)
-     CMOVE> (a1 a2 #-)  Moves # of bytes from a1 to a2 (hi > low)
-     BLANK  ( a # -)  Fill a with # of blank ASCII bytes
-     KEY     ( - c)   Put next available INPUTED ASCII char on stack
-     EXPECT  (a # -)  Awaits # chars or CR from KEY storing at a
-     SPAN    (  - a)  Addrs of number of chars stored by EXPECT
-     WORD    (c - a)  Puts one word from input stream into addrs a
-     COUNT  (a -a+1 #)  Changes stack values of string a for TYPE
-     >IN    ( - a  )  Variable with pointer to next free input space
-     BLK    ( - a  )  Variable pointing to active block, 0= TIB
-     CONVERT (ud1 a1 -ud2 a2)  Convert ASCII string a1 to binary ud2
-     NUMBER ( a -d )  Convert ASCII string a to binary values d
-     -TEXT  (a1 # a2-f)  Flag true if no match in strings # long
-     -MATCH (d # s # -a f) Find match in stings s/d return addrs flag
-     "      ( - a  )  Returns address of compiled string
-             CHAPTER 10 TERMS ( I/O )
-     EXPECTING   Stop computing and wait for keyboard input
-     RELATIVE POINTER  An index into an array used with address to
-                 find true location of data
-     SCANNING    Searching ahead for given characters
-     SUPERSTRING  A string within an array of strings
-     VIRTUAL STRING  Use of disk storage as if it were real memory
-                    CHAPTER 10 I/O
-     EMPTY-BUFFERS will clear all pointers without writting to
-     disk. Any data contained within the buffers is lost at the sake
-     of freeing all buffers for more data. Accessing these buffers
-     you use BLOCK to return the address of the first byte in the
-     numbered block. If the block is not already in memory, BLOCK
-     will force it to be read. BUFFER returns a blocks address but
-     will not force a read ( used within BLOCK).
-         We can get data into the system, either from the blocks or
-     from the input string (keyboard). As indicated before to output
-     characters to the terminal you use EMIT. To send strings you use
-     TYPE, with the count on top and string address below. TYPE will
-     print the characters including blanks, -TRAILING will return
-     without the blanks by changing the stack count, then use TYPE.
-         To get these strings into buffers or locations accessible to
-     our programs we can MOVE them around. MOVE copies 16 bit cells
-     from locations pointed to by the third stack item to the second
-     stack address, and will move the count value(top stack). CMOVE
-     does the same, but count is now byte moves or 8 bits at a time.
-     These move the data from low memory to higher memory and could
-     over write data yet to be moved. CMOVE> starts from the top or
-     high memory and moves data down, preventing garbage generation.
-         Forth has several ways of getting input from the keyboard
-     into the system. KEY is the basic single character input word.
-     KEY? flags if the keyboard has been used. EXPECT will wait and
-     then store a string of characters from the keyboard.
-         Once we have the data in the TIB, we now need to be able to
-     process it. WORD will scan a string until it finds a given
-     character and then moves this string to a new buffer with the
-     count (length of string) as the first address. We use COUNT to
-     add one to the address and push the count on the stack.
-     When performing your own control over Forth, you will want
-     more control than most programming languages provide. Many of
-     the string commands help you understand how Forth works, and
-     there are  more pointers that may be of interest to you. >IN
-     tells where in the input string the interpreter is at, while BLK
-     indicates wether the system is taking input from the TIB or the
-     block buffers. If BLK is zero, input is from TIB, non zero is
-     block buffers.
-       There are two ways to compare strings looking for matches. The
-     -TEXT word compares two strings with a given length and will set
-     the flag false if they match. -MATCH searches for a match of one
-     string and its length within a second string of some length, if
-     a match is found the stack will contain the starting address of
-     the match and the flag set false (in that order).
-        The handling of strings is not difficult in Forth and in fact
-     you have more control over how to handle strings than any other
-     programming language. If Forth doesn't do what you want, just
-     write some word that does.
-         As a problem, try writing some words that find matches in
-     a block buffer and then change them to random words selected
-     from a second buffer, should be fun and produce some intersting
-     statements.
-               Scr # 92         C:TUTOR.BLK
-               CHAPTER 11 GLOSSARY  ( EXTENDING )
-     DOES>   ( -- a)  Separates compile data from run-time portion
-     IMMEDIATE        To be executed not compiled into the word
-     COMPILE xxx      Compile word xxx address into definition
-     LITERAL          A value pushed on stack by a word (binary)
-     [                Leaves compile mode
-     ]                Starts compile mode
-     [COMPILE] xxx    Makes a immediate be treated as non-immediate
-     STATE   ( -- a)  True if compiling, false if interpreting
-     INTERPRET        Perform text interpretation of input stream
-               CHAPTER 11  TERMS  ( EXTENDING )
-     COMPILE-TIME    The action of compiling or generating a new
-              dictionary entry, for later run-time use.
-     COMPILING WORD A word that has action only during the
-              compilation stage, to generate proper run-time action.
-     DEFINING WORD  When executed defines a new dictionary entry
-               that may have compile-time and run-time parts.
-     IMMEDIATE WORD  A word that gets executed during compilation
-               and not compiled into dictionary.
-     PRECEDENCE BIT  The 16th bit, indicates wether a word should be
-              executed (immediadte) or compiled.
-     RUN-TIME        The normal action which a word will take, which
-               is what the word DOES>, it's definition.
-                   CHAPTER 11  EXTENDING
-         It is at this point that we find out how Forth  works.
-     More important it is where we find out how to change Forth to
-     meet our needs. All of this is done by extending the dictionary
-     or when compared to other languages it would be like re-writting
-     the compiler so that it has new ways of handling the input. You
-     can never NOT do something in Forth, it may not at present have
-     a way of handling your desires, but learn its insides and you
-     can make it do anything.
-         We should remember that Forth has two states or actions
-     possible. The first is interpreting, the other compiling. In the
-     interpretive mode we take data from a source and perform actions
-     much like basic reads lines of code and acts on them. The other
-     mode creates new words for the interpreter to use. It would be
-     like creating a new print command in basic (something you can't
-     do).
-         The words we use in the interpret mode have all been defined
-     and compiled in the kernal of Forth. The UTILITY.BLK and CPU8088
-     .BLK have most of the source code words for you to look over. In
-     looking these words over we will see two possible actions that
-     can take place in creating the dictionary words. These two are
-     compile-time and run-time activities.                    .
-         When compiling if we used  Forth words that act on the
-     input data immediately, we would get garbage. That is it would
-     output data as the word was being created, not when we are
-     invoking it. Therefore we need to have words that control when
-     words do their thing.
-         CREATE is the word that creates the dicitonary entry and
-     puts in link and code addresses. This word is used to define
-     words like CONSTANT and VARIABLE. These words when we use them
-     will CREATE a dictionary input using the name we pass at that
-     time. CREATE doesn't do anything at the time it is used in the
-     defined word, only when we invoke it as part of a new defined
-     word. Now if we want the new defined word that was created by
-     using a word with CREATE in it, we use DOES>. DOES> separates
-     the creation from the activity when it is invoked. This is the
-     difference between compile-time and run-time actions.
-         Compile-time actions occur when the word is being created,
-     while run-time actions occur when the word is being interpreted.
-     It is important to understand the two different states of Forth
-     activities. You compile words into the dictionary which when
-     they get invoked will perform certain activities. To compile
-     these words may require some actions which are different from
-     the actions that occur at run-time (interpretation).
-     Interpretation occurs at all times, it just that some of the
-     interpreting is used to make new dictionary entries and some is
-     used to handle screen output. You don't want the two actions to
-     become confussed.
-         F83 has defined two words which can help show the difference
-     between these two states ." and .(  The ." will store a string
-     that is printed when the word is invoke as in error messages.
-     The .( will print the string only while the word is being
-     compiled, or as I have used in the load screen to TUTOR it tells
-     you to wait while it is loading new words.
-         If we want to compute some values that later will be part of
-     the new defined word as LITERAL values we would use [ and ] .
-     The [ means interpret now, while ] means to stop interpreting
-     and resume compiling the word. If you are compiling directly
-     from the keyboard ] will continue compilation after a carriage
-     return.
-         The word IMMEDIATE means that  this word is used within a
-     compilation to do its action immediately. The opposite of this
-     is [COMPILE] which delays compiling of the word till used in an
-     other words compilation.
-         Keeping track of when and what is being compiled and
-     interpreted takes some time and practice. Use the book for most
-     of this discussion. The samples and charts of when and how the
-     dictionary is changed is too complex for this simple tutorial.
-         To really understand Forth, you must use it and play with it
-     understanding how to adapt it to your style of programming. F83
-     and Forth together should be able to solve programming problems
-     with ease once you understand it.
-        ENJOY.
-               Scr # 99         C:TUTOR.BLK
-</code>
-== Source ==
-<code>
-Screen 0 not modified
-(INTRO TEXT FOR SCREEN ZERO                           BDK112186)
-****************************************************************
-****************************************************************
-****************************************************************
-*****                                                     ******
-*****         F83 TUTOR AND HELP PROGRAM                  ******
-*****         F83 TUTOR AND HELP PROGRAM                  ******
-*****                                                     ******
-*****                                                     ******
-*****          Written   by   Bill Kibler                 ******
-*****       PO BOX  487  Cedarville, CA 96104             ******
-*****                                                     ******
-*****         ALL Commercial rights reserved              ******
-*****                                                     ******
-****************************************************************
-****************************************************************
-Screen 1 not modified
-( LOAD BLOCK AND START OF TUROR PROGRAM               BDK012387)
-        53 load     23  tree      15 spaces
-     .( PLEASE WAIT WHILE LOADING TUTOR SCREENS..TUTOR.BLK )
-   CR   CR   CR   CR   CR  ( variables and display  routines  )
-VARIABLE ETUTOR   ( END DISPLAYING  TUTOR SCREENS )
-VARIABLE STUTOR   ( BEGINING SCREEN OF CURRENT GROUP )
-VARIABLE NTUTOR   ( NEXT TUTOR SCREEN OF GROUP  )
-: L$$K    DUP 36 = IF  1 ETUTOR !   THEN  ; ( CHECK FOR $$ )
-: DISPLAY     ( DISPLAY SCREEN OF TEXT )
-        1 ?ENOUGH   DUP SCR !   L/SCR 1
-              DO          5 SPACES
-         DUP  BLOCK I C/L * + C/L
-     TUCK PAD SWAP CMOVE PAD SWAP   ( >TYPE WITHOUT THE TYPE )
-    0 ?DO   DUP C@  L$$K EMIT 1+ LOOP DROP  ( TYPE WITH L$$K )
-    CR       KEY?  ?LEAVE       LOOP DROP  ;
-      -->
-Screen 2 not modified
-  ( go get screens of information - gotutor tutor      bdk012387)
-: WTPRT    ." CURRENT SCREEN IS " SCR ? 2 SPACES ." ESC = EXIT "
-         2  SPACES ." USE SPACE BAR FOR NEXT SCREEN "  ;
-: ESCCHK DUP 27 =  IF 1 ETUTOR ! 32  THEN ;  (  SET ESC FLAG )
-: WAIT     WTPRT  13 EMIT  ( PRINT THEN CR WITHOUT LF )
-         BEGIN KEY ESCCHK  32 = UNTIL ; ( LOOP TIL SPACE KEY  )
-: GOTUTOR       ( DISPLAYS SCREEN ON STACK THEN WAITS  )
-          CR DUP SCR !  15   SPACES   .SCR CR
-          BEGIN  DISPLAY  WAIT  NTUTOR  @ 1 + DUP
-          DUP  NTUTOR ! 1  ETUTOR  @ = UNTIL CR CR  3 SPACES
-    ." REPT = REPEAT LAST LESSON ...GET = NEXT LESSON  "
-      ."  MENU = MENU  "  CR CR CR ;
-: TUTOR     ( STORE SCREEN POINTERS THEN GOTUTOR   )
-           0  ETUTOR   !
-          DUP DUP STUTOR ! NTUTOR ! GOTUTOR ;
-      -->
-Screen 3 not modified
-( INITIALIZE AND START THE LOOPS..GET..REPT..         bdk012987)
-
-: GET      ( GO GET NEXT GROUP OF SCREENS   )
-       NTUTOR  @       TUTOR    ;
-
-: REPT     (  GO BACK AND REPEAT SET OF SCREENS  )
-       STUTOR @  TUTOR   ;
-
-: START-TUTOR   (  START WITH FIRST SCREEN OF TUTOR  )
-            10 TUTOR   ;
-
-: HELP        (  GIVE INTRO MESSAGE   )
-           6 TUTOR  ;
-
-    -->
-
-Screen 4 not modified
-( DEFINING MODULES OF INFORMATION.....                bdk012387)
-: INTRO         10 TUTOR  ;
-: CHP1          12 TUTOR  ;
-: CHP2          18 TUTOR  ;
-: CHP3          25 TUTOR  ;
-: CHP4          34 TUTOR  ;
-: CHP5          40 TUTOR  ;
-: CHP6          48 TUTOR  ;
-: CHP7          55 TUTOR  ;
-: CHP8          66 TUTOR  ;
-: CHP9          73 TUTOR  ;
-: CHP10         84 TUTOR  ;
-: CHP11         92 TUTOR  ;
-
-     -->
-
-Screen 5 not modified
-( MORE ROOM FOR LESSON WORDS....                      bdk012387)
-
-   : MENU      9 DISPLAY  ;  ( will display infor screen )
-
-
-
-
-
-
-  : PRTSCR     CR ." CURRENT GET SCREEN IS " NTUTOR @  .
-      CR  ." REPT SCREEN OF INFORMATION IS " STUTOR @ . CR  ;
-
-
-
-     HELP
-
-Screen 6 not modified
-(  PRINT SCREENS FOR TUTOR INFORMATION...             bdk012887)
-
-           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
-Screen 7 not modified
-( second intro screen with list of words...           bdk012887)
-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
-Screen 8 not modified
-( THIRD  PRINT SCREEN OF TUTOR INFORMATION.....       bdk013087)
-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.
-Screen 9 not modified
-( last   intro screen with list of words...           bdk013087)
-
-                       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
-                                                           $$
-Screen 10 not modified
-(forth tutor program introduction to brodie....      bbdk011687)
-                        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.
-Screen 11 not modified
-( second intro to brodie...                           bdk011687)
-      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.       $$
-Screen 12 not modified
-( chapter 1 intro to stack operation                  bdk012887)
-                  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
-Screen 13 not modified
-( CHAPTER 1  MORE WORDS AND TERMS                     bdk011987)
-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
-Screen 14 not modified
-( chapter 1 continued fundamentals                    bdk012887)
-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
-Screen 15 not modified
-( more fundamentals of forth..chapter 1               bdk011287)
-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.
-Screen 16 not modified
-( more fundamental forth chapter 1                    bdk011987)
-      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   " ;
-
-Screen 17 not modified
-( space for more work problems....                    bdk012187)
-
-   Create a word that asks for your name.
-
-
-
-
-
-
-
-
-
-
-
-
-                   (  $$   )
-Screen 18 not modified
-  ( chapter 2 glossary of new words...                 bdk010587)
-             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
-Screen 19 not modified
-( chapter 2 more words and start of text              bdk010587)
-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)
-
-
-
-
-Screen 20 not modified
-( review of chapter 2 subjects and text               bdk011687)
-           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.
-Screen 21 not modified
-( chpt2 text continued div mul                        bdk011287)
-    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
-Screen 22 not modified
-( chptr 2 continued order and swaps...                bdk011287)
-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
-Screen 23 not modified
-( last chapter 2 with sample problem                  bdk012187)
-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...
-Screen 24 not modified
-( problem space.....                                  bdk011987)
-
-  In this screen...number 24
-
-
-
-
-
-
-
-
-
-
-
-
-              (  $$  )
-Screen 25 not modified
-( chapter 3 glossary for editor words                 bdk011987)
-             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
-Screen 26 not modified
-( more chpt 3 glossary words...editor                 bdk011187)
-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
-Screen 27 not modified
-( more glossary words..last screen of them...         bdk011987)
-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
-Screen 28 not modified
-( review of chpt 3 terms                              bdk012887)
-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
-Screen 29 not modified
-( chptr 3 text, information on editing                bdk011987)
-
-               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.
-Screen 30 not modified
-( chpt 3 continued editor / changing screens          bdk011987)
-     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
-Screen 31 not modified
-( more chpt 3 editor and editing files                bdk011287)
-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
-Screen 32 not modified
-( more chpt 3 editing stuff...                        bdk012187)
-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
-Screen 33 not modified
-( last screen of editing chpt 3...                    bdk012187)
-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........ $$
-Screen 34 not modified
-( chapter 4 glossary of decision words....           bbdk012887)
-             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
-Screen 35 not modified
-( chptr 4 more glossary and terms                     bdk011987)
-?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
-Screen 36 not modified
-( chptr 4 text on decisions....                       bdk012887)
-
-          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.
-Screen 37 not modified
-( chptr 4 more text..logic, decisions...              bdk012887)
-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.
-Screen 38 not modified
-( some chptr 4 samples/ problems                      bdk012187)
-     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.....
-Screen 39 not modified
-( some chptr 4 samples/ problems                      bdk011987)
-   ( 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 ;
-
-
-
-
-
-         (   $$   )
-Screen 40 not modified
-( chapter 5 glossary and   interger math              bdk011987)
-           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
-Screen 41 not modified
-( More chapter 5 glossary and terms                   bdk012887)
-*/   (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.
-Screen 42 not modified
-( chapter 5 terms and some text                       bdk011487)
-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.
-
-
-
-
-
-Screen 43 not modified
-( chapter 5 text INTERGER MATH math                   bdk012887)
-               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
-Screen 44 not modified
-( chapter 5 text fixed point                          bdk011987)
-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
-Screen 45 not modified
-( chapter 5 more fixed point text                     bdk012887)
-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 ; .
-Screen 46 not modified
-( chpt 5 some quickies to help out                    bdk011987)
-     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.
-
-Screen 47 not modified
-(  problem room....                                   bdk011987)
-
-What is the area of circle 12.5 feet in diameter?
-
-
-
-
-
-
-
-
-
-
-
-
-    (   $$  )
-Screen 48 not modified
-( chapter 6 glossary of loop words                    bdk012887)
-           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
-Screen 49 not modified
-( chapter 6 glos and terms..loops...                  bdk011487)
-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.
-
-
-Screen 50 not modified
-( chapter 6 text on loops.....                        bdk011487)
-             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
-Screen 51 not modified
-( chapter 6 loops and more loops...                   bdk012887)
-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
-Screen 52 not modified
-( chapter 6 last page of loops..                      bdk012887)
-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.....  $$
-Screen 53 not modified
-( tree width begin until                              bdk012887)
-
-: 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 )
-         (   $$     )
-Screen 54 not modified
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-Screen 55 not modified
-( chapter 7 glossary ..numbers                        bdk011987)
-            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
-Screen 56 not modified
-( more number glossary chpt 7                         bdk011987)
-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
-Screen 57 not modified
-( last of glossary chapter 7 numbers...               bdk011987)
-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
-Screen 58 not modified
-( chpt 7 more terms....                               bdk012887)
-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
-
-
-
-
-Screen 59 not modified
-( chapter 7 text.. numbers..                          bdk012887)
-                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
-Screen 60 not modified
-( chapter 7 numbers more text...                      bdk012887)
-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
-Screen 61 not modified
-( more chapter 7 text..numbers                        bdk012987)
-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<.
-Screen 62 not modified
-( chapter 7 number formatting...                      bdk012187)
-     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.
-Screen 63 not modified
-( chapter 7 double and mixed numbers                  bdk012887)
-     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*
-Screen 64 not modified
-( last of chapter 7, mixed..definitions..             bdk012187)
-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.
-Screen 65 not modified
-( chapter 7 problem area and expansion...             bdk012187)
-    Try some large size math problems using the new words from
-this chapter.
-
-
-
-
-
-
-
-
-
-
-
-
-        (  $$   )
-Screen 66 not modified
-( chapter 8 glossary for variables...                 bdk012187)
-             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
-Screen 67 not modified
-( chapter 8 more glossary..variables...               bdk012187)
-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 )
-
-Screen 68 not modified
-( chapter 8 terms.. variables ..                      bdk012787)
-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
-
-Screen 69 not modified
-( CHAPTER 8 TEXT .. VARIABLES                         bdk012187)
-     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.
-Screen 70 not modified
-( chapter 8 variable doubled..arrays..text            bdk012187)
-     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).
-Screen 71 not modified
-( chapter 8 arrays and bytes....                      bdk012187)
-     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.
-Screen 72 not modified
-  ( chapter 8 problems..telco array                    bdk012187)
-This array should contain numbers and when queried with an
-index produce formatted output. Lets give it a try...
-
-
-
-
-
-
-
-
-
-
-
-
-                  (  $$  )
-Screen 73 not modified
-( chapter 9..glossary and engines....                 bdk012287)
-         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
-Screen 74 not modified
-( chapter 9 glossary of engine...                     bdk012187)
-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
-Screen 75 not modified
-(  chapter 9 terms engines...                         bdk012187)
-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
-Screen 76 not modified
-( chapter 9 terms...forth engine...                   bdk012187)
-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.
-
-Screen 77 not modified
-( chapter 9 forth engines text...                     bdk012187)
-
-            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.
-Screen 78 not modified
-( chapter 9 forth engine text.....                    bdk012787)
-     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
-Screen 79 not modified
-( chapter 9 forth engine.....                         bdk012787)
-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
-Screen 80 not modified
-( chapter 9 forth engine.....                         bdk012787)
-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!
-Screen 81 not modified
-( chapter 9 engine exiting and map...                 bdk012787)
-     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.
-Screen 82 not modified
-( chapter 9 system words..the engine..                bdk012787)
-     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
-Screen 83 not modified
-( chapter 9 last screen...vocs...                     bdk012287)
-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.
-
-
-
-
-                $$
-Screen 84 not modified
-( chapter 10 glossary...I/O...                        bdk012787)
-                  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
-Screen 85 not modified
-( chapter 10 glossary I/O                             bdk012387)
-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
-
-
-
-Screen 86 not modified
-( chapter 10 terms ..I/O                              bdk012387)
-             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
-
-
-
-
-
-
-
-Screen 87 not modified
-( chapter 10 text of I/O....                          bdk012787)
-                 CHAPTER 10 I/O
-
-     Forth handles data in blocks or groups of data 1024 bytes
-long. These can be in blocks of data on the disk or blocks of
-data contained in buffers within Forths memory map. These blocks
-can have data, screens of source code, text, or grabage. F83 has
-a number of ways of handling these blocks of data.
-     When we list a screen, F83  checks to see if the block has
-been load from disk, if not it loads it into a free buffer. Then
-it returns a pointer to this block and LIST then displays it. If
-we have edited a block or changed it, it will be UPDATEd and
-marked for storage to disk. This storage is not done until the
-buffer is needed. You can force the storage two ways. FLUSH will
-empty all updated buffers and clear all pointers, while the word
-SAVE-BUFFERS writes to disk, but does not clear the pointers.
-Screen 88 not modified
-( chapter 10 I/O block and stuff....                  bdk012787)
-     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
-Screen 89 not modified
-( chapter 10 I/O moves...                             bdk012787)
-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.
-Screen 90 not modified
-( chapter 10 I/O string working...                    bdk012787)
-     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
-Screen 91 not modified
-( chapter 10 last of I/O text...                      bdk012387)
-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.
-
-
-
-
-
-
-
-               (  $$   )
-Screen 92 not modified
-( chapter 11 extending....glossary                    bdk012787)
-           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
-
-
-
-
-Screen 93 not modified
-( chapter 11 extending..terms..                       bdk012787)
-             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.
-
-Screen 94 not modified
-( chapter 11 extending the dictionary..text..         bdk012787)
-                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
-Screen 95 not modified
-  ( chapter 11 extending...                            bdk012787)
-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
-Screen 96 not modified
-( chapter 11 extending..                              bdk012787)
-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).
-Screen 97 not modified
-( chapter 11 extending..                              bdk012787)
-     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
-Screen 98 not modified
-( chapter 11 extending and last text screen           bdk012787)
-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.
-                                                      ( $$  )
-</code>