procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

* syntax.c: Integer cleanups.

Browse source 
(SYNTAX_FLAGS_COMMENT_STYLEC): Return a boolean, not 0-or-2.
All uses that need 0-or-2 changed to:
(SYNTAX_FLAGS_COMMENT_STYLEC2): New macro, with the same semantics
as the old SYNTAX_FLAGS_COMMENT_STYLEC.
(struct lisp_parse_state, syntax_prefix_flag_p, update_syntax_table)
(char_quoted, prev_char_comend_first, back_comment)
(Finternal_describe_syntax_value, skip_chars, skip_syntaxes)
(in_classes, forw_comment, scan_lists, scan_sexps_forward):
Use bool for boolean.
(update_syntax_table, skip_chars, skip_syntaxes):
Prefer int to unsigned when either will do.
(back_comment): Return boolean success flag, like forw_comment,
instead of positive-or-minus-1 (which might have overflowed int anyway).
Don't stuff ptrdiff_t into int.
(syntax_spec_code, syntax_code_spec): Now const.
(Fmatching_paren, scan_lists, scan_sexps_forward):
Use enum syntaxcode for syntax code.
(Fmatching_paren): Check that arg is a character, not just an integer.
(Fstring_to_syntax): Don't assume 0377 fits in enum syntaxcode.
(Finternal_describe_syntax_value): Omit no-longer-needed
comparison to 0.
(skip_chars): Use char, not unsigned char, when the distinction
doesn't matter.
(forw_comment, scan_lists): Prefer A |= B to A = A || B when B's cheap.
* bytecode.c (exec_byte_code):
* syntax.c (syntax_spec_code, Fchar_syntax)
(Finternal_describe_syntax_value, skip_chars, skip_syntaxes)
(init_syntax_once):
* syntax.h (SYNTAX_WITH_FLAGS):
Omit unnecessary casts.
This commit is contained in:
Paul Eggert 2013-06-20 11:59:08 -07:00
parent b932cad712
commit 1fc7100890
4 changed files with 208 additions and 201 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

34
src/ChangeLog
View file

@ -1,3 +1,37 @@
2013-06-20 Paul Eggert <eggert@cs.ucla.edu>
* syntax.c: Integer cleanups.
(SYNTAX_FLAGS_COMMENT_STYLEC): Return a boolean, not 0-or-2.
All uses that need 0-or-2 changed to:
(SYNTAX_FLAGS_COMMENT_STYLEC2): New macro, with the same semantics
as the old SYNTAX_FLAGS_COMMENT_STYLEC.
(struct lisp_parse_state, syntax_prefix_flag_p, update_syntax_table)
(char_quoted, prev_char_comend_first, back_comment)
(Finternal_describe_syntax_value, skip_chars, skip_syntaxes)
(in_classes, forw_comment, scan_lists, scan_sexps_forward):
Use bool for boolean.
(update_syntax_table, skip_chars, skip_syntaxes):
Prefer int to unsigned when either will do.
(back_comment): Return boolean success flag, like forw_comment,
instead of positive-or-minus-1 (which might have overflowed int anyway).
Don't stuff ptrdiff_t into int.
(syntax_spec_code, syntax_code_spec): Now const.
(Fmatching_paren, scan_lists, scan_sexps_forward):
Use enum syntaxcode for syntax code.
(Fmatching_paren): Check that arg is a character, not just an integer.
(Fstring_to_syntax): Don't assume 0377 fits in enum syntaxcode.
(Finternal_describe_syntax_value): Omit no-longer-needed
comparison to 0.
(skip_chars): Use char, not unsigned char, when the distinction
doesn't matter.
(forw_comment, scan_lists): Prefer A |= B to A = A || B when B's cheap.
* bytecode.c (exec_byte_code):
* syntax.c (syntax_spec_code, Fchar_syntax)
(Finternal_describe_syntax_value, skip_chars, skip_syntaxes)
(init_syntax_once):
* syntax.h (SYNTAX_WITH_FLAGS):
Omit unnecessary casts.
2013-06-20 Eli Zaretskii <eliz@gnu.org>
* w32fns.c (w32_wnd_proc): Don't compute the header line and mode

2
src/bytecode.c
View file

@ -1636,7 +1636,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
c = XFASTINT (TOP);
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
MAKE_CHAR_MULTIBYTE (c);
XSETFASTINT (TOP, syntax_code_spec[(int) SYNTAX (c)]);
XSETFASTINT (TOP, syntax_code_spec[SYNTAX (c)]);
}
NEXT;

351
src/syntax.c
View file

@ -36,7 +36,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "intervals.h"
#include "category.h"
/* Then there are seven single-bit flags that have the following meanings:
/* 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.
@ -48,16 +48,15 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
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
that holds the syntax code and the flags. */
@ -73,13 +72,14 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
#define SYNTAX_FLAGS_COMMENT_STYLEB(flags) (((flags) >> 21) & 1)
#define SYNTAX_FLAGS_COMMENT_STYLEC(flags) (((flags) >> 22) & 2)
#define SYNTAX_FLAGS_COMMENT_STYLEC(flags) (((flags) >> 23) & 1)
#define SYNTAX_FLAGS_COMMENT_STYLEC2(flags) (((flags) >> 22) & 2) /* C * 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))
| SYNTAX_FLAGS_COMMENT_STYLEC2 (flags) \
| SYNTAX_FLAGS_COMMENT_STYLEC2 (other_flags))
#define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
@ -114,7 +114,7 @@ struct lisp_parse_state
int instring; /* -1 if not within string, else desired terminator. */
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 */
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 */
ptrdiff_t thislevelstart;
@ -143,13 +143,13 @@ static ptrdiff_t find_start_begv;
static EMACS_INT find_start_modiff;
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 *,
ptrdiff_t, ptrdiff_t, ptrdiff_t, EMACS_INT,
int, Lisp_Object, int);
static int in_classes (int, Lisp_Object);
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
@ -159,7 +159,8 @@ bset_syntax_table (struct buffer *b, Lisp_Object val)
}
/* 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);
}
@ -183,12 +184,12 @@ struct gl_state_s gl_state; /* Global state of syntax parser. */
start/end of OBJECT. */
void
update_syntax_table (ptrdiff_t 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)
@ -340,16 +341,16 @@ update_syntax_table (ptrdiff_t charpos, EMACS_INT count, int init,
gl_state.b_property = gl_state.start;
}
/* 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
static bool
char_quoted (ptrdiff_t charpos, ptrdiff_t bytepos)
{
register enum syntaxcode code;
register ptrdiff_t beg = BEGV;
register int quoted = 0;
enum syntaxcode code;
ptrdiff_t beg = BEGV;
bool quoted = 0;
ptrdiff_t orig = charpos;
while (charpos > beg)
@ -466,10 +467,11 @@ find_defun_start (ptrdiff_t pos, ptrdiff_t pos_byte)
/* Return the SYNTAX_COMEND_FIRST of the character before POS, POS_BYTE. */
static int
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);
@ -479,28 +481,11 @@ prev_char_comend_first (ptrdiff_t pos, ptrdiff_t pos_byte)
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.
@ -508,8 +493,10 @@ prev_char_comend_first (ptrdiff_t pos, ptrdiff_t pos_byte)
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 (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, int comnested, int comstyle, ptrdiff_t *charpos_ptr, ptrdiff_t *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.
@ -521,13 +508,13 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, int comnested
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;
bool comment_lossage = 0;
ptrdiff_t comment_end = from;
ptrdiff_t comment_end_byte = from_byte;
ptrdiff_t comstart_pos = 0;
@ -536,8 +523,8 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, int comnested
or 0 if we didn't come across it yet. */
ptrdiff_t defun_start = 0;
ptrdiff_t defun_start_byte = 0;
register enum syntaxcode code;
int nesting = 1; /* current comment nesting */
enum syntaxcode code;
ptrdiff_t nesting = 1; /* current comment nesting */
int c;
int syntax = 0;
@ -550,8 +537,8 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, int comnested
while (from != stop)
{
ptrdiff_t temp_byte;
int prev_syntax, com2start, com2end;
int comstart;
int prev_syntax;
bool com2start, com2end, comstart;
/* Move back and examine a character. */
DEC_BOTH (from, from_byte);
@ -772,7 +759,7 @@ back_comment (ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t stop, int comnested
*charpos_ptr = from;
*bytepos_ptr = from_byte;
return (from == comment_end) ? -1 : from;
return from != comment_end;
}
DEFUN ("syntax-table-p", Fsyntax_table_p, Ssyntax_table_p, 1, 1, 0,
@ -854,31 +841,28 @@ One argument, a syntax table. */)
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', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@',
'!', '|'
@ -904,15 +888,16 @@ are listed in the documentation of `modify-syntax-entry'. */)
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);
@ -929,19 +914,18 @@ 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)
@ -956,7 +940,6 @@ the value of a `syntax-table' text property. */)
else
match = Qnil;
val = (int) code;
while (*p)
switch (*p++)
{
@ -1078,10 +1061,8 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
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;
@ -1113,7 +1094,7 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
}
syntax_code = XINT (first) & INT_MAX;
code = (enum syntaxcode) (syntax_code & 0377);
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);
@ -1123,14 +1104,13 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
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))
@ -1431,21 +1411,21 @@ This function returns the distance traveled, either zero or negative. */)
}
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 ptrdiff_t 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;
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;
@ -1489,7 +1469,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
if (! string_multibyte)
{
int string_has_eight_bit = 0;
bool string_has_eight_bit = 0;
/* At first setup fastmap. */
while (i_byte < size_byte)
@ -1544,7 +1524,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
if (i_byte + 1 < size_byte
&& str[i_byte] == '-')
{
unsigned int c2;
int c2;
/* Skip over the dash. */
i_byte++;
@ -1557,7 +1537,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
if (c <= c2)
{
unsigned lim2 = c2 + 1;
int lim2 = c2 + 1;
while (c < lim2)
fastmap[c++] = 1;
if (! ASCII_CHAR_P (c2))
@ -1610,9 +1590,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
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;
@ -1666,8 +1644,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
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++;
@ -1681,7 +1658,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
&& 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;
}
@ -1695,7 +1672,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
}
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)
@ -1728,7 +1705,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
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++)
{
@ -1924,13 +1901,13 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
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 ptrdiff_t i, i_byte;
int multibyte;
bool negate = 0;
ptrdiff_t i, i_byte;
bool multibyte;
ptrdiff_t size_byte;
unsigned char *str;
@ -2018,7 +1995,7 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
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);
@ -2035,7 +2012,7 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
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);
@ -2061,7 +2038,7 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
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;
}
@ -2078,7 +2055,7 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
stop = endp;
}
UPDATE_SYNTAX_TABLE_BACKWARD (pos - 1);
if (! fastmap[(int) SYNTAX (p[-1])])
if (! fastmap[SYNTAX (p[-1])])
break;
p--, pos--, pos_byte--;
}
@ -2092,14 +2069,14 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
}
}
/* 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))
{
@ -2119,26 +2096,26 @@ in_classes (int c, Lisp_Object 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
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,
@ -2244,14 +2221,12 @@ If COUNT comments are found as expected, with nothing except whitespace
between them, return t; otherwise return nil. */)
(Lisp_Object count)
{
register ptrdiff_t from;
ptrdiff_t from_byte;
register ptrdiff_t 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;
ptrdiff_t out_charpos, out_bytepos;
EMACS_INT dummy;
@ -2271,7 +2246,8 @@ between them, return t; otherwise return nil. */)
{
do
{
int comstart_first, syntax, other_syntax;
bool comstart_first;
int syntax, other_syntax;
if (from == stop)
{
@ -2299,8 +2275,7 @@ between them, return t; otherwise return nil. */)
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);
}
@ -2336,7 +2311,8 @@ between them, return t; otherwise return nil. */)
{
while (1)
{
int quoted, syntax;
bool quoted;
int syntax;
if (from <= stop)
{
@ -2370,14 +2346,13 @@ between them, return t; otherwise return nil. */)
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;
bool fence_found = 0;
ptrdiff_t ini = from, ini_byte = from_byte;
while (1)
@ -2408,7 +2383,7 @@ between them, return t; otherwise return nil. */)
{
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.
@ -2458,26 +2433,25 @@ between them, return t; otherwise return nil. */)
? 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 ptrdiff_t 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;
bool quoted;
bool mathexit = 0;
enum syntaxcode code, temp_code, c_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 */
bool comnested = 0; /* whether the comment is nestable or not */
ptrdiff_t temp_pos;
EMACS_INT last_good = from;
int found;
bool found;
ptrdiff_t from_byte;
ptrdiff_t out_bytepos, out_charpos;
int temp;
EMACS_INT dummy;
int multibyte_symbol_p = sexpflag && multibyte_syntax_as_symbol;
bool multibyte_symbol_p = sexpflag && multibyte_syntax_as_symbol;
if (depth > 0) min_depth = 0;
@ -2494,7 +2468,8 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
{
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);
@ -2520,8 +2495,7 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
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);
}
@ -2547,8 +2521,8 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
/* Some compilers can't handle this inside the switch. */
c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
temp = SYNTAX_WITH_MULTIBYTE_CHECK (c);
switch (temp)
c_code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
switch (c_code)
{
case Scharquote:
case Sescape:
@ -2631,8 +2605,8 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
break;
/* Some compilers can't handle this inside the switch. */
temp = SYNTAX_WITH_MULTIBYTE_CHECK (c);
switch (temp)
c_code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
switch (c_code)
{
case Scharquote:
case Sescape:
@ -2691,8 +2665,7 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
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
@ -2777,13 +2750,13 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
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;
@ -2938,7 +2911,7 @@ This includes chars with "quote" or "prefix" syntax (' or p). */)
/* 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. */
@ -2946,30 +2919,29 @@ This includes chars with "quote" or "prefix" syntax (' or p). */)
static void
scan_sexps_forward (struct lisp_parse_state *stateptr,
ptrdiff_t from, ptrdiff_t from_byte, ptrdiff_t end,
EMACS_INT targetdepth, int stopbefore,
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;
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 EMACS_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. */
EMACS_INT mindepth; /* Lowest DEPTH value seen. */
int start_quoted = 0; /* Nonzero means starting after a char quote */
bool start_quoted = 0; /* True means starting after a char quote. */
Lisp_Object tem;
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;
bool boundary_stop = commentstop == -1;
bool nofence;
bool found;
ptrdiff_t out_bytepos, out_charpos;
int temp;
@ -3100,8 +3072,8 @@ do { prev_from = from; \
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;
@ -3146,9 +3118,9 @@ do { prev_from = from; \
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);
enum syntaxcode symcharcode = SYNTAX (symchar);
switch (symcharcode)
{
case Scharquote:
case Sescape:
@ -3230,19 +3202,20 @@ do { prev_from = from; \
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;
@ -3398,25 +3371,25 @@ init_syntax_once (void)
create syntax tables. */
Fput (Qsyntax_table, Qchar_table_extra_slots, make_number (0));
temp = AREF (Vsyntax_code_object, (int) Swhitespace);
temp = AREF (Vsyntax_code_object, Swhitespace);
Vstandard_syntax_table = Fmake_char_table (Qsyntax_table, temp);
/* Control characters should not be whitespace. */
temp = AREF (Vsyntax_code_object, (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 = AREF (Vsyntax_code_object, (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 = AREF (Vsyntax_code_object, (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++)
@ -3440,18 +3413,18 @@ init_syntax_once (void)
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 = AREF (Vsyntax_code_object, (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 = AREF (Vsyntax_code_object, (int) Spunct);
temp = AREF (Vsyntax_code_object, Spunct);
for (i = 0; i < 12; i++)
{
c = ".,;:?!#@~^'`"[i];
@ -3459,7 +3432,7 @@ init_syntax_once (void)
}
/* All multibyte characters have syntax `word' by default. */
temp = AREF (Vsyntax_code_object, (int) Sword);
temp = AREF (Vsyntax_code_object, Sword);
char_table_set_range (Vstandard_syntax_table, 0x80, MAX_CHAR, temp);
}

22
src/syntax.h
View file

@ -19,7 +19,7 @@ You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
extern void update_syntax_table (ptrdiff_t, EMACS_INT, int, Lisp_Object);
extern void update_syntax_table (ptrdiff_t, EMACS_INT, bool, Lisp_Object);
/* The standard syntax table is stored where it will automatically
be used in all new buffers. */
@ -99,7 +99,7 @@ enum syntaxcode
_syntax_temp = SYNTAX_ENTRY (c); \
(CONSP (_syntax_temp) \
? XINT (XCAR (_syntax_temp)) \
: (int) Swhitespace); })
: Swhitespace); })
#define SYNTAX_MATCH(c) \
({ Lisp_Object _syntax_temp; \
@ -112,14 +112,14 @@ extern Lisp_Object syntax_temp;
#define SYNTAX(c) \
(syntax_temp = SYNTAX_ENTRY ((c)), \
(CONSP (syntax_temp) \
? (enum syntaxcode) (XINT (XCAR (syntax_temp)) & 0xff) \
? (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)) \
: (int) Swhitespace))
? XINT (XCAR (syntax_temp)) \
: Swhitespace))
#define SYNTAX_MATCH(c) \
(syntax_temp = SYNTAX_ENTRY ((c)), \
@ -130,17 +130,17 @@ extern Lisp_Object syntax_temp;
/* Whether the syntax of the character C has the prefix flag set. */
extern int syntax_prefix_flag_p (int c);
extern bool syntax_prefix_flag_p (int c);
/* This array, indexed by a character, contains the syntax code which that
character signifies (as a char). For example,
(enum syntaxcode) syntax_spec_code['w'] is Sword. */
/* This array, indexed by a character less than 256, contains the
syntax code which that character signifies (as an unsigned char).
For example, syntax_spec_code['w'] == Sword. */
extern unsigned char syntax_spec_code[0400];
extern unsigned char const syntax_spec_code[0400];
/* Indexed by syntax code, give the letter that describes it. */
extern char syntax_code_spec[16];
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.