Go to the previous, next section.

Syntax Tables

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 (see section Motion by Words) and the list motion functions (see section Moving over Balanced Expressions) as well as the functions in this chapter.

A syntax table is a vector of 256 elements; it contains one entry for each of the 256 ASCII characters of an 8-bit byte. Each element is an integer that encodes the syntax of the character in question.

Syntax tables are used only for moving across text, not for the GNU Emacs Lisp reader. GNU Emacs 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, 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 those buffers as well as in any buffers subsequently put in that mode. Occasionally several similar modes share one syntax table. See section Major Mode Examples, for an example of how to set up a syntax table.

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.

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.

Emacs defines twelve 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 which is frequently put in that class; however, its meaning as a designator is unvarying and independent of how it is actually classified.

A syntax descriptor is a Lisp string which specifies a syntax class, a matching character (unused except for 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.

Thus, 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).

Table of Syntax Classes

Here is a summary of the 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 use, and multiple whitespace characters are syntactically equivalent to a single one. Space, tab, newline and formfeed are almost always considered 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, Emacs indicates momentarily the matching open parenthesis when you insert a close parenthesis. See section 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 Emacs Lisp, the delimiters for lists and vectors (`()' and `[]') are classified as parenthesis characters.

Syntax class: string quote

String quote characters (designated with `"') is used to delimit string constants in many languages, including Lisp and C. 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 Emacs 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 Emacs 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. See section Motion by Words.

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. See section Motion by Words.

This class is not currently used in any standard Emacs modes.

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 identical delimiter presently--the `$' that begins and ends 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 but are not part of an adjoining symbol. 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 different 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 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:

Syntax Table Functions

In this section we describe functions for creating, accessing and altering syntax tables.

Function: make-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.

Function: copy-syntax-table &optional table

This function is identical to make-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. See section 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 ?/ ".13")
     => 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 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 in C-mode. This does not show the fact that it is also a comment sequence character. 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

This function makes table the syntax table for the current buffer. It returns table.

Function: syntax-table

This function returns the current syntax table, which is the table for the current buffer.

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

This function moves point forward across characters whose syntax classes are mentioned in syntaxes. It stops when it encounters the end of the buffer, or position lim (if specified), or a character it is not supposed to skip.

The return value is the distance traveled, which is a nonnegative integer.

Function: skip-syntax-backward syntaxes &optional limit

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 lim (if specified), or a character it is not supposed to skip.

The return value indicates the distance traveled. It is an integer that is zero or less.

Function: backward-prefix-chars

This function moves point backward over any number of chars with expression prefix syntax. This includes both characters in the expression prefix syntax class, and characters with the `p' flag.

Parsing Balanced Expressions

Here are several functions for parsing and scanning balanced expressions. The syntax table controls the interpretation of characters, so these functions can be used for Lisp expressions when in Lisp mode and for C expressions when in C mode. See section Moving over Balanced Expressions, for convenient higher-level functions for moving over balanced expressions.

Function: parse-partial-sexp start limit &optional target-depth stop-before state stop-comment

This function parses an expression in the current buffer starting at start, not scanning past limit. Parsing stops at limit or when certain criteria described below are met; point is set to the location where parsing stops. The value returned is a description of the status of the parse at the point where it stops.

Normally, start is assumed to be the top level of an expression to be parsed, such as the beginning of a function definition. Alternatively, you might wish to resume parsing in the middle of an expression. To do this, you must provide a state argument that describes the initial status of parsing. If state is omitted (or nil), parsing assumes that start is the beginning of a new parse at level 0.

If the third argument target-depth is non-nil, parsing stops if the depth in parentheses becomes equal to target-depth. The depth starts at 0, or at whatever is given in state.

If the fourth argument stop-before is non-nil, parsing stops when it comes to any character that starts a sexp. If stop-comment is non-nil, parsing stops when it comes to the start of a comment.

The fifth argument state is a seven-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 parse-partial-sexp.

The result is a list of seven elements describing the final state of the parse:

  1. The depth in parentheses, starting at 0.

  2. The character position of the start of the innermost containing parenthetical grouping; nil if none.

  3. The character position of the start of the last complete subexpression terminated; nil if none.

  4. Non-nil if inside a string. (It is the character that will terminate the string.)

  5. t if inside a comment.

  6. t if point is just after a quote character.

  7. The minimum parenthesis depth encountered during this scan.

Elements 1, 4, 5, and 6 are significant in the argument state.

This function is used to determine how to indent lines in programs written in languages that have nested parentheses.

Function: scan-lists from count depth

This function scans forward count balanced parenthetical groupings from character number from. It returns the character number of the position thus found.

If depth is nonzero, parenthesis depth counting begins from that value. The only candidates for stopping are places where the depth in parentheses becomes zero; scan-lists counts count such places and then stops. Thus, a positive value for depth means go out levels of parenthesis.

Comments are ignored if parse-sexp-ignore-comments is non-nil.

If the beginning or end of the buffer (or its accessible portion) is reached and the depth is not zero, an error is signaled. If the depth is zero but the count is not used up, nil is returned.

Function: scan-sexps from count

Scan from character number from by count balanced expressions. It returns the character number of the position thus found.

Comments are ignored if parse-sexp-ignore-comments is non-nil.

If the beginning or end of (the accessible part of) the buffer is reached in the middle of a parenthetical grouping, an error is signaled. If the beginning or end is reached between groupings but before count is used up, nil is returned.

Variable: parse-sexp-ignore-comments

If the value is non-nil, then comments are treated as whitespace by the functions in this section and by forward-sexp.

In older Emacs versions, this feature worked only when the comment terminator is something like `*/', and appears only to end a comment. In languages where newlines terminate comments, it was necessary make this variable nil, since not every newline is the end of a comment. This limitation no longer exists.

You can use forward-comment to move forward or backward over one comment or several comments.

Function: forward-comment count

This function moves point forward across count comments (backward, if count is negative). If it finds anything other than a comment or whitespace, it stops, leaving point at the place where it stopped. It also stops after satisfying count.

To move forward over all comments and whitespace following point, use (forward-comment (buffer-size)). (buffer-size) is a good argument to use, because the number of comments to skip cannot exceed that many.

Some Standard Syntax Tables

Each of the major modes in Emacs has its own syntax table. Here are several of them:

Function: standard-syntax-table

This function returns the standard syntax table, which is the syntax table used in Fundamental mode.

Variable: text-mode-syntax-table

The value of this variable is the syntax table used in Text mode.

Variable: c-mode-syntax-table

The value of this variable is the syntax table in use in C-mode buffers.

Variable: emacs-lisp-mode-syntax-table

The value of this variable is the syntax table used in Emacs Lisp mode by editing commands. (It has no effect on the Lisp read function.)

Syntax Table Internals

Each element of a syntax table is an integer that translates into the full meaning of the entry: class, possible matching character, and flags. However, it is not common for a programmer to work with the entries directly in this form since the Lisp-level syntax table functions usually work with syntax descriptors (see section Syntax Descriptors).

The low 8 bits of each element of a syntax table indicates the syntax class.

Integer
Class
0
whitespace
1
punctuation
2
word
3
symbol
4
open parenthesis
5
close parenthesis
6
expression prefix
7
string quote
8
paired delimiter
9
escape
10
character quote
11
comment-start
12
comment-end

The next 8 bits are the matching opposite parenthesis (if the character has parenthesis syntax); otherwise, they are not meaningful. The next 6 bits are the flags.

Go to the previous, next section.