@table @code
@item [.?!]
-The first part of the pattern consists of three characters, a period, a
-question mark and an exclamation mark, within square brackets. The
+The first part of the pattern is a character set that matches any one of
+three characters: period, question mark, and exclamation mark. The
match must begin with one of these three characters.
@item []\"')@}]*
preceding regular expression (a character set, in this case) may be
repeated zero or more times.
-@item \\($\\|@ \\|\t\\|@ @ \\)
+@item \\($\\|@ $\\|\t\\|@ @ \\)
The third part of the pattern matches the whitespace that follows the
end of a sentence: the end of a line, or a tab, or two spaces. The
double backslashes mark the parentheses and vertical bars as regular
-expression syntax; the parentheses mark the group and the vertical bars
+expression syntax; the parentheses delimit a group and the vertical bars
separate alternatives. The dollar sign is used to match the end of a
line.
text that is matched by the regular expression @var{regexp}, leaving
point at the beginning of the first text found.
-This function is analogous to @code{re-search-forward}, but they are
-not simple mirror images. @code{re-search-forward} finds the match
-whose beginning is as close as possible. If @code{re-search-backward}
-were a perfect mirror image, it would find the match whose end is as
-close as possible. However, in fact it finds the match whose beginning
-is as close as possible. The reason is that matching a regular
-expression at a given spot always works from beginning to end, and is
-done at a specified beginning position.
+This function is analogous to @code{re-search-forward}, but they are not
+simple mirror images. @code{re-search-forward} finds the match whose
+beginning is as close as possible to the starting point. If
+@code{re-search-backward} were a perfect mirror image, it would find the
+match whose end is as close as possible. However, in fact it finds the
+match whose beginning is as close as possible. The reason is that
+matching a regular expression at a given spot always works from
+beginning to end, and starts at a specified beginning position.
A true mirror-image of @code{re-search-forward} would require a special
feature for matching regexps from end to beginning. It's not worth the
returns after considering that many occurrences.
Normally, the keymap @code{query-replace-map} defines the possible user
-responses. The argument @var{map}, if non-@code{nil}, is a keymap to
-use instead of @code{query-replace-map}.
+responses for queries. The argument @var{map}, if non-@code{nil}, is a
+keymap to use instead of @code{query-replace-map}.
@end defun
@defvar query-replace-map
Do not take action for this question---in other words, ``no.''
@item exit
-Answer this question ``no,'' and don't ask any more.
+Answer this question ``no,'' and give up on the entire series of
+questions, assuming that the answers will be ``no.''
@item act-and-exit
-Answer this question ``yes,'' and don't ask any more.
+Answer this question ``yes,'' and give up on the entire series of
+questions, assuming that subsequent answers will be ``no.''
@item act-and-show
Answer this question ``yes,'' but show the results---don't advance yet
This function returns the position of the start of text matched by the
last regular expression searched for, or a subexpression of it.
-The argument @var{count}, a number, specifies a subexpression whose
-start position is the value. If @var{count} is zero, then the value is
-the position of the text matched by the whole regexp. If @var{count} is
-greater than zero, then the value is the position of the beginning of
-the text matched by the @var{count}th subexpression.
+If @var{count} is zero, then the value is the position of the start of
+the text matched by the whole regexp. Otherwise, @var{count}, specifies
+a subexpression in the regular expresion. The value of the function is
+the starting position of the match for that subexpression.
Subexpressions of a regular expression are those expressions grouped
-inside of parentheses, @samp{\(@dots{}\)}. The @var{count}th
+with escaped parentheses, @samp{\(@dots{}\)}. The @var{count}th
subexpression is found by counting occurrences of @samp{\(} from the
beginning of the whole regular expression. The first subexpression is
numbered 1, the second 2, and so on.
-The value is @code{nil} for a parenthetical grouping inside of a
+The value is @code{nil} for a subexpression inside a
@samp{\|} alternative that wasn't used in the match.
@end defun
(re-search-forward "The \\(cat \\)")
(match-beginning 0)
(match-beginning 1))
- @result{} (t 9 13)
+ @result{} (9 9 13)
@end group
@group
letter, @code{replace-match} considers this a capitalized first word
rather than all upper case.
+If @code{case-replace} is @code{nil}, then case conversion is not done,
+regardless of the value of @var{fixed-case}. @xref{Searching and Case}.
+
If @var{literal} is non-@code{nil}, then @var{replacement} is inserted
exactly as it is, the only alterations being case changes as needed.
If it is @code{nil} (the default), then the character @samp{\} is treated
@item @samp{\@var{n}}
@cindex @samp{\@var{n}} in replacement
-@samp{\@var{n}} stands for the text that matched the @var{n}th
-subexpression in the original regexp. Subexpressions are those
-expressions grouped inside of @samp{\(@dots{}\)}. @var{n} is a digit.
+@samp{\@var{n}}, where @var{n} is a digit, stands for the text that
+matched the @var{n}th subexpression in the original regexp.
+Subexpressions are those expressions grouped inside @samp{\(@dots{}\)}.
@item @samp{\\}
@cindex @samp{\} in replacement
If you do not want this feature, set the variable
@code{case-fold-search} to @code{nil}. Then all letters must match
-exactly, including case. This is a per-buffer-local variable; altering
-the variable affects only the current buffer. (@xref{Intro to
+exactly, including case. This is a buffer-local variable; altering the
+variable affects only the current buffer. (@xref{Intro to
Buffer-Local}.) Alternatively, you may change the value of
@code{default-case-fold-search}, which is the default value of
@code{case-fold-search} for buffers that do not override it.
searching functions Lisp functions use.
@defopt case-replace
-This variable determines whether @code{query-replace} should preserve
-case in replacements. If the variable is @code{nil}, then
-@code{replace-match} should not try to convert case.
+This variable determines whether the replacement functions should
+preserve case. If the variable is @code{nil}, that means to use the
+replacement text verbatim. A non-@code{nil} value means to convert the
+case of the replacement text according to the text being replaced.
+
+The function @code{replace-match} is where this variable actually has
+its effect. @xref{Replacing Match}.
@end defopt
@defopt case-fold-search
@defvar page-delimiter
This is the regexp describing line-beginnings that separate pages. The
-default value is @code{"^\014"} (i.e., @code{"^^L"} or @code{"^\C-l"}).
+default value is @code{"^\014"} (i.e., @code{"^^L"} or @code{"^\C-l"});
+this matches a line that starts with a formfeed character.
@end defvar
@defvar paragraph-separate
This is the regular expression for recognizing the beginning of a line
that separates paragraphs. (If you change this, you may have to
-change @code{paragraph-start} also.) The default value is @code{"^[
-\t\f]*$"}, which is a line that consists entirely of spaces, tabs, and
-form feeds.
+change @code{paragraph-start} also.) The default value is
+@w{@code{"^[@ \t\f]*$"}}, which matches a line that consists entirely of
+spaces, tabs, and form feeds.
@end defvar
@defvar paragraph-start
This is the regular expression for recognizing the beginning of a line
that starts @emph{or} separates paragraphs. The default value is
-@code{"^[ \t\n\f]"}, which matches a line starting with a space, tab,
+@w{@code{"^[@ \t\n\f]"}}, which matches a line starting with a space, tab,
newline, or form feed.
@end defvar
is:
@example
-"[.?!][]\"')@}]*\\($\\|\t\\| \\)[ \t\n]*"
+"[.?!][]\"')@}]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
@end example
-This means a period, question mark or exclamation mark, followed by a
-closing brace, followed by tabs, spaces or new lines.
+This means a period, question mark or exclamation mark, followed
+optionally by a closing parenthetical character, followed by tabs,
+spaces or new lines.
For a detailed explanation of this regular expression, see @ref{Regexp
Example}.
terminates a statement. To support these variations, Emacs makes the
choice of syntax table local to each buffer. Typically, each major
mode has its own syntax table and installs that table in each buffer
-which uses that mode. Changing this table alters the syntax in all
+that uses that mode. Changing this table alters the syntax in all
those buffers as well as in any buffers subsequently put in that mode.
Occasionally several similar modes share one syntax table.
@xref{Example Major Modes}, for an example of how to set up a syntax
between the class of a character in one syntax table and its class in
any other table.
- Each class is designated by a mnemonic character which serves as the
+ Each class is designated by a mnemonic character, which serves as the
name of the class when you need to specify a class. Usually the
-designator character is one which is frequently put in that class;
-however, its meaning as a designator is unvarying and independent of
-what syntax that character currently has.
+designator character is one that is frequently in that class; however,
+its meaning as a designator is unvarying and independent of what syntax
+that character currently has.
@cindex syntax descriptor
- A syntax descriptor is a Lisp string which specifies a syntax class, a
+ A syntax descriptor is a Lisp string that specifies a syntax class, a
matching character (used only for the parenthesis classes) and flags.
The first character is the designator for a syntax class. The second
character is the character to match; if it is unused, put a space there.
@node Syntax Class Table
@subsection Table of Syntax Classes
- Here is a table syntax classes, the characters that stand for them,
+ Here is a table of syntax classes, the characters that stand for them,
their meanings, and examples of their use.
@deffn {Syntax class} @w{whitespace character}
@deffn {Syntax class} @w{word constituent}
@dfn{Word constituents} (designated with @samp{w}) are parts of normal
English words and are typically used in variable and command names in
-programs. All upper and lower case letters and the digits are typically
+programs. All upper- and lower-case letters, and the digits, are typically
word constituents.
@end deffn
@dfn{Paired delimiter characters} (designated with @samp{$}) are like
string quote characters except that the syntactic properties of the
characters between the delimiters are not suppressed. Only @TeX{} mode
-uses a paired identical delimiter presently---the @samp{$} that both
-enters and leaves math mode.
+uses a paired delimiter presently---the @samp{$} that both enters and
+leaves math mode.
@end deffn
@deffn {Syntax class} @w{expression prefix}
@itemize @bullet
@item
-@samp{1} means @var{c} is the start of a two-character comment start
+@samp{1} means @var{c} is the start of a two-character comment-start
sequence.
@item
@samp{2} means @var{c} is the second character of such a sequence.
@item
-@samp{3} means @var{c} is the start of a two-character comment end
+@samp{3} means @var{c} is the start of a two-character comment-end
sequence.
@item
The two comment-start sequences must begin with the same character; only
the second character may differ. Mark the second character of the
-``b''-style comment start sequence with the @samp{b} flag.
+``b''-style comment-start sequence with the @samp{b} flag.
A comment-end sequence (one or two characters) applies to the ``b''
style if its first character has the @samp{b} flag set; otherwise, it
@samp{>b}
@end table
-Thus @samp{/*} is a comment-start sequence for ``a'' style, @samp{//}
-is a comment-start sequence for ``b'' style, @samp{*/} is a
-comment-end sequence for ``a'' style, and newline is a comment-end
-sequence for ``b'' style.
+This defines four comment-delimiting sequences:
+
+@table @asis
+@item @samp{/*}
+This is a comment-start sequence for ``a'' style because the
+second character, @samp{*}, does not have the @samp{b} flag.
+
+@item @samp{//}
+This is a comment-start sequence for ``b'' style because the second
+character, @samp{/}, does have the @samp{b} flag.
+
+@item @samp{*/}
+This is a comment-end sequence for ``a'' style because the first
+character, @samp{*}, does not have the @samp{b} flag
+
+@item newline
+This is a comment-end sequence for ``b'' style, because the newline
+character has the @samp{b} flag.
+@end table
@item
@c Emacs 19 feature
@defun make-syntax-table
This function creates a new syntax table. Character codes 0 through
-31, and 128 through 255, are set up to inherit from the standard syntax
+31 and 128 through 255 are set up to inherit from the standard syntax
table. The other character codes are set up by copying what the
standard syntax table says about them.
;; @r{the first character of a start-comment sequence,}
;; @r{and the second character of an end-comment sequence.}
;; @r{This is used in C mode.}
-(modify-syntax-entry ?/ ".13")
+(modify-syntax-entry ?/ ". 14")
@result{} nil
@end group
@end example
The following examples apply to C mode. The first example shows that
the syntax class of space is whitespace (represented by a space). The
second example shows that the syntax of @samp{/} is punctuation. This
-does not show the fact that it is also part of comment start and end
-sequence. The third example shows that open parenthesis is in the class
+does not show the fact that it is also part of comment-start and -end
+sequences. The third example shows that open parenthesis is in the class
of open parentheses. This does not show the fact that it has a matching
character, @samp{)}.
@defun skip-syntax-forward syntaxes &optional limit
This function moves point forward across characters having syntax classes
mentioned in @var{syntaxes}. It stops when it encounters the end of
-the buffer, or position @var{lim} (if specified), or a character it is
+the buffer, or position @var{limit} (if specified), or a character it is
not supposed to skip.
@ignore @c may want to change this.
The return value is the distance traveled, which is a nonnegative
@defun skip-syntax-backward syntaxes &optional limit
This function moves point backward across characters whose syntax
classes are mentioned in @var{syntaxes}. It stops when it encounters
-the beginning of the buffer, or position @var{lim} (if specified), or a
+the beginning of the buffer, or position @var{limit} (if specified), or a
character it is not supposed to skip.
@ignore @c may want to change this.
The return value indicates the distance traveled. It is an integer that
@defun parse-partial-sexp start limit &optional target-depth stop-before state stop-comment
This function parses a sexp in the current buffer starting at
-@var{start}, not scanning past @var{limit}. It stops at @var{limit} or
-when certain criteria described below are met, and sets to the location
-where parsing stops. It returns a value describing the status of the
-parse at the point where it stops.
+@var{start}, not scanning past @var{limit}. It stops at position
+@var{limit} or when certain criteria described below are met, and sets
+point to the location where parsing stops. It returns a value
+describing the status of the parse at the point where it stops.
If @var{state} is @code{nil}, @var{start} is assumed to be at the top
level of parenthesis structure, such as the beginning of a function
@item
@cindex innermost containing parentheses
-The character position of the start of the innermost containing
-parenthetical grouping; @code{nil} if none.
+The character position of the start of the innermost parenthetical
+grouping containing the stopping point; @code{nil} if none.
@item
@cindex previous complete subexpression
@item
@cindex inside comment
-@code{t} if inside a comment.
+@code{t} if inside a comment (of either style).
@item
@cindex quote character
value. The only candidates for stopping are places where the depth in
parentheses becomes zero; @code{scan-lists} counts @var{count} such
places and then stops. Thus, a positive value for @var{depth} means go
-out levels of parenthesis.
+out @var{depth} levels of parenthesis.
Scanning ignores comments if @code{parse-sexp-ignore-comments} is
non-@code{nil}.
-If scan reaches the beginning or end of the buffer (or its accessible
-portion), and the depth is not zero, an error is signaled. If the depth
-is zero but the count is not used up, @code{nil} is returned.
+If the scan reaches the beginning or end of the buffer (or its
+accessible portion), and the depth is not zero, an error is signaled.
+If the depth is zero but the count is not used up, @code{nil} is
+returned.
@end defun
@defun scan-sexps from count
Scanning ignores comments if @code{parse-sexp-ignore-comments} is
non-@code{nil}.
-If scan reaches the beginning or end of (the accessible part of) the
+If the scan reaches the beginning or end of (the accessible part of) the
buffer in the middle of a parenthetical grouping, an error is signaled.
If it reaches the beginning or end between groupings but before count is
used up, @code{nil} is returned.
To move forward over all comments and whitespace following point, use
@code{(forward-comment (buffer-size))}. @code{(buffer-size)} is a good
-argument to use, because the number of comments to in the buffer cannot
+argument to use, because the number of comments in the buffer cannot
exceed that many.
@node Standard Syntax Tables
HCoop / bpt / emacs.git / commitdiff