![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jove.nr CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc|
Return to jove.nr CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove / doc |
1.1 ! root 1: .hy 0 ! 2: .TH JOVE 1 "12 February 1986" ! 3: .ad ! 4: .SH NAME ! 5: jove - an interactive display-oriented text editor ! 6: .SH SYNOPSIS ! 7: .nf ! 8: jove [-d directory] [-w] [-t tag] [+[n] file] [-p file] [files] ! 9: jove -r ! 10: .fi ! 11: .SH DESCRIPTION ! 12: JOVE is Jonathan's Own Version of Emacs. It is based on the original EMACS ! 13: editor written at MIT by Richard Stallman. Although JOVE is meant to be ! 14: compatible with EMACS, there are some major differences between the two ! 15: editors and you shouldn't rely on their behaving identically. ! 16: .LP ! 17: JOVE works on any reasonable display terminal that is described in the ! 18: .I termcap ! 19: file (see TERMCAP(5) for more details). When you start up JOVE, it checks ! 20: to see whether you have your ! 21: .I TERM ! 22: environment variable set. On most systems that will automatically be set up ! 23: for you, but if it's not JOVE will ask you what kind of terminal you are ! 24: using. To avoid having to type this every time you run JOVE you can set your ! 25: .I TERM ! 26: environment variable yourself. How you do this depends on which shell you ! 27: are running. If you are running the C Shell, as most of you are, you type ! 28: .sp 1 ! 29: % setenv TERM ! 30: .I type ! 31: .sp 1 ! 32: and with the Bourne Shell, you type ! 33: .sp 1 ! 34: $ TERM= ! 35: .I type ! 36: ; export TERM ! 37: .sp 1 ! 38: where ! 39: .I type ! 40: is the name of the kind of terminal you are using (e.g., vt100). If ! 41: neither of these works get somebody to help you. ! 42: .SH INVOKING JOVE ! 43: If you run JOVE with no arguments you will be placed in an empty buffer, ! 44: called ! 45: .I Main. ! 46: Otherwise, any arguments you supply are considered file names and each is ! 47: "given" its own buffer. Only the first file is actually read in--reading ! 48: other files is deferred until you actually try to use the buffers they are ! 49: attached to. This is for efficiency's sake: most of the time, when you run ! 50: JOVE on a big list of files, you end up editing only a few of them. ! 51: .LP ! 52: The names of all of the files specified on the command line are saved in a ! 53: buffer, called ! 54: .I *minibuf*. ! 55: The mini-buffer is a special JOVE buffer that is used when JOVE is prompting ! 56: for some input to many commands (for example, when JOVE is prompting for a ! 57: file name). When you are being prompted for a file name, you can type C-N ! 58: (that's Control-N) and C-P to cycle through the list of files that were ! 59: specified on the command line. The file name will be inserted where you are ! 60: typing and then you can edit it as if you typed it in yourself. ! 61: .LP ! 62: JOVE recognizes the following switches: ! 63: .TP ! 64: .I -d ! 65: The following argument is taken to be the name of the current directory. ! 66: This is for systems that don't have a version of C shell that automatically ! 67: maintains the ! 68: .I CWD ! 69: environment variable. If ! 70: .I -d ! 71: is not specified on a system without a modified C shell, JOVE will have to ! 72: figure out the current directory itself, and that can be VERY slow. You ! 73: can simulate the modified C shell by putting the following lines in your ! 74: C shell initialization file (.cshrc): ! 75: .nf ! 76: .sp 1 ! 77: alias cd 'cd \e!*; setenv CWD $cwd' ! 78: alias popd 'popd \e!*; setenv CWD $cwd' ! 79: alias pushd 'pushd \e!*; setenv CWD $cwd' ! 80: .fi ! 81: .TP ! 82: .I +n ! 83: Reads the file, designated by the following argument, and positions point at ! 84: the ! 85: .I n'th ! 86: line instead of the (default) 1'st line. This can be specified more than ! 87: once but it doesn't make sense to use it twice on the same file; in that ! 88: case the second one wins. If no numeric argument is given after the +, ! 89: the point is positioned at the end of the file. ! 90: .TP ! 91: .I -p ! 92: Parses the error messages in the file designated by the following argument. ! 93: The error messages are assumed to be in a format similar to the C compiler, ! 94: LINT, or GREP output. ! 95: .TP ! 96: .I -t ! 97: Runs the ! 98: .I find-tag ! 99: command on the string of characters immediately following ! 100: the -t if there is one (as in -tTagname), or on ! 101: the following argument (as in -t Tagname) otherwise (see ctags(1)). ! 102: .TP ! 103: .I -w ! 104: Divides the window in two. When this happens, either the same file is ! 105: displayed in both windows, or the second file in the list is read in and ! 106: displayed in its window. ! 107: .SH "RECOVERING BUFFERS AFTER A CRASH" ! 108: The ! 109: .I -r ! 110: option of jove runs the JOVE recover program. Use this when the system ! 111: crashes, or JOVE crashes, or you accidently get logged out while in JOVE. ! 112: If there are any buffers to be recovered, this will find them. ! 113: .LP ! 114: Recover looks for JOVE buffers that are left around and are ! 115: owned by you. (You cannot recover other peoples' buffers, obviously.) ! 116: If there were no buffers that were modified at the time of the ! 117: crash or there were but recover can't get its hands on them, you will be ! 118: informed with the message, "There is nothing to recover." Otherwise, ! 119: recover prints the date and time of the version of the buffers it has, ! 120: and then waits for you type a command. ! 121: .LP ! 122: To get a list of the buffers recover knows about, use the ! 123: .I list ! 124: command. This will list all the buffers and the files and the number of ! 125: lines associated with them. Next to each buffer is a number. When you want ! 126: to recover a buffer, use the ! 127: .I get ! 128: command. The syntax is ! 129: .I get buffer filename ! 130: where ! 131: .I buffer ! 132: is either the buffer's name or the number at the beginning of the line. If ! 133: you don't type the buffer name or the filename, recover will prompt you ! 134: for them. ! 135: .LP ! 136: If there are a lot of buffers and you want to recover all of them, use the ! 137: .I recover ! 138: command. This will recover each buffer to the name of the buffer with ".#" ! 139: prepended to the name (so that the original isn't over-written). It asks ! 140: for each file and if you want to restore that buffer to that name you type ! 141: "yes". If you want to recover the file but to a different name, just type ! 142: the new name in. If you type "no" recover will skip that file and go on ! 143: to the next one. ! 144: .LP ! 145: If you want to look at a buffer before deciding to recover it, use the ! 146: .I print ! 147: command. The syntax for this is ! 148: .I print buffer ! 149: where ! 150: .I buffer ! 151: again is either its name or the number. You can type ^C if you want to ! 152: abort printing the file to the terminal, and recover will respond with ! 153: an appropriate message. ! 154: .LP ! 155: When you're done and have all the buffers you want, type the ! 156: .I quit ! 157: command to leave. You will then be asked whether it's okay to delete the ! 158: tmp files. Most of the time that's okay and you should type "yes". When ! 159: you say that, JOVE removes all traces of those buffers and you won't be able ! 160: to look at them again. (If you recovered some buffers they will still be ! 161: around, so don't worry.) So, if you're not sure whether you've gotten all ! 162: the buffers, you should answer "no" so that you'll be able to run ! 163: recover again at a later time (presumably after you've figured out ! 164: which ones you want to save). ! 165: .LP ! 166: If you type ^C at any time other than when you're printing a file to the ! 167: terminal, recover will exit without a word. If you do this but wish you ! 168: hadn't, just type "jove -r" to the shell again, and you will be put back ! 169: with no loss. ! 170: .SH GETTING HELP ! 171: Once in JOVE, there are several commands available to get help. To execute ! 172: any JOVE command, you type "<ESC> X command-name" followed by <Return>. To ! 173: get a list of all the JOVE commands you type "<ESC> X" followed by "?". The ! 174: .I describe-bindings ! 175: command can be used to get a list containing each key, and its associated ! 176: command (that is, the command that gets executed when you type that key). ! 177: If you want to save the list of bindings, you can set the jove variable ! 178: .I send-typeout-to-buffer ! 179: to ON (using the ! 180: .I set ! 181: command), and then execute the ! 182: .I describe-bindings ! 183: command. This will create a buffer and put in it the bindings list it ! 184: normally would have printed on the screen. Then you can save that buffer to ! 185: a file and print it to use as a quick reference card. (See VARIABLES below.) ! 186: .LP ! 187: Once you know the name of a command, you can find out what it does with the ! 188: .I describe-command ! 189: command, which you can invoke quickly by typing "ESC ?". The ! 190: .I apropos ! 191: command will give you a list of all the command with a specific string in ! 192: their names. For example, if you want to know the names of all the ! 193: commands that are concerned with windows, you can run "apropos" with the ! 194: keyword ! 195: .I window. ! 196: .LP ! 197: If you're not familar with the EMACS command set, it would be worth your ! 198: while to use run TEACHJOVE. Do do that, just type "teachjove" to your shell ! 199: and you will be placed in JOVE in a file which contains directions. I highly ! 200: recommend this for beginners; you may save yourself a lot of time and ! 201: headaches. ! 202: .SH KEY BINDINGS and VARIABLES ! 203: You can alter the key bindings in JOVE to fit your personal tastes. That ! 204: is, you can change what a key does every time you strike it. For example, ! 205: by default the C-N key is bound to the command ! 206: .I next-line ! 207: and so when you type it you move down a line. If you want to change a ! 208: binding or add a new one, you use the ! 209: .I bind-to-key ! 210: command. The syntax is "bind-to-key <command> key". ! 211: .LP ! 212: You can also change the way JOVE behaves in little ways by changing the ! 213: value of some variables with the ! 214: .I set ! 215: command. The syntax is "set <variable> value", where value is a number or a ! 216: string, or "on" or "off", depending on the context. For example, if you ! 217: want JOVE to make backup files, you set the "make-backup-files" variable to ! 218: "on". To see the value of a variable, use the "print <variable>" command. ! 219: .SH INITIALIZATION ! 220: JOVE automatically reads commands from an initialization file in your HOME ! 221: directory, called ".joverc". In this file you can place commands that you ! 222: would normally type in JOVE. If you like to rearrange the key bindings and ! 223: set some variables every time you get into JOVE, you should put them in your ! 224: initialization file. Here are a few lines from mine: ! 225: .nf ! 226: set match-regular-expressions on ! 227: auto-execute-command auto-fill /tmp/Re\e|.*drft ! 228: bind-to-key i-search-forward ^\e ! 229: bind-to-key i-search-reverse ^R ! 230: bind-to-key find-tag-at-point ^[^T ! 231: bind-to-key scroll-down ^C ! 232: bind-to-key grow-window ^Xg ! 233: bind-to-key shrink-window ^Xs ! 234: .fi ! 235: (Note that the Control Characters can be either two character sequences ! 236: (e.g. ^ and C together as ^C) or the actual control character. If you want ! 237: to use an ^ by itself you must BackSlash it (e.g., bind-to-key grow-window ! 238: ^X\e^ binds grow-window to "^X^"). ! 239: .SH SOME MINOR DETAILS ! 240: You should type C-\e instead of C-S in many instances. For example, the way ! 241: to search for a string is documented as being "C-S" but in reality you ! 242: should type "C-\e". This is because C-S is the XOFF character (what gets ! 243: sent when you type the NO SCROLL key), and clearly that won't work. The XON ! 244: character is "C-Q" (what gets sent when you type NO SCROLL again) which is ! 245: documented as the way to do a quoted-insert. The alternate key for this is ! 246: "C-^" (typed as "C-`" on vt100's and its look-alikes). If you want to ! 247: enable C-S and C-Q and you know what you are doing, you can put the line: ! 248: .nf ! 249: set allow-^S-and-^Q on ! 250: .fi ! 251: in your initialization file. ! 252: .LP ! 253: If your terminal has a metakey, JOVE will use it if you turn on the ! 254: "meta-key" variable. JOVE will automatically turn on "meta-key" if the ! 255: METAKEY environment variable exists. This is useful for if you have ! 256: different terminals (e.g., one at home and one at work) and one has a ! 257: metakey and the other doesn't. ! 258: .SH FILES ! 259: LIBDIR/.joverc - system wide initialization file ! 260: .sp 0 ! 261: ~/.joverc - personal initialization file ! 262: .sp 0 ! 263: TMPDIR - where temporary files are stored ! 264: .sp 0 ! 265: LIBDIR/teach-jove - the interactive tutorial ! 266: .sp 0 ! 267: LIBDIR/portsrv - for running shells in windows (pdp11 only) ! 268: .SH SEE ALSO ! 269: .nf ! 270: ed(1) - for a description of regular expressions ! 271: .sp 0 ! 272: teachjove(1) - for an interactive JOVE tutorial. ! 273: .fi ! 274: .SH DIAGNOSTICS ! 275: JOVE diagnostics are meant to be self-explanatory, but you are advised ! 276: to seek help whenever you are confused. You can easily lose a lot of ! 277: work if you don't know EXACTLY what you are doing. ! 278: .SH BUGS ! 279: Lines can't be more than 1024 characters long. ! 280: .sp 1 ! 281: Searches can't cross line boundaries. ! 282: .SH AUTHOR ! 283: Jonathan Payne
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.