![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to jove.3 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 17.jove|
Return to jove.3 CVS log | Up to [CSRG BSD Unix] / 43BSDReno / share / doc / usd / 17.jove |
1.1 root 1: .\" @(#)jove.3 6.1 (Berkeley) 5/30/86
2: .\"
3: .NH 1
4: Directory Handling
5: .XS \n(PN
6: \*(SN Directory Handling
7: .XE
8: .LP
9: To save having to use absolute pathnames when you want to edit a nearby file
10: \s-2JOVE\s0 allows you to move around the
11: .UX
12: filesystem just as the c-shell does.
13: These commands are:
14: .IP "cd dir" 15n
15: Change to the specified directory.
16: .IP "pushd [dir]"
17: Like \fIcd\fP, but save the old directory on the directory stack.
18: With no directory argument, simply exchange the top two directories
19: on the stack and \fIcd\fP to the new top.
20: .IP "popd"
21: Take the current directory off the stack and \fIcd\fP to the directory now
22: at the top.
23: .IP "dirs"
24: Display the contents of the directory stack.
25: .LP
26: The names and behavior of these commands were chosen to mimic those in the c-shell.
27: .NH 1
28: Editing C Programs
29: .XS \n(PN
30: \*(SN Editing C Programs
31: .XE
32: .LP
33: This section details the support provided by \s-2JOVE\s0
34: for working on C programs.
35: .NH 2
36: Indentation Commands
37: .XS \n(PN 5n
38: \*(SN Indentation Commands
39: .XE
40: .LP
41: To save having to lay out C programs "by hand", \s-2JOVE\s0
42: has an idea of the correct indentation of a line,
43: based on the surrounding context.
44: When you are in C Mode, \s-2JOVE\s0 treats tabs specially \(em
45: typing a tab at the beginning of a new line means "indent to
46: the right place".
47: Closing braces are also handled specially, and are indented
48: to match the corresponding open brace.
49: .NH 2
50: Parenthesis and Brace Matching
51: .XS \n(PN 5n
52: \*(SN Parenthesis and Brace Matching
53: .XE
54: .LP
55: To check that parentheses and braces match the way you think they do,
56: turn on \fIShow Match\fP mode (ESC X show-match-mode). Then, whenever
57: you type a close brace or parenthesis, the cursor moves momentarily to
58: the matching opener, if it's currently visible. If it's not visible,
59: \s-2JOVE\s0 displays the line containing the matching opener on the message
60: line.
61: .NH 2
62: C Tags
63: .XS \n(PN 5n
64: \*(SN C Tags
65: .XE
66: .LP
67: Often when you are editing a C program,
68: especially someone else's code,
69: you see a function call and wonder what that function does.
70: You then search for the function within the current file and if you're
71: lucky find
72: the definition, finally returning to the original spot when you are done.
73: However, if are unlucky, the function turns out to be external
74: (defined in another file) and
75: you have to suspend the edit,
76: \fIgrep\fP for the function name in every .c that might contain it,
77: and finally visit the appropriate file.
78: .LP
79: To avoid this diversion or the need to remember which
80: function is defined in which file,
81: Berkeley
82: .UX
83: has a program called \fIctags(1)\fP, which
84: takes a set of source files and looks for function
85: definitions, producing a file called \fItags\fP as its output.
86: .LP
87: \s-2JOVE\s0 has a command called C-X T (\fIfind-tag\fP)
88: that prompts you for the name of a function (a \fItag\fP), looks up
89: the tag reference in the previously constructed tags file,
90: then visits the file containing that tag in a new buffer,
91: with point positioned at the definition of the function.
92: There is another version of this command, namely \fIfind-tag-at-point\fP,
93: that uses the identifier at
94: .I point.
95: .LP
96: So, when you've added new functions to a module, or moved some old
97: ones around, run the \fIctags\fP program to regenerate the \fItags\fP file.
98: \s-2JOVE\s0 looks in the file specified in the \fItag-file\fP variable. The
99: default is "./tags", that is, the tag file in the current directory. If you
100: wish to use an alternate tag file, you use C-U\ C-X\ T, and \s-2JOVE\s0 will
101: prompt for a file name. If you find yourself specifying the same file again
102: and again, you can set \fItag-file\fP to that file, and run
103: \fIfind-tag\fP with no numeric argument.
104: .LP
105: To begin an editing session looking for a particular tag, use
106: the \fI\-t tag\fP command line option to \s-2JOVE\s0.
107: For example, say you wanted to look at the file containing the tag
108: \fISkipChar\fP, you would invoke \s-2JOVE\s0 as:
109: .DS I
110: .I
111: % jove \-t SkipChar
112: .R
113: .DE
114: .NH 2
115: Compiling Your Program
116: .XS \n(PN 5n
117: \*(SN Compiling Your Program
118: .XE
119: .LP
120: You've typed in a program or altered an existing one and now you
121: want to run it through the compiler to check for errors.
122: To save having to suspend the edit,
123: run the compiler,
124: scribble down error messages, and then resume the edit,
125: \s-2JOVE\s0 allows you to compile your code while in the editor.
126: This is done with the C-X C-E (\fIcompile-it\fP) command.
127: If you run \fIcompile-it\fP with no argument
128: it runs the
129: .UX
130: \fImake\fP
131: program into a buffer;
132: If you need a special command or want to pass arguments to \fImake\fP,
133: run \fIcompile-it\fP with any argument (C-U is good enough) and you
134: will be prompted for the command to execute.
135: .LP
136: If any error messages are produced, they are treated specially by \s-2JOVE\s0.
137: That treatment is the subject of the next section.
138: .NH 2
139: Error Message Parsing and Spelling Checking
140: .XS \n(PN
141: \*(SN Error Message Parsing
142: \*(SN Spelling Checking
143: .XE
144: .LP
145: \s-2JOVE\s0 knows how to interpret the error messages from many
146: .UX
147: commands;
148: In particular,
149: the messages from \fIcc\fP,
150: \fIgrep\fP and \fIlint\fP can be understood.
151: After running the \fIcompile-it\fP command,
152: the \fIparse-errors\fP command is automatically executed,
153: and any errors found are displayed in a new buffer.
154: The files whose names are found in parsing the error messages are each
155: brought into \s-2JOVE\s0 buffers and the point is positioned at the first error
156: in the first file.
157: The commands \fIcurrent-error\fP, C-X C-N (\fInext-error\fP), and
158: C-X C-P (\fIprevious-error\fP)
159: can be used to traverse the list of errors.
160: .LP
161: If you already have a file called
162: \fIerrs\fP containing, say, c compiler messages then you can get \s-2JOVE\s0 to interpret the messages by
163: invoking it as:
164: .DS I
165: .I
166: % jove \-p errs
167: .R
168: .DE
169: .LP
170: \s-2JOVE\s0 has a special mechanism for checking the the spelling of a document;
171: It runs the
172: .UX
173: spell program into a buffer.
174: You then delete from this buffer all those words that are not spelling
175: errors and then \s-2JOVE\s0 runs the \fIparse-spelling-errors\fP command to
176: yield a list of errors just as in the last section.
177: .NH 1
178: Simple Customization
179: .XS \n(PN
180: \*(SN Simple Customization
181: .XE
182: .LP
183: .NH 2
184: Major Modes
185: .XS \n(PN 5n
186: \*(SN Major Modes
187: .XE
188: .LP
189: To help with editing particular types of file, say a paper or a C program,
190: \s-2JOVE\s0 has several \fImajor modes\fP.
191: These are as follows:
192: .NH 3
193: Text mode
194: .XS \n(PN 10n
195: \*(SN Text mode
196: .XE
197: .LP
198: This is the default major mode. Nothing special is done.
199: .NH 3
200: C mode
201: .XS \n(PN 10n
202: \*(SN C mode
203: .XE
204: .LP
205: This mode affects the behavior of the tab and parentheses characters.
206: Instead of just inserting the tab, \s-2JOVE\s0 determines
207: where the text "ought" to line up for the C language and tabs to that position
208: instead. The same thing happens with the close brace and close parenthesis;
209: they are tabbed to the "right" place and then inserted.
210: Using the \fIauto-execute-command\fP command, you can make \s-2JOVE\s0 enter
211: \fIC Mode\fP whenever you edit a file whose name ends in \fI.c\fP.
212: .NH 3
213: Lisp mode
214: .XS \n(PN 10n
215: \*(SN Lisp mode
216: .XE
217: .LP
218: This mode is analogous to \fIC Mode\fP,
219: but performs the indentation needed to lay out Lisp programs properly.
220: Note also the \fIgrind-s-expr\fP command that prettyprints an
221: \fIs-expression\fP and the \fIkill-mode-expression\fP command.
222: .NH 2
223: Minor Modes
224: .XS \n(PN 5n
225: \*(SN Minor Modes
226: .XE
227: .LP
228: In addition to the major modes,
229: \s-2JOVE\s0 has a set of minor modes.
230: These are as follows:
231: .NH 3
232: Auto Indent
233: .XS \n(PN 10n
234: \*(SN Auto Indent
235: .XE
236: .LP
237: In this mode,
238: \s-2JOVE\s0 indents each line the same way as that above it. That is,
239: the Return key in this mode acts as the Linefeed key ordinarily does.
240: .NH 3
241: Show Match
242: .XS \n(PN 10n
243: \*(SN Show Match
244: .XE
245: .LP
246: Move the cursor momentarily to the matching opening parenthesis when a closing
247: parenthesis is typed.
248: .NH 3
249: Auto Fill
250: .XS \n(PN 10n
251: \*(SN Auto Fill
252: .XE
253: .LP
254: In \fIAuto Fill\fP mode,
255: a newline is automatically inserted when the line length
256: exceeds the right margin.
257: This way,
258: you can type a whole paper without having to use the Return key.
259: .NH 3
260: Over Write
261: .XS \n(PN 10n
262: \*(SN Over Write
263: .XE
264: .LP
265: In this mode,
266: any text typed in will replace the previous contents.
267: (The default is for new text to be inserted and "push" the old along.)
268: This is useful for editing an already-formatted diagram in which you
269: want to change some things without moving other things around on the
270: screen.
271: .NH 3
272: Word Abbrev
273: .XS \n(PN 10n
274: \*(SN Word Abbrev
275: .XE
276: .LP
277: In this mode, every word you type is compared to a list of word
278: abbreviations; whenever you type an abbreviation, it is replaced
279: by the text that it abbreviates.
280: This can save typing if a particular word or phrase must be entered
281: many times.
282: The abbreviations and their expansions are held in a file that looks like:
283: .DS I
284: abbrev:phrase
285: .DE
286: This file can be set up in your \fI~/.\|joverc\fP with the \fIread-word-abbrev-file\fP command.
287: Then, whenever you are editing a buffer in \fIWord Abbrev\fP mode,
288: \s-2JOVE\s0 checks for the abbreviations you've given.
289: See also the commands
290: \fIread-word-abbrev-file\fP,
291: \fIwrite-word-abbrev-file\fP,
292: \fIedit-word-abbrevs\fP,
293: \fIdefine-global-word-abbrev\fP,
294: \fIdefine-mode-word-abbrev\fP,
295: and \fIbind-macro-to-word-abbrev\fP,
296: and the variable \fIauto-case-abbrev\fP.
297: .NH 2
298: Variables
299: .XS \n(PN 5n
300: \*(SN Variables
301: .XE
302: .LP
303: \s-2JOVE\s0 can be tailored to suit your needs by changing the
304: values of variables.
305: A \s-2JOVE\s0 variable can be given a value with the \fIset\fP command,
306: and its value displayed with the \fIprint\fP command.
307: .LP
308: The variables \s-2JOVE\s0 understands are listed along with the commands
309: in the alphabetical list at the end of this document.
310: .NH 2
311: Key Re-binding
312: .XS \n(PN 5n
313: \*(SN Key Re-binding
314: .XE
315: .LP
316: Many of the commands built into \s-2JOVE\s0 are not bound to
317: specific keys.
318: The command handler in
319: \s-2JOVE\s0 is used to invoke these commands and is activated
320: by the \fIexecute-extended-command\fP command (ESC X).
321: When the name of a command typed in is unambiguous,
322: that command will be executed.
323: Since it is very slow to have
324: to type in the name of each command every time it is needed,
325: \s-2JOVE\s0 makes it possible to \fIbind\fP commands to keys.
326: When a command is
327: \fIbound\fP to a key any future hits on that key will invoke that command.
328: All the printing characters are initially bound to the
329: command \fIself-insert\fP.
330: Thus, typing any printing character causes it to be inserted into the text.
331: Any of the existing commands can be bound to any key.
332: (A \fIkey\fP may actually be a \fIcontrol character\fP
333: or an \fIescape sequence\fP as explained previously under
334: \fICommand Input Conventions\fP).
335: .LP
336: Since there are more commands than there are keys,
337: two keys are treated as \fIprefix\fP commands.
338: When a key bound to one of the prefix commands is typed,
339: the next character
340: typed is interpreted on the basis that it was preceded by one of the
341: prefix keys.
342: Initially ^X and ESC are the prefix keys and
343: many of the built in commands are initially bound to these "two stroke" keys.
344: (For historical reasons, the Escape key is often referred to as "Meta").
345: .NH 2
346: Keyboard Macros
347: .XS \n(PN 5n
348: \*(SN Keyboard Macros
349: .XE
350: .LP
351: Although \s-2JOVE\s0 has many powerful commands,
352: you often find that you have a task that no individual command can do.
353: \s-2JOVE\s0 allows you to define your own commands from sequences
354: of existing ones "by example";
355: Such a sequence is termed a \fImacro\fP.
356: The procedure is as follows:
357: First you type the \fIstart-remembering\fP command,
358: usually bound to C-X (.
359: Next you "perform" the commands which as they are being executed are
360: also
361: remembered, which will constitute the body of the macro.
362: Then you give the \fIstop-remembering\fP command, usually bound to
363: C-X ).
364: You now have a \fIkeyboard macro\fP.
365: To run this command sequence again,
366: use the command \fIexecute-keyboard-macro\fP, usually bound to
367: C-X E.
368: You may find this bothersome to type and re-type,
369: so there is a way to bind the macro to a key.
370: First,
371: you must give the keyboard macro a name using the
372: \fIname-keyboard-macro\fP command.
373: Then the binding is made with the \fIbind-macro-to-key\fP command.
374: We're still not finished because all this hard work will be lost
375: if you leave \s-2JOVE\s0.
376: What you do is to save your macros into a file
377: with the \fIwrite-macros-to-file\fP command.
378: There is a corresponding \fIread-macros-from-file\fP command to retrieve
379: your macros in the next editing session.
380: .NH 2
381: Initialization Files
382: .XS \n(PN 5n
383: \*(SN Initialization Files
384: .XE
385: .LP
386: Users will likely want to modify the default key bindings to their liking.
387: Since it would be quite annoying to have to set up the bindings
388: each time \s-2JOVE\s0 is started up,
389: \s-2JOVE\s0 has the ability to read in a "startup" file.
390: Whenever \s-2JOVE\s0 is started,
391: it reads commands from the file \fI.\|joverc\fP in the user's home directory.
392: These commands are read as
393: if they were typed to the command handler (ESC X) during an edit.
394: There can be only one command per line in the startup file.
395: If there is a file \fI/usr/lib/jove/joverc\fP,
396: then this file will be read before the user's
397: .I .\|joverc
398: file.
399: This can be used to set up a system-wide default startup mode for
400: \s-2JOVE\s0
401: that is tailored to the needs of that system.
402: .LP
403: The \fIsource\fP command can be used to read commands from a specified file
404: at any time during an editing session,
405: even from inside the \fI.\|joverc\fP file.
406: This means that a macro can be used to change the key bindings,
407: e.g., to enter a mode,
408: by reading from a specified file which contains all the necessary bindings.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.