![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-10 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / emacs / info|
Return to emacs-10 CVS log | Up to [Apple XNU] / GNUtools / emacs / info |
1.1 ! root 1: This is Info file ../info/emacs, produced by Makeinfo-1.49 from the ! 2: input file emacs.texi. ! 3: ! 4: This file documents the GNU Emacs editor. ! 5: ! 6: Copyright (C) 1985, 1986, 1988, 1992 Richard M. Stallman. ! 7: ! 8: Permission is granted to make and distribute verbatim copies of this ! 9: manual provided the copyright notice and this permission notice are ! 10: preserved on all copies. ! 11: ! 12: Permission is granted to copy and distribute modified versions of ! 13: this manual under the conditions for verbatim copying, provided also ! 14: that the sections entitled "The GNU Manifesto", "Distribution" and "GNU ! 15: General Public License" are included exactly as in the original, and ! 16: provided that the entire resulting derived work is distributed under the ! 17: terms of a permission notice identical to this one. ! 18: ! 19: Permission is granted to copy and distribute translations of this ! 20: manual into another language, under the above conditions for modified ! 21: versions, except that the sections entitled "The GNU Manifesto", ! 22: "Distribution" and "GNU General Public License" may be included in a ! 23: translation approved by the author instead of in the original English. ! 24: ! 25: ! 26: File: emacs, Node: Rmail Motion, Next: Rmail Deletion, Prev: Rmail Scrolling, Up: Rmail ! 27: ! 28: Moving Among Messages ! 29: ===================== ! 30: ! 31: The most basic thing to do with a message is to read it. The way to ! 32: do this in Rmail is to make the message current. You can make any ! 33: message current given its message number using the `j' command, but the ! 34: usual thing to do is to move sequentially through the file, since this ! 35: is the order of receipt of messages. When you enter Rmail, you are ! 36: positioned at the first new message (new messages are those received ! 37: since the previous use of Rmail), or at the last message if there are ! 38: no new messages this time. Move forward to see the other new messages; ! 39: move backward to reexamine old messages. ! 40: ! 41: `n' ! 42: Move to the next nondeleted message, skipping any intervening ! 43: deleted messages (`rmail-next-undeleted-message'). ! 44: ! 45: `p' ! 46: Move to the previous nondeleted message ! 47: (`rmail-previous-undeleted-message'). ! 48: ! 49: `M-n' ! 50: Move to the next message, including deleted messages ! 51: (`rmail-next-message'). ! 52: ! 53: `M-p' ! 54: Move to the previous message, including deleted messages ! 55: (`rmail-previous-message'). ! 56: ! 57: `j' ! 58: Move to the first message. With argument N, move to message ! 59: number N (`rmail-show-message'). ! 60: ! 61: `>' ! 62: Move to the last message (`rmail-last-message'). ! 63: ! 64: `M-s REGEXP RET' ! 65: Move to the next message containing a match for REGEXP ! 66: (`rmail-search'). If REGEXP is empty, the last regexp used is ! 67: used again. ! 68: ! 69: `- M-s REGEXP RET' ! 70: Move to the previous message containing a match for REGEXP. If ! 71: REGEXP is empty, the last regexp used is used again. ! 72: ! 73: `n' and `p' are the usual way of moving among messages in Rmail. ! 74: They move through the messages sequentially, but skip over deleted ! 75: messages, which is usually what you want to do. Their command ! 76: definitions are named `rmail-next-undeleted-message' and ! 77: `rmail-previous-undeleted-message'. If you do not want to skip deleted ! 78: messages--for example, if you want to move to a message to undelete ! 79: it--use the variants `M-n' and `M-p' (`rmail-next-message' and ! 80: `rmail-previous-message'). A numeric argument to any of these commands ! 81: serves as a repeat count. ! 82: ! 83: In Rmail, you can specify a numeric argument by typing the digits. ! 84: It is not necessary to type `C-u' first. ! 85: ! 86: The `M-s' (`rmail-search') command is Rmail's version of search. The ! 87: usual incremental search command `C-s' works in Rmail, but it searches ! 88: only within the current message. The purpose of `M-s' is to search for ! 89: another message. It reads a regular expression (*note Regexps::.) ! 90: nonincrementally, then searches starting at the beginning of the ! 91: following message for a match. The message containing the match is ! 92: selected. ! 93: ! 94: To search backward in the file for another message, give `M-s' a ! 95: negative argument. In Rmail this can be done with `- M-s'. ! 96: ! 97: It is also possible to search for a message based on labels. *Note ! 98: Rmail Labels::. ! 99: ! 100: To move to a message specified by absolute message number, use `j' ! 101: (`rmail-show-message') with the message number as argument. With no ! 102: argument, `j' selects the first message. `>' (`rmail-last-message') ! 103: selects the last message. ! 104: ! 105: Each time Rmail selects a message, it calls (with no arguments) the ! 106: value of the variable `rmail-show-message-hook', if that is non-`nil'. ! 107: ! 108: ! 109: File: emacs, Node: Rmail Deletion, Next: Rmail Inbox, Prev: Rmail Motion, Up: Rmail ! 110: ! 111: Deleting Messages ! 112: ================= ! 113: ! 114: When you no longer need to keep a message, you can "delete" it. This ! 115: flags it as ignorable, and some Rmail commands will pretend it is no ! 116: longer present; but it still has its place in the Rmail file, and still ! 117: has its message number. ! 118: ! 119: "Expunging" the Rmail file actually removes the deleted messages. ! 120: The remaining messages are renumbered consecutively. Expunging is the ! 121: only action that changes the message number of any message, except for ! 122: undigestifying (*note Rmail Digest::.). ! 123: ! 124: `d' ! 125: Delete the current message, and move to the next nondeleted message ! 126: (`rmail-delete-forward'). ! 127: ! 128: `C-d' ! 129: Delete the current message, and move to the previous nondeleted ! 130: message (`rmail-delete-backward'). ! 131: ! 132: `u' ! 133: Undelete the current message, or move back to a deleted message and ! 134: undelete it (`rmail-undelete-previous-message'). ! 135: ! 136: `x' ! 137: `e' ! 138: Expunge the Rmail file (`rmail-expunge'). These two commands are ! 139: synonyms. ! 140: ! 141: There are two Rmail commands for deleting messages. Both delete the ! 142: current message and select another message. `d' ! 143: (`rmail-delete-forward') moves to the following message, skipping ! 144: messages already deleted, while `C-d' (`rmail-delete-backward') moves ! 145: to the previous nondeleted message. If there is no nondeleted message ! 146: to move to in the specified direction, the message that was just ! 147: deleted remains current. ! 148: ! 149: To make all the deleted messages finally vanish from the Rmail file, ! 150: type `e' (`rmail-expunge'). Until you do this, you can still "undelete" ! 151: the deleted messages. ! 152: ! 153: To undelete, type `u' (`rmail-undelete-previous-message'), which is ! 154: designed to cancel the effect of a `d' command (usually). It undeletes ! 155: the current message if the current message is deleted. Otherwise it ! 156: moves backward to previous messages until a deleted message is found, ! 157: and undeletes that message. ! 158: ! 159: You can usually undo a `d' with a `u' because the `u' moves back to ! 160: and undeletes the message that the `d' deleted. But this does not work ! 161: when the `d' skips a few already-deleted messages that follow the ! 162: message being deleted; then the `u' command will undelete the last of ! 163: the messages that were skipped. There is no clean way to avoid this ! 164: problem. However, by repeating the `u' command, you can eventually get ! 165: back to the message that you intended to undelete. You can also reach ! 166: that message with `M-p' commands and then type `u'. ! 167: ! 168: A deleted message has the `deleted' attribute, and as a result ! 169: `deleted' appears in the mode line when the current message is deleted. ! 170: In fact, deleting or undeleting a message is nothing more than adding ! 171: or removing this attribute. *Note Rmail Labels::. ! 172: ! 173: ! 174: File: emacs, Node: Rmail Inbox, Next: Rmail Files, Prev: Rmail Deletion, Up: Rmail ! 175: ! 176: Rmail Files and Inboxes ! 177: ======================= ! 178: ! 179: Unix places incoming mail for you in a file that we call your ! 180: "inbox". When you start up Rmail, it copies the new messages from your ! 181: inbox into your primary mail file, an Rmail file, which also contains ! 182: other messages saved from previous Rmail sessions. It is in this file ! 183: that you actually read the mail with Rmail. This operation is called ! 184: "getting new mail". It can be repeated at any time using the `g' key in ! 185: Rmail. The inbox file name is `/usr/spool/mail/USERNAME' in Berkeley ! 186: Unix, `/usr/mail/USERNAME' in System V. ! 187: ! 188: There are two reasons for having separate Rmail files and inboxes. ! 189: ! 190: 1. The format in which Unix delivers the mail in the inbox is not ! 191: adequate for Rmail mail storage. It has no way to record ! 192: attributes (such as `deleted') or user-specified labels; it has no ! 193: way to record old headers and reformatted headers; it has no way ! 194: to record cached summary line information. ! 195: ! 196: 2. It is very cumbersome to access an inbox file without danger of ! 197: losing mail, because it is necessary to interlock with mail ! 198: delivery. Moreover, different Unix systems use different ! 199: interlocking techniques. The strategy of moving mail out of the ! 200: inbox once and for all into a separate Rmail file avoids the need ! 201: for interlocking in all the rest of Rmail, since only Rmail ! 202: operates on the Rmail file. ! 203: ! 204: When getting new mail, Rmail first copies the new mail from the inbox ! 205: file to the Rmail file; then it saves the Rmail file; then it deletes ! 206: the inbox file. This way, a system crash may cause duplication of mail ! 207: between the inbox and the Rmail file, but cannot lose mail. ! 208: ! 209: Copying mail from an inbox in the system's mailer directory actually ! 210: puts it in an intermediate file `~/.newmail'. This is because the ! 211: interlocking is done by a C program that copies to another file. ! 212: `~/.newmail' is deleted after mail merging is successful. If there is ! 213: a crash at the wrong time, this file will continue to exist and will be ! 214: used as an inbox the next time you get new mail. ! 215: ! 216: ! 217: File: emacs, Node: Rmail Files, Next: Rmail Output, Prev: Rmail Inbox, Up: Rmail ! 218: ! 219: Multiple Mail Files ! 220: =================== ! 221: ! 222: Rmail operates by default on your "primary mail file", which is named ! 223: `~/RMAIL' and receives your incoming mail from your system inbox file. ! 224: But you can also have other mail files and edit them with Rmail. These ! 225: files can receive mail through their own inboxes, or you can move ! 226: messages into them by explicit command in Rmail (*note Rmail Output::.). ! 227: ! 228: `i FILE RET' ! 229: Read FILE into Emacs and run Rmail on it (`rmail-input'). ! 230: ! 231: `M-x set-rmail-inbox-list RET FILES RET' ! 232: Specify inbox file names for current Rmail file to get mail from. ! 233: ! 234: `g' ! 235: Merge new mail from current Rmail file's inboxes ! 236: (`rmail-get-new-mail'). ! 237: ! 238: `C-u g FILE' ! 239: Merge new mail from inbox file FILE. ! 240: ! 241: To run Rmail on a file other than your primary mail file, you may ! 242: use the `i' (`rmail-input') command in Rmail. This visits the file, ! 243: puts it in Rmail mode, and then gets new mail from the file's inboxes ! 244: if any. You can also use `M-x rmail-input' even when not in Rmail. ! 245: ! 246: The file you read with `i' does not have to be in Rmail file format. ! 247: It could also be Unix mail format, or `mmdf' format; or it could be a ! 248: mixture of all three, as long as each message belongs to one of the ! 249: three formats. Rmail recognizes all three and converts all the ! 250: messages to proper Rmail format before showing you the file. ! 251: ! 252: Each Rmail file can contain a list of inbox file names; you can ! 253: specify this list with `M-x set-rmail-inbox-list RET FILES RET'. The ! 254: argument can contain any number of file names, separated by commas. It ! 255: can also be empty, which specifies that this file should have no ! 256: inboxes. Once a list of inboxes is specified, the Rmail file remembers ! 257: it permanently until it is explicitly changed. ! 258: ! 259: If an Rmail file has inboxes, new mail is merged in from the inboxes ! 260: when the Rmail file is brought into Rmail, and when the `g' ! 261: (`rmail-get-new-mail') command is used. If the Rmail file specifies no ! 262: inboxes, then no new mail is merged in at these times. A special ! 263: exception is made for your primary mail file in using the standard ! 264: system inbox for it if it does not specify any. ! 265: ! 266: To merge mail from a file that is not the usual inbox, give the `g' ! 267: key a numeric argument, as in `C-u g'. Then it reads a file name and ! 268: merges mail from that file. The inbox file is not deleted or changed in ! 269: any way when `g' with an argument is used. This is, therefore, a ! 270: general way of merging one file of messages into another. ! 271: ! 272: ! 273: File: emacs, Node: Rmail Output, Next: Rmail Labels, Prev: Rmail Files, Up: Rmail ! 274: ! 275: Copying Messages Out to Files ! 276: ============================= ! 277: ! 278: `o FILE RET' ! 279: Append a copy of the current message to the file FILE, writing it ! 280: in Rmail file format (`rmail-output-to-rmail-file'). ! 281: ! 282: `C-o FILE RET' ! 283: Append a copy of the current message to the file FILE, writing it ! 284: in Unix mail file format (`rmail-output'). ! 285: ! 286: If an Rmail file has no inboxes, how does it get anything in it? By ! 287: explicit `o' commands. ! 288: ! 289: `o' (`rmail-output-to-rmail-file') appends the current message in ! 290: Rmail format to the end of the specified file. This is the best command ! 291: to use to move messages between Rmail files. If the other Rmail file is ! 292: currently visited, the copying is done into the other file's Emacs ! 293: buffer instead. You should eventually save it on disk. ! 294: ! 295: The `C-o' (`rmail-output') command in Rmail appends a copy of the ! 296: current message to a specified file, in Unix mail file format. This is ! 297: useful for moving messages into files to be read by other mail ! 298: processors that do not understand Rmail format. ! 299: ! 300: Copying a message with `o' or `C-o' gives the original copy of the ! 301: message the `filed' attribute, so that `filed' appears in the mode line ! 302: when such a message is current. ! 303: ! 304: Normally you should use only `o' to output messages to other Rmail ! 305: files, never `C-o'. But it is also safe if you always use `C-o', never ! 306: `o'. When a file is visited in Rmail, the last message is checked, and ! 307: if it is in Unix format, the entire file is scanned and all Unix-format ! 308: messages are converted to Rmail format. (The reason for checking the ! 309: last message is that scanning the file is slow and most Rmail files ! 310: have only Rmail format messages.) If you use `C-o' consistently, the ! 311: last message is sure to be in Unix format, so Rmail will convert all ! 312: messages properly. ! 313: ! 314: The case where you might want to use `C-o' always, instead of `o' ! 315: always, is when you or other users want to append mail to the same file ! 316: from other mail processors. Other mail processors probably do not know ! 317: Rmail format but do know Unix format. ! 318: ! 319: In any case, always use `o' to add to an Rmail file that is being ! 320: visited in Rmail. Adding messages with `C-o' to the actual disk file ! 321: will trigger a "simultaneous editing" warning when you ask to save the ! 322: Emacs buffer, and will be lost if you do save. ! 323: ! 324: ! 325: File: emacs, Node: Rmail Labels, Next: Rmail Summary, Prev: Rmail Output, Up: Rmail ! 326: ! 327: Labels ! 328: ====== ! 329: ! 330: Each message can have various "labels" assigned to it as a means of ! 331: classification. A label has a name; different names mean different ! 332: labels. Any given label is either present or absent on a particular ! 333: message. A few label names have standard meanings and are given to ! 334: messages automatically by Rmail when appropriate; these special labels ! 335: are called "attributes". All other labels are assigned by the user. ! 336: ! 337: `a LABEL RET' ! 338: Assign the label LABEL to the current message (`rmail-add-label'). ! 339: ! 340: `k LABEL RET' ! 341: Remove the label LABEL from the current message ! 342: (`rmail-kill-label'). ! 343: ! 344: `C-M-n LABELS RET' ! 345: Move to the next message that has one of the labels LABELS ! 346: (`rmail-next-labeled-message'). ! 347: ! 348: `C-M-p LABELS RET' ! 349: Move to the previous message that has one of the labels LABELS ! 350: (`rmail-previous-labeled-message'). ! 351: ! 352: `C-M-l LABELS RET' ! 353: Make a summary of all messages containing any of the labels LABELS ! 354: (`rmail-summary-by-labels'). ! 355: ! 356: Specifying an empty string for one these commands means to use the last ! 357: label specified for any of these commands. ! 358: ! 359: The `a' (`rmail-add-label') and `k' (`rmail-kill-label') commands ! 360: allow you to assign or remove any label on the current message. If the ! 361: LABEL argument is empty, it means to assign or remove the same label ! 362: most recently assigned or removed. ! 363: ! 364: Once you have given messages labels to classify them as you wish, ! 365: there are two ways to use the labels: in moving and in summaries. ! 366: ! 367: The command `C-M-n LABELS RET' (`rmail-next-labeled-message') moves ! 368: to the next message that has one of the labels LABELS. LABELS is one ! 369: or more label names, separated by commas. `C-M-p' ! 370: (`rmail-previous-labeled-message') is similar, but moves backwards to ! 371: previous messages. A preceding numeric argument to either one serves ! 372: as a repeat count. ! 373: ! 374: The command `C-M-l LABELS RET' (`rmail-summary-by-labels') displays ! 375: a summary containing only the messages that have at least one of a ! 376: specified set of messages. The argument LABELS is one or more label ! 377: names, separated by commas. *Note Rmail Summary::, for information on ! 378: summaries. ! 379: ! 380: If the LABELS argument to `C-M-n', `C-M-p' or `C-M-l' is empty, it ! 381: means to use the last set of labels specified for any of these commands. ! 382: ! 383: Some labels such as `deleted' and `filed' have built-in meanings and ! 384: are assigned to or removed from messages automatically at appropriate ! 385: times; these labels are called "attributes". Here is a list of Rmail ! 386: attributes: ! 387: ! 388: `unseen' ! 389: Means the message has never been current. Assigned to messages ! 390: when they come from an inbox file, and removed when a message is ! 391: made current. ! 392: ! 393: `deleted' ! 394: Means the message is deleted. Assigned by deletion commands and ! 395: removed by undeletion commands (*note Rmail Deletion::.). ! 396: ! 397: `filed' ! 398: Means the message has been copied to some other file. Assigned by ! 399: the file output commands (*note Rmail Files::.). ! 400: ! 401: `answered' ! 402: Means you have mailed an answer to the message. Assigned by the ! 403: `r' command (`rmail-reply'). *Note Rmail Reply::. ! 404: ! 405: `forwarded' ! 406: Means you have forwarded the message to other users. Assigned by ! 407: the `f' command (`rmail-forward'). *Note Rmail Reply::. ! 408: ! 409: `edited' ! 410: Means you have edited the text of the message within Rmail. *Note ! 411: Rmail Editing::. ! 412: ! 413: All other labels are assigned or removed only by the user, and it is ! 414: up to the user to decide what they mean. ! 415: ! 416: ! 417: File: emacs, Node: Rmail Summary, Next: Rmail Reply, Prev: Rmail Labels, Up: Rmail ! 418: ! 419: Summaries ! 420: ========= ! 421: ! 422: A "summary" is a buffer containing one line per message that Rmail ! 423: can make and display to give you an overview of the mail in an Rmail ! 424: file. Each line shows the message number, the sender, the labels, and ! 425: the subject. When the summary buffer is selected, various commands can ! 426: be used to select messages by moving in the summary buffer, or delete ! 427: or undelete messages. ! 428: ! 429: A summary buffer applies to a single Rmail file only; if you are ! 430: editing multiple Rmail files, they have separate summary buffers. The ! 431: summary buffer name is made by appending `-summary' to the Rmail ! 432: buffer's name. Only one summary buffer will be displayed at a time ! 433: unless you make several windows and select the summary buffers by hand. ! 434: ! 435: * Menu: ! 436: ! 437: * Rmail Make Summary:: Making various sorts of summaries. ! 438: * Rmail Summary Edit:: Manipulating messages from the summary. ! 439: ! 440: ! 441: File: emacs, Node: Rmail Make Summary, Next: Rmail Summary Edit, Prev: Rmail Summary, Up: Rmail Summary ! 442: ! 443: Making Summaries ! 444: ---------------- ! 445: ! 446: Here are the commands to create a summary for the current Rmail file. ! 447: Summaries do not update automatically; to make an updated summary, you ! 448: must use one of these commands again. ! 449: ! 450: `h' ! 451: `C-M-h' ! 452: Summarize all messages (`rmail-summary'). ! 453: ! 454: `l LABELS RET' ! 455: `C-M-l LABELS RET' ! 456: Summarize message that have one or more of the specified labels ! 457: (`rmail-summary-by-labels'). ! 458: ! 459: `C-M-r RCPTS RET' ! 460: Summarize messages that have one or more of the specified ! 461: recipients (`rmail-summary-by-recipients'). ! 462: ! 463: The `h' or `C-M-h' (`rmail-summary') command fills the summary buffer ! 464: for the current Rmail file with a summary of all the messages in the ! 465: file. It then displays and selects the summary buffer in another window. ! 466: ! 467: `C-M-l LABELS RET' (`rmail-summary-by-labels') makes a partial ! 468: summary mentioning only the messages that have one or more of the ! 469: labels LABELS. LABELS should contain label names separated by commas. ! 470: ! 471: `C-M-r RCPTS RET' (`rmail-summary-by-recipients') makes a partial ! 472: summary mentioning only the messages that have one or more of the ! 473: recipients RCPTS. RCPTS should contain mailing addresses separated by ! 474: commas. ! 475: ! 476: Note that there is only one summary buffer for any Rmail file; ! 477: making one kind of summary discards any previously made summary. ! 478: ! 479: ! 480: File: emacs, Node: Rmail Summary Edit, Prev: Rmail Make Summary, Up: Rmail Summary ! 481: ! 482: Editing in Summaries ! 483: -------------------- ! 484: ! 485: Summary buffers are given the major mode Rmail Summary mode, which ! 486: provides the following special commands: ! 487: ! 488: `j' ! 489: Select the message described by the line that point is on ! 490: (`rmail-summary-goto-msg'). ! 491: ! 492: `C-n' ! 493: Move to next line and select its message in Rmail ! 494: (`rmail-summary-next-all'). ! 495: ! 496: `C-p' ! 497: Move to previous line and select its message ! 498: (`rmail-summary-previous-all'). ! 499: ! 500: `n' ! 501: Move to next line, skipping lines saying `deleted', and select its ! 502: message (`rmail-summary-next-msg'). ! 503: ! 504: `p' ! 505: Move to previous line, skipping lines saying `deleted', and select ! 506: its message (`rmail-summary-previous-msg'). ! 507: ! 508: `d' ! 509: Delete the current line's message, then do like `n' ! 510: (`rmail-summary-delete-forward'). ! 511: ! 512: `u' ! 513: Undelete and select this message or the previous deleted message in ! 514: the summary (`rmail-summary-undelete'). ! 515: ! 516: `SPC' ! 517: Scroll the other window (presumably Rmail) forward ! 518: (`rmail-summary-scroll-msg-up'). ! 519: ! 520: `DEL' ! 521: Scroll the other window backward (`rmail-summary-scroll-msg-down'). ! 522: ! 523: `x' ! 524: Kill the summary window (`rmail-summary-exit'). ! 525: ! 526: `q' ! 527: Exit Rmail (`rmail-summary-quit'). ! 528: ! 529: The keys `C-n' and `C-p' are modified in Rmail Summary mode so that ! 530: in addition to moving point in the summary buffer they also cause the ! 531: line's message to become current in the associated Rmail buffer. That ! 532: buffer is also made visible in another window if it is not already so. ! 533: ! 534: `n' and `p' are similar to `C-n' and `C-p', but skip lines that say ! 535: `message deleted'. They are like the `n' and `p' keys of Rmail itself. ! 536: Note, however, that in a partial summary these commands move only ! 537: among the message listed in the summary. ! 538: ! 539: The other Emacs cursor motion commands are not changed in Rmail ! 540: Summary mode, so it is easy to get the point on a line whose message is ! 541: not selected in Rmail. This can also happen if you switch to the Rmail ! 542: window and switch messages there. To get the Rmail buffer back in sync ! 543: with the summary, use the `j' (`rmail-summary-goto-msg') command, which ! 544: selects in Rmail the message of the current summary line. ! 545: ! 546: Deletion and undeletion can also be done from the summary buffer. ! 547: They always work based on where point is located in the summary buffer, ! 548: ignoring which message is selected in Rmail. `d' ! 549: (`rmail-summary-delete-forward') deletes the current line's message, ! 550: then moves to the next line whose message is not deleted and selects ! 551: that message. The inverse of this is `u' (`rmail-summary-undelete'), ! 552: which moves back (if necessary) to a line whose message is deleted, ! 553: undeletes that message, and selects it in Rmail. ! 554: ! 555: When moving through messages with the summary buffer, it is ! 556: convenient to be able to scroll the message while remaining in the ! 557: summary window. The commands SPC (`rmail-summary-scroll-msg-up') and DEL ! 558: (`rmail-summary-scroll-msg-down') do this. They scroll the message just ! 559: as those same keys do when the Rmail buffer is selected. ! 560: ! 561: When you are finished using the summary, type `x' ! 562: (`rmail-summary-exit') to kill the summary buffer's window. ! 563: ! 564: You can also exit Rmail while in the summary. `q' ! 565: (`rmail-summary-quit') kills the summary window, then saves the Rmail ! 566: file and switches to another buffer. ! 567: ! 568: ! 569: File: emacs, Node: Rmail Reply, Next: Rmail Editing, Prev: Rmail Summary, Up: Rmail ! 570: ! 571: Sending Replies ! 572: =============== ! 573: ! 574: Rmail has several commands that use Mail mode to send outgoing mail. ! 575: *Note Sending Mail::, for information on using Mail mode. What are ! 576: documented here are the special commands of Rmail for entering Mail ! 577: mode. Note that the usual keys for sending mail, `C-x m' and `C-x 4 m', ! 578: are available in Rmail mode and work just as they usually do. ! 579: ! 580: `m' ! 581: Send a message (`rmail-mail'). ! 582: ! 583: `c' ! 584: Continue editing already started outgoing message ! 585: (`rmail-continue'). ! 586: ! 587: `r' ! 588: Send a reply to the current Rmail message (`rmail-reply'). ! 589: ! 590: `f' ! 591: Forward current message to other users (`rmail-forward'). ! 592: ! 593: The most common reason to send a message while in Rmail is to reply ! 594: to the message you are reading. To do this, type `r' (`rmail-reply'). ! 595: This displays the `*mail*' buffer in another window, much like `C-x 4 ! 596: m', but preinitializes the `Subject', `To', `CC' and `In-reply-to' ! 597: header fields based on the message being replied to. The `To' field is ! 598: given the sender of that message, and the `CC' gets all the recipients ! 599: of that message (but recipients that match elements of the list ! 600: `rmail-dont-reply-to' are omitted; by default, this list contains your ! 601: own mailing address). ! 602: ! 603: If you don't want to include the other recipients in the `cc' field, ! 604: you can use a prefix argument to the `r' command. In Rmail, you can do ! 605: this with `1 r'. ! 606: ! 607: Once you have initialized the `*mail*' buffer this way, sending the ! 608: mail goes as usual (*note Sending Mail::.). You can edit the ! 609: presupplied header fields if they are not right for you. ! 610: ! 611: One additional Mail mode command is available when mailing is invoked ! 612: from Rmail: `C-c C-y' (`mail-yank-original') inserts into the outgoing ! 613: message a copy of the current Rmail message; normally this is the ! 614: message you are replying to, but you can also switch to the Rmail ! 615: buffer, select a different message, switch back, and yank new current ! 616: message. Normally the yanked message is indented four spaces and has ! 617: most header fields deleted from it; an argument to `C-c C-y' specifies ! 618: the amount to indent, and `C-u C-c C-y' does not indent at all and does ! 619: not delete any header fields. ! 620: ! 621: Another frequent reason to send mail in Rmail is to forward the ! 622: current message to other users. `f' (`rmail-forward') makes this easy ! 623: by preinitializing the `*mail*' buffer with the current message as the ! 624: text, and a subject designating a forwarded message. All you have to ! 625: do is fill in the recipients and send. ! 626: ! 627: The `m' (`rmail-mail') command is used to start editing an outgoing ! 628: message that is not a reply. It leaves the header fields empty. Its ! 629: only difference from `C-x 4 m' is that it makes the Rmail buffer ! 630: accessible for `C-c y', just as `r' does. Thus, `m' can be used to ! 631: reply to or forward a message; it can do anything `r' or `f' can do. ! 632: ! 633: The `c' (`rmail-continue') command resumes editing the `*mail*' ! 634: buffer, to finish editing an outgoing message you were already ! 635: composing, or to alter a message you have sent. ! 636: ! 637: ! 638: File: emacs, Node: Rmail Editing, Next: Rmail Digest, Prev: Rmail Reply, Up: Rmail ! 639: ! 640: Editing Within a Message ! 641: ======================== ! 642: ! 643: Rmail mode provides a few special commands for moving within and ! 644: editing the current message. In addition, the usual Emacs commands are ! 645: available (except for a few, such as `C-M-n' and `C-M-h', that are ! 646: redefined by Rmail for other purposes). However, the Rmail buffer is ! 647: normally read-only, and to alter it you must use the Rmail command `w' ! 648: described below. ! 649: ! 650: `t' ! 651: Toggle display of original headers (`rmail-toggle-headers'). ! 652: ! 653: `w' ! 654: Edit current message (`rmail-edit-current-message'). ! 655: ! 656: Rmail reformats the header of each message before displaying it. ! 657: Normally this involves deleting most header fields, on the grounds that ! 658: they are not interesting. The variable `rmail-ignored-headers' should ! 659: contain a regexp that matches the header fields to discard in this way. ! 660: The original headers are saved permanently, and to see what they look ! 661: like, use the `t' (`rmail-toggle-headers') command. This discards the ! 662: reformatted headers of the current message and displays it with the ! 663: original headers. Repeating `t' reformats the message again. Selecting ! 664: the message again also reformats. ! 665: ! 666: The Rmail buffer is normally read-only, and most of the characters ! 667: you would type to modify it (including most letters) are redefined as ! 668: Rmail commands. This is usually not a problem since it is rare to want ! 669: to change the text of a message. When you do want to do this, the way ! 670: is to type `w' (`rmail-edit-current-message'), which changes from Rmail ! 671: mode into Rmail Edit mode, another major mode which is nearly the same ! 672: as Text mode. The mode line illustrates this change. ! 673: ! 674: In Rmail Edit mode, letters insert themselves as usual and the Rmail ! 675: commands are not available. When you are finished editing the message ! 676: and are ready to go back to Rmail, type `C-c C-c', which switches back ! 677: to Rmail mode. Alternatively, you can return to Rmail mode but cancel ! 678: all the editing that you have done by typing `C-c C-]'. ! 679: ! 680: Entering Rmail Edit mode calls with no arguments the value of the ! 681: variable `text-mode-hook', if that value exists and is not `nil'; then ! 682: it does the same with the variable `rmail-edit-mode-hook'. It adds the ! 683: attribute `edited' to the message. ! 684: ! 685: ! 686: File: emacs, Node: Rmail Digest, Prev: Rmail Editing, Up: Rmail ! 687: ! 688: Digest Messages ! 689: =============== ! 690: ! 691: A "digest message" is a message which exists to contain and carry ! 692: several other messages. Digests are used on moderated mailing lists; ! 693: all the messages that arrive for the list during a period of time such ! 694: as one day are put inside a single digest which is then sent to the ! 695: subscribers. Transmitting the single digest uses much less computer ! 696: time than transmitting the individual messages even though the total ! 697: size is the same, because the per-message overhead in network mail ! 698: transmission is considerable. ! 699: ! 700: When you receive a digest message, the most convenient way to read ! 701: it is to "undigestify" it: to turn it back into many individual ! 702: messages. Then you can read and delete the individual messages as it ! 703: suits you. ! 704: ! 705: To undigestify a message, select it and then type `M-x ! 706: undigestify-rmail-message'. This copies each submessage as a separate ! 707: Rmail message and inserts them all following the digest. The digest ! 708: message itself is flagged as deleted. ! 709: ! 710: ! 711: File: emacs, Node: Recursive Edit, Next: Narrowing, Prev: Rmail, Up: Top ! 712: ! 713: Recursive Editing Levels ! 714: ======================== ! 715: ! 716: A "recursive edit" is a situation in which you are using Emacs ! 717: commands to perform arbitrary editing while in the middle of another ! 718: Emacs command. For example, when you type `C-r' inside of a ! 719: `query-replace', you enter a recursive edit in which you can change the ! 720: current buffer. On exiting from the recursive edit, you go back to the ! 721: `query-replace'. ! 722: ! 723: "Exiting" the recursive edit means returning to the unfinished ! 724: command, which continues execution. For example, exiting the recursive ! 725: edit requested by `C-r' in `query-replace' causes query replacing to ! 726: resume. Exiting is done with `C-M-c' (`exit-recursive-edit'). ! 727: ! 728: You can also "abort" the recursive edit. This is like exiting, but ! 729: also quits the unfinished command immediately. Use the command `C-]' ! 730: (`abort-recursive-edit') for this. *Note Quitting::. ! 731: ! 732: The mode line shows you when you are in a recursive edit by ! 733: displaying square brackets around the parentheses that always surround ! 734: the major and minor mode names. Every window's mode line shows this, ! 735: in the same way, since being in a recursive edit is true of Emacs as a ! 736: whole rather than any particular buffer. ! 737: ! 738: It is possible to be in recursive edits within recursive edits. For ! 739: example, after typing `C-r' in a `query-replace', you might type a ! 740: command that entered the debugger. In such circumstances, two or more ! 741: sets of square brackets appear in the mode line. Exiting the inner ! 742: recursive edit (such as, with the debugger `c' command) would resume ! 743: the command where it called the debugger. After the end of this ! 744: command, you would be able to exit the first recursive edit. Aborting ! 745: also gets out of only one level of recursive edit; it returns ! 746: immediately to the command level of the previous recursive edit. So ! 747: you could immediately abort that one too. ! 748: ! 749: Alternatively, the command `M-x top-level' aborts all levels of ! 750: recursive edits, returning immediately to the top level command reader. ! 751: ! 752: The text being edited inside the recursive edit need not be the same ! 753: text that you were editing at top level. It depends on what the ! 754: recursive edit is for. If the command that invokes the recursive edit ! 755: selects a different buffer first, that is the buffer you will edit ! 756: recursively. In any case, you can switch buffers within the recursive ! 757: edit in the normal manner (as long as the buffer-switching keys have ! 758: not been rebound). You could probably do all the rest of your editing ! 759: inside the recursive edit, visiting files and all. But this could have ! 760: surprising effects (such as stack overflow) from time to time. So ! 761: remember to exit or abort the recursive edit when you no longer need it. ! 762: ! 763: In general, GNU Emacs tries to avoid using recursive edits. It is ! 764: usually preferable to allow the user to switch among the possible ! 765: editing modes in any order he likes. With recursive edits, the only ! 766: way to get to another state is to go "back" to the state that the ! 767: recursive edit was invoked from. ! 768: ! 769: ! 770: File: emacs, Node: Narrowing, Next: Sorting, Prev: Recursive Edit, Up: Top ! 771: ! 772: Narrowing ! 773: ========= ! 774: ! 775: "Narrowing" means focusing in on some portion of the buffer, making ! 776: the rest temporarily invisible and inaccessible. Cancelling the ! 777: narrowing, and making the entire buffer once again visible, is called ! 778: "widening". The amount of narrowing in effect in a buffer at any time ! 779: is called the buffer's "restriction". ! 780: ! 781: `C-x n' ! 782: Narrow down to between point and mark (`narrow-to-region'). ! 783: ! 784: `C-x w' ! 785: Widen to make the entire buffer visible again (`widen'). ! 786: ! 787: When you have narrowed down to a part of the buffer, that part ! 788: appears to be all there is. You can't see the rest, you can't move ! 789: into it (motion commands won't go outside the visible part), you can't ! 790: change it in any way. However, it is not gone, and if you save the ! 791: file all the invisible text will be saved. In addition to sometimes ! 792: making it easier to concentrate on a single subroutine or paragraph by ! 793: eliminating clutter, narrowing can be used to restrict the range of ! 794: operation of a replace command or repeating keyboard macro. The word ! 795: `Narrow' appears in the mode line whenever narrowing is in effect. ! 796: ! 797: The primary narrowing command is `C-x n' (`narrow-to-region'). It ! 798: sets the current buffer's restrictions so that the text in the current ! 799: region remains visible but all text before the region or after the ! 800: region is invisible. Point and mark do not change. ! 801: ! 802: Because narrowing can easily confuse users who do not understand it, ! 803: `narrow-to-region' is normally a disabled command. Attempting to use ! 804: this command asks for confirmation and gives you the option of enabling ! 805: it; once you enable the command, confirmation will no longer be ! 806: required for it. *Note Disabling::. ! 807: ! 808: The way to undo narrowing is to widen with `C-x w' (`widen'). This ! 809: makes all text in the buffer accessible again. ! 810: ! 811: You can get information on what part of the buffer you are narrowed ! 812: down to using the `C-x =' command. *Note Position Info::. ! 813: ! 814: ! 815: File: emacs, Node: Sorting, Next: Shell, Prev: Narrowing, Up: Top ! 816: ! 817: Sorting Text ! 818: ============ ! 819: ! 820: Emacs provides several commands for sorting text in the buffer. All ! 821: operate on the contents of the region (the text between point and the ! 822: mark). They divide the text of the region into many "sort records", ! 823: identify a "sort key" for each record, and then reorder the records ! 824: into the order determined by the sort keys. The records are ordered so ! 825: that their keys are in alphabetical order, or, for numeric sorting, in ! 826: numeric order. In alphabetic sorting, all upper case letters `A' ! 827: through `Z' come before lower case `a', in accord with the ASCII ! 828: character sequence. ! 829: ! 830: The various sort commands differ in how they divide the text into ! 831: sort records and in which part of each record is used as the sort key. ! 832: Most of the commands make each line a separate sort record, but some ! 833: commands use paragraphs or pages as sort records. Most of the sort ! 834: commands use each entire sort record as its own sort key, but some use ! 835: only a portion of the record as the sort key. ! 836: ! 837: `M-x sort-lines' ! 838: Divide the region into lines, and sort by comparing the entire ! 839: text of a line. A prefix argument means sort into descending ! 840: order. ! 841: ! 842: `M-x sort-paragraphs' ! 843: Divide the region into paragraphs, and sort by comparing the entire ! 844: text of a paragraph (except for leading blank lines). A prefix ! 845: argument means sort into descending order. ! 846: ! 847: `M-x sort-pages' ! 848: Divide the region into pages, and sort by comparing the entire ! 849: text of a page (except for leading blank lines). A prefix ! 850: argument means sort into descending order. ! 851: ! 852: `M-x sort-fields' ! 853: Divide the region into lines, and sort by comparing the contents of ! 854: one field in each line. Fields are defined as separated by ! 855: whitespace, so the first run of consecutive non-whitespace ! 856: characters in a line constitutes field 1, the second such run ! 857: constitutes field 2, etc. ! 858: ! 859: You specify which field to sort by with a numeric argument: 1 to ! 860: sort by field 1, etc. A negative argument means sort into ! 861: descending order. Thus, minus 2 means sort by field 2 in ! 862: reverse-alphabetical order. ! 863: ! 864: If two lines are equal in the field being compared, their relative ! 865: order in the text is not changed. This enables you to sort by ! 866: multiple keys: sort first by the least significant key, then by ! 867: the next-to-least key, and so on, ending with the most important ! 868: key. ! 869: ! 870: `M-x sort-numeric-fields' ! 871: Like `M-x sort-fields' except the specified field is converted to ! 872: a number for each line, and the numbers are compared. `10' comes ! 873: before `2' when considered as text, but after it when considered ! 874: as a number. ! 875: ! 876: `M-x sort-columns' ! 877: Like `M-x sort-fields' except that the text within each line used ! 878: for comparison comes from a fixed range of columns. See below for ! 879: an explanation. ! 880: ! 881: For example, if the buffer contains ! 882: ! 883: On systems where clash detection (locking of files being edited) is ! 884: implemented, Emacs also checks the first time you modify a buffer ! 885: whether the file has changed on disk since it was last visited or ! 886: saved. If it has, you are asked to confirm that you want to change ! 887: the buffer. ! 888: ! 889: then if you apply `M-x sort-lines' to the entire buffer you get ! 890: ! 891: On systems where clash detection (locking of files being edited) is ! 892: implemented, Emacs also checks the first time you modify a buffer ! 893: saved. If it has, you are asked to confirm that you want to change ! 894: the buffer. ! 895: whether the file has changed on disk since it was last visited or ! 896: ! 897: where the upper case `O' comes before all lower case letters. If you ! 898: apply instead `C-u 2 M-x sort-fields' you get ! 899: ! 900: implemented, Emacs also checks the first time you modify a buffer ! 901: saved. If it has, you are asked to confirm that you want to change ! 902: the buffer. ! 903: On systems where clash detection (locking of files being edited) is ! 904: whether the file has changed on disk since it was last visited or ! 905: ! 906: where the sort keys were `Emacs', `If', `buffer', `systems' and `the'. ! 907: ! 908: `M-x sort-columns' requires more explanation. You specify the ! 909: columns by putting point at one of the columns and the mark at the other ! 910: column. Because this means you cannot put point or the mark at the ! 911: beginning of the first line to sort, this command uses an unusual ! 912: definition of `region': all of the line point is in is considered part ! 913: of the region, and so is all of the line the mark is in. ! 914: ! 915: For example, to sort a table by information found in columns 10 to ! 916: 15, you could put the mark on column 10 in the first line of the table, ! 917: and point on column 15 in the last line of the table, and then use this ! 918: command. Or you could put the mark on column 15 in the first line and ! 919: point on column 10 in the last line. ! 920: ! 921: This can be thought of as sorting the rectangle specified by point ! 922: and the mark, except that the text on each line to the left or right of ! 923: the rectangle moves along with the text inside the rectangle. *Note ! 924: Rectangles::. ! 925: ! 926: ! 927: File: emacs, Node: Shell, Next: Hardcopy, Prev: Sorting, Up: Top ! 928: ! 929: Running Shell Commands from Emacs ! 930: ================================= ! 931: ! 932: Emacs has commands for passing single command lines to inferior shell ! 933: processes; it can also run a shell interactively with input and output ! 934: to an Emacs buffer `*shell*'. ! 935: ! 936: `M-!' ! 937: Run a specified shell command line and display the output ! 938: (`shell-command'). ! 939: ! 940: `M-|' ! 941: Run a specified shell command line with region contents as input; ! 942: optionally replace the region with the output ! 943: (`shell-command-on-region'). ! 944: ! 945: `M-x shell' ! 946: Run a subshell with input and output through an Emacs buffer. You ! 947: can then give commands interactively. ! 948: ! 949: * Menu: ! 950: ! 951: * Single Shell:: How to run one shell command and return. ! 952: * Interactive Shell:: Permanent shell taking input via Emacs. ! 953: * Shell Mode:: Special Emacs commands used with permanent shell. ! 954: ! 955: ! 956: File: emacs, Node: Single Shell, Next: Interactive Shell, Prev: Shell, Up: Shell ! 957: ! 958: Single Shell Commands ! 959: --------------------- ! 960: ! 961: `M-!' (`shell-command') reads a line of text using the minibuffer ! 962: and creates an inferior shell to execute the line as a command. ! 963: Standard input from the command comes from the null device. If the ! 964: shell command produces any output, the output goes into an Emacs buffer ! 965: named `*Shell Command Output*', which is displayed in another window ! 966: but not selected. A numeric argument, as in `M-1 M-!', directs this ! 967: command to insert any output into the current buffer. In that case, ! 968: point is left before the output and the mark is set after the output. ! 969: ! 970: `M-|' (`shell-command-on-region') is like `M-!' but passes the ! 971: contents of the region as input to the shell command, instead of no ! 972: input. If a numeric argument is used, meaning insert output in the ! 973: current buffer, then the old region is deleted first and the output ! 974: replaces it as the contents of the region. ! 975: ! 976: Both `M-!' and `M-|' use `shell-file-name' to specify the shell to ! 977: use. This variable is initialized based on your `SHELL' environment ! 978: variable when Emacs is started. If the file name does not specify a ! 979: directory, the directories in the list `exec-path' are searched; this ! 980: list is initialized based on the environment variable `PATH' when Emacs ! 981: is started. Your `.emacs' file can override either or both of these ! 982: default initializations. ! 983: ! 984: With `M-!' and `M-|', Emacs has to wait until the shell command ! 985: completes. You can quit with `C-g'; that terminates the shell command. ! 986: ! 987: ! 988: File: emacs, Node: Interactive Shell, Next: Shell Mode, Prev: Single Shell, Up: Shell ! 989: ! 990: Interactive Inferior Shell ! 991: -------------------------- ! 992: ! 993: To run a subshell interactively, putting its typescript in an Emacs ! 994: buffer, use `M-x shell'. This creates (or reuses) a buffer named ! 995: `*shell*' and runs a subshell with input coming from and output going ! 996: to that buffer. That is to say, any "terminal output" from the subshell ! 997: will go into the buffer, advancing point, and any "terminal input" for ! 998: the subshell comes from text in the buffer. To give input to the ! 999: subshell, go to the end of the buffer and type the input, terminated by ! 1000: RET. ! 1001: ! 1002: Emacs does not wait for the subshell to do anything. You can switch ! 1003: windows or buffers and edit them while the shell is waiting, or while ! 1004: it is running a command. Output from the subshell waits until Emacs ! 1005: has time to process it; this happens whenever Emacs is waiting for ! 1006: keyboard input or for time to elapse. ! 1007: ! 1008: If you would like multiple subshells, change the name of buffer ! 1009: `*shell*' to something different by using `M-x rename-buffer'. The ! 1010: next use of `M-x shell' will create a new buffer `*shell*' with its own ! 1011: subshell. By renaming this buffer as well you can create a third one, ! 1012: and so on. All the subshells run independently and in parallel. ! 1013: ! 1014: The file name used to load the subshell is the value of the variable ! 1015: `explicit-shell-file-name', if that is non-`nil'. Otherwise, the ! 1016: environment variable `ESHELL' is used, or the environment variable ! 1017: `SHELL' if there is no `ESHELL'. If the file name specified is ! 1018: relative, the directories in the list `exec-path' are searched (*note ! 1019: Single Shell Commands: Single Shell.). ! 1020: ! 1021: As soon as the subshell is started, it is sent as input the contents ! 1022: of the file `~/.emacs_SHELLNAME', if that file exists, where SHELLNAME ! 1023: is the name of the file that the shell was loaded from. For example, ! 1024: if you use `csh', the file sent to it is `~/.emacs_csh'; if you use the ! 1025: Bourne-Again shell, the file sent to it is `~/.emacs_bash'. ! 1026: ! 1027: `cd', `pushd' and `popd' commands given to the inferior shell are ! 1028: watched by Emacs so it can keep the `*shell*' buffer's default ! 1029: directory the same as the shell's working directory. These commands ! 1030: are recognized syntactically by examining lines of input that are sent. ! 1031: If you use aliases for these commands, you can tell Emacs to recognize ! 1032: them also. For example, if the value of the variable ! 1033: `shell-pushd-regexp' matches the beginning of a shell command line, ! 1034: that line is regarded as a `pushd' command. Change this variable when ! 1035: you add aliases for `pushd'. Likewise, `shell-popd-regexp' and ! 1036: `shell-cd-regexp' are used to recognize commands with the meaning of ! 1037: `popd' and `cd'. These commands are recognized only at the beginning ! 1038: of a shell command line. ! 1039: ! 1040: If Emacs gets an error while trying to handle what it believes is a ! 1041: `cd', `pushd' or `popd' command, and the value of ! 1042: `shell-set-directory-error-hook' is non-`nil', that value is called as ! 1043: a function with no arguments. ! 1044: ! 1045: ! 1046: File: emacs, Node: Shell Mode, Prev: Interactive Shell, Up: Shell ! 1047: ! 1048: Shell Mode ! 1049: ---------- ! 1050: ! 1051: The shell buffer uses Shell mode, which defines several special keys ! 1052: attached to the `C-c' prefix. They are chosen to resemble the usual ! 1053: editing and job control characters present in shells that are not under ! 1054: Emacs, except that you must type `C-c' first. Here is a complete list ! 1055: of the special key bindings of Shell mode: ! 1056: ! 1057: `RET' ! 1058: At end of buffer, send line as input; otherwise, copy current line ! 1059: to end of buffer and send it (`send-shell-input'). When a line is ! 1060: copied, any text at the beginning of the line that matches the ! 1061: variable `shell-prompt-pattern' is left out; this variable's value ! 1062: should be a regexp string that matches the prompts that you use in ! 1063: your subshell. ! 1064: ! 1065: `C-c C-d' ! 1066: Send end-of-file as input, probably causing the shell or its ! 1067: current subjob to finish (`shell-send-eof'). ! 1068: ! 1069: `C-c C-u' ! 1070: Kill all text that has yet to be sent as input ! 1071: (`kill-shell-input'). ! 1072: ! 1073: `C-c C-w' ! 1074: Kill a word before point (`backward-kill-word'). ! 1075: ! 1076: `C-c C-c' ! 1077: Interrupt the shell or its current subjob if any ! 1078: (`interrupt-shell-subjob'). ! 1079: ! 1080: `C-c C-z' ! 1081: Stop the shell or its current subjob if any (`stop-shell-subjob'). ! 1082: ! 1083: `C-c C-\' ! 1084: Send quit signal to the shell or its current subjob if any ! 1085: (`quit-shell-subjob'). ! 1086: ! 1087: `C-c C-o' ! 1088: Delete last batch of output from shell (`kill-output-from-shell'). ! 1089: ! 1090: `C-c C-r' ! 1091: Scroll top of last batch of output to top of window ! 1092: (`show-output-from-shell'). ! 1093: ! 1094: `C-c C-y' ! 1095: Copy the previous bunch of shell input, and insert it into the ! 1096: buffer before point (`copy-last-shell-input'). No final newline ! 1097: is inserted, and the input copied is not resubmitted until you type ! 1098: RET. ! 1099: ! 1100: ! 1101: File: emacs, Node: Hardcopy, Next: Dissociated Press, Prev: Shell, Up: Top ! 1102: ! 1103: Hardcopy Output ! 1104: =============== ! 1105: ! 1106: The Emacs commands for making hardcopy derive their names from the ! 1107: Unix commands `print' and `lpr'. ! 1108: ! 1109: `M-x print-buffer' ! 1110: Print hardcopy of current buffer using Unix command `print' (`lpr ! 1111: -p'). This makes page headings containing the file name and page ! 1112: number. ! 1113: ! 1114: `M-x lpr-buffer' ! 1115: Print hardcopy of current buffer using Unix command `lpr'. This ! 1116: makes no page headings. ! 1117: ! 1118: `M-x print-region' ! 1119: Like `print-buffer' but prints only the current region. ! 1120: ! 1121: `M-x lpr-region' ! 1122: Like `lpr-buffer' but prints only the current region. ! 1123: ! 1124: All the hardcopy commands pass extra switches to the `lpr' program ! 1125: based on the value of the variable `lpr-switches'. Its value should be ! 1126: a list of strings, each string a switch starting with `-'. For ! 1127: example, the value could be `("-Pfoo")' to print on printer `foo'. You ! 1128: can specify an alternative command to run instead of `lpr' by setting ! 1129: the variable `lpr-command'. ! 1130: ! 1131:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.