Black Box 4/BlackBox.cdr/dosutils/anarkey4.arj/ANARKEY.DOC

Text File | 1991-07-30 | 168.7 KB | 3,874 lines

         ANARKEY

         User Manual


         Version 4.0




         Anarchy: A state of being without rulers


         Anarkey: A state of being without keystrokes




















         Steven Calwas
         Moderne Software
         P.O. Box 3638
         Santa Clara, CA 95055-3638
         [phone]




         Copyright (C) 1988-1991
         by Steven Calwas
         All rights reserved


         Anarkey User Manual


         Published by: Moderne Software
                       P.O. Box 3638
                       Santa Clara, CA 95055-3638
                       [phone]


         Copyright (C) 1991 by Steven Calwas


         All rights reserved.  No part of this book may be reproduced
         or transmitted in any form or by any means, electronic or
         mechanical, including photocopying, recording, or by any
         information storage and retrieval system, without permission
         in writing from the Publisher.




         WARRANTY

         THE ANARKEY PRODUCT IS LICENSED "AS IS" WITHOUT ANY WARRANTY
         OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE,
         PERFORMANCE, OR OTHERWISE.  ALL WARRANTIES ARE EXPRESSLY
         DISCLAIMED.  BY USING THE ANARKEY PRODUCT, YOU AGREE THAT
         NEITHER STEVEN CALWAS NOR MODERNE SOFTWARE NOR ANY OFFICERS,
         DIRECTORS, EMPLOYEES, SHAREHOLDERS, AFFILIATES, OWNERS, OR
         ANY OTHER RELATED PARTIES WILL BE LIABLE TO YOU OR ANY THIRD
         PARTY FOR ANY USE OF (OR INABILITY TO USE) OR PERFORMANCE OF
         THIS PRODUCT, OR FOR ANY DAMAGES WHATSOEVER WHETHER BASED ON
         CONTRACT, TORT OR OTHERWISE EVEN IF WE ARE NOTIFIED OF SUCH
         POSSIBILITY IN ADVANCE.  (SOME STATES DO NOT ALLOW THE
         EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL
         DAMAGES, SO THE FOREGOING LIMITATION MAY NOT APPLY TO YOU.)


         Chapter 1

         Introduction and Tutorial

         Anarkey is an intelligent command-line editor for DOS.  With
         Anarkey, complete input lines can be entered with two or
         three keystrokes.  Anarkey is intelligent because there is
         no need to tell it what you want to enter on the command
         line; simply press the <Tab> key and Anarkey figures out
         what you want and does it for you.

         Anarkey knows what you want and gives it to you!

         Here is a list of the main operations Anarkey provides.


         * Line-edit features comparable to those found in word
         processors

         * Ability to save input lines for later retrieval

         * Three methods to retrieve saved command lines
                 1) Sequentially walk through the list of saved
                    commands

                 2) Line completion where you enter a portion of the
                    line and Anarkey completes the remainder for you

                 3) Pop-up window which lists all saved commands.
                    Supports a mouse.

         * A text substitution capability called an AKA (also
         referred to as an "alias" or "synonym").  The Convert
         program is included in the Anarkey package to translate the
         alias and synonym definitions of other editors to Anarkey's
         format.  AKAs can even be executed from a batch file.

         * Enter multiple commands on a single input line

         * A 255-character input line

         * Comprehensive filename completion

         * Environment variable editing

         * Use expanded memory

         * Display a non-blinking cursor

         * Pop-up windows with built-in mouse support to retrieve
         saved commands, complete filenames and edit environment
         variables

         * Configurable key assignments

         * A MegaKey which analyzes the input line, determines the
         type of Anarkey operation you want and does it for you
         automatically.  The MegaKey is what makes Anarkey an
         intelligent command-line editor.

         * Write the list of saved commands and AKAs to a disk file
         for future restoration

         * Comprehensive UNIX switchar support

         * Pop-up help window with configurable help text

         * Full-support for enhanced 101/102-key keyboards

         * Pop-up windows offer your choice between two mouse
         interfaces

         * Special support for the 386 Enhanced Mode of Microsoft
         Windows 3.0

         * And much more!


         Anarkey is written entirely in assembly language for maximum
         efficiency in memory usage and execution speed.  When
         installed in its default configuration, Anarkey uses about
         11K of memory.  If expanded memory is available, Anarkey
         requires only 1K of conventional memory.

         Installation

         To install Anarkey onto your system, copy all files from the
         distribution disk to your hard disk.  If you do not have a
         hard disk, copy the ANARKEY.COM program onto your boot disk.

         Anarkey makes significant use of the Anarkmd program.  To
         guarantee that Anarkey work properly at all times, place the
         ANARKMD.EXE file in a directory specified in the PATH
         environment variable.

         To run Anarkey, execute the ANARKEY.COM program from either
         the DOS prompt or your AUTOEXEC.BAT file.  Since you will
         probably want Anarkey active whenever you are using your
         computer, executing Anarkey from the AUTOEXEC.BAT file makes
         the most sense.

         When run, Anarkey installs itself into the DOS environment
         and terminates, but stays resident.  A default configuration
         is used, but can be modified via command-line options.
         Anarkey options are described in Chapter 11.  For the
         remainder of this tutorial, we assume the default
         configuration is in effect.

         Once resident, Anarkey handles all input requests for the
         following situations:

         * The DOS command line

         * Redirected input

         * DEBUG, SYMDEB, EDLIN and several third-party programs

         * All DOS sessions running under Windows 3.0 in 386 enhanced
         mode

         Notice that Anarkey does not process lines executed from a
         batch file.  However, the Anarkmd program described in
         Chapter 16 provides an indirect method to support batch
         files.  For now, we will postpone that topic.

         The remainder of this chapter is a tutorial on using
         Anarkey's basic features.  It is intended for people who
         want to get started with Anarkey immediately.  Subsequent
         chapters describe all of Anarkey's functions in complete
         detail.

         Quick-Start Tutorial

         Anarkey supplies a multitude of functions which transforms
         the dreary and tedious task of entering DOS commands into a
         quick and enjoyable process.  It is not necessary to
         understand all of Anarkey's powers before using it.  This
         tutorial gets you started using the basic Anarkey features
         immediately.  As you become familiar with these functions,
         additional information can be found in subsequent chapters
         of the manual.

         First, install Anarkey by executing the ANARKEY.COM program.
         This causes a sign-on message to appear, after which Anarkey
         installs itself and terminates.  You will be sitting at a
         new and empty command prompt where everything appears
         normal, however, Anarkey's features are now available for
         your use.

         The first Anarkey feature we will learn is its line-editing
         capability.  Anarkey lets you place the cursor anywhere
         within the input line and enter or delete characters.  If
         you have ever used a word processor, Anarkey's line-editing
         feature will already be familiar.

         To demonstrate, enter the following line at the command
         prompt.  The underscore character represents the cursor
         position.


                echo Anarchy knows what you want_


         The word "Anarchy" can be changed to "Anarkey" by pressing
         the <Left> arrow key to move the cursor until it is beneath
         the letter 'c' in "Anarchy."  Notice that moving the cursor
         within the line does not modify the line in any way.
         Similar to the <Left> key, the <Right> arrow key moves the
         cursor toward the right, <Home> positions the cursor beneath
         the line's first character and <End> moves the cursor to the
         end of the line.  The input line with the repositioned
         cursor now looks like this.


                echo Anarchy knows what you want


         When a character is typed, it is either inserted into the
         line or it overwrites the current character.  When a
         character is inserted, any characters to the right of the
         cursor are shifted to make room for the new character.  When
         a character is overwritten, the new character replaces the
         character at the cursor position; no shift occurs.

         Whether a character is inserted or overwritten depends upon
         Anarkey's input mode.  When in insert mode, typed characters
         are inserted into the line; in overwrite mode, character are
         overwritten.  When first installed, Anarkey is in insert
         mode.

         You can toggle between insert and overwrite modes by
         pressing <Ins>.  Notice the cursor shape changes depending
         upon the current mode.  The insert-mode cursor is an
         underscore while overwrite mode uses a block cursor.

         Get back into insert mode and type the two characters "ke."
         Anarkey inserts them into the line so that it now looks like
         that shown below.  Notice the cursor has remained under the
         letter 'c'.


                echo Anarkechy knows what you want


         Characters are easily deleted from lines using any of
         several functions.  The <Del> key removes the character
         above the cursor and shifts any trailing characters to fill
         the vacated space.  The <Backspace> key deletes the
         character to the left of the cursor and moves the cursor
         left one space.  The <Esc> key erases the entire line.

         Press the <Del> key twice to remove the unwanted characters
         in our sample line.  The final edited line looks like this.


                echo Anarkey knows what you want


         Press the <Enter> key to accept the line and execute it.
         Anarkey saves all executed lines.  You can view all the
         lines Anarkey has saved by pressing <F4>.  Execute the
         following lines and press <F4> to verify that Anarkey has
         saved them.


                dir *.*
                type read.me
                dir \*.bat


         Once a line has been saved, it can be retrieved so you won't
         have to retype it.  Pressing the <Up> and <Down> arrow keys
         "walks" you through the list of saved lines.  Once
         retrieved, a line can be edited using the line-edit
         functions.

         You can display a full-screen window containing the list of
         the saved commands by pressing <Alt-F4>.  (Make sure
         ANARKMD.EXE is stored somewhere along your PATH variable
         before doing this.)  Notice that one line in the window is
         highlighted in reverse video.  This line is called the
         current line.  Pressing the <Up> and <Down> keys makes other
         lines in the window the current line.  If the entire list
         cannot fit in the window, the <PgUp> and <PgDn> keys scroll
         the window's contents.  If a mouse is installed, it can also
         be used to change the current line and scroll the window's
         contents.  Pressing the <Enter> key selects the current
         line.  When a line is selected, the window closes and the
         chosen line is entered onto the input line.

         Perhaps the fastest way to retrieve a command is to use
         Anarkey's command completion feature.  Start with an empty
         command line and enter the first character of the line you
         wish to retrieve.  Then press the <Tab> key (also known as
         the MegaKey).  Anarkey searches the list of saved commands
         until it finds one that starts with the same character you
         entered.  The remainder of the line is then copied onto the
         input line.  You can try this yourself by entering the 'e'
         from our sample input line and pressing <Tab>.  Anarkey
         retrieves the remainder of the saved "echo" command and
         enters it on the input line.  If by some chance Anarkey
         completed the line in some undesired manner (in other words,
         it did not retrieve the desired line), simply press the
         <Tab> key again.

         Besides completing commands, the <Tab> key can also complete
         directory and file names.  When you press <Tab>, Anarkey is
         intelligent enough to know whether you want to retrieve a
         command, as previously described, or complete a file name
         and it acts appropriately.

         As an example of completing a directory name, say we wish to
         enter the command "cd\global."  Type the following
         characters on the input line and press <Tab>.


                cd\g_


         Assuming a directory named "global" existed, Anarkey
         completes it for us.  Similar to command completion, Anarkey
         uses the first character of the name when searching for a
         completion.  Thus, it would look for a directory starting
         with the letter 'g.'  If more than one directory began with
         a 'g,' Anarkey may select the "wrong" name.  If so, simply
         press <Tab> again to cycle through the list of possible
         completions.

         So far, all our examples show you entering only the first
         character of the item to complete.  However, you can enter
         as many characters as you wish.  Often a single character is
         all that will be needed for Anarkey to complete the rest.
         However, staying with our directory-completion example, say
         a large number of directories happened to begin with the
         letter 'g.'  Cycling through them all may take more
         keystrokes than simply typing the name in manually.
         Instead, enter additional characters on the input line to
         narrow Anarkey's search to a smaller number of possible
         completions.  For example, if "gl" is entered on the sample
         input line, Anarkey searches only for directories that begin
         with the letters "gl."  This technique can also be used for
         command completions and all the other completion operations
         Anarkey provides.

         Besides completing directory names, Anarkey also completes
         the names of programs and other file types.  When completing
         a program name which is to be executed, Anarkey does not
         enter the file extension (.BAT, .EXE or .COM) on the input
         line, just as you would not enter it if typing the name
         yourself.

         Anarkey can easily retrieve the setting of an environment
         variable for you.  First type the "SET" command followed one
         or more characters of the variable's name.  Then press
         <Tab>.  Anarkey completes the name and enters the variable's
         setting on the input line.  You can then edit the setting,
         for instance, by adding a new directory to the PATH.  (You
         don't need to type the SET command to retrieve the PATH or
         PROMPT settings, but Anarkey cannot complete their names for
         you if you don't.  Check Chapter 8 for further details on
         this topic.)

         You may have noticed that much of this tutorial kept
         repeating a single lesson.  That lesson was: If you want to
         enter something on the input line, press the <Tab> key;
         Anarkey figures out what you want and does it automatically.
         In other words, Anarkey knows what you want and gives it to
         you.  This capability is what makes Anarkey an intelligent
         command-line editor.

         Using the basic features outlined in this tutorial, you can
         begin to use Anarkey productively right now.  But be aware
         this section barely touched the surface of Anarkey's full
         capabilities.  Much more is available and is as easy to
         learn and use as the functions just described.  If you are
         interested, complete details are provided in the forthcoming
         chapters.



         Chapter 2

         The Pop-Up Help Window

         Anarkey adds many new features to the standard DOS command
         prompt.  When you are first learning Anarkey, the provided
         functions and key assignments will not yet be committed to
         memory.  Even after you become comfortable with Anarkey,
         there will probably be some operations that you will use
         only occasionally and whose keystrokes you will not
         immediately remember.  To assist you during these times,
         Anarkey supports a pop-up help window which lists all of the
         supported functions and their respective key assignments.

         The help window can be popped-up by pressing <Alt-F1> or
         <Alt-H> whenever Anarkey is active, for example, at the DOS
         command prompt.  Before you pop-up the window, make sure the
         Anarkmd program (in the file ANARKMD.EXE) is in either the
         current directory or a directory specified in the PATH
         environment variable.  After pressing the help key, a
         full-screen window will be displayed containing a list of
         Anarkey functions and their current key assignments.

         Note: The reason Anarkmd must be in the current directory or
         along the PATH is because it actually performs the entire
         pop-up window operation.  Anarkey simply executes Anarkmd,
         telling it to display the help window.  But all this is
         performed automatically in the background and you do not
         need to worry about it.

         The information displayed in the window is actually read
         from a standard text file just before the window pops up.
         By reading and displaying a separate text file, Anarkey
         saves precious DOS memory by not keeping the help
         information resident.  It also provides great flexibility in
         the content and format of the displayed help information.
         In other words, you can modify the help text file to your
         heart's desire, even include help information about other
         programs if you wish.  The only restrictions that apply are:
         (1) the file cannot exceed 65,000 characters in size and (2)
         the file may not contain more than 1000 lines of text.

         Since a text file must be loaded to gather the help
         information, Anarkey must be informed of the help file's
         name.  Anarkey first looks for the file name in an
         environment variable called "HELP@."  If HELP@ is defined,
         it should specify the drive, directory and filename of the
         help file.  For example,


                SET HELP@=c:\anarkey\anarkey.hlp


         If HELP@ is not defined, Anarkey assumes the helpfile's name
         is ANARKEY.SUM and will attempt to locate a file with that
         name.  ANARKEY.SUM is a text file distributed with Anarkey
         which contains a list of Anarkey functions and their default
         key assignments.  ANARKEY.SUM can also be updated by
         Anarked, the Anarkey Keystroke Editor, if you modify any of
         the default key assignments.  Anarked is explained in
         Chapter 13.

         Depending upon which version of DOS you are running, Anarkey
         will search for the ANARKEY.SUM file in two locations.
         First, if running under DOS version 3.0 or later, Anarkey
         searches for ANARKEY.SUM in the same directory in which
         Anarkmd is located, also called the home directory.  Under
         versions of DOS prior to 3.0, Anarkey does not check this
         location.

         If the ANARKEY.SUM file is still not found, Anarkey looks
         for it in the current directory.

         These search steps and the order in which they are performed
         are outlined below:


                 1) File specified in HELP@ environment variable

                 2) ANARKEY.SUM in Anarkmd home directory (DOS 3.0+
                    only)

                 3) ANARKEY.SUM in current directory


         If all attempts to locate the help file fail, Anarkey
         displays an error message ("Help file not found") and ends
         the help operation. Otherwise, the help file is loaded and
         displayed in the pop-up window.

         With the help window displayed, the following keystrokes are
         recognized and acted upon:


                 <F1>            -- Display help for pop-up window
                 <Esc>           -- Exit the help window
                 <Enter>         -- Same as <Esc> key
                 <Up>            -- Scroll the window contents up one
                                    line
                 <Down>          -- Scroll the window contents down
                                    one line
                 <PgUp>          -- Scroll the window contents up one
                                    page
                 <PgDn>          -- Scroll the window contents down
                                    one page
                 <Home>          -- View top of help file
                 <End>           -- View bottom of help file


         In addition to keystroke input, if a mouse is installed on
         the computer, it can be used to scroll through the help
         window.  Anarkey supports the Microsoft and any
         Microsoft-compatible mouse.

         With the mouse installed, a separate mouse cursor is
         displayed in the middle of the window in the form of a solid
         block character.  By moving the mouse, the mouse cursor can
         be moved anywhere on the screen.

         Scrolling operations are performed with the mouse by moving
         the mouse cursor to specific locations in the window and
         clicking (pressing and releasing) the left mouse button.
         For example, you can position the mouse cursor anywhere over
         the "Press F1 for help" message in the upper right corner of
         the window and click the left mouse button.  This will have
         the same effect as pressing <F1> in that it will display an
         additional help screen.  Pressing either mouse button will
         clear this secondary help window.

         On the far right edge of the help window is a scroll bar.
         The scroll bar is actually composed of four separate
         sections.  At the very top of the bar is a single-character
         up-arrow.  To scroll the window contents up one line,
         position the mouse cursor on this arrow and click the mouse
         button.  A down-arrow is located at the very bottom of the
         scroll bar.  Click on it to scroll the window contents down
         one line.  The remainder of the scroll bar is divided into
         two equal halves.  Click on the top half to scroll the
         window up one page; click on the bottom half to scroll down
         one page.  You can also press and hold the mouse button with
         the mouse cursor positioned at any of these locations.
         Doing so is the same as repeatedly clicking on the item.

         To clear the help window, click the right mouse button.

         After exiting the help screen, you will be returned to the
         DOS command prompt.  Any characters entered at the prompt
         when the help window was popped-up will still exist.

         The mouse movements described in this chapter are also
         applicable to the other pop-up windows that Anarkey
         supports.  These other windows are discussed in future
         chapters.

         Anarkey also supports an alternative mouse interface in case
         you don't like the interface described in this chapter.  The
         alternative mouse interface is described in Appendix I.


         Chapter 3

         Editing the Command Line

         Anarkey provides line editing functions commonly found in
         word processing programs.  These functions include general
         editing, cursor movement, character deletion and character
         retrieval features.

         One note of interest should be mentioned here.  Most of the
         keystroke assignments listed in the remainder of this manual
         are configurable.  If you don't like some default key
         assignment, Anarked, the Anarkey Keystroke Utility, can be
         used to reassign it to a key more to your liking.  Anarked
         is described in detail in Chapter 13.  Refer to it for
         complete details.  In this manual, only the default key
         assignments will be mentioned.

         General Editing

         Pressing the <Enter> key accepts the input line.  This
         usually means that the line is passed to the command
         processor for execution.  The entire line is always
         accepted, regardless of the cursor's position in the line.

         Before Anarkey passes the line to the command processor, it
         performs some checks and optional processing on the line
         itself.  For example, Anarkey will break the line into
         separate commands.  (You will see shortly that Anarkey
         allows you to specify multiple commands on a single input
         line.)

         It also checks the length of each command to verify that its
         length is within the allowable range.  If a command is too
         long, Anarkey does not accept the input line.  Instead, it
         positions the cursor under the first character that extends
         beyond the length limit and allows you to modify the line
         further.  After the line's length has been adjusted, you can
         press <Enter> to accept the line again.

         Anarkey supports two input modes: insert and overwrite.
         When editing in insert mode, typed characters are inserted
         into the input line; any characters to the right of the
         inserted character are shifted right to make room.  In
         overwrite mode, typed characters write over any existing
         character at the cursor position; no shifting of characters
         occurs as in insert mode.

         The <Ins> key toggles Anarkey between these two input modes.
         By default, Anarkey begins in insert mode.  If you prefer
         Anarkey to start in overwrite mode, you can specify the -I
         option on the Anarkey command line when it is installed.
         Refer to Chapter 11 for more information on Anarkey
         command-line options.

         The current input mode is indicated by the cursor's shape.
         The power-up input mode uses an underscore cursor; the
         alternate mode uses a block cursor.  For example, if Anarkey
         begins in its default insert mode, the cursor is an
         underscore whenever insert mode is active.  On the other
         hand, if you use the -I option to change the power-up mode
         to overwrite then an underscore cursor is used whenever
         Anarkey is in overwrite mode.  The relationship between
         input mode and cursor shape is further illustrated in the
         following table:


                 Power-up mode = Insert (default and -II option)
                         Insert mode cursor      = Underscore
                         Overwrite mode cursor   = Block

                 Power-up mode = Overwrite (-IO option)
                         Insert mode cursor      = Block
                         Overwrite mode cursor   = Underscore


         If you prefer that Anarkey never alter the cursor's shape,
         install it with the -C option.  Anarkey can also display a
         non-blinking cursor if the -CN option is used.  And if the
         normal underscore cursor does not show up well on your
         monitor, use the -CT option to use a thick underscore
         cursor.  Refer to Chapter 11 for details on these and other
         options.

         Anarkey remains in a particular input mode until it is
         explicitly told to toggle to the other mode via a press of
         the <Ins> key.  However, you may prefer that Anarkey always
         begin a new input line in a particular mode.  Anarkey can be
         forced into a particular input mode at the start of each new
         line by including the -I option on the installation command
         line.  Again, refer to Chapter 11 for complete details.

         As you will quickly learn, Anarkey supports a lot of
         features.  Many of these features are invoked by pressing a
         key.  Situations may occur where you wish to enter a certain
         key onto the input line, but pressing the key instead
         executes an Anarkey function.  For example, say you wish to
         enter an ANSI escape sequence onto the input line.  As you
         may know, this would entail typing an <Esc> character
         followed by several other characters.  However, pressing
         <Esc> normally instructs Anarkey to clear the entire input
         line (as will be described shortly).  Is there a way to
         bypass Anarkey's key processing and enter a keystroke
         directly onto the input line?

         The answer to the above question is "yes" and you do it by
         immediately preceding the key by pressing <Ctrl-U>.  The key
         pressed immediately after <Ctrl-U> is entered directly onto
         the input line.  Therefore, to enter an <Esc> onto the input
         line, press <Ctrl-U><Esc>.  The <Ctrl-U> keystroke tells
         Anarkey to enter the next keystroke "unmodified," in other
         words, to skip any interpretation it would normally perform
         on the key.  If you want to enter a <Ctrl-U> on the line,
         simply press <Ctrl-U> twice in succession.

         In summary, the general editing keystrokes discussed in this
         section were:


                 <Enter>         Accept input line
                 <Ins>           Toggle input mode
                 <Ctrl-U>        Enter next keystroke unmodified


         Moving the Cursor

         Anarkey allows the cursor to be placed anywhere on the input
         line.  Thus, you can move the cursor to the beginning or
         middle of a line and modify just a few characters without
         backspacing and deleting any trailing portion.

         The cursor is positioned within the line by cursor-movement
         keystrokes.  Each cursor-movement keystroke is outlined and
         described in the following table.


                 <Home>          Move cursor to start of line
                 <End>           Move cursor to end of line
                 <Right>         Move cursor right one character
                 <Left>          Move cursor left one character
                 <Ctrl-Right>    Move cursor right one word
                 <Ctrl-Left>     Move cursor left one word


         None of the cursor-movement keys alter the contents of the
         input line.  After the cursor is positioned to its desired
         location, additional modifications, such as inserting or
         deleting characters, can be performed.

         Deleting  Characters

         Anarkey also supports functions to remove one or more
         characters from an input line.  They are all listed in the
         table below.


                 <Backspace>     Delete character to left of cursor
                 <Del>           Delete character above cursor
                 <Ctrl-T>        Delete word to right of cursor
                 <Ctrl-End>      Delete to end of line
                 <Esc>           Delete line


         If Anarkey is in insert mode, removal of a character causes
         any trailing characters on the line to shift over to fill
         the vacated space.

         The cursor position moves whenever the <Backspace> or <Esc>
         keys are pressed.  <Backspace> moves the cursor left one
         character and <Esc> places the cursor at the start of the
         empty line.  All the other character-deletion keys have no
         effect on the cursor position.

         Retrieving Characters

         One of Anarkey's strongest features is its ability to
         retrieve command lines previously entered.  That topic is
         discussed in detail in the next chapter.  In addition to
         that powerful new feature, Anarkey also supports two of the
         original DOS functions that retrieve individual characters
         and an enhanced version of one of those functions.  These
         three operations are listed in the following table.


                 <F1>            Retrieve character from previous line
                 <F3>            Retrieve remainder of previous line
                 <Alt-F3>        Retrieve remainder of previous line
                                 and accept line


         The <F1> and <F3> keys provide identical services to those
         offered in the original DOS editing functions.  <Alt-F3> in
         an enhanced version of <F3> in that it immediately accepts
         the input line following the character retrieval operation.
         <Alt-F3> is the equivalent of typing <F3><Enter>.

         Summary

         The following line-editing functions were described in this
         chapter.


                 <Enter>         Accept input line
                 <Ins>           Toggle input mode
                 <Ctrl-U>        Enter next keystroke unmodified
                 <Home>          Move cursor to start of line
                 <End>           Move cursor to end of line
                 <Right>         Move cursor right one character
                 <Left>          Move cursor left one character
                 <Ctrl-Right>    Move cursor right one word
                 <Ctrl-Left>     Move cursor left one word
                 <Backspace>     Delete character to left of cursor
                 <Del>           Delete character above cursor
                 <Ctrl-T>        Delete word to right of cursor
                 <Ctrl-End>      Delete to end of line
                 <Esc>           Delete line
                 <F1>            Retrieve character from previous line
                 <F3>            Retrieve remainder of previous line
                 <Alt-F3>        Retrieve remainder of previous line
                                 and accept line


         Chapter 4

         The History Buffer

         Anarkey saves all entered input lines in a storage area
         called the history buffer.  Keystroke functions are provided
         to retrieve lines from the buffer, saving you from having to
         type them again.  This is one of Anarkey's most powerful
         features.  Also provided are functions to manuever through
         the buffer and control which lines get saved in it.  Each of
         these operations are discussed in this chapter.

         When Anarkey is first installed, the history buffer is
         empty.  When the first input line is accepted (i.e. you
         press <Enter>), it is stored at the very top of the buffer.
         Subsequent input lines are stored in the buffer, one after
         the other, from the top of the buffer to the bottom.  Empty
         lines are not saved in the history buffer.  Lines composed
         of multiple commands are stored in the history buffer as a
         single line.  (Entering multiple commands on a line is
         discussed in Chapter 7.)

         A history buffer with several lines stored in it is depicted
         below.


                rem This is line one
                rem This is line two
                rem Here is the third line
                rem This is the last line in the buffer



         When the history buffer is full and you enter a new input
         line, the line stored at the top of the history buffer is
         removed to make room for the new line.  You can think of
         this action as being similar to lines scrolling off the top
         of a display screen.

         The number of lines the history buffer can hold depends upon
         the line length and the buffer size.  By default, the
         history buffer will hold 500 characters.  However, this can
         be configured to any value from 255 to 50,000 via the -H
         command-line option.  (Refer to Chapter 11 for details.)

         The lines stored in the history buffer can be viewed at any
         time by pressing <F4>.  Lines are output to the screen
         starting with the first line in the buffer and proceeding
         down to the last line.  When an entire screen's worth of
         lines has been displayed, output pauses.  You can press any
         key to display the next screenful of lines.

         If you prefer to view the history buffer from the bottom to
         the top (that is, from the newest line to the oldest), press
         the <Alt-F4> key.  This is identical to <F4> except the
         order in which lines are displayed is from the last line in
         the buffer up to the first.

         Line Retrieval

         At any given time, one line in the history buffer is
         designated as the current buffer line or CBL.  The CBL is a
         very important concept for you to understand.  By moving the
         CBL through the history buffer, in other words, by making a
         different buffer line the current line, is one method
         Anarkey provides to retrieve lines from the buffer.

         The following diagram depicts a sample history buffer with
         the CBL "pointing" to the last line in the buffer.  The last
         line in the history buffer is always a blank line.  When you
         begin entering a new line, the CBL is always set to the
         last, empty line in the buffer.


                copy *.* a:
                dir a:
                del *.txt
                md temp
         CBL ->


         You can move the CBL, in other words, make a different
         buffer line current, by pressing the <Up> or <Down> arrow
         keys.  If the CBL is at the last line in the buffer and the
         <Down> key is press, the CBL circles back up to the top of
         the buffer.  Similarly, with the CBL at the first line in
         the buffer, pressing <Up> will cycle you back to the last,
         empty buffer line.

         Moving the CBL is extremely useful.  When you move the CBL,
         the new current buffer line is retrieved from the history
         buffer and entered onto the input line.  Any characters that
         existed on the input line at the time of the <Up> or <Down>
         keypress are erased prior to retrieving the buffer line.

         For example, pressing the <Up> arrow key with the buffer
         status shown above, moves the CBL up to the previous line
         ("md temp"), retrieves that line from the buffer and places
         it on the input line.  The new buffer status with updated
         CBL is shown in the following diagram.


                copy *.* a:
                dir a:
                del *.txt
         CBL -> md temp


         The <Up> and <Down> keys can be pressed repeatedly to
         sequentially walk through the entire buffer.  Once the
         desired line is retrieved from the buffer, you can use any
         of Anarkey's line-editing functions to modify the line
         before accepting it.

         After retrieving a line, if you immediately accept it by
         pressing <Enter>, Anarkey moves the retrieved line from its
         location in the history buffer down to the end of the
         buffer.  This action prevents the buffer from being filled
         with a bunch of duplicate lines.

         To demonstrate the move operation, assume the CBL has been
         positioned in the history buffer as shown in the following
         diagram.


                copy *.* a:
         CBL -> dir a:
                del *.txt
                md temp


         With the "dir a:" command retrieved, <Enter> is immediately
         pressed to accept the line unmodified.  This causes the CBL
         to be moved to the end of the buffer.  At the next input
         prompt, the new buffer status will be that shown below.


                copy *.* a:
                del *.txt
                md temp
                dir a:
         CBL ->


         Notice the "dir a:" command was moved from its old location
         in the buffer down to the end.

         If you prefer that Anarkey maintain a complete log of the
         commands you execute in the exact order in which they are
         entered, you can turn off this move operation by specifying
         the -F option when installing Anarkey.  Refer to Chapter 12
         for further details.

         Situations may occur where you wish to retrieve two or more
         lines stored consecutively in the history buffer.  For
         example, after retrieving the "dir a:" command as we've just
         done, say we also want to retrieve the line that followed it
         in the buffer, "del *.txt."  Of course, we can use the <Up>
         and <Down> keys again, but that is not necessary.  Also, if
         there existed a large number of lines in the history buffer,
         it may take a long time to get to the line we want.  There
         is an easier way.

         Anarkey maintains an internal record of the buffer position
         of the last retrieved line.  The CBL can be moved to this
         saved position by pressing the <PgDn> key.  Moving the CBL
         to the next line in the buffer also retrieves that line and
         enters it onto the input line.  Thus, continuing with our
         previous example, after pressing <PgDn>, the buffer status
         will be that shown below.


                copy *.* a:
         CBL -> del *.txt
                md temp
                dir a:


         The effect is as though you had repeatedly pressed the <Up>
         key to move the CBL, however, by using <PgDn> instead you
         have entered far fewer keystrokes.

         The CBL can be restored to this saved position only one time
         per input line.  Subsequent <PgDn> keystrokes are equivalent
         to pressing the <Down> key.

         Line Completion

         In actual practice, the number of lines stored in the
         history buffer can be quite large.  Having to walk past each
         line sequentially in order to get to the desired one can be
         more work than retyping it.

         For such cases, Anarkey provides a command completion
         function.  Simply type one or more characters on the input
         line and press the <F5> or <Ctrl-K> key.  Anarkey will
         search the history buffer for a saved command that starts
         with the same character(s).  When it finds one, Anarkey
         retrieves the line and enters it on the input line, in
         effect completing the command for you.  If the completed
         command is not the one you want, press <F5> or <Ctrl-K>
         again and Anarkey will pick up where it left off and
         continue the search.

         When Anarkey searches for a command completion, it always
         begins the search at the CBL and works up toward the top of
         the buffer.  When it finds a completion, it sets the CBL to
         the matching line and retrieves the line.  If the top of the
         buffer is reached without finding a completion (or all the
         completions have been retrieved), Anarkey beeps the speaker
         and sets the CBL to the bottom of the buffer.  Pressing <F5>
         at this point will begin the completion operation again,
         cycling through the history buffer another time.

         If the command completion operation is invoked with an empty
         input line, Anarkey will retrieve the previous buffer line.
         This is identical to pressing the <Up> key.

         As an example of how command completion works, assume the
         following history buffer:


                copy *.* a:
                del *.txt
                md temp
                cd temp
                dir a:
                xcopy a: b:
                mode mono
         CBL ->


         Say we wish to retrieve the "del *.txt" command using
         command completion.  Enter into an empty input line the
         single character "d" and press <F5> or <Ctrl-K>.  Anarkey
         will search from the CBL toward the top of the buffer until
         it discovers a line that starts with the letter "d."  When
         it finds the line "dir a:" it will stop searching, set the
         CBL to the line and retrieve it by entering it on the input
         line.  The buffer status is now that shown in the diagram
         below.


                copy *.* a:
                del *.txt
                md temp
                cd temp
         CBL -> dir a:
                xcopy a: b:
                mode mono


         However, we did not want the "dir a:" command.  Therefore,
         press the <F5> key again to get Anarkey to continue its
         search.  This time it finds the "del *.txt" command and
         retrieves it, completing the desired command for us.  We can
         now edit the line further or simply accept it by pressing
         <Enter>.  The final buffer status will be:


                copy *.* a:
         CBL -> del *.txt
                md temp
                cd temp
                dir a:
                xcopy a: b:
                mode mono


         Alternatively, we could have entered the first two
         characters of the desired command, "de," before beginning
         the search.  If we had, Anarkey would never have matched the
         "dir a:" command and, instead would have gone right to the
         line we wanted.

         At any time during a command completion operation, you can
         add more characters to the input line to narrow the search.
         Assume that after entering the single character "d" in our
         example and found an undesired completion, we realized there
         were a large number of lines stored in the buffer that began
         with that letter.  Rather than retrieve each one, simply
         enter one or more additional characters onto the input line.
         The command completion operation does not move the cursor
         position, therefore, the cursor will still be after the
         initial "d" we entered.  Type one or more characters onto
         the line and continue the search by pressing <F5>.  This
         will narrow down the number of matching completions and
         retrieve the desired line sooner.  In most cases, entering
         from one to three characters will be enough to narrow the
         number of completions to a very small number, allowing quick
         retrieval.

         The command completion function has a close cousin.  The
         <F6> and <Ctrl-L> keys perform the same completion operation
         as <F5> and <Ctrl-K> except the retrieved line is
         immediately accepted.  If you are positive the line you wish
         completed will be the first (or next) one Anarkey will find,
         pressing <F6> or <Ctrl-L> will save you from having to hit
         <Enter>.  However, if you were wrong, it will be too late;
         the retrieved line will already be executing when you
         realize your error.  The <F6> and <Ctrl-L> keys allow you to
         really fly when working at the command prompt, executing
         long and complicated lines with a minimal number of
         keystrokes.  Just be careful you don't crash and burn.

         The History-Buffer Window

         If neither walking through the history buffer nor command
         completion are to your liking, Anarkey provides yet another
         method to retrieve lines from the history buffer.  Press
         <Alt-F5> or <Alt-K> and a full-screen window will pop-up
         that contains all the lines stored in the buffer.  If one or
         more characters are on the input line when you press the
         key, the window will contain only those lines from the
         buffer that could be used to complete the remainder of the
         line.

         Note: Before you pop-up the history-buffer window, be sure
         the Anarkmd program is available in either the current
         directory or a directory specified along the PATH
         environment variable.  Anarkey actually executes Anarkmd
         which then displays the pop-up window.  This saves a large
         amount of memory since the code to process the window is not
         required to be resident.

         From the history-buffer window, you can scroll through the
         buffer, select a line to retrieve or combine multiple
         commands to form a single line to enter on the input line.
         Each of these operations will be described, but if you ever
         need a reminder, you can always press the <F1> key to
         display a help window of recognized keystrokes.

         If the history buffer contains more lines than will fit in a
         single window, you can scroll through the buffer by using
         the keyboard or a mouse.  Navigating through the buffer
         window is identical to scrolling through the pop-up help
         window described in Chapter 2.  Refer back to it if you need
         to refresh your memory on this topic.

         One line in the history buffer window is always displayed in
         reverse video (i.e. black characters on a white background).
         This is the current line.  By using the <Up> or <Down> arrow
         keys, you can make the previous or next line in the window
         the current line.  Press the <Enter> key to select and
         retrieve the current line.  The pop-up window will clear and
         the selected line will be entered onto the input line.  A
         line can be selected with the mouse by placing the mouse
         cursor anywhere on the line and clicking the left button.
         If the left mouse button is double-clicked (clicked twice in
         rapid succession) the line is selected and immediately
         executed.

         The pop-up history buffer window provides one function not
         found in other Anarkey windows.  That function is the
         ability to combine two or more lines together to form a
         single line.  This single line can then be entered onto the
         input line automatically.  Combining lines saves you from
         having to retrieve each one individually; a single retrieval
         operation is all that's required.

         Entering multiple commands on a line is discussed in detail
         in Chapter 7.  However, to understand how they are
         constructed in the pop-up history window, all you need to
         know now is that each command must be separated by a
         semicolon(;).  For example, the following input line is
         composed of two commands, "cd \temp" and "dir."


                cd \temp;dir


         When combining lines in the history buffer window, the
         semicolon character is placed in the line for you
         automatically.

         The process of combining lines entails selecting a line from
         the window.  However, before you press <Enter> or the left
         mouse button to make the selection, press and hold the
         <Ctrl> key (i.e. press either <Ctrl-Enter> or <Ctrl-Left
         Mouse Button).  This causes the line construction window to
         pop-up.

         The line construction window consists of one field area
         which contains the combined lines you have selected up to
         that point.  Additionally, there are four buttons along the
         bottom of the window.

         Each action that may be performed in the line construction
         window is represented by one of the buttons.  To perform an
         action, you select or push its associated button.  At all
         times, one button is displayed with a double-line frame.
         This is the current button.  Press the <Tab> or <Right>
         arrow key to make the next button current.  Press
         <Shift-Tab> or <Left> arrow to make the previous button
         current.  To push a button and perform its associated
         action, make it the current button and press <Enter>.  A
         mouse can also be used to push a button by placing the mouse
         cursor over it and clicking the left button.  Each button
         also has a hot-key character which is displayed in
         highlighted video.  You can press a button's hot-key to
         select or push the button.  If you ever need to be reminded
         of these keystrokes, press <F1> to display a
         context-sensitive help window.

         The Abort button terminates the line construction operation.
         Any combined line created up to that point will be cleared
         and control will return to the history buffer window.

         The Continue button returns control back to the history
         buffer window.  From here, you can select an additional line
         to append to the line being constructed.  To append a line
         to the previously-selected lines, be sure to press
         <Ctrl-Enter> or <Ctrl-Left Button> when you select the line.
         Pressing <Enter> or the left mouse button without holding
         the <Ctrl> key will retrieve that line only and not the
         combined line.

         The Accept and Edit button accepts the constructed line.
         All windows will clear and the line will be entered onto the
         input line for your editing edification.

         The Accept and Execute button is identical to Accept and
         Edit except the line is executed immediately.  Pushing the
         Accept and Execute button is the same as pressing Accept and
         Edit followed by <Enter>.

         Miscellaneous Operations

         In addition to retrieving lines from the history buffer,
         Anarkey provides several miscellaneous functions which
         effect the buffer.

         To store a line in the history buffer without executing it,
         accept the line by pressing <Ctrl-Enter>.  Be aware this
         function is only available at the DOS prompt and not in the
         history buffer window; in the window, <Ctrl-Enter> invokes a
         line-construction operation.

         Individual lines can be removed from the history buffer by
         first retrieving the line and then pressing <Ctrl-Z>.  In
         effect, the current buffer line (CBL) is deleted from the
         buffer.  When this occurs, the CBL will move to the next
         line in the buffer which is then retrieved and entered onto
         the input line.  Thus, <Ctrl-Z> can be pressed repeatedly to
         delete a group of consecutive lines from the buffer.

         The entire history buffer can be cleared by pressing
         <Ctrl-X>.

         Finally, the contents of the history buffer can be written
         to an ASCII text file by pressing <Ctrl-W>.  The Load
         program, discussed in Chapter 14, can then read this file to
         refill the buffer at a later time.  This function is useful
         for carrying over the history buffer contents from one
         computer session to another.

         When you press <Ctrl-W>, the history buffer is always
         written to a file called ANARKEY.LOG located in the root
         directory of the current drive.  If the file cannot be
         written because of a full disk, Anarkey beeps.  If you
         prefer the file be written to a different location or under
         another name, use the Anarkmd program to create the file.
         Refer to Chapter 16 for details on Anarkmd operation.

         Summary

         The line-retrieval functions discussed in this chapter are
         among Anarkey's biggest strengths.  If you take the time to
         become comfortable with them, you will be rewarded with a
         significant time savings.

         In summary, the functions and keystrokes discussed in this
         chapter are listed below.


                 <F4>            View history buffer (top to bottom)
                 <Alt-F4>        View history buffer (bottom to top)
                 <Up>            Retrieve previous buffer line
                 <Down>          Retrieve next buffer line
                 <PgDn>          Retrieve buffer line following last
                                 retrieved line
                 <F5>            Complete line
                 <Ctrl-K>        Same as <F5>
                 <F6>            Complete line and execute
                 <Ctrl-L>        Same as <F6>
                 <Alt-F5>        Display history-buffer window
                 <Alt-K>         Same as <Alt-F5>
                 <Ctrl-Enter>    Store line in history buffer, do not
                                 execute
                 <Ctrl-Z>        Remove current buffer line from
                                 history buffer
                 <Ctrl-X>        Clear history buffer
                 <Ctrl-W>        Write history buffer



         Chapter 5

         Anarkey AKAs

         There exist certain commands which you probably execute with
         great regularity.  The retrieval operations discussed in the
         previous chapter are extremely useful in reducing the number
         of times you have to type such lines.  In addition to
         retrieval functions, Anarkey provides another powerful
         feature called an AKA (pronounced "a-k-a").

         AKAs provide a text-substitution capability to Anarkey.  You
         can assign a long string of characters to a short character
         string of one or two characters.  Then when you enter the
         short string on the input line, Anarkey will replace it with
         the long string.  This text substitution occurs after the
         line has been accepted, but before it has been executed,
         therefore, the substitution is transparent to the user.

         If you are familiar with another command-line editor, an
         Anarkey AKA is analogous to what is sometimes referred to as
         an alias or synonym.  "AKA" is an acronym for
         "Also-Known-As" and "AnarKey Alias."

         In Anarkey's default configuration, AKAs are not supported.
         This saves DOS memory because none of the code needed to
         process AKAs remains resident.  If you wish to use Anarkey's
         AKA feature, you must specify the -A option when Anarkey is
         installed.  Immediately following the -A option, specify the
         amount of memory Anarkey should reserve to store your AKAs.
         For example, to store 200 characters of AKAs, install
         Anarkey with the option -A200.  The -A option is also
         described in Chapter 11 of this manual.

         Defining an AKA

         An AKA is composed of two parts: an AKA word and a
         substitution string.  In most cases, the AKA word will be
         short and the substitution string fairly long or
         complicated.  When you type the AKA word onto an input line
         and accept the line, Anarkey replaces the word with its
         substitution string.

         AKAs can be defined on the DOS command line or via the Load
         program.  (Load is discussed in Chapter 14.)  The syntax for
         both methods is identical and is shown below.


                :AKA_word substitution_string


         A colon(:) character marks the start of an AKA definition
         and AKA word.  AKA words are not case sensitive; "word" is
         equivalent to "WORD."  The first space or <Tab> character
         marks the end of the AKA word.  The remainder of the line is
         the substitution string.

         If the definition's AKA word is identical to an existing
         AKA, the existing AKA is replaced with the new definition.

         A definition's substitution string can include multiple
         commands, provided each command is separated by a
         semicolon(;).  Entering multiple commands per line is
         documented in Chapter 7.

         Anarkey performs a length check on each command specified in
         the substitution string.  If any single command exceeds 127
         characters, Anarkey will refuse to accept the definition.
         It will beep and position the cursor beneath the first
         character that exceeds the limit.

         AKAs cannot be nested.  In other words, if the substitution
         string contains the AKA word from another definition (that
         is, the AKA word is "nested" in the substitution string),
         when Anarkey performs the substitution operation, the nested
         AKA word is not replaced.

         The following line defines an AKA called "home" and a
         substitution string of "cd \mydir."


                :home cd \mydir


         If you enter the above AKA definition onto the input line
         and press <Enter>, Anarkey will save the AKA in it storage
         area.  If there is not enough room to save the definition,
         Anarkey beeps.

         To use an AKA, simply enter its AKA word onto the input
         line.  Using our example, typing "home" and <Enter> will
         execute the command "cd \mydir."

         It is important when entering AKAs that they be specified in
         the command-portion of the line.  The substitution operation
         is only performed on commands and program names and not on
         program arguments or parameters.  This is illustrated in the
         following two input lines.


                >home          Executes "cd \mydir"

                >cd home       Executes "cd home," not "cd cd \mydir"


         Any arguments following the AKA on the input line are
         appended to the substituted sting.  For example, take the
         following AKA definition.


                :d   dir


         Now if you enter "d *.exe" on the input line, Anarkey will
         expand it to "dir *.exe" before execution.   Notice that the
         "*.exe" argument was appended to the substitution string.

         Viewing AKAs

         The list of defined AKAs can be viewed at any time by
         pressing <Alt-F4>.  AKAs will be displayed one per line
         until the screen is full.  Press any key to see the next
         screen's worth of AKAs.  At the end of the displayed list,
         Anarkey will output the amount of space still available to
         store further AKA definitions.

         If AKAs have not been enabled via the -A command-line
         option, the <Alt-F4> key has no effect.

         The Anarkmd program also supports saving AKA definitions to
         a disk file suitable for processing by the Load program.
         This allows you to save your AKA definitions between
         computer sessions.  The Anarkmd program is discussed in
         Chapter 16.  Load is explained in Chapter 14.

         Undefining an AKA

         To undefine an AKA, simply specify the AKA word preceded by
         a colon(:).  Do not specify a substitution string.  For
         example, to undefine our sample AKA, enter the following
         line.


                :home


         Additionally, every AKA can be undefined in one fell swoop
         by pressing <Alt-X>.  This clears the entire AKA storage
         area so that no AKAs are defined.

         Parameter Fields

         All the AKAs shown so far are simple text substitutions
         where the AKA word is directly replaced by the substitution
         string.  However, substitution strings may contain something
         called a parameter field.  A parameter field is a special
         type of designation in the substitution string.  Parameter
         fields are specified by a leading percent sign(%) followed
         by a single-digit number from 1 through 9.  For example, %1,
         %2, %6 and %9 are all valid parameter fields.  The following
         is an AKA definition that uses parameter fields.


                :test   echo %1 %2 %3


         When Anarkey is processing an AKA and performing text
         substitution (that is, after you have entered and accepted a
         line), a parameter field is replaced with the corresponding
         argument taken from the input line.  For example, the %1
         parameter field is replaced with the AKA's first argument,
         %2 with the second and so on.

         Given our sample AKA above, entering the input line "test
         one two three" would result in the command "echo one two
         three" being executed.  The %1 parameter field in the
         substitution string is replaced with the first argument to
         "test," that is, "one."  The other two parameter fields and
         arguments are handled in the same manner.

         Now suppose we redefined our "test" AKA to the following.


                :test   echo %3 %2 %1


         Entering the same "test one two three" line would result in
         the execution of the command "echo three two one."  Notice
         the %3 parameter field was substituted with the third
         argument to "test," %2 with the second argument and %1 with
         the first.

         If a substitution string contains a parameter field, but the
         input line has no corresponding argument, the parameter
         field is replaced with an empty string.  In other words, the
         parameter field is deleted.  Thus, given the previous "test"
         AKA, the input line "test one" would execute "echo one."
         Notice that since there is no second or third argument, the
         %2 and %3 parameter fields are ignored.

         Conversely, if the AKA definition contains a parameter
         field, but the input line includes additional arguments, the
         extra arguments are ignored.  Thus, a line of "test one two
         three four"  converts to "echo three two one" and the extra
         "four" argument is ignored.  Notice that this is different
         than if there were no parameter fields specified in the
         definition.  Recall that without parameter fields, all
         arguments are appended to the end of the substitution string.

         Parameter fields provide the advantage of being able to
         position an argument in a specific place within the
         substitution string.  They can be used to create fairly
         powerful AKAs which approach the functionality of batch
         files, but execute much faster.

         Here is an example of an AKA definition that copies files to
         a specified drive.  The AKA accepts multiple drive
         specifications and each can include the DOS wildcard
         characters.  The syntax of the AKA is:


                MCOPY drive file_spec [file_spec ...]


         For example, you can enter "mcopy a: *.doc test.* *.com."
         The result will be that all files matching the *.doc, test.*
         and *.com specifications will be copied to the A: drive.
         Here is the AKA definition for this command.


         :mcopy   for %f in (%2 %3 %4 %5 %6 %7 %8 %9) do copy %f %1


         As you can see, the substitution string uses the DOS "for"
         command.  If you are unfamiliar with this command, refer to
         your DOS manual for details.  The "for" command is usually
         used in batch files, however, it can be used on the command
         line as well.

         When the input line "mcopy a: *.doc test.* *.com" is
         entered, the executed line after substitution is shown below.


                for %f in (*.doc test.* *.com) do copy %f a:


         When DOS executes the "for" command, the effect will be the
         same as executing the three commands "copy *.doc a:," "copy
         test.* a:" and "copy *.com a:."

         Summary

         In summary, this chapter documented how to work with AKAs
         and the following keystroke operation.


                 <Alt-F4>        View AKAs



         Chapter 6

         Filename Completion

         The average input line often includes a filename.  Many
         times the filename is prefaced by a path specification.  And
         all input lines include a program or command to execute.
         Because these items are entered so often, Anarkey provides
         functions to complete them for you automatically.  These
         completion operations are similar in concept to the line
         completion functions discussed in Chapter 4.  As you
         continue to learn Anarkey, it will become clear that
         entering most items on an input line requires only that you
         type one or two characters of the item and then let Anarkey
         do the rest.

         Completing Names

         Anarkey divides the completion of filenames into two
         categories: directory names and all other files.  The group
         "all other files" includes programs and "normal" files, such
         as text or data files; in other words, anything that is not
         a directory.  Although completing a directory name isn't
         much different from completing a filename, there are some
         minor differences.  These differences will be noted where
         applicable.  Unless stated otherwise, all operations
         described in the remainder of this chapter apply to name
         completions of all types.

         To complete a directory name, press <F7> or <Ctrl-D>.  To
         complete the name of any other type of file, press <F8> or
         <Ctrl-F>.  Any non-whitespace characters (e.g. blank or
         <Tab>) immediately preceding the cursor position are used to
         narrow down the list of possible completions.  For example,
         if the cursor followed the letter "d," Anarkey would
         complete the name using only those files starting with the
         letter "d."  The case of the letters is not important.  If
         no or a blank character precedes the cursor, Anarkey will
         match all files in the category (directory or otherwise).

         If Anarkey finds an existing file that could complete the
         filename, it enters it onto the input line.  The cursor
         position remains unchanged.  If the completed name is not
         the one you desire, press the appropriate completion key
         again and Anarkey will cycle through the list of possible
         completions.

         Once Anarkey has completed the filename, the cursor will
         still be at its original position, that is, somewhere in the
         middle of the completed name.  If you need to enter
         additional characters after the filename, the cursor will
         have to be moved.  This can be accomplished by pressing the
         <End> or <Right> arrow keys, but there is a faster way:
         simply type them in!  Anarkey will automatically move the
         cursor to the first position beyond the completed name if
         the first keystroke after a name completion is one of the
         following:


         Space          Backslash(\)            Colon(:)
         Slash(/)       Input redirection(<)    Semicolon(;)
         Asterisk(*)    Output redirection(>)   Equal sign(=)
         Plus sign(+)   Question mark(?)        Pipe character(|)
         Comma(,)       Dash(-)(only if -U active)


         After moving the cursor, the typed character is entered onto
         the input line.

         Note that the dash(-) character moves the cursor only if the
         -U option was specified on the Anarkey installation line.
         The -U option controls Anarkey's interpretation of the
         slash(/) and dash(-) characters as a path separator and
         switch (or option) specifier, respectively.  This topic is
         discussed in detail in Chapter 10 so don't worry about it
         for now.

         If any other character beside those listed above is typed
         following a completion operation, the character in entered
         onto the input line at the current cursor position.  This is
         useful in case you begin a completion operation only to
         discover there is a large number of possible completions.
         For example, you start completing all the files that start
         with the letter "c," but suddenly remember 75 files start
         with a "c."  Rather then cycle through them all until you
         hit upon the desired file, you can enter additional
         characters to narrow the completion possibilities down.

         When Anarkey completes the name of a program file, it does
         not include the file's extension when it enters the name on
         the input line.  Program names must have the file extension
         BAT, COM or EXE.

         When Anarkey searches for the completion to a "normal"
         filename, in other words, any file other than a program or
         directory, it ignores files with certain extensions.  A file
         using one of the following extensions will not be completed
         by Anarkey.


         .$$$           .BAK            .BIN            .COM
         .EXE           .TMP            .HEX            .LIB
         .OBJ           .OVR            .SYS


         These extensions are ignored because the files which use
         them are rarely entered on input lines.  Anarkey attempts to
         save you the trouble of cycling through these undesired
         files by ignoring them.  If you prefer that Anarkey not
         ignore files using the above extensions, you can specify the
         -X\ option on the installation command line.  Also, you can
         add additional extensions to the ignored list via the -X
         option.  Complete details will be covered in Chapter 11.

         Pop-Up Filename Completion Window

         A pop-up window that contains the entire list of completions
         can be displayed by pressing <Alt-F8> or <Alt-F>.  All file
         types, directories and others, are displayed in the window.
         From this window you can scroll through the list and select
         the desired filename using the keyboard or a mouse.  The
         file-completion window is identical to the history-buffer
         window in the way scrolling and selection are performed.
         Refer to the discussion of the history-buffer window in
         Chapter 4 or press the <F1> key with the file-completion
         window displayed to refresh your memory on the supported
         operations.

         Summary

         The following operations and their assigned keystrokes were
         discussed in this chapter.


                 <F7>            Complete directory name
                 <Ctrl-D>        Same as <F7>
                 <F8>            Complete program/file name
                 <Ctrl-F>        Same as <F8>
                 <Alt-F8>        Pop-up filename completion window
                 <Alt-F>         Same as <Alt-F8>



         Chapter 7

         Multiple Commands per Line

         In plain, vanilla DOS, you are allowed to enter only one
         command per input line.  With Anarkey, multiple commands can
         be included on a single input line.  Using multiple commands
         will reduce the number of line retrieval operations
         performed.  More importantly, multiple commands are
         extremely useful for AKA definitions.  An AKA that uses
         multiple commands is like a miniature batch file.

         Entering Multiple-Command Lines

         Multiple commands are separated on the input line by a
         semicolon(;).  When a line is accepted, Anarkey breaks it
         into separate commands and passes each one to the command
         processor for execution.  The semicolon separators are
         "eaten" by Anarkey and are not passed as part of the command.

         The following are examples of input lines that contain
         multiple commands.


                cd \temp;dir
                md \newdir;cd \newdir;copy \olddir\*.* \newdir
                edit letter.doc;print letter.doc


         There are two situations where the semicolon character is
         not interpreted as a command separator: (1) the semicolon is
         the very last character on the input line and (2) any
         semicolon used in a PATH, PROMPT or SET command.

         If you wish to include a semicolon in a command, specify two
         consecutive semicolons.  Anarkey will convert them to a
         single semicolon character before passing the command along
         for execution.

         The following input lines use semicolon characters as part
         of the command rather than as separators.


                masm anarkey;
                path=c:\dos;d:\global;c:\masm
                prnt doc1.txt;;doc2.txt


         Multiple commands can be disabled on a per-line or permanent
         basis.  With multiple commands disabled, the semicolon
         character is never interpreted as a command separator.  To
         disable multiple commands on the current input line, press
         <F10> or <Ctrl-R>.  The -O installation option will disable
         multiple commands for the entire Anarkey session.  (However,
         note that multiple commands are still allowed in AKA
         definitions, even with the -O option.)

         Length Considerations

         Anarkey input lines can be up to 255 characters in length.
         However, individual commands within the line are restricted
         to the maximum length specified by the command processor in
         service.  The standard DOS COMMAND.COM program prohibits
         commands composed of more than 127 characters.

         If you attempt to accept an input line that contains a
         command whose length exceeds the maximum allowed by the
         command processor, Anarkey will beep and position the cursor
         beneath the first character that exceeds the limit.

         You can also have Anarkey check the length of your commands
         before you accept the line by pressing <F2>.  If any
         commands exceed the maximum, the cursor will be positioned
         at the first character beyond the limit.  Anarkey will do
         nothing if all commands in the line are within bounds.

         Miscellaneous Considerations

         There are a few minor characteristics of multiple-command
         lines that must be mentioned.

         First, if the Load program (discussed in Chapter 14) is
         included on a multiple-command input line, it must be the
         last command in the line.  Any commands following Load will
         not be executed.

         Second, many programs allow you to temporarily exit the
         program and shell to DOS.  Normally, Anarkey would process
         the input line while in this temporary DOS shell.  However,
         if the program that was temporarily exited was invoked from
         a multiple-command line, Anarkey will disable itself while
         in the DOS shell.  This is done to prevent any subsequent
         commands in the original input line from being executed
         while in the temporary shell.  The following input line
         illustrates this situation.


                cd \work;progname;cd \home


         Imagine you were to temporarily shell to DOS while executing
         "progname."  If Anarkey was active, it would execute the
         next command in the line, "cd \home."  However, that command
         should not really be executed until "progname" has
         completed.  To achieve this, Anarkey disables itself while
         the temporary DOS shell is in effect.  Once "progname"
         terminates, Anarkey automatically enables itself and
         executes "cd \home."

         Note the automatic disabling is only performed when
         processing multiple-command lines.  Normally, Anarkey is
         active when temporarily exiting a program to DOS.

         Summary

         In summary, this chapter described the functions assigned to
         the following keys.


                 <F2>            Check command lengths
                 <F10>           Disable multiple commands on current
                                 line
                 <Ctrl-R>        Same as <F10>


         Chapter 8

         Editing Environment Variables

         In addition to retrieving past lines from the history
         buffer, Anarkey can retrieve environment variables and enter
         their values onto the input line.  Once retrieved, the value
         can be modified using the standard editing facilities.  This
         is particularly useful for those times when you need to add
         a new directory to the end of the PATH setting.

         To retrieve the value of an environment variable, enter the
         "SET" command followed by at least one space and then zero
         or more characters of the desired variable's name.  Then
         press the <F9> or <Ctrl-E> key.  If one or more characters
         of the name are entered, Anarkey searches for an environment
         variable to complete the name.  You can cycle through all
         matching completions by repeatedly pressing <F9> or
         <Ctrl-E>.  If no characters of the name are entered, Anarkey
         cycles through all the defined environment variables.

         When an environment variable is retrieved, its complete name
         is entered on the input line followed by an equal sign and
         its value.  The cursor is positioned beneath the first
         character after the equal sign.

         Normally, the PATH and PROMPT environment variables do not
         require that they be preceded by the SET command.  Anarkey
         will still retrieve the values of PATH and PROMPT even if
         they are not in an explicit SET command.  However, their
         complete variable names must be entered on the input line
         before pressing <F9> or <Ctrl-E>; Anarkey will not complete
         the names of PATH and PROMPT if they are not preceded by the
         SET command.

         For example, enter the following input line and press <F9>
         to retrieve the value of the PATH variable.  (The underscore
         represents the cursor position.)


                >path_


         Pop-Up Environment Window

         A full-screen pop-up window containing an alphabetized list
         of all environment variables can be displayed by pressing
         <Alt-F9> or <Alt-E>.  Like all the other Anarkey pop-up
         windows, Anarkmd actually performs the window operation, so
         be sure the Anarkmd program is in either the current
         directory or a directory along the PATH.

         The environment window is similar to the other windows
         discussed to this point.  The current variable is displayed
         in reverse video.  Other variables in the list can be made
         current by using the <Up> and <Down> arrow keys.  If more
         variables are defined than can fit in one window, the window
         can be scrolled using the keyboard or mouse.  Selecting a
         variable for retrieval is performed by making the variable
         current and pressing <Enter>.  The mouse can also be used to
         select the desired variable.  If you need help on using the
         environment window, press <F1> to display a
         context-sensitive help screen.  Refer to Chapter 4 and the
         discussion of the history-buffer window for complete details
         about the recognized window keystrokes and mouse actions.

         Summary

         In summary, the environment variable functions and
         keystrokes described in this chapter are listed below.


                 <F9>            Retrieve environment variable value
                 <Ctrl-E>        Same as <F9>
                 <Alt-F9>        Pop-up environment window
                 <Alt-E>         Same as <Alt-F9>


         Chapter 9

         The MegaKey and MenuKey

         Throughout this manual, you have learned about many
         keystrokes that invoke individual Anarkey functions.  In
         this chapter, you will learn two new keystrokes which
         combine the operations of several of those functions.  The
         MegaKey and MenuKey are two of Anarkey's most potent
         strengths.  With these two simple keys, you gain access to
         all of Anarkey's completion, line-retrieval and window
         functions.

         The MegaKey

         In the previous chapters, you learned about several separate
         Anarkey functions which retrieve and complete items on input
         lines.  Each of those functions and their assigned
         keystrokes are listed below.


                 <F5>, <Ctrl-K>          Retrieve line from history
                                         buffer
                 <F7>, <Ctrl-D>          Complete directory name
                 <F8>, <Ctrl-F>          Complete filename
                 <F9>, <Ctrl-E>          Retrieve environment variable


         Rather than force you to remember all those keystrokes and
         have to think about which one to press at a given time,
         Anarkey combines them all into a single MegaKey.  By
         default, the MegaKey is assigned to <Tab>.  When you press
         <Tab>, Anarkey determines on its own the type of completion
         or retrieval operation you desire and does it for you.  Of
         course, you can still press any of the keys listed above,
         but in most instances, it will be easier to just press <Tab>
         and let Anarkey do all the work.

         Like all the other retrieval and completion functions, the
         MegaKey can be pressed repeatedly to cycle through the list
         of possibilities.

         The MegaKey will correctly determine the desired type of
         operation an amazingly high percentage of the time.
         However, you may occasionally have to cycle through some
         unwanted completions before getting to the one you want.

         The MenuKey

         The MenuKey is a close cousin of the MegaKey.  Like the
         MegaKey, it combines several operations to a single key.
         The MenuKey can be thought of as a "front-end" to all of
         Anarkey's pop-up window functions listed below.


                 <Alt-F1>, <Alt-H>       Pop-up help window
                 <Alt-F5>, <Alt-K>       Pop-up line retrieval window
                 <Alt-F8>, <Alt-F>       Pop-up filename completion
                                         window
                 <Alt-F9>, <Alt-E>       Pop-up environment window


         The MenuKey is assigned to the <Alt-Tab> and <Shift-Tab>
         keys.  However, be aware that the <Alt-Tab> key is not
         normally recognized on DOS systems.  If your system has an
         enhanced, 101-key keyboard (i.e. a keyboard with <F11> and
         <F12> keys), you can use the 101-Keys program to allow DOS
         to recognize <Alt-Tab> and many other keystrokes.  101-Keys
         is discussed in Chapter 15.

         Like all the other Anarkey window functions, be sure the
         Anarkmd program is located in either the current directory
         or a directory along the PATH before pressing the MenuKey.

         The MenuKey displays a pop-up menu.  Each of the above
         operations is listed in the menu.  In addition, the item
         "Return to Command Line" is included in the menu.  Using the
         selection techniques discussed for windows in previous
         chapters, you select a menu item via the keyboard or a
         mouse.  The operation you select is then executed.

         For example, if the help window menu item is selected, the
         pop-up help window is displayed onscreen.  The effect is the
         same as if you had pressed the <Alt-F1> key to display the
         window, but now you only have to remember a single key, the
         MenuKey, to display any of the supported Anarkey windows.

         Summary

         Despite its brief length, this chapter described Anarkey's
         most powerful functions, the MegaKey and MenuKey.  These two
         functions are great leaps toward a state of total Anarkey, a
         state without keystrokes.  Learn them and your life at the
         command prompt will become a pleasure.


                 <Tab>           MegaKey
                 <Alt-Tab>       MenuKey
                 <Shift-Tab>     Same as <Alt-Tab>


         Chapter 10

         Unix Switchar Conventions

         The Unix operating system separates directory names in a
         path specification with a slash(/) character rather than
         DOS's backslash(\).  Also, a Unix command-line option, often
         called a switch, is always preceded by a dash(-) while DOS
         uses a slash for switches.  The character used by an
         operating system to specify program switches is referred to
         as the switchar (pronounced "switch-char").

         Many people prefer the Unix switchar convention over the DOS
         method.  Interestingly, early DOS versions supported an
         undocumented system function which caused the COMMAND.COM
         internal commands, like COPY and DIR, to recognize the Unix
         switchar conventions.  There are several public domain
         programs available that use this undocumented function to
         alter the DOS switchar.  When run, they allow the user to
         enter a dash before each command option and slashes in path
         specifications.

         Unfortunately, these switchar programs suffer from several
         difficulties.  First, they only effect internal COMMAND.COM
         commands and not external or third-party programs, like
         XCOPY.  Second, they have some strange side-effects which
         can make them an adventure to use at times.  And finally,
         both the compatibility box of OS/2 and DOS versions since
         4.00 do not implement the undocumented switchar function,
         making it impossible to change the switch character in these
         newer environments.

         Anarkey provides complete Unix switchar support with none of
         the problems inherent in the switchar programs.  All
         programs, whether internal to COMMAND.COM or external, will
         recognize Unix switchar conventions.  Further, Anarkey
         implements the switchar support in a consistent manner so
         there are no undesirable side effects.  Also, Anarkey fills
         the void left by the new operating systems which do not
         allow modification of the system's switchar.

         By default, Anarkey's Unix switchar support is disabled.  It
         is enabled by including the -U option on Anarkey's
         command-line.  This causes Anarkey to modify certain
         characters entered on an input line.  Generally, the
         characters used in the Unix switchar convention get
         converted to those used in DOS.  The result is that a line
         entered using the Unix convention is translated to its DOS
         equivalent.  This translation is invisible to the user.

         Only two characters are potentially modified by the switchar
         translation.  They are shown in the table below along with
         the character to which each is converted.  Note: The
         backslash character is included in the table to emphasize
         that it can still be used as a path separator even with Unix
         switchar support active.  Both slashes and backslashes are
         valid path separators.


         Character on input line    Converted to
         -----------------------    ------------
                   /                     \
                   -                     / (unless used in file name)
                   \                     \ (unchanged)


         The character translation Anarkey performs is demonstrated
         in the following sample input lines.


         Input Line                     Translated Line
         -------------------------      -------------------------
         dir -p                         dir /p
         copy a:/dos/*.com              copy a:\dos\*.com
         c:/dos/xcopy a:/*.* c: -s      c:\dos\xcopy a:\*.* c: /s


         If you wish to type a slash or dash character and not have
         it translated, enter the character twice.  For example, to
         execute the line "dir /p," you can enter "dir //p" (or "dir
         -p" as shown in the previous table).

         In DOS, the dash character is often used in filenames, as in
         "101-Keys."  If Anarkey were to translate dashes used in
         filenames, the resulting line would be incorrect.  For
         example, the line "copy 101-keys.com a:" would be converted
         to "copy 101/keys.com a:."  Fortunately, Anarkey does not
         translate dash characters used in filenames.  Anarkey
         determines the dash character's context by checking the
         character that immediately precedes the dash.  If the
         character is not a blank space, the dash is assumed to be
         part of a filename.  Otherwise, it is determined the dash is
         a switchar and it gets translated to a slash character.

         Unix-Type Programs

         Some third-party programs already support the Unix switchar
         convention.  Character translation can cause a problem for
         these programs when they receive a line using the DOS syntax
         rather than the expected Unix syntax.  For example, a
         program that recognizes Unix conventions will not understand
         an input line such as "sort /dos/text.doc -b" after Anarkey
         translates it to "sort \dos\text.doc /b."  Such programs
         need to receive untranslated input lines.

         Since Unix-switchar translation must be applied on a
         program-by-program basis, you must tell Anarkey which
         programs already recognize the Unix convention.  Then when
         you execute that program in the future, Anarkey will not
         perform a translation on the program's arguments.

         To inform Anarkey that a program recognizes the Unix
         switchar syntax, enter the program's name on the input line
         preceded by an exclamation point(!).  For example, to
         prevent translations from occurring on the SORT program's
         input line, enter the command "!sort."

         Depending upon the programs you typically run, you may have
         a large number of Unix-type program names to enter.  To save
         you from having to enter each program every time you run
         your computer, you can store the list of program names in a
         text file and have the Load program send it to Anarkey upon
         program start-up.  Additionally, the Anarkmd program can
         create the text file of program names for you.  These
         capabilities of Load and Anarkmd are discussed in Chapters
         14 and 16, respectively.

         When Anarkey receives the name of a Unix-type program, it
         stores the name in its Unix buffer.  The Unix buffer is an
         area of memory Anarkey allocates during installation.  By
         default, Anarkey does not support Unix switchar usage and
         therefore, no memory is allocated for the Unix buffer.  When
         the -U option is specified during installation, Anarkey
         allocates a 25-character Unix buffer.  If more space is
         required to hold Unix-type program names, the desired size
         of the Unix buffer can be specified by appending it to the
         end of the -U option.  For example, to enable Unix switchar
         translations and allocate a Unix buffer of 100 characters,
         include -U100 on the Anarkey installation line.  The -U
         option is more fully described in Chapter 11.

         Note: The Anarkmd program already recognizes Unix switchar
         syntax, therefore, it should always be stored in the Unix
         buffer.  Because Anarkey makes extensive use of Anarkmd
         (e.g. to display the various pop-up windows), when the -U
         option is specified, Anarkey automatically saves the Anarkmd
         program in the Unix buffer.  This preloading of the buffer
         is done to guarantee Anarkmd's proper execution and save you
         the trouble of storing it yourself.

         If there is not enough room to store a program's name in the
         Unix buffer, Anarkey will beep.

         A program can be removed from the Unix buffer by preceding
         its name on the input line with two exclamation points.  For
         example, "!!sort" removes the SORT program from the Unix
         buffer.

         The entire list of programs stored in the Unix buffer can be
         displayed by pressing <Shift-F4>.  Each output line will
         contain one program name preceded by an exclamation point.
         If all programs cannot be displayed on a single screen,
         output is paused between screens.  Press any key to display
         the next screen of names.

         Note that when a program is stored in the Unix buffer, only
         the program's arguments will remain untranslated; all other
         items on the input line, including the program's path
         specification, redirected filenames and piped commands, are
         still translated.  These are all demonstrated in the
         following input line and the resulting translated line.


         Input line:
         c:/bin/sort -b >f:/log.txt | echo -test --the /translations

         Translated line:
         c:\bin\sort -b >f:\log.txt | echo /test -the \translations


         As this example illustrates, Anarkey intelligently parses
         the input line and translates only the appropriate
         characters.

         Summary

         This chapter has described Anarkey's Unix switchar support
         and the following related function.


                 <Alt-F4>        Display Unix buffer



         Chapter 11

         Anarkey Installation Options

         Anarkey recognizes a large assortment of installation
         options which can be used to configure Anarkey to your
         preferences.

         Options are specified on the Anarkey command-line during
         installation.  An option must be preceded by a dash(-) or
         slash(/) character.  Options may be in upper or lowercase
         and may appear on the command line in any order.  Each
         option must be separated by at least one space.

         A sample Anarkey installation line is shown below.


                anarkey -f -h1000 -io


         All of Anarkey's options are described in the remainder of
         this chapter.


         Enable AKA Support

                 -An     Enable AKA support and allocate memory to
                         store n characters

         By default, AKA support is disabled to save memory.  The -A
         option enables AKA support.  The option also specifies the
         amount of memory Anarkey should reserve to store AKA
         definitions.  This number must be appended to the -A option;
         no spaces may separate them.  For example, the following
         input line enables AKA support and allocates 400 characters
         for AKA definitions.


                anarkey -a400


         The combined memory allocated for AKA definitions, the
         history buffer (-H option) and the Unix buffer (-U) may not
         exceed 50,000 characters.  Anarkey will automatically reduce
         the memory allocated, first for Unix definitions and, if
         necessary, AKA definitions if this limit is exceeded.


         Cursor Options

                 -C      Never change cursor shape
                 -CN     Display non-blinking cursor
                 -CT     Display thick underscore cursor

         Anarkey recognizes several options to configure management
         of the cursor.

         The -C option instructs Anarkey to never alter the cursor's
         shape.  Normally, Anarkey will set the cursor shape based
         upon the input mode.

         The -CN option causes Anarkey to display a non-blinking
         cursor whenever possible.  When the cursor is beneath a
         space character, the cursor will not blink.  When beneath
         any other character, the cursor will still blink.

         Some EGA video cards will continue to display a blinking
         cursor despite the presence of the -CN option.  The only
         solution to this is to change video cards (preferably to a
         VGA or better).

         If you pop-up a resident program when the non-blinking
         cursor is active, the cursor may not be visible in the
         popped-up program.  This is a shortcoming of the resident
         program.

         The -C and -CN options cannot both be included on the
         command line.  If they are, the -C option overrides the -CN.

         The -CT option instructs Anarkey to display a thick
         underscore cursor as opposed to its normal "thin"
         underscore.  This option may be desired if the thin
         underscore is difficult to see on your display monitor.

         The -C and -CT options cannot both be included on the
         command line.  If they are, the -C option overrides the -CN.


         Use Expanded Memory

                 -E      Load Anarkey in expanded memory

         Anarkey can store most of its code and data, including the
         history buffer, AKA definitions and Unix program names, in
         expanded memory.  When this occurs, Anarkey takes only about
         1K of DOS memory.  To load Anarkey in expanded memory,
         include the -E option on the installation line.

         All versions of the Lotus-Intel-Microsoft Expanded Memory
         Specification (LIM EMS) are supported, including versions
         3.2 and 4.0.  If a valid expanded memory manager is not
         installed or there is not enough expanded memory available
         to load Anarkey, an error message will be displayed and
         Anarkey will install itself in conventional memory.


         Full History Buffer Disclosure

                 -F      Suppress line movement in history buffer

         When a line is retrieved from the history buffer and
         immediately accepted, Anarkey normally moves the line to the
         end of the buffer to prevent the storage of duplicate lines.
         If you prefer to maintain an log of input lines in the exact
         order in which they were entered, specify the -F option
         during program installation.  The -F option suppresses line
         movement in the history buffer.  Each input line will be
         entered at the bottom of the buffer.


         History Buffer Size

                 -Hn     Reserve n bytes of memory for history buffer

         The default history buffer size is 500 characters.  Using
         the -H option, the buffer size can be set to any value from
         255 through 50,000.  The size must be appended to the -H
         option with no spaces between them.  For example, the
         following line allocates 10,000 bytes for the history
         buffer.  Notice that commas should not be included in the
         option.


                anarkey -h10000


         The combined memory allocated to the history buffer, AKA
         definitions (-A option) and the Unix buffer (-U) cannot
         exceed 50,000 bytes.  If this limit is exceeded, Anarkey
         will automatically reduce the Unix buffer size and, if
         necessary, the AKA-definition space.


         Input Mode Options

                 -II     Start Anarkey in insert mode (default)
                 -IO     Start Anarkey in overwrite mode
                 F       Optional modifier to force input mode at
                         start of each line

         By default, Anarkey first starts up in insert mode.  This is
         the same as specifying the -II option on the installation
         line.  Normally, Anarkey remains in the current input mode
         until the <Ins> key toggles the mode.  If you specify the
         -IIF option, Anarkey will force itself into insert mode
         every time it begins a new input line.

         The -IO option instructs Anarkey to begin operation in
         overwrite mode.  -IOF forces Anarkey into overwrite mode for
         every new input line.


         Display Memory Usage

                 -M      Display Anarkey memory usage

         The -M installation option instructs Anarkey to calculate
         and display the total amount of memory required for the
         specified configuration.  Anarkey takes into account the
         size of any buffers and whether or not expanded memory is to
         be used when it performs its calculation.

         When -M is specified, Anarkey does not install itself and
         remain resident.  It only calculates its memory requirement
         and displays the information.

         Be aware that expanded memory is allocated in 16K chunks.
         Even if only a single byte of expanded memory is needed, an
         entire 16K block must be reserved.  This is a characteristic
         of the LIM EMS specification.

         To help you use expanded memory wisely, Anarkey displays the
         amount of reserved, but unused, expanded memory along with
         the amount that is in use.  Any unused memory can be
         allocated to the history buffer, AKA definitions and/or Unix
         buffer without any additional memory allocation occuring.
         In effect, this is free memory.

         Neither expanded memory nor an expanded memory manager need
         be present to include both the -E and -M options on the
         installation line.

          Note: The memory requirements output by Anarkey indicate
         the amount of memory Anarkey will request from DOS before
         going resident.  In addition to this value, DOS will
         allocate a block of memory large enough to store a copy of
         every environment variable defined at that moment.  You can
         reduce the memory requirements of Anarkey (and any TSR
         program) by installing it before defining many environment
         variables.

         The sample installation line shown below instructs Anarkey
         to calculate how much memory it will need when configured
         with a 1000-character history buffer and 400 characters
         allocated for AKA definitions.


                anarkey -a400 -h1000 -m


         Enable Alternative Mouse Interface

                 -MA     Use alternative mouse interface in pop-up
                         windows

         Anarkey supports two different mouse interfaces when
         processing a pop-up window.  The default interface has been
         described in the earlier chapters of this manual.  The
         alternative interface is discussed in Appendix I.  To enable
         the alternative mouse interface, include the -MA option on
         Anarkey's command-line during installation.


         Disable Multiple-Command Lines

                 -O      Disable multiple-command lines

         Anarkey normally allows multiple commands to be entered on a
         single input line as documented in Chapter 7.  The -O option
         disables multiple-command lines entered on the input line.
         Multiple commands are still allowed in AKA definitions.

         Multiple commands can also be repressed on a per-line basis
         by pressing <F10> or <Ctrl-R>.  Refer to Chapter 7 for
         additional information on multiple-command lines.


         Anarkey Process Number

                 -Pn     Set Anarkey process number to n

         During installation, Anarkey assigns itself a default
         process number.  This process number is used to determine
         whether or not Anarkey is already resident.  This basically
         prevents the loading of duplicate copies of Anarkey.

         There are two instances when you will want to assign Anarkey
         a new process number: (1) when another TSR program uses
         Anarkey's default number and (2) when you wish to purposely
         load multiple copies of Anarkey.  The first scenario is
         possible, but highly unlikely.  It will make itself known by
         Anarkey's failure to install even one copy of itself and
         report that it is already resident.

         You may wish to purposely install multiple copies of Anarkey
         if you use DesqView or Microsoft Windows in their non-386
         modes.  Instructions on how to use Anarkey in these
         environments are included in Chapter 12.

         When you assign a new process number to Anarkey, the number
         is appended to the -P option with no spaces between them.
         Valid process numbers are 0 through 63.  By default, Anarkey
         uses process number 35.

         Be aware that if you change Anarkey's process number, you
         will have to specify the new process number on the Load and
         Anarkmd program's command lines every time you run them.
         This is because those programs require Anarkey to be
         installed in order to perform their tasks and the process
         number is needed to determine Anarkey installation.  The
         Load and Anarkmd programs are discussed in Chapters 14 and
         16, respectively.

         The following line installs Anarkey with the process number
         14.


                anarkey -p14


         Note: Never use the -P option if running the TSR version of
         the QEdit text editor from SemWare.  QEdit TSR contains
         dedicated Anarkey support which requires Anarkey to use its
         default process number.  This is only applicable to the TSR
         version of QEdit and not other QEdit implementations.


         Quiet Mode

                 -Q      Run in quiet mode

         Anarkey will occasionally sound the system bell, for
         instance, after cycling through the list of possible
         filename or line completions.  To suppress these beeps and
         run in quiet mode, include the -Q option on the installation
         line.  However, even in quiet mode, Anarkey still beeps in
         error situations where no other form of notification is
         provided.  Such situations are when an AKA or Unix program
         name is defined, but there is not enough memory left in the
         respective buffer to store it.


         Suppress Line Redisplay

                 -R      Do not redisplay accepted lines

         When an input line is accepted, Anarkey normally redisplays
         the line onscreen so as to allow any redirection to the
         printer to occur.  (Redirection to the printer is
         implemented in DOS by pressing <Ctrl-P>.  Refer to your DOS
         manual for further details.)

         This redisplay is annoying when a voicebox is connected to
         the system because the user hears each input line twice.  To
         suppress line redisplay, include the -R option on the
         installation line.  However, be aware that doing so prevents
         input-line printer redirection from occurring.


         History Buffer Minimum Line Length

                 -Sn     Save input lines at least n characters in
                         length to history buffer

         By default, Anarkey saves all non-empty lines in the history
         buffer.  However, very short lines of one or two characters
         are probably easier to retype than to retrieve from the
         buffer.  Rather than clutter the history buffer with these
         short lines, they can be excluded from the buffer via the -S
         option.

         Appended to the -S option must be the input line's minimum
         length for Anarkey to store it in the buffer.  No spaces can
         separate the -S from the length value.

         For example, the following line instructs Anarkey to store
         only lines of three or more characters in the history buffer.


                anarkey -s3


         Unix Switchar Support

                 -U      Enable Unix switchar support
                 -Un     Enable Unix switchar support, allocate Unix
                         buffer of n characters
                 -US     Translate slash character(/) only, leave
                         dash character(-) unmodified

         The various -U options provide levels of support for the
         Unix switchar conventions.  Details about this topic are
         discussed in Chapter 10.

         The -U option enables Unix switchar support and allocates a
         Unix buffer of 25 characters.

         The -Un option also enables Unix switchar support, but the
         size of the Unix buffer is specified immediately after the
         option.  No spaces may separate the -U from the buffer size.

         Buffer size is specified in number of characters and can be
         any value up to 50,000.  Note however, that the combined
         memory allocated for the history buffer, AKA definitions and
         Unix buffer cannot exceed 50,000 bytes.  If it does, Anarkey
         will automatically reduce the size of the Unix buffer and,
         if necessary, the AKA storage area to meet the limit.

         The -US option instructs Anarkey to convert any slash(/)
         characters on the input line to backslashes(\).  Dash
         characters are left unmodified.  In effect, this allows
         slashes to be used as a path separator in filenames.

         The -US option is leftover from earlier versions of Anarkey
         that did not provide the extensive Unix switchar support
         found in the current version.  Even though it is still
         supported, the comprehensive Unix support described in
         Chapter 10 is preferable to the limited support provided by
         the -US option.

         The following command line installs Anarkey with a
         150-character Unix buffer.


                anarkey -u150


         Ignored File Extensions

                 -X\     Do not ignore any file extensions
                 -Xext   Ignore files with ext extension

         Anarkey usually ignores files with certain extensions when
         it is choosing a filename completion.  This operation is
         described in Chapter 6.

         The -X\ option instructs Anarkey to not ignore any file
         extensions when completing a filename.  In effect, this
         clears the list of ignored file extensions.

         Additional extensions can be added to the list of ignored
         extensions by specifying them with the -X option.  Append
         the extension, with no intervening spaces, to the -X option.
         The DOS wildcard characters '?' and '*' are allowed in the
         extension.  The Anarkey installation line may contain up to
         six (6) -X options.

         The following line adds the extensions .BAT and .Q* to the
         ignored-extensions list.


                anarkey -xbat -xq*


         Both the -X\ and -Xext options may be specified on the same
         installation line.  The -X\ option clears the default
         ignored-extensions list.  Any -Xext options after -X\ are
         then added to the list.

         The next line instructs Anarkey to ignore only files with a
         .TXT extension.


                anarkey -x\ -xtxt



         Chapter 12

         Microsoft Windows and DesqView

         Anarkey is compatible with the Microsoft Windows and
         Quarterdeck DesqView environments.  Important considerations
         when running each of these programs are discussed in this
         chapter.

         Microsoft Windows

         Anarkey contains dedicated support for Microsoft Windows
         v3.0 and later.  Anarkey runs in a DOS session with Windows
         operating in any of its modes (real, standard and
         386-enhanced).

         When running Windows in real or standard modes, install
         Anarkey in each DOS session after beginning the session.
         Anarkey can already be installed when you start Windows, but
         that copy of it will be ignored while in Windows, even in a
         Windows DOS session.  When you terminate a DOS session by
         typing "exit," that session's copy of Anarkey is
         automatically removed from memory.

         Things are quite a bit different when running Windows in its
         386-enhanced mode.  Anarkey is aware of the Windows 386 mode
         and provides special support for each open DOS session.

         However, if you are going to run Windows in 386 mode,
         Anarkey must not be using expanded memory.  This means do
         not include the -E option on the Anarkey installation line.
         If Anarkey is using expanded memory and you attempt to
         execute Windows in 386 mode, Anarkey will terminate the
         Windows session and display an error message.  Either run
         Windows in another mode or reinstall Anarkey without the -E
         option.

         When running Windows in 386 mode, install Anarkey before
         starting Windows.  When Windows begins, a snapshot is taken
         of Anarkey's current status, including the history buffer
         contents, AKA definitions and Unix program names.  Then
         every time a new DOS session is opened under Windows, it is
         initialized to this saved status.  There is no need to
         reinstall Anarkey in each DOS session; it is installed and
         initialized automatically.

         Multiple DOS sessions can be open simultaneously and Anarkey
         will operate in each one.  However, each session maintains
         its own separate copy of data, including history buffer and
         AKA definitions.  For example, if you enter an input line in
         one DOS session, attempting to retrieve it from another
         session will fail because the line was saved in the other
         session's history buffer.  This is also true for AKA
         definitions and the Unix buffer.  Thus, it is a good idea to
         perform all buffer initializations and AKA definitions
         before starting Windows.

         When a DOS session is terminated, its copy of Anarkey is
         automatically removed from memory.

         DesqView

         Anarkey is compatible with DesqView and DesqView 386 and can
         run in a DOS window in either environment.  As far as Anarkey
         is concerned, there is no difference between DesqView and
         DesqView 386; the remainder of this discussion applies to both
         environments.

         When a DesqView DOS window is opened, Anarkey will not be
         active within it, even if Anarkey was loaded prior to running
         DesqView. A copy of Anarkey must be installed in each DOS
         window for it to be active.

         If Anarkey was not installed prior to running DesqView, it can
         be installed in multiple DOS windows without specifying any
         special options. When a DOS window is closed, its copy of
         Anarkey is removed from memory automatically.

         If you want Anarkey active outside of DesqView *and* in each
         DesqView DOS window, a little more work (but only a little) is
         necessary.  Anarkey stills needs to be installed separately in
         each DOS window.  In other words, multiple copies of Anarkey
         are installed into memory.

         It is useful to categorize these multiple copies into two
         groups: copies loaded in DesqView DOS windows and the single
         copy loaded outside DesqView. One of these groups must use the
         -P option when installing Anarkey.  The -P option assigns a
         process number to Anarkey which allows multiple copies of it to
         be installed.  Appended to -P must be the assigned process
         number, for example, -P1.  Refer to Chapter 11, page 38 of the
         "Anarkey User Manual" for more information concerning the -P
         option.

         This is most easily understood by an example.  Say the Anarkey
         copy outside of DesqView was installed without the -P option.
         Then all Anarkey copies loaded within DesqView DOS windows must
         be installed with -P.  The process number specified with -P can
         be the same for each DOS window, for example, you can use -P1
         in each window.  This is handy because it allows you to use the
         same initialization file for each DOS window.

         Conversely, say the Anarkey copy outside DesqView was installed
         with -P. Then the Anarkey copies loaded within DOS windows do
         not need -P options. It all breaks down to the two groups:
         Anarkey copies installed outside DesqView and those installed
         inside DesqView.  One group must use -P options, the other does
         not.



         Chapter 13

         Anarked, the Anarkey Keystroke Editor

         Anarked allows you to change Anarkey's default key
         assignments.  For example, if you want to display the help
         window by pressing <F1> instead of the default <Alt-F1>,
         Anarked lets you do so.  Any Anarkey keystroke, except those
         used during processing of a pop-up window, may be reassigned
         with Anarked.

         Anarked modifies the ANARKEY.COM program file.  Therefore,
         new key assignments made with Anarked are not active until
         you run the modified Anarkey program.

         Running Anarked

         Execute Anarked from the DOS command prompt.  When executed,
         Anarked prompts for the specification of the ANARKEY.COM
         program to process.  If ANARKEY.COM is not in the current
         directory, its location must be specified.  A default spec
         is displayed in [] brackets.  To accept the default, press
         <Enter>.  Otherwise, type the appropriate filename and press
         <Enter>.

         Anarked verifies that the entered filename is a valid
         ANARKEY.COM program file.  If it is not, Anarked refuses to
         accept it and prompts you for a new file spec.

         Anarked recognizes one optional command-line argument, -U.
         -U is used if you are upgrading from a previous version of
         Anarkey.  It allows you to carry over key assignments from
         one version to another, saving you from assigning them again.

         When -U is specified, Anarked prompts for two file
         specifications: (1) the old ANARKEY.COM file and (2) the new
         ANARKEY.COM file to receive the transferred key assignments.
         Again, Anarked checks both files for validity before
         agreeing to process them.  If both files are valid Anarkey
         programs, the key assignments of the first program spec are
         copied to the second spec.

         Occasionally, a new release of Anarkey adds new functions
         not available in the previous version.  When upgrading with
         -U, the default key assignments to all new functions are
         cleared so the new functions are not assigned to any keys.
         This is done to prevent the possibility of conflicting key
         assignments between the new version and the modified, older
         version.  When Anarked begins processing, it displays a list
         all new functions added to the new version.  You will have
         to assign keys to those functions if you wish to use them.
         Note: This requirement is only necessary when upgrading with
         the -U option.

         After all requested input files have been entered, Anarked
         prompts for the name of the output file.  Any changes made
         during the forthcoming Anarked session will be saved in this
         output file.  A default filename is displayed within []
         brackets.  Press <Enter> to accept the default or enter
         another filename.

         With all input and output files specified, Anarked enters
         edit mode where Anarkey key assignments are modified.

         Anarked Edit Mode

         Anarkey key assignments are modified in Anarked's edit mode.
         In edit mode, a full-screen window is displayed which lists
         several Anarkey functions and their current key assignments.

         Each line in the window contains one Anarkey function.  The
         function's description is displayed on the left half of the
         line.  Alongside the description are two columns which
         display the function's current key assignments.  Key
         assignments are surrounded by <> brackets, as in <F1>.  If
         no key is assigned to the function, empty <> brackets are
         displayed.  Each function may have a maximum of two keys
         assigned to it.

         Anarkey's functions are spread over several windows.  You
         can view the next window by pressing <PgDn>.  Press <PgUp>
         to view the previous window.

         One key assignment in the window is displayed in reverse
         video (i.e. black characters on a white background) and is
         referred to as the current key assignment.  Other
         assignments in the window can be made current by pressing
         the <Up>, <Down>, <Left> and <Right> arrow keys.

         Key assignments are modified by first making the assignment
         you wish to modify the current key assignment.  Then press
         the key sequence you wish to assign to the function.  For
         example, to change the help window's key assignment from
         <Alt-F1> to <F1>, use the <PgUp>, <PgDn> and arrow keys to
         make the <Alt-F1> field the current key assignment.  Then
         press <F1>.  The new key assignment replaces any previous
         assignment.

         Nearly any keystroke recognized by DOS can be assigned to an
         Anarkey function.  This includes the function keys and key
         sequences combining one of the <Alt>, <Ctrl> or <Shift>
         keys.  WordStar-like multiple-character key sequences, such
         as <Ctrl-KS>, are not supported.

         Because DOS handles the <Ctrl-C> and <Ctrl-P> keystrokes
         itself (to abort a program and redirect output to a printer,
         respectively), these keys may not be assigned to Anarkey
         functions.

         Also, a key may not be assigned to more than one function.
         If the key being assigned is already assigned to another
         function, Anarked displays a window stating the key's
         current assignment and asks if you wish to remove it.  If
         you respond positively, the key is removed from its old
         function assignment and assigned to the current function.

         A key assignment can be explicitly removed by making it the
         current assignment and pressing <Ctrl-@>.  Key assignments
         can also be removed by going through the Anarked action menu
         described in the next section.  Note: The TOPS local area
         network does not correctly handle <Ctrl-@> keystrokes.
         Thus, to remove key assignments, either UNLOAD TOPS or use
         the action menu function described in the next section.

         The Anarked Action Menu

         The Anarked action menu provides operations not available in
         edit mode.  Press the <Esc> key to display the action menu.

         The action menu lists several operations.  One operation,
         the current item, is displayed in reverse video.  A menu
         operation is invoked by using the <Up> and <Down> arrow keys
         to make it the current item and then pressing <Enter>.  Some
         operations are executed immediately, while others prompt for
         additional input.

         The action menu can be exited by pressing <Esc> again.


         Save changes and quit

         Select this menu item to save your key assignments to the
         output file specified upon program startup.  The new
         assignments will be in effect the next time Anarkey is
         installed.

         Anarked terminates after saving the key assignments.


         Create summary list

         This operation creates an ASCII text file listing all the
         Anarkey functions and their key assignments.  This file is
         suitable for printing and can be displayed in Anarkey's
         pop-up help window.  Refer to Chapter 2 for information
         about the help window.

         Anarked prompts for the name of the file to create.  The
         default file name is the output filename specified at
         startup with a .SUM extension.  Press <Enter> to accept the
         default or enter another filename.

         Alternatively, the file can be sent directly to the printer
         instead of a disk file by entering "PRN" when prompted for
         the filename.  However, be sure the printer is turned on
         before sending the file to it.

         Press <F1> to abort the operation without creating a summary
         list.


         Assign key

         Since the <Esc>, <PgUp>, <PgDn> and arrow keys are
         intercepted and interpreted by Anarked, assigning them to an
         Anarkey function requires that you go through this operation
         of the action menu.

         Anarked prompts for the key to assign to the
         current-key-assignment field.  Any key you press, including
         <Esc>, <PgUp>, <PgDn> or the arrow keys, is assigned to the
         field.

         Press <F1> to abort the operation and return to edit mode.


         Remove keystroke (<Ctrl-@>)

         When this operation is executed, the current-key-assignment
         field is cleared.  This is identical to pressing <Ctrl-@>.


         Quit Anarked without save

         This operation terminates Anarked without saving any
         modified key assignments.

         Keyboard Considerations

         Anarked recognizes the same keystrokes the DOS operating
         system recognizes.  Be aware that even though your keyboard
         may include <F11> and <F12> keys does not necessarily mean
         you can use them.  If DOS does not recognize a keystroke,
         neither does Anarked.

         This problem can be resolved by running the 101-Keys program
         distributed with Anarkey.  101-Keys provides support for
         enhanced keyboards.  It lets Anarked and other programs
         recognize keystrokes DOS does not normally support,
         including the <F11> and <F12> keys.  101-Keys is described
         in Chapter 15.



         Chapter 14

         Load, the Anarkey Load Utility

         The Load program reads an ASCII text file and processes each
         line as if it were entered at the DOS prompt.  The
         difference is that the lines are not executed; they are only
         stored in the history buffer.  Thus, Load provides a method
         to initialize the history buffer.

         Also, if the text file contains AKA definitions or Unix
         program names, Load will process and save them in the
         appropriate manner.  So you don't have to type in your AKA
         definitions and Unix programs at the start of every session,
         it is a good idea to store them in a text file and then have
         Load process the file during AUTOEXEC.BAT initialization.
         The Anarkmd program can create these files for you using the
         AKAs and Unix programs existing at the time it is executed.
         Anarkmd is discussed in Chapter 16.  You can also tell Load
         to not process AKA definitions and Unix programs by
         including the -D option on the command line.  Load options
         are explained later in this chapter.

         Running Load

         Anarkey must be installed prior to running Load.  The only
         exception to this is when Load is executed with the -M
         option, explained below.  Once Anarkey is installed, Load
         can be executed at any time and any number of times.  Load
         can be executed as part of a multiple-command line, but it
         must be the very last command in the line.  Any commands
         following Load in a multiple-command line are ignored.

         Load command-line syntax is shown below.


                LOAD [-options] filename [filename...]


         If Load is executed with no arguments, a usage message is
         displayed.

         Load command-line options are not required.  When specified,
         an option instructs Load to operate in a different manner
         than it normally does.  Recognized options are described in
         the next section.

         Load processes all filenames specified on the command line.
         Filenames may contain the DOS wildcard characters '*' and
         '?'.  Each file must be an ASCII text file.

         Load ignores all lines in the file which are empty or have a
         first word of "REM."  The remaining lines are stored in the
         history buffer, unexecuted.  AKA definitions (identified by
         a colon(:) as the line's first character) are processed and
         added to the list of AKAs.  If there is not enough room to
         store the AKA, Load beeps, displays an error message and
         continues processing the remainder of the file.  Likewise,
         Unix program names (specified by an exclamation point(!) as
         the line's first character) are saved in the Unix buffer.
         Load rejects lines longer than 255 characters or containing
         commands of more than 127 characters.

         Command-Line Options

         Load options modify Load's default operation.  Options may
         appear anywhere on the command line.  Each must be preceded
         by a dash(-) character.  Options may be in upper- or
         lowercase.  Recognized options are described below.


         Suppress Processing of AKA Definitions and Unix Programs

                 -D      Do not process AKA definitions and Unix
                         program names

         Normally, Load processes an AKA definition or Unix program
         name just as if it had been entered on the input line.
         However, sometimes the processed file may contain
         definitions that were defined temporarily and are no longer
         desired.  This can occur when the history buffer from a
         previous session is saved and then restored.

         Such definitions can be ignored during Load processing by
         including -D on the command line.  With -D specified, AKA
         definitions and Unix program names are ignored; they are not
         defined or stored in the Unix or history buffers.


         Fast-Load Operation

                 -F      Load disk file as quickly as possible,
                         bypassing any error checking

         Load normally performs extensive error checking on each line
         it processes.  For example, the line's length is checked to
         verify it is not too long and sufficient space to store an
         AKA definition or Unix program name is checked.  If any
         errors occur, Load displays a message explaining the problem.

         The Load error checking can take a significant amount of
         time.  If you are confident the processed file contains no
         problems, time can be saved by performing a fast-load
         operation.  Fast-load is activated by specifying the -F
         option on the command line.  In fast-load, error checking is
         bypassed and an optimized Load is performed.  Fast-load is
         significantly quicker than Load's normal processing.


         Calculate Space used by AKA Definitions and Unix Program
         Names

                 -M      Display AKA and Unix program space
                         requirements

         When first configuring Anarkey, it is common to create files
         containing AKA definitions and Unix program names, install
         Anarkey and then have Load process the files.  But before
         installing Anarkey, it's useful to know how much space to
         allocate for AKA definitions and the Unix buffer.  Load can
         provide this information by processing the files with the -M
         option.

         With -M on the command line, Load reads the contents of the
         file and accumulates the number of characters required for
         AKA definitions and Unix program names.  It does not process
         the file in any other way.  In other words, the file is not
         loaded into Anarkey's history buffer and AKA definitions and
         Unix program names are not saved.  When all specified files
         have been read, Load displays the total amount of space
         Anarkey will need to store the AKA definitions and Unix
         program names.  These values can then be used in the Anarkey
         -A and -U options, respectively, to reserve Anarkey memory
         during installation.

         Anarkey does not have to be installed prior to running Load
         with the -M option.


         Anarkey Process Number

                 -Pn     Anarkey's process number is n

         The Load -P option is identical to the -P recognized by
         Anarkey.  This option is only necessary in rare situations.
         Refer to the discussion of the Anarkey -P option in Chapter
         11 for information on when to use it.


         Execute in Quiet Mode

                 -Q      Suppress messages

         When -Q is included on Load's command line, informational
         messages, such as the name of the file being processed, are
         not displayed.  However, error messages are still displayed.



         Chapter 15

         101-Keys, Support for Enhanced Keyboards

         Many DOS computers come equipped with an enhanced,
         101/102-key keyboard.  This is the keyboard with <F11> and
         <F12> keys.  Unfortunately, at the time of this writing, the
         DOS operating system does not support the extra keys
         available on these enhanced keyboards.  The 101-Keys program
         solves this problem.

         101-Keys is a small resident program.  It allows full
         recognition of enhanced keys typed at the DOS command prompt
         and within application programs that normally do not support
         101-key keyboards.  With 101-Keys, programs such as Anarkey
         and Anarked recognize many new keystrokes, including <F11>,
         <F12> and combinations of those keys pressed with <Ctrl>,
         <Alt> or the <Shift> keys.  Even though 101-Keys is
         distributed with Anarkey, it provides enhanced keyboard
         support for most application programs that do not normally
         support such keyboards.

         Installation

         To install 101-Keys, execute it from the DOS command prompt
         or a batch file, such as AUTOEXEC.BAT.  101-Keys installs
         itself and terminates while remaining resident.

         An enhanced keyboard must be present on the system.  If
         101-Keys does not find an enhanced keyboard, it displays an
         error message and terminates without remaining resident.

         Once installed, no additional action is required.  From that
         point, Anarkey, Anarked and most application programs will
         recognize the new keystrokes supported by enhanced keyboards.

         101-Keys can be disabled by executing it again with the
         argument "OFF" on the command line.  To enable it, run with
         a command line of "ON."  Temporarily disabling 101-Keys can
         be a workaround if a program incompatible with 101-Keys is
         discovered (which is unlikely).  As an example, if the
         program "incomp" does not work with 101-Keys active, the
         following AKA definition temporarily disables 101-Keys
         whenever it is run.


                :incomp 101-keys off ; incomp %1 %2 %3 ; 101-keys on

         101-Keys and Other Programs

         Some programs need to be specially configured for them to
         recognize the additional keys 101-Keys provides.  All such
         known program configurations are described in this section.

         BRIEF Programmer's Text Editor

         The BFLAGS environment variable must be defined and include
         the string "-D101key."  This informs BRIEF to expect and
         properly handle the enhanced-keyboard input it may receive.


         New 101-Key Keystrokes

         The following list details the new keystrokes that programs
         recognize with 101-Keys installed.


         Stand-Alone Keys       Alt-Keys       Ctrl-Keys    Shift-Keys
         ----------------       --------       ---------    ----------
         F11                    Alt-F11        Ctrl-F11     Shift-F11
         F12                    Alt-F12        Ctrl-F12     Shift-F12
                                Alt-Up Arrow   Ctrl-Up Arrow
                                Alt-Down Arrow Ctrl-Down Arrow
                                Alt-Left Arrow
                                Alt-Right Arrow
                                Alt-Home
                                Alt-End
                                Alt-Page Up
                                Alt-Page Down
                                Alt-Keypad /   Ctrl-Keypad /
                                Alt-Keypad *   Ctrl-Keypad *
                                Alt-Keypad -   Ctrl-Keypad -
                                Alt-Keypad +   Ctrl-Keypad +
                                Alt-Keypad Enter
                                Alt-Insert     Ctrl-Insert
                                Alt-Delete     Ctrl-Delete
         Keypad 5                              Ctrl-Keypad 5
                                Alt-Backspace
                                Alt-Enter
                                Alt-Esc
                                Alt-Tab        Ctrl-Tab
                                Alt-`
                                Alt-[
                                Alt-]
                                Alt-;
                                Alt-'
                                Alt-,
                                Alt-.
                                Alt-/
                                Alt-\



         Chapter 16

         Anarkmd, the Anarkey Command-Line Utility

         In previous chapters, all Anarkey functions were executed by
         pressing keys.  However, some of Anarkey's operations can
         also be executed by running the Anarkmd program (pronounced
         "anar-command").

         There are three advantages gained from this capability: (1)
         It makes Anarkey functions available in situations where
         they are not normally available, (2) some of the functions
         Anarkmd implements are improvements over what Anarkey itself
         provides and (3) Anarkmd can provide functions used by
         Anarkey, thereby saving Anarkey from having to provide such
         functions itself.

         To explain the first advantage, recall that Anarkey does not
         process batch-file lines, therefore, features such as AKAs
         and multiple-command lines cannot be used in them.  However,
         Anarkmd can be executed from a batch file and thus provides
         an indirect way to execute an AKA or multiple-command line.

         Also, when Anarkey writes the history buffer to a disk file,
         it always saves it in a file called ANARKEY.LOG located in
         the current directory of the current drive.  (Check Chapter
         4 if you need to refresh your memory on this.)  Anarkmd adds
         the ability to specify the file's drive, directory and/or
         name, making it more flexible than the related Anarkey
         function.

         Finally, all of Anarkey's pop-up window functions, like the
         help and history-buffer windows, are actually implemented in
         Anarkmd.  Anarkey simply executes Anarkmd whenever a window
         function is invoked.  This saves a large amount of memory
         because none of the window-handling code needs to be
         resident.

         Running Anarkmd

         Anarkmd can be executed from the DOS command prompt, a batch
         file or an AKA.  Anarkmd cannot be run as part of a
         multiple-command line unless it is the last command in the
         line.  If it is not the last command, all trailing commands
         on the line are ignored.

         Anarkmd accepts two types of arguments: (1) a command-line
         option or (2) an input line to execute.  Command-line
         options are used to indicate the Anarkey function to
         execute.  Input lines are used to execute an AKA or
         multiple-command line from a batch file.  Only one type of
         argument can be passed to Anarkmd, either an option or a
         line to execute.

         Command-Line Options

         Options are prefaced by a dash(-) character, may be in
         upper- or lowercase and may be specified in any order on the
         command line.  Each Anarkmd option is described in the
         remainder of this section.


         Invoke an Anarkey Function

                 -Fx     Execute the Anarkey function specified by x

         The -F option informs Anarkmd of the Anarkey function to
         execute.  Only one -F option may be specified on the command
         line.

         Attached to the -F option is a function name.  No spaces may
         separate the -F from the function name.  Anarkmd recognizes
         several function names, but it only looks at the first two
         characters of the name to determine its identity.  Thus, you
         may abbreviate each of the following function names by
         specifying only its first two characters.  Function name can
         be in upper- or lowercase.

         Here is a list of recognized function names, followed by a
         description of each.  Since all of these functions have
         already been documented in previous chapters, they are only
         outlined here.  Refer to previous chapters for complete
         details of a particular function.


                         Bottom_display_history_buffer
                         Clear_history_buffer
                         Command_completion_full_screen
                         Display_history_buffer
                         Environment_selection_full_screen
                         Filename_completion_full_screen
                         Full_screen_menu
                         Help_screen
                         List_switchar_programs
                         Restore_Anarkey
                         Show_AKAs
                         Suspend_Anarkey
                         Toggle_input_mode
                         Undefine_all_AKAs
                         Write_history_buffer


         Bottom_display_history_buffer

         The history buffer is displayed onscreen starting from the
         last line in the buffer (i.e. the newest line) and moving
         toward the first (the oldest line).  This function is
         identical to pressing <Ctrl-F4> except the output is not
         paused between screens.  This nonstop display allows the
         output to be redirected to a disk file via the DOS '>'
         redirection character.

         Use the display_history_buffer option to output the buffer
         from first line to last.

         The following input lines demonstrate this option.


                anarkmd -fbottom_display_history_buffer
                anarkmd -fbo
                anarkmd -fbo >c:\anarkey\anarkey.log


         Clear_history_buffer

         All lines in the history buffer are deleted.  This function
         is identical to pressing <Ctrl-X>.

         This function could be useful when placed in an AKA
         definition.  For example, you may be afraid of accidently
         pressing <Ctrl-X> and clearing the history buffer.  If so,
         use Anarked to remove all key assignments for the
         clear-history-buffer function and then define the following
         AKA.


                :clr_hist       anarkmd -fcl


         With this setup, you can still clear the buffer when you
         enter "clr_hist" and there is no danger of accidently
         erasing it by pressing the wrong key.  Many of the other
         Anarkmd functions can be used for the same purpose.


         Command_completion_full_screen

         The history-buffer window is displayed and processed.  When
         the <Alt-F5> or <Alt-K> key is pressed, Anarkey invokes
         Anarkmd with this option to activate the window.


         Display_history_buffer

         The history buffer is displayed onscreen starting from the
         first line in the buffer (i.e. the oldest line) and moving
         toward the last (the newest line).  This function is
         identical to pressing <F4> except the output is not paused
         between screens.  This nonstop display allows the output to
         be redirected to a disk file via the DOS '>' redirection
         character.

         Use the bottom_display_history_buffer option to output the
         buffer from last line to first.


         Environment_selection_full_screen

         The environment variable window is displayed and processed.
         When the <Alt-F9> or <Alt-E> key is pressed, Anarkey invokes
         Anarkmd with this option to activate the window.


         Filename_completion_full_screen

         The filename-completion window is displayed and processed.
         When the <Alt-F8> or <Alt-F> key is pressed, Anarkey invokes
         Anarkmd with this option to activate the window.


         Full_screen_menu

         This function implements the actions of the MenuKey.  When
         <Alt-Tab> or <Shift-Tab> is pressed, Anarkey invokes Anarkmd
         with this option to activate the window.


         Help_screen

         Anarkey's pop-up help screen is displayed and processed.
         When <Alt-F1> or <Alt-H> is pressed, Anarkey invokes Anarkmd
         with this option to activate the window.


         List_switchar_programs

         The Unix buffer is displayed onscreen.  This function is
         identical to pressing <Shift-F4> except the output is not
         paused between screens.  This nonstop display allows the
         output to be redirected to a disk file via the DOS '>'
         redirection character.


         Restore_Anarkey

         Restores Anarkey processing after it has been disabled by
         the Suspend_Anarkey option.  This function has no comparable
         Anarkey key; it is only available from Anarkmd.


         Show_AKAs

         All AKAs are displayed onscreen.  This function is identical
         to pressing <Alt-F4> except the output is not paused between
         screens.  This nonstop display allows the output to be
         redirected to a disk file via the DOS '>' redirection
         character.  By redirecting the output, a text file is
         created that can be processed by the Load program.

         The following line demonstrates an AKA definition that saves
         all AKAs to a disk file.


                :save_aka       anarkmd -fsh >c:\anarkey.aka


         Suspend_Anarkey

         All Anarkey processing is disabled.  Subsequent requests for
         input are handled by DOS.  Anarkey can be enabled by running
         Anarkmd with the Restore_Anarkey option.  This function has
         no comparable Anarkey key; it is only available from Anarkmd.


         Toggle_input_mode

         Anarkey's input mode is toggled to either insert or
         overwrite mode.  This function is identical to pressing
         <Ins>.


         Undefine_all_AKAs

         All AKAs are deleted.  This function is identical to
         pressing <Alt-X>.


         Write_history_buffer

         The history buffer is written to a disk file.  The file's
         name is specified along with the function name.  Each is
         separated by a colon(:).  The filename must be specified;
         there is no default filename.  The required syntax is shown
         below.


                wr[ite_history_buffer]:filename


         The filename may include a drive and/or path specification.
         Sample command lines are shown below.


                anarkmd -fwr:history.buf
                anarkmd -fwr:c:\anarkey\hist.sav
                anarkmd -fwrite_history_buffer:\temp\anarkey.log


         This function is similar to pressing <Ctrl-W>, but supports
         the specification of the output file.

         If you have a batch file you run whenever you power-down
         your system, this function can be used to save the history
         buffer between sessions.  Simply add the appropriate Anarkmd
         line to the batch file to write the history buffer and then
         place a line in AUTOEXEC which instructs the Load program to
         restore it.  This is illustrated in the following two files.


         LOGOFF.BAT
                anarkmd -fwr:c:\anarkey.log

         AUTOEXEC.BAT
                load c:\anarkey.log


         This completes the Anarkey functions which Anarkmd can
         execute.  The remainder of this section describes additional
         options that Anarkmd recognizes.


         Enable Alternative Mouse Interface

                 -MA     Use alternative mouse interface in pop-up
                         windows

         Two different mouse interfaces are available when processing
         a pop-up window.  The default interface has been described
         in previous chapters.  The alternative interface is
         discussed in Appendix I.  To enable the alternative
         interface, include the -MA option on the Anarkmd command
         line.

         The Anarkmd -MA option is the same as Anarkey's -MA option.
         When Anarkey is installed with -MA and a key is pressed to
         display a pop-up window, Anarkey executes Anarkmd with the
         -MA and appropriate -Fx options.

         The -MA option is ignored if Anarkmd is not processing a
         pop-up window.


         Anarkey Process Number

                 -Pn     Anarkey's process number is n

         The Anarkmd -P option is identical to the -P recognized by
         Anarkey.  This option is only necessary in rare situations.
         Refer to the discussion of the Anarkey -P option in Chapter
         11 for information on when to use it.

         Executing an Input Line

         Anarkmd can execute any valid Anarkey input line passed to
         it as an argument.  Doing so allows AKAs and
         multiple-command lines to be executed from batch files.
         This is demonstrated in the following lines.  (Assume "aka2"
         is a defined AKA.)


                anarkmd aka2 file1 file2 file3
                anarkmd cd\temp;copy prog.exe a:;dir a:


         If the input line contains any DOS redirection characters (
         >, >> or < ) or the pipe operator(|), surround the entire
         input line with double quotes.  Example lines are shown
         below.


                anarkmd "dir >dir.log"
                anarkmd "aka2 file1 | more;aka2 file2"


         When Anarkmd executes an input line, it creates a temporary
         work file.  By default, this file is written to the current
         directory of the current drive.  The file's location is
         configurable by defining an environment variable called
         "ANARTMP."  Set ANARTMP to the drive and/or path in which to
         write the temporary file.  Anarkmd execution speed can be
         increased by setting ANARTMP to a RAM disk.  Anarkmd always
         deletes the temporary file before terminating.  The
         following line instructs Anarkmd to write the temporary file
         to the root directory of J: drive.


                set anartmp=j:\



         Chapter 17

         Convert, AKA-Conversion Utility

         If you are upgrading to Anarkey from another command-line
         editor, you may already have a group of defined AKAs or, as
         they are sometimes referred to, aliases or synonyms.  To
         make the transition from your current editor to Anarkey, the
         Convert program is provided to translate your existing AKAs
         into their equivalent Anarkey syntax.

         Convert translates alias and synonym definitions for the
         CED, PCED and DOSEDIT command-line editors.  The
         command-line syntax is shown below.


                convert -type input_file [output_file]


         The input_file argument specifies the file to convert.  The
         type argument indicates the kind of definitions contained in
         the input file, in other words, whether they are CED, PCED
         or DOSEDIT aliases.  Recognized type arguments are shown
         below.


                 -C      CED synonyms
                 -D      DOSEDIT aliases
                 -P      PCED synonyms


         The optional output_file argument designates the file in
         which to save the converted AKA definitions.  If output_file
         is not specified, Convert writes its output to ANARKEY.AKA
         in the current directory of the current drive.

         Sample Convert input lines are depicted below.


                convert -c syn.def anarkey.cfg
                convert -d dosedit.ali
                convert -p pced.syn c:\bin\anarkey.aka


         When converting DOSEDIT aliases, no additional editing is
         required; a 100% translation is performed.

         Converted CED and PCED synonyms may need some additional
         touch-up before they are fully Anarkey compatible.  The
         areas requiring attention are discussed in the remainder of
         this chapter.

         Convert recognizes and processes the CED/PCED commands
         CHAINCH, PARAMCH, SYN and USERSYN.  Any other commands may
         require some manual conversion.

         PCALL and PCED's '*' operator is irrelevant in Anarkey
         because of its more powerful command-completion functions.
         Thus, Convert removes all asterisk characters from processed
         names.  After conversion, you should check all PCALL and
         synonym definitions that used asterisks to see if they are
         still useful; they may be unnecessary and obsolete with
         Anarkey.

         Anarkey does not support nested AKAs and Convert does not
         look for nested synonyms in the input file.  Any nested
         CED/PCED synonym will require manual conversion.

         To all users of other command-line editors, welcome to the
         wonderful world of Anarkey!



         Appendix I

         Alternative Mouse Interface

         The main chapters in this manual dealt only with Anarkey's
         default mouse interface.  However, Anarkey supports an
         additional interface in its pop-up windows.  This
         alternative mouse interface is used if Anarkey or Anarkmd
         are executed with the -MA option.

         The alternative mouse interface does not support a separate
         mouse cursor or scroll bar.  Instead, mouse movements
         emulate presses of the <Up> and <Down> arrow keys.  To
         change the window's current line (i.e. the highlighted line
         displayed in reverse video), move the mouse in an upward or
         downward direction.  To scroll the window's contents,
         attempt to move the current line beyond the top or bottom
         edge of the window.

         The current line can be selected and entered onto the input
         line by clicking the left mouse button.  Double-clicking the
         left mouse button selects the current line and immediately
         accepts it for execution.

         To exit the window, click the right mouse button.



         Appendix II

         Anarkey Internals

         This appendix documents some technical aspects of Anarkey's
         inner workings.

         Anarkey users do not need to read or understand the
         information contained in this section.  It is provided for
         technical people interested in getting a general
         under-the-hood view of Anarkey.  This discussion assumes the
         reader has a basic understanding of DOS functions and TSR
         program structure.

         Upon installation, Anarkey hooks into two interrupts: (1)
         INT 2Fh, also known as the multiplex interrupt, and (2) INT
         21h, function 0Ah.

         INT 2Fh is used to store Anarkey's program signature.  When
         Anarkey starts execution, it checks INT 2Fh to see if its
         signature, and therefore, a previous instance of the
         program, is already installed.  Anarkey will not install
         multiple copies of itself.  If it finds its signature
         already installed, Anarkey terminates and does not remain
         resident.

         INT 2Fh is shared by many programs, for instance, DOS's
         PRINT and SHARE programs.  Each program is differentiated by
         a unique process number.  Process numbers 0C0h through 0FFh
         are reserved for user programs, such as Anarkey.  By
         default, Anarkey appropriates process number 0E3h.  The -P
         option can be included on Anarkey's installation line to
         have it use a different process number.

         The -P option requires the specification of a value from 0
         through 63.  Anarkey adds 0C0h to this number to arrive at
         its process number.

         If Anarkey determines it is not already installed, it hooks
         into INT 21h, function 0Ah.  This is DOS's buffered-input
         routine.  The resident portion of Anarkey is a replacement
         for this function.

         Anarkey then terminates and goes resident.  All subsequent
         requests for buffered input (most often made by the command
         processor) are intercepted and processed by Anarkey.



         Appendix III

         Miscellaneous Considerations

         A few special situations exist that Anarkey must be able to
         handle appropriately.  These are described in this appendix.
         Also included are programs that are incompatible or require
         special installation to work with Anarkey.

         Redirecting Output to a Serial Terminal

         Anarkey supports cursor positioning and many fancy
         display-related functions.  Unfortunately, serial terminals
         have no standard method to perform such operations; each
         terminal supplies its own "standard."  Because of this,
         Anarkey does not support operation on a serial terminal.

         In DOS, it is possible to redirect output to a serial
         terminal (also called the COM device) by two methods: (1)
         the '>' redirection character and (2) the CTTY command.  If
         output is redirected via '>' redirection, Anarkey detects it
         and temporarily disables itself.  Anarkey then monitors the
         system until output is restored to the video console, at
         which point it reenables itself.  Note this situation is
         handled by Anarkey automatically and no user intervention is
         required.

         If output is redirected by the CTTY command, Anarkey does
         not detect it.  If Anarkey is active when the CTTY
         redirection occurs, the system may hang.  To avoid this,
         disable Anarkey before executing CTTY.  To disable Anarkey,
         run Anarkmd with the -FSU option.  After output is restored
         to the primary video console, run Anarkmd with the -FRE
         option to reenable Anarkey.

         Incompatible Programs

         Some programs are not 100% compatible with Anarkey.  Others
         require special installation instructions to work in harmony
         with it.  Both types of programs are discussed in this
         section.


                 SIDEKICK

         Very old versions of Borland's SideKick program do not
         correctly execute multiple-command lines.  The first command
         gets executed, but each subsequent command requires that a
         key (any key) be pressed before it will be executed.  This
         problem can only be solved by upgrading to a newer version
         of SideKick.


                 TOPS Network

         Anarkey works with the TOPS local area network provided
         Anarkey is installed after TOPSKRNL and TOPSCLNT.

         Also, TOPS alters some typed keystroke codes.  This can
         result in problems when making key assignments with Anarked.
         To get around this problem, restrict your key assignments to
         keys not altered by TOPS.



         Appendix IV

         Anarkey Keystroke Summary

         The following table lists Anarkey's default keystroke
         assignments.


         Help window                           <Alt-F1> or <Alt-H>

         Cursor movement:
                 To start of line              <Home>
                 To end of line                <End>
                 Right one character           <Right>
                 Right one word                <Ctrl-Right>
                 Left one character            <Left>
                 Left one word                 <Ctrl-Left>

         Character deletion:
                 Character left                <Backspace>
                 Current character             <Del>
                 Word right                    <Ctrl-T>
                 To end of line                <Ctrl-End> or <Ctrl-Y>
                 Delete line                   <Esc>

         Character retrieval:
                 Single char from prev line          <F1>
                 Remainder of prev line              <F3>
                 Remainder of prev line and execute  <Alt-F3>

         General editing:
                 Accept line                         <Enter>
                 Toggle input mode                   <Ins>
                 Accept next keystroke unmodified    <Ctrl-U>

         MegaKey and MenuKey:
                 MegaKey                       <Tab>
                 MenuKey                       <Alt-Tab> or <Shift-Tab>

         History Buffer Functions
                 Retrieve previous buffer line <Up>
                 Retrieve next buffer line     <Down>

                 Complete line                 <F5> or <Ctrl-K>
                 Complete line and execute     <F6> or <Ctrl-L>

                 History-buffer window         <Alt-F5> or <Alt-K>

                 Restore CBL, get next line    <PgDn>

                 Display buffer contents             <F4>
                 Display buffer contents from bottom <Ctrl-F4>

                 Write buffer to \ANARKEY.LOG        <Ctrl-W>
                 Save line in buffer, do not execute <Ctrl-Enter>
                      (or <Ctrl-J>, same key)
                 Remove current buffer line          <Ctrl-Z>
                 Clear buffer                        <Ctrl-X>

         AKA Functions
                 Display AKAs                  <Alt-F4>
                 Undefine all AKAs             <Alt-X>

         Filename Completion Functions
                 Complete directory name       <F7> or <Ctrl-D>
                 Complete file/program name    <F8> or <Ctrl-F>
                 Filename-completion window    <Alt-F8> or <Alt-F>

         Environment Variable Retrieval
                 Retrieve environment variable <F9> or <Ctrl-E>
                 Environment-variable window   <Alt-F9> or <Alt-E>

         Unix Switchar Support
                 Display Unix buffer           <Shift-F4>

         Miscellaneous Functions
                 Check command lengths         <F2>
                 Repress multiple-command line <F10> or <Ctrl-R>