#define ISWORD(c) (SYNTAX (c) == Sword)
\f
-#define SIGN_EXTEND_CHAR(c) ((signed char) (c))
-\f
/* Use alloca instead of malloc. This is because using malloc in
re_search* or re_match* could cause memory leaks when C-g is used
in Emacs (note that SAFE_ALLOCA could also call malloc, but does so
#define FIRST_STRING_P(ptr) \
(size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
-/* (Re)Allocate N items of type T using malloc, or fail. */
-#define TALLOC(n, t) ((t *) xmalloc ((n) * sizeof (t)))
-#define RETALLOC(addr, n, t) ((addr) = (t *) xrealloc (addr, (n) * sizeof (t)))
-
#define BYTEWIDTH 8 /* In bits. */
/* Type of source-pattern and string chars. */
static void re_compile_fastmap (struct re_pattern_buffer *);
static ptrdiff_t re_match_2_internal (struct re_pattern_buffer *bufp,
- re_char *string1, size_t size1,
- re_char *string2, size_t size2,
+ re_char *string1, ptrdiff_t size1,
+ re_char *string2, ptrdiff_t size2,
ptrdiff_t pos,
struct re_registers *regs,
ptrdiff_t stop);
static int
extract_number (re_char *source)
{
- unsigned leading_byte = SIGN_EXTEND_CHAR (source[1]);
- return (leading_byte << 8) + source[0];
+ signed char leading_byte = source[1];
+ return leading_byte * 256 + source[0];
}
/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
#define CHARSET_BITMAP_SIZE(p) ((p)[1] & 0x7F)
/* Nonzero if charset P has range table. */
-#define CHARSET_RANGE_TABLE_EXISTS_P(p) ((p)[1] & 0x80)
+#define CHARSET_RANGE_TABLE_EXISTS_P(p) (((p)[1] & 0x80) != 0)
/* Return the address of range table of charset P. But not the start
of table itself, but the before where the number of ranges is
static void
print_fastmap (char *fastmap)
{
- unsigned was_a_range = 0;
- unsigned i = 0;
+ bool was_a_range = false;
+ int i = 0;
while (i < (1 << BYTEWIDTH))
{
if (fastmap[i++])
{
- was_a_range = 0;
+ was_a_range = false;
putchar (i - 1);
while (i < (1 << BYTEWIDTH) && fastmap[i])
{
- was_a_range = 1;
+ was_a_range = true;
i++;
}
if (was_a_range)
case charset:
case charset_not:
{
- register int c, last = -100;
- register int in_range = 0;
+ int c, last = -100;
+ bool in_range = false;
int length = CHARSET_BITMAP_SIZE (p - 1);
- int has_range_table = CHARSET_RANGE_TABLE_EXISTS_P (p - 1);
+ bool has_range_table = CHARSET_RANGE_TABLE_EXISTS_P (p - 1);
fprintf (stderr, "/charset [%s",
(re_opcode_t) *(p - 1) == charset_not ? "^" : "");
if (last + 1 == c && ! in_range)
{
fprintf (stderr, "-");
- in_range = 1;
+ in_range = true;
}
/* Have we broken a range? */
else if (last + 1 != c && in_range)
{
fprintf (stderr, "%c", last);
- in_range = 0;
+ in_range = false;
}
if (! in_range)
re_char *buffer = bufp->buffer;
print_partial_compiled_pattern (buffer, buffer + bufp->used);
- printf ("%zu bytes used/%zu bytes allocated.\n",
+ printf ("%tu bytes used/%tu bytes allocated.\n",
bufp->used, bufp->allocated);
if (bufp->fastmap_accurate && bufp->fastmap)
print_fastmap (bufp->fastmap);
}
- printf ("re_nsub: %zu\t", bufp->re_nsub);
+ printf ("re_nsub: %tu\t", bufp->re_nsub);
printf ("regs_alloc: %d\t", bufp->regs_allocated);
printf ("can_be_null: %d\t", bufp->can_be_null);
fflush (stdout);
static void
-print_double_string (re_char *where, re_char *string1, ssize_t size1,
- re_char *string2, ssize_t size2)
+print_double_string (re_char *where, re_char *string1, ptrdiff_t size1,
+ re_char *string2, ptrdiff_t size2)
{
- ssize_t this_char;
-
if (where == NULL)
printf ("(null)");
else
{
if (FIRST_STRING_P (where))
{
- for (this_char = where - string1; this_char < size1; this_char++)
- putchar (string1[this_char]);
-
+ fwrite_unlocked (where, 1, string1 + size1 - where, stdout);
where = string2;
}
- for (this_char = where - string2; this_char < size2; this_char++)
- putchar (string2[this_char]);
+ fwrite_unlocked (where, 1, string2 + size2 - where, stdout);
}
}
whose default stack limit is 2mb. In order for a larger
value to work reliably, you have to try to make it accord
with the process stack limit. */
-size_t emacs_re_max_failures = 40000;
+ptrdiff_t emacs_re_max_failures = 40000;
union fail_stack_elt
{
re_char *pointer;
- /* This should be the biggest 'int' that's no bigger than a pointer. */
- long integer;
+ intptr_t integer;
};
typedef union fail_stack_elt fail_stack_elt_t;
typedef struct
{
fail_stack_elt_t *stack;
- size_t size;
- size_t avail; /* Offset of next open position. */
- size_t frame; /* Offset of the cur constructed frame. */
+ ptrdiff_t size;
+ ptrdiff_t avail; /* Offset of next open position. */
+ ptrdiff_t frame; /* Offset of the cur constructed frame. */
} fail_stack_type;
#define FAIL_STACK_EMPTY() (fail_stack.frame == 0)
while (REMAINING_AVAIL_SLOTS <= space) { \
if (!GROW_FAIL_STACK (fail_stack)) \
return -2; \
- DEBUG_PRINT ("\n Doubled stack; size now: %zu\n", (fail_stack).size);\
- DEBUG_PRINT (" slots available: %zu\n", REMAINING_AVAIL_SLOTS);\
+ DEBUG_PRINT ("\n Doubled stack; size now: %tu\n", fail_stack.size); \
+ DEBUG_PRINT (" slots available: %tu\n", REMAINING_AVAIL_SLOTS);\
}
/* Push register NUM onto the stack. */
#define PUSH_FAILURE_REG(num) \
do { \
char *destination; \
- long n = num; \
+ intptr_t n = num; \
ENSURE_FAIL_STACK(3); \
- DEBUG_PRINT (" Push reg %ld (spanning %p -> %p)\n", \
+ DEBUG_PRINT (" Push reg %"PRIdPTR" (spanning %p -> %p)\n", \
n, regstart[n], regend[n]); \
PUSH_FAILURE_POINTER (regstart[n]); \
PUSH_FAILURE_POINTER (regend[n]); \
/* Pop a saved register off the stack. */
#define POP_FAILURE_REG_OR_COUNT() \
do { \
- long pfreg = POP_FAILURE_INT (); \
+ intptr_t pfreg = POP_FAILURE_INT (); \
if (pfreg == -1) \
{ \
/* It's a counter. */ \
unsigned char *ptr = (unsigned char *) POP_FAILURE_POINTER (); \
pfreg = POP_FAILURE_INT (); \
STORE_NUMBER (ptr, pfreg); \
- DEBUG_PRINT (" Pop counter %p = %ld\n", ptr, pfreg); \
+ DEBUG_PRINT (" Pop counter %p = %"PRIdPTR"\n", ptr, pfreg); \
} \
else \
{ \
&& FAILURE_PAT (failure) <= bufp->buffer + bufp->used); \
if (FAILURE_PAT (failure) == pat_cur) \
{ \
- cycle = 1; \
+ cycle = true; \
break; \
} \
DEBUG_PRINT (" Other pattern: %p\n", FAILURE_PAT (failure)); \
char *destination; \
DEBUG_STATEMENT (nfailure_points_pushed++); \
DEBUG_PRINT ("\nPUSH_FAILURE_POINT:\n"); \
- DEBUG_PRINT (" Before push, next avail: %zu\n", (fail_stack).avail); \
- DEBUG_PRINT (" size: %zu\n", (fail_stack).size);\
+ DEBUG_PRINT (" Before push, next avail: %tu\n", fail_stack.avail); \
+ DEBUG_PRINT (" size: %tu\n", fail_stack.size); \
\
ENSURE_FAIL_STACK (NUM_NONREG_ITEMS); \
\
DEBUG_PRINT ("\n"); \
\
- DEBUG_PRINT (" Push frame index: %zu\n", fail_stack.frame); \
+ DEBUG_PRINT (" Push frame index: %tu\n", fail_stack.frame); \
PUSH_FAILURE_INT (fail_stack.frame); \
\
DEBUG_PRINT (" Push string %p: \"", string_place); \
\
/* Remove failure points and point to how many regs pushed. */ \
DEBUG_PRINT ("POP_FAILURE_POINT:\n"); \
- DEBUG_PRINT (" Before pop, next avail: %zu\n", fail_stack.avail); \
- DEBUG_PRINT (" size: %zu\n", fail_stack.size); \
+ DEBUG_PRINT (" Before pop, next avail: %tu\n", fail_stack.avail); \
+ DEBUG_PRINT (" size: %tu\n", fail_stack.size); \
\
/* Pop the saved registers. */ \
while (fail_stack.frame < fail_stack.avail) \
\f
/* Subroutine declarations and macros for regex_compile. */
-static reg_errcode_t regex_compile (re_char *pattern, size_t size,
+static reg_errcode_t regex_compile (re_char *pattern, ptrdiff_t size,
bool posix_backtracking,
const char *whitespace_regexp,
struct re_pattern_buffer *bufp);
static bool at_endline_loc_p (re_char *p, re_char *pend);
static re_char *skip_one_char (re_char *p);
static int analyze_first (re_char *p, re_char *pend,
- char *fastmap, const int multibyte);
+ char *fastmap, bool multibyte);
/* Fetch the next character in the uncompiled pattern, with no
translation. */
/* Ensure at least N more bytes of space in buffer. */
#define GET_BUFFER_SPACE(n) \
- while ((size_t) (b - bufp->buffer + (n)) > bufp->allocated) \
- EXTEND_BUFFER ()
+ if (bufp->buffer + bufp->allocated - b < (n)) \
+ EXTEND_BUFFER ((n) - (bufp->buffer + bufp->allocated - b))
/* Ensure one more byte of buffer space and then add C to it. */
#define BUF_PUSH(c) \
be too small, many things would have to change. */
# define MAX_BUF_SIZE (1 << 15)
-/* Extend the buffer by twice its current size via realloc and
+/* Extend the buffer by at least N bytes via realloc and
reset the pointers that pointed into the old block to point to the
correct places in the new one. If extending the buffer results in it
being larger than MAX_BUF_SIZE, then flag memory exhausted. */
-#define EXTEND_BUFFER() \
+#define EXTEND_BUFFER(n) \
do { \
+ ptrdiff_t requested_extension = n; \
unsigned char *old_buffer = bufp->buffer; \
- if (bufp->allocated == MAX_BUF_SIZE) \
+ if (MAX_BUF_SIZE - bufp->allocated < requested_extension) \
return REG_ESIZE; \
- bufp->allocated <<= 1; \
- if (bufp->allocated > MAX_BUF_SIZE) \
- bufp->allocated = MAX_BUF_SIZE; \
ptrdiff_t b_off = b - old_buffer; \
ptrdiff_t begalt_off = begalt - old_buffer; \
bool fixup_alt_jump_set = !!fixup_alt_jump; \
if (fixup_alt_jump_set) fixup_alt_jump_off = fixup_alt_jump - old_buffer; \
if (laststart_set) laststart_off = laststart - old_buffer; \
if (pending_exact_set) pending_exact_off = pending_exact - old_buffer; \
- RETALLOC (bufp->buffer, bufp->allocated, unsigned char); \
+ bufp->buffer = xpalloc (bufp->buffer, &bufp->allocated, \
+ requested_extension, MAX_BUF_SIZE, 1); \
unsigned char *new_buffer = bufp->buffer; \
b = new_buffer + b_off; \
begalt = new_buffer + begalt_off; \
/* Macros for the compile stack. */
-/* Since offsets can go either forwards or backwards, this type needs to
- be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1. */
typedef long pattern_offset_t;
+verify (LONG_MIN <= -(MAX_BUF_SIZE - 1) && MAX_BUF_SIZE - 1 <= LONG_MAX);
typedef struct
{
typedef struct
{
compile_stack_elt_t *stack;
- size_t size;
- size_t avail; /* Offset of next open position. */
+ ptrdiff_t size;
+ ptrdiff_t avail; /* Offset of next open position. */
} compile_stack_type;
The function can be used on ASCII and multibyte (UTF-8-encoded) strings.
*/
re_wctype_t
-re_wctype_parse (const unsigned char **strp, unsigned limit)
+re_wctype_parse (const unsigned char **strp, ptrdiff_t limit)
{
const char *beg = (const char *)*strp, *it;
'buffer' is the compiled pattern;
'syntax' is set to SYNTAX;
'used' is set to the length of the compiled pattern;
- 'fastmap_accurate' is zero;
+ 'fastmap_accurate' is false;
're_nsub' is the number of subexpressions in PATTERN;
The 'fastmap' field is neither examined nor set. */
static reg_errcode_t
-regex_compile (re_char *pattern, size_t size,
+regex_compile (re_char *pattern, ptrdiff_t size,
bool posix_backtracking,
const char *whitespace_regexp,
struct re_pattern_buffer *bufp)
DEBUG_PRINT ("\nCompiling pattern: ");
if (regex_emacs_debug > 0)
{
- size_t debug_count;
-
- for (debug_count = 0; debug_count < size; debug_count++)
+ for (ptrdiff_t debug_count = 0; debug_count < size; debug_count++)
putchar (pattern[debug_count]);
putchar ('\n');
}
#endif
/* Initialize the compile stack. */
- compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
+ compile_stack.stack = xmalloc (INIT_COMPILE_STACK_SIZE
+ * sizeof *compile_stack.stack);
compile_stack.size = INIT_COMPILE_STACK_SIZE;
compile_stack.avail = 0;
range_table_work.allocated = 0;
/* Initialize the pattern buffer. */
- bufp->fastmap_accurate = 0;
- bufp->used_syntax = 0;
+ bufp->fastmap_accurate = false;
+ bufp->used_syntax = false;
/* Set 'used' to zero, so that if we return an error, the pattern
printer (for debugging) will think there's no pattern. We reset it
if (bufp->allocated == 0)
{
- if (bufp->buffer)
- { /* If zero allocated, but buffer is non-null, try to realloc
- enough space. This loses if buffer's address is bogus, but
- that is the user's responsibility. */
- RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char);
- }
- else
- { /* Caller did not allocate a buffer. Do it for them. */
- bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char);
- }
+ /* This loses if BUFP->buffer is bogus, but that is the user's
+ responsibility. */
+ bufp->buffer = xrealloc (bufp->buffer, INIT_BUF_SIZE);
bufp->allocated = INIT_BUF_SIZE;
}
if (many_times_ok)
{
bool simple = skip_one_char (laststart) == b;
- size_t startoffset = 0;
+ ptrdiff_t startoffset = 0;
re_opcode_t ofj =
/* Check if the loop can match the empty string. */
- (simple || !analyze_first (laststart, b, NULL, 0))
+ (simple || !analyze_first (laststart, b, NULL, false))
? on_failure_jump : on_failure_jump_loop;
eassert (skip_one_char (laststart) <= b);
GET_BUFFER_SPACE (7); /* We might use less. */
if (many_times_ok)
{
- bool emptyp = analyze_first (laststart, b, NULL, 0);
+ bool emptyp = !!analyze_first (laststart, b, NULL, false);
/* The non-greedy multiple match looks like
a repeat..until: we only need a conditional jump
content of the syntax-table is not hardcoded in the
range_table. SPACE and WORD are the two exceptions. */
if ((1 << cc) & ((1 << RECC_SPACE) | (1 << RECC_WORD)))
- bufp->used_syntax = 1;
+ bufp->used_syntax = true;
/* Repeat the loop. */
continue;
{
case '(':
{
- int shy = 0;
+ bool shy = false;
regnum_t regnum = 0;
if (p+1 < pend)
{
PATFETCH (c);
switch (c)
{
- case ':': shy = 1; break;
+ case ':': shy = true; break;
case '0':
/* An explicitly specified regnum must start
with non-0. */
FALLTHROUGH;
case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
- regnum = 10*regnum + (c - '0'); break;
+ if (INT_MULTIPLY_WRAPV (regnum, 10, ®num)
+ || INT_ADD_WRAPV (regnum, c - '0',
+ ®num))
+ FREE_STACK_RETURN (REG_ESIZE);
+ break;
default:
/* Only (?:...) is supported right now. */
FREE_STACK_RETURN (REG_BADPAT);
regnum = ++bufp->re_nsub;
else if (regnum)
{ /* It's actually not shy, but explicitly numbered. */
- shy = 0;
+ shy = false;
if (regnum > bufp->re_nsub)
bufp->re_nsub = regnum;
else if (regnum > bufp->re_nsub
regnum = - bufp->re_nsub;
if (COMPILE_STACK_FULL)
- {
- RETALLOC (compile_stack.stack, compile_stack.size << 1,
- compile_stack_elt_t);
- compile_stack.size <<= 1;
- }
+ compile_stack.stack
+ = xpalloc (compile_stack.stack, &compile_stack.size,
+ 1, -1, sizeof *compile_stack.stack);
/* These are the values to restore when we hit end of this
group. They are all relative offsets, so that if the
else
{ /* If the upper bound is > 1, we need to insert
more at the end of the loop. */
- unsigned int nbytes = (upper_bound < 0 ? 3
- : upper_bound > 1 ? 5 : 0);
- unsigned int startoffset = 0;
+ int nbytes = upper_bound < 0 ? 3 : upper_bound > 1 ? 5 : 0;
+ int startoffset = 0;
GET_BUFFER_SPACE (20); /* We might use less. */
Return -1 if fastmap was not updated accurately. */
static int
-analyze_first (re_char *p, re_char *pend, char *fastmap,
- const int multibyte)
+analyze_first (re_char *p, re_char *pend, char *fastmap, bool multibyte)
{
int j, k;
bool not;
eassert (fastmap && bufp->buffer);
memset (fastmap, 0, 1 << BYTEWIDTH); /* Assume nothing's valid. */
+
+ /* FIXME: Is the following assignment correct even when ANALYSIS < 0? */
bufp->fastmap_accurate = 1; /* It will be when we're done. */
analysis = analyze_first (bufp->buffer, bufp->buffer + bufp->used,
void
re_set_registers (struct re_pattern_buffer *bufp, struct re_registers *regs,
- unsigned int num_regs, ptrdiff_t *starts, ptrdiff_t *ends)
+ ptrdiff_t num_regs, ptrdiff_t *starts, ptrdiff_t *ends)
{
if (num_regs)
{
doesn't let you say where to stop matching. */
ptrdiff_t
-re_search (struct re_pattern_buffer *bufp, const char *string, size_t size,
+re_search (struct re_pattern_buffer *bufp, const char *string, ptrdiff_t size,
ptrdiff_t startpos, ptrdiff_t range, struct re_registers *regs)
{
return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
stack overflow). */
ptrdiff_t
-re_search_2 (struct re_pattern_buffer *bufp, const char *str1, size_t size1,
- const char *str2, size_t size2,
+re_search_2 (struct re_pattern_buffer *bufp, const char *str1, ptrdiff_t size1,
+ const char *str2, ptrdiff_t size2,
ptrdiff_t startpos, ptrdiff_t range,
struct re_registers *regs, ptrdiff_t stop)
{
re_char *string2 = (re_char *) str2;
char *fastmap = bufp->fastmap;
Lisp_Object translate = bufp->translate;
- size_t total_size = size1 + size2;
+ ptrdiff_t total_size = size1 + size2;
ptrdiff_t endpos = startpos + range;
bool anchored_start;
/* Nonzero if we are searching multibyte string. */
\f
/* Declarations and macros for re_match_2. */
-static int bcmp_translate (re_char *s1, re_char *s2,
- ptrdiff_t len,
- Lisp_Object translate,
- const int multibyte);
+static bool bcmp_translate (re_char *, re_char *, ptrdiff_t,
+ Lisp_Object, bool);
/* This converts PTR, a pointer into one of the search strings 'string1'
and 'string2' into an offset from the beginning of that string. */
character (i.e. without any translations). UNIBYTE denotes whether c is
unibyte or multibyte character. */
static bool
-execute_charset (re_char **pp, unsigned c, unsigned corig, bool unibyte)
+execute_charset (re_char **pp, int c, int corig, bool unibyte)
{
+ eassume (0 <= c && 0 <= corig);
re_char *p = *pp, *rtp = NULL;
bool not = (re_opcode_t) *p == charset_not;
return not;
}
-/* Non-zero if "p1 matches something" implies "p2 fails". */
-static int
+/* True if "p1 matches something" implies "p2 fails". */
+static bool
mutually_exclusive_p (struct re_pattern_buffer *bufp, re_char *p1,
re_char *p2)
{
if (skip_one_char (p1))
{
DEBUG_PRINT (" End of pattern: fast loop.\n");
- return 1;
+ return true;
}
break;
if (c != RE_STRING_CHAR (p1 + 2, multibyte))
{
DEBUG_PRINT (" '%c' != '%c' => fast loop.\n", c, p1[2]);
- return 1;
+ return true;
}
}
if (!execute_charset (&p1, c, c, !multibyte || ASCII_CHAR_P (c)))
{
DEBUG_PRINT (" No match => fast loop.\n");
- return 1;
+ return true;
}
}
else if ((re_opcode_t) *p1 == anychar
&& c == '\n')
{
DEBUG_PRINT (" . != \\n => fast loop.\n");
- return 1;
+ return true;
}
}
break;
|| idx == CHARSET_BITMAP_SIZE (p1))
{
DEBUG_PRINT (" No match => fast loop.\n");
- return 1;
+ return true;
}
}
else if ((re_opcode_t) *p1 == charset_not)
if (idx == p2[1])
{
DEBUG_PRINT (" No match => fast loop.\n");
- return 1;
+ return true;
}
}
}
}
/* Safe default. */
- return 0;
+ return false;
}
\f
matched substring. */
ptrdiff_t
-re_match_2 (struct re_pattern_buffer *bufp, const char *string1,
- size_t size1, const char *string2, size_t size2, ptrdiff_t pos,
- struct re_registers *regs, ptrdiff_t stop)
+re_match_2 (struct re_pattern_buffer *bufp,
+ char const *string1, ptrdiff_t size1,
+ char const *string2, ptrdiff_t size2,
+ ptrdiff_t pos, struct re_registers *regs, ptrdiff_t stop)
{
ptrdiff_t result;
/* This is a separate function so that we can force an alloca cleanup
afterwards. */
static ptrdiff_t
-re_match_2_internal (struct re_pattern_buffer *bufp, re_char *string1,
- size_t size1, re_char *string2, size_t size2,
+re_match_2_internal (struct re_pattern_buffer *bufp,
+ re_char *string1, ptrdiff_t size1,
+ re_char *string2, ptrdiff_t size2,
ptrdiff_t pos, struct re_registers *regs, ptrdiff_t stop)
{
/* General temporaries. */
int mcnt;
- size_t reg;
/* Just past the end of the corresponding string. */
re_char *end1, *end2;
scanning the strings. */
fail_stack_type fail_stack;
#ifdef DEBUG_COMPILES_ARGUMENTS
- unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
+ ptrdiff_t nfailure_points_pushed = 0, nfailure_points_popped = 0;
#endif
/* We fill all the registers internally, independent of what we
return, for use in backreferences. The number here includes
an element for register zero. */
- size_t num_regs = bufp->re_nsub + 1;
+ ptrdiff_t num_regs = bufp->re_nsub + 1;
+ eassume (0 < num_regs);
/* Information on the contents of registers. These are pointers into
the input strings; they record just what was matched (on this
variables when we find a match better than any we've seen before.
This happens as we backtrack through the failure points, which in
turn happens only if we have not yet matched the entire string. */
- unsigned best_regs_set = false;
+ bool best_regs_set = false;
re_char **best_regstart UNINIT, **best_regend UNINIT;
/* Logically, this is 'best_regend[0]'. But we don't want to have to
#ifdef DEBUG_COMPILES_ARGUMENTS
/* Counts the total number of registers pushed. */
- unsigned num_regs_pushed = 0;
+ ptrdiff_t num_regs_pushed = 0;
#endif
DEBUG_PRINT ("\n\nEntering re_match_2.\n");
/* Initialize subexpression text positions to -1 to mark ones that no
start_memory/stop_memory has been seen for. Also initialize the
register information struct. */
- for (reg = 1; reg < num_regs; reg++)
+ for (ptrdiff_t reg = 1; reg < num_regs; reg++)
regstart[reg] = regend[reg] = NULL;
/* We move 'string1' into 'string2' if the latter's empty -- but not if
DEBUG_PRINT ("\nSAVING match as best so far.\n");
- for (reg = 1; reg < num_regs; reg++)
+ for (ptrdiff_t reg = 1; reg < num_regs; reg++)
{
best_regstart[reg] = regstart[reg];
best_regend[reg] = regend[reg];
dend = ((d >= string1 && d <= end1)
? end_match_1 : end_match_2);
- for (reg = 1; reg < num_regs; reg++)
+ for (ptrdiff_t reg = 1; reg < num_regs; reg++)
{
regstart[reg] = best_regstart[reg];
regend[reg] = best_regend[reg];
{ /* No. So allocate them with malloc. We need one
extra element beyond 'num_regs' for the '-1' marker
GNU code uses. */
- regs->num_regs = max (RE_NREGS, num_regs + 1);
- regs->start = TALLOC (regs->num_regs, ptrdiff_t);
- regs->end = TALLOC (regs->num_regs, ptrdiff_t);
+ ptrdiff_t n = max (RE_NREGS, num_regs + 1);
+ regs->start = xnmalloc (n, sizeof *regs->start);
+ regs->end = xnmalloc (n, sizeof *regs->end);
+ regs->num_regs = n;
bufp->regs_allocated = REGS_REALLOCATE;
}
else if (bufp->regs_allocated == REGS_REALLOCATE)
leave it alone. */
if (regs->num_regs < num_regs + 1)
{
- regs->num_regs = num_regs + 1;
- RETALLOC (regs->start, regs->num_regs, ptrdiff_t);
- RETALLOC (regs->end, regs->num_regs, ptrdiff_t);
+ ptrdiff_t n = num_regs + 1;
+ regs->start
+ = xnrealloc (regs->start, n, sizeof *regs->start);
+ regs->end = xnrealloc (regs->end, n, sizeof *regs->end);
+ regs->num_regs = n;
}
}
else
regs->end[0] = POINTER_TO_OFFSET (d);
}
- /* Go through the first 'min (num_regs, regs->num_regs)'
- registers, since that is all we initialized. */
- for (reg = 1; reg < min (num_regs, regs->num_regs); reg++)
+ for (ptrdiff_t reg = 1; reg < num_regs; reg++)
{
if (REG_UNSET (regstart[reg]) || REG_UNSET (regend[reg]))
regs->start[reg] = regs->end[reg] = -1;
we (re)allocated the registers, this is the case,
because we always allocate enough to have at least one
-1 at the end. */
- for (reg = num_regs; reg < regs->num_regs; reg++)
+ for (ptrdiff_t reg = num_regs; reg < regs->num_regs; reg++)
regs->start[reg] = regs->end[reg] = -1;
}
- DEBUG_PRINT ("%u failure points pushed, %u popped (%u remain).\n",
+ DEBUG_PRINT ("%td failure points pushed, %td popped (%td remain).\n",
nfailure_points_pushed, nfailure_points_popped,
nfailure_points_pushed - nfailure_points_popped);
- DEBUG_PRINT ("%u registers pushed.\n", num_regs_pushed);
+ DEBUG_PRINT ("%td registers pushed.\n", num_regs_pushed);
ptrdiff_t dcnt = POINTER_TO_OFFSET (d) - pos;
case charset:
case charset_not:
{
- register unsigned int c, corig;
- int len;
-
/* Whether matching against a unibyte character. */
bool unibyte_char = false;
(re_opcode_t) *(p - 1) == charset_not ? "_not" : "");
PREFETCH ();
- corig = c = RE_STRING_CHAR_AND_LENGTH (d, len, target_multibyte);
+ int len;
+ int corig = RE_STRING_CHAR_AND_LENGTH (d, len, target_multibyte);
+ int c = corig;
if (target_multibyte)
{
int c1;
/* Strictly speaking, there should be code such as:
eassert (REG_UNSET (regend[*p]));
- PUSH_FAILURE_REGSTOP ((unsigned int)*p);
+ PUSH_FAILURE_REGSTOP (*p);
But the only info to be pushed is regend[*p] and it is known to
be UNSET, so there really isn't anything to push.
eassert ((re_opcode_t)p[-4] == no_op);
{
- int cycle = 0;
+ bool cycle = false;
CHECK_INFINITE_LOOP (p - 4, d);
if (!cycle)
/* If there's a cycle, just continue without pushing
DEBUG_PRINT ("EXECUTING on_failure_jump_loop %d (to %p):\n",
mcnt, p + mcnt);
{
- int cycle = 0;
+ bool cycle = false;
CHECK_INFINITE_LOOP (p - 3, d);
if (cycle)
/* If there's a cycle, get out of the loop, as if the matching
\f
/* Subroutine definitions for re_match_2. */
-/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
- bytes; nonzero otherwise. */
+/* Return true if TRANSLATE[S1] and TRANSLATE[S2] are not identical
+ for LEN bytes. */
-static int
+static bool
bcmp_translate (re_char *s1, re_char *s2, ptrdiff_t len,
- Lisp_Object translate, int target_multibyte)
+ Lisp_Object translate, bool target_multibyte)
{
re_char *p1 = s1, *p2 = s2;
re_char *p1_end = s1 + len;
if (RE_TRANSLATE (translate, p1_ch)
!= RE_TRANSLATE (translate, p2_ch))
- return 1;
+ return true;
p1 += p1_charlen, p2 += p2_charlen;
}
- if (p1 != p1_end || p2 != p2_end)
- return 1;
-
- return 0;
+ return p1 != p1_end || p2 != p2_end;
}
\f
/* Entry points for GNU code. */
We call regex_compile to do the actual compilation. */
const char *
-re_compile_pattern (const char *pattern, size_t length,
+re_compile_pattern (const char *pattern, ptrdiff_t length,
bool posix_backtracking, const char *whitespace_regexp,
struct re_pattern_buffer *bufp)
{
projects / emacs.git / commitdiff