_J_O_V_E _M_a_n_u_a_l _f_o_r _U_N_I_X _U_s_e_r_s Jonathan Payne (revised for 4.3BSD by Doug Kingston and Mark Seiden) ABSTRACT _1. _I_n_t_r_o_d_u_c_t_i_o_n _1. _I_n_t_r_o_d_u_c_t_i_o_n JOVE* is an advanced, self-documenting, customizable real-time display editor. It (and this tutorial introduction) are based on the original EMACS editor and user manual written at M.I.T. by Richard Stallman+. JOVE is considered a _d_i_s_p_l_a_y editor because normally the text being edited is visible on the screen and is updated automati- cally as you type your commands. It's considered a _r_e_a_l-_t_i_m_e editor because the display is updated very frequently, usually after each character or pair of charac- ters you type. This minimizes the amount of information you must keep in your head as you edit. JOVE is _a_d_v_a_n_c_e_d because it provides facilities that go beyond simple insertion and deletion: filling of text; automatic inden- tations of programs; view more than one file at once; and dealing in terms of characters, words, lines, sentences and paragraphs. It is much easier to type one command meaning "go to the end of the paragraph" than to find the desired spot with repetition of simpler commands. _S_e_l_f-_d_o_c_u_m_e_n_t_i_n_g means that at almost any time you can easily find out what a command does, or to find all the commands that pertain to a topic. _C_u_s_t_o_m_i_z_a_b_l_e means that you can change the definition of JOVE commands in little ways. For example, you can rearrange the com- mand set; if you prefer to use arrow keys for the four basic cur- sor motion commands (up, down, left and right), you can. Another sort of customization is writing new commands by combining built in commands. __________________________ *JOVE stands for Jonathan's Own Version of Emacs. +Although JOVE is meant to be compatible with EMACS, and indeed many of the basic commands are very similar, there are some major differences between the two editors, and you should not rely on their behaving identically. September 2, 1987 - 2 - _2. _T_h_e _O_r_g_a_n_i_z_a_t_i_o_n _o_f _t_h_e _S_c_r_e_e_n _2. _T_h_e _O_r_g_a_n_i_z_a_t_i_o_n _o_f _t_h_e _S_c_r_e_e_n JOVE divides the screen up into several sections. The biggest of these sections is used to display the text you are editing. The terminal's cursor shows the position of _p_o_i_n_t, the location at which editing takes place. While the cursor appears to point _a_t a character, point should be thought of as between characters; it points _b_e_f_o_r_e the character that the cursor appears on top of. Terminals have only one cursor, and when output is in progress it must appear where the typing is being done. This doesn't mean that point is moving; it is only that JOVE has no way of showing you the location of point except when the terminal is idle. The lines of the screen are usually available for displaying text but sometimes are pre-empted by typeout from certain commands (such as a listing of all the editor commands). Most of the time, output from commands like these is only desired for a short period of time, usually just long enough to glance at it. When you have finished looking at the output, you can type Space to make your text reappear. (Usually a Space that you type inserts itself, but when there is typeout on the screen, it does nothing but get rid of that). Any other command executes normally, _a_f_t_e_r redrawing your text. _2._1. _T_h_e _M_e_s_s_a_g_e _L_i_n_e _2._1. _T_h_e _M_e_s_s_a_g_e _L_i_n_e The bottom line on the screen, called the _m_e_s_s_a_g_e _l_i_n_e, is reserved for printing messages and for accepting input from the user, such as filenames or search strings. When JOVE prompts for input, the cursor will temporarily appear on the bottom line, waiting for you to type a string. When you have finished typing your input, you can type a Return to send it to JOVE. If you change your mind about running the command that is waiting for input, you can type Control-G to abort, and you can continue with your editing. When JOVE is prompting for a filename, all the usual editing facilities can be used to fix typos and such; in addition, JOVE has the following extra functions: ^N Insert the next filename from the argument list. ^P Insert the previous filename from the argument list. ^R Insert the full pathname of the file in the current buffer. Sometimes you will see --more-- on the message line. This hap- pens when typeout from a command is too long to fit in the screen. It means that if you type a Space the next screenful of typeout will be printed. If you are not interested, typing any- thing but a Space will cause the rest of the output to be dis- carded. Typing C-G will discard the output and print _A_b_o_r_t_e_d where the --more-- was. Typing any other command will discard September 2, 1987 - 3 - the rest of the output and also execute the command. The message line and the list of filenames from the shell command that invoked JOVE are kept in a special buffer called _M_i_n_i_b_u_f that can be edited like any other buffer. _2._2. _T_h_e _M_o_d_e _L_i_n_e _2._2. _T_h_e _M_o_d_e _L_i_n_e At the bottom of the screen, but above the message line, is the _m_o_d_e _l_i_n_e. The mode line format looks like this: JOVE (major minor) Buffer: bufr "file" * _m_a_j_o_r is the name of the current _m_a_j_o_r _m_o_d_e. At any time, JOVE can be in only one major mode at a time. Currently there are only four major modes: _F_u_n_d_a_m_e_n_t_a_l, _T_e_x_t, _L_i_s_p and _C. _m_i_n_o_r is a list of the minor modes that are turned on. Abbrev means that _W_o_r_d _A_b_b_r_e_v mode is on; AI means that _A_u_t_o _I_n_d_e_n_t mode is on; Fill means that _A_u_t_o _F_i_l_l mode is on; OvrWt means that _O_v_e_r _W_r_i_t_e mode is on. Def means that you are in the process of defining a keyboard macro. This is not really a mode, but it's useful to be reminded about it. The meanings of these modes are described later in this document. _b_u_f_r is the name of the currently selected _b_u_f_f_e_r. Each buffer has its own name and holds a file being edited; this is how JOVE can hold several files at once. But at any given time you are editing only one of them, the _s_e_l_e_c_t_e_d buffer. When we speak of what some command does to "the buffer", we are talking about the currently selected buffer. Multiple buffers makes it easy to switch around between several files, and then it is very useful that the mode line tells you which one you are editing at any time. (You will see later that it is possible to divide the screen into multiple _w_i_n_d_o_w_s, each showing a different buffer. If you do this, there is a mode line beneath each window.) _f_i_l_e is the name of the file that you are editing. This is the default filename for commands that expect a filename as input. The asterisk at the end of the mode line means that there are changes in the buffer that have not been saved in the file. If the file has not been changed since it was read in or saved, there is no asterisk. _3. _C_o_m_m_a_n_d _I_n_p_u_t _C_o_n_v_e_n_t_i_o_n_s _3. _C_o_m_m_a_n_d _I_n_p_u_t _C_o_n_v_e_n_t_i_o_n_s _3._1. _N_o_t_a_t_i_o_n_a_l _C_o_n_v_e_n_t_i_o_n_s _f_o_r _A_S_C_I_I _C_h_a_r_a_c_t_e_r_s _3._1. _N_o_t_a_t_i_o_n_a_l _C_o_n_v_e_n_t_i_o_n_s _f_o_r _A_S_C_I_I _C_h_a_r_a_c_t_e_r_s In this manual, "Control" characters (that is, characters that are typed with the Control key and some other key at the same time) are represented by "C-" followed by another character. September 2, 1987 - 4 - Thus, C-A is the character you get when you type A with the Con- trol key (sometimes labeled CTRL) down. Most control characters when present in the JOVE buffer are displayed with a caret; thus, ^A for C-A. Rubout (or DEL) is displayed as ^?, escape as ^[. _3._2. _C_o_m_m_a_n_d _a_n_d _F_i_l_e_n_a_m_e _C_o_m_p_l_e_t_i_o_n _3._2. _C_o_m_m_a_n_d _a_n_d _F_i_l_e_n_a_m_e _C_o_m_p_l_e_t_i_o_n When you are typing the name of a JOVE command, you need type only enough letters to make the name unambiguous. At any point in the course of typing the name, you can type question mark (?) to see a list of all the commands whose names begin with the characters you've already typed; you can type Space to have JOVE supply as many characters as it can; or you can type Return to complete the command if there is only one possibility. For exam- ple, if you have typed the letters "_a_u" and you then type a ques- tion mark, you will see the list auto-execute-command auto-execute-macro auto-fill-mode auto-indent-mode If you type a Return at this point, JOVE will complain by ringing the bell, because the letters you've typed do not unambiguously specify a single command. But if you type Space, JOVE will sup- ply the characters "_t_o-" because all commands that begin "_a_u" also begin "_a_u_t_o-". You could then type the letter "_f" followed by either Space or Return, and JOVE would complete the entire command. Whenever JOVE is prompting you for a filename, say in the _f_i_n_d- _f_i_l_e command, you also need only type enough of the name to make it unambiguous with respect to files that already exist. In this case, question mark and Space work just as they do in command completion, but Return always accepts the name just as you've typed it, because you might want to create a new file with a name similar to that of an existing file. _4. _C_o_m_m_a_n_d_s _a_n_d _V_a_r_i_a_b_l_e_s _4. _C_o_m_m_a_n_d_s _a_n_d _V_a_r_i_a_b_l_e_s JOVE is composed of _c_o_m_m_a_n_d_s which have long names such as _n_e_x_t- _l_i_n_e. Then _k_e_y_s such as C-N are connected to commands through the _c_o_m_m_a_n_d _d_i_s_p_a_t_c_h _t_a_b_l_e. When we say that C-N moves the cur- sor down a line, we are glossing over a distinction which is unimportant for ordinary use, but essential for simple customiza- tion: it is the command _n_e_x_t-_l_i_n_e which knows how to move a down line, and C-N moves down a line because it is connected to that command. The name for this connection is a _b_i_n_d_i_n_g; we say that the key C-N _i_s _b_o_u_n_d _t_o the command _n_e_x_t-_l_i_n_e. Not all commands are bound to keys. To invoke a command that isn't bound to a key, you can type the sequence ESC X, which is bound to the command _e_x_e_c_u_t_e-_n_a_m_e_d-_c_o_m_m_a_n_d. You will then be September 2, 1987 - 5 - able to type the name of whatever command you want to execute on the message line. Sometimes the description of a command will say "to change this, set the variable _m_u_m_b_l_e-_f_o_o". A variable is a name used to remember a value. JOVE contains variables which are there so that you can change them if you want to customize. The variable's value is examined by some command, and changing that value makes the command behave differently. Until you are interesting in customizing JOVE, you can ignore this information. _4._1. _P_r_e_f_i_x _C_h_a_r_a_c_t_e_r_s _4._1. _P_r_e_f_i_x _C_h_a_r_a_c_t_e_r_s Because there are more command names than keys, JOVE provides _p_r_e_f_i_x _c_h_a_r_a_c_t_e_r_s to increase the number of commands that can be invoked quickly and easily. When you type a prefix character JOVE will wait for another character before deciding what to do. If you wait more than a second or so, JOVE will print the prefix character on the message line as a reminder and leave the cursor down there until you type your next character. There are two prefix characters built into JOVE: Escape and Control-X. How the next character is interpreted depends on which prefix character you typed. For example, if you type Escape followed by B you'll run _b_a_c_k_w_a_r_d-_w_o_r_d, but if you type Control-X followed by B you'll run _s_e_l_e_c_t-_b_u_f_f_e_r. Elsewhere in this manual, the Escape key is indicated as "ESC", which is also what JOVE displays on the mes- sage line for Escape. _4._2. _H_e_l_p _4._2. _H_e_l_p To get a list of keys and their associated commands, you type ESC X _d_e_s_c_r_i_b_e-_b_i_n_d_i_n_g_s. If you want to describe a single key, ESC X _d_e_s_c_r_i_b_e-_k_e_y will work. A description of an individual command is available by using ESC X _d_e_s_c_r_i_b_e-_c_o_m_m_a_n_d, and descriptions of variables by using ESC X _d_e_s_c_r_i_b_e-_v_a_r_i_a_b_l_e. If you can't remember the name of the thing you want to know about, ESC X _a_p_r_o_p_o_s will tell you if a command or variable has a given string in its name. For example, ESC X _a_p_r_o_p_o_s _d_e_s_c_r_i_b_e will list the names of the four describe commands mentioned briefly in this section. _5. _B_a_s_i_c _E_d_i_t_i_n_g _C_o_m_m_a_n_d_s _5. _B_a_s_i_c _E_d_i_t_i_n_g _C_o_m_m_a_n_d_s _5._1. _I_n_s_e_r_t_i_n_g _T_e_x_t _5._1. _I_n_s_e_r_t_i_n_g _T_e_x_t To insert printing characters into the text you are editing, just type them. All printing characters you type are inserted into the text at the cursor (that is, at _p_o_i_n_t), and the cursor moves forward. Any characters after the cursor move forward too. If the text in the buffer is FOOBAR, with the cursor before the B, then if you type XX, you get FOOXXBAR, with the cursor still before the B. September 2, 1987 - 6 - To correct text you have just inserted, you can use Rubout. Rubout deletes the character _b_e_f_o_r_e the cursor (not the one that the cursor is on top of or under; that is the character _a_f_t_e_r the cursor). The cursor and all characters after it move backwards. Therefore, if you typing a printing character and then type Rubout, they cancel out. To end a line and start typing a new one, type Return. Return operates by inserting a _l_i_n_e-_s_e_p_a_r_a_t_o_r, so if you type Return in the middle of a line, you break the line in two. Because a line-separator is just a single character, you can type Rubout at the beginning of a line to delete the line-separator and join it with the preceding line. As a special case, if you type Return at the end of a line and there are two or more empty lines just below it, JOVE does not insert a line-separator but instead merely moves to the next (empty) line. This behavior is convenient when you want to add several lines of text in the middle of a buffer. You can use the Control-O (_n_e_w_l_i_n_e-_a_n_d-_b_a_c_k_u_p) command to "open" several empty lines at once; then you can insert the new text, filling up these empty lines. The advantage is that JOVE does not have to redraw the bottom part of the screen for each Return you type, as it would ordinarily. That "redisplay" can be both slow and dis- tracting. If you add too many characters to one line, without breaking it with Return, the line will grow too long to display on one screen line. When this happens, JOVE puts an "!" at the extreme right margin, and doesn't bother to display the rest of the line unless the cursor happens to be in it. The "!" is not part of your text; conversely, even though you can't see the rest of your line, it's still there, and if you break the line, the "!" will go away. Direct insertion works for printing characters and space, but other characters act as editing commands and do not insert them- selves. If you need to insert a control character, Escape, or Rubout, you must first _q_u_o_t_e it by typing the Control-Q command first. _5._2. _M_o_v_i_n_g _t_h_e _C_u_r_s_o_r _5._2. _M_o_v_i_n_g _t_h_e _C_u_r_s_o_r To do more than insert characters, you have to know how to move the cursor. Here are a few of the commands for doing that. C-A Move to the beginning of the line. C-E Move to the end of the line. C-F Move forward over one character. C-B Move backward over one character. September 2, 1987 - 7 - C-N Move down one line, vertically. If you start in the middle of one line, you end in the middle of the next. C-P Move up one line, vertically. ESC < Move to the beginning of the entire buffer. ESC > Move to the end of the entire buffer. ESC , Move to the beginning of the visible window. ESC . Move to the end of the visible window. _5._3. _E_r_a_s_i_n_g _T_e_x_t _5._3. _E_r_a_s_i_n_g _T_e_x_t Rubout Delete the character before the cursor. C-D Delete the character after the cursor. C-K Kill to the end of the line. You already know about the Rubout command which deletes the char- acter before the cursor. Another command, Control-D, deletes the character after the cursor, causing the rest of the text on the line to shift left. If Control-D is typed at the end of a line, that line and the next line are joined together. To erase a larger amount of text, use the Control-K command, which kills a line at a time. If Control-K is done at the begin- ning or middle of a line, it kills all the text up to the end of the line. If Control-K is done at the end of a line, it joins that line and the next line. If Control-K is done twice, it kills the rest of the line and the line separator also. _5._4. _F_i_l_e_s - _S_a_v_i_n_g _Y_o_u_r _W_o_r_k _5._4. _F_i_l_e_s - _S_a_v_i_n_g _Y_o_u_r _W_o_r_k The commands above are sufficient for creating text in the JOVE buffer. The more advanced JOVE commands just make things easier. But to keep any text permanently you must put it in a _f_i_l_e. Files are the objects which UNIX* uses for storing data for a length of time. To tell JOVE to read text into a file, choose a filename, such as _f_o_o._b_a_r, and type C-X C-R _f_o_o._b_a_r. This reads the file _f_o_o._b_a_r so that its contents appear on the screen for editing. You can make changes, and then save the file by typing C-X C-S (save-file). This makes the changes permanent and actually changes the file _f_o_o._b_a_r. Until then, the changes are only inside JOVE, and the file _f_o_o._b_a_r is not really changed. If the file _f_o_o._b_a_r doesn't exist, and you want to create it, read it as if it did exist. When you save your text with C-X C-S __________________________ * UNIX is a Trademark of Bell Laboratories. September 2, 1987 - 8 - the file will be created. _5._5. _E_x_i_t_i_n_g _a_n_d _P_a_u_s_i_n_g - _L_e_a_v_i_n_g _J_O_V_E _5._5. _E_x_i_t_i_n_g _a_n_d _P_a_u_s_i_n_g - _L_e_a_v_i_n_g _J_O_V_E The command C-X C-C (_e_x_i_t-_j_o_v_e) will terminate the JOVE session and return to the shell. If there are modified but unsaved buffers, JOVE will ask you for confirmation, and you can abort the command, look at what buffers are modified but unsaved using C-X C-B (_l_i_s_t-_b_u_f_f_e_r_s), save the valuable ones, and then exit. If what you want to do, on the other hand, is _p_r_e_s_e_r_v_e the edit- ing session but return to the shell temporarily you can (under Berkeley UNIX only) issue the command ESC S (_p_a_u_s_e-_j_o_v_e), do your UNIX work within the c-shell, then return to JOVE using the _f_g command to resume editing at the point where you paused. For this sort of situation you might consider using an _i_n_t_e_r_a_c_t_i_v_e _s_h_e_l_l (that is, a shell in a JOVE window) which lets you use edi- tor commands to manipulate your UNIX commands (and their output) while never leaving the editor. (The interactive shell feature is described below.) _5._6. _G_i_v_i_n_g _N_u_m_e_r_i_c _A_r_g_u_m_e_n_t_s _t_o _J_O_V_E _C_o_m_m_a_n_d_s _5._6. _G_i_v_i_n_g _N_u_m_e_r_i_c _A_r_g_u_m_e_n_t_s _t_o _J_O_V_E _C_o_m_m_a_n_d_s Any JOVE command can be given a _n_u_m_e_r_i_c _a_r_g_u_m_e_n_t. Some commands interpret the argument as a repetition count. For example, giv- ing an argument of ten to the C-F command (forward-character) moves forward ten characters. With these commands, no argument is equivalent to an argument of 1. Some commands use the value of the argument, but do something peculiar (or nothing) when there is no argument. For example, ESC G (_g_o_t_o-_l_i_n_e) with an argument n goes to the beginning of the n'th line. But ESC G with no argument doesn't do anything. Similarly, C-K with an argument kills that many lines, including their line separators. Without an argument, C-K when there is text on the line to the right of the cursor kills that text; when there is no text after the cursor, C-K deletes the line separa- tor. The fundamental way of specifying an argument is to use ESC fol- lowed by the digits of the argument, for example, ESC 123 ESC G to go to line 123. Negative arguments are allowed, although not all of the commands know what to do with one. Typing C-U means do the next command four times. Two such C-U's multiply the next command by sixteen. Thus, C-U C-U C-F moves forward sixteen characters. This is a good way to move forward quickly, since it moves about 1/4 of a line on most terminals. Other useful combinations are: C-U C-U C-N (move down a good fraction of the screen), C-U C-U C-O (make "a lot" of blank lines), and C-U C-K (kill four lines - note that typing C-K four times would kill 2 lines). September 2, 1987 - 9 - There are other, terminal-dependent ways of specifying arguments. They have the same effect but may be easier to type. If your terminal has a numeric keypad which sends something recognizably different from the ordinary digits, it is possible to program JOVE to to allow use of the numeric keypad for specifying argu- ments. _5._7. _T_h_e _M_a_r_k _a_n_d _t_h_e _R_e_g_i_o_n _5._7. _T_h_e _M_a_r_k _a_n_d _t_h_e _R_e_g_i_o_n In general, a command that processes an arbitrary part of the buffer must know where to start and where to stop. In JOVE, such commands usually operate on the text between point and _t_h_e _m_a_r_k. This body of text is called _t_h_e _r_e_g_i_o_n. To specify a region, you set point to one end of it and mark at the other. It doesn't matter which one comes earlier in the text. C-@ Set the mark where point is. C-X C-X Interchange mark and point. For example, if you wish to convert part of the buffer to all upper-case, you can use the C-X C-U command, which operates on the text in the region. You can first go to the beginning of the text to be capitalized, put the mark there, move to the end, and then type C-X C-U. Or, you can set the mark at the end of the text, move to the beginning, and then type C-X C-U. C-X C-U runs the command _c_a_s_e-_r_e_g_i_o_n-_u_p_p_e_r, whose name signifies that the region, or everything between point and mark, is to be capital- ized. The way to set the mark is with the C-@ command or (on some ter- minals) the C-Space command. They set the mark where point is. Then you can move point away, leaving mark behind. When the mark is set, "[Point pushed]" is printed on the message line. Since terminals have only one cursor, there is no way for JOVE to show you where the mark is located. You have to remember. The usual solution to this problem is to set the mark and then use it soon, before you forget where it is. But you can see where the mark is with the command C-X C-X which puts the mark where point was and point where mark was. The extent of the region is unchanged, but the cursor and point are now at the previous loca- tion of the mark. _5._8. _T_h_e _R_i_n_g _o_f _M_a_r_k_s _5._8. _T_h_e _R_i_n_g _o_f _M_a_r_k_s Aside from delimiting the region, the mark is also useful for remembering a spot that you may want to go back to. To make this feature more useful, JOVE remembers 16 previous locations of the mark. Most commands that set the mark push the old mark onto this stack. To return to a marked location, use C-U C-@. This moves point to where the mark was, and restores the mark from the stack of former marks. So repeated use of this command moves point to all of the old marks on the stack, one by one. Since September 2, 1987 - 10 - the stack is actually a ring, enough uses of C-U C-@ bring point back to where it was originally. Some commands whose primary purpose is to move point a great dis- tance take advantage of the stack of marks to give you a way to undo the command. The best example is ESC <, which moves to the beginning of the buffer. If there are more than 22 lines between the beginning of the buffer and point, ESC < sets the mark first, so that you can use C-U C-@ or C-X C-X to go back to where you were. You can change the number of lines from 22 since it is kept in the variable _m_a_r_k-_t_h_r_e_s_h_o_l_d. By setting it to 0, you can make these commands always set the mark. By setting it to a very large number you can prevent these commands from ever setting the mark. If a command decides to set the mark, it prints the mes- sage [_P_o_i_n_t _p_u_s_h_e_d]. _5._9. _K_i_l_l_i_n_g _a_n_d _M_o_v_i_n_g _T_e_x_t _5._9. _K_i_l_l_i_n_g _a_n_d _M_o_v_i_n_g _T_e_x_t The most common way of moving or copying text with JOVE is to kill it, and get it back again in one or more places. This is very safe because the last several pieces of killed text are all remembered, and it is versatile, because the many commands for killing syntactic units can also be used for moving those units. There are also other ways of moving text for special purposes. _5._1_0. _D_e_l_e_t_i_o_n _a_n_d _K_i_l_l_i_n_g _5._1_0. _D_e_l_e_t_i_o_n _a_n_d _K_i_l_l_i_n_g Most commands which erase text from the buffer save it so that you can get it back if you change your mind, or move or copy it to other parts of the buffer. These commands are known as _k_i_l_l commands. The rest of the commands that erase text do not save it; they are known as _d_e_l_e_t_e commands. The delete commands include C-D and Rubout, which delete only one character at a time, and those commands that delete only spaces or line separa- tors. Commands that can destroy significant amounts of non- trivial data generally kill. A command's name and description will use the words _k_i_l_l or _d_e_l_e_t_e to say which one it does. C-D Delete next character. Rubout Delete previous character. ESC \\ Delete spaces and tabs around point. C-X C-O Delete blank lines around the current line. C-K Kill rest of line or one or more lines. C-W Kill region (from point to the mark). ESC D Kill word. ESC Rubout Kill word backwards. September 2, 1987 - 11 - ESC K Kill to end of sentence. C-X Rubout Kill to beginning of sentence. _5._1_1. _D_e_l_e_t_i_o_n _5._1_1. _D_e_l_e_t_i_o_n The most basic delete commands are C-D and Rubout. C-D deletes the character after the cursor, the one the cursor is "on top of" or "underneath". The cursor doesn't move. Rubout deletes the character before the cursor, and moves the cursor back. Line separators act like normal characters when deleted. Actually, C-D and Rubout aren't always _d_e_l_e_t_e commands; if you give an argument, they _k_i_l_l instead. This prevents you from losing a great deal of text by typing a large argument to a C-D or Rubout. The other delete commands are those which delete only formatting characters: spaces, tabs, and line separators. ESC \ (_d_e_l_e_t_e- _w_h_i_t_e-_s_p_a_c_e) deletes all the spaces and tab characters before and after point. C-X C-O (_d_e_l_e_t_e-_b_l_a_n_k-_l_i_n_e_s) deletes all blank lines after the current line, and if the current line is blank deletes all the blank lines preceding the current line as well (leaving one blank line, the current line). _5._1_2. _K_i_l_l_i_n_g _b_y _L_i_n_e_s _5._1_2. _K_i_l_l_i_n_g _b_y _L_i_n_e_s The simplest kill command is the C-K command. If issued at the beginning of a line, it kills all the text on the line, leaving it blank. If given on a line containing only white space (blanks and tabs) the line disappears. As a consequence, if you go to the front of a non-blank line and type two C-K's, the line disap- pears completely. More generally, C-K kills from point up to the end of the line, unless it is at the end of a line. In that case, it kills the line separator following the line, thus merging the next line into the current one. Invisible spaces and tabs at the end of the line are ignored when deciding which case applies, so if point appears to be at the end of the line, you can be sure the line separator will be killed. C-K with an argument of zero kills all the text before point on the current line. _5._1_3. _O_t_h_e_r _K_i_l_l _C_o_m_m_a_n_d_s _5._1_3. _O_t_h_e_r _K_i_l_l _C_o_m_m_a_n_d_s A kill command which is very general is C-W (_k_i_l_l-_r_e_g_i_o_n), which kills everything between point and the mark.* With this command, you can kill and save contiguous characters, if you first set the mark at one end of them and go to the other end. __________________________ *Often users switch this binding from C-W to C-X C-K because it is too easy to hit C-W accidentally. September 2, 1987 - 12 - Other syntactic units can be killed, too; words, with ESC Rubout and ESC D; and, sentences, with ESC K and C-X Rubout. _5._1_4. _U_n-_k_i_l_l_i_n_g _5._1_4. _U_n-_k_i_l_l_i_n_g (_Y_a_n_k_i_n_g) Un-killing (yanking) is getting back text which was killed. The usual way to move or copy text is to kill it and then un-kill it one or more times. C-Y Yank (re-insert) last killed text. ESC Y Replace re-inserted killed text with the previously killed text. ESC W Save region as last killed text without killing. Killed text is pushed onto a _r_i_n_g _b_u_f_f_e_r called the _k_i_l_l _r_i_n_g that remembers the last 10 blocks of text that were killed. (Why it is called a ring buffer will be explained below). The command C-Y (_y_a_n_k) reinserts the text of the most recent kill. It leaves the cursor at the end of the text, and puts the mark at the beginning. Thus, a single C-Y undoes the C-W. If you wish to copy a block of text, you might want to use ESC W (_c_o_p_y-_r_e_g_i_o_n), which copies the region into the kill ring without removing it from the buffer. This is approximately equivalent to C-W followed by C-Y, except that ESC W does not mark the buffer as "changed" and does not cause the screen to be rewritten. There is only one kill ring shared among all the buffers. After visiting a new file, whatever was last killed in the previous file is still on top of the kill ring. This is important for moving text between files. _5._1_5. _A_p_p_e_n_d_i_n_g _K_i_l_l_s _5._1_5. _A_p_p_e_n_d_i_n_g _K_i_l_l_s Normally, each kill command pushes a new block onto the kill ring. However, two or more kill commands immediately in a row (without any other intervening commands) combine their text into a single entry on the ring, so that a single C-Y command gets it all back as it was before it was killed. This means that you don't have to kill all the text in one command; you can keep kil- ling line after line, or word after word, until you have killed it all, and you can still get it all back at once. Commands that kill forward from _p_o_i_n_t add onto the end of the previous killed text. Commands that kill backward from _p_o_i_n_t add onto the beginning. This way, any sequence of mixed forward and backward kill commands puts all the killed text into one entry without needing rearrangement. September 2, 1987 - 13 - _5._1_6. _U_n-_k_i_l_l_i_n_g _E_a_r_l_i_e_r _K_i_l_l_s _5._1_6. _U_n-_k_i_l_l_i_n_g _E_a_r_l_i_e_r _K_i_l_l_s To recover killed text that is no longer the most recent kill, you need the ESC Y (_y_a_n_k-_p_o_p) command. The ESC Y command can be used only after a C-Y (yank) command or another ESC Y. It takes the un-killed text inserted by the C-Y and replaces it with the text from an earlier kill. So, to recover the text of the next- to-the-last kill, you first use C-Y to recover the last kill, and then discard it by use of ESC Y to move back to the previous kill. You can think of all the last few kills as living on a ring. After a C-Y command, the text at the front of the ring is also present in the buffer. ESC Y "rotates" the ring bringing the previous string of text to the front and this text replaces the other text in the buffer as well. Enough ESC Y commands can rotate any part of the ring to the front, so you can get at any killed text so long as it is recent enough to be still in the ring. Eventually the ring rotates all the way around and the most recently killed text comes to the front (and into the buffer) again. ESC Y with a negative argument rotates the ring backwards. When the text you are looking for is brought into the buffer, you can stop doing ESC Y's and the text will stay there. It's really just a copy of what's at the front of the ring, so editing it does not change what's in the ring. And the ring, once rotated, stays rotated, so that doing another C-Y gets another copy of what you rotated to the front with ESC Y. If you change your mind about un-killing, C-W gets rid of the un-killed text, even after any number of ESC Y's. _6. _S_e_a_r_c_h_i_n_g _6. _S_e_a_r_c_h_i_n_g The search commands are useful for finding and moving to arbi- trary positions in the buffer in one swift motion. For example, if you just ran the spell program on a paper and you want to correct some word, you can use the search commands to move directly to that word. There are two flavors of search: _s_t_r_i_n_g _s_e_a_r_c_h and _i_n_c_r_e_m_e_n_t_a_l _s_e_a_r_c_h. The former is the default flavor-if you want to use incremental search you must rearrange the key bindings (see below). _6._1. _C_o_n_v_e_n_t_i_o_n_a_l _S_e_a_r_c_h _6._1. _C_o_n_v_e_n_t_i_o_n_a_l _S_e_a_r_c_h C-S Search forward. C-R Search backward. To search for the string "FOO" you type "C-S FOO". If JOVE finds FOO it moves point to the end of it; otherwise JOVE prints an error message and leaves point unchanged. C-S searches September 2, 1987 - 14 - forward from point so only occurrences of FOO after point are found. To search in the other direction use C-R. It is exactly the same as C-S except it searches in the opposite direction, and if it finds the string, it leaves point at the beginning of it, not at the end as in C-S. While JOVE is searching it prints the search string on the mes- sage line. This is so you know what JOVE is doing. When the system is heavily loaded and editing in exceptionally large buffers, searches can take several (sometimes many) seconds. JOVE remembers the last search string you used, so if you want to search for the same string you can type "C-S ". If you mistyped the last search string, you can type C-S followed by C- R. C-R, as usual, inserts the default search string into the minibuffer, and then you can fix it up. _6._2. _I_n_c_r_e_m_e_n_t_a_l _S_e_a_r_c_h _6._2. _I_n_c_r_e_m_e_n_t_a_l _S_e_a_r_c_h This search command is unusual in that is is _i_n_c_r_e_m_e_n_t_a_l; it begins to search before you have typed the complete search string. As you type in the search string, JOVE shows you where it would be found. When you have typed enough characters to identify the place you want, you can stop. Depending on what you will do next, you may or may not need to terminate the search explicitly with a Return first. The command to search is C-S (_i-_s_e_a_r_c_h-_f_o_r_w_a_r_d). C-S reads in characters and positions the cursor at the first occurrence of the characters that you have typed so far. If you type C-S and then F, the cursor moves in the text just after the next "F". Type an "O", and see the cursor move to after the next "FO". After another "O", the cursor is after the next "FOO". At the same time, the "FOO" has echoed on the message line. If you type a mistaken character, you can rub it out. After the FOO, typing a Rubout makes the "O" disappear from the message line, leaving only "FO". The cursor moves back in the buffer to the "FO". Rubbing out the "O" and "F" moves the cursor back to where you started the search. When you are satisfied with the place you have reached, you can type a Return, which stops searching, leaving the cursor where the search brought it. Also, any command not specially meaning- ful in searches stops the searching and is then executed. Thus, typing C-A would exit the search and then move to the beginning of the line. Return is necessary only if the next character you want to type is a printing character, Rubout, Return, or another search command, since those are the characters that have special meanings inside the search. Sometimes you search for "FOO" and find it, but not the one you hoped to find. Perhaps there is a second FOO that you forgot about, after the one you just found. Then type another C-S and September 2, 1987 - 15 - the cursor will find the next FOO. This can be done any number of times. If you overshoot, you can return to previous finds by rubbing out the C-S's. After you exit a search, you can search for the same string again by typing just C-S C-S: one C-S command to start the search and then another C-S to mean "search again for the same string". If your string is not found at all, the message line says "Fail- ing I-search". The cursor is after the place where JOVE found as much of your string as it could. Thus, if you search for FOOT and there is no FOOT, you might see the cursor after the FOO in FOOL. At this point there are several things you can do. If your string was mistyped, you can rub some of it out and correct it. If you like the place you have found, you can type Return or some other JOVE command to "accept what the search offered". Or you can type C-G, which undoes the search altogether and posi- tions you back where you started the search. You can also type C-R at any time to start searching backwards. If a search fails because the place you started was too late in the file, you should do this. Repeated C-R's keep looking back- ward for more occurrences of the last search string. A C-S starts going forward again. C-R's can be rubbed out just like anything else. _6._3. _S_e_a_r_c_h_i_n_g _w_i_t_h _R_e_g_u_l_a_r _E_x_p_r_e_s_s_i_o_n_s _6._3. _S_e_a_r_c_h_i_n_g _w_i_t_h _R_e_g_- _u_l_a_r _E_x_p_r_e_s_s_i_o_n_s In addition to the searching facilities described above, JOVE can search for patterns using regular expressions. The handling of regular expressions in JOVE is like that of _e_d(_1) or _v_i(_1), but with some notable additions. The extra metacharacters understood by JOVE are \<, \>, \| and \{. The first two of these match the beginnings and endings of words; Thus the search pattern, "\BAR" as the _r_e_p_l_a_c_e-_s_t_r_i_n_g command is bound to the ESC R. Replacement takes place only between point and the end of the buffer so if you want to cover the whole buffer you must go to the beginning first. _7._2. _Q_u_e_r_y _R_e_p_l_a_c_e _7._2. _Q_u_e_r_y _R_e_p_l_a_c_e If you want to change only some of the occurrences of FOO, not all, then the global _r_e_p_l_a_c_e-_s_t_r_i_n_g is inappropriate; Instead, use, e.g., "ESC Q FOOBAR", to run the command _q_u_e_r_y- _r_e_p_l_a_c_e-_s_t_r_i_n_g. This displays each occurrence of FOO and waits for you to say whether to replace it with a BAR. The things you can type when you are shown an occurrence of FOO are: Space to replace the FOO. Rubout to skip to the next FOO without replacing this one. Return to stop without doing any more replacements. Period to replace this FOO and then stop. ! or P to replace all remaining FOO's without asking. C-R or R to enter a recursive editing level, in case the FOO needs to be edited rather than just replaced with a BAR. When you are done, exit the recursive editing level with C-X C-C and the next FOO will be displayed. C-W to delete the FOO, and then start editing the buffer. When you are finished editing whatever is to replace the FOO, exit the recursive editing level with C-X C-C and the next FOO will be displayed. U move to the last replacement and undo it. Another alternative is using _r_e_p_l_a_c_e-_i_n-_r_e_g_i_o_n which is just like _r_e_p_l_a_c_e-_s_t_r_i_n_g except it searches only within the region. September 2, 1987 - 17 - _8. _C_o_m_m_a_n_d_s _f_o_r _E_n_g_l_i_s_h _T_e_x_t _8. _C_o_m_m_a_n_d_s _f_o_r _E_n_g_l_i_s_h _T_e_x_t JOVE has many commands that work on the basic units of English text: words, sentences and paragraphs. _8._1. _W_o_r_d _C_o_m_m_a_n_d_s _8._1. _W_o_r_d _C_o_m_m_a_n_d_s JOVE has commands for moving over or operating on words. By con- vention, they are all ESC commands. ESC F Move Forward over a word. ESC B Move Backward over a word. ESC D Kill forward to the end of a word. ESC Rubout Kill backward to the beginning of a word. Notice how these commands form a group that parallels the character- based commands, C-F, C-B, C-D, and Rubout. The commands ESC F and ESC B move forward and backward over words. They are thus analogous to Control-F and Control-B, which move over single characters. Like their Control- analogues, ESC F and ESC B move several words if given an argument. ESC F with a negative argument moves backward like ESC B, and ESC B with a negative argument moves forward. Forward motion stops right after the last letter of the word, while backward motion stops right before the first letter. It is easy to kill a word at a time. ESC D kills the word after point. To be precise, it kills everything from point to the place ESC F would move to. Thus, if point is in the middle of a word, only the part after point is killed. If some punctuation comes after point, and before the next word, it is killed along with the word. If you wish to kill only the next word but not the punctuation, simply do ESC F to get to the end, and kill the word backwards with ESC Rubout. ESC D takes arguments just like ESC F. ESC Rubout kills the word before point. It kills everything from point back to where ESC B would move to. If point is after the space in "FOO, BAR", then "FOO, " is killed. If you wish to kill just "FOO", then do a ESC B and a ESC D instead of a ESC Rubout. _8._2. _S_e_n_t_e_n_c_e _C_o_m_m_a_n_d_s _8._2. _S_e_n_t_e_n_c_e _C_o_m_m_a_n_d_s The JOVE commands for manipulating sentences and paragraphs are mostly ESC commands, so as to resemble the word-handling com- mands. ESC A Move back to the beginning of the sentence. ESC E Move forward to the end of the sentence. September 2, 1987 - 18 - ESC K Kill forward to the end of the sentence. C-X Rubout Kill back to the beginning of the sentence. The commands ESC A and ESC E move to the beginning and end of the current sentence, respectively. They were chosen to resemble Control-A and Control-E, which move to the beginning and end of a line. Unlike them, ESC A and ESC E if repeated or given numeric arguments move over successive sentences. JOVE considers a sen- tence to end wherever there is a ".", "?", or "!" followed by the end of a line or by one or more spaces. Neither ESC A nor ESC E moves past the end of the line or spaces which delimit the sen- tence. Just as C-A and C-E have a kill command, C-K, to go with them, so ESC A and ESC E have a corresponding kill command ESC K which kills from point to the end of the sentence. With minus one as an argument it kills back to the beginning of the sentence. Positive arguments serve as a repeat count. There is a special command, C-X Rubout for killing back to the beginning of a sentence, because this is useful when you change your mind in the middle of composing text. _8._3. _P_a_r_a_g_r_a_p_h _C_o_m_m_a_n_d_s _8._3. _P_a_r_a_g_r_a_p_h _C_o_m_m_a_n_d_s The JOVE commands for handling paragraphs are ESC [ Move back to previous paragraph beginning. ESC ] Move forward to next paragraph end. ESC [ moves to the beginning of the current or previous para- graph, while ESC ] moves to the end of the current or next para- graph. Paragraphs are delimited by lines of differing indent, or lines with text formatter commands, or blank lines. JOVE knows how to deal with most indented paragraphs correctly, although it can get confused by one- or two-line paragraphs delimited only by indentation. _8._4. _T_e_x_t _I_n_d_e_n_t_a_t_i_o_n _C_o_m_m_a_n_d_s _8._4. _T_e_x_t _I_n_d_e_n_t_a_t_i_o_n _C_o_m_m_a_n_d_s Tab Indent "appropriately" in a mode-dependent fashion. LineFeed Is the same as Return, except it copies the indent of the line you just left. ESC M Moves to the line's first non-blank charac- ter. The way to request indentation is with the Tab command. Its September 2, 1987 - 19 - precise effect depends on the major mode. In _T_e_x_t mode, it indents to the next tab stop. In _C mode, it indents to the "right" position for C programs. To move over the indentation on a line, do ESC M (_f_i_r_s_t-_n_o_n- _b_l_a_n_k). This command, given anywhere on a line, positions the cursor at the first non-blank, non-tab character on the line. _8._5. _T_e_x_t _F_i_l_l_i_n_g _8._5. _T_e_x_t _F_i_l_l_i_n_g _A_u_t_o _F_i_l_l mode causes text to be _f_i_l_l_e_d (broken up into lines that fit in a specified width) automatically as you type it in. If you alter existing text so that it is no longer properly filled, JOVE can fill it again if you ask. Entering _A_u_t_o _F_i_l_l mode is done with ESC X _a_u_t_o-_f_i_l_l-_m_o_d_e. From then on, lines are broken automatically at spaces when they get longer than the desired width. To leave _A_u_t_o _F_i_l_l mode, once again execute ESC X _a_u_t_o-_f_i_l_l-_m_o_d_e. When _A_u_t_o _F_i_l_l mode is in effect, the word Fill appears in the mode line. If you edit the middle of a paragraph, it may no longer correctly be filled. To refill a paragraph, use the command ESC J (_f_i_l_l- _p_a_r_a_g_r_a_p_h). It causes the paragraph that point is inside to be filled. All the line breaks are removed and new ones inserted where necessary. The maximum line width for filling is in the variable _r_i_g_h_t- _m_a_r_g_i_n. Both ESC J and auto-fill make sure that no line exceeds this width. The value of _r_i_g_h_t-_m_a_r_g_i_n is initially 72. Normally ESC J figures out the indent of the paragraph and uses that same indent when filling. If you want to change the indent of a paragraph you set _l_e_f_t-_m_a_r_g_i_n to the new position and type C-U ESC J. _f_i_l_l-_p_a_r_a_g_r_a_p_h, when supplied a numeric argument, uses the value of _l_e_f_t-_m_a_r_g_i_n. If you know where you want to set the right margin but you don't know the actual value, move to where you want to set the value and use the _r_i_g_h_t-_m_a_r_g_i_n-_h_e_r_e command. _l_e_f_t-_m_a_r_g_i_n-_h_e_r_e does the same for the _l_e_f_t-_m_a_r_g_i_n variable. _8._6. _C_a_s_e _C_o_n_v_e_r_s_i_o_n _C_o_m_m_a_n_d_s _8._6. _C_a_s_e _C_o_n_v_e_r_s_i_o_n _C_o_m_m_a_n_d_s ESC L Convert following word to lower case. ESC U Convert following word to upper case. ESC C Capitalize the following word. The word conversion commands are most useful. ESC L converts the word after point to lower case, moving past it. Thus, successive September 2, 1987 - 20 - ESC L's convert successive words. ESC U converts to all capitals instead, while ESC C puts the first letter of the word into upper case and the rest into lower case. All these commands convert several words at once if given an argument. They are especially convenient for converting a large amount of text from all upper case to mixed case, because you can move through the test using ESC L, ESC U or ESC C on each word as appropriate. When given a negative argument, the word case conversion commands apply to the appropriate number of words before point, but do not move point. This is convenient when you have just typed a word in the wrong case. You can give the case conversion command and continue typing. If a word case conversion command is given in the middle of a word, it applies only to the part of the word which follows the cursor, treating it as a whole word. The other case conversion functions are _c_a_s_e-_r_e_g_i_o_n-_u_p_p_e_r and _c_a_s_e-_r_e_g_i_o_n-_l_o_w_e_r, which convert everything between point and mark to the specified case. Point and mark remain unchanged. _8._7. _C_o_m_m_a_n_d_s _f_o_r _F_i_x_i_n_g _T_y_p_o_s _8._7. _C_o_m_m_a_n_d_s _f_o_r _F_i_x_i_n_g _T_y_p_o_s In this section we describe the commands that are especially use- ful for the times when you catch a mistake on your text after you have made it, or change your mind while composing text on line. Rubout Delete last character. ESC Rubout Kill last word. C-X Rubout Kill to beginning of sentence. C-T Transpose two characters. C-X C-T Transpose two lines. ESC Minus ESC L Convert last word to lower case. ESC Minus ESC U Convert last word to upper case. ESC Minus ESC C Convert last word to lower case with capital initial. _8._8. _K_i_l_l_i_n_g _Y_o_u_r _M_i_s_t_a_k_e_s _8._8. _K_i_l_l_i_n_g _Y_o_u_r _M_i_s_t_a_k_e_s The Rubout command is the most important correction command. When used among printing (self-inserting) characters, it can be thought of as canceling the last character typed. When your mistake is longer than a couple of characters, it might be more convenient to use ESC Rubout or C-X Rubout. ESC Rubout September 2, 1987 - 21 - kills back to the start of the last word, and C-X Rubout kills back to the start of the last sentence. C-X Rubout is particu- larly useful when you are thinking of what to write as you type it, in case you change your mind about phrasing. ESC Rubout and C-X Rubout save the killed text for C-Y and ESC Y to retrieve. ESC Rubout is often useful even when you have typed only a few characters wrong, if you know you are confused in your typing and aren't sure what you typed. At such a time, you cannot correct with Rubout except by looking at the screen to see what you did. It requires less thought to kill the whole word and start over again, especially if the system is heavily loaded. If you were typing a command or command parameters, C-G will abort the command with no further processing. _8._9. _T_r_a_n_s_p_o_s_i_t_i_o_n _8._9. _T_r_a_n_s_p_o_s_i_t_i_o_n The common error of transposing two characters can be fixed with the C-T (_t_r_a_n_s_p_o_s_e-_c_h_a_r_a_c_t_e_r_s) command. Normally, C-T transposes the two characters on either side of the cursor and moves the cursor forward one character. Repeating the command several times "drags" a character to the right. (Remember that _p_o_i_n_t is considered to be between two characters, even though the visible cursor in your terminal is on only one of them.) When given at the end of a line, rather than switching the last character of the line with the line separator, which would be useless, C-T transposes the last two characters on the line. So, if you catch your transposition error right away, you can fix it with just a C-T. If you don't catch it so fast, you must move the cursor back to between the two characters. To transpose two lines, use the C-X C-T (_t_r_a_n_s_p_o_s_e-_l_i_n_e_s) com- mand. The line containing the cursor is exchanged with the line above it; the cursor is left at the beginning of the line follow- ing its original position. _8._1_0. _C_h_e_c_k_i_n_g _a_n_d _C_o_r_r_e_c_t_i_n_g _S_p_e_l_l_i_n_g _8._1_0. _C_h_e_c_k_i_n_g _a_n_d _C_o_r_r_e_c_t_i_n_g _S_p_e_l_l_i_n_g When you write a paper, you should correct its spelling at some point close to finishing it. To correct the entire buffer, do ESC X _s_p_e_l_l-_b_u_f_f_e_r. This invokes the UNIX _s_p_e_l_l program, which prints a list of all the misspelled words. JOVE catches the list and places it in a JOVE buffer called Spell. You are given an opportunity to delete from that buffer any words that aren't really errors; then JOVE looks up each misspelled word and remembers where it is in the buffer being corrected. Then you can go forward to each misspelled word with C-X C-N (_n_e_x_t-_e_r_r_o_r) and backward with C-X C-P (_p_r_e_v_i_o_u_s-_e_r_r_o_r). See the section entitled _E_r_r_o_r _M_e_s_s_a_g_e _P_a_r_s_i_n_g. September 2, 1987 - 22 - _9. _F_i_l_e _H_a_n_d_l_i_n_g _9. _F_i_l_e _H_a_n_d_l_i_n_g The basic unit of stored data is the file. Each program, each paper, lives usually in its own file. To edit a program or paper, the editor must be told the name of the file that contains it. This is called _v_i_s_i_t_i_n_g a file. To make your changes to the file permanent on disk, you must _s_a_v_e the file. _9._1. _V_i_s_i_t_i_n_g _F_i_l_e_s _9._1. _V_i_s_i_t_i_n_g _F_i_l_e_s C-X C-V Visit a file. C-X C-R Same as C-X C-V. C-X C-S Save the visited file. ESC ~ Tell JOVE to forget that the buffer has been changed. _V_i_s_i_t_i_n_g a file means copying its contents into JOVE where you can edit them. JOVE remembers the name of the file you visited. Unless you use the multiple buffer feature of JOVE, you can only be visiting one file at a time. The name of the current selected buffer is visible in the mode line. The changes you make with JOVE are made in a copy inside JOVE. The file itself is not changed. The changed text is not per- manent until you _s_a_v_e it in a file. The first time you change the text, an asterisk appears at the end of the mode line; this indicates that the text contains fresh changes which will be lost unless you save them. To visit a file, use the command C-X C-V. Follow the command with the name of the file you wish to visit, terminated by a Return. You can abort the command by typing C-G, or edit the filename with many of the standard JOVE commands (e.g., C-A, C-E, C-F, ESC F, ESC Rubout). If the filename you wish to visit is similar to the filename in the mode line (the default filename), you can type C-R to insert the default and then edit it. If you do type a Return to finish the command, the new file's text appears on the screen, and its name appears in the mode line. In addition, its name becomes the new default filename. If you wish to save the file and make your changes permanent, type C-X C-S. After the save is finished, C-X C-S prints the filename and the number of characters and lines that it wrote to the file. If there are no changes to save (no asterisk at the end of the mode line), the file is not saved; otherwise the changes saved and the asterisk at the end of the mode line will disappear. What if you want to create a file? Just visit it. JOVE prints September 2, 1987 - 23 - (_N_e_w _f_i_l_e) but aside from that behaves as if you had visited an existing empty file. If you make any changes and save them, the file is created. If you visit a nonexistent file unintentionally (because you typed the wrong filename), go ahead and visit the file you meant. If you don't save the unwanted file, it is not created. If you alter one file and then visit another in the same buffer, JOVE offers to save the old one. If you answer YES, the old file is saved; if you answer NO, all the changes you have made to it since the last save are lost. You should not type ahead after a file visiting command, because your type-ahead might answer an unexpected question in a way that you would regret. Sometimes you will change a buffer by accident. Even if you undo the effect of the change by editing, JOVE still knows that "the buffer has been changed". You can tell JOVE to pretend that there have been no changes with the ESC ~ command (_m_a_k_e-_b_u_f_f_e_r- _u_n_m_o_d_i_f_i_e_d). This command simply clears the "modified" flag which says that the buffer contains changes which need to be saved. Even if the buffer really _i_s changed JOVE will still act as if it were not. If JOVE is about to save a file and sees that the date of the version on disk does not match what JOVE last read or wrote, JOVE notifies you of this fact, and asks what to do, because this probably means that something is wrong. For example, somebody else may have been editing the same file. If this is so, there is a good chance that your work or his work will be lost if you don't take the proper steps. You should first find out exactly what is going on. If you determine that somebody else has modi- fied the file, save your file under a different filename and then DIFF the two files to merge the two sets of changes. (The "patch" command is useful for applying the results of context diffs directly). Also get in touch with the other person so that the files don't diverge any further. _9._2. _H_o_w _t_o _U_n_d_o _D_r_a_s_t_i_c _C_h_a_n_g_e_s _t_o _a _F_i_l_e _9._2. _H_o_w _t_o _U_n_d_o _D_r_a_s_t_i_c _C_h_a_n_g_e_s _t_o _a _F_i_l_e If you have made several extensive changes to a file and then change your mind about them, and you haven't yet saved them, you can get rid of them by reading in the previous version of the file. You can do this with the C-X C-V command, to visit the unsaved version of the file. _9._3. _R_e_c_o_v_e_r_i_n_g _f_r_o_m _s_y_s_t_e_m/_e_d_i_t_o_r _c_r_a_s_h_e_s _9._3. _R_e_c_o_v_e_r_i_n_g _f_r_o_m _s_y_s_t_e_m/_e_d_i_t_o_r _c_r_a_s_h_e_s JOVE does not have _A_u_t_o _S_a_v_e mode, but it does provide a way to recover your work in the event of a system or editor crash. JOVE saves information about the files you're editing every so many changes to a buffer to make recovery possible. Since a rela- tively small amount of information is involved it's hardly even September 2, 1987 - 24 - noticeable when JOVE does this. The variable "sync-frequency" says how often to save the necessary information, and the default is every 50 changes. 50 is a very reasonable number: if you are writing a paper you will not lose more than the last 50 charac- ters you typed, which is less than the average length of a line. _9._4. _M_i_s_c_e_l_l_a_n_e_o_u_s _F_i_l_e _O_p_e_r_a_t_i_o_n_s _9._4. _M_i_s_c_e_l_l_a_n_e_o_u_s _F_i_l_e _O_p_e_r_a_t_i_o_n_s ESC X _w_r_i_t_e-_f_i_l_e writes the contents of the buffer into the file , and then visits that file. It can be thought of as a way of "changing the name" of the file you are visiting. Unlike C-X C-S, _w_r_i_t_e-_f_i_l_e saves even if the buffer has not been changed. C-X C-W is another way of getting this command. ESC X _i_n_s_e_r_t-_f_i_l_e inserts the contents of into the buffer at point, leaving point unchanged before the con- tents. You can also use C-X C-I to get this command. ESC X _w_r_i_t_e-_r_e_g_i_o_n writes the region (the text between point and mark) to the specified file. It does not set the visited filename. The buffer is not changed. ESC X _a_p_p_e_n_d-_r_e_g_i_o_n appends the region to . The text is added to the end of . _1_0. _U_s_i_n_g _M_u_l_t_i_p_l_e _B_u_f_f_e_r_s _1_0. _U_s_i_n_g _M_u_l_t_i_p_l_e _B_u_f_f_e_r_s When we speak of "the buffer", which contains the text you are editing, we have given the impression that there is only one. In fact, there may be many of them, each with its own body of text. At any time only one buffer can be _s_e_l_e_c_t_e_d and available for editing, but it isn't hard to switch to a different one. Each buffer individually remembers which file it is visiting, what modes are in effect, and whether there are any changes that need saving. C-X B Select or create a buffer. C-X C-F Visit a file in its own buffer. C-X C-B List the existing buffers. C-X K Kill a buffer. Each buffer in JOVE has a single name, which normally doesn't change. A buffer's name can be any length. The name of the currently selected buffer and the name of the file visited in it are visible in the mode line when you are at top level. A newly started JOVE has only one buffer, named Main, unless you speci- fied files to edit in the shell command that started JOVE. September 2, 1987 - 25 - _1_0._1. _C_r_e_a_t_i_n_g _a_n_d _S_e_l_e_c_t_i_n_g _B_u_f_f_e_r_s _1_0._1. _C_r_e_a_t_i_n_g _a_n_d _S_e_l_e_c_t_- _i_n_g _B_u_f_f_e_r_s To create a new buffer, you need only think of a name for it (say, FOO) and then do C-X B FOO, which is the command C-X B (_s_e_l_e_c_t-_b_u_f_f_e_r) followed by the name. This makes a new, empty buffer (if one by that name didn't previously exist) and selects it for editing. The new buffer is not visiting any file, so if you try to save it you will be asked for the filename to use. Each buffer has its own major mode; the new buffer's major mode is _T_e_x_t mode by default. To return to buffer FOO later after having switched to another, the same command C-X B FOO is used, since C-X B can tell whether a buffer named FOO exists already or not. C-X B Main reselects the buffer Main that JOVE started out with. Just C-X B reselects the previous buffer. Repeated C-X B's alternate between the last two buffers selected. You can also read a file into its own newly created buffer, all with one command: C-X C-F (_f_i_n_d-_f_i_l_e), followed by the filename. The name of the buffer is the last element of the file's path- name. C-F stands for "Find", because if the specified file already resides in a buffer in your JOVE, that buffer is reselected. So you need not remember whether you have brought the file in already or not. A buffer created by C-X C-F can be reselected later with C-X B or C-X C-F, whichever you find more convenient. Nonexistent files can be created with C-X C-F just as they can with C-X C-V. _1_0._2. _U_s_i_n_g _E_x_i_s_t_i_n_g _B_u_f_f_e_r_s _1_0._2. _U_s_i_n_g _E_x_i_s_t_i_n_g _B_u_f_f_e_r_s To get a list of all the buffers that exist, do C-X C-B (_l_i_s_t- _b_u_f_f_e_r_s). Each buffer's type, name, and visited filename is printed. An asterisk before the buffer name indicates a buffer which contains changes that have not been saved. The number that appears at the beginning of a line in a C-X C-B listing is that buffer's _b_u_f_f_e_r _n_u_m_b_e_r. You can select a buffer by typing its number in place of its name. If a buffer with that number doesn't already exist, a new buffer is created with that number as its name. If several buffers have modified text in them, you should save some of them with C-X C-M (_w_r_i_t_e-_m_o_d_i_f_i_e_d-_f_i_l_e_s). This finds all the buffers that need saving and then saves them. Saving the buffers this way is much easier and more efficient (but more dangerous) than selecting each one and typing C-X C-S. If you give C-X C-M an argument, JOVE will ask for confirmation before saving each buffer. ESC X _r_e_n_a_m_e-_b_u_f_f_e_r changes the name of the currently selected buffer. September 2, 1987 - 26 - ESC X _e_r_a_s_e-_b_u_f_f_e_r erases the contents of the without deleting the buffer entirely. _1_0._3. _K_i_l_l_i_n_g _B_u_f_f_e_r_s _1_0._3. _K_i_l_l_i_n_g _B_u_f_f_e_r_s After you use a JOVE for a while, it may fill up with buffers which you no longer need. Eventually you can reach a point where trying to create any more results in an "out of memory" or "out of lines" error. When this happens you will want to kill some buffers with the C-X K (_d_e_l_e_t_e-_b_u_f_f_e_r) command. You can kill the buffer FOO by doing C-X K FOO. If you type C-X K JOVE will kill the previously selected buffer. If you try to kill a buffer that needs saving JOVE will ask you to con- firm it. If you need to kill several buffers, use the command _k_i_l_l-_s_o_m_e- _b_u_f_f_e_r_s. This prompts you with the name of each buffer and asks for confirmation before killing that buffer. _1_1. _C_o_n_t_r_o_l_l_i_n_g _t_h_e _D_i_s_p_l_a_y _1_1. _C_o_n_t_r_o_l_l_i_n_g _t_h_e _D_i_s_p_l_a_y Since only part of a large file will fit on the screen, JOVE tries to show the part that is likely to be interesting. The display control commands allow you to see a different part of the file. C-L Reposition point at a specified vertical position, OR clear and redraw the screen with point in the same place. C-V Scroll forwards (a screen or a few lines). ESC V Scroll backwards. C-Z Scroll forward some lines. ESC Z Scroll backwards some lines. The terminal screen is rarely large enough to display all of your file. If the whole buffer doesn't fit on the screen, JOVE shows a contiguous portion of it, containing _p_o_i_n_t. It continues to show approximately the same portion until point moves outside of what is displayed; then JOVE chooses a new portion centered around the new _p_o_i_n_t. This is JOVE's guess as to what you are most interested in seeing, but if the guess is wrong, you can use the display control commands to see a different portion. The available screen area through which you can see part of the buffer is called _t_h_e _w_i_n_d_o_w, and the choice of where in the buffer to start displaying is also called _t_h_e _w_i_n_d_o_w. (When there is only one window, it plus the mode line and the input line take up the whole screen). First we describe how JOVE chooses a new window position on its September 2, 1987 - 27 - own. The goal is usually to place _p_o_i_n_t half way down the win- dow. This is controlled by the variable _s_c_r_o_l_l-_s_t_e_p, whose value is the number of lines above the bottom or below the top of the window that the line containing point is placed. A value of 0 (the initial value) means center _p_o_i_n_t in the window. The basic display control command is C-L (_r_e_d_r_a_w-_d_i_s_p_l_a_y). In its simplest form, with no argument, it tells JOVE to choose a new window position, centering point half way from the top as usual. C-L with a positive argument chooses a new window so as to put point that many lines from the top. An argument of zero puts point on the very top line. Point does not move with respect to the text; rather, the text and point move rigidly on the screen. If point stays on the same line, the window is first cleared and then redrawn. Thus, two C-L's in a row are guaranteed to clear the current window. ESC C-L will clear and redraw the entire screen. The _s_c_r_o_l_l_i_n_g commands C-V, ESC V, C-Z, and ESC Z, let you move the whole display up or down a few lines. C-V (_n_e_x_t-_p_a_g_e) with an argument shows you that many more lines at the bottom of the screen, moving the text and point up together as C-L might. C-V with a negative argument shows you more lines at the top of the screen, as does ESC V (_p_r_e_v_i_o_u_s-_p_a_g_e) with a positive argument. To read the buffer a window at a time, use the C-V command with no argument. It takes the last line at the bottom of the window and puts it at the top, followed by nearly a whole window of lines not visible before. Point is put at the top of the window. Thus, each C-V shows the "next page of text", except for one line of overlap to provide context. To move backward, use ESC V without an argument, which moves a whole window backwards (again with a line of overlap). C-Z and ESC Z scroll one line forward and one line backward, respectively. These are convenient for moving in units of lines without having to type a numeric argument. _1_1._1. _M_u_l_t_i_p_l_e _W_i_n_d_o_w_s _1_1._1. _M_u_l_t_i_p_l_e _W_i_n_d_o_w_s JOVE allows you to split the screen into two or more _w_i_n_d_o_w_s and use them to display parts of different files, or different parts of the same file. C-X 2 Divide the current window into two smaller ones. C-X 1 Delete all windows but the current one. C-X D Delete current window. C-X N Switch to the next window. September 2, 1987 - 28 - C-X P Switch to the previous window. C-X O Same as C-X P. C-X ^ Make this window bigger. ESC C-V Scroll the other window. When using _m_u_l_t_i_p_l_e _w_i_n_d_o_w mode, the text portion of the screen is divided into separate parts called _w_i_n_d_o_w_s, which can display different pieces of text. Each window can display different files, or parts of the same file. Only one of the windows is _a_c_t_i_v_e; that is the window which the cursor is in. Editing nor- mally takes place in that window alone. To edit in another win- dow, you would give a command to move the cursor to the other window, and then edit there. Each window displays a mode line for the buffer it's displaying. This is useful to keep track of which window corresponds with which file. In addition, the mode line serves as a separator between windows. By setting the variable _m_o_d_e-_l_i_n_e-_s_h_o_u_l_d- _s_t_a_n_d_o_u_t to "on" you can have JOVE display the mode-line in reverse video (assuming your particular terminal has the reverse video capability). The command C-X 2 (_s_p_l_i_t-_c_u_r_r_e_n_t-_w_i_n_d_o_w) enters multiple window mode. A new mode line appears across the middle of the screen, dividing the text display area into two halves. Both windows contain the same buffer and display the same position in it, namely where point was at the time you issued the command. The cursor moves to the second window. To return to viewing only one window, use the command C-X 1 (_d_e_l_e_t_e-_o_t_h_e_r-_w_i_n_d_o_w_s). The current window expands to fill the whole screen, and the other windows disappear until the next C-X 2. (The buffers and their contents are unaffected by any of the window operations). While there is more than one window, you can use C-X N (_n_e_x_t- _w_i_n_d_o_w) to switch to the next window, and C-X P (_p_r_e_v_i_o_u_s-_w_i_n_d_o_w) to switch to the previous one. If you are in the bottom window and you type C-X N, you will be placed in the top window, and the same kind of thing happens when you type C-X P in the top window, namely you will be placed in the bottom window. C-X O is the same as C-X P. It stands for "other window" because when there are only two windows, repeated use of this command will switch between the two windows. Often you will be editing one window while using the other just for reference. Then, the command ESC C-V (_p_a_g_e-_n_e_x_t-_w_i_n_d_o_w) is very useful. It scrolls the next window, as if you switched to the next window, typed C-V, and switched back, without your hav- ing to do all that. With a negative argument, ESC C-V will do an September 2, 1987 - 29 - ESC V in the next window. When a window splits, both halves are approximately the same size. You can redistribute the screen space between the windows with the C-X ^ (_g_r_o_w-_w_i_n_d_o_w) command. It makes the currently selected window grow one line bigger, or as many lines as is specified with a numeric argument. Use ESC X _s_h_r_i_n_k-_w_i_n_d_o_w to make the current window smaller. _1_1._2. _M_u_l_t_i_p_l_e _W_i_n_d_o_w_s _a_n_d _M_u_l_t_i_p_l_e _B_u_f_f_e_r_s _1_1._2. _M_u_l_t_i_p_l_e _W_i_n_- _d_o_w_s _a_n_d _M_u_l_t_i_p_l_e _B_u_f_f_e_r_s Buffers can be selected independently in each window. The C-X B command selects a new buffer in whichever window contains the cursor. Other windows' buffers do not change. You can view the same buffer in more than one window. Although the same buffer appears in both windows, they have different values of point, so you can move around in one window while the other window continues to show the same text. Then, having found one place you wish to refer to, you can go back into the other window with C-X O or C-X P to make your changes. If you have the same buffer in both windows, you must beware of trying to visit a different file in one of the windows with C-X C-V, because if you bring a new file into this buffer, it will replaced the old file in _b_o_t_h windows. To view different files in different windows, you must switch buffers in one of the win- dows first (with C-X B or C-X C-F, perhaps). A convenient "combination" command for viewing something in another window is C-X 4 (_w_i_n_d_o_w-_f_i_n_d). With this command you can ask to see any specified buffer, file or tag in the other window. Follow the C-X 4 with either B and a buffer name, F and a filename, or T and a tag name. This switches to the other window and finds there what you specified. If you were previously in one-window mode, multiple-window mode is entered. C-X 4 B is similar to C-X 2 C-X B. C-X 4 F is similar to C-X 2 C-X C-F. C-X 4 T is similar to C-X 2 C-X T. The difference is one of efficiency, and also that C-X 4 works equally well if you are already using two windows. _1_2. _P_r_o_c_e_s_s_e_s _U_n_d_e_r _J_O_V_E _1_2. _P_r_o_c_e_s_s_e_s _U_n_d_e_r _J_O_V_E Another feature in JOVE is its ability to interact with UNIX in a useful way. You can run other UNIX commands from JOVE and catch their output in JOVE buffers. In this chapter we will discuss the different ways to run and interact with UNIX commands. _1_2._1. _N_o_n-_i_n_t_e_r_a_c_t_i_v_e _U_N_I_X _c_o_m_m_a_n_d_s _1_2._1. _N_o_n-_i_n_t_e_r_a_c_t_i_v_e To run a UNIX command from JOVE just type "C-X !" followed by the name of the command terminated with Return. For example, to get a list of all the users on the system, you do: September 2, 1987 - 30 - C-X ! who Then JOVE picks a reasonable buffer in which the output from the command will be placed. E.g., "who" uses a buffer called who; "ps alx" uses ps; and "fgrep -n foo *.c" uses fgrep. If JOVE wants to use a buffer that already exists it first erases the old contents. If the buffer it selects holds a file, not output from a previous shell command, you must first delete that buffer with C-X K. Once JOVE has picked a buffer it puts that buffer in a window so you can see the command's output as it is running. If there is only one window JOVE will automatically make another one. Other- wise, JOVE tries to pick the most convenient window which isn't the current one. It's not a good idea to type anything while the command is run- ning. There are two reasons for this: (i) JOVE won't see the characters (thus won't execute them) until the command finishes, so you may forget what you've typed. (ii) Although JOVE won't know what you've typed, it _w_i_l_l know that you've typed something, and then it will try to be "smart" and not update the display until it's interpreted what you've typed. But, of course, JOVE won't interpret what you type until the UNIX command completes, so you're left with the uneasy feeling you get when you don't know what the hell the computer is doing*. If you want to interrupt the command for some reason (perhaps you mistyped it, or you changed your mind) you can type C-]. Typing this inside JOVE while a process is running is the same as typing C-C when you are outside JOVE, namely the process stops in a hurry. When the command finishes, JOVE puts you back in the window in which you started. Then it prints a message indicating whether or not the command completed successfully in its (the command's) opinion. That is, if the command had what it considers an error (or you interrupt it with C-]) JOVE will print an appropriate message. _1_2._2. _L_i_m_i_t_a_t_i_o_n_s _o_f _N_o_n-_I_n_t_e_r_a_c_t_i_v_e _P_r_o_c_e_s_s_e_s _1_2._2. _L_i_m_i_t_a_t_i_o_n_s _o_f _N_o_n-_I_n_t_e_r_a_c_t_i_v_e _P_r_o_c_e_s_s_e_s The reason these are called non-interactive processes is that you __________________________ *This is a bug and should be fixed, but probably won't be for a while. September 2, 1987 - 31 - can't type any input to them; you can't interact with them; they can't ask you questions because there is no way for you to answer. For example, you can't run a command interpreter (a shell), or _m_a_i_l or _c_r_y_p_t with C-X ! because there is no way to provide it with input. Remember that JOVE (not the process in the window) is listening to your keyboard, and JOVE waits until the process dies before it looks at what you type. C-X ! is useful for running commands that do some output and then exit. For example, it's very useful to use with the C compiler to catch compilation error messages (see Compiling C Programs), or with the _g_r_e_p commands. _1_2._3. _I_n_t_e_r_a_c_t_i_v_e _P_r_o_c_e_s_s_e_s - _R_u_n _a _S_h_e_l_l _i_n _a _W_i_n_d_o_w _1_2._3. _I_n_t_e_r_a_c_t_i_v_e _P_r_o_c_e_s_s_e_s - _R_u_n _a _S_h_e_l_l _i_n _a _W_i_n_d_o_w Some versions of JOVE|- have the capability of running interactive processes. This is more useful than non-interactive processes for certain types of jobs: (i) You can go off and do some editing while the command is run- ning. This is useful for commands that do sporadic output and run for fairly long periods of time. (ii) Unlike non-interactive processes, you can type input to these. In addition, you can edit what you type with the power of all the JOVE commands _b_e_f_o_r_e you send the input to the process. This is a really important feature, and is especially useful for running a shell in a window. (iii)Because you can continue with normal editing while one of the processes is running, you can create a bunch of contexts and manage them (select them, delete them, or temporarily put them aside) with JOVE's window and buffer mechanisms. Although we may have given an image of processes being attached to _w_i_n_d_o_w_s, in fact they are attached to _b_u_f_f_e_r_s. Therefore, once an _i-_p_r_o_c_e_s_s is running you can select another buffer into that window, or if you wish you can delete the window altogether. If you reselect that buffer later it will be up to date. That is, even though the buffer wasn't visible it was still receiving output from the process. You don't have to worry about missing anything when the buffer isn't visible. _1_2._4. _A_d_v_a_n_t_a_g_e_s _o_f _R_u_n_n_i_n_g _P_r_o_c_e_s_s_e_s _i_n _J_O_V_E _W_i_n_d_o_w_s. _1_2._4. _A_d_v_a_n_t_a_g_e_s _o_f _R_u_n_n_i_n_g _P_r_o_c_e_s_s_e_s _i_n _J_O_V_E _W_i_n_d_o_w_s. There are several advantages to running a shell in a window. What you type isn't seen immediately by the process; instead JOVE waits until you type an entire line before passing it on to the process to read. This means that before you type all of __________________________ |- For example, the version provided with 4.3BSD. September 2, 1987 - 32 - JOVE's editing capabilities are available for fixing errors on your input line. If you discover an error at the beginning of the line, rather than erasing the whole line and starting over, you can simply move to the error, correct it, move back and con- tinue typing. Another feature is that you have the entire history of your ses- sion in a JOVE buffer. You don't have to worry about output from a command moving past the top of the screen. If you missed some output you can move back through it with ESC V and other com- mands. In addition, you can save yourself retyping a command (or a similar one) by sending edited versions of previous commands, or edit the output of one command to become a list of commands to be executed ("immediate shell scripts"). _1_2._5. _D_i_f_f_e_r_e_n_c_e_s _b_e_t_w_e_e_n _N_o_r_m_a_l _a_n_d _I-_p_r_o_c_e_s_s _B_u_f_f_e_r_s _1_2._5. _D_i_f_f_e_r_e_n_c_e_s _b_e_t_w_e_e_n _N_o_r_m_a_l _a_n_d _I-_p_r_o_c_e_s_s _B_u_f_f_e_r_s JOVE behaves differently in several ways when you are in an _i- _p_r_o_c_e_s_s buffer. Most obviously, does different things depending on both your position in the buffer and on the state of the process. In the normal case, when point is at the end of the buffer, Return does what you'd expect: it inserts a line- separator and then sends the line to the process. If you are somewhere else in the buffer, possibly positioned at a previous command that you want to edit, Return will place a copy of that line (with the prompt discarded if there is one) at the end of the buffer and move you there. Then you can edit the line and type Return as in the normal case. If the process has died for some reason, Return does nothing. It doesn't even insert itself. If that happens unexpectedly, you should type ESC X _l_i_s_t- _p_r_o_c_e_s_s_e_s to get a list of each process and its state. If your process died abnormally, _l_i_s_t-_p_r_o_c_e_s_s_e_s may help you fig- ure out why. _1_2._6. _H_o_w _t_o _R_u_n _a _S_h_e_l_l _i_n _a _W_i_n_d_o_w _1_2._6. _H_o_w _t_o _R_u_n _a _S_h_e_l_l _i_n _a _W_i_n_d_o_w Type ESC X _i-_s_h_e_l_l to start up a shell. As with C-X !, JOVE will create a buffer, called shell-1, and select a window for this new buffer. But unlike C-X ! you will be left in the new window. Now, the shell process is said to be attached to shell-1, and it is considered an _i-_p_r_o_c_e_s_s buffer. _1_3. _D_i_r_e_c_t_o_r_y _H_a_n_d_l_i_n_g _1_3. _D_i_r_e_c_t_o_r_y _H_a_n_d_l_i_n_g To save having to use absolute pathnames when you want to edit a nearby file JOVE allows you to move around the UNIX filesystem just as the c-shell does. These commands are: cd dir Change to the specified directory. pushd [dir] Like _c_d, but save the old directory on the direc- tory stack. With no directory argument, simply September 2, 1987 - 33 - exchange the top two directories on the stack and _c_d to the new top. popd Take the current directory off the stack and _c_d to the directory now at the top. dirs Display the contents of the directory stack. The names and behavior of these commands were chosen to mimic those in the c-shell. _1_4. _E_d_i_t_i_n_g _C _P_r_o_g_r_a_m_s _1_4. _E_d_i_t_i_n_g _C _P_r_o_g_r_a_m_s This section details the support provided by JOVE for working on C programs. _1_4._1. _I_n_d_e_n_t_a_t_i_o_n _C_o_m_m_a_n_d_s _1_4._1. _I_n_d_e_n_t_a_t_i_o_n _C_o_m_m_a_n_d_s To save having to lay out C programs "by hand", JOVE has an idea of the correct indentation of a line, based on the surrounding context. When you are in C Mode, JOVE treats tabs specially - typing a tab at the beginning of a new line means "indent to the right place". Closing braces are also handled specially, and are indented to match the corresponding open brace. _1_4._2. _P_a_r_e_n_t_h_e_s_i_s _a_n_d _B_r_a_c_e _M_a_t_c_h_i_n_g _1_4._2. _P_a_r_e_n_t_h_e_s_i_s _a_n_d _B_r_a_c_e _M_a_t_c_h_i_n_g To check that parentheses and braces match the way you think they do, turn on _S_h_o_w _M_a_t_c_h mode (ESC X show-match-mode). Then, when- ever you type a close brace or parenthesis, the cursor moves momentarily to the matching opener, if it's currently visible. If it's not visible, JOVE displays the line containing the match- ing opener on the message line. _1_4._3. _C _T_a_g_s _1_4._3. _C _T_a_g_s Often when you are editing a C program, especially someone else's code, you see a function call and wonder what that function does. You then search for the function within the current file and if you're lucky find the definition, finally returning to the origi- nal spot when you are done. However, if are unlucky, the func- tion turns out to be external (defined in another file) and you have to suspend the edit, _g_r_e_p for the function name in every .c that might contain it, and finally visit the appropriate file. To avoid this diversion or the need to remember which function is defined in which file, Berkeley UNIX has a program called _c_t_a_g_s(_1), which takes a set of source files and looks for func- tion definitions, producing a file called _t_a_g_s as its output. JOVE has a command called C-X T (_f_i_n_d-_t_a_g) that prompts you for the name of a function (a _t_a_g), looks up the tag reference in the previously constructed tags file, then visits the file containing September 2, 1987 - 34 - that tag in a new buffer, with point positioned at the definition of the function. There is another version of this command, namely _f_i_n_d-_t_a_g-_a_t-_p_o_i_n_t, that uses the identifier at _p_o_i_n_t. So, when you've added new functions to a module, or moved some old ones around, run the _c_t_a_g_s program to regenerate the _t_a_g_s file. JOVE looks in the file specified in the _t_a_g-_f_i_l_e variable. The default is "./tags", that is, the tag file in the current directory. If you wish to use an alternate tag file, you use C- U C-X T, and JOVE will prompt for a file name. If you find your- self specifying the same file again and again, you can set _t_a_g- _f_i_l_e to that file, and run _f_i_n_d-_t_a_g with no numeric argument. To begin an editing session looking for a particular tag, use the -_t _t_a_g command line option to JOVE. For example, say you wanted to look at the file containing the tag _S_k_i_p_C_h_a_r, you would invoke JOVE as: % _j_o_v_e -_t _S_k_i_p_C_h_a_r _1_4._4. _C_o_m_p_i_l_i_n_g _Y_o_u_r _P_r_o_g_r_a_m _1_4._4. _C_o_m_p_i_l_i_n_g _Y_o_u_r _P_r_o_g_r_a_m You've typed in a program or altered an existing one and now you want to run it through the compiler to check for errors. To save having to suspend the edit, run the compiler, scribble down error messages, and then resume the edit, JOVE allows you to compile your code while in the editor. This is done with the C-X C-E (_c_o_m_p_i_l_e-_i_t) command. If you run _c_o_m_p_i_l_e-_i_t with no argument it runs the UNIX _m_a_k_e program into a buffer; If you need a special command or want to pass arguments to _m_a_k_e, run _c_o_m_p_i_l_e-_i_t with any argument (C-U is good enough) and you will be prompted for the command to execute. If any error messages are produced, they are treated specially by JOVE. That treatment is the subject of the next section. _1_4._5. _E_r_r_o_r _M_e_s_s_a_g_e _P_a_r_s_i_n_g _a_n_d _S_p_e_l_l_i_n_g _C_h_e_c_k_i_n_g _1_4._5. _E_r_r_o_r _M_e_s_s_a_g_e _P_a_r_s_i_n_g _1_4._5. _S_p_e_l_l_i_n_g _C_h_e_c_k_i_n_g JOVE knows how to interpret the error messages from many UNIX commands; In particular, the messages from _c_c, _g_r_e_p and _l_i_n_t can be understood. After running the _c_o_m_p_i_l_e-_i_t command, the _p_a_r_s_e- _e_r_r_o_r_s command is automatically executed, and any errors found are displayed in a new buffer. The files whose names are found in parsing the error messages are each brought into JOVE buffers and the point is positioned at the first error in the first file. The commands _c_u_r_r_e_n_t-_e_r_r_o_r, C-X C-N (_n_e_x_t-_e_r_r_o_r), and C-X C-P (_p_r_e_v_i_o_u_s-_e_r_r_o_r) can be used to traverse the list of errors. If you already have a file called _e_r_r_s containing, say, c com- piler messages then you can get JOVE to interpret the messages by invoking it as: September 2, 1987 - 35 - % _j_o_v_e -_p _e_r_r_s JOVE has a special mechanism for checking the the spelling of a document; It runs the UNIX spell program into a buffer. You then delete from this buffer all those words that are not spelling errors and then JOVE runs the _p_a_r_s_e-_s_p_e_l_l_i_n_g-_e_r_r_o_r_s command to yield a list of errors just as in the last section. _1_5. _S_i_m_p_l_e _C_u_s_t_o_m_i_z_a_t_i_o_n _1_5. _S_i_m_p_l_e _C_u_s_t_o_m_i_z_a_t_i_o_n _1_5._1. _M_a_j_o_r _M_o_d_e_s _1_5._1. _M_a_j_o_r _M_o_d_e_s To help with editing particular types of file, say a paper or a C program, JOVE has several _m_a_j_o_r _m_o_d_e_s. These are as follows: _1_5._1._1. _T_e_x_t _m_o_d_e _1_5._1._1. _T_e_x_t _m_o_d_e This is the default major mode. Nothing special is done. _1_5._1._2. _C _m_o_d_e _1_5._1._2. _C _m_o_d_e This mode affects the behavior of the tab and parentheses charac- ters. Instead of just inserting the tab, JOVE determines where the text "ought" to line up for the C language and tabs to that position instead. The same thing happens with the close brace and close parenthesis; they are tabbed to the "right" place and then inserted. Using the _a_u_t_o-_e_x_e_c_u_t_e-_c_o_m_m_a_n_d command, you can make JOVE enter _C _M_o_d_e whenever you edit a file whose name ends in ._c. _1_5._1._3. _L_i_s_p _m_o_d_e _1_5._1._3. _L_i_s_p _m_o_d_e This mode is analogous to _C _M_o_d_e, but performs the indentation needed to lay out Lisp programs properly. Note also the _g_r_i_n_d- _s-_e_x_p_r command that prettyprints an _s-_e_x_p_r_e_s_s_i_o_n and the _k_i_l_l- _m_o_d_e-_e_x_p_r_e_s_s_i_o_n command. _1_5._2. _M_i_n_o_r _M_o_d_e_s _1_5._2. _M_i_n_o_r _M_o_d_e_s In addition to the major modes, JOVE has a set of minor modes. These are as follows: _1_5._2._1. _A_u_t_o _I_n_d_e_n_t _1_5._2._1. _A_u_t_o _I_n_d_e_n_t In this mode, JOVE indents each line the same way as that above it. That is, the Return key in this mode acts as the Linefeed key ordinarily does. September 2, 1987 - 36 - _1_5._2._2. _S_h_o_w _M_a_t_c_h _1_5._2._2. _S_h_o_w _M_a_t_c_h Move the cursor momentarily to the matching opening parenthesis when a closing parenthesis is typed. _1_5._2._3. _A_u_t_o _F_i_l_l _1_5._2._3. _A_u_t_o _F_i_l_l In _A_u_t_o _F_i_l_l mode, a newline is automatically inserted when the line length exceeds the right margin. This way, you can type a whole paper without having to use the Return key. _1_5._2._4. _O_v_e_r _W_r_i_t_e _1_5._2._4. _O_v_e_r _W_r_i_t_e In this mode, any text typed in will replace the previous con- tents. (The default is for new text to be inserted and "push" the old along.) This is useful for editing an already-formatted diagram in which you want to change some things without moving other things around on the screen. _1_5._2._5. _W_o_r_d _A_b_b_r_e_v _1_5._2._5. _W_o_r_d _A_b_b_r_e_v In this mode, every word you type is compared to a list of word abbreviations; whenever you type an abbreviation, it is replaced by the text that it abbreviates. This can save typing if a par- ticular word or phrase must be entered many times. The abbrevia- tions and their expansions are held in a file that looks like: abbrev:phrase This file can be set up in your ~/._j_o_v_e_r_c with the _r_e_a_d-_w_o_r_d- _a_b_b_r_e_v-_f_i_l_e command. Then, whenever you are editing a buffer in _W_o_r_d _A_b_b_r_e_v mode, JOVE checks for the abbreviations you've given. See also the commands _r_e_a_d-_w_o_r_d-_a_b_b_r_e_v-_f_i_l_e, _w_r_i_t_e-_w_o_r_d-_a_b_b_r_e_v- _f_i_l_e, _e_d_i_t-_w_o_r_d-_a_b_b_r_e_v_s, _d_e_f_i_n_e-_g_l_o_b_a_l-_w_o_r_d-_a_b_b_r_e_v, _d_e_f_i_n_e-_m_o_d_e- _w_o_r_d-_a_b_b_r_e_v, and _b_i_n_d-_m_a_c_r_o-_t_o-_w_o_r_d-_a_b_b_r_e_v, and the variable _a_u_t_o-_c_a_s_e-_a_b_b_r_e_v. _1_5._3. _V_a_r_i_a_b_l_e_s _1_5._3. _V_a_r_i_a_b_l_e_s JOVE can be tailored to suit your needs by changing the values of variables. A JOVE variable can be given a value with the _s_e_t command, and its value displayed with the _p_r_i_n_t command. The variables JOVE understands are listed along with the commands in the alphabetical list at the end of this document. _1_5._4. _K_e_y _R_e-_b_i_n_d_i_n_g _1_5._4. _K_e_y _R_e-_b_i_n_d_i_n_g Many of the commands built into JOVE are not bound to specific keys. The command handler in JOVE is used to invoke these com- mands and is activated by the _e_x_e_c_u_t_e-_e_x_t_e_n_d_e_d-_c_o_m_m_a_n_d command (ESC X). When the name of a command typed in is unambiguous, that command will be executed. Since it is very slow to have to type in the name of each command every time it is needed, JOVE September 2, 1987 - 37 - makes it possible to _b_i_n_d commands to keys. When a command is _b_o_u_n_d to a key any future hits on that key will invoke that com- mand. All the printing characters are initially bound to the command _s_e_l_f-_i_n_s_e_r_t. Thus, typing any printing character causes it to be inserted into the text. Any of the existing commands can be bound to any key. (A _k_e_y may actually be a _c_o_n_t_r_o_l _c_h_a_r_- _a_c_t_e_r or an _e_s_c_a_p_e _s_e_q_u_e_n_c_e as explained previously under _C_o_m_m_a_n_d _I_n_p_u_t _C_o_n_v_e_n_t_i_o_n_s). Since there are more commands than there are keys, two keys are treated as _p_r_e_f_i_x commands. When a key bound to one of the pre- fix commands is typed, the next character typed is interpreted on the basis that it was preceded by one of the prefix keys. Ini- tially ^X and ESC are the prefix keys and many of the built in commands are initially bound to these "two stroke" keys. (For historical reasons, the Escape key is often referred to as "Meta"). _1_5._5. _K_e_y_b_o_a_r_d _M_a_c_r_o_s _1_5._5. _K_e_y_b_o_a_r_d _M_a_c_r_o_s Although JOVE has many powerful commands, you often find that you have a task that no individual command can do. JOVE allows you to define your own commands from sequences of existing ones "by example"; Such a sequence is termed a _m_a_c_r_o. The procedure is as follows: First you type the _s_t_a_r_t-_r_e_m_e_m_b_e_r_i_n_g command, usually bound to C-X (. Next you "perform" the commands which as they are being executed are also remembered, which will constitute the body of the macro. Then you give the _s_t_o_p-_r_e_m_e_m_b_e_r_i_n_g command, usually bound to C-X ). You now have a _k_e_y_b_o_a_r_d _m_a_c_r_o. To run this command sequence again, use the command _e_x_e_c_u_t_e-_k_e_y_b_o_a_r_d- _m_a_c_r_o, usually bound to C-X E. You may find this bothersome to type and re-type, so there is a way to bind the macro to a key. First, you must give the keyboard macro a name using the _n_a_m_e- _k_e_y_b_o_a_r_d-_m_a_c_r_o command. Then the binding is made with the _b_i_n_d- _m_a_c_r_o-_t_o-_k_e_y command. We're still not finished because all this hard work will be lost if you leave JOVE. What you do is to save your macros into a file with the _w_r_i_t_e-_m_a_c_r_o_s-_t_o-_f_i_l_e command. There is a corresponding _r_e_a_d-_m_a_c_r_o_s-_f_r_o_m-_f_i_l_e command to retrieve your macros in the next editing session. _1_5._6. _I_n_i_t_i_a_l_i_z_a_t_i_o_n _F_i_l_e_s _1_5._6. _I_n_i_t_i_a_l_i_z_a_t_i_o_n _F_i_l_e_s Users will likely want to modify the default key bindings to their liking. Since it would be quite annoying to have to set up the bindings each time JOVE is started up, JOVE has the ability to read in a "startup" file. Whenever JOVE is started, it reads commands from the file ._j_o_v_e_r_c in the user's home directory. These commands are read as if they were typed to the command handler (ESC X) during an edit. There can be only one command per line in the startup file. If there is a file /_u_s_r/_l_i_b/_j_o_v_e/_j_o_v_e_r_c, then this file will be read before the user's ._j_o_v_e_r_c file. This can be used to set up a system-wide default startup mode for JOVE that is tailored to the needs of that system. September 2, 1987 - 38 - The _s_o_u_r_c_e command can be used to read commands from a specified file at any time during an editing session, even from inside the ._j_o_v_e_r_c file. This means that a macro can be used to change the key bindings, e.g., to enter a mode, by reading from a specified file which contains all the necessary bindings. September 2, 1987 - 39 - _1_6. _A_l_p_h_a_b_e_t_i_c_a_l _L_i_s_t _o_f _C_o_m_m_a_n_d_s _a_n_d _V_a_r_i_a_b_l_e_s _1_6._1. _P_r_e_f_i_x-_1 (_E_s_c_a_p_e) This reads the next character and runs a command based on the character typed. If you wait for more than a second or so before typing the next character, the message "ESC" will be printed on the message line to remind you that JOVE is waiting for another character. _1_6._2. _P_r_e_f_i_x-_2 (_C-_X) This reads the next character and runs a command based on the character typed. If you wait for more than a second or so before typing another character, the message "C-X" will be printed on the message line to remind you that JOVE is waiting for another character. _1_6._3. _P_r_e_f_i_x-_3 (_N_o_t _B_o_u_n_d) This reads the next character and runs a command based on the character typed. If you wait for more than a second or so before typing the next character, the character that invoked Prefix-3 will be printed on the message line to remind you that JOVE is waiting for another one. _1_6._4. _a_l_l_o_w-^_S-_a_n_d-^_Q (_v_a_r_i_a_b_l_e) This variable, when set, tells JOVE that your terminal does not need to use the characters C-S and C-Q for flow control, and that it is okay to bind things to them. This variable should be set depending upon what kind of terminal you have. _1_6._5. _a_l_l_o_w-_b_a_d-_f_i_l_e_n_a_m_e_s (_v_a_r_i_a_b_l_e) If set, this variable permits filenames to contain "bad" charac- ters such as those from the set *&%!"`[]{}. These files are harder to deal with, because the characters mean something to the shell. The default value is "off". _1_6._6. _a_p_p_e_n_d-_r_e_g_i_o_n (_N_o_t _B_o_u_n_d) This appends the region to a specified file. If the file does not already exist it is created. _1_6._7. _a_p_r_o_p_o_s (_N_o_t _B_o_u_n_d) This types out all the commands, variables and macros with the specific keyword in their names. For each command and macro that contains the string, the key sequence that can be used to execute the command or macro is printed; with variables, the current value is printed. So, to find all the commands that are related to windows, you type September 2, 1987 - 40 - ESC X apropos window _1_6._8. _a_u_t_o-_c_a_s_e-_a_b_b_r_e_v (_v_a_r_i_a_b_l_e) When this variable is on (the default), word abbreviations are adjusted for case automatically. For example, if "jove" were the abbreviation for "jonathan's own version of emacs", then typing "jove" would give you "jonathan's own version of emacs", typing "Jove" would give you "Jonathan's own version of emacs", and typ- ing "JOVE" would give you "Jonathan's Own Version of Emacs". When this variable is "off", upper and lower case are dis- tinguished when looking for the abbreviation, i.e., in the exam- ple above, "JOVE" and "Jove" would not be expanded unless they were defined separately. _1_6._9. _a_u_t_o-_e_x_e_c_u_t_e-_c_o_m_m_a_n_d (_N_o_t _B_o_u_n_d) This tells JOVE to execute a command automatically when a file whose name matches a specified pattern is visited. The first argument is the command you want executed and the second is a regular expression pattern that specifies the files that apply. For example, if you want to be in show-match-mode when you edit C source files (that is, files that end with ".c" or ".h") you can type ESC X auto-execute-command show-match-mode .*.[ch]$ _1_6._1_0. _a_u_t_o-_e_x_e_c_u_t_e-_m_a_c_r_o (_N_o_t _B_o_u_n_d) This is like _a_u_t_o-_e_x_e_c_u_t_e-_c_o_m_m_a_n_d except you use it to execute macros automatically instead of built-in commands. _1_6._1_1. _a_u_t_o-_f_i_l_l-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns on Auto Fill mode (or off if it's currently on) in the selected buffer. When JOVE is in Auto Fill mode it automatically breaks lines for you when you reach the right margin so you don't have to remember to hit Return. JOVE uses 78 as the right margin but you can change that by setting the variable _r_i_g_h_t-_m_a_r_g_i_n to another value. See the _s_e_t command to learn how to do this. _1_6._1_2. _a_u_t_o-_i_n_d_e_n_t-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns on Auto Indent mode (or off if it's currently on) in the selected buffer. When JOVE is in Auto Indent mode, Return indents the new line to the same position as the line you were just on. This is useful for lining up C code (or any other language (but what else is there besides C?)). This is out of date because of the new command called _n_e_w_l_i_n_e-_a_n_d-_i_n_d_e_n_t but it remains because of several "requests" on the part of, uh, enthusiastic and excitable users, that it be left as it is. September 2, 1987 - 41 - _1_6._1_3. _b_a_c_k_w_a_r_d-_c_h_a_r_a_c_t_e_r (_C-_B) This moves point backward over a single character. If point is at the beginning of the line it moves to the end of the previous line. _1_6._1_4. _b_a_c_k_w_a_r_d-_p_a_r_a_g_r_a_p_h (_E_S_C [) This moves point backward to the beginning of the current or pre- vious paragraph. Paragraphs are bounded by lines that begin with a Period or Tab, or by blank lines; a change in indentation may also signal a break between paragraphs, except that JOVE allows the first line of a paragraph to be indented differently from the other lines. _1_6._1_5. _b_a_c_k_w_a_r_d-_s-_e_x_p_r_e_s_s_i_o_n (_E_S_C _C-_B) This moves point backward over a s-expression. It is just like _f_o_r_w_a_r_d-_s-_e_x_p_r_e_s_s_i_o_n with a negative argument. _1_6._1_6. _b_a_c_k_w_a_r_d-_s_e_n_t_e_n_c_e (_E_S_C _A) This moves point backward to the beginning of the current or pre- vious sentence. JOVE considers the end of a sentence to be the characters ".", "!" or "?" followed by a Return or by one or more spaces. _1_6._1_7. _b_a_c_k_w_a_r_d-_w_o_r_d (_E_S_C _B) This moves point backward to the beginning of the current or pre- vious word. _1_6._1_8. _b_a_d-_f_i_l_e_n_a_m_e-_e_x_t_e_n_s_i_o_n_s (_v_a_r_i_a_b_l_e) This contains a list of words separated by spaces which are to be considered bad filename extensions, and so will not be counted in filename completion. The default is ".o" so if you have jove.c and jove.o in the same directory, the filename completion will _n_o_t complain of an ambiguity because it will ignore jove.o. _1_6._1_9. _b_e_g_i_n_n_i_n_g-_o_f-_f_i_l_e (_E_S_C <) This moves point backward to the beginning of the buffer. This sometimes prints the "Point Pushed" message. If the top of the buffer isn't on the screen JOVE will set the mark so you can go back to where you were if you want. _1_6._2_0. _b_e_g_i_n_n_i_n_g-_o_f-_l_i_n_e (_C-_A) This moves point to the beginning of the current line. September 2, 1987 - 42 - _1_6._2_1. _b_e_g_i_n_n_i_n_g-_o_f-_w_i_n_d_o_w (_E_S_C ,) This moves point to the beginning of the current window. The sequence "ESC ," is the same as "ESC <" (beginning of file) except without the shift key on the "<", and can thus can easily be remembered. _1_6._2_2. _b_i_n_d-_t_o-_k_e_y (_N_o_t _B_o_u_n_d) This attaches a key to an internal JOVE command so that future hits on that key invoke that command. For example, to make "C-W" erase the previous word, you type "ESC X bind-to-key kill- previous-word C-W". _1_6._2_3. _b_i_n_d-_m_a_c_r_o-_t_o-_k_e_y (_N_o_t _B_o_u_n_d) This is like _b_i_n_d-_t_o-_k_e_y except you use it to attach keys to named macros. _1_6._2_4. _b_i_n_d-_m_a_c_r_o-_t_o-_w_o_r_d-_a_b_b_r_e_v (_N_o_t _B_o_u_n_d) This command allows you to bind a macro to a previously defined word abbreviation. Whenever you type the abbreviation, it will first be expanded as an abbreviation, and then the macro will be executed. Note that if the macro moves around, you should set the mark first (C-@) and then exchange the point and mark last (C-X C-X). _1_6._2_5. _b_u_f_f_e_r-_p_o_s_i_t_i_o_n (_N_o_t _B_o_u_n_d) This displays the current file name, current line number, total number of lines, percentage of the way through the file, and the position of the cursor in the current line. _1_6._2_6. _c-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns on C mode in the currently selected buffer. This is one of currently four possible major modes: Fundamental, Text, C, Lisp. When in C or Lisp mode, Tab, "}", and ")" behave a lit- tle differently from usual: They are indented to the "right" place for C (or Lisp) programs. In JOVE, the "right" place is simply the way the author likes it (but I've got good taste). _1_6._2_7. _c_a_s_e-_c_h_a_r_a_c_t_e_r-_c_a_p_i_t_a_l_i_z_e (_N_o_t _B_o_u_n_d) This capitalizes the character after point, i.e., the character undo the cursor. If a negative argument is supplied that many characters _b_e_f_o_r_e point are upper cased. _1_6._2_8. _c_a_s_e-_i_g_n_o_r_e-_s_e_a_r_c_h (_v_a_r_i_a_b_l_e) This variable, when set, tells JOVE to treat upper and lower case as the same when searching. Thus "jove" and "JOVE" would match, and "JoVe" would match either. The default value of this September 2, 1987 - 43 - variable is "off". _1_6._2_9. _c_a_s_e-_r_e_g_i_o_n-_l_o_w_e_r (_N_o_t _B_o_u_n_d) This changes all the upper case letters in the region to their lower case equivalent. _1_6._3_0. _c_a_s_e-_r_e_g_i_o_n-_u_p_p_e_r (_N_o_t _B_o_u_n_d) This changes all the lower case letters in the region to their upper case equivalent. _1_6._3_1. _c_a_s_e-_w_o_r_d-_c_a_p_i_t_a_l_i_z_e (_E_S_C _C) This capitalizes the current word by making the current letter upper case and making the rest of the word lower case. Point is moved to the end of the word. If point is not positioned on a word it is first moved forward to the beginning of the next word. If a negative argument is supplied that many words _b_e_f_o_r_e point are capitalized. This is useful for correcting the word just typed without having to move point to the beginning of the word yourself. _1_6._3_2. _c_a_s_e-_w_o_r_d-_l_o_w_e_r (_E_S_C _L) This lower-cases the current word and leaves point at the end of it. If point is in the middle of a word the rest of the word is converted. If point is not in a word it is first moved forward to the beginning of the next word. If a negative argument is supplied that many words _b_e_f_o_r_e point are converted to lower case. This is useful for correcting the word just typed without having to move point to the beginning of the word yourself. _1_6._3_3. _c_a_s_e-_w_o_r_d-_u_p_p_e_r (_E_S_C _U) This upper-cases the current word and leaves point at the end of it. If point is in the middle of a word the rest of the word is converted. If point is not in a word it is first moved forward to the beginning of the next word. If a negative argument is supplied that many words _b_e_f_o_r_e point are converted to upper case. This is useful for correcting the word just typed without having to move point to the beginning of the word yourself. _1_6._3_4. _c_h_a_r_a_c_t_e_r-_t_o-_o_c_t_a_l-_i_n_s_e_r_t (_N_o_t _B_o_u_n_d) This inserts a Back-slash followed by the ascii value of the next character typed. For example, "C-G" inserts the string "\007". _1_6._3_5. _c_d (_N_o_t _B_o_u_n_d) This changes the current directory. September 2, 1987 - 44 - _1_6._3_6. _c_l_e_a_r-_a_n_d-_r_e_d_r_a_w (_E_S_C _C-_L) This clears the entire screen and redraws all the windows. Use this when JOVE gets confused about what's on the screen, or when the screen gets filled with garbage characters or output from another program. _1_6._3_7. _c_o_m_m_e_n_t-_f_o_r_m_a_t (_v_a_r_i_a_b_l_e) This variable tells JOVE how to format your comments when you run the command _f_i_l_l-_c_o_m_m_e_n_t. Its format is this: %!%c%! The %!, %c, and %! must appear in the format; everything else is optional. A newline (represented by %n) may appear in the open or close patterns. %% is the representation for %. The default comment format is for C comments. See _f_i_l_l-_c_o_m_m_e_n_t for more. _1_6._3_8. _c_o_m_p_i_l_e-_i_t (_C-_X _C-_E) This compiles your program by running the UNIX command "make" into a buffer, and automatically parsing the error messages that are created (if any). See the _p_a_r_s_e-_e_r_r_o_r_s and _p_a_r_s_e-_s_p_e_c_i_a_l- _e_r_r_o_r_s commands. To compile a C program without "make", use "C-U C-X C-E" and JOVE will prompt for a command to run instead of make. (And then the command you type will become the default command.) You can use this to parse the output from the C com- piler or the "grep" or "lint" programs. _1_6._3_9. _c_o_n_t_i_n_u_e-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) This sends SIGCONT to the current interactive process, _i_f the process is currently stopped. _1_6._4_0. _c_o_p_y-_r_e_g_i_o_n (_E_S_C _W) This takes all the text in the region and copies it onto the kill ring buffer. This is just like running _k_i_l_l-_r_e_g_i_o_n followed by the _y_a_n_k command. See the _k_i_l_l-_r_e_g_i_o_n and _y_a_n_k commands. _1_6._4_1. _c_u_r_r_e_n_t-_e_r_r_o_r (_N_o_t _B_o_u_n_d) This moves to the current error in the list of parsed errors. See the _n_e_x_t-_e_r_r_o_r and _p_r_e_v_i_o_u_s-_e_r_r_o_r commands for more detailed information. _1_6._4_2. _d_a_t_e (_N_o_t _B_o_u_n_d) This prints the date on the message line. September 2, 1987 - 45 - _1_6._4_3. _d_e_f_i_n_e-_m_o_d_e-_w_o_r_d-_a_b_b_r_e_v (_N_o_t _B_o_u_n_d) This defines a mode-specific abbreviation. _1_6._4_4. _d_e_f_i_n_e-_g_l_o_b_a_l-_w_o_r_d-_a_b_b_r_e_v (_N_o_t _B_o_u_n_d) This defines a global abbreviation. _1_6._4_5. _d_e_l_e_t_e-_b_l_a_n_k-_l_i_n_e_s (_C-_X _C-_O) This deletes all the blank lines around point. This is useful when you previously opened many lines with "C-O" and now wish to delete the unused ones. _1_6._4_6. _d_e_l_e_t_e-_b_u_f_f_e_r (_C-_X _K) This deletes a buffer and frees up all the memory associated with it. Be careful! Once a buffer has been deleted it is gone for- ever. JOVE will ask you to confirm if you try to delete a buffer that needs saving. This command is useful for when JOVE runs out of space to store new buffers. _1_6._4_7. _d_e_l_e_t_e-_m_a_c_r_o (_N_o_t _B_o_u_n_d) This deletes a macro from the list of named macros. It is an error to delete the keyboard-macro. Once the macro is deleted it is gone forever. If you are about to save macros to a file and decide you don't want to save a particular one, delete it. _1_6._4_8. _d_e_l_e_t_e-_n_e_x_t-_c_h_a_r_a_c_t_e_r (_C-_D) This deletes the character that's just after point (that is, the character under the cursor). If point is at the end of a line, the line separator is deleted and the next line is joined with the current one. _1_6._4_9. _d_e_l_e_t_e-_o_t_h_e_r-_w_i_n_d_o_w_s (_C-_X _1) This deletes all the other windows except the current one. This can be thought of as going back into One Window mode. _1_6._5_0. _d_e_l_e_t_e-_p_r_e_v_i_o_u_s-_c_h_a_r_a_c_t_e_r (_R_u_b_o_u_t) This deletes the character that's just before point (that is, the character before the cursor). If point is at the beginning of the line, the line separator is deleted and that line is joined with the previous one. _1_6._5_1. _d_e_l_e_t_e-_w_h_i_t_e-_s_p_a_c_e (_E_S_C \) This deletes all the Tabs and Spaces around point. September 2, 1987 - 46 - _1_6._5_2. _d_e_l_e_t_e-_c_u_r_r_e_n_t-_w_i_n_d_o_w (_C-_X _D) This deletes the current window and moves point into one of the remaining ones. It is an error to try to delete the only remain- ing window. _1_6._5_3. _d_e_s_c_r_i_b_e-_b_i_n_d_i_n_g_s (_N_o_t _B_o_u_n_d) This types out a list containing each bound key and the command that gets invoked every time that key is typed. To make a wall chart of JOVE commands, set _s_e_n_d-_t_y_p_e_o_u_t-_t_o-_b_u_f_f_e_r to "on" and JOVE will store the key bindings in a buffer which you can save to a file and then print. _1_6._5_4. _d_e_s_c_r_i_b_e-_c_o_m_m_a_n_d (_N_o_t _B_o_u_n_d) This prints some info on a specified command. _1_6._5_5. _d_e_s_c_r_i_b_e-_k_e_y (_N_o_t _B_o_u_n_d) This waits for you to type a key and then tells the name of the command that gets invoked every time that key is hit. Once you have the name of the command you can use the _d_e_s_c_r_i_b_e-_c_o_m_m_a_n_d command to find out exactly what it does. _1_6._5_6. _d_e_s_c_r_i_b_e-_v_a_r_i_a_b_l_e (_N_o_t _B_o_u_n_d) This prints some info on a specified variable. _1_6._5_7. _d_i_g_i_t (_E_S_C [_0-_9]) This reads a numeric argument. When you type "ESC" followed by a number, "digit" keeps reading numbers until you type some other command. Then that command is executes with the numeric argument you specified. _1_6._5_8. _d_i_g_i_t-_1 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 1". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._5_9. _d_i_g_i_t-_2 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 2". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. September 2, 1987 - 47 - _1_6._6_0. _d_i_g_i_t-_3 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 3". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_1. _d_i_g_i_t-_4 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 4". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_2. _d_i_g_i_t-_5 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 5". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_3. _d_i_g_i_t-_6 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 6". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_4. _d_i_g_i_t-_7 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 7". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_5. _d_i_g_i_t-_8 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 8". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_6. _d_i_g_i_t-_9 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 9". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an September 2, 1987 - 48 - argument. _1_6._6_7. _d_i_g_i_t-_0 (_N_o_t _B_o_u_n_d) This pretends you typed "ESC 0". This is useful for terminals that have keypads that send special sequences for numbers typed on the keypad as opposed to numbers typed from the keyboard. This can save having type "ESC" when you want to specify an argu- ment. _1_6._6_8. _d_i_r_s (_N_o_t _B_o_u_n_d) This prints out the directory stack. See the "cd", "pushd", "popd" commands for more info. _1_6._6_9. _d_i_s_a_b_l_e-_b_i_f_f (_v_a_r_i_a_b_l_e) When this is set, JOVE disables biff when you're editing and enables it again when you get out of JOVE, or when you pause to the parent shell or push to a new shell. (This means arrival of new mail will not be immediately apparent but will not cause indiscriminate writing on the display). The default is "off". _1_6._7_0. _d_s_t_o_p-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) Send the "dsusp" character to the current process. This is the character that suspends a process on the next read from the ter- minal. Most people have it set to C-Y. This only works if you have the interactive process feature, and if you are in a buffer bound to a process. _1_6._7_1. _e_d_i_t-_w_o_r_d-_a_b_b_r_e_v_s (_N_o_t _B_o_u_n_d) This creates a buffer with a list of each abbreviation and the phrase it expands into, and enters a recursive edit to let you change the abbreviations or add some more. The format of this list is "abbreviation:phrase" so if you add some more you should follow that format. It's probably simplest just to copy some already existing abbreviations and edit them. When you are done you type "C-X C-C" to exit the recursive edit. _1_6._7_2. _e_n_d-_o_f-_f_i_l_e (_E_S_C >) This moves point forward to the end of the buffer. This some- times prints the "Point Pushed" message. If the end of the buffer isn't on the screen JOVE will set the mark so you can go back to where you were if you want. _1_6._7_3. _e_n_d-_o_f-_l_i_n_e (_C-_E) This moves point to the end of the current line. If the line is too long to fit on the screen JOVE will scroll the line to the left to make the end of the line visible. The line will slide back to its normal position when you move backward past the September 2, 1987 - 49 - leftmost visible character or when you move off the line alto- gether. _1_6._7_4. _e_n_d-_o_f-_w_i_n_d_o_w (_E_S_C .) This moves point to the last character in the window. _1_6._7_5. _e_o_f-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) Sends EOF to the current interactive process. This only works on versions of JOVE which run under 4.2-3 BSD VAX UNIX. You can't send EOF to processes on the 2.9 BSD PDP-11 UNIX. _1_6._7_6. _e_r_a_s_e-_b_u_f_f_e_r (_N_o_t _B_o_u_n_d) This erases the contents of the specified buffer. This is like _d_e_l_e_t_e-_b_u_f_f_e_r except it only erases the contents of the buffer, not the buffer itself. If you try to erase a buffer that needs saving you will be asked to confirm it. _1_6._7_7. _e_r_r_o_r-_w_i_n_d_o_w-_s_i_z_e (_v_a_r_i_a_b_l_e) This is the percentage of the screen to use for the error-window on the screen. When you execute _c_o_m_p_i_l_e-_i_t, _e_r_r_o_r-_w_i_n_d_o_w-_s_i_z_e percent of the screen will go to the error window. If the window already exists and is a different size, it is made to be this size. The default value is 20%. _1_6._7_8. _e_x_c_h_a_n_g_e-_p_o_i_n_t-_a_n_d-_m_a_r_k (_C-_X _C-_X) This moves point to mark and makes mark the old point. This is for quickly moving from one end of the region to another. _1_6._7_9. _e_x_e_c_u_t_e-_n_a_m_e_d-_c_o_m_m_a_n_d (_E_S_C _X) This is the way to execute a command that isn't bound to any key. When you are prompted with ": " you can type the name of the com- mand. You don't have to type the entire name. Once the command is unambiguous you can type Space and JOVE will fill in the rest for you. If you are not sure of the name of the command, type "?" and JOVE will print a list of all the commands that you could possibly match given what you've already typed. If you don't have any idea what the command's name is but you know it has something to do with windows (for example), you can do "ESC X apropos window" and JOVE will print a list of all the commands that are related to windows. If you find yourself constantly executing the same commands this way you probably want to bind them to keys so that you can execute them more quickly. See the _b_i_n_d-_t_o-_k_e_y command. _1_6._8_0. _e_x_e_c_u_t_e-_k_e_y_b_o_a_r_d-_m_a_c_r_o (_C-_X _E) This executes the keyboard macro. If you supply a numeric argu- ment the macro is executed that many times. September 2, 1987 - 50 - _1_6._8_1. _e_x_e_c_u_t_e-_m_a_c_r_o (_N_o_t _B_o_u_n_d) This executes a specified macro. If you supply a numeric argu- ment the macro is executed that many times. _1_6._8_2. _e_x_i_t-_j_o_v_e (_C-_X _C-_C) This exits JOVE. If any buffers need saving JOVE will print a warning message and ask for confirmation. If you leave without saving your buffers all your work will be lost. If you made a mistake and really do want to exit then you can. If you are in a recursive editing level _e_x_i_t-_j_o_v_e will return you from that. _1_6._8_3. _f_i_l_e-_c_r_e_a_t_i_o_n-_m_o_d_e (_v_a_r_i_a_b_l_e) This variable has an octal value. It contains the mode (see _c_h_m_o_d(_1) ) with which files should be created. This mode gets modified by your current umask setting (see _u_m_a_s_k(_1) ). The default value is usually _0_6_6_6 or _0_6_4_4. _1_6._8_4. _f_i_l_e_s-_s_h_o_u_l_d-_e_n_d-_w_i_t_h-_n_e_w_l_i_n_e (_v_a_r_i_a_b_l_e) This variable indicates that all files should always have a new- line at the end. This is often necessary for line printers and the like. When set, if JOVE is writing a file whose last charac- ter is not a newline, it will add one automatically. _1_6._8_5. _f_i_l_l-_c_o_m_m_e_n_t (_N_o_t _B_o_u_n_d) This command fills in your C comments to make them pretty and readable. This filling is done according the variable _c_o_m_m_e_n_t- _f_o_r_m_a_t. /* * the default format makes comments like this. */ This can be changed by changing the format variable. Other languages may be supported by changing the format variable appropriately. The formatter looks backwards from dot for an open comment symbol. If found, all indentation is done relative the position of the first character of the open symbol. If there is a matching close symbol, the entire comment is formatted. If not, the region between dot and the open symbol is reformatted. _1_6._8_6. _f_i_l_l-_p_a_r_a_g_r_a_p_h (_E_S_C _J) This rearranges words between lines so that all the lines in the current paragraph extend as close to the right margin as possi- ble, ensuring that none of the lines will be greater than the right margin. The default value for _r_i_g_h_t-_m_a_r_g_i_n is 78, but can be changed with the _s_e_t and _r_i_g_h_t-_m_a_r_g_i_n-_h_e_r_e commands. JOVE has a complicated algorithm for determining the beginning and end of the paragraph. In the normal case JOVE will give all the lines September 2, 1987 - 51 - the same indent as they currently have, but if you wish to force a new indent you can supply a numeric argument to _f_i_l_l-_p_a_r_a_g_r_a_p_h (e.g., by typing C-U ESC J) and JOVE will indent each line to the column specified by the _l_e_f_t-_m_a_r_g_i_n variable. See also the _l_e_f_t-_m_a_r_g_i_n variable and _l_e_f_t-_m_a_r_g_i_n-_h_e_r_e command. _1_6._8_7. _f_i_l_l-_r_e_g_i_o_n (_N_o_t _B_o_u_n_d) This is like _f_i_l_l-_p_a_r_a_g_r_a_p_h, except it operates on a region instead of just a paragraph. _1_6._8_8. _f_i_l_t_e_r-_r_e_g_i_o_n (_N_o_t _B_o_u_n_d) This sends the text in the region to a UNIX command, and replaces the region with the output from that command. For example, if you are lazy and don't like to take the time to write properly indented C code, you can put the region around your C file and _f_i_l_t_e_r-_r_e_g_i_o_n it through _c_b, the UNIX C beautifier. If you have a file that contains a bunch of lines that need to be sorted you can do that from inside JOVE too, by filtering the region through the _s_o_r_t UNIX command. Before output from the command replaces the region JOVE stores the old text in the kill ring, so if you are unhappy with the results you can easily get back the old text with "C-Y". _1_6._8_9. _f_i_n_d-_f_i_l_e (_C-_X _C-_F) This visits a file into its own buffer and then selects that buffer. If you've already visited this file in another buffer, that buffer is selected. If the file doesn't yet exist, JOVE will print "(New file)" so that you know. _1_6._9_0. _f_i_n_d-_t_a_g (_C-_X _T) This finds the file that contains the specified tag. JOVE looks up tags by default in the "tags" file in the current directory. You can change the default tag name by setting the _t_a_g-_f_i_l_e vari- able to another name. If you specify a numeric argument to this command, you will be prompted for a tag file. This is a good way to specify another tag file without changing the default. If the tag cannot be found the error is reported and point stays where it is. _1_6._9_1. _f_i_n_d-_t_a_g-_a_t-_p_o_i_n_t (_N_o_t _B_o_u_n_d) This finds the file that contains the tag that point is currently on. See _f_i_n_d-_t_a_g. _1_6._9_2. _f_i_r_s_t-_n_o_n-_b_l_a_n_k (_E_S_C _M) This moves point back to the indent of the current line. September 2, 1987 - 52 - _1_6._9_3. _f_o_r_w_a_r_d-_c_h_a_r_a_c_t_e_r (_C-_F) This moves forward over a single character. If point is at the end of the line it moves to the beginning of the next one. _1_6._9_4. _f_o_r_w_a_r_d-_p_a_r_a_g_r_a_p_h (_E_S_C ]) This moves point forward to the end of the current or next para- graph. Paragraphs are bounded by lines that begin with a Period or Tab, or by blank lines; a change in indentation may also sig- nal a break between paragraphs, except that JOVE allows the first line of a paragraph to be indented differently from the other lines. _1_6._9_5. _f_o_r_w_a_r_d-_s-_e_x_p_r_e_s_s_i_o_n (_E_S_C _C-_F) This moves point forward over a s-expression. If the first sig- nificant character after point is "(", this moves past the match- ing ")". If the character begins an identifier, this moves just past it. This is mode dependent, so this will move over atoms in LISP mode and C identifiers in C mode. JOVE also matches "{". _1_6._9_6. _f_o_r_w_a_r_d-_s_e_n_t_e_n_c_e (_E_S_C _E) This moves point forward to the end of the current or next sen- tence. JOVE considers the end of a sentence to be the characters ".", "!" or "?" followed by a Return, or one or more spaces. _1_6._9_7. _f_o_r_w_a_r_d-_w_o_r_d (_E_S_C _F) This moves point forward to the end of the current or next word. _1_6._9_8. _f_u_n_d_a_m_e_n_t_a_l-_m_o_d_e (_N_o_t _B_o_u_n_d) This sets the major mode to Fundamental. This affects what JOVE considers as characters that make up words. For instance, Single-quote is not part of a word in Fundamental mode, but is in Text mode. _1_6._9_9. _g_o_t_o-_l_i_n_e (_E_S_C _G) If a numeric argument is supplied point moves to the beginning of that line. If no argument is supplied, point remains where it is. This is so you don't lose your place unintentionally, by accidentally hitting the "G" instead of "F". _1_6._1_0_0. _g_r_i_n_d-_s-_e_x_p_r (_N_o_t _B_o_u_n_d) When point is positioned on a "(", this re-indents that LISP expression. September 2, 1987 - 53 - _1_6._1_0_1. _g_r_o_w-_w_i_n_d_o_w (_C-_X ^) This makes the current window one line bigger. This only works when there is more than one window and provided there is room to change the size. _1_6._1_0_2. _p_a_r_e_n-_f_l_a_s_h () } ]) This handles the C mode curly brace indentation, the Lisp mode paren indentation, and the Show Match mode paren/curly brace/square bracket flashing. _1_6._1_0_3. _h_a_n_d_l_e-_t_a_b (_T_a_b) This handles indenting to the "right" place in C and Lisp mode, and just inserts itself in Text mode. _1_6._1_0_4. _i-_s_e_a_r_c_h-_f_o_r_w_a_r_d (_N_o_t _B_o_u_n_d) Incremental search. Like search-forward except that instead of prompting for a string and searching for that string all at once, it accepts the string one character at a time. After each char- acter you type as part of the search string, it searches for the entire string so far. When you like what it found, type the Return key to finish the search. You can take back a character with Rubout and the search will back up to the position before that character was typed. C-G aborts the search. _1_6._1_0_5. _i-_s_e_a_r_c_h-_r_e_v_e_r_s_e (_N_o_t _B_o_u_n_d) Incremental search. Like search-reverse except that instead of prompting for a string and searching for that string all at once, it accepts the string one character at a time. After each char- acter you type as part of the search string, it searches for the entire string so far. When you like what it found, type the Return key to finish the search. You can take back a character with Rubout and the search will back up to the position before that character was typed. C-G aborts the search. _1_6._1_0_6. _i_n_s_e_r_t-_f_i_l_e (_C-_X _C-_I) This inserts a specified file into the current buffer at point. Point is positioned at the beginning of the inserted file. _1_6._1_0_7. _i_n_t_e_r_n_a_l-_t_a_b_s_t_o_p (_v_a_r_i_a_b_l_e) The number of spaces JOVE should print when it displays a tab character. The default value is 8. _1_6._1_0_8. _i_n_t_e_r_r_u_p_t-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) This sends the interrupt character (usually C-C) to the interac- tive process in the current buffer. This is only for versions of JOVE that have the interactive processes feature. This only September 2, 1987 - 54 - works when you are inside a buffer that's attached to a process. _1_6._1_0_9. _i-_s_h_e_l_l (_N_o_t _B_o_u_n_d) This starts up an interactive shell in a window. JOVE uses "shell-1" as the name of the buffer in which the interacting takes place. See the manual for information on how to use interactive processes. _1_6._1_1_0. _i-_s_h_e_l_l-_c_o_m_m_a_n_d (_N_o_t _B_o_u_n_d) This is like _s_h_e_l_l-_c_o_m_m_a_n_d except it lets you continue with your editing while the command is running. This is really useful for long running commands with sporadic output. See the manual for information on how to use interactive processes. _1_6._1_1_1. _k_i_l_l-_n_e_x_t-_w_o_r_d (_E_S_C _D) This kills the text from point to the end of the current or next word. _1_6._1_1_2. _k_i_l_l-_p_r_e_v_i_o_u_s-_w_o_r_d (_E_S_C _R_u_b_o_u_t) This kills the text from point to the beginning of the current or previous word. _1_6._1_1_3. _k_i_l_l-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) This command prompts for a buffer name or buffer number (just as select-buffer does) and then sends the process in that buffer a kill signal (9). _1_6._1_1_4. _k_i_l_l-_r_e_g_i_o_n (_C-_W) This deletes the text in the region and saves it on the kill ring. Commands that delete text but save it on the kill ring all have the word "kill" in their names. Type "C-Y" to yank back the most recent kill. _1_6._1_1_5. _k_i_l_l-_s-_e_x_p_r_e_s_s_i_o_n (_E_S_C _C-_K) This kills the text from point to the end of the current or next s-expression. _1_6._1_1_6. _k_i_l_l-_s_o_m_e-_b_u_f_f_e_r_s (_N_o_t _B_o_u_n_d) This goes through all the existing buffers and asks whether or not to kill them. If you decide to kill a buffer, and it turns out that the buffer is modified, JOVE will offer to save it first. This is useful for when JOVE runs out of memory to store lines (this only happens on PDP-11's) and you have lots of buffers that you are no longer using. September 2, 1987 - 55 - _1_6._1_1_7. _k_i_l_l-_t_o-_b_e_g_i_n_n_i_n_g-_o_f-_s_e_n_t_e_n_c_e (_C-_X _R_u_b_o_u_t) This kills from point to the beginning of the current or previous sentence. _1_6._1_1_8. _k_i_l_l-_t_o-_e_n_d-_o_f-_l_i_n_e (_C-_K) This kills from point to the end of the current line. When point is at the end of the line the line separator is deleted and the next line is joined with current one. If a numeric argument is supplied that many lines are killed; if the argument is negative that many lines _b_e_f_o_r_e point are killed; if the argument is zero the text from point to the beginning of the line is killed. _1_6._1_1_9. _k_i_l_l-_t_o-_e_n_d-_o_f-_s_e_n_t_e_n_c_e (_E_S_C _K) This kills from point to the end of the current or next sentence. If a negative numeric argument is supplied it kills from point to the beginning of the current or previous sentence. _1_6._1_2_0. _l_e_f_t-_m_a_r_g_i_n (_v_a_r_i_a_b_l_e) This is how far lines should be indented when auto-indent mode is on, or when the _n_e_w_l_i_n_e-_a_n_d-_i_n_d_e_n_t command is run (usually by typing LineFeed). It is also used by fill-paragraph and auto- fill mode. If the value is zero (the default) then the left mar- gin is determined from the surrounding lines. _1_6._1_2_1. _l_e_f_t-_m_a_r_g_i_n-_h_e_r_e (_N_o_t _B_o_u_n_d) This sets the _l_e_f_t-_m_a_r_g_i_n variable to the current position of point. This is an easy way to say, "Make the left margin begin here," without having to count the number of spaces over it actu- ally is. _1_6._1_2_2. _l_i_s_p-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns on Lisp mode. Lisp mode is one of four mutually exclusive major modes: Fundamental, Text, C, and Lisp. In Lisp mode, the characters Tab and ) are treated specially, similar to the way they are treated in C mode. Also, Auto Indent mode is affected, and handled specially. _1_6._1_2_3. _l_i_s_t-_b_u_f_f_e_r_s (_C-_X _C-_B) This types out a list containing various information about each buffer. Right now that list looks like this: (* means the buffer needs saving) NO Lines Type Name File -- ----- ---- ---- ---- 1 1 File Main [No file] 2 1 Scratch * Minibuf [No file] 3 519 File * commands.doc commands.doc September 2, 1987 - 56 - The first column lists the buffer's number. When JOVE prompts for a buffer name you can either type in the full name, or you can simply type the buffer's number. The second column is the number of lines in the buffer. The third says what type of buffer. There are four types: "File", "Scratch", "Process", "I- Process". "File" is simply a buffer that holds a file; "Scratch" is for buffers that JOVE uses internally; "Process" is one that holds the output from a UNIX command; "I-Process" is one that has an interactive process attached to it. The next column contains the name of the buffer. And the last column is the name of the file that's attached to the buffer. In this case, both Minibuf and commands.doc have been changed but not yet saved. In fact Minibuf won't be saved since it's an internal JOVE buffer that I don't even care about. _1_6._1_2_4. _l_i_s_t-_p_r_o_c_e_s_s_e_s (_N_o_t _B_o_u_n_d) This makes a list somewhat like "list-buffers" does, except its list consists of the current interactive processes. Right now the list looks like this: Buffer Status Command name ------ ------ ------- ---- shell-1 Running i-shell fgrep Done fgrep -n Buffer *.c The first column has the name of the buffer to which the process is attached. The second has the status of the process; if a pro- cess has exited normally the status is "Done" as in fgrep; if the process exited with an error the status is "Exit N" where N is the value of the exit code; if the process was killed by some signal the status is the name of the signal that was used; other- wise the process is running. The last column is the name of the command that is being run. _1_6._1_2_5. _m_a_i_l_b_o_x (_v_a_r_i_a_b_l_e) Set this to the full pathname of your mailbox. JOVE will look here to decide whether or not you have any unread mail. This defaults to /usr/spool/mail/$USER, where $USER is set to your login name. _1_6._1_2_6. _m_a_i_l-_c_h_e_c_k-_f_r_e_q_u_e_n_c_y (_v_a_r_i_a_b_l_e) This is how often (in seconds) JOVE should check your mailbox for incoming mail. See also the _m_a_i_l_b_o_x and _d_i_s_a_b_l_e-_b_i_f_f variables. _1_6._1_2_7. _m_a_k_e-_b_a_c_k_u_p-_f_i_l_e_s (_v_a_r_i_a_b_l_e) If this variable is set, then whenever JOVE writes out a file, it will move the previous version of the file (if there was one) to "#filename". This is often convenient if you save a file by accident. The default value of this variable is "off". _N_o_t_e: this is an optional part of JOVE, and your guru may not have it September 2, 1987 - 57 - enabled, so it may not work. _1_6._1_2_8. _m_a_k_e-_b_u_f_f_e_r-_u_n_m_o_d_i_f_i_e_d (_E_S_C ~) This makes JOVE think the selected buffer hasn't been changed even if it has. Use this when you accidentally change the buffer but don't want it considered changed. Watch the mode line to see the * disappear when you use this command. _1_6._1_2_9. _m_a_k_e-_m_a_c_r_o-_i_n_t_e_r_a_c_t_i_v_e (_N_o_t _B_o_u_n_d) This command is meaningful only while you are defining a keyboard macro. Ordinarily, when a command in a macro definition requires a trailing text argument (file name, search string, etc.), the argument you supply becomes part of the macro definition. If you want to be able to supply a different argument each time the macro is used, then while you are defining it, you should give the make-macro-interactive command just before typing the argu- ment which will be used during the definition process. Note: you must bind this command to a key in order to use it; you can't say ESC X make-macro-interactive. _1_6._1_3_0. _m_a_r_k-_t_h_r_e_s_h_o_l_d (_v_a_r_i_a_b_l_e) This variable contains the number of lines point may move by before the mark is set. If, in a search or something, point moves by more than this many lines, the mark is set so that you may return easily. The default value of this variable is 22 (one screenful, on most terminals). _1_6._1_3_1. _m_a_r_k_s-_s_h_o_u_l_d-_f_l_o_a_t (_v_a_r_i_a_b_l_e) When this variable is "off", the position of a mark is remembered as a line number within the buffer and a character number within the line. If you add or delete text before the mark, it will no longer point to the text you marked originally because that text is no longer at the same line and character number. When this variable is "on", the position of a mark is adjusted to compen- sate for each insertion and deletion. This makes marks much more sensible to use, at the cost of slowing down insertion and dele- tion somewhat. The default value is "on". _1_6._1_3_2. _m_a_t_c_h-_r_e_g_u_l_a_r-_e_x_p_r_e_s_s_i_o_n_s (_v_a_r_i_a_b_l_e) When set, JOVE will match regular expressions in search patterns. This makes special the characters ., *, [, ], ^, and $, and the two-character sequences \<, \>, \{, \} and \|. See the _e_d(_1) manual page, the tutorial "Advanced Editing in UNIX ", and the section above "Searching with Regular Expressions" for more information. September 2, 1987 - 58 - _1_6._1_3_3. _m_e_t_a-_k_e_y (_v_a_r_i_a_b_l_e) You should set this variable to "on" if your terminal has a real Meta key. If your terminal has such a key, then a key sequence like ESC Y can be entered by holding down Meta and typing Y. _1_6._1_3_4. _m_o_d_e-_l_i_n_e (_v_a_r_i_a_b_l_e) The format of the mode line can be determined by setting this variable. The items in the line are specified using a printf(3) format, with the special things being marked as "%x". Digits may be used between the 'x' may be: C check for new mail, and displays "[New mail]" if there is any (see also the mail-check-interval and disable-biff variables) F the current file name, with leading path stripped M the current list of major and minor modes b the current buffer name c the fill character (-) d the current directory e end of string--this must be the last item in the string f the current file name l the current load average (updated automatically) m the buffer-modified symbol (*) n the current buffer number s space, but only if previous character is not a space t the current time (updated automatically) [ ] the square brackets printed when in a recursive edit ( ) items enclosed in %( ... %) will only be printed on the bottom mode line, rather than copied when the window is split In addition, any other character is simply copied into the mode line. Characters may be escaped with a backslash. To get a feel for all this, try typing "ESC X print mode-line" and compare the result with your current mode line. _1_6._1_3_5. _m_o_d_e-_l_i_n_e-_s_h_o_u_l_d-_s_t_a_n_d_o_u_t (_v_a_r_i_a_b_l_e) If set, the mode line will be printed in reverse video, if your terminal supports it. The default for this variable is "off". _1_6._1_3_6. _n_a_m_e-_k_e_y_b_o_a_r_d-_m_a_c_r_o (_N_o_t _B_o_u_n_d) This copies the keyboard macro and gives it a name freeing up the keyboard macro so you can define some more. Keyboard macros with their own names can be bound to keys just like built in commands can. See the _r_e_a_d-_m_a_c_r_o_s-_f_i_l_e-_f_i_l_e and _w_r_i_t_e-_m_a_c_r_o_s-_t_o-_f_i_l_e com- mands. September 2, 1987 - 59 - _1_6._1_3_7. _n_e_w_l_i_n_e (_R_e_t_u_r_n) This divides the current line at point moving all the text to the right of point down onto the newly created line. Point moves down to the beginning of the new line. _1_6._1_3_8. _n_e_w_l_i_n_e-_a_n_d-_b_a_c_k_u_p (_C-_O) This divides the current line at point moving all the text to the right of point down onto the newly created line. The difference between this and "newline" is that point does not move down to the beginning of the new line. _1_6._1_3_9. _n_e_w_l_i_n_e-_a_n_d-_i_n_d_e_n_t (_L_i_n_e_F_e_e_d) This behaves the same was as Return does when in Auto Indent mode. This makes Auto Indent mode obsolete but it remains in the name of backward compatibility. _1_6._1_4_0. _n_e_x_t-_e_r_r_o_r (_C-_X _C-_N) This moves to the next error in the list of errors that were parsed with _p_a_r_s_e-_e_r_r_o_r_s or _p_a_r_s_e-_s_p_e_c_i_a_l-_e_r_r_o_r_s. In one window the list of errors is shown with the current one always at the top. In another window is the file that contains the error. Point is positioned in this window on the line where the error occurred. _1_6._1_4_1. _n_e_x_t-_l_i_n_e (_C-_N) This moves down to the next line. _1_6._1_4_2. _n_e_x_t-_p_a_g_e (_C-_V) This displays the next page of the buffer by taking the bottom line of the window and redrawing the window with it at the top. If there isn't another page in the buffer JOVE rings the bell. If a numeric argument is supplied the screen is scrolled up that many lines; if the argument is negative the screen is scrolled down. _1_6._1_4_3. _n_e_x_t-_w_i_n_d_o_w (_C-_X _N) This moves into the next window. Windows live in a circular list so when you're in the bottom window and you try to move to the next one you are moved to the top window. It is an error to use this command with only one window. _1_6._1_4_4. _n_u_m_b_e_r-_l_i_n_e_s-_i_n-_w_i_n_d_o_w (_N_o_t _B_o_u_n_d) This displays the line numbers for each line in the buffer being displayed. The number isn't actually part of the text; it's just printed before the actual buffer line is. To turn this off you run the command again; it toggles. September 2, 1987 - 60 - _1_6._1_4_5. _o_v_e_r-_w_r_i_t_e-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns Over Write mode on (or off if it's currently on) in the selected buffer. When on, this mode changes the way the self-inserting characters work. Instead of inserting themselves and pushing the rest of the line over to the right, they replace or over-write the existing character. Also, Rubout replaces the character before point with a space instead of deleting it. When Over Write mode is on "OvrWt" is displayed on the mode line. _1_6._1_4_6. _p_a_g_e-_n_e_x_t-_w_i_n_d_o_w (_E_S_C _C-_V) This displays the next page in the next window. This is exactly the same as "C-X N C-V C-X P". _1_6._1_4_7. _p_a_r_e_n-_f_l_a_s_h-_d_e_l_a_y (_v_a_r_i_a_b_l_e) How long, in tenths of seconds, JOVE should pause on a matching parenthesis in _S_h_o_w mode. The default is 5. _1_6._1_4_8. _p_a_r_s_e-_e_r_r_o_r_s (_N_o_t _B_o_u_n_d) This takes the list of C compilation errors (or output from another program in the same format) in the current buffer and parses them for use with the _n_e_x_t-_e_r_r_o_r and _p_r_e_v_i_o_u_s-_e_r_r_o_r and _c_u_r_r_e_n_t-_e_r_r_o_r commands. This is a very useful tool and helps with compiling C programs and when used in conjunction with the "grep" UNIX command very helpful in making changes to a bunch of files. This command understands errors produced by cc, cpp, and lint; plus any other program with the same format (e.g., "grep -n"). JOVE visits each file that has an error and remembers each line that contains an error. It doesn't matter if later you insert or delete some lines in the buffers containing errors; JOVE remembers where they are regardless. _n_e_x_t-_e_r_r_o_r is automat- ically executed after one of the parse commands, so you end up at the first error. _1_6._1_4_9. _p_a_r_s_e-_s_p_e_c_i_a_l-_e_r_r_o_r_s (_N_o_t _B_o_u_n_d) This parses errors in an unknown format. Error parsing works with regular expression search strings with \('s around the the file name and the line number. So, you can use _p_a_r_s_e-_s_p_e_c_i_a_l- _e_r_r_o_r_s to parse lines that are in a slightly different format by typing in your own search string. If you don't know how to use regular expressions you can't use this command. _1_6._1_5_0. _p_a_r_s_e-_s_p_e_l_l_i_n_g-_e_r_r_o_r_s-_i_n-_b_u_f_f_e_r (_N_o_t _B_o_u_n_d) This parses a list of words in the current buffer and looks them up in another buffer that you specify. This will probably go away soon. September 2, 1987 - 61 - _1_6._1_5_1. _p_a_u_s_e-_j_o_v_e (_E_S_C _S) This stops JOVE and returns control to the parent shell. This only works for users using the C-shell, and on systems that have the job control facility. To return to JOVE you type "fg" to the C-shell. _1_6._1_5_2. _p_h_y_s_i_c_a_l-_t_a_b_s_t_o_p (_v_a_r_i_a_b_l_e) How many spaces your terminal prints when it prints a tab charac- ter. _1_6._1_5_3. _p_o_p-_m_a_r_k (_N_o_t _B_o_u_n_d) This gets executed when you run _s_e_t-_m_a_r_k with a numeric argument. JOVE remembers the last 16 marks and you use _p_o_p-_m_a_r_k to go back- ward through the ring of marks. If you execute " _p_o_p-_m_a_r_k enough times you will eventually get back to where you started. _1_6._1_5_4. _p_o_p_d (_N_o_t _B_o_u_n_d) This pops one entry off the directory stack. Entries are pushed with the _p_u_s_h_d command. The names were stolen from the C-shell and the behavior is the same. _1_6._1_5_5. _p_r_e_v_i_o_u_s-_e_r_r_o_r (_C-_X _C-_P) This is the same as _n_e_x_t-_e_r_r_o_r except it goes to the previous error. See _n_e_x_t-_e_r_r_o_r for documentation. _1_6._1_5_6. _p_r_e_v_i_o_u_s-_l_i_n_e (_C-_P) This moves up to the previous line. _1_6._1_5_7. _p_r_e_v_i_o_u_s-_p_a_g_e (_E_S_C _V) This displays the previous page of the current buffer by taking the top line and redrawing the window with it at the bottom. If a numeric argument is supplied the screen is scrolled down that many lines; if the argument is negative the screen is scrolled up. _1_6._1_5_8. _p_r_e_v_i_o_u_s-_w_i_n_d_o_w (_C-_X _P _a_n_d _C-_X _O) This moves into the next window. Windows live in a circular list so when you're in the top window and you try to move to the pre- vious one you are moved to the bottom window. It is an error to use this command with only one window. _1_6._1_5_9. _p_r_i_n_t (_N_o_t _B_o_u_n_d) This prints the value of a JOVE variable. September 2, 1987 - 62 - _1_6._1_6_0. _p_r_i_n_t-_m_e_s_s_a_g_e (_N_o_t _B_o_u_n_d) This command prompts for a message, and then prints it on the bottom line where JOVE messages are printed. _1_6._1_6_1. _p_r_o_c_e_s_s-_b_i_n_d-_t_o-_k_e_y (_N_o_t _B_o_u_n_d) This command is identical to bind-to-key, except that it only affects your bindings when you are in a buffer attached to a pro- cess. When you enter the process buffer, any keys bound with this command will automatically take their new values. When you switch to a non-process buffer, the old bindings for those keys will be restored. For example, you might want to execute process-bind-to-key stop-process ^Z process-bind-to-key interrupt-process ^C Then, when you start up an interactive process and switch into that buffer, C-Z will execute stop-process and C-C will execute interrupt- process. When you switch back to a non-process buffer, C-Z will go back to executing scroll-up (or whatever you have it bound to). _1_6._1_6_2. _p_r_o_c_e_s_s-_n_e_w_l_i_n_e (_R_e_t_u_r_n) This this only gets executed when in a buffer that is attached to an interactive-process. JOVE does two different things depending on where you are when you hit Return. When you're at the end of the I-Process buffer this does what Return normally does, except it also makes the line available to the process. When point is positioned at some other position that line is copied to the end of the buffer (with the prompt stripped) and point is moved there with it, so you can then edit that line before sending it to the process. This command _m_u_s_t be bound to the key you usually use to enter shell commands (Return), or else you won't be able to enter any. _1_6._1_6_3. _p_r_o_c_e_s_s-_p_r_o_m_p_t (_v_a_r_i_a_b_l_e) What a prompt looks like from the i-shell and i-shell-command processes. The default is "% ", the default C-shell prompt. This is actually a regular expression search string. So you can set it to be more than one thing at once using the \| operator. For instance, for LISP hackers, the prompt can be "% -> <[0-9]>: ". _1_6._1_6_4. _p_u_s_h-_s_h_e_l_l (_N_o_t _B_o_u_n_d) This spawns a child shell and relinquishes control to it. This works on any version of UNIX, but this isn't as good as _p_a_u_s_e- _j_o_v_e because it takes time to start up the new shell and you get a brand new environment every time. To return to JOVE you type September 2, 1987 - 63 - "C-D". _1_6._1_6_5. _p_u_s_h_d (_N_o_t _B_o_u_n_d) This pushes a directory onto the directory stack and cd's into it. It asks for the directory name but if you don't specify one it switches the top two entries no the stack. It purposely behaves the same as C-shell's _p_u_s_h_d. _1_6._1_6_6. _p_w_d (_N_o_t _B_o_u_n_d) This prints the working directory. _1_6._1_6_7. _q_u_a_d_r_u_p_l_e-_n_u_m_e_r_i_c-_a_r_g_u_m_e_n_t (_C-_U) This multiplies the numeric argument by 4. So, "C-U C-F" means forward 4 characters and "C-U C-U C-N" means down 16 lines. _1_6._1_6_8. _q_u_e_r_y-_r_e_p_l_a_c_e-_s_t_r_i_n_g (_E_S_C _Q) This replaces the occurrences of a specified string with a speci- fied replacement string. When an occurrence is found point is moved to it and then JOVE asks what to do. The options are: Space to replace this occurrence and go on to the next one. Period to replace this occurrence and then stop. Rubout to skip this occurrence and go on to the next one. C-R to enter a recursive edit. This lets you temporarily suspend the replace, do some editing, and then return to continue where you left off. To continue with the Query Replace type "C-X C-C" as if you were trying to exit JOVE. Normally you would but when you are in a recursive edit all it does is exit that recursive editing level. C-W to delete the matched string and then enter a recursive edit. U to undo the last replacement. P or ! to go ahead and replace the remaining occurrences without asking. Return to stop the Query Replace. The search for occurrences starts at point and goes to the end of the buffer, so to replace in the entire buffer you must first go to the beginning. _1_6._1_6_9. _q_u_i_t-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) This is the same as typing "C-\" (the Quit character) to a normal UNIX process, except it sends it to the current process in JOVE. This is only for versions of JOVE that have the interactive processes feature. This only works when you are inside a buffer that's attached to a process. September 2, 1987 - 64 - _1_6._1_7_0. _q_u_o_t_e_d-_i_n_s_e_r_t (_C-_Q) This lets you insert characters that normally would be executed as other JOVE commands. For example, to insert "C-F" you type "C-Q C-F". _1_6._1_7_1. _r_e_a_d-_w_o_r_d-_a_b_b_r_e_v-_f_i_l_e (_N_o_t _B_o_u_n_d) This reads a specified file that contains a bunch of abbreviation definitions, and makes those abbreviations available. If the selected buffer is not already in Word Abbrev mode this command puts it in that mode. _1_6._1_7_2. _r_e_a_d-_m_a_c_r_o_s-_f_r_o_m-_f_i_l_e (_N_o_t _B_o_u_n_d) This reads the specified file that contains a bunch of macro definitions, and defines all the macros that were currently defined when the file was created. See _w_r_i_t_e-_m_a_c_r_o_s-_t_o-_f_i_l_e to see how to save macros. _1_6._1_7_3. _r_e_d_r_a_w-_d_i_s_p_l_a_y (_C-_L) This centers the line containing point in the window. If that line is already in the middle the window is first cleared and then redrawn. If a numeric argument is supplied, the line is positioned at that offset from the top of the window. For exam- ple, "ESC 0 C-L" positions the line containing point at the top of the window. _1_6._1_7_4. _r_e_c_u_r_s_i_v_e-_e_d_i_t (_N_o_t _B_o_u_n_d) This enters a recursive editing level. This isn't really very useful. I don't know why it's available for public use. I think I'll delete it some day. _1_6._1_7_5. _r_e_n_a_m_e-_b_u_f_f_e_r (_N_o_t _B_o_u_n_d) This lets you rename the current buffer. _1_6._1_7_6. _r_e_p_l_a_c_e-_i_n-_r_e_g_i_o_n (_N_o_t _B_o_u_n_d) This is the same as _r_e_p_l_a_c_e-_s_t_r_i_n_g except that it is restricted to occurrences between Point and Mark. _1_6._1_7_7. _r_e_p_l_a_c_e-_s_t_r_i_n_g (_E_S_C _R) This replaces all occurrences of a specified string with a speci- fied replacement string. This is just like _q_u_e_r_y-_r_e_p_l_a_c_e-_s_t_r_i_n_g except it replaces without asking. _1_6._1_7_8. _r_i_g_h_t-_m_a_r_g_i_n (_v_a_r_i_a_b_l_e) Where the right margin is for _A_u_t_o _F_i_l_l mode and the _j_u_s_t_i_f_y- _p_a_r_a_g_r_a_p_h and _j_u_s_t_i_f_y-_r_e_g_i_o_n commands. The default is 78. September 2, 1987 - 65 - _1_6._1_7_9. _r_i_g_h_t-_m_a_r_g_i_n-_h_e_r_e (_N_o_t _B_o_u_n_d) This sets the _r_i_g_h_t-_m_a_r_g_i_n variable to the current position of point. This is an easy way to say, "Make the right margin begin here," without having to count the number of spaces over it actu- ally is. _1_6._1_8_0. _s_a_v_e-_f_i_l_e (_C-_X _C-_S) This saves the current buffer to the associated file. This makes your changes permanent so you should be sure you really want to. If the buffer has not been modified _s_a_v_e-_f_i_l_e refuses to do the save. If you really do want to write the file you can use "C-X C-W" which executes _w_r_i_t_e-_f_i_l_e. _1_6._1_8_1. _s_c_r_o_l_l-_d_o_w_n (_E_S_C _Z) This scrolls the screen one line down. If the line containing point moves past the bottom of the window point is moved up to the center of the window. If a numeric argument is supplied that many lines are scrolled; if the argument is negative the screen is scrolled up instead. _1_6._1_8_2. _s_c_r_o_l_l-_s_t_e_p (_v_a_r_i_a_b_l_e) How many lines should be scrolled if the _p_r_e_v_i_o_u_s-_l_i_n_e or _n_e_x_t- _l_i_n_e commands move you off the top or bottom of the screen. You may wish to decrease this variable if you are on a slow terminal. _1_6._1_8_3. _s_c_r_o_l_l-_u_p (_C-_Z) This scrolls the screen one line up. If the line containing point moves past the top of the window point is moved down to the center of the window. If a numeric argument is supplied that many lines are scrolled; if the argument is negative the screen is scrolled down instead. _1_6._1_8_4. _s_e_a_r_c_h-_e_x_i_t-_c_h_a_r (_v_a_r_i_a_b_l_e) Set this to the character you want to use to exit incremental search. The default is Newline, which makes i-search compatible with normal string search. _1_6._1_8_5. _s_e_a_r_c_h-_f_o_r_w_a_r_d (_C-_S) This searches forward for a specified search string and positions point at the end of the string if it's found. If the string is not found point remains unchanged. This searches from point to the end of the buffer, so any matches before point will be missed. September 2, 1987 - 66 - _1_6._1_8_6. _s_e_a_r_c_h-_r_e_v_e_r_s_e (_C-_R) This searches backward for a specified search string and posi- tions point at the beginning if the string if it's found. If the string is not found point remains unchanged. This searches from point to the beginning of the buffer, so any matches after point will be missed. _1_6._1_8_7. _s_e_l_e_c_t-_b_u_f_f_e_r (_C-_X _B) This selects a new or already existing buffer making it the current one. You can type either the buffer name or number. If you type in the name you need only type the name until it is unambiguous, at which point typing Escape or Space will complete it for you. If you want to create a new buffer you can type Return instead of Space, and a new empty buffer will be created. _1_6._1_8_8. _s_e_l_f-_i_n_s_e_r_t (_M_o_s_t _P_r_i_n_t_i_n_g _C_h_a_r_a_c_t_e_r_s) This inserts the character that invoked it into the buffer at point. Initially all but a few of the printing characters are bound to _s_e_l_f-_i_n_s_e_r_t. _1_6._1_8_9. _s_e_n_d-_t_y_p_e_o_u_t-_t_o-_b_u_f_f_e_r (_v_a_r_i_a_b_l_e) When this is set JOVE will send output that normally overwrites the screen (temporarily) to a buffer instead. This affects com- mands like _l_i_s_t-_b_u_f_f_e_r_s, _l_i_s_t-_p_r_o_c_e_s_s_e_s, and other commands that use command completion. The default value is "off". _1_6._1_9_0. _s_e_t (_N_o_t _B_o_u_n_d) This gives a specified variable a new value. Occasionally you'll see lines like "set this variable to that value to do this". Well, you use the _s_e_t command to do that. _1_6._1_9_1. _s_e_t-_m_a_r_k (_C-@) This sets the mark at the current position in the buffer. It prints the message "Point pushed" on the message line. It says that instead of "Mark set" because when you set the mark the pre- vious mark is still remembered on a ring of 16 marks. So "Point pushed" means point is pushed onto the ring of marks and becomes the value of "the mark". To go through the ring of marks you type "C-U C-@", or execute the _p_o_p-_m_a_r_k command. If you type this enough times you will get back to where you started. _1_6._1_9_2. _s_h_e_l_l (_v_a_r_i_a_b_l_e) The shell to be used with all the shell commands command. If your SHELL environment variable is set, it is used as the value of _s_h_e_l_l; otherwise "/bin/csh" is the default. September 2, 1987 - 67 - _1_6._1_9_3. _s_h_e_l_l-_c_o_m_m_a_n_d (_C-_X !) This runs a UNIX command and places the output from that command in a buffer. JOVE creates a buffer that matches the name of the command you specify and then attaches that buffer to a window. So, when you have only one window running this command will cause JOVE to split the window and attach the new buffer to that win- dow. Otherwise, JOVE finds the most convenient of the available windows and uses that one instead. If the buffer already exists it is first emptied, except that if it's holding a file, not some output from a previous command, JOVE prints an error message and refuses to execute the command. If you really want to execute the command you should delete that buffer (saving it first, if you like) or use _s_h_e_l_l-_c_o_m_m_a_n_d-_t_o-_b_u_f_f_e_r, and try again. _1_6._1_9_4. _s_h_e_l_l-_c_o_m_m_a_n_d-_t_o-_b_u_f_f_e_r (_N_o_t _B_o_u_n_d) This is just like _s_h_e_l_l-_c_o_m_m_a_n_d except it lets you specify the buffer to use instead of JOVE. _1_6._1_9_5. _s_h_e_l_l-_f_l_a_g_s (_v_a_r_i_a_b_l_e) This defines the flags that are passed to shell commands. The default is "-c". See the _s_h_e_l_l variable to change the default shell. _1_6._1_9_6. _s_h_o_w-_m_a_t_c_h-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns on Show Match mode (or off if it's currently on) in the selected buffer. This changes "}" and ")" so that when they are typed the are inserted as usual, and then the cursor flashes back to the matching "{" or "(" (depending on what was typed) for about half a second, and then goes back to just after the "}" or ")" that invoked the command. This is useful for typing in com- plicated expressions in a program. You can change how long the cursor sits on the matching paren by setting the "paren-flash- delay" variable in tenths of a second. If the matching "{" or "(" isn't visible nothing happens. _1_6._1_9_7. _s_h_r_i_n_k-_w_i_n_d_o_w (_N_o_t _B_o_u_n_d) This makes the current window one line shorter, if possible. Windows must be at least 2 lines high, one for the text and the other for the mode line. _1_6._1_9_8. _s_o_u_r_c_e (_N_o_t _B_o_u_n_d) This reads a bunch of JOVE commands from a file. The format of the file is the same as that in your initialization file (your ".joverc") in your main directory. There should be one command per line and it should be as though you typed "ESC X" while in JOVE. For example, here's part of my initialization file: September 2, 1987 - 68 - bind-to-key i-search-reverse ^R bind-to-key i-search-forward ^S bind-to-key pause-jove ^[S What they do is make "C-R" call the _i-_s_e_a_r_c_h-_r_e_v_e_r_s_e command and "C-S" call _i-_s_e_a_r_c_h-_f_o_r_w_a_r_d and "ESC S" call _p_a_u_s_e-_j_o_v_e. _1_6._1_9_9. _s_p_e_l_l-_b_u_f_f_e_r (_N_o_t _B_o_u_n_d) This runs the current buffer through the UNIX _s_p_e_l_l program and places the output in buffer "Spell". Then JOVE lets you edit the list of words, expecting you to delete the ones that you don't care about, i.e., the ones you know are spelled correctly. Then the _p_a_r_s_e-_s_p_e_l_l_i_n_g-_e_r_r_o_r_s-_i_n-_b_u_f_f_e_r command comes along and finds all the misspelled words and sets things up so the error commands work. _1_6._2_0_0. _s_p_l_i_t-_c_u_r_r_e_n_t-_w_i_n_d_o_w (_C-_X _2) This splits the current window into two equal parts (providing the resulting windows would be big enough) and displays the selected buffer in both windows. Use "C-X 1" to go back to 1 window mode. _1_6._2_0_1. _s_t_a_r_t-_r_e_m_e_m_b_e_r_i_n_g (_C-_X () This starts remembering your key strokes in the Keyboard macro. To stop remembering you type "C-X )". Because of a bug in JOVE you can't stop remembering by typing "ESC X stop-remembering"; _s_t_o_p-_r_e_m_e_m_b_e_r_i_n_g must be bound to "C-X )" in order to make things work correctly. To execute the remembered key strokes you type "C-X E" which runs the _e_x_e_c_u_t_e-_k_e_y_b_o_a_r_d-_m_a_c_r_o command. Sometimes you may want a macro to accept different input each time it runs. To see how to do this, see the _m_a_k_e-_m_a_c_r_o-_i_n_t_e_r_a_c_t_i_v_e command. _1_6._2_0_2. _s_t_o_p-_p_r_o_c_e_s_s (_N_o_t _B_o_u_n_d) This sends a stop signal (C-Z, for most people) to the current process. It only works if you have the interactive process feature, and you are in a buffer attached to a process. _1_6._2_0_3. _s_t_o_p-_r_e_m_e_m_b_e_r_i_n_g (_C-_X )) This stop the definition of the keyboard macro. Because of a bug in JOVE, this must be bound to "C-X )". Anything else will not work properly. _1_6._2_0_4. _s_t_r_i_n_g-_l_e_n_g_t_h (_N_o_t _B_o_u_n_d) This prints the number of characters in the string that point sits in. Strings are surrounded by double quotes. JOVE knows that "\007" is considered a single character, namely "C-G", and also knows about other common ones, like "\r" (Return) and "\n" September 2, 1987 - 69 - (LineFeed). This is mostly useful only for C programmers. _1_6._2_0_5. _s_u_s_p_e_n_d-_j_o_v_e (_E_S_C _S) This is a synonym for _p_a_u_s_e-_j_o_v_e. _1_6._2_0_6. _s_y_n_c-_f_r_e_q_u_e_n_c_y (_v_a_r_i_a_b_l_e) The temporary files used by JOVE are forced out to disk every _s_y_n_c-_f_r_e_q_u_e_n_c_y modifications. The default is 50, which really makes good sense. Unless your system is very unstable, you prob- ably shouldn't fool with this. _1_6._2_0_7. _t_a_g-_f_i_l_e (_v_a_r_i_a_b_l_e) This the name of the file in which JOVE should look up tag defin- itions. The default value is "./tags". _1_6._2_0_8. _t_e_x_t-_m_o_d_e (_N_o_t _B_o_u_n_d) This sets the major mode to Text. Currently the other modes are Fundamental, C and Lisp mode. _1_6._2_0_9. _t_r_a_n_s_p_o_s_e-_c_h_a_r_a_c_t_e_r_s (_C-_T) This switches the character before point with the one after point, and then moves forward one. This doesn't work at the beginning of the line, and at the end of the line it switches the two characters before point. Since point is moved forward, so that the character that was before point is still before point, you can use "C-T" to drag a character down the length of a line. This command pretty quickly becomes very useful. _1_6._2_1_0. _t_r_a_n_s_p_o_s_e-_l_i_n_e_s (_C-_X _C-_T) This switches the current line with the one above it, and then moves down one so that the line that was above point is still above point. This, like _t_r_a_n_s_p_o_s_e-_c_h_a_r_a_c_t_e_r_s, can be used to drag a line down a page. _1_6._2_1_1. _u_n_b_i_n_d-_k_e_y (_N_o_t _B_o_u_n_d) Use this to unbind _a_n_y key sequence. You can use this to unbind even a prefix command, since this command does not use "key-map completion". For example, "ESC X unbind-key ESC [" unbinds the sequence "ESC [". This is useful for "turning off" something set in the system-wide ".joverc" file. _1_6._2_1_2. _u_p_d_a_t_e-_t_i_m_e-_f_r_e_q_u_e_n_c_y (_v_a_r_i_a_b_l_e) How often the mode line is updated (and thus the time and load average, if you display them). The default is 30 seconds. September 2, 1987 - 70 - _1_6._2_1_3. _u_s_e-_i/_d-_c_h_a_r (_v_a_r_i_a_b_l_e) If your terminal has insert/delete character capability you can tell JOVE not to use it by setting this to "off". In my opinion it is only worth using insert/delete character at low baud rates. WARNING: if you set this to "on" when your terminal doesn't have insert/delete character capability, you will get weird (perhaps fatal) results. _1_6._2_1_4. _v_e_r_s_i_o_n (_N_o_t _B_o_u_n_d) Displays the version number of this JOVE. _1_6._2_1_5. _v_i_s_i_b_l_e-_b_e_l_l (_v_a_r_i_a_b_l_e) Use the terminal's visible bell instead of beeping. This is set automatically if your terminal has the capability. _1_6._2_1_6. _v_i_s_i_b_l_e-_s_p_a_c_e_s-_i_n-_w_i_n_d_o_w (_N_o_t _B_o_u_n_d) This displays an underscore character instead of each space in the window and displays a greater-than followed by spaces for each tab in the window. The actual text in the buffer is not changed; only the screen display is affected. To turn this off you run the command again; it toggles. _1_6._2_1_7. _v_i_s_i_t-_f_i_l_e (_C-_X _C-_V) This reads a specified file into the current buffer replacing the old text. If the buffer needs saving JOVE will offer to save it for you. Sometimes you use this to start over, say if you make lots of changes and then change your mind. If that's the case you don't want JOVE to save your buffer and you answer "NO" to the question. _1_6._2_1_8. _w_i_n_d_o_w-_f_i_n_d (_C-_X _4) This lets you select another buffer in another window three dif- ferent ways. This waits for another character which can be one of the following: T Finds a tag in the other window. F Finds a file in the other window. B Selects a buffer in the other window. This is just a convenient short hand for "C-X 2" (or "C-X O" if there are already two windows) followed by the appropriate sequence for invoking each command. With this, though, there isn't the extra overhead of having to redisplay. In addition, you don't have to decide whether to type "C-X 2" or "C-X O" since "C-X 4" does the right thing. September 2, 1987 - 71 - _1_6._2_1_9. _w_o_r_d-_a_b_b_r_e_v-_m_o_d_e (_N_o_t _B_o_u_n_d) This turns on Word Abbrev mode (or off if it's currently on) in the selected buffer. Word Abbrev mode lets you specify a word (an abbreviation) and a phrase with which JOVE should substitute the abbreviation. You can use this to define words to expand into long phrases, e.g., "jove" can expand into "Jonathan's Own Version of Emacs"; another common use is defining words that you often misspell in the same way, e.g., "thier" => "their" or "teh" => "the". See the information on the _a_u_t_o-_c_a_s_e-_a_b_b_r_e_v variable. There are two kinds of abbreviations: mode specific and global. If you define a Mode specific abbreviation in C mode, it will expand only in buffers that are in C mode. This is so you can have the same abbreviation expand to different things depending on your context. Global abbreviations expand regardless of the major mode of the buffer. The way it works is this: JOVE looks first in the mode specific table, and then in the global table. Whichever it finds it in first is the one that's used in the expansion. If it doesn't find the word it is left untouched. JOVE tries to expand words as they are typed, when you type a punctuation character or Space or Return. If you are in Auto Fill mode the expansion will be filled as if you typed it your- self. _1_6._2_2_0. _w_r_a_p-_s_e_a_r_c_h (_v_a_r_i_a_b_l_e) If set, searches will "wrap around" the ends of the buffer instead of stopping at the bottom or top. The default is "off". _1_6._2_2_1. _w_r_i_t_e-_f_i_l_e_s-_o_n-_m_a_k_e (_v_a_r_i_a_b_l_e) When set, all modified files will be written out before calling make when the _c_o_m_p_i_l_e-_i_t command is executed. The default is "on". _1_6._2_2_2. _w_r_i_t_e-_w_o_r_d-_a_b_b_r_e_v-_f_i_l_e (_N_o_t _B_o_u_n_d) This writes the currently defined abbreviations to a specified file. They can be read back in and automatically defined with _r_e_a_d-_w_o_r_d-_a_b_b_r_e_v-_f_i_l_e. _1_6._2_2_3. _w_r_i_t_e-_f_i_l_e (_C-_X _C-_W) This saves the current buffer to a specified file, and then makes that file the default file name for this buffer. If you specify a file that already exists you are asked to confirm over-writing it. _1_6._2_2_4. _w_r_i_t_e-_m_a_c_r_o_s-_t_o-_f_i_l_e (_N_o_t _B_o_u_n_d) This writes the currently defined macros to a specified file. The macros can be read back in with _r_e_a_d-_m_a_c_r_o_s-_f_r_o_m-_f_i_l_e so you can define macros and still use them in other instantiations of September 2, 1987 - 72 - JOVE. _1_6._2_2_5. _w_r_i_t_e-_m_o_d_i_f_i_e_d-_f_i_l_e_s (_C-_X _C-_M) This saves all the buffers that need saving. If you supply a numeric argument it asks for each buffer whether you really want to save it. _1_6._2_2_6. _w_r_i_t_e-_r_e_g_i_o_n (_N_o_t _B_o_u_n_d) This writes the text in the region to a specified file. If the file already exists you are asked to confirm over-writing it. _1_6._2_2_7. _y_a_n_k (_C-_Y) This undoes the last kill command. That is, it inserts the killed text at point. When you do multiple kill commands in a row, they are merged so that yanking them back with "C-Y" yanks back all of them. _1_6._2_2_8. _y_a_n_k-_p_o_p (_E_S_C _Y) This yanks back previous killed text. JOVE has a kill ring on which the last 10 kills are stored. _Y_a_n_k yanks a copy of the text at the front of the ring. If you want one of the last ten kills you use "ESC Y" which rotates the ring so another different entry is now at the front. You can use "ESC Y" only immediately following a "C-Y" or another "ESC Y". If you supply a negative numeric argument the ring is rotated the other way. If you use this command enough times in a row you will eventually get back to where you started. Experiment with this. It's extremely use- ful. September 2, 1987