/* GNU Emacs routines to deal with syntax tables; also word and list parsing.
- Copyright (C) 1985, 1987, 1993-1995, 1997-1999, 2001-2012
- Free Software Foundation, Inc.
+ Copyright (C) 1985, 1987, 1993-1995, 1997-1999, 2001-2014 Free
+ Software Foundation, Inc.
This file is part of GNU Emacs.
#include <config.h>
-#include <ctype.h>
#include <sys/types.h>
-#include <setjmp.h>
+
#include "lisp.h"
#include "commands.h"
-#include "buffer.h"
#include "character.h"
+#include "buffer.h"
#include "keymap.h"
#include "regex.h"
-/* Make syntax table lookup grant data in gl_state. */
-#define SYNTAX_ENTRY_VIA_PROPERTY
-
#include "syntax.h"
#include "intervals.h"
#include "category.h"
-/* Then there are seven single-bit flags that have the following meanings:
+/* Make syntax table lookup grant data in gl_state. */
+#define SYNTAX(c) syntax_property (c, 1)
+#define SYNTAX_ENTRY(c) syntax_property_entry (c, 1)
+#define SYNTAX_WITH_FLAGS(c) syntax_property_with_flags (c, 1)
+
+/* Eight single-bit flags have the following meanings:
1. This character is the first of a two-character comment-start sequence.
2. This character is the second of a two-character comment-start sequence.
3. This character is the first of a two-character comment-end sequence.
Note that any two-character sequence whose first character has flag 1
and whose second character has flag 2 will be interpreted as a comment start.
- bit 6 and 8 are used to discriminate between different comment styles.
+ Bits 6 and 8 discriminate among different comment styles.
Languages such as C++ allow two orthogonal syntax start/end pairs
- and bit 6 is used to determine whether a comment-end or Scommentend
+ and bit 6 determines whether a comment-end or Scommentend
ends style a or b. Comment markers can start style a, b, c, or bc.
Style a is always the default.
- For 2-char comment markers, the style b flag is only looked up on the second
+ For 2-char comment markers, the style b flag is looked up only on the second
char of the comment marker and on the first char of the comment ender.
- For style c (like to for the nested flag), the flag can be placed on any
- one of the chars.
- */
+ For style c (like the nested flag), the flag can be placed on any of
+ the chars. */
-/* These macros extract specific flags from an integer
+/* These functions extract specific flags from an integer
that holds the syntax code and the flags. */
-#define SYNTAX_FLAGS_COMSTART_FIRST(flags) (((flags) >> 16) & 1)
-
-#define SYNTAX_FLAGS_COMSTART_SECOND(flags) (((flags) >> 17) & 1)
-
-#define SYNTAX_FLAGS_COMEND_FIRST(flags) (((flags) >> 18) & 1)
-
-#define SYNTAX_FLAGS_COMEND_SECOND(flags) (((flags) >> 19) & 1)
-
-#define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
+static bool
+SYNTAX_FLAGS_COMSTART_FIRST (int flags)
+{
+ return (flags >> 16) & 1;
+}
+static bool
+SYNTAX_FLAGS_COMSTART_SECOND (int flags)
+{
+ return (flags >> 17) & 1;
+}
+static bool
+SYNTAX_FLAGS_COMEND_FIRST (int flags)
+{
+ return (flags >> 18) & 1;
+}
+static bool
+SYNTAX_FLAGS_COMEND_SECOND (int flags)
+{
+ return (flags >> 19) & 1;
+}
+static bool
+SYNTAX_FLAGS_PREFIX (int flags)
+{
+ return (flags >> 20) & 1;
+}
+static bool
+SYNTAX_FLAGS_COMMENT_STYLEB (int flags)
+{
+ return (flags >> 21) & 1;
+}
+static bool
+SYNTAX_FLAGS_COMMENT_STYLEC (int flags)
+{
+ return (flags >> 23) & 1;
+}
+static int
+SYNTAX_FLAGS_COMMENT_STYLEC2 (int flags)
+{
+ return (flags >> 22) & 2; /* SYNTAX_FLAGS_COMMENT_STYLEC (flags) * 2 */
+}
+static bool
+SYNTAX_FLAGS_COMMENT_NESTED (int flags)
+{
+ return (flags >> 22) & 1;
+}
-#define SYNTAX_FLAGS_COMMENT_STYLEB(flags) (((flags) >> 21) & 1)
-#define SYNTAX_FLAGS_COMMENT_STYLEC(flags) (((flags) >> 22) & 2)
/* FLAGS should be the flags of the main char of the comment marker, e.g.
the second for comstart and the first for comend. */
-#define SYNTAX_FLAGS_COMMENT_STYLE(flags, other_flags) \
- (SYNTAX_FLAGS_COMMENT_STYLEB (flags) \
- | SYNTAX_FLAGS_COMMENT_STYLEC (flags) \
- | SYNTAX_FLAGS_COMMENT_STYLEC (other_flags))
-
-#define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
+static int
+SYNTAX_FLAGS_COMMENT_STYLE (int flags, int other_flags)
+{
+ return (SYNTAX_FLAGS_COMMENT_STYLEB (flags)
+ | SYNTAX_FLAGS_COMMENT_STYLEC2 (flags)
+ | SYNTAX_FLAGS_COMMENT_STYLEC2 (other_flags));
+}
-/* These macros extract a particular flag for a given character. */
+/* Extract a particular flag for a given character. */
-#define SYNTAX_COMEND_FIRST(c) \
- (SYNTAX_FLAGS_COMEND_FIRST (SYNTAX_WITH_FLAGS (c)))
-#define SYNTAX_PREFIX(c) (SYNTAX_FLAGS_PREFIX (SYNTAX_WITH_FLAGS (c)))
+static bool
+SYNTAX_COMEND_FIRST (int c)
+{
+ return SYNTAX_FLAGS_COMEND_FIRST (SYNTAX_WITH_FLAGS (c));
+}
/* We use these constants in place for comment-style and
- string-ender-char to distinguish comments/strings started by
+ string-ender-char to distinguish comments/strings started by
comment_fence and string_fence codes. */
-#define ST_COMMENT_STYLE (256 + 1)
-#define ST_STRING_STYLE (256 + 2)
+enum
+ {
+ ST_COMMENT_STYLE = 256 + 1,
+ ST_STRING_STYLE = 256 + 2
+ };
static Lisp_Object Qsyntax_table_p;
static Lisp_Object Qsyntax_table, Qscan_error;
-#ifndef __GNUC__
-/* Used as a temporary in SYNTAX_ENTRY and other macros in syntax.h,
- if not compiled with GCC. No need to mark it, since it is used
- only very temporarily. */
-Lisp_Object syntax_temp;
-#endif
-
/* This is the internal form of the parse state used in parse-partial-sexp. */
struct lisp_parse_state
{
- int depth; /* Depth at end of parsing. */
+ EMACS_INT depth; /* Depth at end of parsing. */
int instring; /* -1 if not within string, else desired terminator. */
- int incomment; /* -1 if in unnestable comment else comment nesting */
+ EMACS_INT incomment; /* -1 if in unnestable comment else comment nesting */
int comstyle; /* comment style a=0, or b=1, or ST_COMMENT_STYLE. */
- int quoted; /* Nonzero if just after an escape char at end of parsing */
- int mindepth; /* Minimum depth seen while scanning. */
+ bool quoted; /* True if just after an escape char at end of parsing. */
+ EMACS_INT mindepth; /* Minimum depth seen while scanning. */
/* Char number of most recent start-of-expression at current level */
- EMACS_INT thislevelstart;
+ ptrdiff_t thislevelstart;
/* Char number of start of containing expression */
- EMACS_INT prevlevelstart;
- EMACS_INT location; /* Char number at which parsing stopped. */
- EMACS_INT comstr_start; /* Position of last comment/string starter. */
+ ptrdiff_t prevlevelstart;
+ ptrdiff_t location; /* Char number at which parsing stopped. */
+ ptrdiff_t location_byte; /* Corresponding byte position. */
+ ptrdiff_t comstr_start; /* Position of last comment/string starter. */
Lisp_Object levelstarts; /* Char numbers of starts-of-expression
of levels (starting from outermost). */
};
find_start_begv is the BEGV value when it was found.
find_start_modiff is the value of MODIFF when it was found. */
-static EMACS_INT find_start_pos;
-static EMACS_INT find_start_value;
-static EMACS_INT find_start_value_byte;
+static ptrdiff_t find_start_pos;
+static ptrdiff_t find_start_value;
+static ptrdiff_t find_start_value_byte;
static struct buffer *find_start_buffer;
-static EMACS_INT find_start_begv;
-static int find_start_modiff;
+static ptrdiff_t find_start_begv;
+static EMACS_INT find_start_modiff;
-static Lisp_Object Fsyntax_table_p (Lisp_Object);
-static Lisp_Object skip_chars (int, Lisp_Object, Lisp_Object, int);
-static Lisp_Object skip_syntaxes (int, Lisp_Object, Lisp_Object);
-static Lisp_Object scan_lists (EMACS_INT, EMACS_INT, EMACS_INT, int);
+static Lisp_Object skip_chars (bool, Lisp_Object, Lisp_Object, bool);
+static Lisp_Object skip_syntaxes (bool, Lisp_Object, Lisp_Object);
+static Lisp_Object scan_lists (EMACS_INT, EMACS_INT, EMACS_INT, bool);
static void scan_sexps_forward (struct lisp_parse_state *,
- EMACS_INT, EMACS_INT, EMACS_INT, int,
- int, Lisp_Object, int);
-static int in_classes (int, Lisp_Object);
+ ptrdiff_t, ptrdiff_t, ptrdiff_t, EMACS_INT,
+ bool, Lisp_Object, int);
+static bool in_classes (int, Lisp_Object);
+
+/* This setter is used only in this file, so it can be private. */
+static void
+bset_syntax_table (struct buffer *b, Lisp_Object val)
+{
+ b->INTERNAL_FIELD (syntax_table) = val;
+}
\f
/* Whether the syntax of the character C has the prefix flag set. */
-int syntax_prefix_flag_p (int c)
+bool
+syntax_prefix_flag_p (int c)
{
- return SYNTAX_PREFIX (c);
+ return SYNTAX_FLAGS_PREFIX (SYNTAX_WITH_FLAGS (c));
}
struct gl_state_s gl_state; /* Global state of syntax parser. */
-#define INTERVALS_AT_ONCE 10 /* 1 + max-number of intervals
+enum { INTERVALS_AT_ONCE = 10 }; /* 1 + max-number of intervals
to scan to property-change. */
+/* Set the syntax entry VAL for char C in table TABLE. */
+
+static void
+SET_RAW_SYNTAX_ENTRY (Lisp_Object table, int c, Lisp_Object val)
+{
+ CHAR_TABLE_SET (table, c, val);
+}
+
+/* Set the syntax entry VAL for char-range RANGE in table TABLE.
+ RANGE is a cons (FROM . TO) specifying the range of characters. */
+
+static void
+SET_RAW_SYNTAX_ENTRY_RANGE (Lisp_Object table, Lisp_Object range,
+ Lisp_Object val)
+{
+ Fset_char_table_range (table, range, val);
+}
+
+/* Extract the information from the entry for character C
+ in the current syntax table. */
+
+static Lisp_Object
+SYNTAX_MATCH (int c)
+{
+ Lisp_Object ent = SYNTAX_ENTRY (c);
+ return CONSP (ent) ? XCDR (ent) : Qnil;
+}
+
+/* This 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.
+ */
+
+static void
+SETUP_SYNTAX_TABLE (ptrdiff_t from, ptrdiff_t count)
+{
+ 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);
+}
+
+/* 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 functions which are relative to BEGV.
+ So if it is a buffer, we set the offset field to BEGV. */
+
+void
+SETUP_SYNTAX_TABLE_FOR_OBJECT (Lisp_Object object,
+ ptrdiff_t from, ptrdiff_t count)
+{
+ 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),
+ count, 1, gl_state.object);
+}
+
/* Update gl_state to an appropriate interval which contains CHARPOS. The
sign of COUNT give the relative position of CHARPOS wrt the previously
valid interval. If INIT, only [be]_property fields of gl_state are
direction than the intervals - or in an interval. We update the
current syntax-table basing on the property of this interval, and
update the interval to start further than CHARPOS - or be
- NULL_INTERVAL. We also update lim_property to be the next value of
+ NULL. We also update lim_property to be the next value of
charpos to call this subroutine again - or be before/after the
start/end of OBJECT. */
void
-update_syntax_table (EMACS_INT charpos, EMACS_INT count, int init,
+update_syntax_table (ptrdiff_t charpos, EMACS_INT count, bool init,
Lisp_Object object)
{
Lisp_Object tmp_table;
- unsigned cnt = 0;
- int invalidate = 1;
+ int cnt = 0;
+ bool invalidate = 1;
INTERVAL i;
if (init)
i = interval_of (charpos, object);
gl_state.backward_i = gl_state.forward_i = i;
invalidate = 0;
- if (NULL_INTERVAL_P (i))
+ if (!i)
return;
/* interval_of updates only ->position of the return value, so
update the parents manually to speed up update_interval. */
/* We are guaranteed to be called with CHARPOS either in i,
or further off. */
- if (NULL_INTERVAL_P (i))
+ if (!i)
error ("Error in syntax_table logic for to-the-end intervals");
else if (charpos < i->position) /* Move left. */
{
}
}
- while (!NULL_INTERVAL_P (i))
+ while (i)
{
if (cnt && !EQ (tmp_table, textget (i->plist, Qsyntax_table)))
{
/* e_property at EOB is not set to ZV but to ZV+1, so that
we can do INC(from);UPDATE_SYNTAX_TABLE_FORWARD without
having to check eob between the two. */
- + (NULL_INTERVAL_P (next_interval (i)) ? 1 : 0);
+ + (next_interval (i) ? 0 : 1);
gl_state.forward_i = i;
}
else
cnt++;
i = count > 0 ? next_interval (i) : previous_interval (i);
}
- eassert (NULL_INTERVAL_P (i)); /* This property goes to the end. */
+ eassert (i == NULL); /* This property goes to the end. */
if (count > 0)
gl_state.e_property = gl_state.stop;
else
gl_state.b_property = gl_state.start;
}
\f
-/* Returns TRUE if char at CHARPOS is quoted.
+/* Returns true if char at CHARPOS is quoted.
Global syntax-table data should be set up already to be good at CHARPOS
or after. On return global syntax data is good for lookup at CHARPOS. */
-static int
-char_quoted (EMACS_INT charpos, EMACS_INT bytepos)
+static bool
+char_quoted (ptrdiff_t charpos, ptrdiff_t bytepos)
{
- register enum syntaxcode code;
- register EMACS_INT beg = BEGV;
- register int quoted = 0;
- EMACS_INT orig = charpos;
+ enum syntaxcode code;
+ ptrdiff_t beg = BEGV;
+ bool quoted = 0;
+ ptrdiff_t orig = charpos;
while (charpos > beg)
{
/* Return the bytepos one character before BYTEPOS.
We assume that BYTEPOS is not at the start of the buffer. */
-static inline EMACS_INT
-dec_bytepos (EMACS_INT bytepos)
+static ptrdiff_t
+dec_bytepos (ptrdiff_t bytepos)
{
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
return bytepos - 1;
valid on return from the subroutine, so the caller should explicitly
update the global data. */
-static EMACS_INT
-find_defun_start (EMACS_INT pos, EMACS_INT pos_byte)
+static ptrdiff_t
+find_defun_start (ptrdiff_t pos, ptrdiff_t pos_byte)
{
- EMACS_INT opoint = PT, opoint_byte = PT_BYTE;
-
- if (!open_paren_in_column_0_is_defun_start)
- {
- find_start_value = BEGV;
- find_start_value_byte = BEGV_BYTE;
- find_start_buffer = current_buffer;
- find_start_modiff = MODIFF;
- find_start_begv = BEGV;
- find_start_pos = pos;
- return BEGV;
- }
+ ptrdiff_t opoint = PT, opoint_byte = PT_BYTE;
/* Use previous finding, if it's valid and applies to this inquiry. */
if (current_buffer == find_start_buffer
&& MODIFF == find_start_modiff)
return find_start_value;
+ if (!open_paren_in_column_0_is_defun_start)
+ {
+ find_start_value = BEGV;
+ find_start_value_byte = BEGV_BYTE;
+ goto found;
+ }
+
/* Back up to start of line. */
scan_newline (pos, pos_byte, BEGV, BEGV_BYTE, -1, 1);
/* Record what we found, for the next try. */
find_start_value = PT;
find_start_value_byte = PT_BYTE;
+ TEMP_SET_PT_BOTH (opoint, opoint_byte);
+
+ found:
find_start_buffer = current_buffer;
find_start_modiff = MODIFF;
find_start_begv = BEGV;
find_start_pos = pos;
- TEMP_SET_PT_BOTH (opoint, opoint_byte);
-
return find_start_value;
}
\f
/* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
-static int
-prev_char_comend_first (EMACS_INT pos, EMACS_INT pos_byte)
+static bool
+prev_char_comend_first (ptrdiff_t pos, ptrdiff_t pos_byte)
{
- int c, val;
+ int c;
+ bool val;
DEC_BOTH (pos, pos_byte);
UPDATE_SYNTAX_TABLE_BACKWARD (pos);
return val;
}
-/* Return the SYNTAX_COMSTART_FIRST of the character before POS, POS_BYTE. */
-
-/* static int
- * prev_char_comstart_first (pos, pos_byte)
- * int pos, pos_byte;
- * {
- * int c, val;
- *
- * DEC_BOTH (pos, pos_byte);
- * UPDATE_SYNTAX_TABLE_BACKWARD (pos);
- * c = FETCH_CHAR (pos_byte);
- * val = SYNTAX_COMSTART_FIRST (c);
- * UPDATE_SYNTAX_TABLE_FORWARD (pos + 1);
- * return val;
- * } */
-
-/* Checks whether charpos FROM is at the end of a comment.
+/* Check whether charpos FROM is at the end of a comment.
FROM_BYTE is the bytepos corresponding to FROM.
Do not move back before STOP.
- Return a positive value if we find a comment ending at FROM/FROM_BYTE;
- return -1 otherwise.
+ Return true if we find a comment ending at FROM/FROM_BYTE.
If successful, store the charpos of the comment's beginning
into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
Global syntax data remains valid for backward search starting at
the returned value (or at FROM, if the search was not successful). */
-static int
-back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested, int comstyle, EMACS_INT *charpos_ptr, EMACS_INT *bytepos_ptr)
+static bool
+back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop,
+ bool comnested, int comstyle, ptrdiff_t *charpos_ptr,
+ ptrdiff_t *bytepos_ptr)
{
/* Look back, counting the parity of string-quotes,
and recording the comment-starters seen.
which is I+2X quotes from the comment-end.
PARITY is current parity of quotes from the comment end. */
int string_style = -1; /* Presumed outside of any string. */
- int string_lossage = 0;
+ bool string_lossage = 0;
/* Not a real lossage: indicates that we have passed a matching comment
starter plus a non-matching comment-ender, meaning that any matching
comment-starter we might see later could be a false positive (hidden
inside another comment).
Test case: { a (* b } c (* d *) */
- int comment_lossage = 0;
- EMACS_INT comment_end = from;
- EMACS_INT comment_end_byte = from_byte;
- EMACS_INT comstart_pos = 0;
- EMACS_INT comstart_byte IF_LINT (= 0);
+ bool comment_lossage = 0;
+ ptrdiff_t comment_end = from;
+ ptrdiff_t comment_end_byte = from_byte;
+ ptrdiff_t comstart_pos = 0;
+ ptrdiff_t comstart_byte IF_LINT (= 0);
/* Place where the containing defun starts,
or 0 if we didn't come across it yet. */
- EMACS_INT defun_start = 0;
- EMACS_INT defun_start_byte = 0;
- register enum syntaxcode code;
- int nesting = 1; /* current comment nesting */
+ ptrdiff_t defun_start = 0;
+ ptrdiff_t defun_start_byte = 0;
+ enum syntaxcode code;
+ ptrdiff_t nesting = 1; /* current comment nesting */
int c;
int syntax = 0;
that determines quote parity to the comment-end. */
while (from != stop)
{
- EMACS_INT temp_byte;
- int prev_syntax, com2start, com2end;
- int comstart;
+ ptrdiff_t temp_byte;
+ int prev_syntax;
+ bool com2start, com2end, comstart;
/* Move back and examine a character. */
DEC_BOTH (from, from_byte);
have %..\n and %{..}%. */
if (from > stop && (com2end || comstart))
{
- EMACS_INT next = from, next_byte = from_byte;
+ ptrdiff_t next = from, next_byte = from_byte;
int next_c, next_syntax;
DEC_BOTH (next, next_byte);
UPDATE_SYNTAX_TABLE_BACKWARD (next);
else
{
struct lisp_parse_state state;
+ bool adjusted;
lossage:
+ adjusted = true;
/* We had two kinds of string delimiters mixed up
together. Decode this going forwards.
Scan fwd from a known safe place (beginning-of-defun)
{
defun_start = find_defun_start (comment_end, comment_end_byte);
defun_start_byte = find_start_value_byte;
+ adjusted = (defun_start > BEGV);
}
do
{
scan_sexps_forward (&state,
defun_start, defun_start_byte,
- comment_end, -10000, 0, Qnil, 0);
+ comment_end, TYPE_MINIMUM (EMACS_INT),
+ 0, Qnil, 0);
defun_start = comment_end;
+ if (!adjusted)
+ {
+ adjusted = true;
+ find_start_value
+ = CONSP (state.levelstarts) ? XINT (XCAR (state.levelstarts))
+ : state.thislevelstart >= 0 ? state.thislevelstart
+ : find_start_value;
+ find_start_value_byte = CHAR_TO_BYTE (find_start_value);
+ }
+
if (state.incomment == (comnested ? 1 : -1)
&& state.comstyle == comstyle)
from = state.comstr_start;
*charpos_ptr = from;
*bytepos_ptr = from_byte;
- return (from == comment_end) ? -1 : from;
+ return from != comment_end;
}
\f
DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
/* Only the standard syntax table should have a default element.
Other syntax tables should inherit from parents instead. */
- XCHAR_TABLE (copy)->defalt = Qnil;
+ set_char_table_defalt (copy, Qnil);
/* Copied syntax tables should all have parents.
If we copied one with no parent, such as the standard syntax table,
{
int idx;
check_syntax_table (table);
- BVAR (current_buffer, syntax_table) = table;
+ bset_syntax_table (current_buffer, table);
/* Indicate that this buffer now has a specified syntax table. */
idx = PER_BUFFER_VAR_IDX (syntax_table);
SET_PER_BUFFER_VALUE_P (current_buffer, idx, 1);
into the code it signifies.
This is used by modify-syntax-entry, and other things. */
-unsigned char syntax_spec_code[0400] =
+unsigned char const syntax_spec_code[0400] =
{ 0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
- (char) Swhitespace, (char) Scomment_fence, (char) Sstring, 0377,
- (char) Smath, 0377, 0377, (char) Squote,
- (char) Sopen, (char) Sclose, 0377, 0377,
- 0377, (char) Swhitespace, (char) Spunct, (char) Scharquote,
+ Swhitespace, Scomment_fence, Sstring, 0377, Smath, 0377, 0377, Squote,
+ Sopen, Sclose, 0377, 0377, 0377, Swhitespace, Spunct, Scharquote,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
- 0377, 0377, 0377, 0377,
- (char) Scomment, 0377, (char) Sendcomment, 0377,
- (char) Sinherit, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
+ 0377, 0377, 0377, 0377, Scomment, 0377, Sendcomment, 0377,
+ Sinherit, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* @, A ... */
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
- 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword,
- 0377, 0377, 0377, 0377, (char) Sescape, 0377, 0377, (char) Ssymbol,
+ 0377, 0377, 0377, 0377, 0377, 0377, 0377, Sword,
+ 0377, 0377, 0377, 0377, Sescape, 0377, 0377, Ssymbol,
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377, /* `, a, ... */
0377, 0377, 0377, 0377, 0377, 0377, 0377, 0377,
- 0377, 0377, 0377, 0377, 0377, 0377, 0377, (char) Sword,
- 0377, 0377, 0377, 0377, (char) Sstring_fence, 0377, 0377, 0377
+ 0377, 0377, 0377, 0377, 0377, 0377, 0377, Sword,
+ 0377, 0377, 0377, 0377, Sstring_fence, 0377, 0377, 0377
};
/* Indexed by syntax code, give the letter that describes it. */
-char syntax_code_spec[16] =
+char const syntax_code_spec[16] =
{
' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
'!', '|'
CHECK_CHARACTER (character);
char_int = XINT (character);
SETUP_BUFFER_SYNTAX_TABLE ();
- return make_number (syntax_code_spec[(int) SYNTAX (char_int)]);
+ return make_number (syntax_code_spec[SYNTAX (char_int)]);
}
DEFUN ("matching-paren", Fmatching_paren, Smatching_paren, 1, 1, 0,
doc: /* Return the matching parenthesis of CHARACTER, or nil if none. */)
(Lisp_Object character)
{
- int char_int, code;
- CHECK_NUMBER (character);
+ int char_int;
+ enum syntaxcode code;
+ CHECK_CHARACTER (character);
char_int = XINT (character);
SETUP_BUFFER_SYNTAX_TABLE ();
code = SYNTAX (char_int);
}
DEFUN ("string-to-syntax", Fstring_to_syntax, Sstring_to_syntax, 1, 1, 0,
- doc: /* Convert a syntax specification STRING into syntax cell form.
-STRING should be a string as it is allowed as argument of
-`modify-syntax-entry'. Value is the equivalent cons cell
-\(CODE . MATCHING-CHAR) that can be used as value of a `syntax-table'
-text property. */)
+ doc: /* Convert a syntax descriptor STRING into a raw syntax descriptor.
+STRING should be a string of the form allowed as argument of
+`modify-syntax-entry'. The return value is a raw syntax descriptor: a
+cons cell \(CODE . MATCHING-CHAR) which can be used, for example, as
+the value of a `syntax-table' text property. */)
(Lisp_Object string)
{
- register const unsigned char *p;
- register enum syntaxcode code;
+ const unsigned char *p;
int val;
Lisp_Object match;
CHECK_STRING (string);
p = SDATA (string);
- code = (enum syntaxcode) syntax_spec_code[*p++];
- if (((int) code & 0377) == 0377)
+ val = syntax_spec_code[*p++];
+ if (val == 0377)
error ("Invalid syntax description letter: %c", p[-1]);
- if (code == Sinherit)
+ if (val == Sinherit)
return Qnil;
if (*p)
else
match = Qnil;
- val = (int) code;
while (*p)
switch (*p++)
{
}
if (val < ASIZE (Vsyntax_code_object) && NILP (match))
- return XVECTOR (Vsyntax_code_object)->contents[val];
+ return AREF (Vsyntax_code_object, val);
else
/* Since we can't use a shared object, let's make a new one. */
return Fcons (make_number (val), match);
" string quote. \\ escape.
$ paired delimiter. ' expression quote or prefix operator.
< comment starter. > comment ender.
- / character-quote. @ inherit from `standard-syntax-table'.
+ / character-quote. @ inherit from parent table.
| generic string fence. ! generic comment fence.
Only single-character comment start and end sequences are represented thus.
doc: /* Insert a description of the internal syntax description SYNTAX at point. */)
(Lisp_Object syntax)
{
- register enum syntaxcode code;
- int syntax_code;
- char desc, start1, start2, end1, end2, prefix,
- comstyleb, comstylec, comnested;
+ int code, syntax_code;
+ bool start1, start2, end1, end2, prefix, comstyleb, comstylec, comnested;
char str[2];
Lisp_Object first, match_lisp, value = syntax;
first = XCAR (value);
match_lisp = XCDR (value);
- if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
+ if (!INTEGERP (first) || !(NILP (match_lisp) || CHARACTERP (match_lisp)))
{
insert_string ("invalid");
return syntax;
}
- syntax_code = XINT (first);
- code = (enum syntaxcode) (syntax_code & 0377);
+ syntax_code = XINT (first) & INT_MAX;
+ code = syntax_code & 0377;
start1 = SYNTAX_FLAGS_COMSTART_FIRST (syntax_code);
start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);;
end1 = SYNTAX_FLAGS_COMEND_FIRST (syntax_code);
comstylec = SYNTAX_FLAGS_COMMENT_STYLEC (syntax_code);
comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax_code);
- if ((int) code < 0 || (int) code >= (int) Smax)
+ if (Smax <= code)
{
insert_string ("invalid");
return syntax;
}
- desc = syntax_code_spec[(int) code];
- str[0] = desc, str[1] = 0;
+ str[0] = syntax_code_spec[code], str[1] = 0;
insert (str, 1);
if (NILP (match_lisp))
insert_string ("\twhich means: ");
- switch (SWITCH_ENUM_CAST (code))
+ switch (code)
{
case Swhitespace:
insert_string ("whitespace"); break;
If that many words cannot be found before the end of the buffer, return 0.
COUNT negative means scan backward and stop at word beginning. */
-EMACS_INT
-scan_words (register EMACS_INT from, register EMACS_INT count)
+ptrdiff_t
+scan_words (register ptrdiff_t from, register EMACS_INT count)
{
- register EMACS_INT beg = BEGV;
- register EMACS_INT end = ZV;
- register EMACS_INT from_byte = CHAR_TO_BYTE (from);
+ register ptrdiff_t beg = BEGV;
+ register ptrdiff_t end = ZV;
+ register ptrdiff_t from_byte = CHAR_TO_BYTE (from);
register enum syntaxcode code;
int ch0, ch1;
Lisp_Object func, pos;
if (! NILP (Ffboundp (func)))
{
pos = call2 (func, make_number (from - 1), make_number (end));
- if (INTEGERP (pos) && XINT (pos) > from)
+ if (INTEGERP (pos) && from < XINT (pos) && XINT (pos) <= ZV)
{
from = XINT (pos);
from_byte = CHAR_TO_BYTE (from);
if (! NILP (Ffboundp (func)))
{
pos = call2 (func, make_number (from), make_number (beg));
- if (INTEGERP (pos) && XINT (pos) < from)
+ if (INTEGERP (pos) && BEGV <= XINT (pos) && XINT (pos) < from)
{
from = XINT (pos);
from_byte = CHAR_TO_BYTE (from);
DEFUN ("forward-word", Fforward_word, Sforward_word, 0, 1, "^p",
doc: /* Move point forward ARG words (backward if ARG is negative).
+If ARG is omitted or nil, move point forward one word.
Normally returns t.
If an edge of the buffer or a field boundary is reached, point is left there
and the function returns nil. Field boundaries are not noticed if
(Lisp_Object arg)
{
Lisp_Object tmp;
- int orig_val, val;
+ ptrdiff_t orig_val, val;
if (NILP (arg))
XSETFASTINT (arg, 1);
/* Avoid jumping out of an input field. */
tmp = Fconstrain_to_field (make_number (val), make_number (PT),
- Qt, Qnil, Qnil);
+ Qnil, Qnil, Qnil);
val = XFASTINT (tmp);
SET_PT (val);
SYNTAX is a string of syntax code characters.
Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.
If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.
-This function returns the distance traveled, either zero or negative. */)
+This function returns either zero or a negative number, and the absolute value
+of this is the distance traveled. */)
(Lisp_Object syntax, Lisp_Object lim)
{
return skip_syntaxes (0, syntax, lim);
}
static Lisp_Object
-skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_classes)
+skip_chars (bool forwardp, Lisp_Object string, Lisp_Object lim,
+ bool handle_iso_classes)
{
- register unsigned int c;
- unsigned char fastmap[0400];
+ int c;
+ char fastmap[0400];
/* Store the ranges of non-ASCII characters. */
int *char_ranges IF_LINT (= NULL);
int n_char_ranges = 0;
- int negate = 0;
- register EMACS_INT i, i_byte;
- /* Set to 1 if the current buffer is multibyte and the region
- contains non-ASCII chars. */
- int multibyte;
- /* Set to 1 if STRING is multibyte and it contains non-ASCII
- chars. */
- int string_multibyte;
- EMACS_INT size_byte;
+ bool negate = 0;
+ ptrdiff_t i, i_byte;
+ /* True if the current buffer is multibyte and the region contains
+ non-ASCII chars. */
+ bool multibyte;
+ /* True if STRING is multibyte and it contains non-ASCII chars. */
+ bool string_multibyte;
+ ptrdiff_t size_byte;
const unsigned char *str;
int len;
Lisp_Object iso_classes;
if (! string_multibyte)
{
- int string_has_eight_bit = 0;
+ bool string_has_eight_bit = 0;
/* At first setup fastmap. */
while (i_byte < size_byte)
if (i_byte + 1 < size_byte
&& str[i_byte] == '-')
{
- unsigned int c2;
+ int c2;
/* Skip over the dash. */
i_byte++;
if (c <= c2)
{
- unsigned lim2 = c2 + 1;
+ int lim2 = c2 + 1;
while (c < lim2)
fastmap[c++] = 1;
if (! ASCII_CHAR_P (c2))
the corresponding multibyte chars. */
if (multibyte && string_has_eight_bit)
{
- unsigned char fastmap2[0400];
- int range_start_byte, range_start_char;
-
- memcpy (fastmap + 0200, fastmap2 + 0200, 0200);
+ char *p1;
+ char himap[0200 + 1];
+ memcpy (himap, fastmap + 0200, 0200);
+ himap[0200] = 0;
memset (fastmap + 0200, 0, 0200);
- /* We are sure that this loop stops. */
- for (i = 0200; ! fastmap2[i]; i++);
- c = BYTE8_TO_CHAR (i);
- fastmap[CHAR_LEADING_CODE (c)] = 1;
- range_start_byte = i;
- range_start_char = c;
- char_ranges = (int *) alloca (sizeof (int) * 128 * 2);
- for (i = 129; i < 0400; i++)
+ char_ranges = alloca (sizeof *char_ranges * 128 * 2);
+ i = 0;
+
+ while ((p1 = memchr (himap + i, 1, 0200 - i)))
{
- c = BYTE8_TO_CHAR (i);
- fastmap[CHAR_LEADING_CODE (c)] = 1;
- if (i - range_start_byte != c - range_start_char)
- {
- char_ranges[n_char_ranges++] = range_start_char;
- char_ranges[n_char_ranges++] = ((i - 1 - range_start_byte)
- + range_start_char);
- range_start_byte = i;
- range_start_char = c;
- }
+ /* Deduce the next range C..C2 from the next clump of 1s
+ in HIMAP starting with &HIMAP[I]. HIMAP is the high
+ order half of the old FASTMAP. */
+ int c2, leading_code;
+ i = p1 - himap;
+ c = BYTE8_TO_CHAR (i + 0200);
+ i += strlen (p1);
+ c2 = BYTE8_TO_CHAR (i + 0200 - 1);
+
+ char_ranges[n_char_ranges++] = c;
+ char_ranges[n_char_ranges++] = c2;
+ leading_code = CHAR_LEADING_CODE (c);
+ memset (fastmap + leading_code, 1,
+ CHAR_LEADING_CODE (c2) - leading_code + 1);
}
- char_ranges[n_char_ranges++] = range_start_char;
- char_ranges[n_char_ranges++] = ((i - 1 - range_start_byte)
- + range_start_char);
}
}
else /* STRING is multibyte */
{
- char_ranges = (int *) alloca (sizeof (int) * SCHARS (string) * 2);
+ char_ranges = alloca (sizeof *char_ranges * SCHARS (string) * 2);
while (i_byte < size_byte)
{
- unsigned char leading_code;
-
- leading_code = str[i_byte];
+ int leading_code = str[i_byte];
c = STRING_CHAR_AND_LENGTH (str + i_byte, len);
i_byte += len;
if (i_byte + 1 < size_byte
&& str[i_byte] == '-')
{
- unsigned int c2;
- unsigned char leading_code2;
+ int c2, leading_code2;
/* Skip over the dash. */
i_byte++;
&& i_byte < size_byte)
{
leading_code2 = str[i_byte];
- c2 =STRING_CHAR_AND_LENGTH (str + i_byte, len);
+ c2 = STRING_CHAR_AND_LENGTH (str + i_byte, len);
i_byte += len;
}
}
if (! ASCII_CHAR_P (c))
{
- unsigned lim2 = leading_code2 + 1;
+ int lim2 = leading_code2 + 1;
while (leading_code < lim2)
fastmap[leading_code++] = 1;
if (c <= c2)
for (i = 0; i < n_char_ranges; i += 2)
{
int c1 = char_ranges[i];
- unsigned lim2 = char_ranges[i + 1] + 1;
+ int lim2 = char_ranges[i + 1] + 1;
for (; c1 < lim2; c1++)
{
}
{
- EMACS_INT start_point = PT;
- EMACS_INT pos = PT;
- EMACS_INT pos_byte = PT_BYTE;
+ ptrdiff_t start_point = PT;
+ ptrdiff_t pos = PT;
+ ptrdiff_t pos_byte = PT_BYTE;
unsigned char *p = PT_ADDR, *endp, *stop;
if (forwardp)
}
immediate_quit = 1;
- /* This code may look up syntax tables using macros that rely on the
+ /* This code may look up syntax tables using functions that rely on the
gl_state object. To make sure this object is not out of date,
let's initialize it manually.
We ignore syntax-table text-properties for now, since that's
static Lisp_Object
-skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
+skip_syntaxes (bool forwardp, Lisp_Object string, Lisp_Object lim)
{
- register unsigned int c;
+ int c;
unsigned char fastmap[0400];
- int negate = 0;
- register EMACS_INT i, i_byte;
- int multibyte;
- EMACS_INT size_byte;
+ bool negate = 0;
+ ptrdiff_t i, i_byte;
+ bool multibyte;
+ ptrdiff_t size_byte;
unsigned char *str;
CHECK_STRING (string);
fastmap[i] ^= 1;
{
- EMACS_INT start_point = PT;
- EMACS_INT pos = PT;
- EMACS_INT pos_byte = PT_BYTE;
+ ptrdiff_t start_point = PT;
+ ptrdiff_t pos = PT;
+ ptrdiff_t pos_byte = PT_BYTE;
unsigned char *p = PT_ADDR, *endp, *stop;
if (forwardp)
stop = endp;
}
c = STRING_CHAR_AND_LENGTH (p, nbytes);
- if (! fastmap[(int) SYNTAX (c)])
+ if (! fastmap[SYNTAX (c)])
break;
p += nbytes, pos++, pos_byte += nbytes;
UPDATE_SYNTAX_TABLE_FORWARD (pos);
p = GAP_END_ADDR;
stop = endp;
}
- if (! fastmap[(int) SYNTAX (*p)])
+ if (! fastmap[SYNTAX (*p)])
break;
p++, pos++, pos_byte++;
UPDATE_SYNTAX_TABLE_FORWARD (pos);
prev_p = p;
while (--p >= stop && ! CHAR_HEAD_P (*p));
c = STRING_CHAR (p);
- if (! fastmap[(int) SYNTAX (c)])
+ if (! fastmap[SYNTAX (c)])
break;
pos--, pos_byte -= prev_p - p;
}
stop = endp;
}
UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
- if (! fastmap[(int) SYNTAX (p[-1])])
+ if (! fastmap[SYNTAX (p[-1])])
break;
p--, pos--, pos_byte--;
}
}
}
-/* Return 1 if character C belongs to one of the ISO classes
+/* Return true if character C belongs to one of the ISO classes
in the list ISO_CLASSES. Each class is represented by an
integer which is its type according to re_wctype. */
-static int
+static bool
in_classes (int c, Lisp_Object iso_classes)
{
- int fits_class = 0;
+ bool fits_class = 0;
while (CONSP (iso_classes))
{
FROM_BYTE is the bytepos corresponding to FROM.
Do not move past STOP (a charpos).
The comment over which we have to jump is of style STYLE
- (either SYNTAX_FLAGS_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
+ (either SYNTAX_FLAGS_COMMENT_STYLE (foo) or ST_COMMENT_STYLE).
NESTING should be positive to indicate the nesting at the beginning
for nested comments and should be zero or negative else.
ST_COMMENT_STYLE cannot be nested.
PREV_SYNTAX is the SYNTAX_WITH_FLAGS of the previous character
(or 0 If the search cannot start in the middle of a two-character).
- If successful, return 1 and store the charpos of the comment's end
+ If successful, return true and store the charpos of the comment's end
into *CHARPOS_PTR and the corresponding bytepos into *BYTEPOS_PTR.
- Else, return 0 and store the charpos STOP into *CHARPOS_PTR, the
+ Else, return false and store the charpos STOP into *CHARPOS_PTR, the
corresponding bytepos into *BYTEPOS_PTR and the current nesting
(as defined for state.incomment) in *INCOMMENT_PTR.
The comment end is the last character of the comment rather than the
- character just after the comment.
+ character just after the comment.
Global syntax data is assumed to initially be valid for FROM and
remains valid for forward search starting at the returned position. */
-static int
-forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
- int nesting, int style, int prev_syntax,
- EMACS_INT *charpos_ptr, EMACS_INT *bytepos_ptr,
- int *incomment_ptr)
+static bool
+forw_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop,
+ EMACS_INT nesting, int style, int prev_syntax,
+ ptrdiff_t *charpos_ptr, ptrdiff_t *bytepos_ptr,
+ EMACS_INT *incomment_ptr)
{
register int c, c1;
register enum syntaxcode code;
between them, return t; otherwise return nil. */)
(Lisp_Object count)
{
- register EMACS_INT from;
- EMACS_INT from_byte;
- register EMACS_INT stop;
- register int c, c1;
- register enum syntaxcode code;
+ ptrdiff_t from, from_byte, stop;
+ int c, c1;
+ enum syntaxcode code;
int comstyle = 0; /* style of comment encountered */
- int comnested = 0; /* whether the comment is nestable or not */
- int found;
+ bool comnested = 0; /* whether the comment is nestable or not */
+ bool found;
EMACS_INT count1;
- EMACS_INT out_charpos, out_bytepos;
- int dummy;
+ ptrdiff_t out_charpos, out_bytepos;
+ EMACS_INT dummy;
CHECK_NUMBER (count);
count1 = XINT (count);
{
do
{
- int comstart_first, syntax, other_syntax;
+ bool comstart_first;
+ int syntax, other_syntax;
if (from == stop)
{
the comment section. */
code = Scomment;
comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
- comnested
- = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
+ comnested |= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
INC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_FORWARD (from);
}
{
while (1)
{
- int quoted, syntax;
+ bool quoted;
+ int syntax;
if (from <= stop)
{
c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
other_syntax = SYNTAX_WITH_FLAGS (c1);
comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
- comnested
- = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
+ comnested |= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
}
if (code == Scomment_fence)
{
/* Skip until first preceding unquoted comment_fence. */
- int fence_found = 0;
- EMACS_INT ini = from, ini_byte = from_byte;
+ bool fence_found = 0;
+ ptrdiff_t ini = from, ini_byte = from_byte;
while (1)
{
{
found = back_comment (from, from_byte, stop, comnested, comstyle,
&out_charpos, &out_bytepos);
- if (found == -1)
+ if (!found)
{
if (c == '\n')
/* This end-of-line is not an end-of-comment.
}
\f
/* Return syntax code of character C if C is an ASCII character
- or `multibyte_symbol_p' is zero. Otherwise, return Ssymbol. */
+ or if MULTIBYTE_SYMBOL_P is false. Otherwise, return Ssymbol. */
-#define SYNTAX_WITH_MULTIBYTE_CHECK(c) \
- ((ASCII_CHAR_P (c) || !multibyte_symbol_p) \
- ? SYNTAX (c) : Ssymbol)
+static enum syntaxcode
+syntax_multibyte (int c, bool multibyte_symbol_p)
+{
+ return ASCII_CHAR_P (c) || !multibyte_symbol_p ? SYNTAX (c) : Ssymbol;
+}
static Lisp_Object
-scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpflag)
+scan_lists (EMACS_INT from, EMACS_INT count, EMACS_INT depth, bool sexpflag)
{
Lisp_Object val;
- register EMACS_INT stop = count > 0 ? ZV : BEGV;
- register int c, c1;
+ ptrdiff_t stop = count > 0 ? ZV : BEGV;
+ int c, c1;
int stringterm;
- int quoted;
- int mathexit = 0;
- register enum syntaxcode code, temp_code;
- int min_depth = depth; /* Err out if depth gets less than this. */
+ bool quoted;
+ bool mathexit = 0;
+ enum syntaxcode code;
+ EMACS_INT min_depth = depth; /* Err out if depth gets less than this. */
int comstyle = 0; /* style of comment encountered */
- int comnested = 0; /* whether the comment is nestable or not */
- EMACS_INT temp_pos;
+ bool comnested = 0; /* whether the comment is nestable or not */
+ ptrdiff_t temp_pos;
EMACS_INT last_good = from;
- int found;
- EMACS_INT from_byte;
- EMACS_INT out_bytepos, out_charpos;
- int temp, dummy;
- int multibyte_symbol_p = sexpflag && multibyte_syntax_as_symbol;
+ bool found;
+ ptrdiff_t from_byte;
+ ptrdiff_t out_bytepos, out_charpos;
+ EMACS_INT dummy;
+ bool multibyte_symbol_p = sexpflag && multibyte_syntax_as_symbol;
if (depth > 0) min_depth = 0;
{
while (from < stop)
{
- int comstart_first, prefix, syntax, other_syntax;
+ bool comstart_first, prefix;
+ int syntax, other_syntax;
UPDATE_SYNTAX_TABLE_FORWARD (from);
c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
syntax = SYNTAX_WITH_FLAGS (c);
- code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
+ code = syntax_multibyte (c, multibyte_symbol_p);
comstart_first = SYNTAX_FLAGS_COMSTART_FIRST (syntax);
comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
the comment section */
code = Scomment;
comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
- comnested
- = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
+ comnested |= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
INC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_FORWARD (from);
}
if (prefix)
continue;
- switch (SWITCH_ENUM_CAST (code))
+ switch (code)
{
case Sescape:
case Scharquote:
{
UPDATE_SYNTAX_TABLE_FORWARD (from);
- /* Some compilers can't handle this inside the switch. */
c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
- temp = SYNTAX_WITH_MULTIBYTE_CHECK (c);
- switch (temp)
+ switch (syntax_multibyte (c, multibyte_symbol_p))
{
case Scharquote:
case Sescape:
stringterm = FETCH_CHAR_AS_MULTIBYTE (temp_pos);
while (1)
{
+ enum syntaxcode c_code;
if (from >= stop)
goto lose;
UPDATE_SYNTAX_TABLE_FORWARD (from);
c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+ c_code = syntax_multibyte (c, multibyte_symbol_p);
if (code == Sstring
- ? (c == stringterm
- && SYNTAX_WITH_MULTIBYTE_CHECK (c) == Sstring)
- : SYNTAX_WITH_MULTIBYTE_CHECK (c) == Sstring_fence)
+ ? c == stringterm && c_code == Sstring
+ : c_code == Sstring_fence)
break;
- /* Some compilers can't handle this inside the switch. */
- temp = SYNTAX_WITH_MULTIBYTE_CHECK (c);
- switch (temp)
+ switch (c_code)
{
case Scharquote:
case Sescape:
UPDATE_SYNTAX_TABLE_BACKWARD (from);
c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
syntax= SYNTAX_WITH_FLAGS (c);
- code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
+ code = syntax_multibyte (c, multibyte_symbol_p);
if (depth == min_depth)
last_good = from;
comstyle = 0;
c2 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
other_syntax = SYNTAX_WITH_FLAGS (c2);
comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
- comnested
- = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
+ comnested |= SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
}
/* Quoting turns anything except a comment-ender
else if (SYNTAX_FLAGS_PREFIX (syntax))
continue;
- switch (SWITCH_ENUM_CAST (code))
+ switch (code)
{
case Sword:
case Ssymbol:
temp_pos--;
UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
c1 = FETCH_CHAR_AS_MULTIBYTE (temp_pos);
- temp_code = SYNTAX_WITH_MULTIBYTE_CHECK (c1);
/* Don't allow comment-end to be quoted. */
- if (temp_code == Sendcomment)
+ if (syntax_multibyte (c1, multibyte_symbol_p) == Sendcomment)
goto done2;
quoted = char_quoted (from - 1, temp_pos);
if (quoted)
UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
}
c1 = FETCH_CHAR_AS_MULTIBYTE (temp_pos);
- temp_code = SYNTAX_WITH_MULTIBYTE_CHECK (c1);
- if (! (quoted || temp_code == Sword
- || temp_code == Ssymbol
- || temp_code == Squote))
- goto done2;
+ if (! quoted)
+ switch (syntax_multibyte (c1, multibyte_symbol_p))
+ {
+ case Sword: case Ssymbol: case Squote: break;
+ default: goto done2;
+ }
DEC_BOTH (from, from_byte);
}
goto done2;
case Smath:
if (!sexpflag)
break;
- temp_pos = dec_bytepos (from_byte);
- UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
- if (from != stop && c == FETCH_CHAR_AS_MULTIBYTE (temp_pos))
- DEC_BOTH (from, from_byte);
+ if (from > BEGV)
+ {
+ temp_pos = dec_bytepos (from_byte);
+ UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
+ if (from != stop && c == FETCH_CHAR_AS_MULTIBYTE (temp_pos))
+ DEC_BOTH (from, from_byte);
+ }
if (mathexit)
{
mathexit = 0;
break;
found = back_comment (from, from_byte, stop, comnested, comstyle,
&out_charpos, &out_bytepos);
- /* FIXME: if found == -1, then it really wasn't a comment-end.
+ /* FIXME: if !found, it really wasn't a comment-end.
For single-char Sendcomment, we can't do much about it apart
from skipping the char.
For 2-char endcomments, we could try again, taking both
chars as separate entities, but it's a lot of trouble
for very little gain, so we don't bother either. -sm */
- if (found != -1)
+ if (found)
from = out_charpos, from_byte = out_bytepos;
break;
goto lose;
DEC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_BACKWARD (from);
- if (!char_quoted (from, from_byte)
- && (c = FETCH_CHAR_AS_MULTIBYTE (from_byte),
- SYNTAX_WITH_MULTIBYTE_CHECK (c) == code))
- break;
+ if (!char_quoted (from, from_byte))
+ {
+ c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+ if (syntax_multibyte (c, multibyte_symbol_p) == code)
+ break;
+ }
}
if (code == Sstring_fence && !depth && sexpflag) goto done2;
break;
goto lose;
DEC_BOTH (from, from_byte);
UPDATE_SYNTAX_TABLE_BACKWARD (from);
- if (!char_quoted (from, from_byte)
- && (stringterm
- == (c = FETCH_CHAR_AS_MULTIBYTE (from_byte)))
- && SYNTAX_WITH_MULTIBYTE_CHECK (c) == Sstring)
- break;
+ if (!char_quoted (from, from_byte))
+ {
+ c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+ if (c == stringterm
+ && (syntax_multibyte (c, multibyte_symbol_p)
+ == Sstring))
+ break;
+ }
}
if (!depth && sexpflag) goto done2;
break;
point (i.e. the starting point is DEPTH parentheses deep). This
function scans over parentheses until the depth goes to zero COUNT
times. Hence, positive DEPTH moves out that number of levels of
-paretheses, while negative DEPTH moves to a deeper level.
+parentheses, while negative DEPTH moves to a deeper level.
Comments are ignored if `parse-sexp-ignore-comments' is non-nil.
This includes chars with "quote" or "prefix" syntax (' or p). */)
(void)
{
- EMACS_INT beg = BEGV;
- EMACS_INT opoint = PT;
- EMACS_INT opoint_byte = PT_BYTE;
- EMACS_INT pos = PT;
- EMACS_INT pos_byte = PT_BYTE;
+ ptrdiff_t beg = BEGV;
+ ptrdiff_t opoint = PT;
+ ptrdiff_t opoint_byte = PT_BYTE;
+ ptrdiff_t pos = PT;
+ ptrdiff_t pos_byte = PT_BYTE;
int c;
if (pos <= beg)
while (!char_quoted (pos, pos_byte)
/* Previous statement updates syntax table. */
&& ((c = FETCH_CHAR_AS_MULTIBYTE (pos_byte), SYNTAX (c) == Squote)
- || SYNTAX_PREFIX (c)))
+ || syntax_prefix_flag_p (c)))
{
opoint = pos;
opoint_byte = pos_byte;
/* Parse forward from FROM / FROM_BYTE to END,
assuming that FROM has state OLDSTATE (nil means FROM is start of function),
and return a description of the state of the parse at END.
- If STOPBEFORE is nonzero, stop at the start of an atom.
+ If STOPBEFORE, stop at the start of an atom.
If COMMENTSTOP is 1, stop at the start of a comment.
If COMMENTSTOP is -1, stop at the start or end of a comment,
after the beginning of a string, or after the end of a string. */
static void
scan_sexps_forward (struct lisp_parse_state *stateptr,
- EMACS_INT from, EMACS_INT from_byte, EMACS_INT end,
- int targetdepth, int stopbefore,
+ ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t end,
+ EMACS_INT targetdepth, bool stopbefore,
Lisp_Object oldstate, int commentstop)
{
struct lisp_parse_state state;
-
- register enum syntaxcode code;
+ enum syntaxcode code;
int c1;
- int comnested;
- struct level { int last, prev; };
+ bool comnested;
+ struct level { ptrdiff_t last, prev; };
struct level levelstart[100];
- register struct level *curlevel = levelstart;
+ struct level *curlevel = levelstart;
struct level *endlevel = levelstart + 100;
- register int depth; /* Paren depth of current scanning location.
+ EMACS_INT depth; /* Paren depth of current scanning location.
level - levelstart equals this except
when the depth becomes negative. */
- int mindepth; /* Lowest DEPTH value seen. */
- int start_quoted = 0; /* Nonzero means starting after a char quote */
+ EMACS_INT mindepth; /* Lowest DEPTH value seen. */
+ bool start_quoted = 0; /* True means starting after a char quote. */
Lisp_Object tem;
- EMACS_INT prev_from; /* Keep one character before FROM. */
- EMACS_INT prev_from_byte;
+ ptrdiff_t prev_from; /* Keep one character before FROM. */
+ ptrdiff_t prev_from_byte;
int prev_from_syntax;
- int boundary_stop = commentstop == -1;
- int nofence;
- int found;
- EMACS_INT out_bytepos, out_charpos;
+ bool boundary_stop = commentstop == -1;
+ bool nofence;
+ bool found;
+ ptrdiff_t out_bytepos, out_charpos;
int temp;
prev_from = from;
tem = Fcar (oldstate);
/* Check whether we are inside string_fence-style string: */
state.instring = (!NILP (tem)
- ? (INTEGERP (tem) ? XINT (tem) : ST_STRING_STYLE)
+ ? (CHARACTERP (tem) ? XFASTINT (tem) : ST_STRING_STYLE)
: -1);
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
state.comstyle = (NILP (tem)
? 0
- : (EQ (tem, Qsyntax_table)
- ? ST_COMMENT_STYLE
- : INTEGERP (tem) ? XINT (tem) : 1));
+ : (RANGED_INTEGERP (0, tem, ST_COMMENT_STYLE)
+ ? XINT (tem)
+ : ST_COMMENT_STYLE));
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
- state.comstr_start = NILP (tem) ? -1 : XINT (tem) ;
+ state.comstr_start =
+ RANGED_INTEGERP (PTRDIFF_MIN, tem, PTRDIFF_MAX) ? XINT (tem) : -1;
oldstate = Fcdr (oldstate);
tem = Fcar (oldstate);
while (!NILP (tem)) /* >= second enclosing sexps. */
{
- /* curlevel++->last ran into compiler bug on Apollo */
- curlevel->last = XINT (Fcar (tem));
+ Lisp_Object temhd = Fcar (tem);
+ if (RANGED_INTEGERP (PTRDIFF_MIN, temhd, PTRDIFF_MAX))
+ curlevel->last = XINT (temhd);
if (++curlevel == endlevel)
curlevel--; /* error ("Nesting too deep for parser"); */
curlevel->prev = -1;
terminates the comment section. */
state.comstyle
= SYNTAX_FLAGS_COMMENT_STYLE (syntax, prev_from_syntax);
- comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
- comnested = comnested || SYNTAX_FLAGS_COMMENT_NESTED (syntax);
+ comnested = (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax)
+ | SYNTAX_FLAGS_COMMENT_NESTED (syntax));
state.incomment = comnested ? 1 : -1;
state.comstr_start = prev_from;
INC_FROM;
if (SYNTAX_FLAGS_PREFIX (prev_from_syntax))
continue;
- switch (SWITCH_ENUM_CAST (code))
+ switch (code)
{
case Sescape:
case Scharquote:
symstarted:
while (from < end)
{
- /* Some compilers can't handle this inside the switch. */
- temp = FETCH_CHAR_AS_MULTIBYTE (from_byte);
- temp = SYNTAX (temp);
- switch (temp)
+ int symchar = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+ switch (SYNTAX (symchar))
{
case Scharquote:
case Sescape:
while (1)
{
int c;
+ enum syntaxcode c_code;
if (from >= end) goto done;
c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
- /* Some compilers can't handle this inside the switch. */
- temp = SYNTAX (c);
+ c_code = SYNTAX (c);
- /* Check TEMP here so that if the char has
+ /* Check C_CODE here so that if the char has
a syntax-table property which says it is NOT
a string character, it does not end the string. */
- if (nofence && c == state.instring && temp == Sstring)
+ if (nofence && c == state.instring && c_code == Sstring)
break;
- switch (temp)
+ switch (c_code)
{
case Sstring_fence:
if (!nofence) goto string_end;
stop: /* Here if stopping before start of sexp. */
from = prev_from; /* We have just fetched the char that starts it; */
+ from_byte = prev_from_byte;
goto done; /* but return the position before it. */
endquoted:
state.prevlevelstart
= (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
state.location = from;
+ state.location_byte = from_byte;
state.levelstarts = Qnil;
while (curlevel > levelstart)
state.levelstarts = Fcons (make_number ((--curlevel)->last),
any character that starts a sexp.
Fifth arg OLDSTATE is a list like what this function returns.
It is used to initialize the state of the parse. Elements number 1, 2, 6
- and 8 are ignored.
+ are ignored.
Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
If it is symbol `syntax-table', stop after the start of a comment or a
string, or after end of a comment or a string. */)
- (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth, Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
+ (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth,
+ Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
{
struct lisp_parse_state state;
- int target;
+ EMACS_INT target;
if (!NILP (targetdepth))
{
target = XINT (targetdepth);
}
else
- target = -100000; /* We won't reach this depth */
+ target = TYPE_MINIMUM (EMACS_INT); /* We won't reach this depth */
validate_region (&from, &to);
scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
(NILP (commentstop)
? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
- SET_PT (state.location);
+ SET_PT_BOTH (state.location, state.location_byte);
return Fcons (make_number (state.depth),
Fcons (state.prevlevelstart < 0
/* This has to be done here, before we call Fmake_char_table. */
DEFSYM (Qsyntax_table, "syntax-table");
- /* Intern_C_String this now in case it isn't already done.
- Setting this variable twice is harmless.
- But don't staticpro it here--that is done in alloc.c. */
+ /* This variable is DEFSYMed in alloc.c and not initialized yet, so
+ intern it here. NOTE: you must guarantee that init_syntax_once
+ is called before all other users of this variable. */
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
/* Create objects which can be shared among syntax tables. */
- Vsyntax_code_object = Fmake_vector (make_number (Smax), Qnil);
- for (i = 0; i < ASIZE (Vsyntax_code_object); i++)
- XVECTOR (Vsyntax_code_object)->contents[i]
- = Fcons (make_number (i), Qnil);
+ Vsyntax_code_object = make_uninit_vector (Smax);
+ for (i = 0; i < Smax; i++)
+ ASET (Vsyntax_code_object, i, Fcons (make_number (i), Qnil));
/* Now we are ready to set up this property, so we can
create syntax tables. */
Fput (Qsyntax_table, Qchar_table_extra_slots, make_number (0));
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Swhitespace];
+ temp = AREF (Vsyntax_code_object, Swhitespace);
Vstandard_syntax_table = Fmake_char_table (Qsyntax_table, temp);
/* Control characters should not be whitespace. */
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Spunct];
+ temp = AREF (Vsyntax_code_object, Spunct);
for (i = 0; i <= ' ' - 1; i++)
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, 0177, temp);
/* Except that a few really are whitespace. */
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Swhitespace];
+ temp = AREF (Vsyntax_code_object, Swhitespace);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ' ', temp);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\t', temp);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\n', temp);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, 015, temp);
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, 014, temp);
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Sword];
+ temp = AREF (Vsyntax_code_object, Sword);
for (i = 'a'; i <= 'z'; i++)
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
for (i = 'A'; i <= 'Z'; i++)
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '}',
Fcons (make_number (Sclose), make_number ('{')));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '"',
- Fcons (make_number ((int) Sstring), Qnil));
+ Fcons (make_number (Sstring), Qnil));
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\\',
- Fcons (make_number ((int) Sescape), Qnil));
+ Fcons (make_number (Sescape), Qnil));
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Ssymbol];
+ temp = AREF (Vsyntax_code_object, Ssymbol);
for (i = 0; i < 10; i++)
{
c = "_-+*/&|<>="[i];
SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, c, temp);
}
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Spunct];
+ temp = AREF (Vsyntax_code_object, Spunct);
for (i = 0; i < 12; i++)
{
c = ".,;:?!#@~^'`"[i];
}
/* All multibyte characters have syntax `word' by default. */
- temp = XVECTOR (Vsyntax_code_object)->contents[(int) Sword];
+ temp = AREF (Vsyntax_code_object, Sword);
char_table_set_range (Vstandard_syntax_table, 0x80, MAX_CHAR, temp);
}
DEFSYM (Qscan_error, "scan-error");
Fput (Qscan_error, Qerror_conditions,
- pure_cons (Qscan_error, pure_cons (Qerror, Qnil)));
+ listn (CONSTYPE_PURE, 2, Qscan_error, Qerror));
Fput (Qscan_error, Qerror_message,
- make_pure_c_string ("Scan error"));
+ build_pure_c_string ("Scan error"));
DEFVAR_BOOL ("parse-sexp-ignore-comments", parse_sexp_ignore_comments,
doc: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);
DEFVAR_BOOL ("open-paren-in-column-0-is-defun-start",
open_paren_in_column_0_is_defun_start,
- doc: /* *Non-nil means an open paren in column 0 denotes the start of a defun. */);
+ doc: /* Non-nil means an open paren in column 0 denotes the start of a defun. */);
open_paren_in_column_0_is_defun_start = 1;