This chapter describes how to use the Single-Line (SL) command editor. In general, SL lets you store, recall, manipulate, and edit command lines. Using SL saves you time, because SL streamlines the command-issuing process.

You can use most SL functionality with any distributed RT--11 monitor. However, you must be running a mapped monitor to use the powerful RECALL command function, and using SL under a mapped monitor requires the least amount of limited low memory.

This chapter contains the following information: (unnumbered) Reasons for using SL Turning on SL Editing the command line Storing and recalling commands Turning on SLMIN

Use the on-line index utility, INDEX, and see the on-line help utility, HELP, for more information on topics described in this chapter. (Why You Should Use SL)

Use SL for any of the following reasons: (NUMBERED) Computers are often used for repetitive tasks. Likewise, you are often required to repeat tasks when you use your computer. For example, suppose you must initialize a dozen floppy diskettes and examine those diskettes for bad blocks. Without SL, you have to type the following command a dozen times (where (ddn:) represents your diskette drive and unit number): (.)(INITIALIZE/BADBLOCKS/NOQUERY ddn: (RET))

Using SL, you type (issue) that command once. Then, when it is time to reissue that command, you press ( (UPARROW) ) and then press (RETURN). Pressing ( (UPARROW) ) recalls that command and pressing (RETURN) issues it. Suppose you mistype a command. RT--11 returns an error message indicating an invalid command or option to that command. Without SL, you retype that command (and perhaps mistype it again). Using SL, you press ( (UPARROW) ) to recall that command. You then examine the command, determine your mistake, correct your mistake using SL, and press (RETURN). You often reissue a command after modifying just a small fragment of that command. Without SL, you retype the entire command. Using SL, you recall the command, edit the small fragment using SL, and reissue the command. SL stores previous commands in a 512-byte buffer. Under any RT--11 monitor, you can continuously press ( (UPARROW) ) to scroll through those previous commands. You then press (RETURN) to issue any of those previous commands.

Under a mapped monitor, you can use the SL command RECALL/ALL to display the stored commands. You can then recall a specific command by using either the number displayed next to each command or the shortest unambiguous abbreviation for that command. You then press (RETURN) to issue that recalled command. You often repeat a set of commands. You might repeatedly edit, compile, link, and run a program. Without SL, you type the same set of commands repeatedly as you debug your code. Using the functionality, (set cycle) and (cycle), you use just three keystrokes to sequentially display and repeat each command in the set. You may find that you often issue a particular command. SL lets you save one command that you can issue whenever you need it.

This chapter describes and provides examples of how to perform those functions. You can also use the distributed on-line index program, INDEX, to find all references to SL in the RT--11 documentation. (Turning on SL\sl_on_sec)

The RT--11 monitor you are using determines which SL functionality is available. You enable different SL functionality by specifying various conditions with the SET SL command. All SL set conditions are described in the (SUG_BOOK). The SL conditions described in this chapter are: (2\10) (KED\Turns on keypad editing functionality. Keypad editing is available under all RT--11 monitors. ) (KMON\Turns on SL and sets it to edit only keyboard monitor commands. The KMON condition can be used under all RT--11 monitors. ) (OFF\Turns off SL under all monitors. ) (ON\Turns on SL and sets it to edit both keyboard monitor and CSI commands. If you use the CSI command syntax, you should turn on SL, using the ON condition. Otherwise, use the KMON condition. Because this chapter uses only keyboard monitor commands, the KMON condition is shown. ) (RECALL\Lets you use the RECALL keyboard command. RECALL can be used with only a mapped monitor. ) (SYSGEN\Matches certain SL characteristics with any RT--11 monitor you may have built, using the SYSGEN procedure. Setting the SYSGEN condition is described further in this section. ) (VT102\Matches certain SL characteristics with the VT200 and VT300 series video terminals, making SL more efficient with those terminals. )

Use one of the following two series of commands to turn on SL:

(If you are not running a mapped monitor:\BOLD)

Issue the following command (omit the VT102 conditional if not using VT200 or VT300 series terminals): (.)(SET SL VT102,KED,KMON (RET))

If RT--11 returns an error message indicating an invalid command, a conflict may exist between SYSGEN conditions for your monitor and SL. RT--11 cannot install SL. Issue the following commands to match SL with your RT--11 monitor's characteristics: (.)(SET SL SYSGEN (RET)) (.)(INSTALL SL (RET)) (.)(SET SL KED,KMON (RET))

(If you are running a mapped monitor:\BOLD)

Issue the following command (omit the VT102 conditional if not using VT200 or VT300 series terminals): (.)(SET SL VT102,RECALL,KED,KMON (RET))

If RT--11 returns an error message indicating an invalid command, a conflict may exist between SYSGEN conditions for your monitor and SL. RT--11 cannot install SL. Issue the following commands to match SL with your RT--11 monitor's characteristics: (.)(SET SL SYSGEN (RET)) (.)(INSTALL SL (RET)) (.)(SET SL RECALL,KED,KMON (RET)) (Editing the Command Line\sl_ed_sec)

One of the major SL functions is command line editing. Without command line editing, any change you want to make to a command line requires that you delete all characters from your current cursor position to the character you want to change or add. Because you turned on SL in the previous section, you can now move the cursor directly to that part of the command line you want to change without having to delete any intervening characters.

Two levels of editing functionality are available to you. The first level, the basic level, is available when you turn on SL. An enhanced level, keypad editing, is available when you set the SL condition KED. No memory penalty occurs with turning on keypad editing; the keypad editing functionality uses no extra computer memory.

Because you set the SL condition KED when you turned on SL in (sl_on_sec), you have both levels of functionality available and you can combine the features of both levels.

You should understand basic command line editing before you examine the enhanced functionality available with keypad command line editing. (Basic Editing of the Command Line\sl_ed_bas_sec)

Basic command line editing generally involves two types of operations: (NUMBERED) First, you use the arrow keys to move your cursor through the command line and into and out of the stack of previous commands. You use ( (LEFTARROW) ) and ( (RIGHTARROW) ) to move through the command line. If you need to recall a command before editing, you use ( (UPARROW) ) and ( (DOWNARROW) ) to move through the command stack to recall that command. Once you have placed your cursor at the desired location, you use other keypad and keyboard keys to delete, add, and manipulate characters within the command line.

As SL is distributed, any character you type within a command line is added; that functionality is called INSERT mode. You can change that functionality while editing a command line so that any character you type replaces the character located at the cursor position; that is called REPLACE mode. You alternate between INSERT and REPLACE mode by pressing (CTRL/A). SL returns to INSERT mode each time you press (RETURN) to issue a command.

The following table lists the keypad and keyboard keys you can use with basic command line editing and their functions. Following the table is an exercise that demonstrates using those keys.

(2\20) (Key\Function) ((PF1)\Changes the function of other keys when used in combination with them. Also referred to as the GOLD key. ) ((PF1) ( S )\Saves the displayed command. The ( S ) key is located on your main keyboard and is not case sensitive. ) ((PF1) ( X )\Displays the saved command. The ( X ) key is located on your main keyboard and is not case sensitive. ) ((PF2)\Displays a screen of helpful SL information on the top half of your screen (above the command line). If you first issue the command, SET SL LEARN, subsequently pressing (PF2) causes the SL help screen to be locked onto the display. Issue the command SET SL NOLEARN to remove the help screen. ) ((PF4)\Delete line function key. Deletes command line from cursor position to end of line. The (PF1) (PF4) combination restores the deleted line. ) (( (UPARROW) ) or (CTRL/E)\Moves the cursor into the command stack, displaying previous commands. The (PF1) ( (UPARROW) ) combination displays the next command in the current cycle of commands. This cycle functionality is described in (sl_cyc_sec). ) (( (DOWNARROW) ) or (CTRL/V)\Moves the cursor out of the command stack, displaying previous commands. The (PF1) ( (DOWNARROW) ) combination establishes an offset into the stack of previous commands. This set cycle functionality is described in (sl_cyc_chng_sec). ) (( (LEFTARROW) ) or (CTRL/D)\ Moves the cursor toward the beginning of the command line. The (PF1) ( (LEFTARROW) ) combination moves the cursor to the beginning of the command line. ) (( (RIGHTARROW) )\Moves the cursor toward the end of a command line. The (PF1) ( (RIGHTARROW) ) combination moves the cursor to the end of the command line. ) ((LINE FEED) or (CTRL/J)\Deletes the element of command syntax to the left of the cursor. An element of syntax can be the device handler name and unit number, file name, file type or extension, command, any options, and any arguments to those options. ) ((DELETE)\Deletes the character to the left of the cursor. The (PF1) (DELETE) combination restores that deleted character or character position. ) ((BACKSPACE)or (CTRL/H)\Switches the character at the current cursor position with the character to the right of the cursor and moves the cursor to the right. The (PF1) (BACKSPACE) combination switches the character at the current cursor position with the character to the left of the cursor and moves the cursor to the left. ) ((CTRL/B)\Requires that TT is set to condition NOFB. Same as ( (UPARROW) ) ) ((CTRL/F)\Requires that TT is set to condition NOFB. Same as ( (RIGHTARROW) ) ) ((CTRL/R) or (CTRL/W)\Redisplays the current command line. Use (CTRL/R) or (CTRL/W) to refresh the command line on your terminal screen if the command line becomes garbled or corrupted. ) ((CTRL/U)\ Deletes all characters from the current cursor position to the beginning of the command line. The (PF1) (CTRL/U) combination restores those deleted characters. ) ((RETURN)\Issues the currently displayed command. You can press (RETURN) and issue a command no matter where the current cursor position in that command. The (PF1) (RETURN) combination truncates the command (deletes all characters from the cursor position to the end of the command line) and issues the truncated command. )

The following exercise shows basic command line editing: (NUMBERED) Type the following command but do not press (RETURN): (.)(DIRECTORY/FULL SY:) Press (PF1) and (S) to save that command. You could press (RETURN) and issue that command. However, for the purpose of this exercise, press (CTRL/U) to delete the command line. Issue the following misspelled command exactly as shown: (.)(DILECTORY/PROTECT/ODRER:SIZE SY: (RET))

RT--11 returns an error message indicating an invalid command or that the command does not exist. Press the ( (UPARROW) ) key. SL recalls the previous command: .DILECTORY/PROTECT/ODRER:SIZE SY: Examine that command line and note that the command DIRECTORY is misspelled as DI(L)ECTORY and the option /ORDER:SIZE is misspelled as /O(DR)ER-:SIZE. Press (PF1) and ( (LEFTARROW) ). The cursor is then located at the beginning of the command line. Press ( (RIGHTARROW) ) until your cursor is positioned at the E character in DIL(E)CTORY: .DIL(E)CTORY/PROTECT/ODRER:SIZE SY:

(If you go too far, you can return using ( (LEFTARROW) ).) Press (DELETE). Type the letter R. Correct the misspelled option /ODRER/SIZE. Press ( (RIGHTARROW) ) until the cursor rests on the letter D: .DIRECTORY/PROTECT/O(D)RER:SIZE SY: Press (CTLR/H) to switch the letter D with the letter to the right of it (R). Press (RETURN).

You have corrected the command and it executes. Press (PF1) and ( X ) to display the command you saved at the beginning of this exercise. Press (RETURN) to issue that command. Continuously press ( (UPARROW) ) to verify you have stored the commands you issued in this exercise on your stack of previous commands. After you display all the commands on your stack of previous commands, you are returned to the monitor prompt (.). Press and hold down the ( (DOWNARROW) ) key. You scroll back out through your stack of previous commands to the monitor prompt (.). (Keypad Editing of the Command Line)

The keypad method lets you use your keypad editing keys to recall command lines, move the cursor, and edit the command line. This method requires that you know the function of the keypad keys.

In keypad mode, you use the keypad to edit the command line as you would use the keypad from within the KED editor. Use the KED keypad functions appropriate for editing text within a single line. The following table lists those keypad keys you use to recall commands, move the cursor, and edit command lines. Following the table is a series of exercises that demonstrate using those keys.

(2\20) (Key\Function) ((PF1)\ Changes the function of other keys when used in combination with them. Also referred to as the GOLD key. ) ((PF2)\Displays a HELP frame on your terminal screen. ) ((PF4)\Deletes the command line from the cursor position to the end of the command line. The (PF1) (PF4) combination restores that deleted command line. ) (( 0 )\Moves the cursor to the beginning of the command line. If the cursor is at the beginning of the command line, ( 0 ) moves the cursor to the beginning of next previous or next most recent command line. The (PF1) ( 0 ) combination is the open-line function. Produces a blank line for entering a command. ) (( 1 )\ Causes the cursor to move across one element of syntax. An element of syntax can be the device handler name and unit number, file name, file type or extension, command, any options, and any arguments to those options. ) (( 2 )\Moves the cursor to the end of the command line. If the cursor is at the end of the command line, ( 2 ) moves the cursor to the end of the next previous or next recent command line. The (PF1) ( 2 ) combination deletes all characters from the cursor position to the end of line. ) (( 3 )\Moves the cursor one character position. ) (( 4 )\Causes subsequent cursor movement to be forward. ) (( 5 )\Causes subsequent cursor movement to be in reverse. ) (( , )\ Deletes one character at the cursor position. The (PF1) ( , ) combination restores that deleted character. ) (( - )\ Deletes one element of command syntax at the cursor position. An element of syntax can be the device handler name and unit number, file name, file type or extension, command, any options, and any arguments to those options. The (PF1) ( - ) combination restores that element of command syntax. ) ((ENTER)\Issues the displayed command. Equivalent to (RETURN) key. )

The keypad keys ( . ) ( 6 ) ( 7 ) ( 8 ) ( 9 ) and (PF3) are not implemented.

(Exercises\BOLD)

The following exercises demonstrate keypad command line editing:

(Exercise 1\BOLD)

This exercise recalls a command you typed previously and corrects the misspelling in that command. (NUMBERED) Press the ( 5 ) ( 0 ) keypad keys until the following misspelled command is displayed: .(D)ILECTORY/PROTECT/ODRER:SIZE SY:

Your cursor is resting at the beginning of the command line. Press the ( 4 ) keypad key to direct cursor motion forward. Press the ( 3 ) keypad key twice so the cursor rests on the letter L: .DI(L)ECTORY/PROTECT/ODRER:SIZE SY: Press the ( , ) keypad key to delete the letter L. Type the letter R. Press the ( 1 ) keypad key twice and the ( 3) keypad key once so the cursor rests on the D: .DIRECTORY/PROTECT/O(D)RER:SIZE SY: Press the ( , ) keypad key to delete the letter D. Press the ( 3 ) keypad key to advance the cursor one character and type D. Press (RETURN).

The command executes.

(Exercise 2\BOLD)

This exercise recalls a previous command and changes an option argument. You also change the device for which you want the directory from your default data (DK) to system (SY) device. (NUMBERED) Press the ( 5 ) ( 0 ) keypad keys to recall the command: .(D)IRECTORY/PROTECT/ORDER:SIZE SY: Press the ( 4 ) keypad key to change the cursor motion to forward. Press the ( 1 ) keypad key three times to move forward three syntax elements: .DIRECTORY/PROTECT/ORDER:(S)IZE SY: Press the ( - ) keypad key to delete SIZE. Type DATE and press the space bar. Press the ( - ) keypad key to delete SY:. Type DK: and press (ENTER).

The edited command now executes and gives you different information.

(Exercise 3\BOLD)

This exercise recalls the previous command and changes it to return the full directory of your default data (DK) device. (NUMBERED) Press the ( 5 ) ( 0 ) keypad keys to recall the last command: .(D)IRECTORY/PROTECT/ORDER:DATE DK: Press the ( 4 ) ( 1 ) keypad keys: .DIRECTORY/(P)ROTECT/ORDER:DATE DK: Press the ( - ) keypad key three times to delete the command options PROTECT/ORDER:DATE: .DIRECTORY/(D)K: Type FULL, press the space bar, and press (ENTER).

The command executes and displays the full directory of your default data device. (Storing and Recalling Commands)

Another major SL function is storing and recalling previous command lines.

(Storing Commands\BOLD)

SL stores previous commands on its 512-byte command storage stack. Because each character and space you type in a command uses 1 byte of stack storage, you can store more commands by abbreviating commands and options to their shortest unambiguous length.

You can also store a command by explicitly saving it. SL lets you save one command that you can recall whenever you need it.

(Recalling Commands\BOLD)

SL provides five methods for recalling stored commands. If you are using a mapped monitor and have set the SL conditions RECALL and KED (SET SL RECALL,KED), you can use all methods. Otherwise, the indicated restrictions apply. (UNNUMBERED) Arrow key method

Under all monitors, you can use ( (UPARROW) ) and ( (DOWNARROW) ) to scroll into and out of the command storage stack. Keypad method

Under all monitors with the KED condition in effect, you can use the keypad advance and backup motion function keys with the beginning-of-line or end-of-line function keys to move in and out of the command storage stack. Cycling method

Under all monitors, you can use the cycling functionality (set cycle and cycle) to recall continuously a sequence of commands. RECALL command method

To use the RECALL command, you must be using a mapped monitor with the RECALL condition in effect. The RECALL command provides the most direct method for displaying and recalling previous commands. The RECALL command displays a numbered list of previous commands. You can recall any command from that list by using the command number or the shortest unambiguous abbreviation for that command. Save command method

Under all monitors, you can save a displayed command by pressing (PF1) and ( S ). You can then recall that saved command whenever you need it by pressing (PF1) and ( X ).

You issue any recalled command by pressing (RETURN) regardless of the cursor position within that command.

Exercise some caution when issuing a recalled command. Be sure to read carefully the recalled command before pressing (RETURN).

The following sections describe using those methods for recalling stored commands. (Using Arrow Keys to Recall Commands)

Use ( (UPARROW) ) and ( (DOWNARROW) ) to recall (display) previous commands.

Use ( (UPARROW) ) to move into your stack of previous commands. Press and release ( (UPARROW) ) to singly recall previous commands or press and hold ( (UPARROW) ) to scroll into your stack of commands.

Use ( (DOWNARROW) ) to move back out through the stack. Press and release ( (DOWNARROW) ) to singly display commands or press and hold ( (DOWNARROW) ) to scroll out through the command stack to the current (empty) command line.

SL returns to the monitor prompt (.) when you exceed either command stack limit; when you scroll into the stack beyond the first stored command, or scroll out of the stack beyond the last stored command. You can then issue a command in response to that monitor prompt or use the arrow keys to reenter the command stack to recall and issue a previous command. (Using the Keypad to Recall Commands)

If you have enabled keypad editing, using the command SET SL KED, you can use the keypad to scroll into and out of your storage stack of previous commands. Use a combination of four keypad keys to do that.

You use the advance function key, ( 4 ), or the backup function key, ( 5 ), to set the direction of motion through the stack. Pressing ( 5 ) moves you into the stack. Pressing ( 4 ) moves you back out of the stack. You need to set the direction of motion only once, until you want to change it.

The beginning-of-line, ( 0 ), and end-of-line, ( 2 ), function keys determine your cursor placement on the command line, as you move in and out of the command stack.

For example, pressing the keypad sequence, ( 5 ) ( 0 ) ( 0 ), places your cursor at the beginning of the command that resides two entries into the stack. Pressing the keypad key ( 5 ) and then pressing and holding the keypad key ( 0 ) causes SL to scroll through your stack of previous commands with the cursor at the beginning of each command. Pressing ( 4 ) and ( 0 ) in the same manner reverses the process.

SL returns to the monitor prompt (.) when you exceed either command stack limit; when you scroll into the stack beyond the first stored command, or scroll out of the stack beyond the last stored command. You can then issue a command in response to that monitor prompt or use the keypad to reenter the command stack to recall and issue a previous command. (Using the Cycling Method to Recall a Sequence of Commands\sl_cyc_sec)

SL provides the (set cycle) and (cycle) functionality for recalling a sequence of commands. That method is useful when you are repeating an operation that requires a command sequence.

By default, SL lets you continuously repeat the previous two commands as a sequence. SL also lets you determine the number of commands you want to continuously repeat as a sequence. (Default Cycling Functionality)

You can continuously repeat the previous two commands in your command storage stack. That is, the default SL cycle functionality contains an offset of two commands. You access and repeat those two commands as a sequence by pressing (PF1) and ( (UPARROW) ) to access each command and pressing (RETURN) to repeat that command.

The default cycling functionality is useful when you want to continuously repeat the previous two commands. How to change the number of commands you continuously repeat is described in the next section. (Changing the Cycling Functionality\sl_cyc_chng_sec)

You can change the cycling functionality to store an offset into your storage stack of previous commands. After you have issued a series of commands that you then want to repeat, you establish the offset (set the cycle) for the first command in that sequence. You then cycle through that command sequence, return to that first command, and repeat the sequence.

Command sequence cycling is helpful, for example, when debugging source code. Assume you are debugging MACRO source code. That operation may require that you repeatedly edit, assemble, link, and run the code. You may repeatedly issue the commands EDIT filename, MACRO filename, LINK filename, and RUN filename.

After you have issued that sequence of commands, RUN filename is the first stored command on your stack, and EDIT filename is the fourth. Rather than scroll into your stack four positions to repeat each command in the sequence, you can use the set cycle and cycle functionality as follows: (NUMBERED) Use the arrow keys, the keypad, or the RECALL command to recall the first command in the sequence (EDIT filename). Press (PF1) and ( (DOWNARROW) ) to store that offset (set the cycle) into your command stack. Press (RETURN) to issue that command. When you are ready to recall the next command in the sequence, press (PF1) and ( (UPARROW) ). SL recalls the next command in the sequence. Press (RETURN) to issue that command. Continue to press (PF1) and ( (UPARROW) ) to recall successive commands in the sequence. Press (RETURN) to issue each of those commands. When you have issued the last command (RUN filename) and want to repeat the sequence, press (PF1) and ( (UPARROW) ) to recall the command EDIT filename. Press (RETURN) to issue that command.

You can continue to use this command sequence cycle until you change the offset into your stack. You change that offset by issuing, rather than recalling, any command. Therefore, you should think of the set cycle and cycle functionality as a temporary method of recalling a particular command sequence.

(Using RECALL to Display and Recall Commands)

You issue the RECALL command in response to the keyboard monitor prompt (.). You can use the RECALL command to: (UNNUMBERED) Display all previous commands stored in your command storage stack.

The following command displays all stored previous commands: (.)(RECALL/ALL (RET))

SL displays the list of previous commands, as in the following example: .RECALL/ALL (RET) 1 SRUN KEX.SAV * 2 MOUNT LD2: DK:INTRO.DSK 3 SHOW SUBSET .

That display includes all previous commands stored in your command stack. In this example display, SRUN KEX.SAV is the most recent command you issued, indicated by the number 1 next to that command. The asterisk (*) next to the command, MOUNT LD2: DK:INTRO.DSK, indicates that command is first in the current cycle of commands. Recall the previous command.

The RECALL command with no option recalls the most recent previous command: (.)(RECALL (RET)) Recall a command, using the number displayed next to that command.

Assuming that issuing the RECALL/ALL command returns the following example display: .RECALL/ALL (RET) 1 SRUN KEX.SAV * 2 MOUNT LD2: DK:INTRO.DSK 3 SHOW SUBSET .

You can recall the command, SHOW SUBSET, by issuing the following command: (.)(RECALL 3 (RET)) Recall a command, using the shortest unambiguous abbreviation for that command.

Assuming that issuing the RECALL/ALL command returns the following example display: .RECALL/ALL (RET) 1 SRUN KEX.SAV * 2 MOUNT LD2: DK:INTRO.DSK 3 SHOW SUBSET .

You can recall the command, SHOW SUBSET, by issuing the following command: (.)(RECALL SH (RET))

SL does not keep any RECALL command in its stack of previous commands. Therefore, you cannot recall the RECALL command. (Saving a Command)

SL lets you save one command outside the stack of previous commands. You can then recall that command whenever you need it. You save a command, using the following procedure: (NUMBERED) The command you want to save must be displayed. You display a command by either typing it or recalling it from your stack of previous commands.

Do not issue the command; do not press (RETURN). Once the command is displayed, press (PF1) and ( S ).

You can then press (RETURN) to issue that command. However, you do not need to issue the command to save it.

You can now recall the saved command at any time by pressing (PF1) and ( X ). (SLMIN --- The Smallest Single-Line Command Editor)

RT--11 distributes a minimal single-line command editor that contains a subset of the basic command line editing features described in (sl_ed_bas_sec). SLMIN needs less memory than SL. SLMIN can be an appropriate command line editor when you are not using a mapped monitor and you are concerned about low-memory availability. You cannot use SLMIN if you are using a mapped monitor.

Enhanced SL features, such as keypad editing and the RECALL command, are not available under SLMIN.

SLMIN provides all the basic command line editing features described in (sl_ed_bas_sec), except: (UNNUMBERED) There is no help screen. The (PF2) keypad key has no meaning under SLMIN. The stack of previous commands contains only two commands. Pressing (LINE FEED) or (CTRL/J) does not delete previous commands, but rather is equivalent to pressing (RETURN).

All other basic command line editing features are available.

Issue the following commands to preserve the distributed SL and copy SLMIN to SL: (.)(SET SL OFF (RET)) (.)(RENAME SL.SYS SL.DIS (RET)) (.)(COPY SLMIN.SYS SL.SYS (RET)) (.)(REMOVE SL (RET)) (.)(INSTALL SL (RET))

You then turn on SLMIN as SL by issuing the following command: (.)(SET SL KMON (RET))

If you want to return to using the distributed SL, issue the following commands: (.)(SET SL OFF (RET)) (.)(UNPROTECT SL.SYS (RET)) (.)(RENAME SL.SYS SLMIN.SYS (RET)) (.)(RENAME SL.DIS SL.SYS (RET)) (.)(REMOVE SL (RET)) (.)(INSTALL SL (RET)) (.)(SET SL KED,KMON (RET))