home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 4 / DATAFILE_PDCD4.iso / unix / riscbsd / 1_1_contri / usd / 17_jove / jove_4 < prev   
Encoding:
Text File  |  1986-05-31  |  66.6 KB  |  1,445 lines

  1. .\"    @(#)jove.4    6.1 (Berkeley) 5/30/86
  2. .\"
  3. .bp
  4. .NH 1
  5. Alphabetical List of Commands and Variables
  6. .dc "Prefix-1" "Escape"
  7. This reads the next character and runs a command based on the character
  8. typed.  If you wait for more than a second or so before typing the next
  9. character, the message "ESC" will be printed on the message line to
  10. remind you that \s-2JOVE\s0 is waiting for another character.
  11. .dc "Prefix-2" "C-X"
  12. This reads the next character and runs a command based on the character
  13. typed.  If you wait for more than a second or so before typing another
  14. character, the message "C-X" will be printed on the message line to
  15. remind you that \s-2JOVE\s0 is waiting for another character.
  16. .dc "Prefix-3" "Not Bound"
  17. This reads the next character and runs a command based on the character
  18. typed.  If you wait for more than a second or so before typing the next
  19. character, the character that invoked Prefix-3 will be printed on the
  20. message line to remind you that \s-2JOVE\s0 is waiting for another one.
  21. .dc "allow-^S-and-^Q" "(variable)"
  22. This variable, when set, tells \s-2JOVE\s0 that your terminal does not need
  23. to use the characters C-S and C-Q for flow control, and that it is
  24. okay to bind things to them.  This variable should be set depending
  25. upon what kind of terminal you have.
  26. .dc "allow-bad-filenames" "(variable)"
  27. If set, this variable permits filenames to contain "bad" characters
  28. such as those from the set *&%!"`[]{}.  These files are harder to deal
  29. with, because the characters mean something to the shell.  The default
  30. value is "off".
  31. .dc "append-region" "Not Bound"
  32. This appends the region to a specified file.  If the file does not
  33. already exist it is created.
  34. .dc "apropos" "Not Bound"
  35. This types out all the commands, variables and macros with the specific
  36. keyword in their names.  For each command and macro that contains the
  37. string, the key sequence that can be used to execute the command or macro is
  38. printed; with variables, the current value is printed.  So, to find all the
  39. commands that are related to windows, you type
  40. .DS
  41. ESC X apropos window<Return>
  42. .DE
  43. .dc "auto-case-abbrev" "(variable)"
  44. When this variable is on (the default), word abbreviations are adjusted for
  45. case automatically.  For example, if "jove" were the abbreviation for
  46. "jonathan's own version of emacs", then typing "jove" would give you
  47. "jonathan's own version of emacs", typing "Jove" would give you "Jonathan's
  48. own version of emacs", and typing "JOVE" would give you "Jonathan's Own
  49. Version of Emacs".  When this variable is "off", upper and lower case are
  50. distinguished when looking for the abbreviation, i.e., in the example above,
  51. "JOVE" and "Jove" would not be expanded unless they were defined separately.
  52. .dc "auto-execute-command" "Not Bound"
  53. This tells \s-2JOVE\s0 to execute a command automatically when a file whose
  54. name matches a specified pattern is visited.  The first argument is the
  55. command you want executed and the second is a regular expression
  56. pattern that specifies the files that apply.  For example, if you want
  57. to be in show-match-mode when you edit C source files (that is, files
  58. that end with ".c" or ".h") you can type
  59. .ID
  60. ESC X auto-execute-command show-match-mode .*\.[ch]$
  61. .DE
  62. .dc "auto-execute-macro" "Not Bound"
  63. This is like
  64. .IQ auto-execute-command
  65. except you use it to execute macros
  66. automatically instead of built-in commands.
  67. .dc "auto-fill-mode" "Not Bound"
  68. This turns on Auto Fill mode (or off if it's currently on) in the
  69. selected buffer.  When \s-2JOVE\s0 is in Auto Fill mode it automatically
  70. breaks lines for you when you reach the right margin so you don't have
  71. to remember to hit Return.  \s-2JOVE\s0 uses 78 as the right margin but you
  72. can change that by setting the variable
  73. .IQ right-margin
  74. to another
  75. value.  See the
  76. .IQ set
  77. command to learn how to do this.
  78. .dc "auto-indent-mode" "Not Bound"
  79. This turns on Auto Indent mode (or off if it's currently on) in the
  80. selected buffer.  When \s-2JOVE\s0 is in Auto Indent mode, Return indents the
  81. new line to the same position as the line you were just on.  This is
  82. useful for lining up C code (or any other language (but what else is
  83. there besides C?)).  This is out of date because of the new command
  84. called
  85. .IQ newline-and-indent
  86. but it remains because of several
  87. "requests" on the part of, uh, enthusiastic and excitable users, that
  88. it be left as it is.
  89. .dc "backward-character" "C-B"
  90. This moves point backward over a single character.  If point is at the
  91. beginning of the line it moves to the end of the previous line.
  92. .dc "backward-paragraph" "ESC ["
  93. This moves point backward to the beginning of the current or previous
  94. paragraph.  Paragraphs are bounded by lines that begin with a Period or
  95. Tab, or by blank lines; a change in indentation may also signal a break
  96. between paragraphs, except that \s-2JOVE\s0 allows the first line of a paragraph
  97. to be indented differently from the other lines.
  98. .dc "backward-s-expression" "ESC C-B"
  99. This moves point backward over a s-expression.  It is just like
  100. .IQ forward-s-expression
  101. with a negative argument.
  102. .dc "backward-sentence" "ESC A"
  103. This moves point backward to the beginning of the current or previous
  104. sentence.  \s-2JOVE\s0 considers the end of a sentence to be the characters
  105. ".", "!" or "?" followed by a Return or by one or more spaces.
  106. .dc "backward-word" "ESC B"
  107. This moves point backward to the beginning of the current or previous
  108. word.
  109. .dc "bad-filename-extensions" "(variable)"
  110. This contains a list of words separated by spaces which are to be
  111. considered bad filename extensions, and so will not be counted in
  112. filename completion.  The default is ".o" so if you have jove.c and
  113. jove.o in the same directory, the filename completion will
  114. .IQ not
  115. complain
  116. of an ambiguity because it will ignore jove.o.
  117. .dc "beginning-of-file" "ESC <"
  118. This moves point backward to the beginning of the buffer.  This
  119. sometimes prints the "Point Pushed" message.  If the top of the buffer
  120. isn't on the screen \s-2JOVE\s0 will set the mark so you can go back to where
  121. you were if you want.
  122. .dc "beginning-of-line" "C-A"
  123. This moves point to the beginning of the current line.
  124. .dc "beginning-of-window" "ESC ,"
  125. This moves point to the beginning of the current window.  The sequence
  126. "ESC ," is the same as "ESC <" (beginning of file) except without the shift
  127. key on the "<", and can thus can easily be remembered.
  128. .dc "bind-to-key" "Not Bound"
  129. This attaches a key to an internal \s-2JOVE\s0 command so that future hits on
  130. that key invoke that command.  For example, to make "C-W" erase the
  131. previous word, you type "ESC X bind-to-key kill-previous-word C-W".
  132. .dc "bind-macro-to-key" "Not Bound"
  133. This is like
  134. .IQ bind-to-key
  135. except you use it to attach keys to
  136. named macros.
  137. .dc "bind-macro-to-word-abbrev" "Not Bound"
  138. This command allows you to bind a macro to a previously defined word
  139. abbreviation.  Whenever you type the abbreviation, it will first be expanded
  140. as an abbreviation, and then the macro will be executed.  Note that if the
  141. macro moves around, you should set the mark first (C-@) and then exchange
  142. the point and mark last (C-X C-X).
  143. .dc "buffer-position" "Not Bound"
  144. This displays the current file name, current line number, total number
  145. of lines, percentage of the way through the file, and the position of
  146. the cursor in the current line.
  147. .dc "c-mode" "Not Bound"
  148. This turns on C mode in the currently selected buffer.  This is one of
  149. currently four possible major modes:  Fundamental, Text, C, Lisp.
  150. When in C or Lisp mode, Tab, "}", and ")" behave a little differently
  151. from usual: They are indented to the "right" place for C (or Lisp)
  152. programs.  In \s-2JOVE\s0, the "right" place is simply the way the author
  153. likes it (but I've got good taste).
  154. .dc "case-character-capitalize" "Not Bound"
  155. This capitalizes the character after point, i.e., the character undo
  156. the cursor.  If a negative argument is supplied that many characters
  157. .IQ before
  158. point are upper cased.
  159. .dc "case-ignore-search" "(variable)"
  160. This variable, when set, tells \s-2JOVE\s0 to treat upper and lower case as
  161. the same when searching.  Thus "jove" and "JOVE" would match, and
  162. "JoVe" would match either.  The default value of this variable is "off".
  163. .dc "case-region-lower" "Not Bound"
  164. This changes all the upper case letters in the region to their lower
  165. case equivalent.
  166. .dc "case-region-upper" "Not Bound"
  167. This changes all the lower case letters in the region to their upper
  168. case equivalent.
  169. .dc "case-word-capitalize" "ESC C"
  170. This capitalizes the current word by making the current letter upper
  171. case and making the rest of the word lower case.  Point is moved to
  172. the end of the word.  If point is not positioned on a word it is first
  173. moved forward to the beginning of the next word.  If a negative
  174. argument is supplied that many words
  175. .IQ before
  176. point are capitalized.
  177. This is useful for correcting the word just typed without having to
  178. move point to the beginning of the word yourself.
  179. .dc "case-word-lower" "ESC L"
  180. This lower-cases the current word and leaves point at the end of it.
  181. If point is in the middle of a word the rest of the word is
  182. converted.  If point is not in a word it is first moved forward to the
  183. beginning of the next word.  If a negative argument is supplied that
  184. many words
  185. .IQ before
  186. point are converted to lower case.  This is useful
  187. for correcting the word just typed without having to move point to the
  188. beginning of the word yourself.
  189. .dc "case-word-upper" "ESC U"
  190. This upper-cases the current word and leaves point at the end of it.
  191. If point is in the middle of a word the rest of the word is
  192. converted.  If point is not in a word it is first moved forward to the
  193. beginning of the next word.  If a negative argument is supplied that
  194. many words
  195. .IQ before
  196. point are converted to upper case.  This is useful
  197. for correcting the word just typed without having to move point to the
  198. beginning of the word yourself.
  199. .dc "character-to-octal-insert" "Not Bound"
  200. This inserts a Back-slash followed by the ascii value of the next
  201. character typed.  For example, "C-G" inserts the string "\\007".
  202. .dc "cd" "Not Bound"
  203. This changes the current directory.
  204. .dc "clear-and-redraw" "ESC C-L"
  205. This clears the entire screen and redraws all the windows.  Use this
  206. when \s-2JOVE\s0 gets confused about what's on the screen, or when the screen
  207. gets filled with garbage characters or output from another program.
  208. .dc "comment-format" "(variable)"
  209. This variable tells \s-2JOVE\s0 how to format your comments when you run the
  210. command
  211. .IQ fill-comment.
  212. Its format is this:
  213. .ID
  214. <open pattern>%!<line header>%c<line trailer>%!<close pattern>
  215. .DE
  216. The %!, %c, and %! must appear in the format; everything else is optional.
  217. A newline (represented by %n) may appear in the open or close patterns.  %%
  218. is the representation for %.  The default comment format is for C comments.
  219. See
  220. .IQ fill-comment
  221. for more.
  222. .dc "compile-it" "C-X C-E"
  223. This compiles your program by running the UNIX command "make" into a buffer,
  224. and automatically parsing the error messages that are created (if any).  See
  225. the
  226. .IQ parse-errors
  227. and
  228. .IQ parse-special-errors
  229. commands.  To compile
  230. a C program without "make", use "C-U C-X C-E" and \s-2JOVE\s0 will prompt
  231. for a command to run instead of make.  (And then the command you type will
  232. become the default command.)  You can use this to parse the output from the
  233. C compiler or the "grep" or "lint" programs.
  234. .dc "continue-process" "Not Bound"
  235. This sends SIGCONT to the current interactive process,
  236. .IQ if
  237. the process
  238. is currently stopped.
  239. .dc "copy-region" "ESC W"
  240. This takes all the text in the region and copies it onto the kill ring
  241. buffer.  This is just like running
  242. .IQ kill-region
  243. followed by the
  244. .IQ yank
  245. command.  See the
  246. .IQ kill-region
  247. and
  248. .IQ yank
  249. commands.
  250. .dc "current-error" "Not Bound"
  251. This moves to the current error in the list of parsed errors.  See the
  252. .IQ next-error
  253. and
  254. .IQ previous-error
  255. commands for more detailed
  256. information.
  257. .dc "date" "Not Bound"
  258. This prints the date on the message line.
  259. .dc "define-mode-word-abbrev" "Not Bound"
  260. This defines a mode-specific abbreviation.
  261. .dc "define-global-word-abbrev" "Not Bound"
  262. This defines a global abbreviation.
  263. .dc "delete-blank-lines" "C-X C-O"
  264. This deletes all the blank lines around point.  This is useful when you
  265. previously opened many lines with "C-O" and now wish to delete the
  266. unused ones.
  267. .dc "delete-buffer" "C-X K"
  268. This deletes a buffer and frees up all the memory associated with it.
  269. Be careful!  Once a buffer has been deleted it is gone forever.  \s-2JOVE\s0
  270. will ask you to confirm if you try to delete a buffer that needs
  271. saving.  This command is useful for when \s-2JOVE\s0 runs out of space to
  272. store new buffers.
  273. .dc "delete-macro" "Not Bound"
  274. This deletes a macro from the list of named macros.  It is an error to
  275. delete the keyboard-macro.  Once the macro is deleted it is gone forever.
  276. If you are about to save macros to a file and decide you don't want to save
  277. a particular one, delete it.
  278. .dc "delete-next-character" "C-D"
  279. This deletes the character that's just after point (that is, the
  280. character under the cursor).  If point is at the end of a line, the
  281. line separator is deleted and the next line is joined with the current
  282. one.
  283. .dc "delete-other-windows" "C-X 1"
  284. This deletes all the other windows except the current one.  This can be
  285. thought of as going back into One Window mode.
  286. .dc "delete-previous-character" "Rubout"
  287. This deletes the character that's just before point (that is, the
  288. character before the cursor).  If point is at the beginning of the
  289. line, the line separator is deleted and that line is joined with the
  290. previous one.
  291. .dc "delete-white-space" "ESC \\\\"
  292. This deletes all the Tabs and Spaces around point.
  293. .dc "delete-current-window" "C-X D"
  294. This deletes the current window and moves point into one of the
  295. remaining ones.  It is an error to try to delete the only remaining
  296. window.
  297. .dc "describe-bindings" "Not Bound"
  298. This types out a list containing each bound key and the command that gets
  299. invoked every time that key is typed.  To make a wall chart of \s-2JOVE\s0
  300. commands, set
  301. .IQ send-typeout-to-buffer
  302. to "on" and \s-2JOVE\s0 will
  303. store the key bindings in a buffer which you can save to a file and then
  304. print.
  305. .dc "describe-command" "Not Bound"
  306. This prints some info on a specified command.
  307. .dc "describe-key" "Not Bound"
  308. This waits for you to type a key and then tells the name of the
  309. command that gets invoked every time that key is hit.  Once you have
  310. the name of the command you can use the
  311. .IQ describe-command
  312. command
  313. to find out exactly what it does.
  314. .dc "describe-variable" "Not Bound"
  315. This prints some info on a specified variable.
  316. .dc "digit" "ESC [0-9]"
  317. This reads a numeric argument.  When you type "ESC" followed by a
  318. number, "digit" keeps reading numbers until you type some other
  319. command.  Then that command is executes with the numeric argument you
  320. specified.
  321. .dc "digit-1" "Not Bound"
  322. This pretends you typed "ESC 1".  This is useful for terminals that
  323. have keypads that send special sequences for numbers typed on the
  324. keypad as opposed to numbers typed from the keyboard.  This can save
  325. having type "ESC" when you want to specify an argument.
  326. .dc "digit-2" "Not Bound"
  327. This pretends you typed "ESC 2".  This is useful for terminals that
  328. have keypads that send special sequences for numbers typed on the
  329. keypad as opposed to numbers typed from the keyboard.  This can save
  330. having type "ESC" when you want to specify an argument.
  331. .dc "digit-3" "Not Bound"
  332. This pretends you typed "ESC 3".  This is useful for terminals that
  333. have keypads that send special sequences for numbers typed on the
  334. keypad as opposed to numbers typed from the keyboard.  This can save
  335. having type "ESC" when you want to specify an argument.
  336. .dc "digit-4" "Not Bound"
  337. This pretends you typed "ESC 4".  This is useful for terminals that
  338. have keypads that send special sequences for numbers typed on the
  339. keypad as opposed to numbers typed from the keyboard.  This can save
  340. having type "ESC" when you want to specify an argument.
  341. .dc "digit-5" "Not Bound"
  342. This pretends you typed "ESC 5".  This is useful for terminals that
  343. have keypads that send special sequences for numbers typed on the
  344. keypad as opposed to numbers typed from the keyboard.  This can save
  345. having type "ESC" when you want to specify an argument.
  346. .dc "digit-6" "Not Bound"
  347. This pretends you typed "ESC 6".  This is useful for terminals that
  348. have keypads that send special sequences for numbers typed on the
  349. keypad as opposed to numbers typed from the keyboard.  This can save
  350. having type "ESC" when you want to specify an argument.
  351. .dc "digit-7" "Not Bound"
  352. This pretends you typed "ESC 7".  This is useful for terminals that
  353. have keypads that send special sequences for numbers typed on the
  354. keypad as opposed to numbers typed from the keyboard.  This can save
  355. having type "ESC" when you want to specify an argument.
  356. .dc "digit-8" "Not Bound"
  357. This pretends you typed "ESC 8".  This is useful for terminals that
  358. have keypads that send special sequences for numbers typed on the
  359. keypad as opposed to numbers typed from the keyboard.  This can save
  360. having type "ESC" when you want to specify an argument.
  361. .dc "digit-9" "Not Bound"
  362. This pretends you typed "ESC 9".  This is useful for terminals that
  363. have keypads that send special sequences for numbers typed on the
  364. keypad as opposed to numbers typed from the keyboard.  This can save
  365. having type "ESC" when you want to specify an argument.
  366. .dc "digit-0" "Not Bound"
  367. This pretends you typed "ESC 0".  This is useful for terminals that
  368. have keypads that send special sequences for numbers typed on the
  369. keypad as opposed to numbers typed from the keyboard.  This can save
  370. having type "ESC" when you want to specify an argument.
  371. .dc "dirs" "Not Bound"
  372. This prints out the directory stack.  See the "cd", "pushd", "popd"
  373. commands for more info.
  374. .dc "disable-biff" "(variable)"
  375. When this is set, \s-2JOVE\s0 disables biff when you're editing and enables it
  376. again when you get out of \s-2JOVE\s0, or when you pause to the parent shell
  377. or push to a new shell. (This means arrival of new mail will not be
  378. immediately apparent but will not cause indiscriminate writing on the
  379. display). The default is "off".
  380. .dc "dstop-process" "Not Bound"
  381. Send the "dsusp" character to the current process.  This is the
  382. character that suspends a process on the next read from the
  383. terminal.  Most people have it set to C-Y.  This only works if
  384. you have the interactive process feature, and if you are in a
  385. buffer bound to a process.
  386. .dc "edit-word-abbrevs" "Not Bound"
  387. This creates a buffer with a list of each abbreviation and the phrase
  388. it expands into, and enters a recursive edit to let you change the
  389. abbreviations or add some more.  The format of this list is
  390. "abbreviation:phrase" so if you add some more you should follow that
  391. format.  It's probably simplest just to copy some already existing
  392. abbreviations and edit them.  When you are done you type "C-X C-C" to
  393. exit the recursive edit.
  394. .dc "end-of-file" "ESC >"
  395. This moves point forward to the end of the buffer.  This sometimes
  396. prints the "Point Pushed" message.  If the end of the buffer isn't on
  397. the screen \s-2JOVE\s0 will set the mark so you can go back to where you were
  398. if you want.
  399. .dc "end-of-line" "C-E"
  400. This moves point to the end of the current line.  If the line is too
  401. long to fit on the screen \s-2JOVE\s0 will scroll the line to the left to
  402. make the end of the line visible.  The line will slide back to its
  403. normal position when you move backward past the leftmost visible character
  404. or when you move off the line altogether.
  405. .dc "end-of-window" "ESC ."
  406. This moves point to the last character in the window.
  407. .dc "eof-process" "Not Bound"
  408. Sends EOF to the current interactive process.  This only works on
  409. versions of \s-2JOVE\s0 which run under 4.2-3 BSD VAX UNIX.  You can't send
  410. EOF to processes on the 2.9 BSD PDP-11 UNIX.
  411. .dc "erase-buffer" "Not Bound"
  412. This erases the contents of the specified buffer.  This is like
  413. .IQ delete-buffer
  414. except it only erases the contents of the buffer, not
  415. the buffer itself.  If you try to erase a buffer that needs saving you
  416. will be asked to confirm it.
  417. .dc "error-window-size" "(variable)"
  418. This is the percentage of the screen to use for the error-window on the
  419. screen.  When you execute
  420. .IQ compile-it,
  421. .IQ error-window-size
  422. percent of the screen will go to the error window.  If the window already
  423. exists and is a different size, it is made to be this size.  The default
  424. value is 20%.
  425. .dc "exchange-point-and-mark" "C-X C-X"
  426. This moves point to mark and makes mark the old point.  This is for
  427. quickly moving from one end of the region to another.
  428. .dc "execute-named-command" "ESC X"
  429. This is the way to execute a command that isn't bound to any key.
  430. When you are prompted with ": " you can type the name of the
  431. command.  You don't have to type the entire name.  Once the command
  432. is unambiguous you can type Space and \s-2JOVE\s0 will fill in the rest for
  433. you.
  434. If you are not sure of the name of the command, type "?" and \s-2JOVE\s0
  435. will print a list of all the commands that you could possibly match
  436. given what you've already typed.  If you don't have any idea what the
  437. command's name is but you know it has something to do with windows
  438. (for example), you can do "ESC X apropos window" and \s-2JOVE\s0 will print a
  439. list of all the commands that are related to windows.
  440. If you find yourself constantly executing the same commands this way
  441. you probably want to bind them to keys so that you can execute them
  442. more quickly.  See the
  443. .IQ bind-to-key
  444. command.
  445. .dc "execute-keyboard-macro" "C-X E"
  446. This executes the keyboard macro.  If you supply a numeric argument the
  447. macro is executed that many times.
  448. .dc "execute-macro" "Not Bound"
  449. This executes a specified macro.  If you supply a numeric argument the
  450. macro is executed that many times.
  451. .dc "exit-jove" "C-X C-C"
  452. This exits \s-2JOVE\s0.  If any buffers need saving \s-2JOVE\s0 will print a warning
  453. message and ask for confirmation.  If you leave without saving your
  454. buffers all your work will be lost.  If you made a mistake and really
  455. do want to exit then you can.  If you are in a recursive editing level
  456. .IQ exit-jove
  457. will return you from that.
  458. .dc "file-creation-mode" "(variable)"
  459. This variable has an octal value.
  460. It contains the mode (see
  461. .IQ chmod(1)
  462. ) with which files should be created.  This mode gets modified by your
  463. current umask setting (see
  464. .IQ umask(1)
  465. ).  The default value is usually
  466. .IQ 0666
  467. or
  468. .IQ 0644.
  469. .dc "files-should-end-with-newline" "(variable)"
  470. This variable indicates that all files should always have a newline
  471. at the end.  This is often necessary for line printers and the like.
  472. When set, if \s-2JOVE\s0 is writing a file whose last character is not a
  473. newline, it will add one automatically.
  474. .dc "fill-comment" "Not Bound"
  475. This command fills in your C comments to make them pretty and readable.
  476. This filling is done according the variable
  477. .IQ comment-format.
  478. .DS L
  479. /*
  480.  * the default format makes comments like this.
  481.  */
  482. .DE
  483. This can be changed by changing the format variable.  Other languages
  484. may be supported by changing the format variable appropriately.  The
  485. formatter looks backwards from dot for an open comment symbol.  If 
  486. found, all indentation is done relative the position of the first character
  487. of the open symbol.  If there is a matching close symbol, the entire 
  488. comment is formatted.  If not, the region between dot and the open symbol
  489. is reformatted.
  490. .dc "fill-paragraph" "ESC J"
  491. This rearranges words between lines so that all the lines in the current
  492. paragraph extend as close to the right margin as possible, ensuring that
  493. none of the lines will be greater than the right margin.  The default value
  494. for
  495. .IQ right-margin
  496. is 78, but can be changed with the
  497. .IQ set
  498. and
  499. .IQ right-margin-here
  500. commands.  \s-2JOVE\s0 has a complicated algorithm
  501. for determining the beginning and end of the paragraph.  In the normal case
  502. \s-2JOVE\s0 will give all the lines the same indent as they currently have,
  503. but if you wish to force a new indent you can supply a numeric argument to
  504. .IQ fill-paragraph
  505. (e.g., by typing C-U ESC J)
  506. and \s-2JOVE\s0 will indent each line to the column
  507. specified by the
  508. .IQ left-margin
  509. variable.  See also the
  510. .IQ left-margin
  511. variable and
  512. .IQ left-margin-here
  513. command.
  514. .dc "fill-region" "Not Bound"
  515. This is like
  516. .IQ fill-paragraph,
  517. except it operates on a region instead of
  518. just a paragraph.
  519. .dc "filter-region" "Not Bound"
  520. This sends the text in the region to a UNIX command, and replaces the
  521. region with the output from that command.  For example, if you are
  522. lazy and don't like to take the time to write properly indented C
  523. code, you can put the region around your C file and
  524. .IQ filter-region
  525. it
  526. through
  527. .IQ cb,
  528. the UNIX C beautifier.  If you have a file that contains
  529. a bunch of lines that need to be sorted you can do that from inside
  530. \s-2JOVE\s0 too, by filtering the region through the
  531. .IQ sort
  532. UNIX command.
  533. Before output from the command replaces the region \s-2JOVE\s0 stores the old
  534. text in the kill ring, so if you are unhappy with the results you can
  535. easily get back the old text with "C-Y".
  536. .dc "find-file" "C-X C-F"
  537. This visits a file into its own buffer and then selects that buffer.
  538. If you've already visited this file in another buffer, that buffer is
  539. selected.  If the file doesn't yet exist, \s-2JOVE\s0 will print "(New file)"
  540. so that you know.
  541. .dc "find-tag" "C-X T"
  542. This finds the file that contains the specified tag.  \s-2JOVE\s0 looks up
  543. tags by default in the "tags" file in the current directory.  You can change
  544. the default tag name by setting the
  545. .IQ tag-file
  546. variable to another
  547. name.  If you specify a numeric argument to this command, you will be
  548. prompted for a tag file.  This is a good way to specify another tag file
  549. without changing the default.  If the tag cannot be found the error is
  550. reported and point stays where it is.
  551. .dc "find-tag-at-point" "Not Bound"
  552. This finds the file that contains the tag that point is currently on.
  553. See
  554. .IQ find-tag.
  555. .dc "first-non-blank" "ESC M"
  556. This moves point back to the indent of the current line.
  557. .dc "forward-character" "C-F"
  558. This moves forward over a single character.  If point is at the end of
  559. the line it moves to the beginning of the next one.
  560. .dc "forward-paragraph" "ESC ]"
  561. This moves point forward to the end of the current or next paragraph.
  562. Paragraphs are bounded by lines that begin with a Period or Tab, or by blank
  563. lines; a change in indentation may also signal a break between paragraphs,
  564. except that \s-2JOVE\s0 allows the first line of a paragraph to be indented
  565. differently from the other lines.
  566. .dc "forward-s-expression" "ESC C-F"
  567. This moves point forward over a s-expression.  If the first significant
  568. character after point is "(", this moves past the matching ")".  If the
  569. character begins an identifier, this moves just past it.  This is mode
  570. dependent, so this will move over atoms in LISP mode and C identifiers in C
  571. mode.  \s-2JOVE\s0 also matches "{".
  572. .dc "forward-sentence" "ESC E"
  573. This moves point forward to the end of the current or next sentence.
  574. \s-2JOVE\s0 considers the end of a sentence to be the characters ".", "!" or
  575. "?" followed by a Return, or one or more spaces.
  576. .dc "forward-word" "ESC F"
  577. This moves point forward to the end of the current or next word.
  578. .dc "fundamental-mode" "Not Bound"
  579. This sets the major mode to Fundamental.  This affects what \s-2JOVE\s0
  580. considers as characters that make up words.  For instance,
  581. Single-quote is not part of a word in Fundamental mode, but is in Text
  582. mode.
  583. .dc "goto-line" "ESC G"
  584. If a numeric argument is supplied point moves to the beginning of that
  585. line.  If no argument is supplied, point remains where it is.  This is
  586. so you don't lose your place unintentionally, by accidentally hitting
  587. the "G" instead of "F".
  588. .dc "grind-s-expr" "Not Bound"
  589. When point is positioned on a "(", this re-indents that LISP expression.
  590. .dc "grow-window" "C-X ^"
  591. This makes the current window one line bigger.  This only works when
  592. there is more than one window and provided there is room to change the
  593. size.
  594. .dc "paren-flash" ") } ]"
  595. This handles the C mode curly brace indentation, the Lisp mode paren
  596. indentation, and the Show Match mode paren/curly brace/square bracket
  597. flashing.
  598. .dc "handle-tab" "Tab"
  599. This handles indenting to the "right" place in C and Lisp mode, and
  600. just inserts itself in Text mode.
  601. .dc "i-search-forward" "Not Bound"
  602. Incremental search.  Like search-forward except that instead of prompting
  603. for a string and searching for that string all at once, it accepts the string
  604. one character at a time.  After each character you type as part of the search
  605. string, it searches for the entire string so far.  When you like what it
  606. found, type the Return key to finish the search.  You can take back a
  607. character with Rubout and the search will back up to the position before
  608. that character was typed.  C-G aborts the search.
  609. .dc "i-search-reverse" "Not Bound"
  610. Incremental search.  Like search-reverse except that instead of prompting
  611. for a string and searching for that string all at once, it accepts the string
  612. one character at a time.  After each character you type as part of the search
  613. string, it searches for the entire string so far.  When you like what it
  614. found, type the Return key to finish the search.  You can take back a
  615. character with Rubout and the search will back up to the position before
  616. that character was typed.  C-G aborts the search.
  617. .dc "insert-file" "C-X C-I"
  618. This inserts a specified file into the current buffer at point.  Point
  619. is positioned at the beginning of the inserted file.
  620. .dc "internal-tabstop" "(variable)"
  621. The number of spaces \s-2JOVE\s0 should print when it displays a tab character.
  622. The default value is 8.
  623. .dc "interrupt-process" "Not Bound"
  624. This sends the interrupt character (usually C-C) to the interactive process
  625. in the current buffer.  This is only for versions of \s-2JOVE\s0 that have the
  626. interactive processes feature.  This only works when you are inside a buffer
  627. that's attached to a process.
  628. .dc "i-shell" "Not Bound"
  629. This starts up an interactive shell in a window.  \s-2JOVE\s0 uses "shell-1"
  630. as the name of the buffer in which the interacting takes place.  See
  631. the manual for information on how to use interactive processes.
  632. .dc "i-shell-command" "Not Bound"
  633. This is like
  634. .IQ shell-command
  635. except it lets you continue with your
  636. editing while the command is running.  This is really useful for long
  637. running commands with sporadic output.  See the manual for information
  638. on how to use interactive processes.
  639. .dc "kill-next-word" "ESC D"
  640. This kills the text from point to the end of the current or next word.
  641. .dc "kill-previous-word" "ESC Rubout"
  642. This kills the text from point to the beginning of the current or
  643. previous word.
  644. .dc "kill-process" "Not Bound"
  645. This command prompts for a buffer name or buffer number (just as
  646. select-buffer does) and then sends the process in that buffer a
  647. kill signal (9).
  648. .dc "kill-region" "C-W"
  649. This deletes the text in the region and saves it on the kill ring.
  650. Commands that delete text but save it on the kill ring all have the
  651. word "kill" in their names.  Type "C-Y" to yank back the most recent
  652. kill.
  653. .dc "kill-s-expression" "ESC C-K"
  654. This kills the text from point to the end of the current or next
  655. s-expression.
  656. .dc "kill-some-buffers" "Not Bound"
  657. This goes through all the existing buffers and asks whether or not to kill
  658. them.  If you decide to kill a buffer, and it turns out that the buffer is
  659. modified, \s-2JOVE\s0 will offer to save it first.  This is useful for when \s-2JOVE\s0
  660. runs out of memory to store lines (this only happens on PDP-11's) and you
  661. have lots of buffers that you are no longer using.
  662. .dc "kill-to-beginning-of-sentence" "C-X Rubout"
  663. This kills from point to the beginning of the current or previous
  664. sentence.
  665. .dc "kill-to-end-of-line" "C-K"
  666. This kills from point to the end of the current line.  When point is
  667. at the end of the line the line separator is deleted and the next line
  668. is joined with current one.  If a numeric argument is supplied that
  669. many lines are killed; if the argument is negative that many lines
  670. .IQ before
  671. point are killed; if the argument is zero the text from point
  672. to the beginning of the line is killed.
  673. .dc "kill-to-end-of-sentence" "ESC K"
  674. This kills from point to the end of the current or next sentence.  If a
  675. negative numeric argument is supplied it kills from point to the
  676. beginning of the current or previous sentence.
  677. .dc "left-margin" "(variable)"
  678. This is how far lines should be indented when auto-indent mode is on,
  679. or when the
  680. .IQ newline-and-indent
  681. command is run (usually by typing
  682. LineFeed).  It is also used by fill-paragraph and auto-fill mode.
  683. If the value is zero (the default) then the left margin is determined
  684. from the surrounding lines.
  685. .dc "left-margin-here" "Not Bound"
  686. This sets the
  687. .IQ left-margin
  688. variable to the current position of
  689. point.  This is an easy way to say, "Make the left margin begin here,"
  690. without having to count the number of spaces over it actually is.
  691. .dc "lisp-mode" "Not Bound"
  692. This turns on Lisp mode.  Lisp mode is one of four mutually exclusive major
  693. modes: Fundamental, Text, C, and Lisp.  In Lisp mode, the characters Tab
  694. and ) are treated specially, similar to the way they are treated in C mode.
  695. Also, Auto Indent mode is affected, and handled specially.
  696. .dc "list-buffers" "C-X C-B"
  697. This types out a list containing various information about each buffer.
  698. Right now that list looks like this:
  699. .DS
  700. .ta \w'NO111'u +\w'Lines1'u +\w'Scratch111'u +\w'*1'u +\w'commands.doc111'u
  701. \ (* means the buffer needs saving)
  702. \ NO    Lines    Type        Name    File
  703. \ --    -----    ----        ----    ----
  704. \ 1    1    File        Main    [No file]
  705. \ 2    1    Scratch    *    Minibuf    [No file]
  706. \ 3    519    File    *    commands.doc    commands.doc
  707. .DE
  708. The first column lists the buffer's number.  When \s-2JOVE\s0 prompts for a
  709. buffer name you can either type in the full name, or you can simply
  710. type the buffer's number.  The second column is the number of lines in
  711. the buffer.  The third says what type of buffer.  There are four
  712. types: "File", "Scratch", "Process", "I-Process".  "File" is simply a
  713. buffer that holds a file; "Scratch" is for buffers that \s-2JOVE\s0 uses
  714. internally; "Process" is one that holds the output from a UNIX
  715. command; "I-Process" is one that has an interactive process attached to
  716. it.  The next column contains the name of the buffer.  And the last
  717. column is the name of the file that's attached to the buffer.  In this
  718. case, both Minibuf and commands.doc have been changed but not yet
  719. saved.  In fact Minibuf won't be saved since it's an internal \s-2JOVE\s0
  720. buffer that I don't even care about.
  721. .dc "list-processes" "Not Bound"
  722. This makes a list somewhat like "list-buffers" does, except its
  723. list consists of the current interactive processes.  Right now the list
  724. looks like this:
  725. .DS
  726. .ta \w'shell-111111111111'u +\w'Running1111111111'u
  727. \ Buffer    Status    Command name
  728. \ ------    ------    ------- ----
  729. \ shell-1    Running    i-shell
  730. \ fgrep     Done    fgrep -n Buffer *.c
  731. .DE
  732. The first column has the name of the buffer to which the process is
  733. attached.  The second has the status of the process; if a process has
  734. exited normally the status is "Done" as in fgrep; if the process
  735. exited with an error the status is "Exit N" where N is the value of
  736. the exit code; if the process was killed by some signal the status is
  737. the name of the signal that was used; otherwise the process is
  738. running.  The last column is the name of the command that is being run.
  739. .dc "mailbox" "(variable)"
  740. Set this to the full pathname of your mailbox.  \s-2JOVE\s0 will look here to
  741. decide whether or not you have any unread mail.  This defaults to
  742. /usr/spool/mail/$USER, where $USER is set to your login name.
  743. .dc "mail-check-frequency" "(variable)"
  744. This is how often (in seconds) \s-2JOVE\s0 should check your mailbox for
  745. incoming mail.  See also the
  746. .IQ mailbox
  747. and
  748. .IQ disable-biff
  749. variables.
  750. .dc "make-backup-files" "(variable)"
  751. If this variable is set, then whenever \s-2JOVE\s0 writes out a file, it will
  752. move the previous version of the file (if there was one) to "#filename".
  753. This is often convenient if you save a file by accident.  The default
  754. value of this variable is "off".
  755. .IQ Note:
  756. this is an optional part of
  757. \s-2JOVE\s0, and your guru may not have it enabled, so it may not work.
  758. .dc "make-buffer-unmodified" "ESC ~"
  759. This makes \s-2JOVE\s0 think the selected buffer hasn't been changed even if
  760. it has.  Use this when you accidentally change the buffer but don't
  761. want it considered changed.  Watch the mode line to see the * disappear
  762. when you use this command.  
  763. .dc "make-macro-interactive" "Not Bound"
  764. This command is meaningful only while you are defining a keyboard macro.
  765. Ordinarily, when a command in a macro definition requires a trailing
  766. text argument (file name, search string, etc.), the argument you
  767. supply becomes part of the macro definition.  If you want to be able
  768. to supply a different argument each time the macro is used, then while
  769. you are defining it, you should give the make-macro-interactive
  770. command just before typing the argument which will be used during the
  771. definition process.  Note: you must bind this command to a key in
  772. order to use it; you can't say ESC X make-macro-interactive.
  773. .dc "mark-threshold" "(variable)"
  774. This variable contains the number of lines point may move by before
  775. the mark is set.  If, in a search or something, point moves by more
  776. than this many lines, the mark is set so that you may return easily.
  777. The default value of this variable is 22 (one screenful, on most
  778. terminals).
  779. .dc "marks-should-float" "(variable)"
  780. When this variable is "off", the position of a mark is remembered as a line
  781. number within the buffer and a character number within the line.  If you add
  782. or delete text before the mark, it will no longer point to the text you
  783. marked originally because that text is no longer at the same line and
  784. character number.  When this variable is "on", the position of a mark is
  785. adjusted to compensate for each insertion and deletion.  This makes marks
  786. much more sensible to use, at the cost of slowing down insertion and
  787. deletion somewhat.  The default value is "on".
  788. .dc "match-regular-expressions" "(variable)"
  789. When set, \s-2JOVE\s0 will match regular expressions in search patterns.
  790. This makes special the characters ., *, [, ], ^, and $, and the two-character
  791. sequences \e<, \e>, \e\|{, \e\|} and \e\||.
  792. See the
  793. .IQ ed(1)
  794. manual page, the tutorial "Advanced Editing in 
  795. .UX
  796. ", and the section above "Searching with Regular Expressions"
  797. for more information.
  798. .dc "meta-key" "(variable)"
  799. You should set this variable to "on" if your terminal has a real Meta
  800. key.
  801. If your terminal has such a key, then a key sequence like ESC Y can
  802. be entered by holding down Meta and typing Y.
  803. .dc "mode-line" "(variable)"
  804. The format of the mode line can be determined by setting this variable.
  805. The items in the line are specified using a printf(3) format, with the
  806. special things being marked as "%x".  Digits may be used between the
  807. '%' and the 'x' to mean repeat that many times.
  808. \&'x' may be:
  809. .DS I
  810. .ta .5i 1i 1.5i
  811.     C    check for new mail, and displays "[New mail]" if there
  812.         is any (see also the mail-check-interval and disable-biff
  813.         variables)
  814.     F    the current file name, with leading path stripped
  815.     M    the current list of major and minor modes
  816.     b    the current buffer name
  817.     c    the fill character (-)
  818.     d    the current directory
  819.     e    end of string--this must be the last item in the string
  820.     f    the current file name
  821.     l    the current load average (updated automatically)
  822.     m    the buffer-modified symbol (*)
  823.     n    the current buffer number
  824.     s    space, but only if previous character is not a space
  825.     t    the current time (updated automatically)
  826.     [ ]    the square brackets printed when in a recursive edit
  827.     ( )    items enclosed in %( ... %) will only be printed on
  828.         the bottom mode line, rather than copied when the
  829.         window is split
  830. .DE
  831. In addition, any other character is simply copied into the mode line.
  832. Characters may be escaped with a backslash.  To get a feel for all
  833. this, try typing "ESC X print mode-line" and compare the result with
  834. your current mode line.
  835. .dc "mode-line-should-standout" "(variable)"
  836. If set, the mode line will be printed in reverse video, if your
  837. terminal supports it.  The default for this variable is "off".
  838. .dc "name-keyboard-macro" "Not Bound"
  839. This copies the keyboard macro and gives it a name freeing up the
  840. keyboard macro so you can define some more.  Keyboard macros with
  841. their own names can be bound to keys just like built in commands
  842. can.  See the
  843. .IQ read-macros-file-file
  844. and
  845. .IQ write-macros-to-file
  846. commands.
  847. .dc "newline" "Return"
  848. This divides the current line at point moving all the text to the
  849. right of point down onto the newly created line.  Point moves down to
  850. the beginning of the new line.
  851. .dc "newline-and-backup" "C-O"
  852. This divides the current line at point moving all the text to the
  853. right of point down onto the newly created line.  The difference
  854. between this and "newline" is that point does not move down to the
  855. beginning of the new line.
  856. .dc "newline-and-indent" "LineFeed"
  857. This behaves the same was as Return does when in Auto Indent mode.
  858. This makes Auto Indent mode obsolete but it remains in the name of
  859. backward compatibility.
  860. .dc "next-error" "C-X C-N"
  861. This moves to the next error in the list of errors that were parsed
  862. with
  863. .IQ parse-errors
  864. or
  865. .IQ parse-special-errors.
  866. In one window the list
  867. of errors is shown with the current one always at the top.  In another
  868. window is the file that contains the error.  Point is positioned in
  869. this window on the line where the error occurred.
  870. .dc "next-line" "C-N"
  871. This moves down to the next line.
  872. .dc "next-page" "C-V"
  873. This displays the next page of the buffer by taking the bottom line of
  874. the window and redrawing the window with it at the top.  If there isn't
  875. another page in the buffer \s-2JOVE\s0 rings the bell.  If a numeric argument
  876. is supplied the screen is scrolled up that many lines; if the argument
  877. is negative the screen is scrolled down.
  878. .dc "next-window" "C-X N"
  879. This moves into the next window.  Windows live in a circular list so
  880. when you're in the bottom window and you try to move to the next one
  881. you are moved to the top window.  It is an error to use this command
  882. with only one window.
  883. .dc "number-lines-in-window" "Not Bound"
  884. This displays the line numbers for each line in the buffer being
  885. displayed.  The number isn't actually part of the text; it's just
  886. printed before the actual buffer line is.  To turn this off you run
  887. the command again; it toggles.
  888. .dc "over-write-mode" "Not Bound"
  889. This turns Over Write mode on (or off if it's currently on) in the selected
  890. buffer.  When on, this mode changes the way the self-inserting characters
  891. work.  Instead of inserting themselves and pushing the rest of the line over
  892. to the right, they replace or over-write the existing character.  Also,
  893. Rubout replaces the character before point with a space instead of deleting
  894. it.  When Over Write mode is on "OvrWt" is displayed on the mode line.
  895. .dc "page-next-window" "ESC C-V"
  896. This displays the next page in the next window.  This is exactly the
  897. same as "C-X N C-V C-X P".
  898. .dc "paren-flash-delay" "(variable)"
  899. How long, in tenths of seconds, \s-2JOVE\s0 should pause on a matching
  900. parenthesis in
  901. .IQ Show Match
  902. mode.  The default is 5.
  903. .dc "parse-errors" "Not Bound"
  904. This takes the list of C compilation errors (or output from another program
  905. in the same format) in the current buffer and parses them for use with the
  906. .IQ next-error
  907. and
  908. .IQ previous-error
  909. and
  910. .IQ current-error
  911. commands.
  912. This is a very useful tool and helps with compiling C programs and when used
  913. in conjunction with the "grep" UNIX command very helpful in making changes
  914. to a bunch of files.  This command understands errors produced by cc, cpp,
  915. and lint; plus any other program with the same format (e.g., "grep -n").
  916. \s-2JOVE\s0 visits each file that has an error and remembers each line that
  917. contains an error.  It doesn't matter if later you insert or delete
  918. some lines in the buffers containing errors; \s-2JOVE\s0 remembers where
  919. they are regardless.
  920. .IQ next-error
  921. is automatically executed after one
  922. of the parse commands, so you end up at the first error.
  923. .dc "parse-special-errors" "Not Bound"
  924. This parses errors in an unknown format.  Error parsing works with
  925. regular expression search strings with \\('s around the the file name
  926. and the line number.  So, you can use
  927. .IQ parse-special-errors
  928. to parse
  929. lines that are in a slightly different format by typing in your own
  930. search string.  If you don't know how to use regular expressions you
  931. can't use this command.
  932. .dc "parse-spelling-errors-in-buffer" "Not Bound"
  933. This parses a list of words in the current buffer and looks them up in
  934. another buffer that you specify.  This will probably go away soon.
  935. .dc "pause-jove" "ESC S"
  936. This stops \s-2JOVE\s0 and returns control to the parent shell.  This
  937. only works for users using the C-shell, and on systems that have the
  938. job control facility.  To return to \s-2JOVE\s0 you type "fg" to the C-shell.
  939. .dc "physical-tabstop" "(variable)"
  940. How many spaces your terminal prints when it prints a tab character.
  941. .dc "pop-mark" "Not Bound"
  942. This gets executed when you run
  943. .IQ set-mark
  944. with a numeric argument.
  945. \s-2JOVE\s0 remembers the last 16 marks and you use
  946. .IQ pop-mark
  947. to go
  948. backward through the ring of marks.  If you execute "
  949. .IQ pop-mark
  950. enough
  951. times you will eventually get back to where you started.
  952. .dc "popd" "Not Bound"
  953. This pops one entry off the directory stack.  Entries are pushed with
  954. the
  955. .IQ pushd
  956. command.  The names were stolen from the C-shell and the
  957. behavior is the same.
  958. .dc "previous-error" "C-X C-P"
  959. This is the same as
  960. .IQ next-error
  961. except it goes to the previous error.
  962. See
  963. .IQ next-error
  964. for documentation.
  965. .dc "previous-line" "C-P"
  966. This moves up to the previous line.
  967. .dc "previous-page" "ESC V"
  968. This displays the previous page of the current buffer by taking the top
  969. line and redrawing the window with it at the bottom.  If a numeric
  970. argument is supplied the screen is scrolled down that many lines; if
  971. the argument is negative the screen is scrolled up.
  972. .dc "previous-window" "C-X P and C-X O"
  973. This moves into the next window.  Windows live in a circular list so
  974. when you're in the top window and you try to move to the previous one
  975. you are moved to the bottom window.  It is an error to use this command
  976. with only one window.
  977. .dc "print" "Not Bound"
  978. This prints the value of a \s-2JOVE\s0 variable.
  979. .dc "print-message" "Not Bound"
  980. This command prompts for a message, and then prints it on the bottom
  981. line where \s-2JOVE\s0 messages are printed.
  982. .dc "process-bind-to-key" "Not Bound"
  983. This command is identical to bind-to-key, except that it only affects
  984. your bindings when you are in a buffer attached to a process.  When
  985. you enter the process buffer, any keys bound with this command will
  986. automatically take their new values.  When you switch to a non-process
  987. buffer, the old bindings for those keys will be restored.  For example,
  988. you might want to execute
  989. .DS I
  990. process-bind-to-key stop-process ^Z
  991. process-bind-to-key interrupt-process ^C
  992. .DE
  993. Then, when you start up an interactive process and switch into that
  994. buffer, C-Z will execute stop-process and C-C will execute interrupt-
  995. process.  When you switch back to a non-process buffer, C-Z will go
  996. back to executing scroll-up (or whatever you have it bound to).
  997. .dc "process-newline" "Return"
  998. This this only gets executed when in a buffer that is attached to an
  999. interactive-process.  \s-2JOVE\s0 does two different things depending on where
  1000. you are when you hit Return.  When you're at the end of the I-Process
  1001. buffer this does what Return normally does, except it also makes the
  1002. line available to the process.  When point is positioned at some other
  1003. position that line is copied to the end of the buffer (with the prompt
  1004. stripped) and point is moved there with it, so you can then edit that
  1005. line before sending it to the process.  This command
  1006. .IQ must
  1007. be bound
  1008. to the key you usually use to enter shell commands (Return), or else
  1009. you won't be able to enter any.
  1010. .dc "process-prompt" (variable)
  1011. What a prompt looks like from the i-shell and i-shell-command
  1012. processes.  The default is "% ", the default C-shell prompt.  This is
  1013. actually a regular expression search string.  So you can set it to be
  1014. more than one thing at once using the \\| operator.  For instance, for
  1015. LISP hackers, the prompt can be
  1016. .DS
  1017. "% \\|-> \\|<[0-9]>: ".
  1018. .DE
  1019. .dc "push-shell" "Not Bound"
  1020. This spawns a child shell and relinquishes control to it.  This works
  1021. on any version of UNIX, but this isn't as good as
  1022. .IQ pause-jove
  1023. because
  1024. it takes time to start up the new shell and you get a brand new
  1025. environment every time.  To return to \s-2JOVE\s0 you type "C-D".
  1026. .dc "pushd" "Not Bound"
  1027. This pushes a directory onto the directory stack and cd's into it.  It
  1028. asks for the directory name but if you don't specify one it switches
  1029. the top two entries no the stack.  It purposely behaves the same as
  1030. C-shell's
  1031. .IQ pushd.
  1032. .dc "pwd" "Not Bound"
  1033. This prints the working directory.
  1034. .dc "quadruple-numeric-argument" "C-U"
  1035. This multiplies the numeric argument by 4.  So, "C-U C-F" means
  1036. forward 4 characters and "C-U C-U C-N" means down 16 lines.
  1037. .dc "query-replace-string" "ESC Q"
  1038. This replaces the occurrences of a specified string with a specified
  1039. replacement string.  When an occurrence is found point is moved to it
  1040. and then \s-2JOVE\s0 asks what to do.  The options are:
  1041. .DS I
  1042. .ta \w'Rubout111'u
  1043. Space    to replace this occurrence and go on to the next one.
  1044. Period    to replace this occurrence and then stop.
  1045. Rubout    to skip this occurrence and go on to the next one.
  1046. C-R    to enter a recursive edit.  This lets you temporarily
  1047.     suspend the replace, do some editing, and then return
  1048.     to continue where you left off.  To continue with the
  1049.     Query Replace type "C-X C-C" as if you were trying to
  1050.     exit \s-2JOVE\s0.  Normally you would but when you are in a
  1051.     recursive edit all it does is exit that recursive
  1052.     editing level.
  1053. C-W    to delete the matched string and then enter a recursive
  1054.     edit.
  1055. U    to undo the last replacement.
  1056. P or !    to go ahead and replace the remaining occurrences without
  1057.     asking.
  1058. Return    to stop the Query Replace.
  1059. .DE
  1060. The search for occurrences starts at point and goes to the end of the
  1061. buffer, so to replace in the entire buffer you must first go to the
  1062. beginning.
  1063. .dc "quit-process" "Not Bound"
  1064. This is the same as typing "C-\\" (the Quit character) to a normal UNIX
  1065. process, except it sends it to the current process in \s-2JOVE\s0.  This is
  1066. only for versions of \s-2JOVE\s0 that have the interactive processes feature.
  1067. This only works when you are inside a buffer that's attached to a
  1068. process.
  1069. .dc "quoted-insert" "C-Q"
  1070. This lets you insert characters that normally would be executed as
  1071. other \s-2JOVE\s0 commands.  For example, to insert "C-F" you type "C-Q C-F".
  1072. .dc "read-word-abbrev-file" "Not Bound"
  1073. This reads a specified file that contains a bunch of abbreviation
  1074. definitions, and makes those abbreviations available.  If the selected
  1075. buffer is not already in Word Abbrev mode this command puts it in
  1076. that mode.
  1077. .dc "read-macros-from-file" "Not Bound"
  1078. This reads the specified file that contains a bunch of macro
  1079. definitions, and defines all the macros that were currently defined
  1080. when the file was created.  See
  1081. .IQ write-macros-to-file
  1082. to see how to
  1083. save macros.
  1084. .dc "redraw-display" "C-L"
  1085. This centers the line containing point in the window.  If that line is
  1086. already in the middle the window is first cleared and then redrawn.
  1087. If a numeric argument is supplied, the line is positioned at that
  1088. offset from the top of the window.  For example, "ESC 0 C-L" positions
  1089. the line containing point at the top of the window.
  1090. .dc "recursive-edit" "Not Bound"
  1091. This enters a recursive editing level.  This isn't really very
  1092. useful.  I don't know why it's available for public use.  I think I'll
  1093. delete it some day.
  1094. .dc "rename-buffer" "Not Bound"
  1095. This lets you rename the current buffer.
  1096. .dc "replace-in-region" "Not Bound"
  1097. This is the same as
  1098. .IQ replace-string
  1099. except that it is restricted
  1100. to occurrences between Point and Mark.
  1101. .dc "replace-string" "ESC R"
  1102. This replaces all occurrences of a specified string with a specified
  1103. replacement string.  This is just like
  1104. .IQ query-replace-string
  1105. except
  1106. it replaces without asking.
  1107. .dc "right-margin" "(variable)"
  1108. Where the right margin is for
  1109. .IQ "Auto Fill"
  1110. mode and the
  1111. .IQ justify-paragraph
  1112. and
  1113. .IQ justify-region
  1114. commands.  The default is 78.
  1115. .dc "right-margin-here" "Not Bound"
  1116. This sets the
  1117. .IQ right-margin
  1118. variable to the current position of
  1119. point.  This is an easy way to say, "Make the right margin begin here,"
  1120. without having to count the number of spaces over it actually is.
  1121. .dc "save-file" "C-X C-S"
  1122. This saves the current buffer to the associated file.  This makes your
  1123. changes permanent so you should be sure you really want to.  If the
  1124. buffer has not been modified
  1125. .IQ save-file
  1126. refuses to do the save.  If
  1127. you really do want to write the file you can use "C-X C-W" which
  1128. executes
  1129. .IQ write-file.
  1130. .dc "scroll-down" "ESC Z"
  1131. This scrolls the screen one line down.  If the line containing point
  1132. moves past the bottom of the window point is moved up to the center of
  1133. the window.  If a numeric argument is supplied that many lines are
  1134. scrolled; if the argument is negative the screen is scrolled up
  1135. instead.
  1136. .dc "scroll-step" "(variable)"
  1137. How many lines should be scrolled if the
  1138. .IQ previous-line
  1139. or
  1140. .IQ next-line
  1141. commands move you off the top or bottom of the screen.  You
  1142. may wish to decrease this variable if you are on a slow terminal.
  1143. .dc "scroll-up" "C-Z"
  1144. This scrolls the screen one line up.  If the line containing point
  1145. moves past the top of the window point is moved down to the center of
  1146. the window.  If a numeric argument is supplied that many lines are
  1147. scrolled; if the argument is negative the screen is scrolled down
  1148. instead.
  1149. .dc "search-exit-char" "(variable)"
  1150. Set this to the character you want to use to exit incremental search.
  1151. The default is Newline, which makes i-search compatible with normal
  1152. string search.
  1153. .dc "search-forward" "C-S"
  1154. This searches forward for a specified search string and positions
  1155. point at the end of the string if it's found.  If the string is not
  1156. found point remains unchanged.  This searches from point to the end of
  1157. the buffer, so any matches before point will be missed.
  1158. .dc "search-reverse" "C-R"
  1159. This searches backward for a specified search string and positions
  1160. point at the beginning if the string if it's found.  If the string is
  1161. not found point remains unchanged.  This searches from point to the
  1162. beginning of the buffer, so any matches after point will be missed.
  1163. .dc "select-buffer" "C-X B"
  1164. This selects a new or already existing buffer making it the current
  1165. one.  You can type either the buffer name or number.  If you type in
  1166. the name you need only type the name until it is unambiguous, at which
  1167. point typing Escape or Space will complete it for you.  If you want to
  1168. create a new buffer you can type Return instead of Space, and a new
  1169. empty buffer will be created.
  1170. .dc "self-insert" "Most Printing Characters"
  1171. This inserts the character that invoked it into the buffer at point.
  1172. Initially all but a few of the printing characters are bound to
  1173. .IQ self-insert.
  1174. .dc "send-typeout-to-buffer" "(variable)"
  1175. When this is set \s-2JOVE\s0 will send output that normally overwrites the
  1176. screen (temporarily) to a buffer instead.  This affects commands like
  1177. .IQ list-buffers,
  1178. .IQ list-processes,
  1179. and other commands that use command
  1180. completion.  The default value is "off".
  1181. .dc "set" "Not Bound"
  1182. This gives a specified variable a new value.  Occasionally you'll see
  1183. lines like "set this variable to that value to do this".  Well, you
  1184. use the
  1185. .IQ set
  1186. command to do that.
  1187. .dc "set-mark" "C-@"
  1188. This sets the mark at the current position in the buffer.  It prints
  1189. the message "Point pushed" on the message line.  It says that instead
  1190. of "Mark set" because when you set the mark the previous mark is still
  1191. remembered on a ring of 16 marks.  So "Point pushed" means point is
  1192. pushed onto the ring of marks and becomes the value of "the mark".
  1193. To go through the ring of marks you type "C-U C-@", or execute the
  1194. .IQ pop-mark
  1195. command.  If you type this enough times you will get back
  1196. to where you started.
  1197. .dc "shell" "(variable)"
  1198. The shell to be used with all the shell commands command.  If your SHELL
  1199. environment variable is set, it is used as the value of
  1200. .IQ shell;
  1201. otherwise "/bin/csh" is the default.
  1202. .dc "shell-command" "C-X !"
  1203. This runs a UNIX command and places the output from that command in a
  1204. buffer.  \s-2JOVE\s0 creates a buffer that matches the name of the command
  1205. you specify and then attaches that buffer to a window.  So, when you
  1206. have only one window running this command will cause \s-2JOVE\s0 to split the
  1207. window and attach the new buffer to that window.  Otherwise, \s-2JOVE\s0
  1208. finds the most convenient of the available windows and uses that one
  1209. instead.  If the buffer already exists it is first emptied, except that if
  1210. it's holding a file, not some output from a previous command, \s-2JOVE\s0
  1211. prints an error message and refuses to execute the command.  If you
  1212. really want to execute the command you should delete that buffer
  1213. (saving it first, if you like) or use
  1214. .IQ shell-command-to-buffer,
  1215. and
  1216. try again.
  1217. .dc "shell-command-to-buffer" "Not Bound"
  1218. This is just like
  1219. .IQ shell-command
  1220. except it lets you specify the
  1221. buffer to use instead of \s-2JOVE\s0.
  1222. .dc "shell-flags" "(variable)"
  1223. This defines the flags that are passed to shell commands.  The default is
  1224. "-c".  See the
  1225. .IQ shell
  1226. variable to change the default shell.
  1227. .dc "show-match-mode" "Not Bound"
  1228. This turns on Show Match mode (or off if it's currently on) in the
  1229. selected buffer.  This changes "}" and ")" so that when they are typed
  1230. the are inserted as usual, and then the cursor flashes back to the
  1231. matching "{" or "(" (depending on what was typed) for about half a
  1232. second, and then goes back to just after the "}" or ")" that invoked
  1233. the command.  This is useful for typing in complicated expressions in
  1234. a program.  You can change how long the cursor sits on the matching
  1235. paren by setting the "paren-flash-delay" variable in tenths of a
  1236. second.  If the matching "{" or "(" isn't visible nothing happens.
  1237. .dc "shrink-window" "Not Bound"
  1238. This makes the current window one line shorter, if possible.  Windows
  1239. must be at least 2 lines high, one for the text and the other for the
  1240. mode line.
  1241. .dc "source" "Not Bound"
  1242. This reads a bunch of \s-2JOVE\s0 commands from a file.  The format of the
  1243. file is the same as that in your initialization file (your ".joverc")
  1244. in your main directory.  There should be one command per line and it
  1245. should be as though you typed "ESC X" while in \s-2JOVE\s0.  For example,
  1246. here's part of my initialization file:
  1247. .DS I
  1248. bind-to-key i-search-reverse ^R
  1249. bind-to-key i-search-forward ^S
  1250. bind-to-key pause-jove ^[S
  1251. .DE
  1252. What they do is make "C-R" call the
  1253. .IQ i-search-reverse
  1254. command and
  1255. "C-S" call
  1256. .IQ i-search-forward
  1257. and "ESC S" call
  1258. .IQ pause-jove.
  1259. .dc "spell-buffer" "Not Bound"
  1260. This runs the current buffer through the UNIX
  1261. .IQ spell
  1262. program and places
  1263. the output in buffer "Spell".  Then \s-2JOVE\s0 lets you edit the list of
  1264. words, expecting you to delete the ones that you don't care about, i.e., the
  1265. ones you know are spelled correctly.  Then the
  1266. .IQ parse-spelling-errors-in-buffer
  1267. command comes along and finds all the
  1268. misspelled words and sets things up so the error commands work.
  1269. .dc "split-current-window" "C-X 2"
  1270. This splits the current window into two equal parts (providing the
  1271. resulting windows would be big enough) and displays the selected
  1272. buffer in both windows.  Use "C-X 1" to go back to 1 window mode.
  1273. .dc "start-remembering" "C-X ("
  1274. This starts remembering your key strokes in the Keyboard macro.  To
  1275. stop remembering you type "C-X )".  Because of a bug in \s-2JOVE\s0 you can't
  1276. stop remembering by typing "ESC X stop-remembering";
  1277. .IQ stop-remembering
  1278. must be bound to "C-X )" in order to make things work correctly.  To
  1279. execute the remembered key strokes you type "C-X E" which runs the
  1280. .IQ execute-keyboard-macro
  1281. command.
  1282. Sometimes you may want a macro to accept different input each time it runs.
  1283. To see how to do this, see the
  1284. .IQ make-macro-interactive
  1285. command.
  1286. .dc "stop-process" "Not Bound"
  1287. This sends a stop signal (C-Z, for most people) to the current process.
  1288. It only works if you have the interactive process feature, and you are
  1289. in a buffer attached to a process.
  1290. .dc "stop-remembering" "C-X )"
  1291. This stop the definition of the keyboard macro.  Because of a bug in
  1292. \s-2JOVE\s0, this must be bound to "C-X )".  Anything else will not work
  1293. properly.
  1294. .dc "string-length" "Not Bound"
  1295. This prints the number of characters in the string that point sits in.
  1296. Strings are surrounded by double quotes.  \s-2JOVE\s0 knows that "\\007" is
  1297. considered a single character, namely "C-G", and also knows about
  1298. other common ones, like "\\r" (Return) and "\\n" (LineFeed).  This is
  1299. mostly useful only for C programmers.
  1300. .dc "suspend-jove" "ESC S"
  1301. This is a synonym for
  1302. .IQ pause-jove.
  1303. .dc "sync-frequency" "(variable)"
  1304. The temporary files used by \s-2JOVE\s0 are forced out to disk every
  1305. .IQ sync-frequency
  1306. modifications.  The default is 50, which really makes
  1307. good sense.  Unless your system is very unstable, you probably
  1308. shouldn't fool with this.
  1309. .dc "tag-file" "(variable)"
  1310. This the name of the file in which \s-2JOVE\s0 should look up tag
  1311. definitions.  The default value is "./tags".
  1312. .dc "text-mode" "Not Bound"
  1313. This sets the major mode to Text.  Currently the other modes are
  1314. Fundamental, C and Lisp mode.
  1315. .dc "transpose-characters" "C-T"
  1316. This switches the character before point with the one after point, and
  1317. then moves forward one.  This doesn't work at the beginning of the
  1318. line, and at the end of the line it switches the two characters before
  1319. point.  Since point is moved forward, so that the character that was
  1320. before point is still before point, you can use "C-T" to drag a
  1321. character down the length of a line.  This command pretty quickly
  1322. becomes very useful.
  1323. .dc "transpose-lines" "C-X C-T"
  1324. This switches the current line with the one above it, and then moves
  1325. down one so that the line that was above point is still above point.
  1326. This, like
  1327. .IQ transpose-characters,
  1328. can be used to drag a line down a page.
  1329. .dc "unbind-key" "Not Bound"
  1330. Use this to unbind
  1331. .IQ any
  1332. key sequence.  You can use this to unbind even a
  1333. prefix command, since this command does not use "key-map completion".  For
  1334. example, "ESC X unbind-key ESC [" unbinds the sequence "ESC [".  This is
  1335. useful for "turning off" something set in the system-wide ".joverc" file.
  1336. .dc "update-time-frequency" "(variable)"
  1337. How often the mode line is updated (and thus the time and load
  1338. average, if you display them).  The default is 30 seconds.
  1339. .dc "use-i/d-char" "(variable)"
  1340. If your terminal has insert/delete character capability you can tell \s-2JOVE\s0
  1341. not to use it by setting this to "off".  In my opinion it is only worth using
  1342. insert/delete character at low baud rates.  WARNING: if you set this to
  1343. "on" when your terminal doesn't have insert/delete character capability,
  1344. you will get weird (perhaps fatal) results.
  1345. .dc "version" "Not Bound"
  1346. Displays the version number of this \s-2JOVE\s0.
  1347. .dc "visible-bell" "(variable)"
  1348. Use the terminal's visible bell instead of beeping.  This is set
  1349. automatically if your terminal has the capability.
  1350. .dc "visible-spaces-in-window" "Not Bound"
  1351. This displays an underscore character instead of each space in the
  1352. window and displays a greater-than followed by spaces for each tab
  1353. in the window.  The actual text in the buffer is not changed; only
  1354. the screen display is affected.  To turn this off you run the command
  1355. again; it toggles.
  1356. .dc "visit-file" "C-X C-V"
  1357. This reads a specified file into the current buffer replacing the old
  1358. text.  If the buffer needs saving \s-2JOVE\s0 will offer to save it for you.
  1359. Sometimes you use this to start over, say if you make lots of changes
  1360. and then change your mind.  If that's the case you don't want \s-2JOVE\s0 to
  1361. save your buffer and you answer "NO" to the question.
  1362. .dc "window-find" "C-X 4"
  1363. This lets you select another buffer in another window three
  1364. different ways.  This waits for another character which can be one of
  1365. the following:
  1366. .DS I
  1367. .ta .5i 1i 1.5i
  1368. T    Finds a tag in the other window.
  1369. F    Finds a file in the other window.
  1370. B    Selects a buffer in the other window.
  1371. .DE
  1372. This is just a convenient short hand for "C-X 2" (or "C-X O" if there are
  1373. already two windows) followed by the appropriate sequence for invoking each
  1374. command.  With this, though, there isn't the extra overhead of having to
  1375. redisplay.  In addition, you don't have to decide whether to type "C-X 2" or
  1376. "C-X O" since "C-X 4" does the right thing.
  1377. .dc "word-abbrev-mode" "Not Bound"
  1378. This turns on Word Abbrev mode (or off if it's currently on) in the
  1379. selected buffer.  Word Abbrev mode lets you specify a word (an
  1380. abbreviation) and a phrase with which \s-2JOVE\s0 should substitute the
  1381. abbreviation.  You can use this to define words to expand into long
  1382. phrases, e.g., "jove" can expand into "Jonathan's Own Version of
  1383. Emacs"; another common use is defining words that you often misspell
  1384. in the same way, e.g., "thier" => "their" or "teh" => "the".  See
  1385. the information on the
  1386. .IQ auto-case-abbrev
  1387. variable.
  1388. .sp 1
  1389. There are two kinds of abbreviations: mode specific and global.  If
  1390. you define a Mode specific abbreviation in C mode, it will expand only
  1391. in buffers that are in C mode.  This is so you can have the same
  1392. abbreviation expand to different things depending on your context.
  1393. Global abbreviations expand regardless of the major mode of the
  1394. buffer.  The way it works is this: \s-2JOVE\s0 looks first in the mode
  1395. specific table, and then in the global table.  Whichever it finds it
  1396. in first is the one that's used in the expansion.  If it doesn't find
  1397. the word it is left untouched.
  1398. \s-2JOVE\s0 tries to expand words as they are typed, when you type a
  1399. punctuation character or Space or Return.  If you are in Auto Fill
  1400. mode the expansion will be filled as if you typed it yourself.
  1401. .dc "wrap-search" "(variable)"
  1402. If set, searches will "wrap around" the ends of the buffer instead
  1403. of stopping at the bottom or top.  The default is "off".
  1404. .dc "write-files-on-make" "(variable)"
  1405. When set, all modified files will be written out before calling
  1406. make when the
  1407. .IQ compile-it
  1408. command is executed.  The default is "on".
  1409. .dc "write-word-abbrev-file" "Not Bound"
  1410. This writes the currently defined abbreviations to a specified file.
  1411. They can be read back in and automatically defined with
  1412. .IQ read-word-abbrev-file.
  1413. .dc "write-file" "C-X C-W"
  1414. This saves the current buffer to a specified file, and then makes that
  1415. file the default file name for this buffer.  If you specify a file
  1416. that already exists you are asked to confirm over-writing it.
  1417. .dc "write-macros-to-file" "Not Bound"
  1418. This writes the currently defined macros to a specified file.  The
  1419. macros can be read back in with
  1420. .IQ read-macros-from-file
  1421. so you can
  1422. define macros and still use them in other instantiations of \s-2JOVE\s0.
  1423. .dc "write-modified-files" "C-X C-M"
  1424. This saves all the buffers that need saving.  If you supply a numeric
  1425. argument it asks for each buffer whether you really want to save it.
  1426. .dc "write-region" "Not Bound"
  1427. This writes the text in the region to a specified file.  If the file
  1428. already exists you are asked to confirm over-writing it.
  1429. .dc "yank" "C-Y"
  1430. This undoes the last kill command.  That is, it inserts the killed
  1431. text at point.  When you do multiple kill commands in a row, they are
  1432. merged so that yanking them back with "C\-Y" yanks back all of them.
  1433. .dc "yank-pop" "ESC Y"
  1434. This yanks back previous killed text.  \s-2JOVE\s0 has a kill ring on which
  1435. the last 10 kills are stored.
  1436. .IQ Yank
  1437. yanks a copy of the text at the
  1438. front of the ring.  If you want one of the last ten kills you use "ESC
  1439. Y" which rotates the ring so another different entry is now at the
  1440. front.  You can use "ESC Y" only immediately following a "C-Y" or
  1441. another "ESC Y".  If you supply a negative numeric argument the ring
  1442. is rotated the other way.  If you use this command enough times in a
  1443. row you will eventually get back to where you started.  Experiment
  1444. with this.  It's extremely useful.
  1445.