Merge from trunk

author: Tom Tromey 2013-07-12 18:44:13 -0600
committer: Tom Tromey 2013-07-12 18:44:13 -0600
commit: b34a529f177a6ea32da5cb1254f91bf9d71838db (patch)
tree: 477131abc15d3107b30b635223d87a22550b480b /src/syntax.h
parent: e6f63071a3f7721f55220514b6d9a8ee8c1232d8 (diff)
parent: 5e301d7651c0691bb2bc7f3fbe711fdbe26ac471 (diff)
download: emacs-b34a529f177a6ea32da5cb1254f91bf9d71838db.tar.gz
emacs-b34a529f177a6ea32da5cb1254f91bf9d71838db.zip
1 files changed, 96 insertions, 200 deletions
diff --git a/src/syntax.h b/src/syntax.h
index 58d39b9059c..1b96284af42 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -18,6 +18,10 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+INLINE_HEADER_BEGIN
+#ifndef SYNTAX_INLINE
+# define SYNTAX_INLINE INLINE
+#endif
 extern void update_syntax_table (ptrdiff_t, EMACS_INT, bool, Lisp_Object);
@@ -54,79 +58,64 @@ enum syntaxcode
    Smax         /* Upper bound on codes that are meaningful */
  };
-/* Set the syntax entry VAL for char C in table TABLE.  */
-#define SET_RAW_SYNTAX_ENTRY(table, c, val)     \
-  CHAR_TABLE_SET ((table), c, (val))
-/* Set the syntax entry VAL for char-range RANGE in table TABLE.
+struct gl_state_s
-   RANGE is a cons (FROM . TO) specifying the range of characters.  */
+{
+  Lisp_Object object;                   /* The object we are scanning. */
+  ptrdiff_t start;                      /* Where to stop. */
+  ptrdiff_t stop;                       /* Where to stop. */
+  bool use_global;                      /* Whether to use global_code
+                                           or c_s_t. */
+  Lisp_Object global_code;              /* Syntax code of current char. */
+  Lisp_Object current_syntax_table;     /* Syntax table for current pos. */
+  Lisp_Object old_prop;                 /* Syntax-table prop at prev pos. */
+  ptrdiff_t b_property;                 /* First index where c_s_t is valid. */
+  ptrdiff_t e_property;                 /* First index where c_s_t is
+                                           not valid. */
+  INTERVAL forward_i;                   /* Where to start lookup on forward */
+  INTERVAL backward_i;                  /* or backward movement.  The
+                                           data in c_s_t is valid
+                                           between these intervals,
+                                           and possibly at the
+                                           intervals too, depending
+                                           on: */
+  /* Offset for positions specified to UPDATE_SYNTAX_TABLE.  */
+  ptrdiff_t offset;
+};
-#define SET_RAW_SYNTAX_ENTRY_RANGE(table, range, val)   \
+extern struct gl_state_s gl_state;
-  Fset_char_table_range ((table), (range), (val))
-/* SYNTAX_ENTRY fetches the information from the entry for character C
+/* Fetch the information from the entry for character C
   in syntax table TABLE, or from globally kept data (gl_state).
   Does inheritance.  */
-/* CURRENT_SYNTAX_TABLE gives the syntax table valid for current
-   position, it is either the buffer's syntax table, or syntax table
-   found in text properties.  */
+SYNTAX_INLINE Lisp_Object
+SYNTAX_ENTRY (int c)
+{
 #ifdef SYNTAX_ENTRY_VIA_PROPERTY
-#  define SYNTAX_ENTRY(c)                                             \
+  return (gl_state.use_global
-    (gl_state.use_global ? gl_state.global_code : SYNTAX_ENTRY_INT (c))
+          ? gl_state.global_code
-#  define CURRENT_SYNTAX_TABLE gl_state.current_syntax_table
+          : CHAR_TABLE_REF (gl_state.current_syntax_table, c));
 #else
-#  define SYNTAX_ENTRY SYNTAX_ENTRY_INT
+  return CHAR_TABLE_REF (BVAR (current_buffer, syntax_table), c);
-#  define CURRENT_SYNTAX_TABLE BVAR (current_buffer, syntax_table)
 #endif
+}
-#define SYNTAX_ENTRY_INT(c) CHAR_TABLE_REF (CURRENT_SYNTAX_TABLE, (c))
 /* Extract the information from the entry for character C
   in the current syntax table.  */
-#ifdef __GNUC__
+SYNTAX_INLINE int
-#define SYNTAX(c)                                                       \
+SYNTAX_WITH_FLAGS (int c)
-  ({ Lisp_Object _syntax_temp;                                          \
+{
-     _syntax_temp = SYNTAX_ENTRY (c);                                   \
+  Lisp_Object ent = SYNTAX_ENTRY (c);
-     (CONSP (_syntax_temp)                                              \
+  return CONSP (ent) ? XINT (XCAR (ent)) : Swhitespace;
-      ? (enum syntaxcode) (XINT (XCAR (_syntax_temp)) & 0xff)           \
+}
-      : Swhitespace); })
+SYNTAX_INLINE enum syntaxcode
-#define SYNTAX_WITH_FLAGS(c)                                            \
+SYNTAX (int c)
-  ({ Lisp_Object _syntax_temp;                                          \
+{
-     _syntax_temp = SYNTAX_ENTRY (c);                                   \
+  return SYNTAX_WITH_FLAGS (c) & 0xff;
-     (CONSP (_syntax_temp)                                              \
+}
-      ? XINT (XCAR (_syntax_temp))                                      \
-      : Swhitespace); })
-#define SYNTAX_MATCH(c)                                                 \
-  ({ Lisp_Object _syntax_temp;                                          \
-     _syntax_temp = SYNTAX_ENTRY (c);                                   \
-     (CONSP (_syntax_temp)                                              \
-      ? XCDR (_syntax_temp)                                             \
-      : Qnil); })
-#else
-extern Lisp_Object syntax_temp;
-#define SYNTAX(c)                                                       \
-  (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
-   (CONSP (syntax_temp)                                                 \
-    ? (enum syntaxcode) (XINT (XCAR (syntax_temp)) & 0xff)              \
-    : Swhitespace))
-#define SYNTAX_WITH_FLAGS(c)                                            \
-  (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
-   (CONSP (syntax_temp)                                                 \
-    ? XINT (XCAR (syntax_temp))                                         \
-    : Swhitespace))
-#define SYNTAX_MATCH(c)                                                 \
-  (syntax_temp = SYNTAX_ENTRY ((c)),                                    \
-   (CONSP (syntax_temp)                                                 \
-    ? XCDR (syntax_temp)                                                \
-    : Qnil))
-#endif
 /* Whether the syntax of the character C has the prefix flag set.  */
@@ -145,158 +134,65 @@ extern char const syntax_code_spec[16];
 /* Convert the byte offset BYTEPOS into a character position,
   for the object recorded in gl_state with SETUP_SYNTAX_TABLE_FOR_OBJECT.
-   The value is meant for use in the UPDATE_SYNTAX_TABLE... macros.
+   The value is meant for use in code that does nothing when
-   These macros do nothing when parse_sexp_lookup_properties is 0,
+   parse_sexp_lookup_properties is 0, so return 0 in that case, for speed.  */
-   so we return 0 in that case, for speed.  */
+SYNTAX_INLINE ptrdiff_t
-#define SYNTAX_TABLE_BYTE_TO_CHAR(bytepos)                              \
+SYNTAX_TABLE_BYTE_TO_CHAR (ptrdiff_t bytepos)
-  (! parse_sexp_lookup_properties                                       \
+{
-   ? 0                                                                  \
+  return (! parse_sexp_lookup_properties
-   : STRINGP (gl_state.object)                                          \
+          ? 0
-   ? string_byte_to_char (gl_state.object, (bytepos))                   \
+          : STRINGP (gl_state.object)
-   : BUFFERP (gl_state.object)                                          \
+          ? string_byte_to_char (gl_state.object, bytepos)
-   ? buf_bytepos_to_charpos (XBUFFER (gl_state.object),                 \
+          : BUFFERP (gl_state.object)
-                             (bytepos) + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1) - BUF_BEGV (XBUFFER (gl_state.object)) + 1      \
+          ? ((buf_bytepos_to_charpos
-   : NILP (gl_state.object)                                             \
+              (XBUFFER (gl_state.object),
-   ? BYTE_TO_CHAR ((bytepos) + BEGV_BYTE - 1) - BEGV + 1                \
+               (bytepos + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1)))
-   : (bytepos))
+             - BUF_BEGV (XBUFFER (gl_state.object)) + 1)
+          : NILP (gl_state.object)
+          ? BYTE_TO_CHAR (bytepos + BEGV_BYTE - 1) - BEGV + 1
+          : bytepos);
+}
 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
   currently good for a position before CHARPOS.  */
-#define UPDATE_SYNTAX_TABLE_FORWARD(charpos)                    \
+SYNTAX_INLINE void
-  (parse_sexp_lookup_properties                                 \
+UPDATE_SYNTAX_TABLE_FORWARD (ptrdiff_t charpos)
-   && (charpos) >= gl_state.e_property                          \
+{
-   ? (update_syntax_table ((charpos) + gl_state.offset, 1, 0,   \
+  if (parse_sexp_lookup_properties && charpos >= gl_state.e_property)
-                           gl_state.object),                    \
+    update_syntax_table (charpos + gl_state.offset, 1, 0, gl_state.object);
-      1)                                                        \
+}
-   : 0)
 /* Make syntax table state (gl_state) good for CHARPOS, assuming it is
   currently good for a position after CHARPOS.  */
-#define UPDATE_SYNTAX_TABLE_BACKWARD(charpos)                   \
+SYNTAX_INLINE void
-  (parse_sexp_lookup_properties                                 \
+UPDATE_SYNTAX_TABLE_BACKWARD (ptrdiff_t charpos)
-   && (charpos) < gl_state.b_property                           \
+{
-   ? (update_syntax_table ((charpos) + gl_state.offset, -1, 0,  \
+  if (parse_sexp_lookup_properties && charpos < gl_state.b_property)
-                           gl_state.object),                    \
+    update_syntax_table (charpos + gl_state.offset, -1, 0, gl_state.object);
-      1)                                                        \
+}
-   : 0)
 /* Make syntax table good for CHARPOS.  */
-#define UPDATE_SYNTAX_TABLE(charpos)                            \
+SYNTAX_INLINE void
-  (parse_sexp_lookup_properties                                 \
+UPDATE_SYNTAX_TABLE (ptrdiff_t charpos)
-   && (charpos) < gl_state.b_property                           \
+{
-   ? (update_syntax_table ((charpos) + gl_state.offset, -1, 0,  \
+  UPDATE_SYNTAX_TABLE_BACKWARD (charpos);
-                           gl_state.object),                    \
+  UPDATE_SYNTAX_TABLE_FORWARD (charpos);
-      1)                                                        \
+}
-   : (parse_sexp_lookup_properties                              \
-      && (charpos) >= gl_state.e_property                       \
+/* Set up the buffer-global syntax table.  */
-      ? (update_syntax_table ((charpos) + gl_state.offset, 1, 0,\
-                              gl_state.object),                 \
-         1)                                                     \
-      : 0))
-/* This macro sets up the buffer-global syntax table.  */
-#define SETUP_BUFFER_SYNTAX_TABLE()                                     \
-do                                                                      \
-  {                                                                     \
-    gl_state.use_global = 0;                                            \
-    gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);\
-  } while (0)
-/* This macro should be called with FROM at the start of forward
-   search, or after the last position of the backward search.  It
-   makes sure that the first char is picked up with correct table, so
-   one does not need to call UPDATE_SYNTAX_TABLE immediately after the
-   call.
-   Sign of COUNT gives the direction of the search.
- */
-#define SETUP_SYNTAX_TABLE(FROM, COUNT)                                 \
-do                                                                      \
-  {                                                                     \
-    SETUP_BUFFER_SYNTAX_TABLE ();                                       \
-    gl_state.b_property = BEGV;                                         \
-    gl_state.e_property = ZV + 1;                                       \
-    gl_state.object = Qnil;                                             \
-    gl_state.offset = 0;                                                \
-    if (parse_sexp_lookup_properties)                                   \
-      if ((COUNT) > 0 || (FROM) > BEGV)                                 \
-        update_syntax_table ((COUNT) > 0 ? (FROM) : (FROM) - 1, (COUNT),\
-                             1, Qnil);                                  \
-  }                                                                     \
-while (0)
-/* Same as above, but in OBJECT.  If OBJECT is nil, use current buffer.
-   If it is t (which is only used in fast_c_string_match_ignore_case),
-   ignore properties altogether.
-   This is meant for regex.c to use.  For buffers, regex.c passes arguments
-   to the UPDATE_SYNTAX_TABLE macros which are relative to BEGV.
-   So if it is a buffer, we set the offset field to BEGV.  */
-#define SETUP_SYNTAX_TABLE_FOR_OBJECT(OBJECT, FROM, COUNT)              \
-do                                                                      \
-  {                                                                     \
-    SETUP_BUFFER_SYNTAX_TABLE ();                                       \
-    gl_state.object = (OBJECT);                                         \
-    if (BUFFERP (gl_state.object))                                      \
-      {                                                                 \
-        struct buffer *buf = XBUFFER (gl_state.object);                 \
-        gl_state.b_property = 1;                                        \
-        gl_state.e_property = BUF_ZV (buf) - BUF_BEGV (buf) + 1;        \
-        gl_state.offset = BUF_BEGV (buf) - 1;                           \
-      }                                                                 \
-    else if (NILP (gl_state.object))                                    \
-      {                                                                 \
-        gl_state.b_property = 1;                                        \
-        gl_state.e_property = ZV - BEGV + 1;                            \
-        gl_state.offset = BEGV - 1;                                     \
-      }                                                                 \
-    else if (EQ (gl_state.object, Qt))                                  \
-      {                                                                 \
-        gl_state.b_property = 0;                                        \
-        gl_state.e_property = PTRDIFF_MAX;                              \
-        gl_state.offset = 0;                                            \
-      }                                                                 \
-    else                                                                \
-      {                                                                 \
-        gl_state.b_property = 0;                                        \
-        gl_state.e_property = 1 + SCHARS (gl_state.object);             \
-        gl_state.offset = 0;                                            \
-      }                                                                 \
-    if (parse_sexp_lookup_properties)                                   \
-      update_syntax_table (((FROM) + gl_state.offset                    \
-                            + (COUNT > 0 ? 0 :  -1)),                   \
-                           COUNT, 1, gl_state.object);                  \
-  }                                                                     \
-while (0)
-struct gl_state_s
+SYNTAX_INLINE void
+SETUP_BUFFER_SYNTAX_TABLE (void)
 {
-  Lisp_Object object;                   /* The object we are scanning. */
+  gl_state.use_global = 0;
-  ptrdiff_t start;                      /* Where to stop. */
+  gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);
-  ptrdiff_t stop;                       /* Where to stop. */
+}
-  int use_global;                       /* Whether to use global_code
-                                           or c_s_t. */
-  Lisp_Object global_code;              /* Syntax code of current char. */
-  Lisp_Object current_syntax_table;     /* Syntax table for current pos. */
-  Lisp_Object old_prop;                 /* Syntax-table prop at prev pos. */
-  ptrdiff_t b_property;                 /* First index where c_s_t is valid. */
-  ptrdiff_t e_property;                 /* First index where c_s_t is
-                                           not valid. */
-  INTERVAL forward_i;                   /* Where to start lookup on forward */
-  INTERVAL backward_i;                  /* or backward movement.  The
-                                           data in c_s_t is valid
-                                           between these intervals,
-                                           and possibly at the
-                                           intervals too, depending
-                                           on: */
-  /* Offset for positions specified to UPDATE_SYNTAX_TABLE.  */
-  ptrdiff_t offset;
-};
-extern struct gl_state_s gl_state;
 extern ptrdiff_t scan_words (ptrdiff_t, EMACS_INT);
+extern void SETUP_SYNTAX_TABLE_FOR_OBJECT (Lisp_Object, ptrdiff_t, ptrdiff_t);
+INLINE_HEADER_END
author	Tom Tromey	2013-07-12 18:44:13 -0600
committer	Tom Tromey	2013-07-12 18:44:13 -0600
commit	b34a529f177a6ea32da5cb1254f91bf9d71838db (patch)
tree	477131abc15d3107b30b635223d87a22550b480b /src/syntax.h
parent	e6f63071a3f7721f55220514b6d9a8ee8c1232d8 (diff)
parent	5e301d7651c0691bb2bc7f3fbe711fdbe26ac471 (diff)
download	emacs-b34a529f177a6ea32da5cb1254f91bf9d71838db.tar.gz emacs-b34a529f177a6ea32da5cb1254f91bf9d71838db.zip

diff --git a/src/syntax.h b/src/syntax.h index 58d39b9059c..1b96284af42 100644 --- a/src/syntax.h +++ b/src/syntax.h
@@ -18,6 +18,10 @@ GNU General Public License for more details.
18	You should have received a copy of the GNU General Public License	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/>. */	19	along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20		20
		21	INLINE_HEADER_BEGIN
		22	#ifndef SYNTAX_INLINE
		23	# define SYNTAX_INLINE INLINE
		24	#endif
21		25
22	extern void update_syntax_table (ptrdiff_t, EMACS_INT, bool, Lisp_Object);	26	extern void update_syntax_table (ptrdiff_t, EMACS_INT, bool, Lisp_Object);
23		27
@@ -54,79 +58,64 @@ enum syntaxcode
54	Smax /* Upper bound on codes that are meaningful */	58	Smax /* Upper bound on codes that are meaningful */
55	};	59	};
56		60
57	/* Set the syntax entry VAL for char C in table TABLE. */
58
59	#define SET_RAW_SYNTAX_ENTRY(table, c, val) \
60	CHAR_TABLE_SET ((table), c, (val))
61		61
62	/* Set the syntax entry VAL for char-range RANGE in table TABLE.	62	struct gl_state_s
63	RANGE is a cons (FROM . TO) specifying the range of characters. */	63	{
		64	Lisp_Object object; /* The object we are scanning. */
		65	ptrdiff_t start; /* Where to stop. */
		66	ptrdiff_t stop; /* Where to stop. */
		67	bool use_global; /* Whether to use global_code
		68	or c_s_t. */
		69	Lisp_Object global_code; /* Syntax code of current char. */
		70	Lisp_Object current_syntax_table; /* Syntax table for current pos. */
		71	Lisp_Object old_prop; /* Syntax-table prop at prev pos. */
		72	ptrdiff_t b_property; /* First index where c_s_t is valid. */
		73	ptrdiff_t e_property; /* First index where c_s_t is
		74	not valid. */
		75	INTERVAL forward_i; /* Where to start lookup on forward */
		76	INTERVAL backward_i; /* or backward movement. The
		77	data in c_s_t is valid
		78	between these intervals,
		79	and possibly at the
		80	intervals too, depending
		81	on: */
		82	/* Offset for positions specified to UPDATE_SYNTAX_TABLE. */
		83	ptrdiff_t offset;
		84	};
64		85
65	#define SET_RAW_SYNTAX_ENTRY_RANGE(table, range, val) \	86	extern struct gl_state_s gl_state;
66	Fset_char_table_range ((table), (range), (val))
67		87
68	/* SYNTAX_ENTRY fetches the information from the entry for character C	88	/* Fetch the information from the entry for character C
69	in syntax table TABLE, or from globally kept data (gl_state).	89	in syntax table TABLE, or from globally kept data (gl_state).
70	Does inheritance. */	90	Does inheritance. */
71	/* CURRENT_SYNTAX_TABLE gives the syntax table valid for current
72	position, it is either the buffer's syntax table, or syntax table
73	found in text properties. */
74		91
		92	SYNTAX_INLINE Lisp_Object
		93	SYNTAX_ENTRY (int c)
		94	{
75	#ifdef SYNTAX_ENTRY_VIA_PROPERTY	95	#ifdef SYNTAX_ENTRY_VIA_PROPERTY
76	# define SYNTAX_ENTRY(c) \	96	return (gl_state.use_global
77	(gl_state.use_global ? gl_state.global_code : SYNTAX_ENTRY_INT (c))	97	? gl_state.global_code
78	# define CURRENT_SYNTAX_TABLE gl_state.current_syntax_table	98	: CHAR_TABLE_REF (gl_state.current_syntax_table, c));
79	#else	99	#else
80	# define SYNTAX_ENTRY SYNTAX_ENTRY_INT	100	return CHAR_TABLE_REF (BVAR (current_buffer, syntax_table), c);
81	# define CURRENT_SYNTAX_TABLE BVAR (current_buffer, syntax_table)
82	#endif	101	#endif
83		102	}
84	#define SYNTAX_ENTRY_INT(c) CHAR_TABLE_REF (CURRENT_SYNTAX_TABLE, (c))
85		103
86	/* Extract the information from the entry for character C	104	/* Extract the information from the entry for character C
87	in the current syntax table. */	105	in the current syntax table. */
88		106
89	#ifdef __GNUC__	107	SYNTAX_INLINE int
90	#define SYNTAX(c) \	108	SYNTAX_WITH_FLAGS (int c)
91	({ Lisp_Object _syntax_temp; \	109	{
92	_syntax_temp = SYNTAX_ENTRY (c); \	110	Lisp_Object ent = SYNTAX_ENTRY (c);
93	(CONSP (_syntax_temp) \	111	return CONSP (ent) ? XINT (XCAR (ent)) : Swhitespace;
94	? (enum syntaxcode) (XINT (XCAR (_syntax_temp)) & 0xff) \	112	}
95	: Swhitespace); })	113
96		114	SYNTAX_INLINE enum syntaxcode
97	#define SYNTAX_WITH_FLAGS(c) \	115	SYNTAX (int c)
98	({ Lisp_Object _syntax_temp; \	116	{
99	_syntax_temp = SYNTAX_ENTRY (c); \	117	return SYNTAX_WITH_FLAGS (c) & 0xff;
100	(CONSP (_syntax_temp) \	118	}
101	? XINT (XCAR (_syntax_temp)) \
102	: Swhitespace); })
103
104	#define SYNTAX_MATCH(c) \
105	({ Lisp_Object _syntax_temp; \
106	_syntax_temp = SYNTAX_ENTRY (c); \
107	(CONSP (_syntax_temp) \
108	? XCDR (_syntax_temp) \
109	: Qnil); })
110	#else
111	extern Lisp_Object syntax_temp;
112	#define SYNTAX(c) \
113	(syntax_temp = SYNTAX_ENTRY ((c)), \
114	(CONSP (syntax_temp) \
115	? (enum syntaxcode) (XINT (XCAR (syntax_temp)) & 0xff) \
116	: Swhitespace))
117
118	#define SYNTAX_WITH_FLAGS(c) \
119	(syntax_temp = SYNTAX_ENTRY ((c)), \
120	(CONSP (syntax_temp) \
121	? XINT (XCAR (syntax_temp)) \
122	: Swhitespace))
123
124	#define SYNTAX_MATCH(c) \
125	(syntax_temp = SYNTAX_ENTRY ((c)), \
126	(CONSP (syntax_temp) \
127	? XCDR (syntax_temp) \
128	: Qnil))
129	#endif
130		119
131		120
132	/* Whether the syntax of the character C has the prefix flag set. */	121	/* Whether the syntax of the character C has the prefix flag set. */
@@ -145,158 +134,65 @@ extern char const syntax_code_spec[16];
145	/* Convert the byte offset BYTEPOS into a character position,	134	/* Convert the byte offset BYTEPOS into a character position,
146	for the object recorded in gl_state with SETUP_SYNTAX_TABLE_FOR_OBJECT.	135	for the object recorded in gl_state with SETUP_SYNTAX_TABLE_FOR_OBJECT.
147		136
148	The value is meant for use in the UPDATE_SYNTAX_TABLE... macros.	137	The value is meant for use in code that does nothing when
149	These macros do nothing when parse_sexp_lookup_properties is 0,	138	parse_sexp_lookup_properties is 0, so return 0 in that case, for speed. */
150	so we return 0 in that case, for speed. */	139
151		140	SYNTAX_INLINE ptrdiff_t
152	#define SYNTAX_TABLE_BYTE_TO_CHAR(bytepos) \	141	SYNTAX_TABLE_BYTE_TO_CHAR (ptrdiff_t bytepos)
153	(! parse_sexp_lookup_properties \	142	{
154	? 0 \	143	return (! parse_sexp_lookup_properties
155	: STRINGP (gl_state.object) \	144	? 0
156	? string_byte_to_char (gl_state.object, (bytepos)) \	145	: STRINGP (gl_state.object)
157	: BUFFERP (gl_state.object) \	146	? string_byte_to_char (gl_state.object, bytepos)
158	? buf_bytepos_to_charpos (XBUFFER (gl_state.object), \	147	: BUFFERP (gl_state.object)
159	(bytepos) + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1) - BUF_BEGV (XBUFFER (gl_state.object)) + 1 \	148	? ((buf_bytepos_to_charpos
160	: NILP (gl_state.object) \	149	(XBUFFER (gl_state.object),
161	? BYTE_TO_CHAR ((bytepos) + BEGV_BYTE - 1) - BEGV + 1 \	150	(bytepos + BUF_BEGV_BYTE (XBUFFER (gl_state.object)) - 1)))
162	: (bytepos))	151	- BUF_BEGV (XBUFFER (gl_state.object)) + 1)
		152	: NILP (gl_state.object)
		153	? BYTE_TO_CHAR (bytepos + BEGV_BYTE - 1) - BEGV + 1
		154	: bytepos);
		155	}
163		156
164	/* Make syntax table state (gl_state) good for CHARPOS, assuming it is	157	/* Make syntax table state (gl_state) good for CHARPOS, assuming it is
165	currently good for a position before CHARPOS. */	158	currently good for a position before CHARPOS. */
166		159
167	#define UPDATE_SYNTAX_TABLE_FORWARD(charpos) \	160	SYNTAX_INLINE void
168	(parse_sexp_lookup_properties \	161	UPDATE_SYNTAX_TABLE_FORWARD (ptrdiff_t charpos)
169	&& (charpos) >= gl_state.e_property \	162	{
170	? (update_syntax_table ((charpos) + gl_state.offset, 1, 0, \	163	if (parse_sexp_lookup_properties && charpos >= gl_state.e_property)
171	gl_state.object), \	164	update_syntax_table (charpos + gl_state.offset, 1, 0, gl_state.object);
172	1) \	165	}
173	: 0)
174		166
175	/* Make syntax table state (gl_state) good for CHARPOS, assuming it is	167	/* Make syntax table state (gl_state) good for CHARPOS, assuming it is
176	currently good for a position after CHARPOS. */	168	currently good for a position after CHARPOS. */
177		169
178	#define UPDATE_SYNTAX_TABLE_BACKWARD(charpos) \	170	SYNTAX_INLINE void
179	(parse_sexp_lookup_properties \	171	UPDATE_SYNTAX_TABLE_BACKWARD (ptrdiff_t charpos)
180	&& (charpos) < gl_state.b_property \	172	{
181	? (update_syntax_table ((charpos) + gl_state.offset, -1, 0, \	173	if (parse_sexp_lookup_properties && charpos < gl_state.b_property)
182	gl_state.object), \	174	update_syntax_table (charpos + gl_state.offset, -1, 0, gl_state.object);
183	1) \	175	}
184	: 0)
185		176
186	/* Make syntax table good for CHARPOS. */	177	/* Make syntax table good for CHARPOS. */
187		178
188	#define UPDATE_SYNTAX_TABLE(charpos) \	179	SYNTAX_INLINE void
189	(parse_sexp_lookup_properties \	180	UPDATE_SYNTAX_TABLE (ptrdiff_t charpos)
190	&& (charpos) < gl_state.b_property \	181	{
191	? (update_syntax_table ((charpos) + gl_state.offset, -1, 0, \	182	UPDATE_SYNTAX_TABLE_BACKWARD (charpos);
192	gl_state.object), \	183	UPDATE_SYNTAX_TABLE_FORWARD (charpos);
193	1) \	184	}
194	: (parse_sexp_lookup_properties \	185
195	&& (charpos) >= gl_state.e_property \	186	/* Set up the buffer-global syntax table. */
196	? (update_syntax_table ((charpos) + gl_state.offset, 1, 0,\
197	gl_state.object), \
198	1) \
199	: 0))
200
201	/* This macro sets up the buffer-global syntax table. */
202	#define SETUP_BUFFER_SYNTAX_TABLE() \
203	do \
204	{ \
205	gl_state.use_global = 0; \
206	gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);\
207	} while (0)
208
209	/* This macro should be called with FROM at the start of forward
210	search, or after the last position of the backward search. It
211	makes sure that the first char is picked up with correct table, so
212	one does not need to call UPDATE_SYNTAX_TABLE immediately after the
213	call.
214	Sign of COUNT gives the direction of the search.
215	*/
216
217	#define SETUP_SYNTAX_TABLE(FROM, COUNT) \
218	do \
219	{ \
220	SETUP_BUFFER_SYNTAX_TABLE (); \
221	gl_state.b_property = BEGV; \
222	gl_state.e_property = ZV + 1; \
223	gl_state.object = Qnil; \
224	gl_state.offset = 0; \
225	if (parse_sexp_lookup_properties) \
226	if ((COUNT) > 0 \|\| (FROM) > BEGV) \
227	update_syntax_table ((COUNT) > 0 ? (FROM) : (FROM) - 1, (COUNT),\
228	1, Qnil); \
229	} \
230	while (0)
231
232	/* Same as above, but in OBJECT. If OBJECT is nil, use current buffer.
233	If it is t (which is only used in fast_c_string_match_ignore_case),
234	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 = PTRDIFF_MAX; \
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		187
277	struct gl_state_s	188	SYNTAX_INLINE void
		189	SETUP_BUFFER_SYNTAX_TABLE (void)
278	{	190	{
279	Lisp_Object object; /* The object we are scanning. */	191	gl_state.use_global = 0;
280	ptrdiff_t start; /* Where to stop. */	192	gl_state.current_syntax_table = BVAR (current_buffer, syntax_table);
281	ptrdiff_t stop; /* Where to stop. */	193	}
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	ptrdiff_t b_property; /* First index where c_s_t is valid. */
288	ptrdiff_t 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	ptrdiff_t offset;
299	};
300		194
301	extern struct gl_state_s gl_state;
302	extern ptrdiff_t scan_words (ptrdiff_t, EMACS_INT);	195	extern ptrdiff_t scan_words (ptrdiff_t, EMACS_INT);
		196	extern void SETUP_SYNTAX_TABLE_FOR_OBJECT (Lisp_Object, ptrdiff_t, ptrdiff_t);
		197
		198	INLINE_HEADER_END