@c -*-texinfo-*-
@c This is part of the GNU Emacs Lisp Reference Manual.
-@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999
-@c Free Software Foundation, Inc.
+@c Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2002, 2003,
+@c 2004, 2005, 2006 Free Software Foundation, Inc.
@c See the file elisp.texi for copying conditions.
@setfilename ../info/syntax
@node Syntax Tables, Abbrevs, Searching and Matching, Top
@dfn{Punctuation characters} (designated by @samp{.}) 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
+Some programming language modes, such as Emacs Lisp mode, have no
characters in this class since the few characters that are not symbol or
-word constituents all have other uses.
+word constituents all have other uses. Other programming language modes,
+such as C mode, use punctuation syntax for operators.
@end deffn
@deffn {Syntax class} @w{open parenthesis character}
@deffn {Syntax class} @w{inherit}
This syntax class does not specify a particular syntax. It says to look
in the standard syntax table to find the syntax of this character. The
-designator for this syntax code is @samp{@@}.
+designator for this syntax class is @samp{@@}.
@end deffn
@deffn {Syntax class} @w{generic comment delimiter}
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 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
@samp{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.
+according to their usual syntax classes.
The function @code{backward-prefix-chars} moves back over these
characters, as well as over characters whose primary syntax class is
@code{char-syntax}.
@end defun
-@defun syntax-after pos
-This function returns a description of the syntax of the character in
-the buffer after position @var{pos}, taking account of syntax
-properties as well as the syntax table.
-
-The value is usually a syntax class character; however, if the buffer
-character has parenthesis syntax, the value is a cons cell of the form
-@code{(@var{class} . @var{match})}, where @var{class} is the syntax
-class character and @var{match} is the buffer character's matching
-parenthesis.
-@end defun
-
@defun set-syntax-table table
This function makes @var{table} the syntax table for the current buffer.
It returns @var{table}.
the current buffer.
@end defun
-@defmac with-syntax-table @var{table} @var{body}...
-@tindex with-syntax-table
+@defmac with-syntax-table @var{table} @var{body}@dots{}
This macro executes @var{body} using @var{table} as the current syntax
table. It returns the value of the last form in @var{body}, after
restoring the old current syntax table.
@section Syntax Properties
@kindex syntax-table @r{(text property)}
-When the syntax table is not flexible enough to specify the syntax of a
-language, you can use @code{syntax-table} text properties to override
-the syntax table for specific character occurrences in the buffer.
-@xref{Text Properties}.
+When the syntax table is not flexible enough to specify the syntax of
+a language, you can use @code{syntax-table} text properties to
+override the syntax table for specific character occurrences in the
+buffer. @xref{Text Properties}. You can use Font Lock mode to set
+@code{syntax-table} text properties. @xref{Setting Syntax
+Properties}.
The valid values of @code{syntax-table} text property are:
@defun skip-syntax-forward syntaxes &optional limit
This function moves point forward across characters having syntax
-classes mentioned in @var{syntaxes} (a string of syntax code
+classes mentioned in @var{syntaxes} (a string of syntax class
characters). It stops when it encounters the end of the buffer, or
position @var{limit} (if specified), or a character it is not supposed
to skip.
string, or the end of a comment or a string, whichever comes first.
@cindex parse state
-The fifth argument @var{state} is a nine-element list of the same form
-as the value of this function, described below. (It is OK to omit the
-last element of the nine.) The return value of one call may be used to
-initialize the state of the parse on another call to
-@code{parse-partial-sexp}.
+The fifth argument @var{state} is a ten-element list of the same form
+as the value of this function, described below. The return value of
+one call may be used to initialize the state of the parse on another
+call to @code{parse-partial-sexp}.
-The result is a list of nine elements describing the final state of
+The result is a list of ten elements describing the final state of
the parse:
@enumerate 0
@item
-The depth in parentheses, counting from 0.
+The depth in parentheses, counting from 0. @strong{Warning:} this can
+be negative if there are more close parens than open parens between
+the start of the defun and point.
@item
@cindex innermost containing parentheses
@item
What kind of comment is active: @code{nil} for a comment of style
``a'' or when not inside a comment, @code{t} for a comment of style
-``b'', and @code{syntax-table} for a comment that should be ended by a
+``b,'' and @code{syntax-table} for a comment that should be ended by a
generic comment delimiter character.
@item
the position where the comment began; while inside a string, this is the
position where the string began. When outside of strings and comments,
this element is @code{nil}.
-@end enumerate
-Elements 0, 3, 4, 5 and 7 are significant in the argument @var{state}.
+@item
+Internal data for continuing the parsing. The meaning of this
+data is subject to change; it is used if you pass this list
+as the @var{state} argument to another call.
+@end enumerate
-Actually, the return value is currently a list of ten, rather than
-nine, elements and @var{state} is allowed to be a list of ten elements
-as well. However, the meaning of the tenth element is subject to
-change and only the first eight elements of @var{state} need to be
-specified.
+Elements 1, 2, and 6 are ignored in the argument @var{state}. Element
+8 is used only to set the corresponding element of the return value,
+in certain simple cases. Element 9 is used only to set element 1 of
+the return value, in trivial cases where parsing starts and stops
+within the same pair of parentheses.
@cindex indenting with parentheses
This function is most often used to compute indentation for languages
that have nested parentheses.
@end defun
+@defun syntax-ppss &optional pos
+This function returns the state that the parser would have at position
+@var{pos}, if it were started with a default start state at the
+beginning of the buffer. Thus, it is equivalent to
+@code{(parse-partial-sexp (point-min) @var{pos})}, except that
+@code{syntax-ppss} uses a cache to speed up the computation. Also,
+the 2nd value (previous complete subexpression) and 6th value (minimum
+parenthesis depth) of the returned state are not meaningful.
+@end defun
+
+@defun syntax-ppss-flush-cache beg
+This function flushes the cache used by @code{syntax-ppss}, starting at
+position @var{beg}.
+
+When @code{syntax-ppss} is called, it automatically hooks itself
+to @code{before-change-functions} to keep its cache consistent.
+But this can fail if @code{syntax-ppss} is called while
+@code{before-change-functions} is temporarily let-bound, or if the
+buffer is modified without obeying the hook, such as when using
+@code{inhibit-modification-hooks}. For this reason, it is sometimes
+necessary to flush the cache manually.
+@end defun
+
+@defvar syntax-begin-function
+If this is non-@code{nil}, it should be a function that moves to an
+earlier buffer position where the parser state is equivalent to
+@code{nil}---in other words, a position outside of any comment,
+string, or parenthesis. @code{syntax-ppss} uses it to supplement its
+cache.
+@end defvar
+
@defun scan-lists from count depth
This function scans forward @var{count} balanced parenthetical groupings
from position @var{from}. It returns the position where the scan stops.
@end defun
@defvar multibyte-syntax-as-symbol
-@tindex multibyte-syntax-as-symbol
If this variable is non-@code{nil}, @code{scan-sexps} treats all
non-@acronym{ASCII} characters as symbol constituents regardless
of what the syntax table says about them. (However, text properties
@end defopt
@vindex parse-sexp-lookup-properties
-The behaviour of @code{parse-partial-sexp} is also affected by
+The behavior of @code{parse-partial-sexp} is also affected by
@code{parse-sexp-lookup-properties} (@pxref{Syntax Properties}).
You can use @code{forward-comment} to move forward or backward over
This table gives the value of @var{syntax-code} which corresponds
to each syntactic type.
-@multitable @columnfractions .05 .3 .3 .3
+@multitable @columnfractions .05 .3 .3 .31
@item
@tab
@i{Integer} @i{Class}
@var{matching-char})} corresponding to the syntax descriptor @var{desc}.
@end defun
+@defun syntax-after pos
+This function returns the syntax code of the character in the buffer
+after position @var{pos}, taking account of syntax properties as well
+as the syntax table. If @var{pos} is outside the buffer's accessible
+portion (@pxref{Narrowing, accessible portion}), this function returns
+@code{nil}.
+@end defun
+
+@defun syntax-class syntax
+This function returns the syntax class of the syntax code
+@var{syntax}. (It masks off the high 16 bits that hold the flags
+encoded in the syntax descriptor.) If @var{syntax} is @code{nil}, it
+returns @code{nil}; this is so evaluating the expression
+
+@example
+(syntax-class (syntax-after pos))
+@end example
+
+@noindent
+where @code{pos} is outside the buffer's accessible portion, will
+yield @code{nil} without throwing errors or producing wrong syntax
+class codes.
+@end defun
+
@node Categories
@section Categories
@cindex categories of characters
@defun define-category char docstring &optional table
This function defines a new category, with name @var{char} and
-documentation @var{docstring}, for the category table @var{table},
+documentation @var{docstring}, for the category table @var{table}.
@end defun
@defun category-docstring category &optional table
@end defun
@defun make-category-table
-@tindex make-category-table
This creates and returns an empty category table. In an empty category
table, no categories have been allocated, and no characters belong to
any categories.