eX version 0.4b User's Manual                         File eXMan17.txt
(C) Copyright 1995, 1996 William E. Wilgus III.   All rights reserved.


eX Words

Execution Directives

Most of the directives have both un-conditional and conditional
execution forms.  The conditional form employs a test structure
immediately after the directive:

               directive{ conditional test }

In addition to the conspicuous fact that the directive executes only 
if the test is true, the test is not an aggregation and returns no
value.  Another possibly less conspicuous fact is that a program
branch may be made to the macro in which the branch appears, and
similarly, a macro may employ itself as a sub-program. 

eX will automatically load a branch or sub-programming macro if it is
not memory resident; the object in this case must be given as a file 
specification, of course.  If the directive is to be executed and eX
can't find the object macro file---or can't find an object label---eX
aborts.  eX presumes a macro specified by a number is memory resident
and executes it whether it is there or not.  Executing a null "" macro
is legal, but there's a quirk in the interpreter that causes it to
crash trying to execute a macro that does not contain at least one
character (whitespace suffices). 


abort
     Terminates execution.  In an inter-active command, or if a macro
     is executing from the inter-active mode, eX returns to the
     inter-active mode.  Otherwise, an exit is made to the operating
     system.  In either case, the `abort' message, which also outputs
     the macro name, line and column, is displayed.  This is the route
     taken when eX detects an error, but not the route taken when eX
     `crashes', I'm afraid you have to go back to DOS when that
     occurs.

call
                    call Label
                    call{ConditionalTest} Label
     The intra-macro sub-program execution directive.  Causes
     execution of a sub-program within the macro beginning at the
     point identified by the label specified by the argument Label,
     which may be given as the label's name or implied number. 
     An argument given as 0 indicates the beginning of the macro. 
     When the sub-program terminates, execution resumes at the point 
     immediately following the call.  See also `:>' (macro labels) in
     the chapter `Non-operator Characters / Character Sequences' and
     return in this section. 

chain
                         chain
                         chain{ConditionalTest}
     Activates macro chaining.  When the end of a macro is reached and
     no explicit return is executed, the next memory resident macro
     (by macro number), if any, is executed if chaining is in effect. 
     Chaining remains in effect unless the process is terminated
     through the directive EndChain (described in this section). 
     Chain takes no arguments and is otherwise inert.  The state of
     chain may be determined through the function `chaining'.

chaining
     Returns the status of the chaining process, 0 indicating 
     inactive, non-zero active.  See also chain.

delay (Not available with eX Lite.)
                          delay eev#
     Delays for eev# seconds, which may have a fractional part.  It is
     otherwise inert.  See also `sleep' in this section.

EndChain
                    EndChain
                    EndChain{ConditionalTest}
     De-activates macro chaining.  See also chain and chaining in this
     section.

EndMac
                    EndMac
                    EndMac{ConditionalTest}
     Simulates the end of a macro, complete with implied macro return.
     Note that chaining over-rides an implied macro return. 

gosub
          gosub Macro
          gosub{ConditionalTest} Macro
     The inter-macro sub-programming directive.  Causes execution of a
     macro as a sub-program.  Macro may be given as its name or macro
     number.  If given as its name, eX will automatically load it if 
     not memory resident.  The macro number may be determined by the
     function `MacId' (macro id).

     See also goto, return, call jump, LongCall and LongJump in this
     section. 

goto
          goto Macro
          goto{ConditionalTest} Macro
     The inter-macro branch directive.  Branches to the macro
     specified by Macro, which may be given as a name or macro number.
     (The macro number can be determined via the function MacId.)
     `goto' can automatically load the macro if it is not memory
     resident and Macro is given as a file specification.  

     See also jump and LongJump in this section. 

jump
                    jump Label
                    jump{ConditionalTest} Label
     The intra-macro program branch directive.  Causes a program
     branch to the point identified by the label within the macro that
     is specified through the argument Label.  Label may be given as
     its name or implied number, which if given as 0 indicates the
     beginning of the macro.  eX will abort if it can't find the
     label.  See also `:>' (macro labels) in the chapter `Non-operator 
     Characters / Character Sequences', and `LongJump' and `goto' in this
     section.  

LongCall
               LongCall macro label
               LongCall{ConditionalTest} macro label
     The inter/intra-macro sub-program execution directive.  Causes
     execution of a sub-program within the macro specified by the 
     argument macro beginning at the point within that macro
     identified by the label specified through the argument label. 
     That macro may be the macro in which the `LongCall' appears.
     When the sub-program terminates, execution resumes at the point 
     immediately following the `LongCall'.

     The macro may be specified by its name or macro number, which
     can be determined via the function `MacId'.  If given by its name,
     eX will automatically load it if it is not memory resident.  The
     argument label may be given as the label's name or implied
     number.  A label argument given as 0 indicates the beginning of
     the macro. 

     See also `:>' (macro labels) in the chapter `Non-operator 
     Characters / Character Sequences; and `return', `call', and `gosub' in
     this section. 

LongJump
               LongJump Macro Label
               LongJump{ConditionalTest} Macro Label
     The inter/intra-macro program branch directive.  Causes a branch
     to a point within the macro specified by the argument macro that
     is identified by the label given through the argument label. 
     If the object macro is not memory resident the argument macro
     must be given as the identifier so eX may load the macro. 
     Otherwise, the argument macro may be given as the object macro's
     identifier or number.  Macro may be the macro in which the
     `LongJump' appears.  The argument label may be given as the 
     label's name or implied number.  A label argument given as 0
     indicates the beginning of the macro.  If the directive is to be
     executed and the label is not found, eX will abort.  See also `:>'
     (macro labels) in the chapter `Non-operator Characters /
     Character Sequences; and `jump' and `goto' in this section.

return
         return
         return{ConditionalTest}
         return{Conditional Test}(Macro$)
     Sub-program termination directive. Terminates execution of the
     current macro.  If that execution of the macro in which the 
     return appears is either directly or indirectly the result of eX
     performing a sub-programming directive in a previously executing
     macro, execution of the macro in which that sub-programming
     directive appeared is resumed at the position in that macro which
     is immediately after that directive.  Otherwise, all execution
     terminates.  

     Note that the end of a macro implies a return, allowing a macro 
     that does not contain an explicit return to be used as either 
     a sub-program or program branch object.  However, chaining will
     over-ride an implied return, but not an explicit one. 

     The optional macro$ argument within the optional parenthesized 
     argument is a return to a specific macro that has a `gosub' (`call', 
     or `LongCall') return pending, and macro must be an identifier.  
     The feat is accomplished through discarding returns until the match is 
     found.  If the macro is not found, execution terminates. 


sleep
                    sleep<<(Seconds#)>>
     Delays for Seconds# seconds (which may include a fractional part)
     or until any keyboard key is typed.  If the argument is omitted or
     Seconds# evaluates to 0, it waits until a keyboard key is typed.  
     Sleep is otherwise inert.  See also `delay' in this section. 



Terminal

beep
     Sounds the terminal bell (or buzzer). 



Keyboard & Input

edit
          edit StringEntityReference$
          edit(StringEntityReference$, Characters#)
          edit NumericDataEntity$
          edit(NumericEntityReference$, Digits#<<, Decimals#>>)
     The data entity edit routine.  There are fundamental differences
     between the `edit' and `enter' routines and the keyboard input
     routine `?'. 

     1. The keyboard input routine ? cannot edit a data entity, uses
        only as many video columns (and rows) as required by the data
        entered and returns the value entered but is not an implied
        assignment.  
     2. The edit and enter routines can edit a data entity, use 
        the number of video rows/columns expressed or implied by their
        invocation, return the last keystroke typed while in the
        routine as a number, and are an implied assignment.  (The
        returned keystroke might be useful in program branching.) 
     The difference between `edit' and `enter' is that `edit' does not null
     the data if the first keystroke is a data keystroke, `enter' does. 
     The original data value may, of course, be recalled at any time
     prior to exiting either routine via a restart field (^ HOME) or
     exiting the routine via ESC.  
      
     For numeric data, the first position of the field is always at
     the current location of the cursor.  In the parenthesized form,
     if the Decimals# argument is omitted, decimals is taken to be
     0.  In the un-parenthesized form, Digits# is taken to be 15 and
     Decimals# is taken to be 16, which are the current maximums.
     The routine also uses one column for the sign and if Decimals# is
     not 0, one for the decimal point.  On entry to the routine, if a
     digit field has been provided, the cursor is positioned to its
     least significant digit and the Data Entry Mode is Insert.
     Otherwise, the cursor is positioned to the most significant
     decimal and the Data Entry Mode is Type-Over. 
 
     For string data, if Characters# is given as 0 or the the
     un-parenthesized form is used, Characters# is taken to be 1920,
     the display is cleared and the first position of the field is row
     1, column 1.  Otherwise, the first position of the field is the
     current cursor position.  `Edit' and `enter' currently do not
     determine if displaying the field will scroll the display and are
     themselves incapable of scrolling.  Otherwise, the length of the
     field must be the lesser of 32,767 and the free string storage
     space divided by two (2), which can be determined by the
     expression

                   min 32767, (freemem$ / 2)

     Use of the Insert Mode may require that the length of the field
     be less than or equal to freemem$ / 3.  These latter restrictions
     are limitations are due to implememtation and will hopefully be
     eliminated. 


     Numeric Features
 

          Cursor Column Right                         Right Cursor Key
              
               Moves the cursor one digit to the right, as long as the
               cursor is not column right of the entered data.  If the
               cursor passes the decimal point or becomes column right
               of the entered data, the Data Entry Mode is forced to
               Type-Over. 

          Cursor Column Left                           Left Cursor Key
                   
               Moves the cursor one digit to the left, as long as the 
               cursor is not column left of the entered data.  If the 
               beginning of the entered data is passed, the Data Entry
               Mode is forced to Insert.  If the decimal point is
               passed the Data Entry Mode is forced to Insert.  (The  
               cursor is prohibited from moving to the left of the
               decimal point if no digit positions were provided--
               Digits% = 0.)

          Cursor to Least Significant               ^ Right Cursor Key

               If the cursor is in the digits field, the cursor is
               moved to the least significant digit (just to the left
               of the decimal point) and the Data Entry Mode is forced
               to the Insert Mode.  
 
               If the cursor is in the decimal field, the cursor is
               moved to the decimal place to the right of the last
               decimal digit that has been entered (farthest from to
               the decimal point) and the Data Entry Mode is forced to
               Type-Over. 

          Cursor to Most Significant                 ^ Left Cursor Key
                   
               If the cursor is in the digits field and the digit
               field is full, moves the cursor to the most significant
               digit (farthest digit from the decimal point) and the
               Data Entry Mode is un-altered.  If the digit field is
               not full, the cursor is moved to the beginning of the
               entered data and the Data Entry Mode is forced to
               Insert.  
 
               If the cursor is in the decimal field, the cursor
               is moved to the most significant decimal place (closest
               to the decimal point) and the Data Entry Mode is not
               altered. 

          Cursor to End of Data                                    End

               Moves the cursor to the least significant digit and the
               Data Entry Mode is forced to Type-Over.

          Cursor to Beginning of Field                            Home

               If the field includes digit positions, moves the cursor
               to the units digit and the Data Entry Mode is forced to
               Insert.  Otherwise, the command is ignored.

          Entry Mode                                            Insert

               Toggles the data entry mode between the Insert and
               Type-Over Modes.  The Insert Mode is indicated by
               `Insert' being displayed on column one (1) of the
               next-to-last video line.  (Some numeric routine
               commands other than the Entry Mode toggle can force a
               change in the mode.) 
 
               The Type-Over Mode is the default mode for the
               decimal portion of the field and the action is that of
               normal typing.  The action of the Insert Mode is
               dependant upon which portion of the field the cursor is
               in.  

               In the decimal section of the field, digits from the
               cursor to the end of the field are moved right one
               column and the digit is placed at the cursor, which is
               then moved one column to the right.  Any digits that
               `spill' out of the field are lost. 

               The Insert Mode is the default for the digit section of
               the field, and the action is to move the digits from
               the cursor to the beginning of the entered data left
               one column and place the typed digit at the cursor.  
               The cursor is not moved.  Any digits that `spill' out
               of the field are lost.  The Insert Mode is forced
               active if the cursor comes to the left of the first
               digit in the field.  

          Delete Character                                      Delete
                   
               Deletes the digit at the cursor.  If the cursor is in
               the digits portion of the field, the digits to the left
               of the cursor are moved 1 column to the right.  If the
               character is in the decimal portion of the field, the
               decimal digits to the right of the cursor are moved 1 
               column to the left.  

          Backspace                                          Backspace

               If the cursor is in the digits section of the field and
               a digit left of the cursor exists, the digit to the 
               left of the cursor is deleted and any digits remaining
               at the left of the cursor are moved one column to the
               right.  If no digits exist to the left of the cursor,
               the bell is sounded and no action is taken. 
 
               If the cursor is in the decimal section of the field
               and a decimal digit exists to the left of the cursor,
               the decimal digit to the left of the cursor is deleted,
               and the cursor and any decimal digits from the cursor
               to the end of the entered data are moved one column
               left.  If the cursor is immediately to the right of the
               decimal point, the bell is sounded and no action takes
               place.  

          Delete to End of the Field                             ^ End

               If the cursor is in the digit section of the field and 
               digits have been entered, the digits from the cursor to
               the decimal point are deleted, and the cursor and any
               digits to the left of the cursor are moved right one
               (1) column for each digit that was deleted.  If no
               digits are in the digit field, the command is ignored. 

               If the cursor is in the decimal section of the field,
               the decimal digits from the cursor to the end of the
               field are deleted (and replaced with zeroes), and the
               Data Entry Mode is forced to Type-Over.

          Cursor to Decimal Field / Digits Field            . (period)

               Causes the cursor to move to the opposite side of the 
               decimal point.  If the cursor is in the digits section
               of the field when the command is given, the cursor is
               re-aligned to the first decimal and the Data Entry Mode
               is forced to the Type-Over Mode.  If the cursor is in
               the decimal section of the field when the command is
               given, the cursor is re-aligned to the least 
               significant digit position and the Data Entry Mode is 
               forced to the Insert Mode.

          Sign of the Number                                     + / -

               The sign of the field is changed to positive by typing
               the + key and to negative by typing the - key. 

          Zero the Field                                           ^ Z

              ^ Z or ^z sets the value of the field to 0.0, displays
              that value, and moves the cursor to the field's initial
              position and resets the Data Entry Mode.

          Calculator Functions                                     ^ T
                    
               Ten (10) calculator functions are available and the
               display of the Function Keys can be toggled on and off
               with ^ T or ^ t.  The display is placed on the bottom  
               line of the screen.  The functions are available
               whether the display is active or not. 
 
               The first 7 `functions' are, of course, really 
               operators; only the last 3 are functions. For 
               operators, the first operand is the field value and the
               second operand is the value entered in response to the 
               prompt.  The keyboard input routine ? is used to obtain
               the operand or function argument from the user.  The
               appropriate operation is performed, and the result is 
               displayed in the field.  All of the operators accept
               any of the functions (root, logN, or exp) as the
               second operand.  If one of these functions is selected
               by itself, the current value of the field is used as
               the argument, and the field becomes the function value.


               Addition                              + Function Key 1
                              
                    The subsequently entered value is added to the    
                    field.  

               Subtraction                           - Function Key 2

                    The subsequently entered value is subtracted from 
                    the field.  

               Multiplication                        * Function Key 3

                    The field is multiplied by the subsequently 
                    entered value.  

               Division                              / Function Key 4

                    The field is divided by the subsequently entered 
                    value.  

               Integer Result Division               \ Function Key 5

                    The field is divided by the subsequently entered 
                    value and any fractional part of the quotient is 
                    discarded. 

               Modulo                              Mod Function Key 6

                    The field is divided by the subsequently entered 
                    value and only the remainder, if any, is retained.

               Raising to a Power                    ^ Function Key 7

                    The field is raised to the power of the 
                    subsequently entered value.  

               Order n Root                       Root Function Key 8

                    If an operation is pending, i.e. this function is 
                    being used as the second operand of an operator, 
                    the user is prompted for both the number whose 
                    root is to be taken and the order of that root; 
                    then the root is supplied as the second operand
                    for the pending operation. 
 
                    If no operation is pending, the field becomes the 
                    number whose root is to be taken and the user is 
                    prompted for the order of the root; then the
                    result root becomes the value of the field.

                    As this is an iterative function, the result will
                    may take a few moments.

               Natural Log                        Logn Function Key 9

                    If an operation is pending, i.e. this function is 
                    being used as the second operand for an operator, 
                    the user is prompted for the number whose log is 
                    to be supplied; the natural log is then supplied 
                    as the second operand for the pending operation.  
 
                    If no operation is pending, the field becomes the 
                    number whose log is to be returned and the value 
                    returned becomes the value of the field.
 
                    The number whose log is to be returned must be 
                    greater than 0.

               Exponential Function                Exp Function Key 10

                    If an operation is pending, i.e. this function is 
                    being used as the second operand for an operator, 
                    the user is prompted for the number whose 
                    exponential function is to be supplied; the value 
                    is then supplied as the second operand for the 
                    pending operation.  
 
                    If no operation is pending, the field becomes the 
                    number whose exponential function is to be 
                    returned and that value becomes the value of the 
                    field. 
 
                    The number whose exponential function is to be 
                    returned must be <= 88.02969. 
 

          Restart Field                                         ^ HOME
                   
               Resets the value of the field to the orignal value of
               the field.  The new value of the field is displayed and
               the cursor is moved to the field's initial cursor
               position and the Data Entry Mode is forced to the
               default mode.  It does not re-activate the `first
               keystroke' feature of the enter routine.  

          Enter                                         Enter / Return

               Accepts the data and exits the function.  The value 13
               is returned by the routine.

          Abort                                                    ESC

               Discards any changes made to the field, i.e. restores
               the value of the field to the value that is was when
               the routine was entered, updates the display, and exits
               the  routine.  The value 27 is returned by the routine.


 
     String Features

          The following character substitutions are made when
          displaying the data.  

          Code | Character       || Substitution | Approx. symbol
          --------------------------------------------------------
            13 | Carriage return ||           17 | Left Arrowhead
            10 | Line feed       ||           25 | Down Arrow
            9  | Horizontal tab  ||           16 | Right Arrowhead


          Cursor Column Right                         Right Cursor Key

               Moves the cursor one column to the right, as long as
               the cursor is not at the end of the entered data. 
               (The cursor is at the end of the entered data when it
               is to the right of the last data in the field.)  If the
               cursor comes to the end of the entered data, the Data
               Entry mode is forced to Type-Over. 

          Cursor Column Left                           Left Cursor Key
                   
               Moves the cursor one character to the left, as long as
               the cursor is not at the beginning of the field.  The
               Data Entry Mode is un-altered.

          Cursor Word Right                         ^ Right Cursor Key
                   
               Moves the cursor one word to the right.  (A word is
               delimited by a space (ASCII Code 32), the end of the
               entered data, or the beginning of the data field.)  If
               the end of the entered data is reached, the Data Entry 
               Mode is forced to Type-Over.

          Cursor Word Left                           ^ Left Cursor Key
                   
               Moves the cursor one word to the left if the cursor is
               at the beginning of a word, or, if it is not at the
               beginning of a word, to the beginning of the word that
               it is in.

          Subsequent Line                              Down Cursor Key
                   
               If a subsequent field video line exists and data exists
               on that line, moves the cursor to column 1 on the
               subsequent line.  Otherwise, the cursor is moved to the
               end of the entered data.  If the cursor comes to the
               end of the entered data, the Data Entry Mode is forced
               to Type-Over. 

          Preceding Line                                 Up Cursor Key
                   
               If a preceding field video line exists, moves the
               cursor to the field's left-hand column on the preceding
               line.  Otherwise, the cursor is moved to the beginning
               of the field.  The Data Entry Mode is un-altered.

          Cursor to End of Data                                    END

               Moves the cursor to the end of the data and forces the
               Data Entry Mode to Type-Over.

          Cursor to Beginning of Field                            HOME

               Moves the cursor to the beginning of the field.  The 
               Data Entry Mode is un-altered.  

          Tab                                                      TAB

               Moves the cursor right to the next Tab position, which
               are every 5 columns.  If the Insert Mode is active, 
               spaces (ASCII 32) are inserted until the next Tab 
               position is reached.

          Entry Mode                                            Insert

               The Insert key toggles the data entry mode between the 
               Insert and Type-Over Modes.  The Insert Mode is 
               indicated by `Insert' displayed on column 1 of the
               next-to-last video line.

               The Type-Over Mode's action is to place the character
               typed at the cursor and then move the cursor one column
               to the right and is the default mode.  The Insert 
               Mode's action is to move the character(s) from the 
               cursor to the end of the entered data one column to the
               right, place the character typed at the cursor, and 
               then move the cursor one column to the right.  (In 
               order to minimize delays in the display of the 
               character typed, the routines may wait until no
               keystrokes are in the keyboard buffer to display the 
               characters that have been moved in their new position.)
               The Data Entry Mode reverts to type-over only if the 
               cursor reaches the end of the entered data or the user 
               types the Insert key.

          Delete Character                                Del / Delete

               Deletes the character at the cursor.  The data to the
               right of the deleted character is moved 1 column to the
               left. 

          Backspace                                          Backspace

               Deletes the character to the left of the cursor and 
               then moves the cursor and all the characters from the
               cursor to the end of the entered data left one column. 
               If the cursor is at column 1, the action is prevented 
               and the bell sounds. 

          Delete to End of Word                                    ^ D
                
               ^ D or ^d deletes the characters from the cursor to the
               end of the word (as defined by a `space').

          Delete to End of the Field                             ^ End

               Deletes the characters from the cursor to the end of 
               the entered data (i.e., the end of the field), and 
               forces the Data Entry Mode to Type-Over.

          Upper Case                                               ^ U
                   
               ^ U or ^ u converts the field to UPPER CASE alphabetic.
 
          Lower Case                                               ^ L
                   
               ^ L or ^ l converts the field to lower case alphabetic.


          Proper Case                                              ^ P

               ^ P or ^ p converts the field to Proper Case
               alphabetic.  

          Restart Field                                         ^ Home

               Re-sets the value of the field to its original value. 
               The new value of the field is displayed and the cursor 
               is moved to the field's initial cursor position and the
               Data Entry Mode is forced to the default mode.  It does
               not re-activate the 'first keystroke' feature of the 
               enter routine.

          Enter                                         Enter / Return

               Accepts the data as it exists and exits the function. 
               The value 13 is returned by the function.

          Abort                                                   Esc

               Discards any changes made to the field, i.e. restores
               the value of the field to the value that is was when 
               the routine was entered, updates the display, and exits
               the routine.  The value 27 is returned by the function.
 

enter
          enter(StringEntityReference$, Characters#)
          enter StringEntityReference$
          enter(NumericEntityReference$, Digits#<<, Decimals#>>)
          enter NuericEntityReference$
     The data entity entry routine.  This routine differs from `edit' 
     only in that if the first keystroke typed upon entry to the 
     routine is a data keystroke, the carry value will be nulled ("")
     zeroed (0.0) prior to placing the keystroke in the field.  See 
     `edit' in this section for further details, and `?' in the chapter 
     `Characters / Character Sequences'.

KeyChk
     Determines the availability of a keystroke in the keyboard 
     buffer.  If none is available, the value -1 is returned. 
     Otherwise, the value of the first keystroke in the keyboard 
     buffer is returned---but not removed from the buffer---as a 
     positive integer in the range 0--255. 

     Values in the range 0--126 represent the ASCII codes 0--126. 
     Values in the range 127--255 are 

     Code  Key           Code  Key           Code  Key
     ----------------------------------------------------------
      131  Ctrl 2 or @    178  Alt M          223  Ctrl FKey 2
      132  Alt 9 or (     187  FKey 1         224  Ctrl FKey 3
      133  Alt 0 or )     188  FKey 2         225  Ctrl FKey 4
      134  Alt -          189  FKey 3         226  Ctrl FKey 5
      135  Alt =          190  FKey 4         227  Ctrl FKey 6
      136  Ctrl Pg Up     191  FKey 5         228  Ctrl FKey 7
      143  Shift Tab      192  FKey 6         229  Ctrl FKey 8
      144  Alt Q          193  FKey 7         230  Ctrl FKey 9
      145  Alt W          194  FKey 8         231  Ctrl FKey 10
      146  Alt E          195  FKey 9         232  Alt FKey 1
      147  Alt R          196  FKey 10        233  Alt FKey 2
      148  Alt T          199  Home           234  Alt FKey 3
      149  Alt Y          200  Up arrow       235  Alt FKey 4
      150  Alt U          201  Page Up        236  Alt FKey 5
      151  Alt I          203  Left arrow     237  Alt FKey 6
      152  Alt O          205  Right arrow    238  Alt FKey 7
      153  Alt P          207  End            239  Alt FKey 8
      158  Alt A          208  Down arrow     240  Alt FKey 9
      159  Alt S          209  Page Down      241  Alt Fkey 10
      160  Alt D          210  Insert         243  Ctrl Left arrow
      161  Alf F          211  Delete         244  Ctrl Right arrow
      162  Alt G          212  Shift FKey 1   245  Ctrl End
      163  Alt H          213  Shift FKey 2   246  Ctrl Page Down
      164  Alt J          214  Shift FKey 3   247  Ctrl Home
      165  Alt K          215  Shift FKey 4   248  Alt 1 or !
      166  Alt L          216  Shift FKey 5   249  Alt 2 or @
      172  Alt Z          217  Shift FKey 6   250  Alt 3 or #
      173  Alt X          218  Shift FKey 7   251  Alt 4 or $
      174  Alt C          219  Shift FKey 8   252  Alt 5 or %
      175  Alt V          220  Shift FKey 9   253  Alt 6 or ~
      176  Alt B          221  Shift FKey 10  254  Alt 7 or &
      177  Alt N          222  Ctrl FKey 1    255  Alt 8 or *

     See also `KeyClr' and `KeyIn' in this section. 

KeyClr
                    keyclr<<(keystrokes#)>>
     Clears the keyboard buffer.  If the argument is given, clears 
     only the first keystrokes# from the keyboard.  See also `KeyChk' 
     and `KeyIn' in this section.

KeyFlags
     Returns the status of the keyboard toggle and shift keys.  If the
     bit corresponding to the key in the returned value is set, the
     key is either on or down, as appropriate.

          Key               Bit   Bit Set Means   Test
          --------------------------------------------------------
          Alt                3    Depressed       KeyFlags and 8
          Caps Lock          6    Active          KeyFlags and 64
          Ctrl               2    Depressed       KeyFlags and 4
          Insert             7    Active          KeyFlags and 128
          Left Shift Key     1    Depressed       KeyFlags and 2
          Num Lock           5    Active          KeyFlags and 32
          Scroll Lock        4    Active          KeyFlags and 16
          Right Shift Key    0    Depressed       KeyFlags and 1

KeyIn
                         keyin<<$>>
     Gets and removes the next key that has been typed from the
     keyboard buffer, or if none has been typed, waits for one to be
     typed.  The value returned is a positive integer in the range
     0--255, or, if the optional string suffix `$' is used, a one byte
     string whose character is in the range 0--255.  Values in the
     range 0--126 represent the ASCII codes 0--126.  Values in the
     range 127--255 may be interpreted with  the table given with 
     `KeyChk' above. 



Printer

I thought you might be ready for a small section, so this is
it!

pcol
     Returns the current column of the printer's print head.  Tabs are
     not expanded, so this may be inaccurate.




Video Display

at
                    at<<(line#, column#)>>
     Positions the video cursor.  If either line# or column# is given
     as 0, or the argument is omitted, uses the last specified line# 
     and/or column#; and if no line#, column# has ever been specified,
     uses the default 1.  The upper left-hand corner of the display is
     line 1, column 1. 
     See also `cls', `vCol' and `vLine' in this section.

BColor
                         bColor#
                         bColor color#
     Background color.  The function form `bColor#' returns the 
     currently active background color (and takes no argument).  The 
     statement form `bColor color#' sets the active background color to
     color# from a palette of 8 colors 0--7) given in the table given 
     under the entry for `fColor'.  The statement form is otherwise     
     inert.  See also `FColor' and `vAttr' in this section. 

bPage
                         bPage#
                         bPage PageNumber#
     Browse mode video page.  The function form `bPage#' returns the
     video page specified for use by the browse mode (and takes no
     argument).  The statement form `bPage PageNumber#' specifies the
     video page to be used by the browse mode (the default is 0).  See
     also `vPage' in this section.

cls
                    cls<<(VideoPositions#)>>
     Clears video screen.  If the argument is omitted, the active text
     display is cleared and the cursor is moved to the upper left-hand
     corner of the cleared area.  It does not clear the video monitor 
     area if it is active.  If the argument is given, VideoPositions#
     video positions are cleared beginning at the current cursor 
     position, which is preserved.  The un-parenthesized form is not
     allowed.  See also `ClsEol' and `scroll' in this section.

ClsEol
     Clears the video line from the cursor position (which is 
     preserved) to its end.  See also `cls' and `scroll' in this section. 

fColor
                          fColor#
                          fColor Color#
     The function form `fColor#' returns the currently active foreground
     color and takes no arguments.  The statement form `fColor Color#' 
     sets the active foreground color to Color# from a palette of 16 
     (colors 0--15) given in the table below (the monchrome table is 
     given immediately after).  The statement form is otherwise inert.
     See also `bColor' and `vAttr' in this section.  Additionally, you
     may change foreground colors via the eX words listed in the table
     below.

          Color Palette
          Bits          Number   Color                    eX Word

           0  0  0  0        0   Black                    Black
           0  0  0  1        1   Blue                     Blue
           0  0  1  0        2   Green                    Green
           0  0  1  1        3   Cyan                     Cyan
           0  1  0  0        4   Red                      Red
           0  1  0  1        5   Magenta                  Magenta
           0  1  1  0        6   Brown (or dark yellow)   Yellow
           0  1  1  1        7   Light grey (or white)    White
           1  0  0  0        8   Dark grey (or black)     Grey
           1  0  0  1        9   Light blue               LBlue
           1  0  1  0       10   Light green              LGreen
           1  0  1  1       11   Light cyan               LCyan
           1  1  0  0       12   Light red                LRed
           1  1  0  1       13   Light magenta            LMagenta
           1  1  1  0       14   Yellow (or lite yellow)  LYellow
           1  1  1  1       15   Bright white             LWhite
 
     The blinking form of these colors may be invoked by using their eX
     word with a `b' suffix, i.e.

                           WhiteB

     is blinking white.

          Monochrome Adapter
          Background  Foreground  Color
                  0           0    No display
                  0           1    Underline
                  0           7    Normal video
                  0           9    Hi-intensity underline
                  0          15    Hi-intensity video
                  7           0    Reverse video

     The following eX words may be used to set the background color and are
     NOT available with eX Lite:

                         OnBlack
                         OnBlue
                         OnGreen
                         OnCyan
                         OnRed
                         OnMagenta
                         OnYellow    (yields brown)
                         OnWhite



FKMenu
                       FKMenu MenuLegend$
     Displays a `function key menu' beginning at the current video cursor 
     position.  The function keys are numbered 1--0 and displayed in normal 
     video; and their six character legends are displayed in reverse video.
     Function keys that are not given a legend or whose legend is given as
     blank are not displayed.  The `MenuLegend$' is simply a string containing
     the six character long menu legends which are seperated by two spaces.

               FKMenu "One     Two      Three           Five  "

     will produce

               `1One    2Two    3Three           5Five  '

     Note that all FKMenu does is produce the video display; it does not 
     affect the function keys in any way.


RVid

     Reverse Video.  Reverses the foreground and background video colors; 
     i.e., if the foreground color is White and the background color is 
     Black, after
                         RVid
     the foreground color will be Black and the background color whill be 
     White.  NOTE the `RVid' forces the background color displayed to be
     within the legal range 0--7, but preserves the value of the new `BColor'
     sot that a subsequent `RVid' will correctly restore the colors.

scroll

     scroll NumberOfLines#
     scroll(UpperLin#, LeftCol#, LowerLin#, RightCol#, NumberOfLines#)

     Either scrolls the defined video display rectangle up, down, or
     clears it.  The video cursor does not move. 

     The first four arguments of the parenthesized argument define the
     rectangle as indicated by their names.  NumberOfLines# is the 
     scroll displacement which, if given as a positive number scrolls
     the video up, and down if given as a negative.  If NumberOfLines#
     is given as 0, the defined rectangle is cleared.  Video that 
     scrolls out of the rectangle or is cleared is lost. 
 
     In the un-parenthesized form, the video rectangle scrolled is 
     that which was defined in the last use of the word, or if no
     rectangle was defined in any previous use of scroll, the entire
     screen.  See also cls, ClsEol in this section. 

                         Warning
     Scroll is a BIOS call and depending on your system, you may
     experience difficulties with it.  (Some scroll operations turn
     off the the cursor on my new 'puter.)  Therefore, some     
     experimentation seems prudent. 

vAttr
                    vAttr<<(line#, column#)>>
     Returns the 16 bit video attribute of the character position at 
     line#, column# of the active video page.  If the argument is
     omitted the attribute at the current cursor position is returned.
     The colors may be determined as follows: 

          _ForeColor := (vAttr & 15)         ** low order byte **
          _BackColor := ((vAttr & 240) \ 16) ** high order byte **

     See also `bColor' and `fColor' in this section.

vChar
                    vChar<<(line#, column#)>>
     Returns the character displayed at line#, column# of the 
     active video page.  If the argument is omitted the character
     displayed at the current cursor position is returned.  See also
     `vAttr' in this section.

vCol
                         vCol#
                         vCol ColumnNumber#
     Video column.  The function form `vCol#' returns the video column
     of the cursor and takes no argument.  The statement form 
     `vCol ColumnNumber#' moves the cursor to video ColumnNumber#, but
     the cursor's line remains un-changed.  The statement form is
     otherwise inert.  The left-hand video column is 1 and the right 
     hand column is 80.  See also `at' and `vLine' in this section.

vLine
                         vLine#
                         vLine LineNumber#
     Video line.  The function form `vLine#' returns the video line of
     the cursor and takes no argument.  The statement form 
     `vLine LineNumber#' moves the cursor to video LineNumber#, but the
     cursor's column remains un-changed.  The statement form is
     otherwise inert.  The top video line is 1 and the bottom line is
     25, or if monitor is active, 19.  See also `at' and `vCol' in this
     section. 

vPage
                         vPage#
                         vPage PageNumber#
     Video page.  The function form `vPage#' returns the active, or
     current, video page and takes no argument.  The statement form
     `vPage PageNumber#' changes the active video page to PageNumber#. 
     The first video page (default) is 0 and the number of pages
     available is system dependant.  Generally, monochrome systems
     have a single page (0) and color systems 12 pages (0--11).  The
     statement form is otherwise inert.




Output


EndPrint
     Terminates output to the system printer from the plane and 
     level in which it appears.  In other words, it is local to its
     plane and level.  It is intended for use in the argument list of
     a dual output construction, as illustrated by

                    show print _x, _y, EndPrint _z

     See also `EndShow', `show', `show print', `print' and `print show' 
     in this section. 

EndShow
     Terminates output to the video display from the plane and  
     level in which it appears.  In other words, it is local to its
     plane and level.  It is intended for use in the argument list of
     a dual output construction, as illustrated by  

                    show print _x, _y, EndShow _z 

     See also `EndPrint', `show', `show print', `print and `print show'
     in this section. 

form
     Form can serve three purposes. 
     
                         form specification$
     First, to control the format of numeric output to the video
     display, printer and sequential output files; and the statement
     is otherwise inert.  This form is global and the output format
     remains in effect until superceeded by a subsequent form 
     statement.  The format specification characters are given in  
     the table below.  More than 24 digits in the format will produce
     an error.  Numeric formatting may be dis-abled by specifying the
     null string ("") as the format.  The parenthesized argument form
     may not be used.  See also the section on `show' and `print'. 
 
                         form$
     Second, to return the current numeric output format definition
     string.  This function form does not take an argument. 
      
                         form eev#
                         form (eev# + eev$)
     Third, to return a string containing a numeric value that has
     been formatted in accordance with the current format string
     (numeric to formatted ASCII representation data type cast).  If 
     form is given both a string value and a numeric value, the  
     format is first set to that of the string, then a string
     containing the numeric value, formatted according to the new 
     format string, is returned.  A numeric suffix # is ignored and 
     the parenthesized argument form may not be used. 

                    form ("#,###.#" + 5000)
     returns "5,000.0"
 

                Positons                          &  & Positions
     Character  Provided   Meaning                         Provided

            #          1   represents a digit position
            .          0   decimal point
            +          0   sign of number, if at start of form, leads;
                           end, trails; if at end of form, negatives
                           printed with trailing
           **          1   fills leading spaces with *'s
            0          1   fills leading spaces with 0's
                           (not supported by show/print
           $$          1   fills leading spaces with $'s
          **$          1   fills leading spaces with *'s, then 1 $
                           (dollar sign)
            ,          0   (comma) if left of the decimal, printed
                           every 3 left of decimal (only 1 necessary).
                           if right of decimal, at the end of the
                           number
         ^^^^              exponential format (single precision
                           range).  The general form is ^^^^#.  It is
                           not supported by form eev#.
        ^^^^^              exponential format (double precision
                           range).  The general form is ^^^^^#.  It is
                           not supported by form eev#.
            _          1   (underscore) next character in form is a
                           literal.  It is not supported by 
                           form eev#.
            %          0   causes % to preceed if number larger 
                           than form specified.


nf
     Number First directive.  Mandates for both `show' and `print' that
     the numeric data class shall be output first when they 
     simultaneously recieve both data classes.  It is persistent and
     local to its plane and level. 

pnf
     Print Number First directive.  Mandates that the numeric data
     class is be output first when `print' simultaneously recieves both
     data classes.  It is persistent and local to its plane and
     level.

print
               print<<$>><<;>> eev<<; eev ... >>
               print<<#>><<;>> eev<<, eev ... >>
               print<<#>><<;>> eev;literal_characters eev

     Outputs the values produced by the argument list to the system
     printer.  If provided with a numeric value, outputs the numeric;
     and its formatting may be controlled with a `form' statement.  If
     provided with a string, outputs the string.  If provided
     simultaneously with both data classes outputs both; but the
     optional data class suffixes ($ and #) limit output to the data
     class of the suffix, but do not cause the other data class to 
     not exist.  The order of data class output may be specified
     through the directives `pnf', `psf', `nf' and `sf'. 

     The optional semi-colon suffix (;) supresses the
     output of a carriage return after the last element in the
     argument list.  Similarly, if a semi-colon is used as an argument
     list element seperator, no carriage return is output following
     the output of that argument list element, and a semi-colon /
     whitespace seperator may be used to delimit a literal that is
     output.  (See also the `p#' command in the chapter `eX commands'.) 

     Conversely, if a comma is used as an argument list element
     seperator, a carriage return is output following the output of
     that argument list element.  

     Operators and multiple operators, to which output is transparent,
     may appear anywhere in the argument list.  (Operated Addresses
     just plain don't work in a list.) 
     
     See also `form', `show', `show print', `print', `print show', `pnf',
     `psf', `nf' and `sf'. 

print show

     Not actually an eX word but a `construction', it outputs the
     values represented in the argument list to both the system
     printer and the video display.  In actuality, either eX word 
     may appear anywhere in the argument list of the other, so dual 
     output may commence anywhere in the argument list.  Dual output
     may be terminated via either of the directives `EndPrint' and
     `EndShow', and these eX words may also appear anywhere in the
     argument list. 

     Data class suffixes ($, #) that are used with either eX word is
     applicable to that eX word only, as are any semi-colon (;) 
     suffixes.  However, semi-colons and commas in the argument list
     are applicable to both `print' and `show'.  See also `print', 
     `EndPrint', `show' and `EndShow'.  

     A couple pro-formas:
          print<<#>><<;>> show<<$>><<;>> eev<<, eev ... >>
          print<<$>><<;>> eev, show<<#>><<;>> eev, endprint eev
          show eev; print eev, eev, endshow

PrintScrn
     Prints the video display on LPT1.  See also `ScrnPrint' in this
     section. 

psf
     Print String First directive.  Mandates that the string data
     class is be output first when print simultaneously recieves both
     data classes.  It is persistent and local to its plane and 
     level. 

ScrnPrint
     Returns the status of the screen print facility.  A value of -1
     indicates it is available and/or its last use was successful. 
     Any other value indicates either the last screen print has not
     yet been completed or the facility is un-available for an un 
     specified reason that should be considered an error or abnormal
     condition.  See also `PrintScrn' in this section. 

sf
     String First directive.  Mandates for both `show' and `print' that
     the string data class shall be output first when they
     simultaneously recieve both data classes.  It is persistent and
     local to its plane and level. 

show
               show<<$>><<;>> eev<<, eev<<; ... >> >>
               show<<#>><<;>> eev<<; eev<<, ... >> >>
     Outputs the values produced by the argument list to the video
     display.  Except for the destination, `show' is identical to
     print and you are directed to that directive's discussion for
     further details.  See also `show', `show print', `print', 
     `print show', `sf', `nf', `ssf', and `snf'. 

show print
     See the identical `print show' in this section.  

snf
     Show Number First directive.  Mandates that the numeric data
     class is be output first when show simultaneously recieves both
     data classes.  It is persistent and local to its plane and 
     level. 

ssf
     Show String First directive.  Mandates that the string data class
     is be output first when show simultaneously recieves both data
     classes. It is persistent and local to its plane and level. 



Operating System Controls, Directives & Status


append
               append(SourceFile$, DestinationFile$)
     Appends SourceFile$ to DestinationFile$ and returns a number
     indicating the result, which may be interpreted with  

              Result   Meaning
                 768    Bad path
                 512    File not found
                 255    No directory space
                  -2    File not found
                  -3    Bad path or file not found
                  -5    Access denied

     It's an eX routine and doesn't check for the catastrophy of 
     SourceFile$ being the same as DestinationFile$.  

break
                    break <<:= eev#>>

     Returns the status of the operating system's Control Break 
     facility, which, if enabled, may be used to terminate execution
     of a program.   It is assignable; 0 turns it off and any non-zero
     value turns it on.  NOTE that eX itself does not currently honor
     control breaks.

cd
                         cd Directory$
     Changes the disk directory to that specified by Directory$. 
     It is not the same as `os ("cd " + Directory$)' and will
     produce an eX error if the change cannot be made (directory not
     found).  

cDir
                         cDir<<(DiskDirve)>>
     Returns the current directory for the disk drive specified by the
     argument, which may be either number or string.  If an string is
     given, the uppercase first character of the string is used as the
     drive specifier.  If a number argument is given, 0 may be used to
     indicate the current drive.  The drives are otherwise specified
     as 1 / A, 2 / B, 3 / C...  If the argument is omitted, the
     current directory for the current (or logged) drive is returned. 
     The un-parenthesized argument form is not supported.  

cDrive
                         cDrive <<:= eev>>
     Returns the current disk drive.  It is assignable, and if a
     string is provided, the first character of the string is used to
     make the assignment; otherwise the numeric value is used, with
     1 denoting drive A, 2 drive B...

copy
                    copy(SourceFile$, DestinationFile$)
     Copies SourceFile$ to DestinationFile$ and returns a number
     indicating the result, which may be interpreted with  

              Result   Meaning
                 768    Bad path
                 512    File not found
                 255    No directory space
                  -2    File not found
                  -3    Bad path or file not found
                  -5    Access denied

     It's an eX routine, rather than an operating system routine and
     doesn't check for the catastrophic error that would be produced
     by SourceFile$ being the same as DestinationFile$.  

del
                    del FileSpecification$
     Deletes disk file FileSpecification$.  It isn't the same as
                 os chr "del " , FileSpecification$
     and will produce an eX error if the file isn't found or can't be
     deleted.

dir
                    dir FileSpecification$
     Displays the disk directory.  The files displayed will conform to
     the argument, and the wild-card characters * and ? may be
     employed as at the operating system level.  If the argument is
     null "", all files in the current directory will be displayed.  

     It will produce an eX error if no matching files are found, and 
     is not the same as 

                   os chr "dir ", FileSpecification$
 
     It's likely `dir' will either be changed or omitted in the future. 
     See also `FindFile' and `NextFile' in this section.

envir
                        envir eev
     Returns the string value of the DOS environment for the
     argument (which may be null "") if it exists, otherwise it
     returns the null string ("").  eev may be the (string) name of an
     entry within the table or the (numeric) number of the entry, in
     which case the entire entry including it's name is returned. 
 
     It is assignable; however, while any changes to the environment
     will be available to any eX programs and inherited by any program
     run under either of eX's os modes, the changes will be discarded 
     when eX is exited.  The assignment string must be in either of
     the forms   
  
                         set EntryName=text
                         set EntryName=

     If text either contains only a semi-colon (;) or is a null 
     string (""), the entry is removed from the environment table.  

ExitCode
     Returns the termination code of a program run with eX's `os'
     command.  It remains valid until another use of `os'.  
     Interpretation of `ExitCode' must be done with the documentation 
     for the program or the operating system.  NOTE that not all
     programs terminate with the operating system process that returns
     an exit (or return) code.  See also `ExitMode' in this section.  

ExitMode
     Returns the termination mode of a program run with eX's `os'
     command.  It remains valid until another use of os.  The values
     may be interpreted with the table below.  NOTE that not all
     programs terminate with the operating system process that returns
     an exit (or return) mode.  See also `ExitCode' in this section. 

     Value   Meaning
        0    Normal termination
        1    Terminated by Ctrl C
        2    Terminated by critical device error
        3    Terminate and stay resident (TSR)

FindFile
          FindFile FileSpecification$
          FindFile(FileSpecification$<<, FileAttribute#>>)
     An operating system interrupt.  Searches for the first file that
     matches the argument, which may include the `wild-card'
     characters * and ? and returns the file specification if a match
     is found.  If no match is found, the null string ("") is 
     returned.  
     See also `FAttr' and `NextFile' in this section.

FreeDisk
                   FreeDisk<<(DiskDrive)>>)
     Returns the number of bytes that are available on the disk drive 
     specified by the argument, which may be given as a string or a
     numeric (1 / A, 2 / B...).  If the argument is omitted, the
     number of bytes on the current (logged) drive is returned.  

md
                         md Directory$
     Creates the disk directory specified by Directory$.  It is
     internal, not the operating system command, and will produce an
     eX error if the directory cannot be created.

move
               move(SourceFileSpec$, DestinationFileSpec$)
     Moves and/or renames a file.  In order to rename a file, the file
     name and/or file name extension in DestinationFileSpec$ must be
     different than that in SourceFileSpec$ and DestinationFileSpec$. 
     In order to move a file, the path specification in  
     DestinationFileSpec$ must differ from that in SourceFileSpec$.  
     The way to simultaneously move and rename a file should be
     apparent.  If either argument is in the default directory, the
     path portion of that file specification is optional.  An error
     (crash---it's an eX routine) will be generated if  

          1. SourceFileSpec$ is not found or does not exist. 
          2. DestinationFileSpec$ already exists. 
          3. an attempt is made to move a file from one disk drive
             to another.  

NextFile
     An operating system interrupt.  Searches for the next file that
     matches the argument of the last FindFile, which must have been
     successful.  If another match is found, the file specification is
     returned; otherwise, the null string ("") is returned.  See also
     `FindFile' in this section.  

os
                         os eev$
     Executes the operating system command eev$.  `os' can be used for
     two semingly different yet actually nearly identical purposes.  

     First, if eev$ is null (""), it has the effect of temporarily
     transfering you to the operating system level.  (For those who
     are intimate with MS-DOS/PC-DOS, a new COMMAND.COM is loaded and
     transferred to.)  The operating system's title will be displayed
     and you are now effectively at the operating system level and may
     do anything that it allows.  Any errors while `at the operating
     system level' are generated by the operating system and are
     independent of eX.  When you are through at the operating system
     level and wish to return to eX, simply type 

                              exit [ Return ] 

     Note that eX remains memory resident and the memory available to 
     the operating system is considerably less than that available
     prior to the invocation of eX.  
 
     If eev$ is not null, it is taken to be an operating system 
     command and is executed by and at the operating system 
     level.  (Again, a new COMMAND.COM with the /c option is loaded
     and transferred to. The DOS command given in eev$ is run as a 
     child process.)  eev$ may be any command that may be given at the
     operating system level, and program arguments may be included.  
     Again, eX remains memory resident and seriously reduces the 
     amount of memory that is available to the operating system, and
     therefore, any program that is to be run.  eX is returned to
     automatically when the command(s) have been completed. 
      
     With either use of the word, if eX cannot find the file
     COMMAND.COM, an error is generated (crash) and the message  

                         File not found

     is displayed.  

rd
                         rd Directory$
     Removes the argument disk directory.  It is not the same as      
             os chr "rd ", Directory$
     and will produce an eX error (crash) if the directory is not
     found or cannot be removed---usually because the directory is not
     `empty'. 

ren
     ren is identical to move and is provided for convenience only.  
     See `move' in this section of the manual. 
     If you wish to simply re-name a file, use the operating system's
     `ren' command via eX's `os' command. 

spool
               spool(Command#, FileSpecification$)
     Spool is an interface to an installed print spooler for
     MS-DOS/PC-DOS 3.0 or subsequent and should work with all print
     spoolers. 

     I hate to admit that for various reasons I have yet to try it.  
     It returns a result code that may be interpreted with 

     Code   Meaning
        1   Invalid function (except Request 0).
        2   File not found.
        3   Path not found.
        4   Too many open files.
        5   Access denied.
        8   Queue full (try submitting later).  The normally 
            returned code for a `freeze' request (6).
        9   Spooler busy.
       12   File specification too long (maximum 64).
       15   Invalid drive specification.

     The commands are 

     Command
     #  Name                      Use
     0  Get Installed State       FileSpec$ may be omitted.  The
                                  returned value may be any of
                                    0: not installed, can be
                                    1: not installed, can't be
                                  255: is installed.
     1  Submit File for Printing  Add FileSpec$, which may not
                                  include * or ?, to print queue.
     2  Cancel File               Remove (don't print) FileSpec$
                                  from the queue. FileSpec$ may
                                  include * or ?, canceling all 
                                  matching files in the queue.
     3  Cancel All Files          Remove (do not print) all files 
                                  from the print queue.  FileSpec$ 
                                  may be omitted.
     4  File Status               Returns queue position of 
                                  FileSpec$, which may not include 
                                  * or ?.  0 is the current job, 256
                                  indicates file not in the queue.
     5  Un-freeze the Spooler     Re-commence printing where it left 
                                  off after freeze command. FileSpec$
                                  may be omitted.
     6  Freeze the Spooler        Cease printing (until `un-freeze'
                                  command).  Normally returns error
                                  code 8, queue is full.  FileSpec$
                                  may be omitted.

touch
                    touch FileSpecification$
     Unix's utility built in.  Sets the argument file's date and time
     to the current system date and time.

verify
                    verify <<:= eev#>>
     Returns the status of the system verify state and is assignable,
     a value of 0 turns it off and any non-zero value turns it on. 

