-\1f
-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
- 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 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 FIXED-CASE. *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
- 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'. (In Emacs 18 and earlier versions,
- markers were used even for matching on a string, except in the case
- of the integer 0.)
-
- 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':
-
- - Macro: 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 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 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 table
- This function constructs a copy of TABLE and returns it. If TABLE
- is not supplied (or is `nil'), it returns a copy of the current
- syntax table. Otherwise, an error is signaled if TABLE is not a
- syntax table.
-
- - Command: modify-syntax-entry char syntax-descriptor &optional table
- This function sets the syntax entry for CHAR according to
- SYNTAX-DESCRIPTOR. The syntax is changed only for 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 this character is discarded.
-
- An error is signaled if the first character of the syntax
- descriptor is not one of the twelve syntax class designator
- characters. An error is also signaled if CHAR is not a character.
-
- 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
- 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 CHAR is not a character.
-
- 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 table &optional buffer
- This function makes TABLE the syntax table for BUFFER, which
- defaults to the current buffer if omitted. It returns 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.
-