src/syntax.h

   1 /* Declarations having to do with GNU Emacs syntax tables.
   2
   3 Copyright (C) 1985, 1993-1994, 1997-1998, 2001-2016 Free Software
   4 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 (at
  11 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 #ifndef EMACS_SYNTAX_H
  22 #define EMACS_SYNTAX_H
  23
  24 #include "buffer.h"
  25 #include "lisp.h"
  26
  27 INLINE_HEADER_BEGIN
  28
  29 extern void update_syntax_table (ptrdiff_t, EMACS_INT, bool, Lisp_Object);
  30 extern void update_syntax_table_forward (ptrdiff_t, bool, Lisp_Object);
  31
  32 /* The standard syntax table is stored where it will automatically
  33    be used in all new buffers.  */
  34 #define Vstandard_syntax_table BVAR (&buffer_defaults, syntax_table)
  35
  36 /* A syntax table is a chartable whose elements are cons cells
  37    (CODE+FLAGS . MATCHING-CHAR).  MATCHING-CHAR can be nil if the char
  38    is not a kind of parenthesis.
  39
  40    The low 8 bits of CODE+FLAGS is a code, as follows:  */
  41
  42 enum syntaxcode
  43   {
  44     Swhitespace, /* for a whitespace character */
  45     Spunct,      /* for random punctuation characters */
  46     Sword,       /* for a word constituent */
  47     Ssymbol,     /* symbol constituent but not word constituent */
  48     Sopen,       /* for a beginning delimiter */
  49     Sclose,      /* for an ending delimiter */
  50     Squote,      /* for a prefix character like Lisp ' */
  51     Sstring,     /* for a string-grouping character like Lisp " */
  52     Smath,       /* for delimiters like $ in Tex.  */
  53     Sescape,     /* for a character that begins a C-style escape */
  54     Scharquote,  /* for a character that quotes the following character */
  55     Scomment,    /* for a comment-starting character */
  56     Sendcomment, /* for a comment-ending character */
  57     Sinherit,    /* use the standard syntax table for this character */
  58     Scomment_fence, /* Starts/ends comment which is delimited on the
  59                        other side by any char with the same syntaxcode.  */
  60     Sstring_fence,  /* Starts/ends string which is delimited on the
  61                        other side by any char with the same syntaxcode.  */
  62     Smax         /* Upper bound on codes that are meaningful.  */
  63   };
  64
  65
  66 struct gl_state_s
  67 {
  68   Lisp_Object object;                   /* The object we are scanning.  */
  69   ptrdiff_t start;                      /* Where to stop.  */
  70   ptrdiff_t stop;                       /* Where to stop.  */
  71   bool use_global;                      /* Whether to use global_code
  72                                            or c_s_t.  */
  73   Lisp_Object global_code;              /* Syntax code of current char.  */
  74   Lisp_Object current_syntax_table;     /* Syntax table for current pos.  */
  75   Lisp_Object old_prop;                 /* Syntax-table prop at prev pos.  */
  76   ptrdiff_t b_property;                 /* First index where c_s_t is valid.  */
  77   ptrdiff_t e_property;                 /* First index where c_s_t is
  78                                            not valid.  */
  79   bool e_property_truncated;            /* true if e_property if was truncated
  80                                            by parse_sexp_propertize_done.  */
  81   INTERVAL forward_i;                   /* Where to start lookup on forward.  */
  82   INTERVAL backward_i;                  /* or backward movement.  The
  83                                            data in c_s_t is valid
  84                                            between these intervals,
  85                                            and possibly at the
  86                                            intervals too, depending
  87                                            on:  */
  88   /* Offset for positions specified to UPDATE_SYNTAX_TABLE.  */
  89   ptrdiff_t offset;
  90 };
  91
  92 extern struct gl_state_s gl_state;
  93
  94 /* Fetch the information from the entry for character C
  95    in the current buffer's syntax table,
  96    or (if VIA_PROPERTY) from globally kept data (gl_state).
  97    Does inheritance.  */
  98
  99 INLINE Lisp_Object
 100 syntax_property_entry (int c, bool via_property)
 101 {
 102   if (via_property)
 103     return (gl_state.use_global
 104             ? gl_state.global_code
 105             : CHAR_TABLE_REF (gl_state.current_syntax_table, c));
 106   return CHAR_TABLE_REF (BVAR (current_buffer, syntax_table), c);
 107 }
 108 INLINE Lisp_Object
 109 SYNTAX_ENTRY (int c)
 110 {
 111   return syntax_property_entry (c, false);
 112 }
 113
 114 /* Extract the information from the entry for character C
 115    in the current syntax table.  */
 116
 117 INLINE int
 118 syntax_property_with_flags (int c, bool via_property)
 119 {
 120   Lisp_Object ent = syntax_property_entry (c, via_property);
 121   return CONSP (ent) ? XINT (XCAR (ent)) : Swhitespace;
 122 }
 123 INLINE int
 124 SYNTAX_WITH_FLAGS (int c)
 125 {
 126   return syntax_property_with_flags (c, false);
 127 }
 128
 129 INLINE enum syntaxcode
 130 syntax_property (int c, bool via_property)
 131 {
 132   return syntax_property_with_flags (c, via_property) & 0xff;
 133 }
 134 INLINE enum syntaxcode
 135 SYNTAX (int c)
 136 {
 137   return syntax_property (c, false);
 138 }
 139
 140
 141 /* Whether the syntax of the character C has the prefix flag set.  */
 142 extern bool syntax_prefix_flag_p (int c);
 143
 144 /* This array, indexed by a character less than 256, contains the
 145    syntax code which that character signifies (as an unsigned char).
 146    For example, syntax_spec_code['w'] == Sword.  */
 147
 148 extern unsigned char const syntax_spec_code[0400];
 149
 150 /* Indexed by syntax code, give the letter that describes it.  */
 151
 152 extern char const syntax_code_spec[16];
 153
 154 /* Convert the byte offset BYTEPOS into a character position,
 155    for the object recorded in gl_state with SETUP_SYNTAX_TABLE_FOR_OBJECT.
 156
 157    The value is meant for use in code that does nothing when
 158    parse_sexp_lookup_properties is false, so return 0 in that case,
 159    for speed.  */
 160
 161 INLINE ptrdiff_t
 162 SYNTAX_TABLE_BYTE_TO_CHAR (ptrdiff_t bytepos)
 163 {
 164   return (! parse_sexp_lookup_properties
 165           ? 0
 166           : STRINGP (gl_state.object)
 167           ? string_byte_to_char (gl_state.object, bytepos)
 168           : BUFFERP (gl_state.object)
 169           ? ((buf_bytepos_to_charpos
 170               (XBUFFER (gl_state.object),
 171                (bytepos + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1)))
 172              - BUF_BEGV (XBUFFER (gl_state.object)) + 1)
 173           : NILP (gl_state.object)
 174           ? BYTE_TO_CHAR (bytepos + BEGV_BYTE - 1) - BEGV + 1
 175           : bytepos);
 176 }
 177
 178 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
 179    currently good for a position before CHARPOS.  */
 180
 181 INLINE void
 182 UPDATE_SYNTAX_TABLE_FORWARD (ptrdiff_t charpos)
 183 { /* Performs just-in-time syntax-propertization.  */
 184   if (parse_sexp_lookup_properties && charpos >= gl_state.e_property)
 185     update_syntax_table_forward (charpos + gl_state.offset,
 186                                  false, gl_state.object);
 187 }
 188
 189 INLINE void
 190 UPDATE_SYNTAX_TABLE_FORWARD_FAST (ptrdiff_t charpos)
 191 {
 192   if (parse_sexp_lookup_properties && charpos >= gl_state.e_property)
 193     update_syntax_table (charpos + gl_state.offset, 1, false, gl_state.object);
 194 }
 195
 196 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
 197    currently good for a position after CHARPOS.  */
 198
 199 INLINE void
 200 UPDATE_SYNTAX_TABLE_BACKWARD (ptrdiff_t charpos)
 201 {
 202   if (parse_sexp_lookup_properties && charpos < gl_state.b_property)
 203     update_syntax_table (charpos + gl_state.offset, -1, false, gl_state.object);
 204 }
 205
 206 /* Make syntax table good for CHARPOS.  */
 207
 208 INLINE void
 209 UPDATE_SYNTAX_TABLE (ptrdiff_t charpos)
 210 {
 211   UPDATE_SYNTAX_TABLE_BACKWARD (charpos);
 212   UPDATE_SYNTAX_TABLE_FORWARD (charpos);
 213 }
 214
 215 INLINE void
 216 UPDATE_SYNTAX_TABLE_FAST (ptrdiff_t charpos)
 217 {
 218   UPDATE_SYNTAX_TABLE_BACKWARD (charpos);
 219   UPDATE_SYNTAX_TABLE_FORWARD_FAST (charpos);
 220 }
 221
 222 /* Set up the buffer-global syntax table.  */
 223
 224 INLINE void
 225 SETUP_BUFFER_SYNTAX_TABLE (void)
 226 {
 227   gl_state.use_global = false;
 228   gl_state.e_property_truncated = false;
 229   gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);
 230 }
 231
 232 extern ptrdiff_t scan_words (ptrdiff_t, EMACS_INT);
 233 extern void SETUP_SYNTAX_TABLE_FOR_OBJECT (Lisp_Object, ptrdiff_t, ptrdiff_t);
 234
 235 INLINE_HEADER_END
 236
 237 #endif /* EMACS_SYNTAX_H */