src/syntax.h

   1 /* Declarations having to do with GNU Emacs syntax tables.
   2
   3 Copyright (C) 1985, 1993-1994, 1997-1998, 2001-2011
   4   Free Software Foundation, Inc.
   5
   6 This file is part of GNU Emacs.
   7
   8 GNU Emacs is free software: you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 GNU Emacs is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21
  22 extern Lisp_Object Qsyntax_table_p;
  23 extern void update_syntax_table (EMACS_INT, int, int, Lisp_Object);
  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     Scomment_fence, /* Starts/ends comment which is delimited on the
  52                        other side by any char with the same syntaxcode.  */
  53     Sstring_fence,  /* Starts/ends string which is delimited on the
  54                        other side by any char with the same syntaxcode.  */
  55     Smax         /* Upper bound on codes that are meaningful */
  56   };
  57
  58 /* Set the syntax entry VAL for char C in table TABLE.  */
  59
  60 #define SET_RAW_SYNTAX_ENTRY(table, c, val)     \
  61   CHAR_TABLE_SET ((table), c, (val))
  62
  63 /* Set the syntax entry VAL for char-range RANGE in table TABLE.
  64    RANGE is a cons (FROM . TO) specifying the range of characters.  */
  65
  66 #define SET_RAW_SYNTAX_ENTRY_RANGE(table, range, val)   \
  67   Fset_char_table_range ((table), (range), (val))
  68
  69 /* SYNTAX_ENTRY fetches the information from the entry for character C
  70    in syntax table TABLE, or from globally kept data (gl_state).
  71    Does inheritance.  */
  72 /* CURRENT_SYNTAX_TABLE gives the syntax table valid for current
  73    position, it is either the buffer's syntax table, or syntax table
  74    found in text properties.  */
  75
  76 #ifdef SYNTAX_ENTRY_VIA_PROPERTY
  77 #  define SYNTAX_ENTRY(c)                                             \
  78     (gl_state.use_global ? gl_state.global_code : SYNTAX_ENTRY_INT (c))
  79 #  define CURRENT_SYNTAX_TABLE gl_state.current_syntax_table
  80 #else
  81 #  define SYNTAX_ENTRY SYNTAX_ENTRY_INT
  82 #  define CURRENT_SYNTAX_TABLE current_buffer->syntax_table
  83 #endif
  84
  85 #define SYNTAX_ENTRY_INT(c) CHAR_TABLE_REF (CURRENT_SYNTAX_TABLE, (c))
  86
  87 /* Extract the information from the entry for character C
  88    in the current syntax table.  */
  89
  90 #ifdef __GNUC__
  91 #define SYNTAX(c)                                                       \
  92   ({ Lisp_Object _syntax_temp;                                          \
  93      _syntax_temp = SYNTAX_ENTRY (c);                                   \
  94      (CONSP (_syntax_temp)                                              \
  95       ? (enum syntaxcode) (XINT (XCAR (_syntax_temp)) & 0xff)           \
  96       : Swhitespace); })
  97
  98 #define SYNTAX_WITH_FLAGS(c)                                            \
  99   ({ Lisp_Object _syntax_temp;                                          \
 100      _syntax_temp = SYNTAX_ENTRY (c);                                   \
 101      (CONSP (_syntax_temp)                                              \
 102       ? XINT (XCAR (_syntax_temp))                                      \
 103       : (int) Swhitespace); })
 104
 105 #define SYNTAX_MATCH(c)                                                 \
 106   ({ Lisp_Object _syntax_temp;                                          \
 107      _syntax_temp = SYNTAX_ENTRY (c);                                   \
 108      (CONSP (_syntax_temp)                                              \
 109       ? XCDR (_syntax_temp)                                             \
 110       : Qnil); })
 111 #else
 112 extern Lisp_Object syntax_temp;
 113 #define SYNTAX(c)                                                       \
 114   (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
 115    (CONSP (syntax_temp)                                                 \
 116     ? (enum syntaxcode) (XINT (XCAR (syntax_temp)) & 0xff)      \
 117     : Swhitespace))
 118
 119 #define SYNTAX_WITH_FLAGS(c)                                            \
 120   (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
 121    (CONSP (syntax_temp)                                                 \
 122     ? XINT (XCAR (syntax_temp))                                 \
 123     : (int) Swhitespace))
 124
 125 #define SYNTAX_MATCH(c)                                                 \
 126   (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
 127    (CONSP (syntax_temp)                                                 \
 128     ? XCDR (syntax_temp)                                                \
 129     : Qnil))
 130 #endif
 131
 132
 133 /* Whether the syntax of the character C has the prefix flag set.  */
 134 extern int syntax_prefix_flag_p (int c);
 135
 136 /* This array, indexed by a character, contains the syntax code which that
 137  character signifies (as a char).  For example,
 138  (enum syntaxcode) syntax_spec_code['w'] is Sword.  */
 139
 140 extern unsigned char syntax_spec_code[0400];
 141
 142 /* Indexed by syntax code, give the letter that describes it.  */
 143
 144 extern char syntax_code_spec[16];
 145
 146 /* Convert the byte offset BYTEPOS into a character position,
 147    for the object recorded in gl_state with SETUP_SYNTAX_TABLE_FOR_OBJECT.
 148
 149    The value is meant for use in the UPDATE_SYNTAX_TABLE... macros.
 150    These macros do nothing when parse_sexp_lookup_properties is 0,
 151    so we return 0 in that case, for speed.  */
 152
 153 #define SYNTAX_TABLE_BYTE_TO_CHAR(bytepos)                              \
 154   (! parse_sexp_lookup_properties                                       \
 155    ? 0                                                                  \
 156    : STRINGP (gl_state.object)                                          \
 157    ? string_byte_to_char (gl_state.object, (bytepos))                   \
 158    : BUFFERP (gl_state.object)                                          \
 159    ? buf_bytepos_to_charpos (XBUFFER (gl_state.object),                 \
 160                              (bytepos) + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1) - BUF_BEGV (XBUFFER (gl_state.object)) + 1      \
 161    : NILP (gl_state.object)                                             \
 162    ? BYTE_TO_CHAR ((bytepos) + BEGV_BYTE - 1) - BEGV + 1                \
 163    : (bytepos))
 164
 165 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
 166    currently good for a position before CHARPOS.  */
 167
 168 #define UPDATE_SYNTAX_TABLE_FORWARD(charpos)                    \
 169   (parse_sexp_lookup_properties                                 \
 170    && (charpos) >= gl_state.e_property                          \
 171    ? (update_syntax_table ((charpos) + gl_state.offset, 1, 0,   \
 172                            gl_state.object),                    \
 173       1)                                                        \
 174    : 0)
 175
 176 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
 177    currently good for a position after CHARPOS.  */
 178
 179 #define UPDATE_SYNTAX_TABLE_BACKWARD(charpos)                   \
 180   (parse_sexp_lookup_properties                                 \
 181    && (charpos) < gl_state.b_property                           \
 182    ? (update_syntax_table ((charpos) + gl_state.offset, -1, 0,  \
 183                            gl_state.object),                    \
 184       1)                                                        \
 185    : 0)
 186
 187 /* Make syntax table good for CHARPOS.  */
 188
 189 #define UPDATE_SYNTAX_TABLE(charpos)                            \
 190   (parse_sexp_lookup_properties                                 \
 191    && (charpos) < gl_state.b_property                           \
 192    ? (update_syntax_table ((charpos) + gl_state.offset, -1, 0,  \
 193                            gl_state.object),                    \
 194       1)                                                        \
 195    : (parse_sexp_lookup_properties                              \
 196       && (charpos) >= gl_state.e_property                       \
 197       ? (update_syntax_table ((charpos) + gl_state.offset, 1, 0,\
 198                               gl_state.object),                 \
 199          1)                                                     \
 200       : 0))
 201
 202 /* This macro sets up the buffer-global syntax table.  */
 203 #define SETUP_BUFFER_SYNTAX_TABLE()                                     \
 204 do                                                                      \
 205   {                                                                     \
 206     gl_state.use_global = 0;                                            \
 207     gl_state.current_syntax_table = current_buffer->syntax_table;       \
 208   } while (0)
 209
 210 /* This macro should be called with FROM at the start of forward
 211    search, or after the last position of the backward search.  It
 212    makes sure that the first char is picked up with correct table, so
 213    one does not need to call UPDATE_SYNTAX_TABLE immediately after the
 214    call.
 215    Sign of COUNT gives the direction of the search.
 216  */
 217
 218 #define SETUP_SYNTAX_TABLE(FROM, COUNT)                                 \
 219 do                                                                      \
 220   {                                                                     \
 221     SETUP_BUFFER_SYNTAX_TABLE ();                                       \
 222     gl_state.b_property = BEGV;                                         \
 223     gl_state.e_property = ZV + 1;                                       \
 224     gl_state.object = Qnil;                                             \
 225     gl_state.offset = 0;                                                \
 226     if (parse_sexp_lookup_properties)                                   \
 227       if ((COUNT) > 0 || (FROM) > BEGV)                                 \
 228         update_syntax_table ((COUNT) > 0 ? (FROM) : (FROM) - 1, (COUNT),\
 229                              1, Qnil);                                  \
 230   }                                                                     \
 231 while (0)
 232
 233 /* Same as above, but in OBJECT.  If OBJECT is nil, use current buffer.
 234    If it is t, ignore properties altogether.
 235
 236    This is meant for regex.c to use.  For buffers, regex.c passes arguments
 237    to the UPDATE_SYNTAX_TABLE macros which are relative to BEGV.
 238    So if it is a buffer, we set the offset field to BEGV.  */
 239
 240 #define SETUP_SYNTAX_TABLE_FOR_OBJECT(OBJECT, FROM, COUNT)              \
 241 do                                                                      \
 242   {                                                                     \
 243     SETUP_BUFFER_SYNTAX_TABLE ();                                       \
 244     gl_state.object = (OBJECT);                                         \
 245     if (BUFFERP (gl_state.object))                                      \
 246       {                                                                 \
 247         struct buffer *buf = XBUFFER (gl_state.object);                 \
 248         gl_state.b_property = 1;                                        \
 249         gl_state.e_property = BUF_ZV (buf) - BUF_BEGV (buf) + 1;        \
 250         gl_state.offset = BUF_BEGV (buf) - 1;                           \
 251       }                                                                 \
 252     else if (NILP (gl_state.object))                                    \
 253       {                                                                 \
 254         gl_state.b_property = 1;                                        \
 255         gl_state.e_property = ZV - BEGV + 1;                            \
 256         gl_state.offset = BEGV - 1;                                     \
 257       }                                                                 \
 258     else if (EQ (gl_state.object, Qt))                                  \
 259       {                                                                 \
 260         gl_state.b_property = 0;                                        \
 261         gl_state.e_property = 1500000000;                               \
 262         gl_state.offset = 0;                                            \
 263       }                                                                 \
 264     else                                                                \
 265       {                                                                 \
 266         gl_state.b_property = 0;                                        \
 267         gl_state.e_property = 1 + SCHARS (gl_state.object);             \
 268         gl_state.offset = 0;                                            \
 269       }                                                                 \
 270     if (parse_sexp_lookup_properties)                                   \
 271       update_syntax_table (((FROM) + gl_state.offset                    \
 272                             + (COUNT > 0 ? 0 :  -1)),                   \
 273                            COUNT, 1, gl_state.object);                  \
 274   }                                                                     \
 275 while (0)
 276
 277 struct gl_state_s
 278 {
 279   Lisp_Object object;                   /* The object we are scanning. */
 280   int start;                            /* Where to stop. */
 281   int stop;                             /* Where to stop. */
 282   int use_global;                       /* Whether to use global_code
 283                                            or c_s_t. */
 284   Lisp_Object global_code;              /* Syntax code of current char. */
 285   Lisp_Object current_syntax_table;     /* Syntax table for current pos. */
 286   Lisp_Object old_prop;                 /* Syntax-table prop at prev pos. */
 287   int b_property;                       /* First index where c_s_t is valid. */
 288   int e_property;                       /* First index where c_s_t is
 289                                            not valid. */
 290   INTERVAL forward_i;                   /* Where to start lookup on forward */
 291   INTERVAL backward_i;                  /* or backward movement.  The
 292                                            data in c_s_t is valid
 293                                            between these intervals,
 294                                            and possibly at the
 295                                            intervals too, depending
 296                                            on: */
 297   /* Offset for positions specified to UPDATE_SYNTAX_TABLE.  */
 298   int offset;
 299 };
 300
 301 extern struct gl_state_s gl_state;
 302 extern EMACS_INT scan_words (EMACS_INT, EMACS_INT);
 303