![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emacs-4 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-4 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: Horizontal Scrolling, Prev: Scrolling, Up: Display ! 27: ! 28: Horizontal Scrolling ! 29: ==================== ! 30: ! 31: `C-x <' ! 32: Scroll text in current window to the left (`scroll-left'). ! 33: ! 34: `C-x >' ! 35: Scroll to the right (`scroll-right'). ! 36: ! 37: The text in a window can also be scrolled horizontally. This means ! 38: that each line of text is shifted sideways in the window, and one or ! 39: more characters at the beginning of each line are not displayed at all. ! 40: When a window has been scrolled horizontally in this way, text lines ! 41: are truncated rather than continued (*note Continuation Lines::.), with ! 42: a `$' appearing in the first column when there is text truncated to the ! 43: left, and in the last column when there is text truncated to the right. ! 44: ! 45: The command `C-x <' (`scroll-left') scrolls the selected window to ! 46: the left by N columns with argument N. With no argument, it scrolls by ! 47: almost the full width of the window (two columns less, to be precise). ! 48: `C-x >' (`scroll-right') scrolls similarly to the right. The window ! 49: cannot be scrolled any farther to the right once it is displaying ! 50: normally (with each line starting at the window's left margin); ! 51: attempting to do so has no effect. ! 52: ! 53: ! 54: File: emacs, Node: Selective Display, Next: Display Vars, Prev: Display, Up: Display ! 55: ! 56: Selective Display ! 57: ================= ! 58: ! 59: Emacs has the ability to hide lines indented more than a certain ! 60: number of columns (you specify how many columns). You can use this to ! 61: get an overview of a part of a program. ! 62: ! 63: To hide lines, type `C-x $' (`set-selective-display') with a numeric ! 64: argument N. (*Note Arguments::, for how to give the argument.) Then ! 65: lines with at least N columns of indentation disappear from the screen. ! 66: The only indication of their presence is that three dots (`...') ! 67: appear at the end of each visible line that is followed by one or more ! 68: invisible ones. ! 69: ! 70: The invisible lines are still present in the buffer, and most editing ! 71: commands see them as usual, so it is very easy to put point in the ! 72: middle of invisible text. When this happens, the cursor appears at the ! 73: end of the previous line, after the three dots. If point is at the end ! 74: of the visible line, before the newline that ends it, the cursor ! 75: appears before the three dots. ! 76: ! 77: The commands `C-n' and `C-p' move across the invisible lines as if ! 78: they were not there. ! 79: ! 80: To make everything visible again, type `C-x $' with no argument. ! 81: ! 82: ! 83: File: emacs, Node: Display Vars, Prev: Selective Display, Up: Display ! 84: ! 85: Variables Controlling Display ! 86: ============================= ! 87: ! 88: This section contains information for customization only. Beginning ! 89: users should skip it. ! 90: ! 91: The variable `mode-line-inverse-video' controls whether the mode ! 92: line is displayed in inverse video (assuming the terminal supports it); ! 93: `nil' means don't do so. *Note Mode Line::. ! 94: ! 95: If the variable `inverse-video' is non-`nil', Emacs attempts to ! 96: invert all the lines of the display from what they normally are. ! 97: ! 98: If the variable `visible-bell' is non-`nil', Emacs attempts to make ! 99: the whole screen blink when it would normally make an audible bell ! 100: sound. This variable has no effect if your terminal does not have a way ! 101: to make the screen blink. ! 102: ! 103: When you reenter Emacs after suspending, Emacs normally clears the ! 104: screen and redraws the entire display. On some terminals with more ! 105: than one page of memory, it is possible to arrange the termcap entry so ! 106: that the `ti' and `te' strings (output to the terminal when Emacs is ! 107: entered and exited, respectively) switch between pages of memory so as ! 108: to use one page for Emacs and another page for other output. Then you ! 109: might want to set the variable `no-redraw-on-reenter' non-`nil' so that ! 110: Emacs will assume, when resumed, that the screen page it is using still ! 111: contains what Emacs last wrote there. ! 112: ! 113: The variable `echo-keystrokes' controls the echoing of ! 114: multi-character keys; its value is the number of seconds of pause ! 115: required to cause echoing to start, or zero meaning don't echo at all. ! 116: *Note Echo Area::. ! 117: ! 118: If the variable `ctl-arrow' is `nil', control characters in the ! 119: buffer are displayed with octal escape sequences, all except newline and ! 120: tab. Altering the value of `ctl-arrow' makes it local to the current ! 121: buffer; until that time, the default value is in effect. The default is ! 122: initially `t'. *Note Locals::. ! 123: ! 124: Normally, a tab character in the buffer is displayed as whitespace ! 125: which extends to the next display tab stop position, and display tab ! 126: stops come at intervals equal to eight spaces. The number of spaces ! 127: per tab is controlled by the variable `tab-width', which is made local ! 128: by changing it, just like `ctl-arrow'. Note that how the tab character ! 129: in the buffer is displayed has nothing to do with the definition of TAB ! 130: as a command. ! 131: ! 132: If you set the variable `selective-display-ellipses' to `nil', the ! 133: three dots do not appear at the end of a line that precedes invisible ! 134: lines. Then there is no visible indication of the invisible lines. ! 135: This variable too becomes local automatically when set. ! 136: ! 137: ! 138: File: emacs, Node: Search, Next: Fixit, Prev: Display, Up: Top ! 139: ! 140: Searching and Replacement ! 141: ************************* ! 142: ! 143: Like other editors, Emacs has commands for searching for occurrences ! 144: of a string. The principal search command is unusual in that it is ! 145: "incremental"; it begins to search before you have finished typing the ! 146: search string. There are also nonincremental search commands more like ! 147: those of other editors. ! 148: ! 149: Besides the usual `replace-string' command that finds all ! 150: occurrences of one string and replaces them with another, Emacs has a ! 151: fancy replacement command called `query-replace' which asks ! 152: interactively which occurrences to replace. ! 153: ! 154: * Menu: ! 155: ! 156: * Incremental Search:: Search happens as you type the string. ! 157: * Nonincremental Search:: Specify entire string and then search. ! 158: * Word Search:: Search for sequence of words. ! 159: * Regexp Search:: Search for match for a regexp. ! 160: * Regexps:: Syntax of regular expressions. ! 161: * Search Case:: To ignore case while searching, or not. ! 162: * Replace:: Search, and replace some or all matches. ! 163: * Other Repeating Search:: Operating on all matches for some regexp. ! 164: ! 165: ! 166: File: emacs, Node: Incremental Search, Next: Nonincremental Search, Prev: Search, Up: Search ! 167: ! 168: Incremental Search ! 169: ================== ! 170: ! 171: An incremental search begins searching as soon as you type the first ! 172: character of the search string. As you type in the search string, Emacs ! 173: shows you where the string (as you have typed it so far) would be found. ! 174: When you have typed enough characters to identify the place you want, ! 175: you can stop. Depending on what you will do next, you may or may not ! 176: need to terminate the search explicitly with an ESC first. ! 177: ! 178: `C-s' ! 179: Incremental search forward (`isearch-forward'). ! 180: ! 181: `C-r' ! 182: Incremental search backward (`isearch-backward'). ! 183: ! 184: `C-s' starts an incremental search. `C-s' reads characters from the ! 185: keyboard and positions the cursor at the first occurrence of the ! 186: characters that you have typed. If you type `C-s' and then `F', the ! 187: cursor moves right after the first `F'. Type an `O', and see the ! 188: cursor move to after the first `FO'. After another `O', the cursor is ! 189: after the first `FOO' after the place where you started the search. ! 190: Meanwhile, the search string `FOO' has been echoed in the echo area. ! 191: ! 192: The echo area display ends with three dots when actual searching is ! 193: going on. When search is waiting for more input, the three dots are ! 194: removed. (On slow terminals, the three dots are not displayed.) ! 195: ! 196: If you make a mistake in typing the search string, you can erase ! 197: characters with DEL. Each DEL cancels the last character of search ! 198: string. This does not happen until Emacs is ready to read another ! 199: input character; first it must either find, or fail to find, the ! 200: character you want to erase. If you do not want to wait for this to ! 201: happen, use `C-g' as described below. ! 202: ! 203: When you are satisfied with the place you have reached, you can type ! 204: ESC, which stops searching, leaving the cursor where the search brought ! 205: it. Also, any command not specially meaningful in searches stops the ! 206: searching and is then executed. Thus, typing `C-a' would exit the ! 207: search and then move to the beginning of the line. ESC is necessary ! 208: only if the next command you want to type is a printing character, DEL, ! 209: ESC, or another control character that is special within searches ! 210: (`C-q', `C-w', `C-r', `C-s' or `C-y'). ! 211: ! 212: Sometimes you search for `FOO' and find it, but not the one you ! 213: expected to find. There was a second `FOO' that you forgot about, ! 214: before the one you were looking for. In this event, type another `C-s' ! 215: to move to the next occurrence of the search string. This can be done ! 216: any number of times. If you overshoot, you can cancel some `C-s' ! 217: characters with DEL. ! 218: ! 219: After you exit a search, you can search for the same string again by ! 220: typing just `C-s C-s': the first `C-s' is the key that invokes ! 221: incremental search, and the second `C-s' means "search again". ! 222: ! 223: If your string is not found at all, the echo area says `Failing ! 224: I-Search'. The cursor is after the place where Emacs found as much of ! 225: your string as it could. Thus, if you search for `FOOT', and there is ! 226: no `FOOT', you might see the cursor after the `FOO' in `FOOL'. At this ! 227: point there are several things you can do. If your string was ! 228: mistyped, you can rub some of it out and correct it. If you like the ! 229: place you have found, you can type ESC or some other Emacs command to ! 230: "accept what the search offered". Or you can type `C-g', which removes ! 231: from the search string the characters that could not be found (the `T' ! 232: in `FOOT'), leaving those that were found (the `FOO' in `FOOT'). A ! 233: second `C-g' at that point cancels the search entirely, returning point ! 234: to where it was when the search started. ! 235: ! 236: If a search is failing and you ask to repeat it by typing another ! 237: `C-s', it starts again from the beginning of the buffer. Repeating a ! 238: failing reverse search with `C-r' starts again from the end. This is ! 239: called "wrapping around". `Wrapped' appears in the search prompt once ! 240: this has happened. ! 241: ! 242: The `C-g' "quit" character does special things during searches; just ! 243: what it does depends on the status of the search. If the search has ! 244: found what you specified and is waiting for input, `C-g' cancels the ! 245: entire search. The cursor moves back to where you started the search. ! 246: If `C-g' is typed when there are characters in the search string that ! 247: have not been found--because Emacs is still searching for them, or ! 248: because it has failed to find them--then the search string characters ! 249: which have not been found are discarded from the search string. With ! 250: them gone, the search is now successful and waiting for more input, so ! 251: a second `C-g' will cancel the entire search. ! 252: ! 253: To search for a control character such as `C-s' or DEL or ESC, you ! 254: must quote it by typing `C-q' first. This function of `C-q' is ! 255: analogous to its meaning as an Emacs command: it causes the following ! 256: character to be treated the way a graphic character would normally be ! 257: treated in the same context. You can also specify a quoted character ! 258: in octal while searching, just as you can for insertion. *Note Basic::. ! 259: ! 260: You can change to searching backwards with `C-r'. If a search fails ! 261: because the place you started was too late in the file, you should do ! 262: this. Repeated `C-r' keeps looking for more occurrences backwards. A ! 263: `C-s' starts going forwards again. `C-r' in a search can be cancelled ! 264: with DEL. ! 265: ! 266: If you know initially that you want to search backwards, you can use ! 267: `C-r' instead of `C-s' to start the search, because `C-r' is also a key ! 268: running a command (`isearch-backward') to search backward. ! 269: ! 270: The characters `C-y' and `C-w' can be used in incremental search to ! 271: grab text from the buffer into the search string. This makes it ! 272: convenient to search for another occurrence of text at point. `C-w' ! 273: copies the word after point as part of the search string, advancing ! 274: point over that word. Another `C-s' to repeat the search will then ! 275: search for a string including that word. `C-y' is similar to `C-w' but ! 276: copies all the rest of the current line into the search string. ! 277: ! 278: All the characters special in incremental search can be changed by ! 279: setting the following variables: ! 280: ! 281: `search-delete-char' ! 282: Character to delete from incremental search string (normally DEL). ! 283: ! 284: `search-exit-char' ! 285: Character to exit incremental search (normally ESC). ! 286: ! 287: `search-quote-char' ! 288: Character to quote special characters for incremental search ! 289: (normally `C-q'). ! 290: ! 291: `search-repeat-char' ! 292: Character to repeat incremental search forwards (normally `C-s'). ! 293: ! 294: `search-reverse-char' ! 295: Character to repeat incremental search backwards (normally `C-r'). ! 296: ! 297: `search-yank-line-char' ! 298: Character to pull rest of line from buffer into search string ! 299: (normally `C-y'). ! 300: ! 301: `search-yank-word-char' ! 302: Character to pull next word from buffer into search string ! 303: (normally `C-w'). ! 304: ! 305: Slow Terminal Incremental Search ! 306: -------------------------------- ! 307: ! 308: Incremental search on a slow terminal uses a modified style of ! 309: display that is designed to take less time. Instead of redisplaying ! 310: the buffer at each place the search gets to, it creates a new ! 311: single-line window and uses that to display the line that the search ! 312: has found. The single-line window comes into play as soon as point ! 313: gets outside of the text that is already on the screen. ! 314: ! 315: When the search is terminated, the single-line window is removed. ! 316: Only at this time is the window in which the search was done ! 317: redisplayed to show its new value of point. ! 318: ! 319: The three dots at the end of the search string, normally used to ! 320: indicate that searching is going on, are not displayed in slow style ! 321: display. ! 322: ! 323: The slow terminal style of display is used when the terminal baud ! 324: rate is less than or equal to the value of the variable ! 325: `search-slow-speed', initially 1200. ! 326: ! 327: The number of lines to use in slow terminal search display is ! 328: controlled by the variable `search-slow-window-lines'. 1 is its normal ! 329: value. ! 330: ! 331: ! 332: File: emacs, Node: Nonincremental Search, Next: Word Search, Prev: Incremental Search, Up: Search ! 333: ! 334: Nonincremental Search ! 335: ===================== ! 336: ! 337: Emacs also has conventional nonincremental search commands, which ! 338: require you to type the entire search string before searching begins. ! 339: ! 340: `C-s ESC STRING RET' ! 341: Search for STRING. ! 342: ! 343: `C-r ESC STRING RET' ! 344: Search backward for STRING. ! 345: ! 346: To do a nonincremental search, first type `C-s ESC'. This enters ! 347: the minibuffer to read the search string; terminate the string with ! 348: RET, and then the search is done. If the string is not found the ! 349: search command gets an error. ! 350: ! 351: The way `C-s ESC' works is that the `C-s' invokes incremental ! 352: search, which is specially programmed to invoke nonincremental search ! 353: if the argument you give it is empty. (Such an empty argument would ! 354: otherwise be useless.) `C-r ESC' also works this way. ! 355: ! 356: Forward and backward nonincremental searches are implemented by the ! 357: commands `search-forward' and `search-backward'. These commands may be ! 358: bound to keys in the usual manner. The reason that incremental search ! 359: is programmed to invoke them as well is that `C-s ESC' is the ! 360: traditional sequence of characters used in Emacs to invoke ! 361: nonincremental search. ! 362: ! 363: However, nonincremental searches performed using `C-s ESC' do not ! 364: call `search-forward' right away. The first thing done is to see if ! 365: the next character is `C-w', which requests a word search. *Note Word ! 366: Search::. ! 367: ! 368: ! 369: File: emacs, Node: Word Search, Next: Regexp Search, Prev: Nonincremental Search, Up: Search ! 370: ! 371: Word Search ! 372: =========== ! 373: ! 374: Word search searches for a sequence of words without regard to how ! 375: the words are separated. More precisely, you type a string of many ! 376: words, using single spaces to separate them, and the string can be ! 377: found even if there are multiple spaces, newlines or other punctuation ! 378: between the words. ! 379: ! 380: Word search is useful in editing documents formatted by text ! 381: formatters. If you edit while looking at the printed, formatted ! 382: version, you can't tell where the line breaks are in the source file. ! 383: With word search, you can search without having to know them. ! 384: ! 385: `C-s ESC C-w WORDS RET' ! 386: Search for WORDS, ignoring differences in punctuation. ! 387: ! 388: `C-r ESC C-w WORDS RET' ! 389: Search backward for WORDS, ignoring differences in punctuation. ! 390: ! 391: Word search is a special case of nonincremental search and is invoked ! 392: with `C-s ESC C-w'. This is followed by the search string, which must ! 393: always be terminated with RET. Being nonincremental, this search does ! 394: not start until the argument is terminated. It works by constructing a ! 395: regular expression and searching for that. *Note Regexp Search::. ! 396: ! 397: A backward word search can be done by `C-r ESC C-w'. ! 398: ! 399: Forward and backward word searches are implemented by the commands ! 400: `word-search-forward' and `word-search-backward'. These commands may ! 401: be bound to keys in the usual manner. The reason that incremental ! 402: search is programmed to invoke them as well is that `C-s ESC C-w' is ! 403: the traditional Emacs sequence of keys for word search. ! 404: ! 405: ! 406: File: emacs, Node: Regexp Search, Next: Regexps, Prev: Word Search, Up: Search ! 407: ! 408: Regular Expression Search ! 409: ========================= ! 410: ! 411: A "regular expression" ("regexp", for short) is a pattern that ! 412: denotes a set of strings, possibly an infinite set. Searching for ! 413: matches for a regexp is a very powerful operation that editors on Unix ! 414: systems have traditionally offered. In GNU Emacs, you can search for ! 415: the next match for a regexp either incrementally or not. ! 416: ! 417: Incremental search for a regexp is done by typing `C-M-s' ! 418: (`isearch-forward-regexp'). This command reads a search string ! 419: incrementally just like `C-s', but it treats the search string as a ! 420: regexp rather than looking for an exact match against the text in the ! 421: buffer. Each time you add text to the search string, you make the ! 422: regexp longer, and the new regexp is searched for. A reverse regexp ! 423: search command, `isearch-backward-regexp', also exists but no key runs ! 424: it. ! 425: ! 426: All of the control characters that do special things within an ! 427: ordinary incremental search have the same function in incremental ! 428: regexp search. Typing `C-s' or `C-r' immediately after starting the ! 429: search retrieves the last incremental search regexp used; that is to ! 430: say, incremental regexp and non-regexp searches have independent ! 431: defaults. ! 432: ! 433: Note that adding characters to the regexp in an incremental regexp ! 434: search does not make the cursor move back and start again. Perhaps it ! 435: ought to; I am not sure. As it stands, if you have searched for `foo' ! 436: and you add `\|bar', the search will not check for a `bar' in the ! 437: buffer before the `foo'. ! 438: ! 439: Nonincremental search for a regexp is done by the functions ! 440: `re-search-forward' and `re-search-backward'. You can invoke these ! 441: with `M-x', or bind them to keys. Also, you can call ! 442: `re-search-forward' by way of incremental regexp search with `C-M-s ! 443: ESC'. ! 444: ! 445: ! 446: File: emacs, Node: Regexps, Next: Search Case, Prev: Regexp Search, Up: Search ! 447: ! 448: Syntax of Regular Expressions ! 449: ============================= ! 450: ! 451: Regular expressions have a syntax in which a few characters are ! 452: special constructs and the rest are "ordinary". An ordinary character ! 453: is a simple regular expression which matches that character and nothing ! 454: else. The special characters are `$', `^', `.', `*', `+', `?', `[', `]' ! 455: and `\'; no new special characters will be defined. Any other ! 456: character appearing in a regular expression is ordinary, unless a `\' ! 457: precedes it. ! 458: ! 459: For example, `f' is not a special character, so it is ordinary, and ! 460: therefore `f' is a regular expression that matches the string `f' and ! 461: no other string. (It does not match the string `ff'.) Likewise, `o' ! 462: is a regular expression that matches only `o'. ! 463: ! 464: Any two regular expressions A and B can be concatenated. The result ! 465: is a regular expression which matches a string if A matches some amount ! 466: of the beginning of that string and B matches the rest of the string. ! 467: ! 468: As a simple example, we can concatenate the regular expressions `f' ! 469: and `o' to get the regular expression `fo', which matches only the ! 470: string `fo'. Still trivial. To do something nontrivial, you need to ! 471: use one of the special characters. Here is a list of them. ! 472: ! 473: `. (Period)' ! 474: is a special character that matches any single character except a ! 475: newline. Using concatenation, we can make regular expressions like ! 476: `a.b' which matches any three-character string which begins with ! 477: `a' and ends with `b'. ! 478: ! 479: `*' ! 480: is not a construct by itself; it is a suffix, which means the ! 481: preceding regular expression is to be repeated as many times as ! 482: possible. In `fo*', the `*' applies to the `o', so `fo*' matches ! 483: one `f' followed by any number of `o's. The case of zero `o's is ! 484: allowed: `fo*' does match `f'. ! 485: ! 486: `*' always applies to the smallest possible preceding expression. ! 487: Thus, `fo*' has a repeating `o', not a repeating `fo'. ! 488: ! 489: The matcher processes a `*' construct by matching, immediately, as ! 490: many repetitions as can be found. Then it continues with the rest ! 491: of the pattern. If that fails, backtracking occurs, discarding ! 492: some of the matches of the `*'-modified construct in case that ! 493: makes it possible to match the rest of the pattern. For example, ! 494: matching `ca*ar' against the string `caaar', the `a*' first tries ! 495: to match all three `a's; but the rest of the pattern is `ar' and ! 496: there is only `r' left to match, so this try fails. The next ! 497: alternative is for `a*' to match only two `a's. With this choice, ! 498: the rest of the regexp matches successfully. ! 499: ! 500: `+' ! 501: Is a suffix character similar to `*' except that it requires that ! 502: the preceding expression be matched at least once. So, for ! 503: example, `ca+r' will match the strings `car' and `caaaar' but not ! 504: the string `cr', whereas `ca*r' would match all three strings. ! 505: ! 506: `?' ! 507: Is a suffix character similar to `*' except that it can match the ! 508: preceding expression either once or not at all. For example, ! 509: `ca?r' will match `car' or `cr'; nothing else. ! 510: ! 511: `[ ... ]' ! 512: `[' begins a "character set", which is terminated by a `]'. In ! 513: the simplest case, the characters between the two form the set. ! 514: Thus, `[ad]' matches either one `a' or one `d', and `[ad]*' ! 515: matches any string composed of just `a's and `d's (including the ! 516: empty string), from which it follows that `c[ad]*r' matches `cr', ! 517: `car', `cdr', `caddaar', etc. ! 518: ! 519: Character ranges can also be included in a character set, by ! 520: writing two characters with a `-' between them. Thus, `[a-z]' ! 521: matches any lower-case letter. Ranges may be intermixed freely ! 522: with individual characters, as in `[a-z$%.]', which matches any ! 523: lower case letter or `$', `%' or period. ! 524: ! 525: Note that the usual special characters are not special any more ! 526: inside a character set. A completely different set of special ! 527: characters exists inside character sets: `]', `-' and `^'. ! 528: ! 529: To include a `]' in a character set, you must make it the first ! 530: character. For example, `[]a]' matches `]' or `a'. To include a ! 531: `-', write `---', which is a range containing only `-'. To ! 532: include `^', make it other than the first character in the set. ! 533: ! 534: `[^ ... ]' ! 535: `[^' begins a "complement character set", which matches any ! 536: character except the ones specified. Thus, `[^a-z0-9A-Z]' matches ! 537: all characters except letters and digits. ! 538: ! 539: `^' is not special in a character set unless it is the first ! 540: character. The character following the `^' is treated as if it ! 541: were first (`-' and `]' are not special there). ! 542: ! 543: Note that a complement character set can match a newline, unless ! 544: newline is mentioned as one of the characters not to match. ! 545: ! 546: `^' ! 547: is a special character that matches the empty string, but only if ! 548: at the beginning of a line in the text being matched. Otherwise ! 549: it fails to match anything. Thus, `^foo' matches a `foo' which ! 550: occurs at the beginning of a line. ! 551: ! 552: `$' ! 553: is similar to `^' but matches only at the end of a line. Thus, ! 554: `xx*$' matches a string of one `x' or more at the end of a line. ! 555: ! 556: `\' ! 557: has two functions: it quotes the special characters (including ! 558: `\'), and it introduces additional special constructs. ! 559: ! 560: Because `\' quotes special characters, `\$' is a regular ! 561: expression which matches only `$', and `\[' is a regular ! 562: expression which matches only `[', and so on. ! 563: ! 564: Note: for historical compatibility, special characters are treated as ! 565: ordinary ones if they are in contexts where their special meanings make ! 566: no sense. For example, `*foo' treats `*' as ordinary since there is no ! 567: preceding expression on which the `*' can act. It is poor practice to ! 568: depend on this behavior; better to quote the special character anyway, ! 569: regardless of where is appears. ! 570: ! 571: For the most part, `\' followed by any character matches only that ! 572: character. However, there are several exceptions: characters which, ! 573: when preceded by `\', are special constructs. Such characters are ! 574: always ordinary when encountered on their own. Here is a table of `\' ! 575: constructs. ! 576: ! 577: `\|' ! 578: specifies an alternative. Two regular expressions A and B with ! 579: `\|' in between form an expression that matches anything that ! 580: either A or B will match. ! 581: ! 582: Thus, `foo\|bar' matches either `foo' or `bar' but no other string. ! 583: ! 584: `\|' applies to the largest possible surrounding expressions. ! 585: Only a surrounding `\( ... \)' grouping can limit the grouping ! 586: power of `\|'. ! 587: ! 588: Full backtracking capability exists to handle multiple uses of ! 589: `\|'. ! 590: ! 591: `\( ... \)' ! 592: is a grouping construct that serves three purposes: ! 593: ! 594: 1. To enclose a set of `\|' alternatives for other operations. ! 595: Thus, `\(foo\|bar\)x' matches either `foox' or `barx'. ! 596: ! 597: 2. To enclose a complicated expression for the postfix `*' to ! 598: operate on. Thus, `ba\(na\)*' matches `bananana', etc., with ! 599: any (zero or more) number of `na' strings. ! 600: ! 601: 3. To mark a matched substring for future reference. ! 602: ! 603: ! 604: This last application is not a consequence of the idea of a ! 605: parenthetical grouping; it is a separate feature which happens to ! 606: be assigned as a second meaning to the same `\( ... \)' construct ! 607: because there is no conflict in practice between the two meanings. ! 608: Here is an explanation of this feature: ! 609: ! 610: `\DIGIT' ! 611: after the end of a `\( ... \)' construct, the matcher remembers the ! 612: beginning and end of the text matched by that construct. Then, ! 613: later on in the regular expression, you can use `\' followed by ! 614: DIGIT to mean "match the same text matched the DIGIT'th time by the ! 615: `\( ... \)' construct." ! 616: ! 617: The strings matching the first nine `\( ... \)' constructs ! 618: appearing in a regular expression are assigned numbers 1 through 9 ! 619: in order that the open-parentheses appear in the regular ! 620: expression. `\1' through `\9' may be used to refer to the text ! 621: matched by the corresponding `\( ... \)' construct. ! 622: ! 623: For example, `\(.*\)\1' matches any newline-free string that is ! 624: composed of two identical halves. The `\(.*\)' matches the first ! 625: half, which may be anything, but the `\1' that follows must match ! 626: the same exact text. ! 627: ! 628: `\`' ! 629: matches the empty string, provided it is at the beginning of the ! 630: buffer. ! 631: ! 632: `\'' ! 633: matches the empty string, provided it is at the end of the buffer. ! 634: ! 635: `\b' ! 636: matches the empty string, provided it is at the beginning or end ! 637: of a word. Thus, `\bfoo\b' matches any occurrence of `foo' as a ! 638: separate word. `\bballs?\b' matches `ball' or `balls' as a ! 639: separate word. ! 640: ! 641: `\B' ! 642: matches the empty string, provided it is not at the beginning or ! 643: end of a word. ! 644: ! 645: `\<' ! 646: matches the empty string, provided it is at the beginning of a ! 647: word. ! 648: ! 649: `\>' ! 650: matches the empty string, provided it is at the end of a word. ! 651: ! 652: `\w' ! 653: matches any word-constituent character. The editor syntax table ! 654: determines which characters these are. ! 655: ! 656: `\W' ! 657: matches any character that is not a word-constituent. ! 658: ! 659: `\sCODE' ! 660: matches any character whose syntax is CODE. CODE is a character ! 661: which represents a syntax code: thus, `w' for word constituent, ! 662: `-' for whitespace, `(' for open-parenthesis, etc. *Note Syntax::. ! 663: ! 664: `\SCODE' ! 665: matches any character whose syntax is not CODE. ! 666: ! 667: Here is a complicated regexp, used by Emacs to recognize the end of a ! 668: sentence together with any whitespace that follows. It is given in Lisp ! 669: syntax to enable you to distinguish the spaces from the tab characters. ! 670: In Lisp syntax, the string constant begins and ends with a ! 671: double-quote. `\"' stands for a double-quote as part of the regexp, ! 672: `\\' for a backslash as part of the regexp, `\t' for a tab and `\n' for ! 673: a newline. ! 674: ! 675: "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*" ! 676: ! 677: This contains four parts in succession: a character set matching period, ! 678: `?' or `!'; a character set matching close-brackets, quotes or ! 679: parentheses, repeated any number of times; an alternative in ! 680: backslash-parentheses that matches end-of-line, a tab or two spaces; ! 681: and a character set matching whitespace characters, repeated any number ! 682: of times. ! 683: ! 684: Note that the above example shows how to write this regexp when ! 685: entering it as part of an Emacs Lisp program. To enter the same regexp ! 686: in an interactive command such as `re-search-forward' you must spell it ! 687: differently: ! 688: ! 689: [.?!][]"')]*\($\|^Q^I\| \)[ ^Q^I^Q^J]* ! 690: ! 691: ! 692: File: emacs, Node: Search Case, Next: Replace, Prev: Regexps, Up: Search ! 693: ! 694: Searching and Case ! 695: ================== ! 696: ! 697: All sorts of searches in Emacs normally ignore the case of the text ! 698: they are searching through; if you specify searching for `FOO', then ! 699: `Foo' and `foo' are also considered a match. Regexps, and in ! 700: particular character sets, are included: `[aB]' would match `a' or `A' ! 701: or `b' or `B'. ! 702: ! 703: If you do not want this feature, set the variable `case-fold-search' ! 704: to `nil'. Then all letters must match exactly, including case. This ! 705: is a per-buffer variable; altering the variable affects only the current ! 706: buffer, but there is a default value which you can change as well. ! 707: *Note Locals::. ! 708: ! 709: ! 710: File: emacs, Node: Replace, Next: Other Repeating Search, Prev: Search Case, Up: Search ! 711: ! 712: Replacement Commands ! 713: ==================== ! 714: ! 715: Global search-and-replace operations are not needed as often in ! 716: Emacs as they are in other editors, but they are available. In ! 717: addition to the simple `replace-string' command which is like that ! 718: found in most editors, there is a `query-replace' command which asks ! 719: you, for each occurrence of the pattern, whether to replace it. ! 720: ! 721: The replace commands all replace one string (or regexp) with one ! 722: replacement string. It is possible to perform several replacements in ! 723: parallel using the command `expand-region-abbrevs'. *Note Expanding ! 724: Abbrevs::. ! 725: ! 726: * Menu: ! 727: ! 728: * Unconditional Replace:: Replacing all matches for a string. ! 729: * Regexp Replace:: Replacing all matches for a regexp. ! 730: * Replacement and Case:: How replacements preserve case of letters. ! 731: * Query Replace:: How to use querying. ! 732: ! 733: ! 734: File: emacs, Node: Unconditional Replace, Next: Regexp Replace, Prev: Replace, Up: Replace ! 735: ! 736: Unconditional Replacement ! 737: ------------------------- ! 738: ! 739: `M-x replace-string RET STRING RET NEWSTRING RET' ! 740: Replace every occurrence of STRING with NEWSTRING. ! 741: ! 742: `M-x replace-regexp RET REGEXP RET NEWSTRING RET' ! 743: Replace every match for REGEXP with NEWSTRING. ! 744: ! 745: To replace every instance of `foo' after point with `bar', use the ! 746: command `M-x replace-string' with the two arguments `foo' and `bar'. ! 747: Replacement occurs only after point, so if you want to cover the whole ! 748: buffer you must go to the beginning first. All occurrences up to the ! 749: end of the buffer are replaced; to limit replacement to part of the ! 750: buffer, narrow to that part of the buffer before doing the replacement ! 751: (*note Narrowing::.). ! 752: ! 753: When `replace-string' exits, point is left at the last occurrence ! 754: replaced. The value of point when the `replace-string' command was ! 755: issued is remembered on the mark ring; `C-u C-SPC' moves back there. ! 756: ! 757: A numeric argument restricts replacement to matches that are ! 758: surrounded by word boundaries. ! 759: ! 760: ! 761: File: emacs, Node: Regexp Replace, Next: Replacement and Case, Prev: Unconditional Replace, Up: Replace ! 762: ! 763: Regexp Replacement ! 764: ------------------ ! 765: ! 766: `replace-string' replaces exact matches for a single string. The ! 767: similar command `replace-regexp' replaces any match for a specified ! 768: pattern. ! 769: ! 770: In `replace-regexp', the NEWSTRING need not be constant. It can ! 771: refer to all or part of what is matched by the REGEXP. `\&' in ! 772: NEWSTRING stands for the entire text being replaced. `\D' in NEWSTRING, ! 773: where D is a digit, stands for whatever matched the D'th parenthesized ! 774: grouping in REGEXP. For example, ! 775: ! 776: M-x replace-regexp RET c[ad]+r RET \&-safe RET ! 777: ! 778: would replace (for example) `cadr' with `cadr-safe' and `cddr' with ! 779: `cddr-safe'. ! 780: ! 781: M-x replace-regexp RET \(c[ad]+r\)-safe RET \1 RET ! 782: ! 783: would perform exactly the opposite replacements. To include a `\' in ! 784: the text to replace with, you must give `\\'. ! 785: ! 786: ! 787: File: emacs, Node: Replacement and Case, Next: Query Replace, Prev: Regexp Replace, Up: Replace ! 788: ! 789: Replace Commands and Case ! 790: ------------------------- ! 791: ! 792: If the arguments to a replace command are in lower case, it preserves ! 793: case when it makes a replacement. Thus, the command ! 794: ! 795: M-x replace-string RET foo RET bar RET ! 796: ! 797: replaces a lower case `foo' with a lower case `bar', `FOO' with `BAR', ! 798: and `Foo' with `Bar'. If upper case letters are used in the second ! 799: argument, they remain upper case every time that argument is inserted. ! 800: If upper case letters are used in the first argument, the second ! 801: argument is always substituted exactly as given, with no case ! 802: conversion. Likewise, if the variable `case-replace' is set to `nil', ! 803: replacement is done without case conversion. If `case-fold-search' is ! 804: set to `nil', case is significant in matching occurrences of `foo' to ! 805: replace; also, case conversion of the replacement string is not done. ! 806: ! 807: ! 808: File: emacs, Node: Query Replace, Prev: Replacement and Case, Up: Replace ! 809: ! 810: Query Replace ! 811: ------------- ! 812: ! 813: `M-% STRING RET NEWSTRING RET' ! 814: `M-x query-replace RET STRING RET NEWSTRING RET' ! 815: Replace some occurrences of STRING with NEWSTRING. ! 816: ! 817: `M-x query-replace-regexp RET REGEXP RET NEWSTRING RET' ! 818: Replace some matches for REGEXP with NEWSTRING. ! 819: ! 820: If you want to change only some of the occurrences of `foo' to ! 821: `bar', not all of them, then you cannot use an ordinary ! 822: `replace-string'. Instead, use `M-%' (`query-replace'). This command ! 823: finds occurrences of `foo' one by one, displays each occurrence and ! 824: asks you whether to replace it. A numeric argument to `query-replace' ! 825: tells it to consider only occurrences that are bounded by ! 826: word-delimiter characters. ! 827: ! 828: Aside from querying, `query-replace' works just like ! 829: `replace-string', and `query-replace-regexp' works just like ! 830: `replace-regexp'. ! 831: ! 832: The things you can type when you are shown an occurrence of STRING ! 833: or a match for REGEXP are: ! 834: ! 835: `SPC' ! 836: to replace the occurrence with NEWSTRING. This preserves case, ! 837: just like `replace-string', provided `case-replace' is non-`nil', ! 838: as it normally is. ! 839: ! 840: `DEL' ! 841: to skip to the next occurrence without replacing this one. ! 842: ! 843: `, (Comma)' ! 844: to replace this occurrence and display the result. You are then ! 845: asked for another input character, except that since the ! 846: replacement has already been made, DEL and SPC are equivalent. ! 847: You could type `C-r' at this point (see below) to alter the ! 848: replaced text. You could also type `C-x u' to undo the ! 849: replacement; this exits the `query-replace', so if you want to do ! 850: further replacement you must use `C-x ESC' to restart (*note ! 851: Repetition::.). ! 852: ! 853: `ESC' ! 854: to exit without doing any more replacements. ! 855: ! 856: `. (Period)' ! 857: to replace this occurrence and then exit. ! 858: ! 859: `!' ! 860: to replace all remaining occurrences without asking again. ! 861: ! 862: `^' ! 863: to go back to the location of the previous occurrence (or what ! 864: used to be an occurrence), in case you changed it by mistake. ! 865: This works by popping the mark ring. Only one `^' in a row is ! 866: allowed, because only one previous replacement location is kept ! 867: during `query-replace'. ! 868: ! 869: `C-r' ! 870: to enter a recursive editing level, in case the occurrence needs ! 871: to be edited rather than just replaced with NEWSTRING. When you ! 872: are done, exit the recursive editing level with `C-M-c' and the ! 873: next occurrence will be displayed. *Note Recursive Edit::. ! 874: ! 875: `C-w' ! 876: to delete the occurrence, and then enter a recursive editing level ! 877: as in `C-r'. Use the recursive edit to insert text to replace the ! 878: deleted occurrence of STRING. When done, exit the recursive ! 879: editing level with `C-M-c' and the next occurrence will be ! 880: displayed. ! 881: ! 882: `C-l' ! 883: to redisplay the screen and then give another answer. ! 884: ! 885: `C-h' ! 886: to display a message summarizing these options, then give another ! 887: answer. ! 888: ! 889: If you type any other character, the `query-replace' is exited, and ! 890: the character executed as a command. To restart the `query-replace', ! 891: use `C-x ESC', which repeats the `query-replace' because it used the ! 892: minibuffer to read its arguments. *Note C-x ESC: Repetition. ! 893: ! 894: To replace every occurrence, you can start `query-replace' at the ! 895: beginning of the buffer and type `!', or you can use the ! 896: `replace-string' command at the beginning of the buffer. To replace ! 897: every occurrence in a part of the buffer, narrow to that part and then ! 898: run `replace-string' or `query-replace' at the beginning of it. *Note ! 899: Narrowing::. ! 900: ! 901: ! 902: File: emacs, Node: Other Repeating Search, Prev: Replace, Up: Search ! 903: ! 904: Other Search-and-Loop Commands ! 905: ============================== ! 906: ! 907: Here are some other commands that find matches for a regular ! 908: expression. They all operate from point to the end of the buffer. ! 909: ! 910: `M-x occur' ! 911: Print each line that follows point and contains a match for the ! 912: specified regexp. A numeric argument specifies the number of ! 913: context lines to print before and after each matching line; the ! 914: default is none. ! 915: ! 916: The buffer `*Occur*' containing the output serves as a menu for ! 917: finding the occurrences in their original context. Find an ! 918: occurrence as listed in `*Occur*', position point there and type ! 919: `C-c C-c'; this switches to the buffer that was searched and moves ! 920: point to the original of the same occurrence. ! 921: ! 922: `M-x list-matching-lines' ! 923: Synonym for `M-x occur'. ! 924: ! 925: `M-x count-matches' ! 926: Print the number of matches following point for the specified ! 927: regexp. ! 928: ! 929: `M-x delete-non-matching-lines' ! 930: Delete each line that follows point and does not contain a match ! 931: for the specified regexp. ! 932: ! 933: `M-x delete-matching-lines' ! 934: Delete each line that follows point and contains a match for the ! 935: specified regexp. ! 936: ! 937: ! 938: File: emacs, Node: Fixit, Next: Files, Prev: Search, Up: Top ! 939: ! 940: Commands for Fixing Typos ! 941: ************************* ! 942: ! 943: In this chapter we describe the commands that are especially useful ! 944: for the times when you catch a mistake in your text just after you have ! 945: made it, or change your mind while composing text on line. ! 946: ! 947: * Menu: ! 948: ! 949: * Kill Errors:: Commands to kill a batch of recently entered text. ! 950: * Transpose:: Exchanging two characters, words, lines, lists... ! 951: * Fixing Case:: Correcting case of last word entered. ! 952: * Spelling:: Apply spelling checker to a word, or a whole file. ! 953: ! 954: ! 955: File: emacs, Node: Kill Errors, Next: Transpose, Prev: Fixit, Up: Fixit ! 956: ! 957: Killing Your Mistakes ! 958: ===================== ! 959: ! 960: `DEL' ! 961: Delete last character (`delete-backward-char'). ! 962: ! 963: `M-DEL' ! 964: Kill last word (`backward-kill-word'). ! 965: ! 966: `C-x DEL' ! 967: Kill to beginning of sentence (`backward-kill-sentence'). ! 968: ! 969: The DEL character (`delete-backward-char') is the most important ! 970: correction command. When used among graphic (self-inserting) ! 971: characters, it can be thought of as canceling the last character typed. ! 972: ! 973: When your mistake is longer than a couple of characters, it might be ! 974: more convenient to use `M-DEL' or `C-x DEL'. `M-DEL' kills back to the ! 975: start of the last word, and `C-x DEL' kills back to the start of the ! 976: last sentence. `C-x DEL' is particularly useful when you are thinking ! 977: of what to write as you type it, in case you change your mind about ! 978: phrasing. `M-DEL' and `C-x DEL' save the killed text for `C-y' and ! 979: `M-y' to retrieve. *Note Yanking::. ! 980: ! 981: `M-DEL' is often useful even when you have typed only a few ! 982: characters wrong, if you know you are confused in your typing and aren't ! 983: sure exactly what you typed. At such a time, you cannot correct with ! 984: DEL except by looking at the screen to see what you did. It requires ! 985: less thought to kill the whole word and start over again. ! 986: ! 987: ! 988: File: emacs, Node: Transpose, Next: Fixing Case, Prev: Kill Errors, Up: Fixit ! 989: ! 990: Transposing Text ! 991: ================ ! 992: ! 993: `C-t' ! 994: Transpose two characters (`transpose-chars'). ! 995: ! 996: `M-t' ! 997: Transpose two words (`transpose-words'). ! 998: ! 999: `C-M-t' ! 1000: Transpose two balanced expressions (`transpose-sexps'). ! 1001: ! 1002: `C-x C-t' ! 1003: Transpose two lines (`transpose-lines'). ! 1004: ! 1005: The common error of transposing two characters can be fixed, when ! 1006: they are adjacent, with the `C-t' command (`transpose-chars'). ! 1007: Normally, `C-t' transposes the two characters on either side of point. ! 1008: When given at the end of a line, rather than transposing the last ! 1009: character of the line with the newline, which would be useless, `C-t' ! 1010: transposes the last two characters on the line. So, if you catch your ! 1011: transposition error right away, you can fix it with just a `C-t'. If ! 1012: you don't catch it so fast, you must move the cursor back to between ! 1013: the two transposed characters. If you transposed a space with the last ! 1014: character of the word before it, the word motion commands are a good ! 1015: way of getting there. Otherwise, a reverse search (`C-r') is often the ! 1016: best way. *Note Search::. ! 1017: ! 1018: `Meta-t' (`transpose-words') transposes the word before point with ! 1019: the word after point. It moves point forward over a word, dragging the ! 1020: word preceding or containing point forward as well. The punctuation ! 1021: characters between the words do not move. For example, `FOO, BAR' ! 1022: transposes into `BAR, FOO' rather than `BAR FOO,'. ! 1023: ! 1024: `C-M-t' (`transpose-sexps') is a similar command for transposing two ! 1025: expressions (*note Lists::.), and `C-x C-t' (`transpose-lines') ! 1026: exchanges lines. They work like `M-t' except in determining the ! 1027: division of the text into syntactic units. ! 1028: ! 1029: A numeric argument to a transpose command serves as a repeat count: ! 1030: it tells the transpose command to move the character (word, sexp, line) ! 1031: before or containing point across several other characters (words, ! 1032: sexps, lines). For example, `C-u 3 C-t' moves the character before ! 1033: point forward across three other characters. This is equivalent to ! 1034: repeating `C-t' three times. `C-u - 4 M-t' moves the word before point ! 1035: backward across four words. `C-u - C-M-t' would cancel the effect of ! 1036: plain `C-M-t'. ! 1037: ! 1038: A numeric argument of zero is assigned a special meaning (because ! 1039: otherwise a command with a repeat count of zero would do nothing): to ! 1040: transpose the character (word, sexp, line) ending after point with the ! 1041: one ending after the mark. ! 1042: ! 1043: ! 1044: File: emacs, Node: Fixing Case, Next: Spelling, Prev: Transpose, Up: Fixit ! 1045: ! 1046: Case Conversion ! 1047: =============== ! 1048: ! 1049: `M-- M-l' ! 1050: Convert last word to lower case. Note `Meta--' is Meta-minus. ! 1051: ! 1052: `M-- M-u' ! 1053: Convert last word to all upper case. ! 1054: ! 1055: `M-- M-c' ! 1056: Convert last word to lower case with capital initial. ! 1057: ! 1058: A very common error is to type words in the wrong case. Because of ! 1059: this, the word case-conversion commands `M-l', `M-u' and `M-c' have a ! 1060: special feature when used with a negative argument: they do not move the ! 1061: cursor. As soon as you see you have mistyped the last word, you can ! 1062: simply case-convert it and go on typing. *Note Case::. ! 1063: ! 1064: ! 1065: File: emacs, Node: Spelling, Prev: Fixing Case, Up: Fixit ! 1066: ! 1067: Checking and Correcting Spelling ! 1068: ================================ ! 1069: ! 1070: `M-$' ! 1071: Check and correct spelling of word (`spell-word'). ! 1072: ! 1073: `M-x spell-buffer' ! 1074: Check and correct spelling of each word in the buffer. ! 1075: ! 1076: `M-x spell-region' ! 1077: Check and correct spelling of each word in the region. ! 1078: ! 1079: `M-x spell-string' ! 1080: Check spelling of specified word. ! 1081: ! 1082: To check the spelling of the word before point, and optionally ! 1083: correct it as well, use the command `M-$' (`spell-word'). This command ! 1084: runs an inferior process containing the `spell' program to see whether ! 1085: the word is correct English. If it is not, it asks you to edit the ! 1086: word (in the minibuffer) into a corrected spelling, and then does a ! 1087: `query-replace' to substitute the corrected spelling for the old one ! 1088: throughout the buffer. ! 1089: ! 1090: If you exit the minibuffer without altering the original spelling, it ! 1091: means you do not want to do anything to that word. Then the ! 1092: `query-replace' is not done. ! 1093: ! 1094: `M-x spell-buffer' checks each word in the buffer the same way that ! 1095: `spell-word' does, doing a `query-replace' if appropriate for every ! 1096: incorrect word. ! 1097: ! 1098: `M-x spell-region' is similar but operates only on the region, not ! 1099: the entire buffer. ! 1100: ! 1101: `M-x spell-string' reads a string as an argument and checks whether ! 1102: that is a correctly spelled English word. It prints in the echo area a ! 1103: message giving the answer. ! 1104: ! 1105: ! 1106: File: emacs, Node: Files, Next: Buffers, Prev: Fixit, Up: Top ! 1107: ! 1108: File Handling ! 1109: ************* ! 1110: ! 1111: The basic unit of stored data in Unix is the "file". To edit a file, ! 1112: you must tell Emacs to examine the file and prepare a buffer containing ! 1113: a copy of the file's text. This is called "visiting" the file. Editing ! 1114: commands apply directly to text in the buffer; that is, to the copy ! 1115: inside Emacs. Your changes appear in the file itself only when you ! 1116: "save" the buffer back into the file. ! 1117: ! 1118: In addition to visiting and saving files, Emacs can delete, copy, ! 1119: rename, and append to files, and operate on file directories. ! 1120: ! 1121: * Menu: ! 1122: ! 1123: * File Names:: How to type and edit file name arguments. ! 1124: * Visiting:: Visiting a file prepares Emacs to edit the file. ! 1125: * Saving:: Saving makes your changes permanent. ! 1126: * Reverting:: Reverting cancels all the changes not saved. ! 1127: * Auto Save:: Auto Save periodically protects against loss of data. ! 1128: * ListDir:: Listing the contents of a file directory. ! 1129: * Dired:: "Editing" a directory to delete, rename, etc. ! 1130: the files in it. ! 1131: * Misc File Ops:: Other things you can do on files. ! 1132: ! 1133:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.