^^MOVE TOP                                                                    
This command positions the cursor to the first line of the buffer,            
scrolling or repainting the screen as necessary. pEDIT keeps all text in      
memory, making it very fast to move to the top of the buffer from any         
point in the buffer.                                                          
^^MOVE BOTTOM                                                                 
This function moves the cursor to the dummy last line at the end of the       
buffer. Again, the screen will scroll or repaint as required.                 
^^MOVE HOME                                                                   
The action of MoveHome depends on the position of the cursor within the       
current line. If the cursor is not at the beginning of the line, it will      
move there. If it is at the start of a line, it will move to the start of     
the previous line. Scrolling will take place as necessary toward the          
beginning of the buffer.                                                      
^^MOVE END                                                                    
MoveEnd works like MoveHome but in the opposite direction. If the cursor      
is not at the end of the current line it will move there. If the cursor is    
already at the end of a line, it will move to the end of the next line.       
The screen will scroll as needed toward the end of the buffer.                
^^MOVE UP                                                                     
This command is used to move up one line in the current buffer. Obviously,    
there can be no action if the cursor is already on the first line of the      
buffer. Otherwise, the cursor will move up a line, scrolling if necessary.    
Note that pEDIT attempts to keep the cursor as close to the same column as    
possible.                                                                     
^^MOVE DOWN                                                                   
MoveDown moves the cursor down one line following logic similar to that of    
MoveUp. The cursor can't move if it is already on the dummy last line of      
the buffer. Otherwise, it will move down, scrolling as necessary. Again,      
pEDIT will keep the cursor as close as possible to the same column.           
^^MOVE LEFT                                                                   
This function moves the cursor left one character position. The cursor may    
move more than one column if the character being crossed is a Tab or          
control character. If the cursor is at the beginning of a line, it will       
wrap to the end of the previous line.                                         
^^MOVE RIGHT                                                                  
This command moves the cursor right one character. Again, more than one       
column will be crossed for the Tab and other control characters. If the       
cursor is at the end of a line, it will wrap to the beginning of the next     
line.                                                                         
^^MOVE WORD                                                                   
MoveWord will move the cursor to the beginning of the next word in the        
current direction. If the direction is Forward, it will move toward the       
end of the buffer; if the direction is Reverse, toward the beginning of       
the buffer.                                                                   
                                                                              
The screen will scroll or repaint depending on the state of Select. If        
Select is active, the screen will be redisplayed. If Select is not active,    
scrolling will take place to keep the cursor on the fourth line from the      
top or bottom of the window. Scrolling is much faster than having to          
repaint the entire screen.                                                    
^^INSERT CHAR                                                                 
This is the default when a typing key or other non-definable key such as      
Tab, BackSpace or Enter is pressed. In Insert mode, the character will be     
inserted into the buffer at the current cursor position; text to the right    
is "shoved over" to make room. In Overstrike mode, the character is simply    
overwritten.                                                                  
                                                                              
pEDIT uses automatic word wrap to keep text between the defined margins as    
you type. If a word will not fit inside the current right margin, it will     
be moved to the start of the next line.                                       
                                                                              
Some keys require special handling. When the Tab key is pressed, the          
cursor will move to the next tab stop. pEDIT supports standard tab stops      
at every eighth column. Other control characters display as a caret (^)       
followed by the displayable character, i.e. Ctrl-A shows as '^A'.             
^^RESTORE TEXT                                                                
This command restores the text last deleted by EraseWord or EraseLine. The    
text is stored in a special text buffer for later restoration. This text      
buffer is rebuilt after every action so only the very last erasure can be     
restored.                                                                     
^^OPEN LINE                                                                   
This function opens up a new (empty) line for text insertion. The end         
result is the same as pressing Enter followed by Move Left except that        
there will be no indenting to a defined left margin, if any.                  
^^FILL PARAGRAPH                                                              
FillParagraph reformats a paragraph or portion of a paragraph to fit          
within the defined margins. Use this command after you have inserted or       
deleted text or changed margins. Note that reformatting is not automatic.     
                                                                              
Reformatting begins at the current line and stops at the end of the           
paragraph. A paragraph is defined as contiguous text bounded by empty         
lines both above and below. pEDIT will not see indented text as a separate    
paragraph unless it has at least one empty line separating it from other      
text.                                                                         
                                                                              
FillParagraph should be used sparingly in large documents. It works by        
saving the text in a special fill buffer, deleting the current paragraph      
and re-inserting the text. This uses considerable storage space.              
^^INDENT                                                                      
This function is very useful in programming when you want to indent a         
section of code in or out without having to manually edit each line. A        
level is 4 character positions or one-half a tab stop. Indent uses tabs       
and spaces as needed to indent the line to the desired offset.                
                                                                              
To use indent (1) position the cursor to the start of the first line, (2)     
toggle Select on, (3) highlight the entire range of lines to be indented      
and (4) issue the "INDENT" or "INDENT n" command. Specify the number of       
levels (n) as a positive or negative integer - positive for 'out' (toward     
the right), negative for 'in'.                                                
                                                                              
The selected range must start at the beginning of the first line and end      
at the end of the last line. Select is automatically turned off after the     
function completes.                                                           
^^AUTO INDENT                                                                 
This is another function very useful in programming. It is used to start a    
new line and automatically indent the line the same as the previous line.     
pEDIT uses the same leading whitespace (spaces and tabs) as the previous      
line. AutoIndent is normally used at the end of a line but the command can    
be issued anywhere.                                                           
^^CENTER LINE                                                                 
This command centers the current line - the line the cursor is on - between   
the existing margins. Unlike the Indent function, only spaces are used to     
indent the line to the appropriate position.                                  
^^CAPITAL WORD                                                                
CapitalWord capitalizes the current word starting at the current position     
within the word. The case change does not start at the beginning of the       
word; this is to allow, for example, 'Compuserve' to be changed to            
'CompuServe'.                                                                 
^^LOWER WORD                                                                  
This command converts the current word to lower-case starting at the          
current position within the word. All characters from the cursor to the       
end of the word will be changed to lower-case.                                
^^UPPER WORD                                                                  
UpperWord converts the current word to upper-case, again starting at the      
current character position and not at the beginning of the word.              
^^QUOTE CHAR                                                                  
This function is used to enter special characters into the text. pEDIT        
prompts you with "Press key to be added: "; at this point press one of the    
special keys. For example, to insert a form feed (Ctrl-L, Ascii 12) press     
Ctrl-V followed by Ctrl-L. The character will show as '^L' on the screen.     
                                                                              
The feature can also be used with Find and Replace. To find a line feed       
(Ctrl-J, Ascii 10) for example, press the DoCommand key and enter "FIND       
^V^J".                                                                        
                                                                              
Note that extended keys such as the PC keypad and function keys cannot be     
quoted. These keys return two bytes - a null followed by a displayable        
character.                                                                    
                                                                              
The PC graphics characters - those above Ascii 127 - are inserted in a        
special way. Hold down the Alt key and enter the decimal value of the         
character using the numeric keypad only; release the Alt key when done.       
^^TRANS CHAR                                                                  
This command transposes (swaps) two characters of text within a line. The     
cursor must be on the second character when you issue the command. The        
cursor cannot be positioned past the end of the line.                         
^^ERASE CHAR                                                                  
This command deletes the current character - the character the cursor is      
on. The action taken depends on the current mode. In Insert mode, the         
character is deleted and text to the right of the cursor is shifted left      
to "fill in the hole". In Overstrike mode, the character is replaced by a     
space.                                                                        
^^ERASE PREV                                                                  
This function deletes the previous character - the character to the left      
of the cursor. In Insert mode, the character is deleted and text to the       
right of the cursor is again shifted toward the left. In Overstrike mode,     
the character is again replaced by a space.                                   
                                                                              
ErasePrev is permanently bound to the Backspace key which cannot be           
redefined. BackSpace therefore functions the same as it does at the DOS       
(Operating System) level.                                                     
^^ERASE WORD                                                                  
EraseWord deletes text from the current position in a word to the end of      
the word. Deletion does not start at the beginning of the word. The           
current direction (Forward/Reverse) does not affect the action; deletion      
is always toward the end of the word.                                         
                                                                              
The current mode also has no effect on EraseWord. The entire word (or         
portion of a word) will be erased.                                            
^^ERASE LINE                                                                  
This command erases an entire line or a portion of a line depending on the    
position of the cursor. If the cursor is at the beginning of a line, the      
entire line - including the new line (end of line) marker - is erased and     
stored in the text buffer. If the cursor is not at the start of a line,       
deletion is from the current position to the end of the line.                 
^^FIND                                                                        
Find is used to search for a specified text string. Either press the Find     
key and respond to the prompt "String to find" or press DoCommand and         
enter "FIND <text>". The direction will of course follow the current          
direction. A Find operation can be cancelled by pressing the Abort key        
(Ctrl-C).                                                                     
                                                                              
If the target string is all lowercase, the operation will be case-            
insensitive; that is 'pedit' will match 'pedit', 'pEDIT' and 'PEDIT'. If,     
however, the target contains any uppercase characters, the match will be      
exact, i.e. 'pEDIT' matches only 'pEDIT'.                                     
                                                                              
pEDIT's new wild card search capability uses special symbols to match the     
beginning and end of a line. These symbols must be something no one would     
ever search for by themselves; use '\\<' for bol and '\\>' for eol. For       
example, '.\\>' would match a period only if it was at the end of a line.     
^^FINDNEXT                                                                    
This command will find the next occurrence of the last search string you      
specified. It is advisable to have Findnext bound to a key so only a          
single key press is required to repeat the last search operation.             
^^REPLACE                                                                     
pEDIT has a very powerful search and replace function. To initiate, either    
press the Replace key and reply to the "Old string:" and "New string:"        
prompts, or press DoCommand and enter "REPLACE old new".                      
                                                                              
pEDIT will search for each occurrence of 'old' and prompt you with            
"Replace (Y)es (N)o (A)ll (L)ast (Q)uit: :"                                   
                                                                              
    Y, Enter - replace this occurrence                                        
    N        - skip this replacement                                          
    A        - replace all occurrences from this point                        
    L        - make this the last replacement and quit                        
    Q        - quit.                                                          
                                                                              
Matching the old string will follow the rules listed for the Find command     
above except that no wild cards are permitted. The replacement will always    
substitute the new string, i.e. "REPLACE pedit pEDIT" will substitute         
'pEDIT' in all cases.                                                         
^^GET FILE                                                                    
This command loads in a new file for editing. pEDIT now supports wild-card    
file specifications using full standard DOS parameters of the type '*.*'      
and '*.BAS'. If more than one file matches the specification, you will be     
presented with a list of all matching file names in alpha order. Use the      
arrow keys to highlight the desired file and press Enter.                     
                                                                              
Once a file has been selected, pEDIT will create a buffer for the file,       
then create a window and map the buffer to the window. The status line        
will reflect the new buffer name and the first screen of text, if any,        
will be displayed. If no file exists, pEDIT will display "Creating file"      
and present you with an empty screen.                                         
                                                                              
pEDIT allows 4 user buffers. The number of lines and characters of text       
depends on available memory.                                                  
^^INCLUDE FILE                                                                
This function reads in the specified file from disk and inserts it into the   
buffer starting at the current cursor location. The screen will repaint to    
show the new text. The end result is the same as if the user typed in the     
text contained in the file.                                                   
                                                                              
Include File should be used only for relatively small files. The function     
uses the normal InsertChar routine, not the much faster GetFile which         
loads text directly into memory.                                              
^^WRITE FILE                                                                  
WriteFile is used to save the contents of the current buffer to disk          
without terminating the editing session. The file name used will be the       
one specified when the buffer was created. If no file name has been           
selected, pEDIT will ask for one.                                             
                                                                              
You can change the name of the file at any time by using a command of the     
form "WRITE FILE filespec" where filespec is a valid DOS file                 
specification.                                                                
                                                                              
pEDIT now checks to make sure there is sufficient disk space for the file     
BEFORE starting the save operation. The section on Error Handling has a       
full description of what to do if you get an error while saving a file.       
^^SHOW BUFFER                                                                 
This command displays detailed information about the current buffer: the      
buffer name, associated file name, current mode and direction, number of      
lines and characters of text, etc. The status line also shows the pEDIT       
version number.                                                               
^^LIST BUFFERS                                                                
This function lists a summary of all defined buffers - the two system         
buffers (COMMAND and DOS) plus up to 4 user buffers. The following items      
are displayed: buffer name, number of lines in the buffer, buffer type        
(System or User), whether or not the buffer has been modified and the name    
of the file associated with the buffer.                                       
^^BUFFER                                                                      
Use this command to switch between buffers. You will be presented with a      
BUFFER window containing the names of all buffers - System and User. The      
cursor will automatically be positioned on the first User buffer. Use the     
up and down arrow keys to highlight the desired buffer name; press Enter      
to select that buffer.                                                        
                                                                              
Exercise care when "in" the COMMAND buffer. Any modification of the           
COMMAND buffer outside of command mode may cause pEDIT to abort.              
^^TRIM BUFFER                                                                 
This function 'trims' the current buffer by truncating all "empty" lines -    
those containing only blanks - to length zero.                                
                                                                              
TrimBuffer is useful in any document where a left margin has been defined.    
pEDIT automatically indents every line to the specified left margin, which    
can result in "empty" lines between paragraphs. These "empty" lines can       
take up quite a bit of space in a large document.                             
^^CHANGE MODE                                                                 
The ChangeMode command is used to toggle between Insert and Overstrike        
modes. If the mode is Insert when the command is given, it will change to     
Overstrike and vice versa.                                                    
^^CHANGE DIR                                                                  
Use this command to toggle between the Forward and Reverse directions.        
Note that the buffer direction applies only to the Find, Findnext, Replace    
and MoveWord functions.                                                       
^^MARK                                                                        
This function is used to 'mark' a particular place in a buffer so you can     
return to it at some later time. There can be only one marker in each         
buffer. pEDIT tries to stay as close as possible to the original mark as      
text is inserted and deleted.                                                 
^^GOTO MARK                                                                   
Issue this command to move to the position defined by the last Mark           
command. The screen will scroll or repaint as necessary.                      
^^LINE                                                                        
The Line command is used to display the current line number or move to a      
particular line in the buffer. Enter "LINE" by itself to display the          
current line and number of lines; use "LINE nn" to move to line number nn.    
^^ONE WINDOW                                                                  
The OneWindow command 'unsplits' the screen. If there are 2 windows on        
screen, OneWindow will make the current window - the one the cursor is in     
- the only window. The screen will be repainted to show a full 21 lines of    
text. The line the cursor was on when the command was issued becomes the      
top line of the window.                                                       
^^TWO WINDOWS                                                                 
TwoWindows 'splits' the screen. If there is only one window, the screen       
will be split into two windows. Both windows will be mapped to the current    
buffer and will initially show the same 10 lines of that buffer. The          
cursor will move to the other window anticipating that you want to load in    
another file.                                                                 
                                                                              
When two windows are mapped to the same part of the same buffer, each must    
reflect the current state of the buffer. pEDIT will update both windows as    
necessary to keep the display correct.                                        
^^OTHER WINDOW                                                                
If the screen is split, this command will move the cursor to the other        
window. The cursor will move to the row and column stored the last time       
the cursor was in the window.                                                 
^^PREV SCREEN                                                                 
PrevScreen scrolls the screen up (towards the beginning of the buffer) by     
the number of rows currently on screen - 21 or 10 depending on the window     
size. The current direction has no effect on this command.                    
                                                                              
If the screen cannot scroll the full amount, the cursor will move up until    
it hits the first line of the buffer.                                         
^^NEXT SCREEN                                                                 
NextScreen scrolls the screen down by the number of rows currently on         
screen - 21 or 10 as for PrevScreen. Here, 'down' means towards the end of    
the buffer with the current direction having no effect.                       
                                                                              
If the screen cannot scroll the full amount the cursor will move until it     
hits the dummy line at the end of the buffer.                                 
^^SHIFT LEFT                                                                  
The Shift commands provide for horizontal scrolling - the ability to see      
text beyond column 80. ShiftLeft moves the window to the left (toward the     
left margin) the specified number of columns. pEDIT will prompt for the       
number of columns to shift if it is not given on the command line.            
^^SHIFT RIGHT                                                                 
ShiftRight shifts the screen to the right - toward the end of the line -      
by the number of columns you specify. How far the window can be shifted is    
limited only by pEDIT's maximum line length of 32767 characters.              
^^LEARN                                                                       
The Learn command is used to start recording keystrokes. The recording        
will continue until the Remember command is given. pEDIT will store all       
typing keys, function keys and other special keys such as control keys.       
                                                                              
Any keystrokes can be stored in a pEDIT Version 2 key macro. This fixes a     
deficiency with previous versions of pEDIT. The only restriction is that a    
macro containing a REPEAT command cannot, for obvious reasons, itself be      
repeated.                                                                     
^^REMEMBER                                                                    
Remember is used to end the keystroke recording started by Learn. pEDIT       
will ask for a key to bind to; press any of the definable keys described      
in the Appendix. You cannot bind to the Tab, Enter, Backspace or Ctrl-C       
(Abort) keys. Only one keyboard or dynamic macro can be defined at a time.    
With the new disk macros, however, it is possible to have several pre-        
defined macros available for use.                                             
                                                                              
A macro must not be bound to a key that is contained within the macro. If     
this happens, the macro routine will go into a loop and probably crash the    
system.                                                                       
^^SAVE MACRO                                                                  
SaveMacro is used to save the currently defined keyboard macro to disk.       
Enter only the file name; pEDIT automatically adds the extension '.PMC'.      
The editor will write the macro file in the directory pointed to by the       
PEDIT environment variable, or if none is defined, in the current             
directory.                                                                    
                                                                              
If a file of the same name already exists, you will be given the chance to    
overwrite it or abort.                                                        
^^EXECUTE                                                                     
This command executes a key macro. Whenever this command is issued, the       
keystrokes are 'replayed' as if you entered them. There are two forms of      
this command: one for a dynamic macro, one for a disk macro. See the          
section Macro Facility for more information.                                  
                                                                              
Use 'EXECUTE' by itself for the single dynamic macro. To execute a disk       
macro, use a command of the form 'EXECUTE filename' where 'filename' is a     
valid DOS file name without an extension. pEDIT automatically adds the        
file type .PMC to all disk macro file names.                                  
                                                                              
It is recommended that you reserve one key for dynamic macros; F12 on the     
enhanced keyboard has been left open for this purpose. Another good choice    
might be Alt-X for eXecute.                                                   
^^SELECT TEXT                                                                 
SelectText is a toggle that turns the select state on/off. If select is       
off, it will be turned on and vice versa. When it is active, selected text    
is highlighted in reverse video as the cursor is moved. Select is             
automatically turned off after any RemoveText or StoreText command. To        
cancel the selection, simply issue the command again.                         
^^REMOVE TEXT                                                                 
This command removes the selected text from the buffer and stores it in       
the paste buffer. The paste buffer is built every time RemoveText is          
invoked so only the most recently deleted text is available. The screen is    
updated as necessary to show the state of the buffer after the removal.       
^^STORE TEXT                                                                  
StoreText is similar to RemoveText except that the text is not removed        
from the buffer. The paste buffer is rebuilt to contain the selected text.    
Use this command whenever you want to make a copy of some text without        
deleting it.                                                                  
^^INSERT HERE                                                                 
This function inserts text from the paste buffer into your text starting      
at the current cursor position. Again, the screen is updated to show the      
new state of the buffer. Insert Here can be invoked more than once to make    
multiple copies of the stored text.                                           
^^RECALL                                                                      
The Recall command is used to recall the last command given via DoCommand.    
The end result is the same as pressing the DoCommand key followed by the      
up arrow with one important difference; the previous command is copied to     
the current command line. The command can of course be edited before          
pressing Enter to begin execution.                                            
^^DO COMMAND                                                                  
DoCommand is used to directly issue commands to pEDIT. The editor will        
respond with the 'Command: ' prompt; at this point you can enter any valid    
pEDIT command. Commands can be upper- or lower-case or mixed. Note that       
commands must be entered in full with spaces in between words. No pEDIT       
command contains more than 2 words.                                           
                                                                              
The Command line is really a one-line window into the COMMAND buffer. All     
defined keys can be used on the command line for editing the current line     
or recalling previous commands. Use MoveUp and MoveDown to scroll up and      
down through the stored commands.                                             
^^REFRESH SCREEN                                                              
This command is used to clear and repaint the screen. Use RefreshScreen       
if, for any reason, the screen should be over-written or otherwise            
obliterated. Everything - including reverse video - will be redrawn.          
^^DEFINE KEY                                                                  
This function is used to dynamically define a key during an editing           
session. pEDIT will ask for a procedure name and a key press. The             
procedure name is any valid pEDIT command entered in full (no                 
abbreviations) with a space in between words. In pEDIT 2, this procedure      
name can be ANY pEDIT command including parameters. The command can be        
bound to any definable key.                                                   
                                                                              
Generally it is best to put key bindings in the init file so they are         
automatically defined when the editor is invoked.                             
^^SHOW KEY                                                                    
ShowKey is used to show what procedure is bound to a key. pEDIT will          
prompt for a key press and display the name of the procedure, if any,         
bound to that key.                                                            
^^LIST KEYS                                                                   
ListKeys lists all definable keys and the procedures bound to them. pEDIT     
will pause in between screens; press Enter to continue to the next screen.    
^^SPAWN                                                                       
This function spawns or shells you to DOS. A second copy of COMMAND.COM is    
loaded into memory to process commands. You may then enter DOS commands       
and do anything you can do at the operating system level. Type 'EXIT' to      
return to the editor exactly as you left it.                                  
                                                                              
If you have a floppy-only system, COMMAND.COM must be available or the        
spawn will fail. Also, some versions of DOS prior to 3.x have a problem       
with "SHELL" and may not work properly.                                       
                                                                              
pEDIT tries to keep 50-70k of memory free for the Spawn and Dos commands;     
this will not leave sufficient memory for anything but DOS resident           
commands (DIR, TYPE, etc.) and small programs. If you need more memory,       
use the eXtended Spawn function (XSpawn).                                     
^^XSPAWN                                                                      
This function serves the same purpose as Spawn but with one important         
extension. All text memory is swapped out to disk, leaving much more          
memory available to DOS. On a machine with 640k, about 350k will be           
available - more than enough to compile and run other programs - even         
another copy of pEDIT.                                                        
                                                                              
The restrictions noted for Spawn apply here. Also, you must be careful not    
to delete pEDIT's temporary swap files. See the section titled 'Extended      
DOS Shell' for more information.                                              
^^REPEAT                                                                      
Repeat lets you repeat any key press up to 32767 times. Only the next         
single key press - typing, function, Ctrl, Alt - is repeated.                 
                                                                              
The repeat count is shown by 'Repeat: ' on the message line. Use BackSpace    
to correct the count; set the count to zero if you wish to cancel.            
                                                                              
You can end a repeat loop by pressing the Abort (Ctrl-C) key.                 
^^SET AUTOSAVE                                                                
pEDIT has an 'autosave' function that automatically saves your work to        
disk. If autosave is on, pEDIT will periodically do a WriteFile if changes    
have been made. The 'Working . . .' message will appear and the disk          
access light will come on. You will be told how many lines were written.      
The usage is 'SET AUTOSAVE ON|OFF'.                                           
^^SET COLOR                                                                   
SetColor lets you choose foreground and background colors on a color          
(CGA/EGA/VGA) monitor. For monochrome, the only legal combinations are        
"SET COLOR blk wht" and "SET COLOR wht blk". Here 'blk' and 'wht' refer to    
the mono colors whatever they may be - black and white, green and black,      
etc.                                                                          
                                                                              
If you issue the command as "SET COLOR" pEDIT will prompt for the             
foreground and background colors.                                             
                                                                              
See the Appendix for a list of valid color code names.                        
^^SET LINES                                                                   
SetLines lets you switch between 25 and 43 line mode on an EGA or VGA         
monitor. These displays can show more than the normal 25 lines of text.       
Note that screen writing and scrolling are generally much slower in 43-       
line mode. The SetLines command cannot be given when the screen is split.     
VGA 50 line mode is not supported. The usage is 'SET LINES 25|43'.            
^^SET MARGINS                                                                 
This command lets you set left and right text margins. The default margins    
are 1 and 80. The left margin must be greater than zero and the right         
margin has to be greater than the left. The format of the command is "SET     
MARGINS left right"; if "SET MARGINS" alone is used, pEDIT will prompt for    
the values.                                                                   
                                                                              
Paragraphs are not automatically reformatted when margins are changed. Use    
FillParagraph for this.                                                       
^^DOS                                                                         
The Dos function spawns or "shells" a command to DOS for execution. The       
output from the command will be placed in the DOS buffer as text. If only     
one window is on-screen, pEDIT will split the screen and map the DOS          
buffer to the other window.                                                   
                                                                              
The program must load a second copy of COMMAND.COM into memory to handle      
the request. See Spawn for a discussion of limitations and cautions.          
^^XDOS                                                                        
The eXtended DOS function (XDos) uses an intelligent DOS shell to free up     
additional memory for the execution of DOS commands. See the description      
of XShell and the section titled 'Extended DOS Shell'.                        
                                                                              
A common use of XDos would be to compile a program from within the editor.    
For example, 'XDOS BC TEST /O ;' would be used to compile a QuickBASIC        
program. The compiler output will of course be directed into the DOS          
buffer.                                                                       
^^HELP                                                                        
The Help command provides full on-line help for every pEDIT command. The      
editor looks for a help file named PEDIT.HLP in the directory defined by      
the PEDIT environment variable, or if none is defined, in the current         
directory.                                                                    
                                                                              
You will be presented with a HELP window containing an alphabetical list      
of all pEDIT commands. Use the arrow keys to highlight the command you        
want help with and press Enter.                                               
^^KEYBOARD                                                                    
The Keyboard function displays the contents of the file PEDIT.KEY on the      
screen in a KEYBOARD window. The editor again looks for this file in the      
directory specified by the PEDIT environment variable, or in the current      
directory. Normally this command is used to display a diagram of your         
keyboard and/or a list of the keys you have defined.                          
^^QUIT                                                                        
Use the Quit command to abort an editing session. Abort MEANS abort - any     
changes you have made will be lost. If any User buffers have been             
modified, pEDIT gives you the option of not quitting by displaying            
"Buffer(s) modified - quit (Y/N)? ". Enter Y to abort, N to cancel the        
abort and resume editing.                                                     
^^EXIT                                                                        
The Exit command terminates the editing session and returns you to DOS.       
The current buffer is automatically written to disk if it has been            
modified. If any other user buffers have been altered, pEDIT asks you one     
at a time if you want to write them. Answer Y to save the buffer, N to        
skip it.                                                                      
