Simtel MSDOS 1992 June

home *** CD-ROM | disk | FTP | other *** search

/ Simtel MSDOS 1992 June / SIMTEL_0692.cdr / msdos / keyboard / recall.arc / RECALL.DOC < prev

Wrap

Text File | 1989-10-15 | 36.1 KB | 772 lines

Command Line RECALL 2.1 Resident Interrupt Handler for DOS Buffered Keyboard Input (c) Roger Roth PO Box 840 West Jordan, UT 84084-0840 CompuServ: 70431,2513 No Fee for Use, Not for Sale or Resale ---------------------------------- Contents --------------------------------- Introduction - Features Installation - Installing on a Hard Disk - Installing in Memory Command History - Buffer 1 vs. Buffer 2 - <UpArrow> and <DownArrow> Keys - Listing History - Fetching Old Commands by Number - Searching for a Command Fragment Line Editing - Moving the Cursor - Deleting Characters - Toggling Insert Mode - Two Methods of Backspacing DOS Compatibility - Function Keys - The Template - Inserting Control Characters Command Line Options - Changing Defaults - Redefining Keys Aliasing - Creating Aliases - Using Aliases Function Key Macros - Defining Function Key Macros - Executing Function Key Macros Environment Substitution Environment Completion Filename and Dirname Completion Technical Notes - Calling from Assembly Language - Calling from C Language - Internals - DOS Environment -------------------------------- Introduction ------------------------------- Command Line RECALL is a Terminate and Stay Resident (TSR) program that provides recall and full editing of previously entered commands. The user can move the cursor, insert, and delete, while the entire command line is in view. When a command is entered, it is saved in a History Buffer so that it can be recalled at a later time for reuse or revision. Only part of RECALL.COM becomes memory resident. Much of its executable code is used to process the many options available after memory install. RECALL.COM can be executed over and over again without reinstalling itself in memory. The following features are supported by Command Line RECALL: - Retrieve previously entered commands with <UpArrow> and <DownArrow>. - Display a list of previously entered commands. - Retrieve previously entered commands by number. - Retrieve previously entered commands by searching for a string. - Two separate command line buffers, one for DOS and one for programs that run under DOS, such as DEBUG and EDLIN. - Control of memory usage, by specifying the size of both buffers. - Most options can be set at or after memory install. - The functions of many keys can be redefined. - Aliases for frequently used commands. - Function Key Macros. - Environment Substitution and Completion. - Filename and Dirname Completion. Command Line RECALL tries not to be annoying: - Close compatibility with regular DOS command line editing. - Video parameters, including cursor size and display colors, are never changed. - Screen sizes other than 25 x 80 are detected and taken advantage of. - No case sensitivity, all options and Environment Variable strings can be entered in either upper or lower case. - An exact match of the previously entered command will not be added to the History Buffer. - History Buffers are non-circular. Repeated <UpArrow>s will stop at the oldest command. Repeated <DownArrow>s will stop at the newest command. -------------------------------- Installation ------------------------------- To access the many features of Command Line RECALL, it is necessary to copy RECALL.COM to a subdirectory which is on the PATH. For example, if RECALL.COM is on a diskette in the A: drive: C:\> path PATH=C:\DOS;C:\UTILS;C:\WORDPROC;C:\WRKSHEET C:\> copy A:\RECALL.COM C:\UTILS 1 File(s) copied RECALL.COM becomes memory resident the first time it is run. A short message will be displayed with information about the amount of memory used. To make Command Line RECALL memory resident: A> RECALL Once Command Line RECALL is installed in memory, it will stay in memory until the computer is reset, <Ctrl-Alt-Del>. Most users will be happy with the defaults. However, many users will want to specify various options. For example, to make Command Line RECALL memory resident, but change some of the defaults: A> RECALL /SIZE1=2048 /INS+ To make Command Line RECALL memory resident each time the computer boots up, install RECALL.COM into AUTOEXEC.BAT. Edit the AUTOEXEC.BAT file, and add one line (with or without options): RECALL [/options] ------------------------------ Command History ------------------------------ Command Line RECALL maintains two separate History Buffers, one for DOS and one for programs that run under DOS, such as DEBUG and EDLIN. When working with one buffer, the other will not be affected. Throughout this document, the following naming convention is used: 'Buffer 1' is the History Buffer used for DOS command line editing. 'Buffer 2' is the History Buffer used by programs which run under DOS. The following keys will retrieve previously entered commands: <UpArrow> edit previous command <DownArrow> edit next command <PgUp> edit oldest command <PgDn> edit most recent command <Ctrl-PgUp> remove displayed command from History <Ctrl-PgDn> clear all History The following commands will display History from Buffer 1: RECALL display last 20 commands (no parameters) RECALL /ALL display all commands, pausing every 20 RECALL /ALL /LOG >PRN print all commands, no pause The following commands will display History from Buffer 2: RECALL /2 display last 20 commands RECALL /ALL2 display all commands, pausing every 20 RECALL /ALL2 /LOG >PRN print all commands, no pause Command Line RECALL actually displays commands (number of screen rows - 5) at a time. Since most users operate in 25 line mode, this document will claim that commands are displayed 20 at a time. By default, the above commands display the command History from most recent to oldest. The default can be changed, History can be displayed from oldest to most recent, with a 'RECALL /LIST-' command. The list commands mentioned above display a number next to each listed command. A previous command can be retrieved by referencing that number: RECALL nn recall command #nn A previous command can be retrieved by doing a non case sensitive search for a command fragment: RECALL frag recall previous command containing 'frag' Ordinarily, when a command is entered, it is added to the History Buffer. The following are exceptions: - The command is too short (as specified with a 'RECALL /TOOSHORT1=n' command). - The command is an exact copy of the previously entered command. - The command is a RECALL command with any list option (example: RECALL /ALL). - The command is a successful RECALL search command, i.e. a RECALL command which brings back a previous command for editing. Once a command is added to the History Buffer, it will stay there until one of the following events occurs: - The History Buffer is full and room is needed to add a new command. Older commands will be discarded to make room for newer commands. - The command is deleted from the History Buffer with <Ctrl-PgUp>. - The History Buffer is cleared with <Ctrl-PgDn>. - The History Buffer is cleared with a 'RECALL /CLEAR' command. -------------------------------- Line Editing ------------------------------- Command Line RECALL provides the capability for full editing of the command line with the entire command line visible. Most of the keys described below have similar use with all DOS programs. The following keys move the cursor: <LeftArrow> move left one char <RightArrow> move right one char <Ctrl-LeftArrow> move left to beginning of word <Ctrl-RightArrow> move right to beginning of word <Home> move to left of line <End> move to right of line The following keys delete characters: <Backspace> delete char to left of cursor <Ctrl-Backspace> delete char to left of cursor, slide line left <Del> delete char at cursor <Shift-Tab> delete word left of cursor <Ctrl-Home> delete all chars left of cursor <Ctrl-End> delete all chars at cursor and right of cursor <Ctrl-Enter> delete all chars at cursor and right of cursor <Esc> delete entire line The <Ins> key is used to temporarily toggle insert/overwrite mode. However, when <Enter> is pressed, Command Line RECALL goes back to its fixed mode which is normally overwrite. At any time, the fixed mode can be changed to insert with a 'RECALL /INS+' command or back to overwrite with a 'RECALL /INS-' command (see Command Line Options in this document). There are two different methods of backspacing. Both methods delete the character to the left of the cursor. Both methods work identically in insert mode or when the cursor is at the end of the line. The difference can be noticed in overwrite mode when the cursor is somewhere in the middle of the line. Method 1 will delete the character and replace it with a space. Method 2 will delete the character and slide the line to the left. By default, <Backspace> uses method 1 and <Ctrl-Backspace> uses method 2. If method 2 is preferred, change the definition of the <Backspace> key (see Defining Keys in this document). ----------------------------- DOS Compatibility ----------------------------- The DOS operating system provides Buffered Keyboard Input, on the DOS command line and to any program which wants to use it. Command Line RECALL is a new implementation of Buffered Keyboard Input. <F1> through <F6> will work just like they used to work with DOS: <F1> one char from Template to current line <F2> (+char) chars from Template to current line until char matched <F3> rest of chars from Template to current line <F4> (+char) skip in Template until char matched <F5> copy current line to Template and to History Buffer <F6> end of file char, <Ctrl-Z> or ascii 26 <RightArrow> works just like <F1>, when cursor is at end of line To fully understand the DOS compatibility of Command Line RECALL, the difference between the Template and the History Buffer should be clear. When a program (DOS, DEBUG, EDLIN, etc.) uses Buffered Keyboard Input, the program must provide a buffer, the Template, for Buffered Keyboard Input to use. The Template is the communication link between programs and Buffered Keyboard Input. Regular DOS command line editing uses only the Template and no History Buffers. Command Line RECALL maintains its own History Buffers and normally writes to the Template only when <Enter> is pressed. However, <F1> through <F6>, and in some cases <RightArrow>, cause Command Line RECALL to access the Template. The inserting of control characters into the command line is accomplished with a trick derived from a similar function of EDLIN, the DOS line editor. To insert a control character into the command line, press <Ctrl-V>, then one of the following keys: key following <Ctrl-V> ascii value inserted into command line ---------------------- -------------------------------------- a through z ascii 1 through 26 A through Z ascii 1 through 26 [ \ ] ^ _ ascii 27, 28, 29, 30, 31 = ascii 127 ---------------------------- Command Line Options --------------------------- Most users will find that Command Line RECALL works just fine with only default options. This section can be skipped for now and read at a later time. However, many options are available to customize to a user's needs. Notice that all options except '/SIZE1=' and '/SIZE2=' can be set after Command Line RECALL is memory resident. When Command Line RECALL is run with no options, one of three things can happen: 1) The first time, it will become memory resident with default options. 2) If disabled (see 'RECALL /OFF' command), it will reenable itself. 3) Otherwise, the last 20 commands will be displayed. Help: RECALL /? display short help message At Memory Install Only: RECALL /SIZE1=nnnnn size of Buffer 1 (default 512) RECALL /SIZE2=nnnnn size of Buffer 2 (default 256) 256 <= 'nnnnn' <= 16384 After Memory Install Only: RECALL /OFF temporarily disable, use regular DOS command line editing RECALL /ON enable Command Line RECALL RECALL /CLEAR clear both command buffers RECALL /CLEAR1 clear Buffer 1 RECALL /CLEAR2 clear Buffer 2 The '/OFF' option will leave Command Line RECALL resident in memory, but all 'Buffered Keyboard Input' calls will be handled by DOS. The '/ON' option will reenable Command Line RECALL without using any more memory. The '/CLEAR' options will throw away all saved command History, but will not change the size of either History Buffer. At or After Memory Install: RECALL /INS- insert mode off, overwrite (default) RECALL /INS+ insert mode on RECALL /LIST- list History backwards RECALL /LIST+ list History forwards (default) RECALL /ALIAS- disable Aliasing RECALL /ALIAS+ enable Aliasing (default) RECALL /ALIASCHR1=c Aliasing char for Buffer 1 (default @) RECALL /ALIASCHR2=c Aliasing char for Buffer 2 (default #) RECALL /TOOSHORT1=nn don't save cmds of len <= nn in Buffer 1 (default 0) RECALL /TOOSHORT2=nn don't save cmds of len <= nn in Buffer 2 (default 3) RECALL /FILEATTRIB=hh File Completion search attribute (default 00 hex) RECALL /DIRATTRIB=hh Dir Completion search attribute (default 10 hex) After Memory Install, Displaying History from Buffer 1: RECALL display last 20 commands (no parameters) RECALL /ALL display all commands, pausing every 20 RECALL /ALL /LOG >PRN print all commands (no pause) After Memory Install, Displaying History from Buffer 2: RECALL /2 display last 20 commands RECALL /ALL2 display all commands, pausing every 20 RECALL /ALL2 /LOG >PRN print all commands (no pause) Redefining Keys: RECALL /key=function The possible values for 'key' are listed in the left column below, and the possible values for 'function' are listed in the second column below. It so happens that for each 'key' listed below, the default 'function' is listed to its right. The third column is a short description of the 'function'. By default, the last 'function' is not assigned to any 'key'. The default 'key's and 'function's are described elsewhere in this document. Upper/lower case, no difference. key function description --- -------- ----------- UP PrevCmd edit previous command in History Buffer DOWN NextCmd edit next command in History Buffer LEFT CharL move left one char RIGHT CharR move right one char ^LEFT WordL move left to beginning of word ^RIGHT WordR move right to beginning of word HOME BegLine move to left of line END EndLine move to right of line ^HOME DelLineL delete chars left of cursor ^END DelLineR delete chars at cursor and right of cursor PGUP FirstCmd edit oldest command PGDN LastCmd edit most recent command ^PGUP DelCmd remove displayed command from History Buffer ^PGDN ClearHist clear the History Buffer INS InsMode toggle insert/overwrite mode DEL DelChar delete char at cursor F1 FOne F1 function key (DOS compatible) F2 FTwo F2 function key (DOS compatible) F3 FThree F3 function key (DOS compatible) F4 FFour F4 function key (DOS compatible) F5 FFive F5 function key (DOS compatible) F6 FSix F6 function key (DOS compatible) F7 Nothing do nothing F8 EnvCmpl invoke Environment Completion F9 DirCmpl invoke Dirname Completion F10 FilCmpl invoke Filename Completion BSP BackSpace delete char to left of cursor ^BSP BackSpace2 delete char to left of cursor, slide line left BKTAB DelWordL delete word to left of cursor DelWordR delete word at cursor and right of cursor Example, installing Command Line RECALL in memory with options: - insert mode on, instead of the default, overwrite - redefine <Backspace> to use Backspace Method 2 - redefine <Ctrl-Backspace> to Delete Word Left - Make Buffer 1 larger, 2 kilobytes, instead of the 512 byte default RECALL /INS+ /BSP=BackSpace2 /^BSP=DelWordL /SIZE1=2048 Example, changing options after Command Line RECALL is memory resident: - display History backwards - save only commands 4 characters or longer in Buffer 1 - clear all History in Buffer 2 - disable Clear History function of <Ctrl-PgDn> RECALL /LIST- /TOOSHORT1=3 /clear2 /^PgDn=nothing The first example above is valid only on first time use, because of the '/SIZE1=' option. The second example above is not valid for first time use, because of the '/CLEAR2' option. The following examples give a clue as to how Command Line RECALL decides whether to change options, or to search for a previously entered command, or to display an error message: RECALL /INS+ /LisTT- Command Line RECALL looks for mistakes before it takes any action. The error will be detected and an error message will be displayed. The default insert mode will not be changed. RECALL /LisTT- Command Line RECALL sees no valid options in this command, so it will assume that a search for a previous command containing command fragment, '/LISTT-', is being requested. If there is no matching previous command, a 'No Find' error message will be displayed. RECALL 94 Command Line RECALL first looks for command #94. If a 94th command is in the History Buffer, it will be presented for editing. Otherwise, a search for a previous command containing command fragment, '94', will be conducted. If such a command is in the History Buffer, it will be presented for editing. Otherwise, a 'No Find' error message will be displayed. ---------------------------------- Aliasing --------------------------------- An Alias is an alternate name. Aliasing allows the user less typing with frequently used commands. Aliasing can also replace the use of simple one line Batch Files. An Alias is defined with the DOS SET command. To define an Alias for use with Buffer 1: A> set @alias=string or A> set @alias="string" 'Alias' is now an alternate name for 'string'. Whenever 'alias' is typed at the far left of the command line, it will be as though 'string' was really typed. Aliasing works only at the far left of the command line. Another feature, Environment Substitution, described elsewhere in this document, is similar to Aliasing, but works anywhere on the command line. Command Line RECALL doesn't care whether or not 'string' is enclosed in double quotes. However the double quotes allow a user to get certain characters (namely '<', '>', and '|') into the Environment. An Alias defined for use in Buffer 1 will have no effect from within a program which runs under DOS (Buffer 2), and vice versa. The rest of this section will concentrate on defining Aliases for use from the DOS command line (Buffer 1). The use of Aliases with Buffer 2 is not as useful, but is fully supported. To define an Alias for use with Buffer 2: A> set #alias=string An '@' before the Alias applies to the DOS command line (Buffer 1). The '@' can be changed with a 'RECALL /ALIASCHR1=c' command. A '#' before the Alias applies to programs which run under DOS (Buffer 2). The '#' can be changed with a 'RECALL /ALIASCHR2=' command. For example, to make 'D' an Alias for 'DIR': A> set @d=dir define Alias A> d use Alias A> d *.doc use Alias Aliases are defined with the DOS SET command. The following Alias definitions are excellent candidates for addition to AUTOEXEC.BAT: A> set @up="cd .." (quotes optional) A> set @cmp="echo n| comp" (quotes necessary) A> set @r=recall After Aliases have been defined, they can be accessed from the DOS command line. Column 1 below shows how Aliases are used. Column 2 shows how the command would have to be typed without the Aliasing feature. For users who understand DOS Batch Language, column 3 shows an equivalent one line Batch File. The following examples use the Aliases defined with the above SET commands: Aliasing equivalent Batch Language -------- ---------- -------------- A> up A> cd .. cd .. A> cmp file1 file2 A> echo n| comp file1 file2 echo n| comp %1 %2 A> r autoexec A> recall autoexec %@r% autoexec ---------------------------- Function Key Macros ---------------------------- Function Key Macros are Aliases. The Function Key Macros feature of Command Line RECALL is nothing more than a special case of the Aliasing feature. Function Key Macros can be defined for the following keys: <Shift-F1> through <Shift-F10> <Ctrl-F1> through <Ctrl-F10> <Alt-F1> through <Alt-F10> Function Key Macros cannot be defined for <F1> through <F10>, as these keys are used to access other features. Macros are defined using the DOS SET command, exactly the same way Aliases are defined. To define Macros for use with Buffer 1: A> set @macro=string or A> set @macro="string" An Alias is also a Function Key Macro when the Alias, 'macro', is one of the following (upper/lower case, no difference): ShiftF1 CtrlF1 AltF1 ShiftF2 CtrlF2 AltF2 ShiftF3 CtrlF3 AltF3 ShiftF4 CtrlF4 AltF4 ShiftF5 CtrlF5 AltF5 ShiftF6 CtrlF6 AltF6 ShiftF7 CtrlF7 AltF7 ShiftF8 CtrlF8 AltF8 ShiftF9 CtrlF9 AltF9 ShiftF10 CtrlF10 AltF10 To define Macros for use with Buffer 2: A:\> set #macro=string Thirty Macros can be defined for use with Buffer 1, and thirty Macros can be defined for use with Buffer 2. Macros defined for use in Buffer 1 will have no effect in Buffer 2 and vice versa. An '@' before the Macro (Alias) applies to the DOS command line (Buffer 1). The '@' can be changed with a 'RECALL /ALIASCHR1=' command. A '#' before the Macro (Alias) applies to programs which run under DOS (Buffer 2). The '#' can be changed with a 'RECALL /ALIASCHR2=' command. After a Macro has been defined for a function key, pressing that function key will perform the following actions: 1) Clear the current line (like the <Esc> key). 2) Type in the characters assigned to the Macro. 3) Process the characters (like the <Enter> key). A caret, '^', has a special meaning in a Macro definition. A '^' as the first character of 'string' means skip step 1), above. A '^' as the last character of 'string' means skip step 3), above. Macros are defined with the DOS SET command. Some examples follow: A> set @CtrlF6="DIR ^" (quotes optional) A> set @CtrlF5="set | find "@"" (quotes necessary) A> set @AltF10=recall A> set @ShiftF8=^autoexec.bat^ Some examples of using the above defined Macros from the DOS command line follow: keystrokes equivalent ---------- ---------- A> <Alt-F10> A> recall<Enter> A> <Ctrl-F5> A> set | find "@"<Enter> A> <Ctrl-F6>*.bat A> DIR *.bat A> edit <Shift-F8> A> edit autoexec.bat A> altF10 /ins+ <Enter> A> recall /ins+ <Enter> Notice, in the last example, that a Function Key Macro is being used as an Alias. Function Key Macros can be defined on the fly, but those used often should be added to AUTOEXEC.BAT. Function Key Macros could be very useful in the implementation of Batch Menus. -------------------------- Environment Substitution ------------------------- Environment Substitution is similar to Aliasing. An Environment Variable's equivalent string can be inserted into a command line by proceeding the Environment Variable with a single quote, ('), or enclosing it between single quotes. For example: A> echo The path is 'path' and today is Friday. The path is C:\DOS;C:\UTILS and today is Friday. Environment Variables are defined with the DOS SET command: A> set a=autoexec.bat A> set @r=recall Column 1 below shows how Environment Substitution is invoked. Column 2 shows how the command would have to be typed without Environment Substitution. For users who understand DOS Batch Language, column 3 shows an equivalent line in a Batch File. The following examples use the Environment Variables defined with the above SET commands: Examples equivalent Batch Language -------- ---------- -------------- A> type 'a' A> type autoexec.bat A> type %a% A> r 'a A> recall autoexec.bat A> %@r% %a% A> echo '@r 'a A> echo recall autoexec.bat A> echo %@r% %a% Environment Substitution works anywhere on the command line, whereas Aliasing, described elsewhere in this document, works only at the far left of the command line. --------------------------- Environment Completion -------------------------- Environment Completion is similar to Environment Substitution, but allows the user to edit the Environment Variable equivalent string before pressing <Enter>. Environment Completion allows a user to edit long Environment Variable definitions. When <F8> is pressed, the last word on the command line is looked up in the Environment. If a match is found, an equal sign and the Environment Variable equivalent string are placed at the end of the line for further editing. Without Command Line RECALL, a change to the PATH Environment Variable requires retyping the whole path. The following example shows how easy changing the PATH can be: A> path press <F8> A> path=C:\DOS;C:\UTILS;C:\EDIT continue editing ---------------------- Filename and Dirname Completion ---------------------- Filename Completion allows a user to type a few characters of a filename, then press <F10> to complete the filename. <F10> can be pressed again and again to view other possible completions of the filename. No matter where the cursor is located, Command Line RECALL uses the last word on the line to look for a matching file. A blank at the end of the line is just like a '*.*' at the end of the line. The following examples demonstrate the use of Filename Completion. The second column shows how Command Line RECALL searches for matching filenames: examples what is searched for -------- -------------------- A> type<F10> TYPE*.* no space before <F10> A> type <F10> *.* space before <F10> A> copy \dos\.com<F10> \DOS\*.COM A> edit a:subdir\<F10> A:SUBDIR\*.* A> del c:\xyz?.<F10> C:\XYZ?. A> type J:\xyz*<F10> J:\XYZ*.* Dirname Completion, <F9>, works just like Filename Completion, <F10>, except that only subdirectory names are matched. The following example shows how to use Dirname Completion and Filename Completion to search through a hard disk directory tree for a file. This particular example searches for a filename for a COPY command: keys display ---- ------- copy s C:\> copy s <F9> C:\> copy STUFF <F9> C:\> copy SYS \ C:\> copy SYS\ <F9> C:\> copy SYS\DOS \c C:\> copy SYS\DOS\c <F10> C:\> copy SYS\DOS\COMMAND.COM <F10> C:\> copy SYS\DOS\CHKDSK.COM ------------------------------ Technical Notes ------------------------------ This section is not for everyone. Skip it if seems too complicated or too boring. Command Line RECALL is a Terminate-and-Stay-Resident (TSR) program which traps and completely handles Interrupt 21H, service 0aH, also known as Buffered Keyboard Input. All other Interrupt 21 calls except 0a are passed directly to DOS. Command Line RECALL can be called from programs written in Assembly Language or in a high level language. When a program calls INT 21 with register AH=0a, instead of using the old command line editor provided with DOS, the program now has use of all the editing features explained in this document. This provides an easy way for a program to get user input. Remember, that programs that run under DOS use Buffer 2 and use the '#' character for Aliases and Function Key Macros. Buffered Keyboard Input can be called from Assembly Language. The following example is not a complete program, rather Data and Code fragments: ;*** Data *** TEMPLATE db 81 ;max len of buffered input (incl CR) db ? ;returned len goes here (not incl CR) db 81 dup(?) ;returned buffered input chars go here ;*** Code *** mov dx,offset TEMPLATE ;DS:DX -> Template mov ah,0aH ;Buffered Keyboard Input int 21H mov si,dx ;DS:SI -> Template mov ch,0 ;CX <- len of user input mov cl,[si+1] add si,2 ;DS:SI -> user input characters The high level language, C, can also be used to access Buffered Keyboard Input. The following is a complete C program: /* DOS interrupt with AL and DX arg1,arg2,arg3 -- AH,DX,AL */ extern int bdos(int, unsigned int, unsigned int); struct template { /* Template for Buffered Keyboard Input */ char max_len; /* maximum return len (incl CR) */ char ret_len; /* len of user input (not incl CR) */ char ret_chars[21]; /* user input characters */ }; main() { struct template bfr; bfr.max_len = 21; /* maximum return len (incl CR) */ printf("Press ^C when Done\n"); while (1) { /* infinite loop */ bdos(10, (unsigned int)&bfr, 0); /* buffered keyboard input */ /* change terminator from CR to NULL, and print results */ *(bfr.ret_chars + (int)bfr.ret_len) = '\0'; printf("\n%s *** Len = %i ***\n", bfr.ret_chars, bfr.ret_len); /* change terminator back to CR */ *(bfr.ret_chars + (int)bfr.ret_len) = '\r'; } } Command Line RECALL was written in a mixture of Assembly Language and C. To reduce the memory requirements, the part of RECALL.COM that becomes memory resident was written almost entirely in Assembly Language. C was used to write the part of RECALL.COM which handles the various command line options. The memory resident part of Command Line RECALL is executing when the computer is at the DOS prompt. It is possible that Command Line RECALL will spend more time executing than all other programs combined. Most of Command Line RECALL's execution time is spent waiting for user keystrokes. Command Line RECALL uses INT 21H, Service 8 for keyboard input. This insures compatibility with DOS piping. In an attempt at maximum compatibility, the only ascii keystrokes assigned to functions are: <Enter> ascii 13 <Ctrl-Enter> ascii 10 <BackSpace> ascii 8 redefinable <Ctrl-BackSpace> ascii 127 redefinable <Esc> ascii 27 <Tab> ascii 9 <Ctrl-V> ascii 22 To prevent a user from accidentally hosing the DOS pipeline, only two keys from the above list can be redefined. Command Line RECALL uses INT 10H, service 0aH for display output. This is a departure from the more traditional INT 10H, service 0eH. Command Line RECALL assumes that after it becomes memory resident, the first program requesting Buffered Keyboard Input is DOS. In this way, calls by DOS (Buffer 1) can be differentiated from calls by programs that run under DOS (Buffer 2). If RECALL.COM is memory installed from AUTOEXEC.BAT, and DEBUG is run after RECALL.COM in AUTOEXEC.BAT, Command Line RECALL will be faked out and will not behave correctly. Every program that runs under DOS receives a copy of the DOS Environment. When Command Line RECALL is run for the first time, it receives a copy of the DOS Environment. Before Command Line RECALL makes itself memory resident, it throws away its copy of the DOS Environment and uses COMMAND.COM's Environment, instead. Therefore, after Command Line RECALL becomes memory resident, it will notice changes made to the Environment. When an application is run it receives a copy of the Environment. When a user Shells out of an application, the DOS Shell will be working with a copy of a copy of the Environment. Changes made to the Environment when Shelled out of an application will not be noticed by Command Line RECALL. The DOS Environment is used heavily by Command Line RECALL's Aliasing and Macros features. It may be necessary to expand the Environment Size by including a SHELL statement in CONFIG.SYS, for example: SHELL = C:\COMMAND.COM /P /E:nnnn With DOS 3.x and higher, the 'nnnn' is the Environment Size in bytes. To allocate a 1K Environment: SHELL = C:\COMMAND.COM /P /E:1024 With DOS 2.x, the 'nnnn' is the Environment Size in 16 byte paragraphs. To allocate a 1K Environment: SHELL = C:\COMMAND.COM /P /E:64 On a non-hard disk system with DOS 3.x: SHELL = A:\COMMAND.COM /P /E:1024 Consult a DOS manual for more details. ---------------------------------- Updates ---------------------------------- To update to the latest version of Command Line RECALL, write: Roger Roth Command Line RECALL PO Box 840 West Jordan, UT 84084-0840 Include $20 (shipping/handling) and mailing label. Specify 5.25" or 3.5". Diskette will include approximately 15 other utilities, including: KEYBUF memory resident 160 character keyboard type ahead buffer KBD keyboard repeat rate, shift bits, stuff type ahead buffer CLEAR set display rows, columns, colors, cursor in text modes SEARCH find text strings in ascii files WTO standard output with escape sequences and optional (Y/N) response RENN rename files, move files, rename directories with verify