src/syntax.h

   1 /* Declarations having to do with GNU Emacs syntax tables.
   2    Copyright (C) 1985, 1993, 1994 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Emacs.
   5
   6 GNU Emacs is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Emacs is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Emacs; see the file COPYING.  If not, write to
  18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21
  22 extern Lisp_Object Qsyntax_table_p;
  23 extern Lisp_Object Fsyntax_table_p (), Fsyntax_table (), Fset_syntax_table ();
  24
  25 /* The standard syntax table is stored where it will automatically
  26    be used in all new buffers.  */
  27 #define Vstandard_syntax_table buffer_defaults.syntax_table
  28
  29 /* A syntax table is a chartable whose elements are cons cells
  30    (CODE+FLAGS . MATCHING-CHAR).  MATCHING-CHAR can be nil if the char
  31    is not a kind of parenthesis.
  32
  33    The low 8 bits of CODE+FLAGS is a code, as follows:  */
  34
  35 enum syntaxcode
  36   {
  37     Swhitespace, /* for a whitespace character */
  38     Spunct,      /* for random punctuation characters */
  39     Sword,       /* for a word constituent */
  40     Ssymbol,     /* symbol constituent but not word constituent */
  41     Sopen,       /* for a beginning delimiter */
  42     Sclose,      /* for an ending delimiter */
  43     Squote,      /* for a prefix character like Lisp ' */
  44     Sstring,     /* for a string-grouping character like Lisp " */
  45     Smath,       /* for delimiters like $ in Tex. */
  46     Sescape,     /* for a character that begins a C-style escape */
  47     Scharquote,  /* for a character that quotes the following character */
  48     Scomment,    /* for a comment-starting character */
  49     Sendcomment, /* for a comment-ending character */
  50     Sinherit,    /* use the standard syntax table for this character */
  51     Smax         /* Upper bound on codes that are meaningful */
  52   };
  53
  54 /* Fetch the syntax entry for char C from table TABLE.
  55    This returns the whole entry (normally a cons cell)
  56    and does not do any kind of inheritance.  */
  57
  58 #if 1
  59 #define RAW_SYNTAX_ENTRY(table, c)                              \
  60   (XCHAR_TABLE (table)->contents[(unsigned char) (c)])
  61
  62 #define SET_RAW_SYNTAX_ENTRY(table, c, val)                     \
  63   (XCHAR_TABLE (table)->contents[(unsigned char) (c)] = (val))
  64 #else
  65 #define RAW_SYNTAX_ENTRY(table, c)                              \
  66   ((c) >= 128                                                   \
  67    ? raw_syntax_table_lookup (table, c)                         \
  68    : XCHAR_TABLE (table)->contents[(unsigned char) (c)])
  69
  70 #define SET_RAW_SYNTAX_ENTRY(table, c, val)                     \
  71   ((c) >= 128                                                   \
  72    ? set_raw_syntax_table_lookup (table, c, (val))              \
  73    : XCHAR_TABLE (table)->contents[(unsigned char) (c)] = (val))
  74 #endif
  75
  76 /* Extract the information from the entry for character C
  77    in syntax table TABLE.  Do inheritance.  */
  78
  79 #ifdef __GNUC__
  80 #define SYNTAX_ENTRY(c)                                                 \
  81   ({ Lisp_Object temp, table;                                           \
  82      unsigned char cc = (c);                                            \
  83      table = current_buffer->syntax_table;                              \
  84      while (!NILP (table))                                              \
  85        {                                                                \
  86          temp = RAW_SYNTAX_ENTRY (table, cc);                           \
  87          if (!NILP (temp))                                              \
  88            break;                                                       \
  89          table = XCHAR_TABLE (table)->parent;                           \
  90        }                                                                \
  91      temp; })
  92
  93 #define SYNTAX(c)                                                       \
  94   ({ Lisp_Object temp;                                                  \
  95      temp = SYNTAX_ENTRY (c);                                           \
  96      (CONSP (temp)                                                      \
  97       ? (enum syntaxcode) (XINT (XCONS (temp)->car) & 0xff)             \
  98       : wrong_type_argument (Qconsp, temp)); })
  99
 100 #define SYNTAX_WITH_FLAGS(c)                                            \
 101   ({ Lisp_Object temp;                                                  \
 102      temp = SYNTAX_ENTRY (c);                                           \
 103      (CONSP (temp)                                                      \
 104       ? XINT (XCONS (temp)->car)                                        \
 105       : wrong_type_argument (Qconsp, temp)); })
 106
 107 #define SYNTAX_MATCH(c)                                                 \
 108   ({ Lisp_Object temp;                                                  \
 109      temp = SYNTAX_ENTRY (c);                                           \
 110      (CONSP (temp)                                                      \
 111       ? XINT (XCONS (temp)->cdr)                                        \
 112       : wrong_type_argument (Qconsp, temp)); })
 113 #else
 114 extern Lisp_Object syntax_temp;
 115 extern Lisp_Object syntax_parent_lookup ();
 116
 117 #define SYNTAX_ENTRY(c)                                                 \
 118   (syntax_temp                                                          \
 119      = RAW_SYNTAX_ENTRY (current_buffer->syntax_table, (c)),            \
 120    (NILP (syntax_temp)                                                  \
 121     ? (syntax_temp                                                      \
 122        = syntax_parent_lookup (current_buffer->syntax_table,            \
 123                                (unsigned char) (c)))                    \
 124     : syntax_temp))
 125
 126 #define SYNTAX(c)                                                       \
 127   (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
 128    (CONSP (syntax_temp)                                                 \
 129     ? (enum syntaxcode) (XINT (XCONS (syntax_temp)->car) & 0xff)        \
 130     : wrong_type_argument (Qconsp, syntax_temp)))
 131
 132 #define SYNTAX_WITH_FLAGS(c)                                            \
 133   (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
 134    (CONSP (syntax_temp)                                                 \
 135     ? XINT (XCONS (syntax_temp)->car)                                   \
 136     : wrong_type_argument (Qconsp, syntax_temp)))
 137
 138 #define SYNTAX_MATCH(c)                                                 \
 139   (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
 140    (CONSP (syntax_temp)                                                 \
 141     ? XINT (XCONS (syntax_temp)->cdr)                                   \
 142     : wrong_type_argument (Qconsp, syntax_temp)))
 143 #endif
 144
 145 /* Then there are six single-bit flags that have the following meanings:
 146   1. This character is the first of a two-character comment-start sequence.
 147   2. This character is the second of a two-character comment-start sequence.
 148   3. This character is the first of a two-character comment-end sequence.
 149   4. This character is the second of a two-character comment-end sequence.
 150   5. This character is a prefix, for backward-prefix-chars.
 151   Note that any two-character sequence whose first character has flag 1
 152   and whose second character has flag 2 will be interpreted as a comment start.
 153
 154   bit 6 is used to discriminate between two different comment styles.
 155   Languages such as C++ allow two orthogonal syntax start/end pairs
 156   and bit 6 is used to determine whether a comment-end or Scommentend
 157   ends style a or b. Comment start sequences can start style a or b.
 158   Style a is always the default.
 159   */
 160
 161 #define SYNTAX_COMSTART_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 16) & 1)
 162
 163 #define SYNTAX_COMSTART_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 17) & 1)
 164
 165 #define SYNTAX_COMEND_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 18) & 1)
 166
 167 #define SYNTAX_COMEND_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 19) & 1)
 168
 169 #define SYNTAX_PREFIX(c) ((SYNTAX_WITH_FLAGS (c) >> 20) & 1)
 170
 171 /* extract the comment style bit from the syntax table entry */
 172 #define SYNTAX_COMMENT_STYLE(c) ((SYNTAX_WITH_FLAGS (c) >> 21) & 1)
 173
 174 /* This array, indexed by a character, contains the syntax code which that
 175  character signifies (as a char).  For example,
 176  (enum syntaxcode) syntax_spec_code['w'] is Sword. */
 177
 178 extern unsigned char syntax_spec_code[0400];
 179
 180 /* Indexed by syntax code, give the letter that describes it. */
 181
 182 extern char syntax_code_spec[14];