X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=info%2Fxemacs.info-6;h=e6c1b6f64cbeca03eaade73e089feb2b01cabda5;hb=98769b42a33fd8236341ac4175165b2dab7ceae4;hp=7aad8042e0a5119c1b5e6bc97eba1d65d1795fdf;hpb=d8bd7eee3147c839d3c74d1823c139cd54867a75;p=chise%2Fxemacs-chise.git diff --git a/info/xemacs.info-6 b/info/xemacs.info-6 index 7aad804..e6c1b6f 100644 --- a/info/xemacs.info-6 +++ b/info/xemacs.info-6 @@ -1,4 +1,4 @@ -This is ../info/xemacs.info, produced by makeinfo version 4.0 from +This is ../info/xemacs.info, produced by makeinfo version 4.0b from xemacs/xemacs.texi. INFO-DIR-SECTION XEmacs Editor @@ -30,6 +30,409 @@ versions, except that the sections entitled "The GNU Manifesto", translation approved by the author instead of in the original English.  +File: xemacs.info, Node: Rectangles, Next: Registers, Prev: Accumulating Text, Up: Top + +Rectangles +========== + + The rectangle commands affect rectangular areas of text: all +characters between a certain pair of columns, in a certain range of +lines. Commands are provided to kill rectangles, yank killed +rectangles, clear them out, or delete them. Rectangle commands are +useful with text in multicolumnar formats, like code with comments at +the right, or for changing text into or out of such formats. + + To specify the rectangle a command should work on, put the mark at +one corner and point at the opposite corner. The specified rectangle is +called the "region-rectangle" because it is controlled about the same +way the region is controlled. Remember that a given combination of +point and mark values can be interpreted either as specifying a region +or as specifying a rectangle; it is up to the command that uses them to +choose the interpretation. + +`M-x delete-rectangle' + Delete the text of the region-rectangle, moving any following text + on each line leftward to the left edge of the region-rectangle. + +`M-x kill-rectangle' + Similar, but also save the contents of the region-rectangle as the + "last killed rectangle". + +`M-x yank-rectangle' + Yank the last killed rectangle with its upper left corner at point. + +`M-x open-rectangle' + Insert blank space to fill the space of the region-rectangle. The + previous contents of the region-rectangle are pushed rightward. + +`M-x clear-rectangle' + Clear the region-rectangle by replacing its contents with spaces. + + The rectangle operations fall into two classes: commands deleting and +moving rectangles, and commands for blank rectangles. + + There are two ways to get rid of the text in a rectangle: you can +discard the text (delete it) or save it as the "last killed" rectangle. +The commands for these two ways are `M-x delete-rectangle' and `M-x +kill-rectangle'. In either case, the portion of each line that falls +inside the rectangle's boundaries is deleted, causing following text +(if any) on the line to move left. + + Note that "killing" a rectangle is not killing in the usual sense; +the rectangle is not stored in the kill ring, but in a special place +that only records the most recently killed rectangle (that is, does not +append to a killed rectangle). Different yank commands have to be used +and only one rectangle is stored, because yanking a rectangle is quite +different from yanking linear text and yank-popping commands are +difficult to make sense of. + + Inserting a rectangle is the opposite of deleting one. You specify +where to put the upper left corner by putting point there. The +rectangle's first line is inserted at point, the rectangle's second line +is inserted at a point one line vertically down, and so on. The number +of lines affected is determined by the height of the saved rectangle. + + To insert the last killed rectangle, type `M-x yank-rectangle'. +This can be used to convert single-column lists into double-column +lists; kill the second half of the list as a rectangle and then yank it +beside the first line of the list. + + There are two commands for working with blank rectangles: `M-x +clear-rectangle' erases existing text, and `M-x open-rectangle' inserts +a blank rectangle. Clearing a rectangle is equivalent to deleting it +and then inserting a blank rectangle of the same size. + + Rectangles can also be copied into and out of registers. *Note +Rectangle Registers: RegRect. + + +File: xemacs.info, Node: Registers, Next: Display, Prev: Rectangles, Up: Top + +Registers +********* + + XEmacs "registers" are places in which you can save text or +positions for later use. Once you save text or a rectangle in a +register, you can copy it into the buffer once or many times; a position +saved in a register is used by moving point to that position. +Rectangles can also be copied into and out of registers (*note +Rectangles::). + + Each register has a name which is a single character. A register can +store a piece of text, a rectangle, a position, a window configuration, +or a file name, but only one thing at any given time. Whatever you +store in a register remains there until you store something else in that +register. To see what a register R contains, use `M-x view-register'. + +`M-x view-register R' + Display a description of what register R contains. + + `M-x view-register' reads a register name as an argument and then +displays the contents of the specified register. + +* Menu: + +* Position: RegPos. Saving positions in registers. +* Text: RegText. Saving text in registers. +* Rectangle: RegRect. Saving rectangles in registers. +* Configurations: RegConfig. Saving window configurations in registers. +* Files: RegFiles. File names in registers. +* Numbers: RegNumbers. Numbers in registers. +* Bookmarks:: Bookmarks are like registers, but persistent. + + +File: xemacs.info, Node: RegPos, Next: RegText, Prev: Registers, Up: Registers + +Saving Positions in Registers +============================= + + Saving a position records a place in a buffer so that you can move +back there later. Moving to a saved position switches to that buffer +and moves point to that place in it. + +`C-x r R' + Save position of point in register R (`point-to-register'). + +`C-x r j R' + Jump to the position saved in register R (`jump-to-register'). + + To save the current position of point in a register, choose a name R +and type `C-x r R'. The register R retains the position thus +saved until you store something else in that register. + + The command `C-x r j R' moves point to the position recorded in +register R. The register is not affected; it continues to record the +same location. You can jump to the same position using the same +register as often as you want. + + If you use `C-x r j' to go to a saved position, but the buffer it +was saved from has been killed, `C-x r j' tries to create the buffer +again by visiting the same file. Of course, this works only for buffers +that were visiting files. + + +File: xemacs.info, Node: RegText, Next: RegRect, Prev: RegPos, Up: Registers + +Saving Text in Registers +======================== + + When you want to insert a copy of the same piece of text many times, +it can be impractical to use the kill ring, since each subsequent kill +moves the piece of text further down on the ring. It becomes hard to +keep track of the argument needed to retrieve the same text with `C-y'. +An alternative is to store the text in a register with `C-x r s' +(`copy-to-register') and then retrieve it with `C-x r i' +(`insert-register'). + +`C-x r s R' + Copy region into register R (`copy-to-register'). + +`C-x r g R' +`C-x r i R' + Insert text contents of register R (`insert-register'). + + `C-x r s R' stores a copy of the text of the region into the +register named R. Given a numeric argument, `C-x r s R' deletes the +text from the buffer as well. + + `C-x r i R' inserts the text from register R in the buffer. By +default it leaves point before the text and places the mark after it. +With a numeric argument (`C-u'), it puts point after the text and the +mark before it. + + +File: xemacs.info, Node: RegRect, Next: RegConfig, Prev: RegText, Up: Registers + +Saving Rectangles in Registers +============================== + + A register can contain a rectangle instead of lines of text. The +rectangle is represented as a list of strings. *Note Rectangles::, for +basic information on rectangles and how to specify rectangles in a +buffer. + +`C-x r r R' + Copy the region-rectangle into register R + (`copy-rectangle-to-register'). With a numeric argument, delete it + as well. + +`C-x r g R' +`C-x r i R' + Insert the rectangle stored in register R (if it contains a + rectangle) (`insert-register'). + + The `C-x r i R' command inserts linear text if the register +contains that, or inserts a rectangle if the register contains one. + + See also the command `sort-columns', which you can think of as +sorting a rectangle. *Note Sorting::. + + +File: xemacs.info, Node: RegConfig, Next: RegNumbers, Prev: RegRect, Up: Registers + +Saving Window Configurations in Registers +========================================= + + You can save the window configuration of the selected frame in a +register, or even the configuration of all windows in all frames, and +restore the configuration later. + +`C-x r w R' + Save the state of the selected frame's windows in register R + (`window-configuration-to-register'). + +`M-x frame-configuration-to-register R' + Save the state of all frames, including all their windows, in + register R (`frame-configuration-to-register'). + + Use `C-x r j R' to restore a window or frame configuration. This is +the same command used to restore a cursor position. When you restore a +frame configuration, any existing frames not included in the +configuration become invisible. If you wish to delete these frames +instead, use `C-u C-x r j R'. + + +File: xemacs.info, Node: RegNumbers, Next: RegFiles, Prev: RegConfig, Up: Registers + +Keeping Numbers in Registers +============================ + + There are commands to store a number in a register, to insert the +number in the buffer in decimal, and to increment it. These commands +can be useful in keyboard macros (*note Keyboard Macros::). + +`C-u NUMBER C-x r n REG' + Store NUMBER into register REG (`number-to-register'). + +`C-u NUMBER C-x r + REG' + Increment the number in register REG by NUMBER + (`increment-register'). + +`C-x r g REG' + Insert the number from register REG into the buffer. + + `C-x r g' is the same command used to insert any other sort of +register contents into the buffer. + + +File: xemacs.info, Node: RegFiles, Next: Bookmarks, Prev: RegNumbers, Up: Registers + +Keeping File Names in Registers +=============================== + + If you visit certain file names frequently, you can visit them more +conveniently if you put their names in registers. Here's the Lisp code +used to put a file name in a register: + + (set-register ?R '(file . NAME)) + +For example, + + (set-register ?z '(file . "/usr/src/xemacs/src/ChangeLog")) + +puts the file name shown in register `z'. + + To visit the file whose name is in register R, type `C-x r j R'. +(This is the same command used to jump to a position or restore a frame +configuration.) + + +File: xemacs.info, Node: Bookmarks, Prev: RegFiles, Up: Registers + +Bookmarks +========= + + "Bookmarks" are somewhat like registers in that they record +positions you can jump to. Unlike registers, they have long names, and +they persist automatically from one Emacs session to the next. The +prototypical use of bookmarks is to record "where you were reading" in +various files. + + Note: bookmark.el is distributed in edit-utils package. You need to +install that to use bookmark facility (*note Packages::). + +`C-x r m ' + Set the bookmark for the visited file, at point. + +`C-x r m BOOKMARK ' + Set the bookmark named BOOKMARK at point (`bookmark-set'). + +`C-x r b BOOKMARK ' + Jump to the bookmark named BOOKMARK (`bookmark-jump'). + +`C-x r l' + List all bookmarks (`list-bookmarks'). + +`M-x bookmark-save' + Save all the current bookmark values in the default bookmark file. + + The prototypical use for bookmarks is to record one current position +in each of several files. So the command `C-x r m', which sets a +bookmark, uses the visited file name as the default for the bookmark +name. If you name each bookmark after the file it points to, then you +can conveniently revisit any of those files with `C-x r b', and move to +the position of the bookmark at the same time. + + To display a list of all your bookmarks in a separate buffer, type +`C-x r l' (`list-bookmarks'). If you switch to that buffer, you can +use it to edit your bookmark definitions or annotate the bookmarks. +Type `C-h m' in that buffer for more information about its special +editing commands. + + When you kill XEmacs, XEmacs offers to save your bookmark values in +your default bookmark file, `~/.emacs.bmk', if you have changed any +bookmark values. You can also save the bookmarks at any time with the +`M-x bookmark-save' command. The bookmark commands load your default +bookmark file automatically. This saving and loading is how bookmarks +persist from one XEmacs session to the next. + + If you set the variable `bookmark-save-flag' to 1, then each command +that sets a bookmark will also save your bookmarks; this way, you don't +lose any bookmark values even if XEmacs crashes. (The value, if a +number, says how many bookmark modifications should go by between +saving.) + + Bookmark position values are saved with surrounding context, so that +`bookmark-jump' can find the proper position even if the file is +modified slightly. The variable `bookmark-search-size' says how many +characters of context to record, on each side of the bookmark's +position. + + Here are some additional commands for working with bookmarks: + +`M-x bookmark-load FILENAME ' + Load a file named FILENAME that contains a list of bookmark + values. You can use this command, as well as `bookmark-write', to + work with other files of bookmark values in addition to your + default bookmark file. + +`M-x bookmark-write FILENAME ' + Save all the current bookmark values in the file FILENAME. + +`M-x bookmark-delete BOOKMARK ' + Delete the bookmark named BOOKMARK. + +`M-x bookmark-insert-location BOOKMARK ' + Insert in the buffer the name of the file that bookmark BOOKMARK + points to. + +`M-x bookmark-insert BOOKMARK ' + Insert in the buffer the _contents_ of the file that bookmark + BOOKMARK points to. + + +File: xemacs.info, Node: Display, Next: Search, Prev: Registers, Up: Top + +Controlling the Display +*********************** + + Since only part of a large buffer fits in the window, XEmacs tries +to show the part that is likely to be interesting. The display control +commands allow you to specify which part of the text you want to see. + +`C-l' + Clear frame and redisplay, scrolling the selected window to center + point vertically within it (`recenter'). + +`C-v' +`pgdn' +`next' + Scroll forward (a windowful or a specified number of lines) + (`scroll-up'). On most X keyboards, you can get this + functionality using the key labelled `Page Down', which generates + either `next' or `pgdn'. + +`M-v' +`pgup' +`prior' + Scroll backward (`scroll-down'). On most X keyboards, you can get + this functionality using the key labelled `Page Up', which + generates either `prior' or `pgup'. + +`ARG C-l' + Scroll so point is on line ARG (`recenter'). + +`C-x <' +`C-pgdn' +`C-next' + Scroll text in current window to the left (`scroll-left'). + +`C-x >' +`C-pgup' +`C-prior' + Scroll to the right (`scroll-right'). + +`C-x $' + Make deeply indented lines invisible (`set-selective-display'). + +* Menu: + +* Scrolling:: Moving text up and down in a window. +* Horizontal Scrolling:: Moving text left and right in a window. +* Selective Display:: Hiding lines with lots of indentation. +* Display Vars:: Information on variables for customizing display. + + File: xemacs.info, Node: Scrolling, Next: Horizontal Scrolling, Prev: Display, Up: Display Scrolling @@ -582,612 +985,3 @@ regexp and non-regexp searches have independent defaults. way of incremental regexp search with `M-C-s '; similarly for `re-search-backward' with `M-C-r '. - -File: xemacs.info, Node: Regexps, Next: Search Case, Prev: Regexp Search, Up: Search - -Syntax of Regular Expressions -============================= - - Regular expressions have a syntax in which a few characters are -special constructs and the rest are "ordinary". An ordinary character -is a simple regular expression that matches that character and nothing -else. The special characters are `.', `*', `+', `?', `[', `]', `^', -`$', and `\'; no new special characters will be defined in the future. -Any other character appearing in a regular expression is ordinary, -unless a `\' precedes it. - - For example, `f' is not a special character, so it is ordinary, and -therefore `f' is a regular expression that matches the string `f' and -no other string. (It does _not_ match the string `ff'.) Likewise, `o' -is a regular expression that matches only `o'. - - Any two regular expressions A and B can be concatenated. The result -is a regular expression that matches a string if A matches some amount -of the beginning of that string and B matches the rest of the string. - - As a simple example, we can concatenate the regular expressions `f' -and `o' to get the regular expression `fo', which matches only the -string `fo'. Still trivial. To do something more powerful, you need -to use one of the special characters. Here is a list of them: - -`. (Period)' - is a special character that matches any single character except a - newline. Using concatenation, we can make regular expressions - like `a.b', which matches any three-character string that begins - with `a' and ends with `b'. - -`*' - is not a construct by itself; it is a quantifying suffix operator - that means to repeat the preceding regular expression as many - times as possible. In `fo*', the `*' applies to the `o', so `fo*' - matches one `f' followed by any number of `o's. The case of zero - `o's is allowed: `fo*' does match `f'. - - `*' always applies to the _smallest_ possible preceding - expression. Thus, `fo*' has a repeating `o', not a repeating `fo'. - - The matcher processes a `*' construct by matching, immediately, as - many repetitions as can be found; it is "greedy". Then it - continues with the rest of the pattern. If that fails, - backtracking occurs, discarding some of the matches of the - `*'-modified construct in case that makes it possible to match the - rest of the pattern. For example, in matching `ca*ar' against the - string `caaar', the `a*' first tries to match all three `a's; but - the rest of the pattern is `ar' and there is only `r' left to - match, so this try fails. The next alternative is for `a*' to - match only two `a's. With this choice, the rest of the regexp - matches successfully. - - Nested repetition operators can be extremely slow if they specify - backtracking loops. For example, it could take hours for the - regular expression `\(x+y*\)*a' to match the sequence - `xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz'. The slowness is because - Emacs must try each imaginable way of grouping the 35 `x''s before - concluding that none of them can work. To make sure your regular - expressions run fast, check nested repetitions carefully. - -`+' - is a quantifying suffix operator similar to `*' except that the - preceding expression must match at least once. It is also - "greedy". So, for example, `ca+r' matches the strings `car' and - `caaaar' but not the string `cr', whereas `ca*r' matches all three - strings. - -`?' - is a quantifying suffix operator similar to `*', except that the - preceding expression can match either once or not at all. For - example, `ca?r' matches `car' or `cr', but does not match anything - else. - -`*?' - works just like `*', except that rather than matching the longest - match, it matches the shortest match. `*?' is known as a - "non-greedy" quantifier, a regexp construct borrowed from Perl. - - This construct is very useful for when you want to match the text - inside a pair of delimiters. For instance, `/\*.*?\*/' will match - C comments in a string. This could not easily be achieved without - the use of a non-greedy quantifier. - - This construct has not been available prior to XEmacs 20.4. It is - not available in FSF Emacs. - -`+?' - is the non-greedy version of `+'. - -`??' - is the non-greedy version of `?'. - -`\{n,m\}' - serves as an interval quantifier, analogous to `*' or `+', but - specifies that the expression must match at least N times, but no - more than M times. This syntax is supported by most Unix regexp - utilities, and has been introduced to XEmacs for the version 20.3. - - Unfortunately, the non-greedy version of this quantifier does not - exist currently, although it does in Perl. - -`[ ... ]' - `[' begins a "character set", which is terminated by a `]'. In - the simplest case, the characters between the two brackets form - the set. Thus, `[ad]' matches either one `a' or one `d', and - `[ad]*' matches any string composed of just `a's and `d's - (including the empty string), from which it follows that `c[ad]*r' - matches `cr', `car', `cdr', `caddaar', etc. - - The usual regular expression special characters are not special - inside a character set. A completely different set of special - characters exists inside character sets: `]', `-' and `^'. - - `-' is used for ranges of characters. To write a range, write two - characters with a `-' between them. Thus, `[a-z]' matches any - lower case letter. Ranges may be intermixed freely with individual - characters, as in `[a-z$%.]', which matches any lower case letter - or `$', `%', or a period. - - To include a `]' in a character set, make it the first character. - For example, `[]a]' matches `]' or `a'. To include a `-', write - `-' as the first character in the set, or put it immediately after - a range. (You can replace one individual character C with the - range `C-C' to make a place to put the `-'.) There is no way to - write a set containing just `-' and `]'. - - To include `^' in a set, put it anywhere but at the beginning of - the set. - -`[^ ... ]' - `[^' begins a "complement character set", which matches any - character except the ones specified. Thus, `[^a-z0-9A-Z]' matches - all characters _except_ letters and digits. - - `^' is not special in a character set unless it is the first - character. The character following the `^' is treated as if it - were first (thus, `-' and `]' are not special there). - - Note that a complement character set can match a newline, unless - newline is mentioned as one of the characters not to match. - -`^' - is a special character that matches the empty string, but only at - the beginning of a line in the text being matched. Otherwise it - fails to match anything. Thus, `^foo' matches a `foo' that occurs - at the beginning of a line. - - When matching a string instead of a buffer, `^' matches at the - beginning of the string or after a newline character `\n'. - -`$' - is similar to `^' but matches only at the end of a line. Thus, - `x+$' matches a string of one `x' or more at the end of a line. - - When matching a string instead of a buffer, `$' matches at the end - of the string or before a newline character `\n'. - -`\' - has two functions: it quotes the special characters (including - `\'), and it introduces additional special constructs. - - Because `\' quotes special characters, `\$' is a regular - expression that matches only `$', and `\[' is a regular expression - that matches only `[', and so on. - - *Please note:* For historical compatibility, special characters are -treated as ordinary ones if they are in contexts where their special -meanings make no sense. For example, `*foo' treats `*' as ordinary -since there is no preceding expression on which the `*' can act. It is -poor practice to depend on this behavior; quote the special character -anyway, regardless of where it appears. - - For the most part, `\' followed by any character matches only that -character. However, there are several exceptions: characters that, -when preceded by `\', are special constructs. Such characters are -always ordinary when encountered on their own. Here is a table of `\' -constructs: - -`\|' - specifies an alternative. Two regular expressions A and B with - `\|' in between form an expression that matches anything that - either A or B matches. - - Thus, `foo\|bar' matches either `foo' or `bar' but no other string. - - `\|' applies to the largest possible surrounding expressions. - Only a surrounding `\( ... \)' grouping can limit the grouping - power of `\|'. - - Full backtracking capability exists to handle multiple uses of - `\|'. - -`\( ... \)' - is a grouping construct that serves three purposes: - - 1. To enclose a set of `\|' alternatives for other operations. - Thus, `\(foo\|bar\)x' matches either `foox' or `barx'. - - 2. To enclose an expression for a suffix operator such as `*' to - act on. Thus, `ba\(na\)*' matches `bananana', etc., with any - (zero or more) number of `na' strings. - - 3. To record a matched substring for future reference. - - This last application is not a consequence of the idea of a - parenthetical grouping; it is a separate feature that happens to be - assigned as a second meaning to the same `\( ... \)' construct - because there is no conflict in practice between the two meanings. - Here is an explanation of this feature: - -`\DIGIT' - matches the same text that matched the DIGITth occurrence of a `\( - ... \)' construct. - - In other words, after the end of a `\( ... \)' construct. the - matcher remembers the beginning and end of the text matched by that - construct. Then, later on in the regular expression, you can use - `\' followed by DIGIT to match that same text, whatever it may - have been. - - The strings matching the first nine `\( ... \)' constructs - appearing in a regular expression are assigned numbers 1 through 9 - in the order that the open parentheses appear in the regular - expression. So you can use `\1' through `\9' to refer to the text - matched by the corresponding `\( ... \)' constructs. - - For example, `\(.*\)\1' matches any newline-free string that is - composed of two identical halves. The `\(.*\)' matches the first - half, which may be anything, but the `\1' that follows must match - the same exact text. - -`\(?: ... \)' - is called a "shy" grouping operator, and it is used just like `\( - ... \)', except that it does not cause the matched substring to be - recorded for future reference. - - This is useful when you need a lot of grouping `\( ... \)' - constructs, but only want to remember one or two - or if you have - more than nine groupings and need to use backreferences to refer to - the groupings at the end. - - Using `\(?: ... \)' rather than `\( ... \)' when you don't need - the captured substrings ought to speed up your programs some, - since it shortens the code path followed by the regular expression - engine, as well as the amount of memory allocation and string - copying it must do. The actual performance gain to be observed - has not been measured or quantified as of this writing. - - The shy grouping operator has been borrowed from Perl, and has not - been available prior to XEmacs 20.3, nor is it available in FSF - Emacs. - -`\w' - matches any word-constituent character. The editor syntax table - determines which characters these are. *Note Syntax::. - -`\W' - matches any character that is not a word constituent. - -`\sCODE' - matches any character whose syntax is CODE. Here CODE is a - character that represents a syntax code: thus, `w' for word - constituent, `-' for whitespace, `(' for open parenthesis, etc. - *Note Syntax::, for a list of syntax codes and the characters that - stand for them. - -`\SCODE' - matches any character whose syntax is not CODE. - - The following regular expression constructs match the empty -string--that is, they don't use up any characters--but whether they -match depends on the context. - -`\`' - matches the empty string, but only at the beginning of the buffer - or string being matched against. - -`\'' - matches the empty string, but only at the end of the buffer or - string being matched against. - -`\=' - matches the empty string, but only at point. (This construct is - not defined when matching against a string.) - -`\b' - matches the empty string, but only at the beginning or end of a - word. Thus, `\bfoo\b' matches any occurrence of `foo' as a - separate word. `\bballs?\b' matches `ball' or `balls' as a - separate word. - -`\B' - matches the empty string, but _not_ at the beginning or end of a - word. - -`\<' - matches the empty string, but only at the beginning of a word. - -`\>' - matches the empty string, but only at the end of a word. - - Here is a complicated regexp used by Emacs to recognize the end of a -sentence together with any whitespace that follows. It is given in Lisp -syntax to enable you to distinguish the spaces from the tab characters. -In Lisp syntax, the string constant begins and ends with a -double-quote. `\"' stands for a double-quote as part of the regexp, -`\\' for a backslash as part of the regexp, `\t' for a tab and `\n' for -a newline. - - "[.?!][]\"')]*\\($\\|\t\\| \\)[ \t\n]*" - -This regexp contains four parts: a character set matching period, `?' -or `!'; a character set matching close-brackets, quotes or parentheses, -repeated any number of times; an alternative in backslash-parentheses -that matches end-of-line, a tab or two spaces; and a character set -matching whitespace characters, repeated any number of times. - - -File: xemacs.info, Node: Search Case, Next: Replace, Prev: Regexps, Up: Search - -Searching and Case -================== - - All searches in Emacs normally ignore the case of the text they are -searching through; if you specify searching for `FOO', `Foo' and `foo' -are also considered a match. Regexps, and in particular character -sets, are included: `[aB]' matches `a' or `A' or `b' or `B'. - - If you want a case-sensitive search, set the variable -`case-fold-search' to `nil'. Then all letters must match exactly, -including case. `case-fold-search' is a per-buffer variable; altering -it affects only the current buffer, but there is a default value which -you can change as well. *Note Locals::. You can also use Case -Sensitive Search from the Options menu on your screen. - - -File: xemacs.info, Node: Replace, Next: Other Repeating Search, Prev: Search Case, Up: Search - -Replacement Commands -==================== - - Global search-and-replace operations are not needed as often in -Emacs as they are in other editors, but they are available. In -addition to the simple `replace-string' command which is like that -found in most editors, there is a `query-replace' command which asks -you, for each occurrence of a pattern, whether to replace it. - - The replace commands all replace one string (or regexp) with one -replacement string. It is possible to perform several replacements in -parallel using the command `expand-region-abbrevs'. *Note Expanding -Abbrevs::. - -* Menu: - -* Unconditional Replace:: Replacing all matches for a string. -* Regexp Replace:: Replacing all matches for a regexp. -* Replacement and Case:: How replacements preserve case of letters. -* Query Replace:: How to use querying. - - -File: xemacs.info, Node: Unconditional Replace, Next: Regexp Replace, Prev: Replace, Up: Replace - -Unconditional Replacement -------------------------- - -`M-x replace-string STRING NEWSTRING ' - Replace every occurrence of STRING with NEWSTRING. - -`M-x replace-regexp REGEXP NEWSTRING ' - Replace every match for REGEXP with NEWSTRING. - - To replace every instance of `foo' after point with `bar', use the -command `M-x replace-string' with the two arguments `foo' and `bar'. -Replacement occurs only after point: if you want to cover the whole -buffer you must go to the beginning first. By default, all occurrences -up to the end of the buffer are replaced. To limit replacement to part -of the buffer, narrow to that part of the buffer before doing the -replacement (*note Narrowing::). - - When `replace-string' exits, point is left at the last occurrence -replaced. The value of point when the `replace-string' command was -issued is remembered on the mark ring; `C-u C-' moves back there. - - A numeric argument restricts replacement to matches that are -surrounded by word boundaries. - - -File: xemacs.info, Node: Regexp Replace, Next: Replacement and Case, Prev: Unconditional Replace, Up: Replace - -Regexp Replacement ------------------- - - `replace-string' replaces exact matches for a single string. The -similar command `replace-regexp' replaces any match for a specified -pattern. - - In `replace-regexp', the NEWSTRING need not be constant. It can -refer to all or part of what is matched by the REGEXP. `\&' in -NEWSTRING stands for the entire text being replaced. `\D' in -NEWSTRING, where D is a digit, stands for whatever matched the D'th -parenthesized grouping in REGEXP. For example, - - M-x replace-regexp c[ad]+r \&-safe - -would replace (for example) `cadr' with `cadr-safe' and `cddr' with -`cddr-safe'. - - M-x replace-regexp \(c[ad]+r\)-safe \1 - -would perform exactly the opposite replacements. To include a `\' in -the text to replace with, you must give `\\'. - - -File: xemacs.info, Node: Replacement and Case, Next: Query Replace, Prev: Regexp Replace, Up: Replace - -Replace Commands and Case -------------------------- - - If the arguments to a replace command are in lower case, the command -preserves case when it makes a replacement. Thus, the following -command: - - M-x replace-string foo bar - -replaces a lower-case `foo' with a lower case `bar', `FOO' with `BAR', -and `Foo' with `Bar'. If upper-case letters are used in the second -argument, they remain upper-case every time that argument is inserted. -If upper-case letters are used in the first argument, the second -argument is always substituted exactly as given, with no case -conversion. Likewise, if the variable `case-replace' is set to `nil', -replacement is done without case conversion. If `case-fold-search' is -set to `nil', case is significant in matching occurrences of `foo' to -replace; also, case conversion of the replacement string is not done. - - -File: xemacs.info, Node: Query Replace, Prev: Replacement and Case, Up: Replace - -Query Replace -------------- - -`M-% STRING NEWSTRING ' -`M-x query-replace STRING NEWSTRING ' - Replace some occurrences of STRING with NEWSTRING. - -`M-x query-replace-regexp REGEXP NEWSTRING ' - Replace some matches for REGEXP with NEWSTRING. - - If you want to change only some of the occurrences of `foo' to -`bar', not all of them, you can use `query-replace' instead of `M-%'. -This command finds occurrences of `foo' one by one, displays each -occurrence, and asks you whether to replace it. A numeric argument to -`query-replace' tells it to consider only occurrences that are bounded -by word-delimiter characters. - - Aside from querying, `query-replace' works just like -`replace-string', and `query-replace-regexp' works just like -`replace-regexp'. - - The things you can type when you are shown an occurrence of STRING -or a match for REGEXP are: - -`' - to replace the occurrence with NEWSTRING. This preserves case, - just like `replace-string', provided `case-replace' is non-`nil', - as it normally is. - -`' - to skip to the next occurrence without replacing this one. - -`, (Comma)' - to replace this occurrence and display the result. You are then - prompted for another input character. However, since the - replacement has already been made, and are equivalent. - At this point, you can type `C-r' (see below) to alter the - replaced text. To undo the replacement, you can type `C-x u'. - This exits the `query-replace'. If you want to do further - replacement you must use `C-x ESC' to restart (*note Repetition::). - -`' - to exit without doing any more replacements. - -`. (Period)' - to replace this occurrence and then exit. - -`!' - to replace all remaining occurrences without asking again. - -`^' - to go back to the location of the previous occurrence (or what - used to be an occurrence), in case you changed it by mistake. - This works by popping the mark ring. Only one `^' in a row is - allowed, because only one previous replacement location is kept - during `query-replace'. - -`C-r' - to enter a recursive editing level, in case the occurrence needs - to be edited rather than just replaced with NEWSTRING. When you - are done, exit the recursive editing level with `C-M-c' and the - next occurrence will be displayed. *Note Recursive Edit::. - -`C-w' - to delete the occurrence, and then enter a recursive editing level - as in `C-r'. Use the recursive edit to insert text to replace the - deleted occurrence of STRING. When done, exit the recursive - editing level with `C-M-c' and the next occurrence will be - displayed. - -`C-l' - to redisplay the screen and then give another answer. - -`C-h' - to display a message summarizing these options, then give another - answer. - - If you type any other character, Emacs exits the `query-replace', and -executes the character as a command. To restart the `query-replace', -use `C-x ', which repeats the `query-replace' because it used the -minibuffer to read its arguments. *Note C-x ESC: Repetition. - - -File: xemacs.info, Node: Other Repeating Search, Prev: Replace, Up: Search - -Other Search-and-Loop Commands -============================== - - Here are some other commands that find matches for a regular -expression. They all operate from point to the end of the buffer. - -`M-x occur' - Print each line that follows point and contains a match for the - specified regexp. A numeric argument specifies the number of - context lines to print before and after each matching line; the - default is none. - - The buffer `*Occur*' containing the output serves as a menu for - finding occurrences in their original context. Find an occurrence - as listed in `*Occur*', position point there, and type `C-c C-c'; - this switches to the buffer that was searched and moves point to - the original of the same occurrence. - -`M-x list-matching-lines' - Synonym for `M-x occur'. - -`M-x count-matches' - Print the number of matches following point for the specified - regexp. - -`M-x delete-non-matching-lines' - Delete each line that follows point and does not contain a match - for the specified regexp. - -`M-x delete-matching-lines' - Delete each line that follows point and contains a match for the - specified regexp. - - -File: xemacs.info, Node: Fixit, Next: Files, Prev: Search, Up: Top - -Commands for Fixing Typos -************************* - - This chapter describes commands that are especially useful when you -catch a mistake in your text just after you have made it, or when you -change your mind while composing text on line. - -* Menu: - -* Kill Errors:: Commands to kill a batch of recently entered text. -* Transpose:: Exchanging two characters, words, lines, lists... -* Fixing Case:: Correcting case of last word entered. -* Spelling:: Apply spelling checker to a word, or a whole file. - - -File: xemacs.info, Node: Kill Errors, Next: Transpose, Prev: Fixit, Up: Fixit - -Killing Your Mistakes -===================== - -`' - Delete last character (`delete-backward-char'). - -`M-' - Kill last word (`backward-kill-word'). - -`C-x ' - Kill to beginning of sentence (`backward-kill-sentence'). - - The character (`delete-backward-char') is the most important -correction command. When used among graphic (self-inserting) -characters, it can be thought of as canceling the last character typed. - - When your mistake is longer than a couple of characters, it might be -more convenient to use `M-' or `C-x '. `M-' kills back -to the start of the last word, and `C-x ' kills back to the start -of the last sentence. `C-x ' is particularly useful when you are -thinking of what to write as you type it, in case you change your mind -about phrasing. `M-' and `C-x ' save the killed text for -`C-y' and `M-y' to retrieve. *Note Yanking::. - - `M-' is often useful even when you have typed only a few -characters wrong, if you know you are confused in your typing and aren't -sure exactly what you typed. At such a time, you cannot correct with - except by looking at the screen to see what you did. It requires -less thought to kill the whole word and start over. -