+File: lispref.info, Node: Replacing Match, Next: Entire Match Data, Prev: Simple Match Data, Up: Match Data
+
+Replacing the Text That Matched
+-------------------------------
+
+ This function replaces the text matched by the last search with
+REPLACEMENT.
+
+ - Function: replace-match replacement &optional fixedcase literal
+ string strbuffer
+ This function replaces the text in the buffer (or in STRING) that
+ was matched by the last search. It replaces that text with
+ REPLACEMENT.
+
+ If you did the last search in a buffer, you should specify `nil'
+ for STRING. Then `replace-match' does the replacement by editing
+ the buffer; it leaves point at the end of the replacement text,
+ and returns `t'.
+
+ If you did the search in a string, pass the same string as STRING.
+ Then `replace-match' does the replacement by constructing and
+ returning a new string.
+
+ If the fourth argument STRING is a string, fifth argument
+ STRBUFFER specifies the buffer to be used for syntax-table and
+ case-table lookup and defaults to the current buffer. When STRING
+ is not a string, the buffer that the match occurred in has
+ automatically been remembered and you do not need to specify it.
+
+ If FIXEDCASE is non-`nil', then the case of the replacement text
+ is not changed; otherwise, the replacement text is converted to a
+ different case depending upon the capitalization of the text to be
+ replaced. If the original text is all upper case, the replacement
+ text is converted to upper case. If the first word of the
+ original text is capitalized, then the first word of the
+ replacement text is capitalized. If the original text contains
+ just one word, and that word is a capital letter, `replace-match'
+ considers this a capitalized first word rather than all upper case.
+
+ If `case-replace' is `nil', then case conversion is not done,
+ regardless of the value of FIXEDCASE. *Note Searching and Case::.
+
+ If LITERAL is non-`nil', then REPLACEMENT is inserted exactly as
+ it is, the only alterations being case changes as needed. If it
+ is `nil' (the default), then the character `\' is treated
+ specially. If a `\' appears in REPLACEMENT, then it must be part
+ of one of the following sequences:
+
+ `\&'
+ `\&' stands for the entire text being replaced.
+
+ `\N'
+ `\N', where N is a digit, stands for the text that matched
+ the Nth subexpression in the original regexp. Subexpressions
+ are those expressions grouped inside `\(...\)'.
+
+ `\\'
+ `\\' stands for a single `\' in the replacement text.
+
+\1f
+File: lispref.info, Node: Entire Match Data, Next: Saving Match Data, Prev: Replacing Match, Up: Match Data
+
+Accessing the Entire Match Data
+-------------------------------
+
+ The functions `match-data' and `set-match-data' read or write the
+entire match data, all at once.
+
+ - Function: match-data &optional integers reuse
+ This function returns a newly constructed list containing all the
+ information on what text the last search matched. Element zero is
+ the position of the beginning of the match for the whole
+ expression; element one is the position of the end of the match
+ for the expression. The next two elements are the positions of
+ the beginning and end of the match for the first subexpression,
+ and so on. In general, element number 2N corresponds to
+ `(match-beginning N)'; and element number 2N + 1 corresponds to
+ `(match-end N)'.
+
+ All the elements are markers or `nil' if matching was done on a
+ buffer, and all are integers or `nil' if matching was done on a
+ string with `string-match'. However, if the optional first
+ argument INTEGERS is non-`nil', always use integers (rather than
+ markers) to represent buffer positions.
+
+ If the optional second argument REUSE is a list, reuse it as part
+ of the value. If REUSE is long enough to hold all the values, and
+ if INTEGERS is non-`nil', no new lisp objects are created.
+
+ As always, there must be no possibility of intervening searches
+ between the call to a search function and the call to `match-data'
+ that is intended to access the match data for that search.
+
+ (match-data)
+ => (#<marker at 9 in foo>
+ #<marker at 17 in foo>
+ #<marker at 13 in foo>
+ #<marker at 17 in foo>)
+
+ - Function: set-match-data match-list
+ This function sets the match data from the elements of MATCH-LIST,
+ which should be a list that was the value of a previous call to
+ `match-data'.
+
+ If MATCH-LIST refers to a buffer that doesn't exist, you don't get
+ an error; that sets the match data in a meaningless but harmless
+ way.
+
+ `store-match-data' is an alias for `set-match-data'.
+
+\1f
+File: lispref.info, Node: Saving Match Data, Prev: Entire Match Data, Up: Match Data
+
+Saving and Restoring the Match Data
+-----------------------------------
+
+ When you call a function that may do a search, you may need to save
+and restore the match data around that call, if you want to preserve the
+match data from an earlier search for later use. Here is an example
+that shows the problem that arises if you fail to save the match data:
+
+ (re-search-forward "The \\(cat \\)")
+ => 48
+ (foo) ; Perhaps `foo' does
+ ; more searching.
+ (match-end 0)
+ => 61 ; Unexpected result--not 48!
+
+ You can save and restore the match data with `save-match-data':
+
+ - Special Form: save-match-data body...
+ This special form executes BODY, saving and restoring the match
+ data around it.
+
+ You can use `set-match-data' together with `match-data' to imitate
+the effect of the special form `save-match-data'. This is useful for
+writing code that can run in Emacs 18. Here is how:
+
+ (let ((data (match-data)))
+ (unwind-protect
+ ... ; May change the original match data.
+ (set-match-data data)))
+
+ Emacs automatically saves and restores the match data when it runs
+process filter functions (*note Filter Functions::) and process
+sentinels (*note Sentinels::).
+
+\1f
+File: lispref.info, Node: Searching and Case, Next: Standard Regexps, Prev: Match Data, Up: Searching and Matching
+
+Searching and Case
+==================
+
+ By default, searches in Emacs ignore the case of the text they are
+searching through; if you specify searching for `FOO', then `Foo' or
+`foo' is also considered a match. Regexps, and in particular character
+sets, are included: thus, `[aB]' would match `a' or `A' or `b' or `B'.
+
+ If you do not want this feature, set the variable `case-fold-search'
+to `nil'. Then all letters must match exactly, including case. This
+is a buffer-local variable; altering the variable affects only the
+current buffer. (*Note Intro to Buffer-Local::.) Alternatively, you
+may change the value of `default-case-fold-search', which is the
+default value of `case-fold-search' for buffers that do not override it.
+
+ Note that the user-level incremental search feature handles case
+distinctions differently. When given a lower case letter, it looks for
+a match of either case, but when given an upper case letter, it looks
+for an upper case letter only. But this has nothing to do with the
+searching functions Lisp functions use.
+
+ - User Option: case-replace
+ This variable determines whether the replacement functions should
+ preserve case. If the variable is `nil', that means to use the
+ replacement text verbatim. A non-`nil' value means to convert the
+ case of the replacement text according to the text being replaced.
+
+ The function `replace-match' is where this variable actually has
+ its effect. *Note Replacing Match::.
+
+ - User Option: case-fold-search
+ This buffer-local variable determines whether searches should
+ ignore case. If the variable is `nil' they do not ignore case;
+ otherwise they do ignore case.
+
+ - Variable: default-case-fold-search
+ The value of this variable is the default value for
+ `case-fold-search' in buffers that do not override it. This is the
+ same as `(default-value 'case-fold-search)'.
+
+\1f
+File: lispref.info, Node: Standard Regexps, Prev: Searching and Case, Up: Searching and Matching
+
+Standard Regular Expressions Used in Editing
+============================================
+
+ This section describes some variables that hold regular expressions
+used for certain purposes in editing:
+
+ - Variable: page-delimiter
+ This is the regexp describing line-beginnings that separate pages.
+ The default value is `"^\014"' (i.e., `"^^L"' or `"^\C-l"'); this
+ matches a line that starts with a formfeed character.
+
+ The following two regular expressions should _not_ assume the match
+always starts at the beginning of a line; they should not use `^' to
+anchor the match. Most often, the paragraph commands do check for a
+match only at the beginning of a line, which means that `^' would be
+superfluous. When there is a nonzero left margin, they accept matches
+that start after the left margin. In that case, a `^' would be
+incorrect. However, a `^' is harmless in modes where a left margin is
+never used.
+
+ - Variable: 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 `paragraph-start' also.) The default value is
+ `"[ \t\f]*$"', which matches a line that consists entirely of
+ spaces, tabs, and form feeds (after its left margin).
+
+ - Variable: paragraph-start
+ This is the regular expression for recognizing the beginning of a
+ line that starts _or_ separates paragraphs. The default value is
+ `"[ \t\n\f]"', which matches a line starting with a space, tab,
+ newline, or form feed (after its left margin).
+
+ - Variable: sentence-end
+ This is the regular expression describing the end of a sentence.
+ (All paragraph boundaries also end sentences, regardless.) The
+ default value is:
+
+ "[.?!][]\"')}]*\\($\\| $\\|\t\\| \\)[ \t\n]*"
+
+ 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 *Note
+ Regexp Example::.
+
+\1f
+File: lispref.info, Node: Syntax Tables, Next: Abbrevs, Prev: Searching and Matching, Up: Top
+
+Syntax Tables
+*************
+
+ A "syntax table" specifies the syntactic textual function of each
+character. This information is used by the parsing commands, the
+complex movement commands, and others to determine where words, symbols,
+and other syntactic constructs begin and end. The current syntax table
+controls the meaning of the word motion functions (*note Word Motion::)
+and the list motion functions (*note List Motion::) as well as the
+functions in this chapter.
+
+* Menu:
+
+* Basics: Syntax Basics. Basic concepts of syntax tables.
+* Desc: Syntax Descriptors. How characters are classified.
+* Syntax Table Functions:: How to create, examine and alter syntax tables.
+* Motion and Syntax:: Moving over characters with certain syntaxes.
+* Parsing Expressions:: Parsing balanced expressions
+ using the syntax table.
+* Standard Syntax Tables:: Syntax tables used by various major modes.
+* Syntax Table Internals:: How syntax table information is stored.
+
+\1f
+File: lispref.info, Node: Syntax Basics, Next: Syntax Descriptors, Up: Syntax Tables
+
+Syntax Table Concepts
+=====================
+
+ A "syntax table" provides Emacs with the information that determines
+the syntactic use of each character in a buffer. This information is
+used by the parsing commands, the complex movement commands, and others
+to determine where words, symbols, and other syntactic constructs begin
+and end. The current syntax table controls the meaning of the word
+motion functions (*note Word Motion::) and the list motion functions
+(*note List Motion::) as well as the functions in this chapter.
+
+ Under XEmacs 20, a syntax table is a particular subtype of the
+primitive char table type (*note Char Tables::), and each element of the
+char table is an integer that encodes the syntax of the character in
+question, or a cons of such an integer and a matching character (for
+characters with parenthesis syntax).
+
+ Under XEmacs 19, a syntax table is a vector of 256 elements; it
+contains one entry for each of the 256 possible characters in an 8-bit
+byte. Each element is an integer that encodes the syntax of the
+character in question. (The matching character, if any, is embedded in
+the bits of this integer.)
+
+ Syntax tables are used only for moving across text, not for the Emacs
+Lisp reader. XEmacs Lisp uses built-in syntactic rules when reading
+Lisp expressions, and these rules cannot be changed.
+
+ Each buffer has its own major mode, and each major mode has its own
+idea of the syntactic class of various characters. For example, in Lisp
+mode, the character `;' begins a comment, but in C mode, it terminates
+a statement. To support these variations, XEmacs 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 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. *Note Example Major
+Modes::, for an example of how to set up a syntax table.
+
+ A syntax table can inherit the data for some characters from the
+standard syntax table, while specifying other characters itself. The
+"inherit" syntax class means "inherit this character's syntax from the
+standard syntax table." Most major modes' syntax tables inherit the
+syntax of character codes 0 through 31 and 128 through 255. This is
+useful with character sets such as ISO Latin-1 that have additional
+alphabetic characters in the range 128 to 255. Just changing the
+standard syntax for these characters affects all major modes.
+
+ - Function: syntax-table-p object
+ This function returns `t' if OBJECT is a vector of length 256
+ elements. This means that the vector may be a syntax table.
+ However, according to this test, any vector of length 256 is
+ considered to be a syntax table, no matter what its contents.
+
+\1f
+File: lispref.info, Node: Syntax Descriptors, Next: Syntax Table Functions, Prev: Syntax Basics, Up: Syntax Tables
+
+Syntax Descriptors
+==================
+
+ This section describes the syntax classes and flags that denote the
+syntax of a character, and how they are represented as a "syntax
+descriptor", which is a Lisp string that you pass to
+`modify-syntax-entry' to specify the desired syntax.
+
+ XEmacs defines a number of "syntax classes". Each syntax table puts
+each character into one class. There is no necessary relationship
+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
+name of the class when you need to specify a class. Usually the
+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.
+
+ 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.
+Then come the characters for any desired flags. If no matching
+character or flags are needed, one character is sufficient.
+
+ For example, the descriptor for the character `*' in C mode is
+`. 23' (i.e., punctuation, matching character slot unused, second
+character of a comment-starter, first character of an comment-ender),
+and the entry for `/' is `. 14' (i.e., punctuation, matching character
+slot unused, first character of a comment-starter, second character of
+a comment-ender).
+
+* Menu:
+
+* Syntax Class Table:: Table of syntax classes.
+* Syntax Flags:: Additional flags each character can have.
+
+\1f
+File: lispref.info, Node: Syntax Class Table, Next: Syntax Flags, Up: Syntax Descriptors
+
+Table of Syntax Classes
+-----------------------
+
+ Here is a table of syntax classes, the characters that stand for
+them, their meanings, and examples of their use.
+
+ - Syntax class: whitespace character
+ "Whitespace characters" (designated with ` ' or `-') separate
+ symbols and words from each other. Typically, whitespace
+ characters have no other syntactic significance, and multiple
+ whitespace characters are syntactically equivalent to a single
+ one. Space, tab, newline and formfeed are almost always
+ classified as whitespace.
+
+ - Syntax class: word constituent
+ "Word constituents" (designated with `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 word constituents.
+
+ - Syntax class: symbol constituent
+ "Symbol constituents" (designated with `_') are the extra
+ characters that are used in variable and command names along with
+ word constituents. For example, the symbol constituents class is
+ used in Lisp mode to indicate that certain characters may be part
+ of symbol names even though they are not part of English words.
+ These characters are `$&*+-_<>'. In standard C, the only
+ non-word-constituent character that is valid in symbols is
+ underscore (`_').
+
+ - Syntax class: punctuation character
+ "Punctuation characters" (`.') are those characters that are used
+ as punctuation in English, or are used in some way in a programming
+ language to separate symbols from one another. Most programming
+ language modes, including Emacs Lisp mode, have no characters in
+ this class since the few characters that are not symbol or word
+ constituents all have other uses.
+
+ - Syntax class: open parenthesis character
+ - Syntax class: close parenthesis character
+ Open and close "parenthesis characters" are characters used in
+ dissimilar pairs to surround sentences or expressions. Such a
+ grouping is begun with an open parenthesis character and
+ terminated with a close. Each open parenthesis character matches
+ a particular close parenthesis character, and vice versa.
+ Normally, XEmacs indicates momentarily the matching open
+ parenthesis when you insert a close parenthesis. *Note Blinking::.
+
+ The class of open parentheses is designated with `(', and that of
+ close parentheses with `)'.
+
+ In English text, and in C code, the parenthesis pairs are `()',
+ `[]', and `{}'. In XEmacs Lisp, the delimiters for lists and
+ vectors (`()' and `[]') are classified as parenthesis characters.
+
+ - Syntax class: string quote
+ "String quote characters" (designated with `"') are used in many
+ languages, including Lisp and C, to delimit string constants. The
+ same string quote character appears at the beginning and the end
+ of a string. Such quoted strings do not nest.
+
+ The parsing facilities of XEmacs consider a string as a single
+ token. The usual syntactic meanings of the characters in the
+ string are suppressed.
+
+ The Lisp modes have two string quote characters: double-quote (`"')
+ and vertical bar (`|'). `|' is not used in XEmacs Lisp, but it is
+ used in Common Lisp. C also has two string quote characters:
+ double-quote for strings, and single-quote (`'') for character
+ constants.
+
+ English text has no string quote characters because English is not
+ a programming language. Although quotation marks are used in
+ English, we do not want them to turn off the usual syntactic
+ properties of other characters in the quotation.
+
+ - Syntax class: escape
+ An "escape character" (designated with `\') starts an escape
+ sequence such as is used in C string and character constants. The
+ character `\' belongs to this class in both C and Lisp. (In C, it
+ is used thus only inside strings, but it turns out to cause no
+ trouble to treat it this way throughout C code.)
+
+ Characters in this class count as part of words if
+ `words-include-escapes' is non-`nil'. *Note Word Motion::.
+
+ - Syntax class: character quote
+ A "character quote character" (designated with `/') quotes the
+ following character so that it loses its normal syntactic meaning.
+ This differs from an escape character in that only the character
+ immediately following is ever affected.
+
+ Characters in this class count as part of words if
+ `words-include-escapes' is non-`nil'. *Note Word Motion::.
+
+ This class is used for backslash in TeX mode.
+
+ - Syntax class: paired delimiter
+ "Paired delimiter characters" (designated with `$') 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 delimiter presently--the `$' that both enters
+ and leaves math mode.
+
+ - Syntax class: expression prefix
+ An "expression prefix operator" (designated with `'') is used for
+ syntactic operators that are part of an expression if they appear
+ next to one. These characters in Lisp include the apostrophe, `''
+ (used for quoting), the comma, `,' (used in macros), and `#' (used
+ in the read syntax for certain data types).
+
+ - Syntax class: comment starter
+ - Syntax class: comment ender
+ The "comment starter" and "comment ender" characters are used in
+ various languages to delimit comments. These classes are
+ designated with `<' and `>', respectively.
+
+ English text has no comment characters. In Lisp, the semicolon
+ (`;') starts a comment and a newline or formfeed ends one.
+
+ - Syntax class: inherit
+ This syntax class does not specify a syntax. It says to look in
+ the standard syntax table to find the syntax of this character.
+ The designator for this syntax code is `@'.
+
+\1f
+File: lispref.info, Node: Syntax Flags, Prev: Syntax Class Table, Up: Syntax Descriptors
+
+Syntax Flags
+------------
+
+ In addition to the classes, entries for characters in a syntax table
+can include flags. There are six possible flags, represented by the
+characters `1', `2', `3', `4', `b' and `p'.
+
+ All the flags except `p' are used to describe multi-character
+comment delimiters. The digit flags indicate that a character can
+_also_ be part of a comment sequence, in addition to the syntactic
+properties associated with its character class. The flags are
+independent of the class and each other for the sake of characters such
+as `*' in C mode, which is a punctuation character, _and_ the second
+character of a start-of-comment sequence (`/*'), _and_ the first
+character of an end-of-comment sequence (`*/').
+
+ The flags for a character C are:
+
+ * `1' means C is the start of a two-character comment-start sequence.
+
+ * `2' means C is the second character of such a sequence.
+
+ * `3' means C is the start of a two-character comment-end sequence.
+
+ * `4' means C is the second character of such a sequence.
+
+ * `b' means that C as a comment delimiter belongs to the alternative
+ "b" comment style.
+
+ Emacs supports two comment styles simultaneously in any one syntax
+ table. This is for the sake of C++. Each style of comment syntax
+ has its own comment-start sequence and its own comment-end
+ sequence. Each comment must stick to one style or the other;
+ thus, if it starts with the comment-start sequence of style "b",
+ it must also end with the comment-end sequence of style "b".
+
+ 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 `b'
+ flag.
+
+ A comment-end sequence (one or two characters) applies to the "b"
+ style if its first character has the `b' flag set; otherwise, it
+ applies to the "a" style.
+
+ The appropriate comment syntax settings for C++ are as follows:
+
+ `/'
+ `124b'
+
+ `*'
+ `23'
+
+ newline
+ `>b'
+
+ This defines four comment-delimiting sequences:
+
+ `/*'
+ This is a comment-start sequence for "a" style because the
+ second character, `*', does not have the `b' flag.
+
+ `//'
+ This is a comment-start sequence for "b" style because the
+ second character, `/', does have the `b' flag.
+
+ `*/'
+ This is a comment-end sequence for "a" style because the first
+ character, `*', does not have the `b' flag
+
+ newline
+ This is a comment-end sequence for "b" style, because the
+ newline character has the `b' flag.
+
+ * `p' identifies an additional "prefix character" for Lisp syntax.
+ These characters are treated as whitespace when they appear between
+ expressions. When they appear within an expression, they are
+ handled according to their usual syntax codes.
+
+ The function `backward-prefix-chars' moves back over these
+ characters, as well as over characters whose primary syntax class
+ is prefix (`''). *Note Motion and Syntax::.
+
+\1f
+File: lispref.info, Node: Syntax Table Functions, Next: Motion and Syntax, Prev: Syntax Descriptors, Up: Syntax Tables
+
+Syntax Table Functions
+======================
+
+ In this section we describe functions for creating, accessing and
+altering syntax tables.
+
+ - Function: make-syntax-table &optional oldtable
+ 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 table. The other character codes are set up by
+ copying what the standard syntax table says about them.
+
+ Most major mode syntax tables are created in this way.
+
+ - Function: copy-syntax-table &optional syntax-table
+ This function constructs a copy of SYNTAX-TABLE and returns it.
+ If SYNTAX-TABLE is not supplied (or is `nil'), it returns a copy
+ of the current syntax table. Otherwise, an error is signaled if
+ SYNTAX-TABLE is not a syntax table.
+
+ - Command: modify-syntax-entry char-range syntax-descriptor &optional
+ syntax-table
+ This function sets the syntax entry for CHAR-RANGE according to
+ SYNTAX-DESCRIPTOR. CHAR-RANGE is either a single character or a
+ range of characters, as used with `put-char-table'. The syntax is
+ changed only for SYNTAX-TABLE, which defaults to the current
+ buffer's syntax table, and not in any other syntax table. The
+ argument SYNTAX-DESCRIPTOR specifies the desired syntax; this is a
+ string beginning with a class designator character, and optionally
+ containing a matching character and flags as well. *Note Syntax
+ Descriptors::.
+
+ This function always returns `nil'. The old syntax information in
+ the table for CHAR-RANGE is discarded.
+
+ An error is signaled if the first character of the syntax
+ descriptor is not one of the twelve syntax class designator
+ characters.
+
+ Examples:
+
+ ;; Put the space character in class whitespace.
+ (modify-syntax-entry ?\ " ")
+ => nil
+
+ ;; Make `$' an open parenthesis character,
+ ;; with `^' as its matching close.
+ (modify-syntax-entry ?$ "(^")
+ => nil
+
+ ;; Make `^' a close parenthesis character,
+ ;; with `$' as its matching open.
+ (modify-syntax-entry ?^ ")$")
+ => nil
+
+ ;; Make `/' a punctuation character,
+ ;; the first character of a start-comment sequence,
+ ;; and the second character of an end-comment sequence.
+ ;; This is used in C mode.
+ (modify-syntax-entry ?/ ". 14")
+ => nil
+
+ - Function: char-syntax character &optional syntax-table
+ This function returns the syntax class of CHARACTER, represented
+ by its mnemonic designator character. This _only_ returns the
+ class, not any matching parenthesis or flags.
+
+ An error is signaled if CHARACTER is not a character.
+
+ The characters that correspond to various syntax codes are listed
+ in the documentation of `modify-syntax-entry'.
+
+ Optional second argument SYNTAX-TABLE is the syntax table to be
+ used, and defaults to the current buffer's syntax table.
+
+ 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 `/' is
+ punctuation. This 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, `)'.
+
+ (char-to-string (char-syntax ?\ ))
+ => " "
+
+ (char-to-string (char-syntax ?/))
+ => "."
+
+ (char-to-string (char-syntax ?\())
+ => "("
+
+ - Function: set-syntax-table syntax-table &optional buffer
+ This function makes SYNTAX-TABLE the syntax table for BUFFER, which
+ defaults to the current buffer if omitted. It returns
+ SYNTAX-TABLE.
+
+ - Function: syntax-table &optional buffer
+ This function returns the syntax table for BUFFER, which defaults
+ to the current buffer if omitted.
+
+\1f
+File: lispref.info, Node: Motion and Syntax, Next: Parsing Expressions, Prev: Syntax Table Functions, Up: Syntax Tables
+
+Motion and Syntax
+=================
+
+ This section describes functions for moving across characters in
+certain syntax classes. None of these functions exists in Emacs
+version 18 or earlier.
+
+ - Function: skip-syntax-forward syntaxes &optional limit buffer
+ This function moves point forward across characters having syntax
+ classes mentioned in SYNTAXES. It stops when it encounters the
+ end of the buffer, or position LIMIT (if specified), or a
+ character it is not supposed to skip. Optional argument BUFFER
+ defaults to the current buffer if omitted.
+
+ - Function: skip-syntax-backward syntaxes &optional limit buffer
+ This function moves point backward across characters whose syntax
+ classes are mentioned in SYNTAXES. It stops when it encounters
+ the beginning of the buffer, or position LIMIT (if specified), or a
+ character it is not supposed to skip. Optional argument BUFFER
+ defaults to the current buffer if omitted.
+
+
+ - Function: backward-prefix-chars &optional buffer
+ This function moves point backward over any number of characters
+ with expression prefix syntax. This includes both characters in
+ the expression prefix syntax class, and characters with the `p'
+ flag. Optional argument BUFFER defaults to the current buffer if
+ omitted.
+
+\1f