{
}
-#endif /* MULE */
-
-#define RE_TRANSLATE(ch) TRT_TABLE_OF (translate, (Emchar) ch)
-#define TRANSLATE_P(tr) (!NILP (tr))
+#endif /* not MULE */
#else /* not emacs */
if (!done)
{
- const char *word_syntax_chars =
+ CONST char *word_syntax_chars =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
memset (re_syntax_table, 0, sizeof (re_syntax_table));
}
}
-#endif /* SYNTAX_TABLE */
+#endif /* not SYNTAX_TABLE */
#define SYNTAX_UNSAFE(ignored, c) re_syntax_table[c]
-#define RE_TRANSLATE(c) translate[(unsigned char) (c)]
-#define TRANSLATE_P(tr) tr
-
-#endif /* emacs */
+#endif /* not emacs */
/* Under XEmacs, this is needed because we don't define it elsewhere. */
#ifdef SWITCH_ENUM_BUG
#include <alloca.h>
#else /* not __GNUC__ or HAVE_ALLOCA_H */
#ifndef _AIX /* Already did AIX, up at the top. */
-void *alloca ();
+char *alloca ();
#endif /* not _AIX */
-#endif /* HAVE_ALLOCA_H */
-#endif /* __GNUC__ */
+#endif /* not HAVE_ALLOCA_H */
+#endif /* not __GNUC__ */
#endif /* not alloca */
/* No need to do anything to free, after alloca. */
#define REGEX_FREE(arg) ((void)0) /* Do nothing! But inhibit gcc warning. */
-#endif /* REGEX_MALLOC */
+#endif /* not REGEX_MALLOC */
/* Define how to allocate the failure stack. */
/* No need to explicitly free anything. */
#define REGEX_FREE_STACK(arg)
-#endif /* REGEX_MALLOC */
-#endif /* REL_ALLOC */
+#endif /* not REGEX_MALLOC */
+#endif /* not REL_ALLOC */
/* True if `size1' is non-NULL and PTR is pointing anywhere inside
#define BYTEWIDTH 8 /* In bits. */
-#define STREQ(s1, s2) (strcmp (s1, s2) == 0)
+#define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
#undef MAX
#undef MIN
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
-/* Type of source-pattern and string chars. */
-typedef const unsigned char re_char;
-
typedef char boolean;
#define false 0
#define true 1
#ifdef DEBUG
static void
-extract_number (int *dest, re_char *source)
+extract_number (int *dest, unsigned char *source)
{
int temp = SIGN_EXTEND_CHAR (*(source + 1));
*dest = *source & 0377;
the START pointer into it and ending just before the pointer END. */
static void
-print_partial_compiled_pattern (re_char *start, re_char *end)
+print_partial_compiled_pattern (unsigned char *start, unsigned char *end)
{
int mcnt, mcnt2;
- unsigned char *p = (unsigned char *) start;
- re_char *pend = end;
+ unsigned char *p = start;
+ unsigned char *pend = end;
if (start == NULL)
{
static void
print_compiled_pattern (struct re_pattern_buffer *bufp)
{
- re_char *buffer = bufp->buffer;
+ unsigned char *buffer = bufp->buffer;
print_partial_compiled_pattern (buffer, buffer + bufp->used);
printf ("%ld bytes used/%ld bytes allocated.\n", bufp->used,
static void
-print_double_string (re_char *where, re_char *string1, int size1,
- re_char *string2, int size2)
+print_double_string (CONST char *where, CONST char *string1, int size1,
+ CONST char *string2, int size2)
{
if (where == NULL)
printf ("(null)");
#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
-#endif /* DEBUG */
+#endif /* not DEBUG */
\f
/* Set by `re_set_syntax' to the current regexp syntax to recognize. Can
also be assigned to arbitrarily: each pattern buffer stores its own
POSIX doesn't require that we do anything for REG_NOERROR,
but why not be nice? */
-static const char *re_error_msgid[] =
+static CONST char *re_error_msgid[] =
{
"Success", /* REG_NOERROR */
"No match", /* REG_NOMATCH */
union fail_stack_elt
{
- re_char *pointer;
+ unsigned char *pointer;
int integer;
};
typedef struct
{
fail_stack_elt_t *stack;
- size_t size;
- size_t avail; /* Offset of next open position. */
+ unsigned size;
+ unsigned avail; /* Offset of next open position. */
} fail_stack_type;
#define FAIL_STACK_EMPTY() (fail_stack.avail == 0)
DEBUG_PRINT2 (" Pushing reg: %d\n", this_reg); \
DEBUG_STATEMENT (num_regs_pushed++); \
\
- DEBUG_PRINT2 (" start: 0x%lx\n", (long) regstart[this_reg]); \
+ DEBUG_PRINT2 (" start: 0x%p\n", regstart[this_reg]); \
PUSH_FAILURE_POINTER (regstart[this_reg]); \
\
- DEBUG_PRINT2 (" end: 0x%lx\n", (long) regend[this_reg]); \
+ DEBUG_PRINT2 (" end: 0x%p\n", regend[this_reg]); \
PUSH_FAILURE_POINTER (regend[this_reg]); \
\
DEBUG_PRINT2 (" info: 0x%lx\n ", \
- * (long *) (®_info[this_reg])); \
+ * (unsigned long *) (®_info[this_reg])); \
DEBUG_PRINT2 (" match_null=%d", \
REG_MATCH_NULL_STRING_P (reg_info[this_reg])); \
DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg])); \
DEBUG_PRINT2 (" Pushing high active reg: %d\n", highest_active_reg);\
PUSH_FAILURE_INT (highest_active_reg); \
\
- DEBUG_PRINT2 (" Pushing pattern 0x%lx: \n", (long) pattern_place); \
+ DEBUG_PRINT2 (" Pushing pattern 0x%p: ", pattern_place); \
DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend); \
PUSH_FAILURE_POINTER (pattern_place); \
\
- DEBUG_PRINT2 (" Pushing string 0x%lx: `", (long) string_place); \
+ DEBUG_PRINT2 (" Pushing string 0x%p: `", string_place); \
DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2, \
size2); \
DEBUG_PRINT1 ("'\n"); \
{ \
DEBUG_STATEMENT (fail_stack_elt_t ffailure_id;) \
int this_reg; \
- const unsigned char *string_temp; \
+ CONST unsigned char *string_temp; \
\
assert (!FAIL_STACK_EMPTY ()); \
\
saved NULL, thus retaining our current position in the string. */ \
string_temp = POP_FAILURE_POINTER (); \
if (string_temp != NULL) \
- str = string_temp; \
+ str = (CONST char *) string_temp; \
\
- DEBUG_PRINT2 (" Popping string 0x%lx: `", (long) str); \
+ DEBUG_PRINT2 (" Popping string 0x%p: `", str); \
DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2); \
DEBUG_PRINT1 ("'\n"); \
\
pat = (unsigned char *) POP_FAILURE_POINTER (); \
- DEBUG_PRINT2 (" Popping pattern 0x%lx: ", (long) pat); \
+ DEBUG_PRINT2 (" Popping pattern 0x%p: ", pat); \
DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend); \
\
/* Restore register info. */ \
\
reg_info[this_reg].word = POP_FAILURE_ELT (); \
DEBUG_PRINT2 (" info: 0x%lx\n", \
- * (long *) ®_info[this_reg]); \
+ * (unsigned long *) ®_info[this_reg]); \
\
- regend[this_reg] = POP_FAILURE_POINTER (); \
- DEBUG_PRINT2 (" end: 0x%lx\n", (long) regend[this_reg]); \
+ regend[this_reg] = (CONST char *) POP_FAILURE_POINTER (); \
+ DEBUG_PRINT2 (" end: 0x%p\n", regend[this_reg]); \
\
- regstart[this_reg] = POP_FAILURE_POINTER (); \
- DEBUG_PRINT2 (" start: 0x%lx\n", (long) regstart[this_reg]); \
+ regstart[this_reg] = (CONST char *) POP_FAILURE_POINTER (); \
+ DEBUG_PRINT2 (" start: 0x%p\n", regstart[this_reg]); \
} \
\
set_regs_matched_done = 0; \
while (0)
/* Registers are set to a sentinel when they haven't yet matched. */
-static unsigned char reg_unset_dummy;
+static char reg_unset_dummy;
#define REG_UNSET_VALUE (®_unset_dummy)
#define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
\f
string passed to us by the user to an unsigned char that we can use
as an array index (in, e.g., `translate'). */
#define PATFETCH(c) \
- do { \
- PATFETCH_RAW (c); \
- c = TRANSLATE (c); \
+ do {if (p == pend) return REG_EEND; \
+ assert (p < pend); \
+ c = (unsigned char) *p++; \
+ if (translate) c = (unsigned char) translate[c]; \
} while (0)
/* Fetch the next character in the uncompiled pattern, with no
#define PATFETCH_RAW(c) \
do {if (p == pend) return REG_EEND; \
assert (p < pend); \
- c = charptr_emchar (p); \
- INC_CHARPTR (p); \
+ c = (unsigned char) *p++; \
} while (0)
/* Go backwards one character in the pattern. */
-#define PATUNFETCH DEC_CHARPTR (p)
+#define PATUNFETCH p--
#ifdef MULE
#define PATFETCH_EXTENDED(emch) \
do {if (p == pend) return REG_EEND; \
assert (p < pend); \
- emch = charptr_emchar ((const Bufbyte *) p); \
+ emch = charptr_emchar ((CONST Bufbyte *) p); \
INC_CHARPTR (p); \
- if (TRANSLATE_P (translate) && emch < 0x80) \
- emch = (Emchar) (unsigned char) RE_TRANSLATE (emch); \
+ if (translate && emch < 0x80) \
+ emch = (Emchar) (unsigned char) translate[emch]; \
} while (0)
#define PATFETCH_RAW_EXTENDED(emch) \
do {if (p == pend) return REG_EEND; \
assert (p < pend); \
- emch = charptr_emchar ((const Bufbyte *) p); \
+ emch = charptr_emchar ((CONST Bufbyte *) p); \
INC_CHARPTR (p); \
} while (0)
#define PATFETCH_RAW_EITHER(emch) PATFETCH_RAW (emch)
#define PATUNFETCH_EITHER PATUNFETCH
-#endif /* MULE */
+#endif /* not MULE */
/* If `translate' is non-null, return translate[D], else just D. We
cast the subscript to translate because some data is declared as
`char *', to avoid warnings when a string constant is passed. But
when we use a character as a subscript we must make it unsigned. */
-#define TRANSLATE(d) (TRANSLATE_P (translate) ? RE_TRANSLATE (d) : (d))
+#define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d))
#ifdef MULE
#define TRANSLATE_EXTENDED_UNSAFE(emch) \
- (TRANSLATE_P (translate) && emch < 0x80 ? RE_TRANSLATE (emch) : (emch))
+ (translate && emch < 0x80 ? translate[emch] : (emch))
#endif
/* Make sure we have at least N more bytes of space in buffer. */
#define GET_BUFFER_SPACE(n) \
- while (buf_end - bufp->buffer + (n) > bufp->allocated) \
+ while (b - bufp->buffer + (n) > bufp->allocated) \
EXTEND_BUFFER ()
/* Make sure we have one more byte of buffer space and then add C to it. */
#define BUF_PUSH(c) \
do { \
GET_BUFFER_SPACE (1); \
- *buf_end++ = (unsigned char) (c); \
+ *b++ = (unsigned char) (c); \
} while (0)
#define BUF_PUSH_2(c1, c2) \
do { \
GET_BUFFER_SPACE (2); \
- *buf_end++ = (unsigned char) (c1); \
- *buf_end++ = (unsigned char) (c2); \
+ *b++ = (unsigned char) (c1); \
+ *b++ = (unsigned char) (c2); \
} while (0)
#define BUF_PUSH_3(c1, c2, c3) \
do { \
GET_BUFFER_SPACE (3); \
- *buf_end++ = (unsigned char) (c1); \
- *buf_end++ = (unsigned char) (c2); \
- *buf_end++ = (unsigned char) (c3); \
+ *b++ = (unsigned char) (c1); \
+ *b++ = (unsigned char) (c2); \
+ *b++ = (unsigned char) (c3); \
} while (0)
#define STORE_JUMP2(op, loc, to, arg) \
store_op2 (op, loc, (to) - (loc) - 3, arg)
-/* Like `STORE_JUMP', but for inserting. Assume `buf_end' is the
- buffer end. */
+/* Like `STORE_JUMP', but for inserting. Assume `b' is the buffer end. */
#define INSERT_JUMP(op, loc, to) \
- insert_op1 (op, loc, (to) - (loc) - 3, buf_end)
+ insert_op1 (op, loc, (to) - (loc) - 3, b)
-/* Like `STORE_JUMP2', but for inserting. Assume `buf_end' is the
- buffer end. */
+/* Like `STORE_JUMP2', but for inserting. Assume `b' is the buffer end. */
#define INSERT_JUMP2(op, loc, to, arg) \
- insert_op2 (op, loc, (to) - (loc) - 3, arg, buf_end)
+ insert_op2 (op, loc, (to) - (loc) - 3, arg, b)
/* This is not an arbitrary limit: the arguments which represent offsets
being larger than MAX_BUF_SIZE, then flag memory exhausted. */
#define EXTEND_BUFFER() \
do { \
- re_char *old_buffer = bufp->buffer; \
+ unsigned char *old_buffer = bufp->buffer; \
if (bufp->allocated == MAX_BUF_SIZE) \
return REG_ESIZE; \
bufp->allocated <<= 1; \
/* If the buffer moved, move all the pointers into it. */ \
if (old_buffer != bufp->buffer) \
{ \
- buf_end = (buf_end - old_buffer) + bufp->buffer; \
+ b = (b - old_buffer) + bufp->buffer; \
begalt = (begalt - old_buffer) + bufp->buffer; \
if (fixup_alt_jump) \
fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\
/* Set the bit for character C in a bit vector. */
#define SET_LIST_BIT(c) \
- (buf_end[((unsigned char) (c)) / BYTEWIDTH] \
+ (b[((unsigned char) (c)) / BYTEWIDTH] \
|= 1 << (((unsigned char) c) % BYTEWIDTH))
#ifdef MULE
unsigned char *end);
static void insert_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2,
unsigned char *end);
-static boolean at_begline_loc_p (re_char *pattern, re_char *p,
+static boolean at_begline_loc_p (CONST char *pattern, CONST char *p,
reg_syntax_t syntax);
-static boolean at_endline_loc_p (re_char *p, re_char *pend, int syntax);
+static boolean at_endline_loc_p (CONST char *p, CONST char *pend, int syntax);
static boolean group_in_compile_stack (compile_stack_type compile_stack,
regnum_t regnum);
-static reg_errcode_t compile_range (re_char **p_ptr, re_char *pend,
- RE_TRANSLATE_TYPE translate,
- reg_syntax_t syntax,
+static reg_errcode_t compile_range (CONST char **p_ptr, CONST char *pend,
+ char *translate, reg_syntax_t syntax,
unsigned char *b);
#ifdef MULE
-static reg_errcode_t compile_extended_range (re_char **p_ptr,
- re_char *pend,
- RE_TRANSLATE_TYPE translate,
+static reg_errcode_t compile_extended_range (CONST char **p_ptr,
+ CONST char *pend,
+ char *translate,
reg_syntax_t syntax,
Lisp_Object rtab);
#endif /* MULE */
static boolean common_op_match_null_string_p (unsigned char **p,
unsigned char *end,
register_info_type *reg_info);
-static int bcmp_translate (const unsigned char *s1, const unsigned char *s2,
- REGISTER int len, RE_TRANSLATE_TYPE translate);
+static int bcmp_translate (CONST unsigned char *s1, CONST unsigned char *s2,
+ REGISTER int len, char *translate);
static int re_match_2_internal (struct re_pattern_buffer *bufp,
- re_char *string1, int size1,
- re_char *string2, int size2, int pos,
+ CONST char *string1, int size1,
+ CONST char *string2, int size2, int pos,
struct re_registers *regs, int stop);
\f
#ifndef MATCH_MAY_ALLOCATE
but never make them smaller. */
static int regs_allocated_size;
-static re_char ** regstart, ** regend;
-static re_char ** old_regstart, ** old_regend;
-static re_char **best_regstart, **best_regend;
+static CONST char ** regstart, ** regend;
+static CONST char ** old_regstart, ** old_regend;
+static CONST char **best_regstart, **best_regend;
static register_info_type *reg_info;
-static re_char **reg_dummy;
+static CONST char **reg_dummy;
static register_info_type *reg_info_dummy;
/* Make the register vectors big enough for NUM_REGS registers,
{
if (num_regs > regs_allocated_size)
{
- RETALLOC_IF (regstart, num_regs, re_char *);
- RETALLOC_IF (regend, num_regs, re_char *);
- RETALLOC_IF (old_regstart, num_regs, re_char *);
- RETALLOC_IF (old_regend, num_regs, re_char *);
- RETALLOC_IF (best_regstart, num_regs, re_char *);
- RETALLOC_IF (best_regend, num_regs, re_char *);
+ RETALLOC_IF (regstart, num_regs, CONST char *);
+ RETALLOC_IF (regend, num_regs, CONST char *);
+ RETALLOC_IF (old_regstart, num_regs, CONST char *);
+ RETALLOC_IF (old_regend, num_regs, CONST char *);
+ RETALLOC_IF (best_regstart, num_regs, CONST char *);
+ RETALLOC_IF (best_regend, num_regs, CONST char *);
RETALLOC_IF (reg_info, num_regs, register_info_type);
- RETALLOC_IF (reg_dummy, num_regs, re_char *);
+ RETALLOC_IF (reg_dummy, num_regs, CONST char *);
RETALLOC_IF (reg_info_dummy, num_regs, register_info_type);
regs_allocated_size = num_regs;
return (free (compile_stack.stack), value)
static reg_errcode_t
-regex_compile (re_char *pattern, int size, reg_syntax_t syntax,
+regex_compile (CONST char *pattern, int size, reg_syntax_t syntax,
struct re_pattern_buffer *bufp)
{
/* We fetch characters from PATTERN here. We declare these as int
REGISTER EMACS_INT c, c1;
/* A random temporary spot in PATTERN. */
- re_char *p1;
+ CONST char *p1;
/* Points to the end of the buffer, where we should append. */
- REGISTER unsigned char *buf_end;
+ REGISTER unsigned char *b;
/* Keeps track of unclosed groups. */
compile_stack_type compile_stack;
/* Points to the current (ending) position in the pattern. */
- re_char *p = pattern;
- re_char *pend = pattern + size;
+ CONST char *p = pattern;
+ CONST char *pend = pattern + size;
/* How to translate the characters in the pattern. */
- RE_TRANSLATE_TYPE translate = bufp->translate;
+ char *translate = bufp->translate;
/* Address of the count-byte of the most recently inserted `exactn'
command. This makes it possible to tell if a new exact-match
/* Place in the uncompiled pattern (i.e., the {) to
which to go back if the interval is invalid. */
- re_char *beg_interval;
+ CONST char *beg_interval;
/* Address of the place where a forward jump should go to the end of
the containing expression. Each alternative of an `or' -- except the
bufp->allocated = INIT_BUF_SIZE;
}
- begalt = buf_end = bufp->buffer;
+ begalt = b = bufp->buffer;
/* Loop through the uncompiled pattern until we're at the end. */
while (p != pend)
/* If we get here, we found another repeat character. */
if (!(syntax & RE_NO_MINIMAL_MATCHING))
{
- /* "*?" and "+?" and "??" are okay (and mean match
- minimally), but other sequences (such as "*??" and
- "+++") are rejected (reserved for future use). */
+ /* `*?' and `+?' and `??' are okay (and mean match
+ minimally), but other sequences (such as `*??' and
+ `+++') are rejected (reserved for future use). */
if (minimal || c != '?')
FREE_STACK_RETURN (REG_BADRPT);
minimal = true;
9: end of pattern.
*/
GET_BUFFER_SPACE (6);
- INSERT_JUMP (jump, laststart, buf_end + 3);
- buf_end += 3;
+ INSERT_JUMP (jump, laststart, b + 3);
+ b += 3;
INSERT_JUMP (on_failure_jump, laststart, laststart + 6);
- buf_end += 3;
+ b += 3;
}
else if (zero_times_ok)
{
9: end of pattern.
*/
GET_BUFFER_SPACE (6);
- INSERT_JUMP (jump, laststart, buf_end + 3);
- buf_end += 3;
- STORE_JUMP (on_failure_jump, buf_end, laststart + 3);
- buf_end += 3;
+ INSERT_JUMP (jump, laststart, b + 3);
+ b += 3;
+ STORE_JUMP (on_failure_jump, b, laststart + 3);
+ b += 3;
}
else
{
6: end of pattern.
*/
GET_BUFFER_SPACE (3);
- STORE_JUMP (on_failure_jump, buf_end, laststart);
- buf_end += 3;
+ STORE_JUMP (on_failure_jump, b, laststart);
+ b += 3;
}
}
else
boolean keep_string_p = false;
if (many_times_ok)
- { /* More than one repetition is allowed, so put in
- at the end a backward relative jump from
- `buf_end' to before the next jump we're going
- to put in below (which jumps from laststart to
- after this jump).
+ { /* More than one repetition is allowed, so put in at the
+ end a backward relative jump from `b' to before the next
+ jump we're going to put in below (which jumps from
+ laststart to after this jump).
But if we are at the `*' in the exact sequence `.*\n',
insert an unconditional jump backwards to the .,
character after the `*'. Do we have to do something
analogous here for null bytes, because of
RE_DOT_NOT_NULL? */
- if (*(p - 2) == '.'
+ if (TRANSLATE (*(p - 2)) == TRANSLATE ('.')
&& zero_times_ok
- && p < pend && *p == '\n'
+ && p < pend && TRANSLATE (*p) == TRANSLATE ('\n')
&& !(syntax & RE_DOT_NEWLINE))
{ /* We have .*\n. */
- STORE_JUMP (jump, buf_end, laststart);
+ STORE_JUMP (jump, b, laststart);
keep_string_p = true;
}
else
/* Anything else. */
- STORE_JUMP (maybe_pop_jump, buf_end, laststart - 3);
+ STORE_JUMP (maybe_pop_jump, b, laststart - 3);
/* We've added more stuff to the buffer. */
- buf_end += 3;
+ b += 3;
}
- /* On failure, jump from laststart to buf_end + 3,
- which will be the end of the buffer after this jump
- is inserted. */
+ /* On failure, jump from laststart to b + 3, which will be the
+ end of the buffer after this jump is inserted. */
GET_BUFFER_SPACE (3);
INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump
: on_failure_jump,
- laststart, buf_end + 3);
- buf_end += 3;
+ laststart, b + 3);
+ b += 3;
if (!zero_times_ok)
{
we hit that loop. */
GET_BUFFER_SPACE (3);
INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6);
- buf_end += 3;
+ b += 3;
}
}
pending_exact = 0;
case '.':
- laststart = buf_end;
+ laststart = b;
BUF_PUSH (anychar);
break;
opcode, the length count, and the bitset; 34 bytes in all. */
GET_BUFFER_SPACE (34);
- laststart = buf_end;
+ laststart = b;
/* We test `*p == '^' twice, instead of using an if
statement, so we only need one BUF_PUSH. */
BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
/* Clear the whole map. */
- memset (buf_end, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
+ memset (b, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
/* charset_not matches newline according to a syntax bit. */
- if ((re_opcode_t) buf_end[-2] == charset_not
+ if ((re_opcode_t) b[-2] == charset_not
&& (syntax & RE_HAT_LISTS_NOT_NEWLINE))
SET_LIST_BIT ('\n');
{
/* There are extended chars here, which means we need to start
over and shift to unified range-table format. */
- if (buf_end[-2] == charset)
- buf_end[-2] = charset_mule;
+ if (b[-2] == charset)
+ b[-2] = charset_mule;
else
- buf_end[-2] = charset_mule_not;
- buf_end--;
+ b[-2] = charset_mule_not;
+ b--;
p = p1; /* go back to the beginning of the charset, after
a possible ^. */
rtab = Vthe_lisp_rangetab;
Fclear_range_table (rtab);
/* charset_not matches newline according to a syntax bit. */
- if ((re_opcode_t) buf_end[-1] == charset_mule_not
+ if ((re_opcode_t) b[-1] == charset_mule_not
&& (syntax & RE_HAT_LISTS_NOT_NEWLINE))
SET_EITHER_BIT ('\n');
}
{
if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
- PATFETCH (c);
+ PATFETCH_EITHER (c);
#ifdef MULE
if (c >= 0x80 && !has_extended_chars)
{
if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
- PATFETCH (c1);
+ PATFETCH_EITHER (c1);
#ifdef MULE
if (c1 >= 0x80 && !has_extended_chars)
{
operator. */
if (c == '-'
&& !(p - 2 >= pattern && p[-2] == '[')
- && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
+ && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
&& *p != ']')
{
reg_errcode_t ret;
syntax, rtab);
else
#endif /* MULE */
- ret = compile_range (&p, pend, translate, syntax, buf_end);
+ ret = compile_range (&p, pend, translate, syntax, b);
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
}
syntax, rtab);
else
#endif /* MULE */
- ret = compile_range (&p, pend, translate, syntax, buf_end);
+ ret = compile_range (&p, pend, translate, syntax, b);
if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
}
for (;;)
{
- /* #### This code is unused.
- Correctness is not checked after TRT
- table change. */
+ /* Do not do PATFETCH_EITHER() here. We want
+ to just see if the bytes match particular
+ strings, and we put them all back if not.
+
+ #### May need to be changed once trt tables
+ are working. */
PATFETCH (c);
if (c == ':' || c == ']' || p == pend
|| c1 == CHAR_CLASS_MAX_LENGTH)
break;
- str[c1++] = (char) c;
+ str[c1++] = c;
}
str[c1] = '\0';
- /* If isn't a word bracketed by `[:' and `:]':
+ /* If isn't a word bracketed by `[:' and:`]':
undo the ending character, the letters, and leave
the leading `:' and `[' (but set bits for them). */
if (c == ':' && *p == ']')
int bytes_needed =
unified_range_table_bytes_needed (rtab);
GET_BUFFER_SPACE (bytes_needed);
- unified_range_table_copy_data (rtab, buf_end);
- buf_end += unified_range_table_bytes_used (buf_end);
+ unified_range_table_copy_data (rtab, b);
+ b += unified_range_table_bytes_used (b);
break;
}
#endif /* MULE */
/* Discard any (non)matching list bytes that are all 0 at the
end of the map. Decrease the map-length byte too. */
- while ((int) buf_end[-1] > 0 && buf_end[buf_end[-1] - 1] == 0)
- buf_end[-1]--;
- buf_end += buf_end[-1];
+ while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
+ b[-1]--;
+ b += b[-1];
}
break;
if (!(syntax & RE_NO_SHY_GROUPS)
&& p != pend
- && *p == '?')
+ && TRANSLATE(*p) == TRANSLATE('?'))
{
p++;
- PATFETCH (c);
+ PATFETCH(c);
switch (c)
{
case ':': /* shy groups */
COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer;
COMPILE_STACK_TOP.fixup_alt_jump
= fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;
- COMPILE_STACK_TOP.laststart_offset = buf_end - bufp->buffer;
+ COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;
COMPILE_STACK_TOP.regnum = r;
/* We will eventually replace the 0 with the number of
if (r <= MAX_REGNUM)
{
COMPILE_STACK_TOP.inner_group_offset
- = buf_end - bufp->buffer + 2;
+ = b - bufp->buffer + 2;
BUF_PUSH_3 (start_memory, r, 0);
}
fixup_alt_jump = 0;
laststart = 0;
- begalt = buf_end;
+ begalt = b;
/* If we've reached MAX_REGNUM groups, then this open
won't actually generate any code, so we'll have to
clear pending_exact explicitly. */
/* We allocated space for this jump when we assigned
to `fixup_alt_jump', in the `handle_alt' case below. */
- STORE_JUMP (jump_past_alt, fixup_alt_jump, buf_end - 1);
+ STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);
}
/* See similar code for backslashed left paren above. */
/* Insert before the previous alternative a jump which
jumps to this alternative if the former fails. */
GET_BUFFER_SPACE (3);
- INSERT_JUMP (on_failure_jump, begalt, buf_end + 6);
+ INSERT_JUMP (on_failure_jump, begalt, b + 6);
pending_exact = 0;
- buf_end += 3;
+ b += 3;
/* The alternative before this one has a jump after it
which gets executed if it gets matched. Adjust that
bytes which we'll fill in when we get to after `c'. */
if (fixup_alt_jump)
- STORE_JUMP (jump_past_alt, fixup_alt_jump, buf_end);
+ STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
/* Mark and leave space for a jump after this alternative,
to be filled in later either by next alternative or
when know we're at the end of a series of alternatives. */
- fixup_alt_jump = buf_end;
+ fixup_alt_jump = b;
GET_BUFFER_SPACE (3);
- buf_end += 3;
+ b += 3;
laststart = 0;
- begalt = buf_end;
+ begalt = b;
break;
if (syntax & RE_CONTEXT_INVALID_OPS)
FREE_STACK_RETURN (REG_BADRPT);
else if (syntax & RE_CONTEXT_INDEP_OPS)
- laststart = buf_end;
+ laststart = b;
else
goto unfetch_interval;
}
if (upper_bound == 0)
{
GET_BUFFER_SPACE (3);
- INSERT_JUMP (jump, laststart, buf_end + 3);
- buf_end += 3;
+ INSERT_JUMP (jump, laststart, b + 3);
+ b += 3;
}
/* Otherwise, we have a nontrivial interval. When
because `re_compile_fastmap' needs to know.
Jump to the `jump_n' we might insert below. */
INSERT_JUMP2 (succeed_n, laststart,
- buf_end + 5 + (upper_bound > 1) * 5,
+ b + 5 + (upper_bound > 1) * 5,
lower_bound);
- buf_end += 5;
+ b += 5;
/* Code to initialize the lower bound. Insert
before the `succeed_n'. The `5' is the last two
bytes of this `set_number_at', plus 3 bytes of
the following `succeed_n'. */
- insert_op2 (set_number_at, laststart, 5, lower_bound, buf_end);
- buf_end += 5;
+ insert_op2 (set_number_at, laststart, 5, lower_bound, b);
+ b += 5;
if (upper_bound > 1)
{ /* More than one repetition is allowed, so
When we've reached this during matching,
we'll have matched the interval once, so
jump back only `upper_bound - 1' times. */
- STORE_JUMP2 (jump_n, buf_end, laststart + 5,
+ STORE_JUMP2 (jump_n, b, laststart + 5,
upper_bound - 1);
- buf_end += 5;
+ b += 5;
/* The location we want to set is the second
parameter of the `jump_n'; that is `b-2' as
We insert this at the beginning of the loop
so that if we fail during matching, we'll
reinitialize the bounds. */
- insert_op2 (set_number_at, laststart,
- buf_end - laststart,
- upper_bound - 1, buf_end);
- buf_end += 5;
+ insert_op2 (set_number_at, laststart, b - laststart,
+ upper_bound - 1, b);
+ b += 5;
}
}
pending_exact = 0;
break;
case 's':
- laststart = buf_end;
+ laststart = b;
PATFETCH (c);
/* XEmacs addition */
if (c >= 0x80 || syntax_spec_code[c] == 0377)
break;
case 'S':
- laststart = buf_end;
+ laststart = b;
PATFETCH (c);
/* XEmacs addition */
if (c >= 0x80 || syntax_spec_code[c] == 0377)
#ifdef MULE
/* 97.2.17 jhod merged in to XEmacs from mule-2.3 */
case 'c':
- laststart = buf_end;
+ laststart = b;
PATFETCH_RAW (c);
if (c < 32 || c > 127)
FREE_STACK_RETURN (REG_ECATEGORY);
break;
case 'C':
- laststart = buf_end;
+ laststart = b;
PATFETCH_RAW (c);
if (c < 32 || c > 127)
FREE_STACK_RETURN (REG_ECATEGORY);
case 'w':
- laststart = buf_end;
+ laststart = b;
BUF_PUSH (wordchar);
break;
case 'W':
- laststart = buf_end;
+ laststart = b;
BUF_PUSH (notwordchar);
break;
case '1': case '2': case '3': case '4': case '5':
case '6': case '7': case '8': case '9':
- {
- regnum_t reg;
- if (syntax & RE_NO_BK_REFS)
- goto normal_char;
+ if (syntax & RE_NO_BK_REFS)
+ goto normal_char;
- reg = c - '0';
+ c1 = c - '0';
- if (reg > regnum)
- FREE_STACK_RETURN (REG_ESUBREG);
+ if (c1 > regnum)
+ FREE_STACK_RETURN (REG_ESUBREG);
- /* Can't back reference to a subexpression if inside of it. */
- if (group_in_compile_stack (compile_stack, reg))
- goto normal_char;
+ /* Can't back reference to a subexpression if inside of it. */
+ if (group_in_compile_stack (compile_stack, c1))
+ goto normal_char;
- laststart = buf_end;
- BUF_PUSH_2 (duplicate, reg);
- }
+ laststart = b;
+ BUF_PUSH_2 (duplicate, c1);
break;
{
/* XEmacs: modifications here for Mule. */
/* `q' points to the beginning of the next char. */
- re_char *q = p;
+ CONST char *q = p - 1;
+ INC_CHARPTR (q);
/* If no exactn currently being built. */
if (!pending_exact
/* If last exactn not at current position. */
- || pending_exact + *pending_exact + 1 != buf_end
+ || pending_exact + *pending_exact + 1 != b
/* We have only one byte following the exactn for the count. */
|| ((unsigned int) (*pending_exact + (q - p)) >=
{
/* Start building a new exactn. */
- laststart = buf_end;
+ laststart = b;
BUF_PUSH_2 (exactn, 0);
- pending_exact = buf_end - 1;
+ pending_exact = b - 1;
}
-#ifndef MULE
BUF_PUSH (c);
(*pending_exact)++;
-#else
- {
- Bytecount bt_count;
- Bufbyte tmp_buf[MAX_EMCHAR_LEN];
- int i;
-
- bt_count = set_charptr_emchar (tmp_buf, c);
- for (i = 0; i < bt_count; i++)
- {
- BUF_PUSH (tmp_buf[i]);
- (*pending_exact)++;
- }
- }
-#endif
+ while (p < q)
+ {
+ PATFETCH (c);
+ BUF_PUSH (c);
+ (*pending_exact)++;
+ }
break;
}
} /* switch (c) */
/* Through the pattern now. */
if (fixup_alt_jump)
- STORE_JUMP (jump_past_alt, fixup_alt_jump, buf_end);
+ STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
if (!COMPILE_STACK_EMPTY)
FREE_STACK_RETURN (REG_EPAREN);
free (compile_stack.stack);
/* We have succeeded; set the length of the buffer. */
- bufp->used = buf_end - bufp->buffer;
+ bufp->used = b - bufp->buffer;
#ifdef DEBUG
if (debug)
= (fail_stack_elt_t *) realloc (fail_stack.stack,
(fail_stack.size
* sizeof (fail_stack_elt_t)));
-#endif /* emacs */
+#endif /* not emacs */
}
regex_grow_registers (num_regs);
least one character before the ^. */
static boolean
-at_begline_loc_p (re_char *pattern, re_char *p, reg_syntax_t syntax)
+at_begline_loc_p (CONST char *pattern, CONST char *p, reg_syntax_t syntax)
{
- re_char *prev = p - 2;
+ CONST char *prev = p - 2;
boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
return
at least one character after the $, i.e., `P < PEND'. */
static boolean
-at_endline_loc_p (re_char *p, re_char *pend, int syntax)
+at_endline_loc_p (CONST char *p, CONST char *pend, int syntax)
{
- re_char *next = p;
+ CONST char *next = p;
boolean next_backslash = *next == '\\';
- re_char *next_next = p + 1 < pend ? p + 1 : 0;
+ CONST char *next_next = p + 1 < pend ? p + 1 : 0;
return
/* Before a subexpression? */
`regex_compile' itself. */
static reg_errcode_t
-compile_range (re_char **p_ptr, re_char *pend, RE_TRANSLATE_TYPE translate,
- reg_syntax_t syntax, unsigned char *buf_end)
+compile_range (CONST char **p_ptr, CONST char *pend, char *translate,
+ reg_syntax_t syntax, unsigned char *b)
{
unsigned this_char;
- re_char *p = *p_ptr;
+ CONST char *p = *p_ptr;
int range_start, range_end;
if (p == pend)
We also want to fetch the endpoints without translating them; the
appropriate translation is done in the bit-setting loop below. */
- /* The SVR4 compiler on the 3B2 had trouble with unsigned const char *. */
- range_start = ((const unsigned char *) p)[-2];
- range_end = ((const unsigned char *) p)[0];
+ /* The SVR4 compiler on the 3B2 had trouble with unsigned CONST char *. */
+ range_start = ((CONST unsigned char *) p)[-2];
+ range_end = ((CONST unsigned char *) p)[0];
/* Have to increment the pointer into the pattern string, so the
caller isn't still at the ending character. */
#ifdef MULE
static reg_errcode_t
-compile_extended_range (re_char **p_ptr, re_char *pend,
- RE_TRANSLATE_TYPE translate,
+compile_extended_range (CONST char **p_ptr, CONST char *pend, char *translate,
reg_syntax_t syntax, Lisp_Object rtab)
{
Emchar this_char, range_start, range_end;
- const Bufbyte *p;
+ CONST Bufbyte *p;
if (*p_ptr == pend)
return REG_ERANGE;
- p = (const Bufbyte *) *p_ptr;
+ p = (CONST Bufbyte *) *p_ptr;
range_end = charptr_emchar (p);
p--; /* back to '-' */
DEC_CHARPTR (p); /* back to start of range */
return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
/* Can't have ranges spanning different charsets, except maybe for
- ranges entirely within the first 256 chars. */
+ ranges entirely witin the first 256 chars. */
if ((range_start >= 0x100 || range_end >= 0x100)
&& CHAR_LEADING_BYTE (range_start) !=
/* Reset for next path. */
path_can_be_null = true;
- p = (unsigned char *) fail_stack.stack[--fail_stack.avail].pointer;
+ p = fail_stack.stack[--fail_stack.avail].pointer;
continue;
}
/* And all extended characters must be allowed, too. */
for (j = 0x80; j < 0xA0; j++)
fastmap[j] = 1;
-#else /* not MULE */
+#else /* ! MULE */
for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
fastmap[j] = 1;
-#endif /* MULE */
+#endif /* ! MULE */
for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
}
}
}
-#else /* not MULE */
+#else /* ! MULE */
for (j = 0; j < (1 << BYTEWIDTH); j++)
if (SYNTAX_UNSAFE
(XCHAR_TABLE
(regex_emacs_buffer->mirror_syntax_table), j) ==
(enum syntaxcode) k)
fastmap[j] = 1;
-#endif /* MULE */
+#endif /* ! MULE */
break;
}
}
}
-#else /* not MULE */
+#else /* ! MULE */
for (j = 0; j < (1 << BYTEWIDTH); j++)
if (SYNTAX_UNSAFE
(XCHAR_TABLE
(regex_emacs_buffer->mirror_syntax_table), j) !=
(enum syntaxcode) k)
fastmap[j] = 1;
-#endif /* MULE */
+#endif /* ! MULE */
break;
#ifdef MULE
doesn't let you say where to stop matching. */
int
-re_search (struct re_pattern_buffer *bufp, const char *string, int size,
+re_search (struct re_pattern_buffer *bufp, CONST char *string, int size,
int startpos, int range, struct re_registers *regs)
{
return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
stack overflow). */
int
-re_search_2 (struct re_pattern_buffer *bufp, const char *str1,
- int size1, const char *str2, int size2, int startpos,
+re_search_2 (struct re_pattern_buffer *bufp, CONST char *string1,
+ int size1, CONST char *string2, int size2, int startpos,
int range, struct re_registers *regs, int stop)
{
int val;
- re_char *string1 = (re_char *) str1;
- re_char *string2 = (re_char *) str2;
REGISTER char *fastmap = bufp->fastmap;
- REGISTER RE_TRANSLATE_TYPE translate = bufp->translate;
+ REGISTER char *translate = bufp->translate;
int total_size = size1 + size2;
int endpos = startpos + range;
#ifdef REGEX_BEGLINE_CHECK
int anchored_at_begline = 0;
#endif
- re_char *d;
+ CONST unsigned char *d;
Charcount d_size;
/* Check for out-of-range STARTPOS. */
return -1;
else
{
- d = ((const unsigned char *)
+ d = ((CONST unsigned char *)
(startpos >= size1 ? string2 - size1 : string1) + startpos);
range = charcount_to_bytecount (d, 1);
}
if (startpos < size1 && startpos + range >= size1)
lim = range - (size1 - startpos);
- d = ((const unsigned char *)
+ d = ((CONST unsigned char *)
(startpos >= size1 ? string2 - size1 : string1) + startpos);
DEC_CHARPTR(d); /* Ok, since startpos != size1. */
d_size = charcount_to_bytecount (d, 1);
- if (TRANSLATE_P (translate))
- while (range > lim && *d != '\n')
+ if (translate)
+#ifdef MULE
+ while (range > lim && (*d >= 0x80 || translate[*d] != '\n'))
+#else
+ while (range > lim && translate[*d] != '\n')
+#endif
{
d += d_size; /* Speedier INC_CHARPTR(d) */
d_size = charcount_to_bytecount (d, 1);
if (startpos < size1 && startpos + range >= size1)
lim = range - (size1 - startpos);
- d = ((const unsigned char *)
+ d = ((CONST unsigned char *)
(startpos >= size1 ? string2 - size1 : string1) + startpos);
/* Written out as an if-else to avoid testing `translate'
inside the loop. */
- if (TRANSLATE_P (translate))
- while (range > lim)
- {
+ if (translate)
+ while (range > lim &&
#ifdef MULE
- Emchar buf_ch;
-
- buf_ch = charptr_emchar (d);
- buf_ch = RE_TRANSLATE (buf_ch);
- if (buf_ch >= 0200 || fastmap[(unsigned char) buf_ch])
- break;
-#else
- if (fastmap[(unsigned char)RE_TRANSLATE (*d)])
- break;
-#endif /* MULE */
+ *d < 0x80 &&
+#endif
+ !fastmap[(unsigned char)translate[*d]])
+ {
d_size = charcount_to_bytecount (d, 1);
range -= d_size;
d += d_size; /* Speedier INC_CHARPTR(d) */
}
else /* Searching backwards. */
{
- Emchar c = (size1 == 0 || startpos >= size1
- ? charptr_emchar (string2 + startpos - size1)
- : charptr_emchar (string1 + startpos));
- c = TRANSLATE (c);
+ unsigned char c = (size1 == 0 || startpos >= size1
+ ? string2[startpos - size1]
+ : string1[startpos]);
#ifdef MULE
- if (!(c >= 0200 || fastmap[(unsigned char) c]))
- goto advance;
+ if (c < 0x80 && !fastmap[(unsigned char) TRANSLATE (c)])
#else
- if (!fastmap[(unsigned char) c])
- goto advance;
+ if (!fastmap[(unsigned char) TRANSLATE (c)])
#endif
+ goto advance;
}
}
break;
else if (range > 0)
{
- d = ((const unsigned char *)
+ d = ((CONST unsigned char *)
(startpos >= size1 ? string2 - size1 : string1) + startpos);
d_size = charcount_to_bytecount (d, 1);
range -= d_size;
{
/* Note startpos > size1 not >=. If we are on the
string1/string2 boundary, we want to backup into string1. */
- d = ((const unsigned char *)
+ d = ((CONST unsigned char *)
(startpos > size1 ? string2 - size1 : string1) + startpos);
DEC_CHARPTR(d);
d_size = charcount_to_bytecount (d, 1);
FREE_VAR (reg_dummy); \
FREE_VAR (reg_info_dummy); \
} while (0)
-#else /* not MATCH_MAY_ALLOCATE */
+#else
#define FREE_VARIABLES() ((void)0) /* Do nothing! But inhibit gcc warning. */
-#endif /* MATCH_MAY_ALLOCATE */
+#endif /* not MATCH_MAY_ALLOCATE */
/* These values must meet several constraints. They must not be valid
register values; since we have a limit of 255 registers (because
/* re_match is like re_match_2 except it takes only a single string. */
int
-re_match (struct re_pattern_buffer *bufp, const char *string, int size,
+re_match (struct re_pattern_buffer *bufp, CONST char *string, int size,
int pos, struct re_registers *regs)
{
- int result = re_match_2_internal (bufp, NULL, 0, (re_char *) string, size,
+ int result = re_match_2_internal (bufp, NULL, 0, string, size,
pos, regs, size);
alloca (0);
return result;
matched substring. */
int
-re_match_2 (struct re_pattern_buffer *bufp, const char *string1,
- int size1, const char *string2, int size2, int pos,
+re_match_2 (struct re_pattern_buffer *bufp, CONST char *string1,
+ int size1, CONST char *string2, int size2, int pos,
struct re_registers *regs, int stop)
{
- int result = re_match_2_internal (bufp, (re_char *) string1, size1,
- (re_char *) string2, size2,
+ int result = re_match_2_internal (bufp, string1, size1, string2, size2,
pos, regs, stop);
alloca (0);
return result;
/* This is a separate function so that we can force an alloca cleanup
afterwards. */
static int
-re_match_2_internal (struct re_pattern_buffer *bufp, re_char *string1,
- int size1, re_char *string2, int size2, int pos,
+re_match_2_internal (struct re_pattern_buffer *bufp, CONST char *string1,
+ int size1, CONST char *string2, int size2, int pos,
struct re_registers *regs, int stop)
{
/* General temporaries. */
int should_succeed; /* XEmacs change */
/* Just past the end of the corresponding string. */
- re_char *end1, *end2;
+ CONST char *end1, *end2;
/* Pointers into string1 and string2, just past the last characters in
each to consider matching. */
- re_char *end_match_1, *end_match_2;
+ CONST char *end_match_1, *end_match_2;
/* Where we are in the data, and the end of the current string. */
- re_char *d, *dend;
+ CONST char *d, *dend;
/* Where we are in the pattern, and the end of the pattern. */
unsigned char *p = bufp->buffer;
/* Mark the opcode just after a start_memory, so we can test for an
empty subpattern when we get to the stop_memory. */
- re_char *just_past_start_mem = 0;
+ unsigned char *just_past_start_mem = 0;
/* We use this to map every character in the string. */
- RE_TRANSLATE_TYPE translate = bufp->translate;
+ char *translate = bufp->translate;
/* Failure point stack. Each place that can handle a failure further
down the line pushes a failure point on this stack. It consists of
stopped matching the regnum-th subexpression. (The zeroth register
keeps track of what the whole pattern matches.) */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
- re_char **regstart, **regend;
+ CONST char **regstart, **regend;
#endif
/* If a group that's operated upon by a repetition operator fails to
are when we last see its open-group operator. Similarly for a
register's end. */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
- re_char **old_regstart, **old_regend;
+ CONST char **old_regstart, **old_regend;
#endif
/* The is_active field of reg_info helps us keep track of which (possibly
turn happens only if we have not yet matched the entire string. */
unsigned best_regs_set = false;
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
- re_char **best_regstart, **best_regend;
+ CONST char **best_regstart, **best_regend;
#endif
/* Logically, this is `best_regend[0]'. But we don't want to have to
the end of the best match so far in a separate variable. We
initialize this to NULL so that when we backtrack the first time
and need to test it, it's not garbage. */
- re_char *match_end = NULL;
+ CONST char *match_end = NULL;
/* This helps SET_REGS_MATCHED avoid doing redundant work. */
int set_regs_matched_done = 0;
/* Used when we pop values we don't care about. */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global. */
- re_char **reg_dummy;
+ CONST char **reg_dummy;
register_info_type *reg_info_dummy;
#endif
array indexing. We should fix this. */
if (bufp->re_nsub)
{
- regstart = REGEX_TALLOC (num_regs, re_char *);
- regend = REGEX_TALLOC (num_regs, re_char *);
- old_regstart = REGEX_TALLOC (num_regs, re_char *);
- old_regend = REGEX_TALLOC (num_regs, re_char *);
- best_regstart = REGEX_TALLOC (num_regs, re_char *);
- best_regend = REGEX_TALLOC (num_regs, re_char *);
+ regstart = REGEX_TALLOC (num_regs, CONST char *);
+ regend = REGEX_TALLOC (num_regs, CONST char *);
+ old_regstart = REGEX_TALLOC (num_regs, CONST char *);
+ old_regend = REGEX_TALLOC (num_regs, CONST char *);
+ best_regstart = REGEX_TALLOC (num_regs, CONST char *);
+ best_regend = REGEX_TALLOC (num_regs, CONST char *);
reg_info = REGEX_TALLOC (num_regs, register_info_type);
- reg_dummy = REGEX_TALLOC (num_regs, re_char *);
+ reg_dummy = REGEX_TALLOC (num_regs, CONST char *);
reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type);
if (!(regstart && regend && old_regstart && old_regend && reg_info
MATCHED_SOMETHING (reg_info[mcnt]) = 0;
EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;
}
+
/* We move `string1' into `string2' if the latter's empty -- but not if
`string1' is null. */
if (size2 == 0 && string1 != NULL)
dend = end_match_2;
}
- DEBUG_PRINT1 ("The compiled pattern is: \n");
+ DEBUG_PRINT1 ("The compiled pattern is: ");
DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
DEBUG_PRINT1 ("The string to match is: `");
DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
fails at this starting point in the input data. */
for (;;)
{
- DEBUG_PRINT2 ("\n0x%lx: ", (long) p);
+ DEBUG_PRINT2 ("\n0x%p: ", p);
#ifdef emacs /* XEmacs added, w/removal of immediate_quit */
if (!no_quit_in_re_search)
QUIT;
/* This is written out as an if-else so we don't waste time
testing `translate' inside the loop. */
- if (TRANSLATE_P (translate))
+ if (translate)
{
do
{
-#ifdef MULE
- Emchar pat_ch, buf_ch;
- Bytecount pat_len;
-
- PREFETCH ();
- pat_ch = charptr_emchar (p);
- buf_ch = charptr_emchar (d);
- if (RE_TRANSLATE (buf_ch) != pat_ch)
- goto fail;
-
- pat_len = charcount_to_bytecount (p, 1);
- p += pat_len;
- INC_CHARPTR (d);
-
- mcnt -= pat_len;
-#else /* not MULE */
PREFETCH ();
- if ((unsigned char) RE_TRANSLATE (*d++) != *p++)
+ if (translate[(unsigned char) *d++] != (char) *p++)
goto fail;
- mcnt--;
-#endif
}
- while (mcnt > 0);
+ while (--mcnt);
}
else
{
do
{
PREFETCH ();
- if (*d++ != *p++) goto fail;
+ if (*d++ != (char) *p++) goto fail;
}
while (--mcnt);
}
DEBUG_PRINT2 ("EXECUTING charset_mule%s.\n", not ? "_not" : "");
PREFETCH ();
- c = charptr_emchar ((const Bufbyte *) d);
+ c = charptr_emchar ((CONST Bufbyte *) d);
c = TRANSLATE_EXTENDED_UNSAFE (c); /* The character to match. */
if (EQ (Qt, unified_range_table_lookup (p, c, Qnil)))
highest_active_reg = NO_HIGHEST_ACTIVE_REG;
}
else
- {
- highest_active_reg = r;
-
- /* 98/9/21 jhod: We've also gotta set lowest_active_reg, don't we? */
- r = 1;
- while (r < highest_active_reg && !IS_ACTIVE(reg_info[r]))
- r++;
- lowest_active_reg = r;
- }
- }
+ highest_active_reg = r;
+ }
/* If just failed to match something this time around with a
group that's operated on by a repetition operator, try to
followed by the numeric value of <digit> as the register number. */
case duplicate:
{
- REGISTER re_char *d2, *dend2;
+ REGISTER CONST char *d2, *dend2;
int regno = *p++; /* Get which register to match against. */
DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);
/* Compare that many; failure if mismatch, else move
past them. */
- if (TRANSLATE_P (translate)
+ if (translate
? bcmp_translate ((unsigned char *) d,
(unsigned char *) d2, mcnt, translate)
: memcmp (d, d2, mcnt))
DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");
EXTRACT_NUMBER_AND_INCR (mcnt, p);
- DEBUG_PRINT3 (" %d (to 0x%lx):\n", mcnt, (long) (p + mcnt));
+ DEBUG_PRINT3 (" %d (to 0x%p):\n", mcnt, p + mcnt);
- PUSH_FAILURE_POINT (p + mcnt, (unsigned char *) 0, -2);
+ PUSH_FAILURE_POINT (p + mcnt, (char *) 0, -2);
break;
DEBUG_PRINT1 ("EXECUTING on_failure_jump");
EXTRACT_NUMBER_AND_INCR (mcnt, p);
- DEBUG_PRINT3 (" %d (to 0x%lx)", mcnt, (long) (p + mcnt));
+ DEBUG_PRINT3 (" %d (to 0x%p)", mcnt, p + mcnt);
/* If this on_failure_jump comes right before a group (i.e.,
the original * applied to a group), save the information
`pop_failure_point'. */
unsigned dummy_low_reg, dummy_high_reg;
unsigned char *pdummy;
- re_char *sdummy = NULL;
+ CONST char *sdummy = NULL;
DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");
POP_FAILURE_POINT (sdummy, pdummy,
EXTRACT_NUMBER_AND_INCR (mcnt, p); /* Get the amount to jump. */
DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
p += mcnt; /* Do the jump. */
- DEBUG_PRINT2 ("(to 0x%lx).\n", (long) p);
+ DEBUG_PRINT2 ("(to 0x%p).\n", p);
break;
DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");
/* It doesn't matter what we push for the string here. What
the code at `fail' tests is the value for the pattern. */
- PUSH_FAILURE_POINT ((unsigned char *) 0, (unsigned char *) 0, -2);
+ PUSH_FAILURE_POINT ((unsigned char *) 0, (char *) 0, -2);
goto unconditional_jump;
DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");
/* See comments just above at `dummy_failure_jump' about the
two zeroes. */
- PUSH_FAILURE_POINT ((unsigned char *) 0, (unsigned char *) 0, -2);
+ PUSH_FAILURE_POINT ((unsigned char *) 0, (char *) 0, -2);
break;
/* Have to succeed matching what follows at least n times.
mcnt--;
p += 2;
STORE_NUMBER_AND_INCR (p, mcnt);
- DEBUG_PRINT3 (" Setting 0x%lx to %d.\n", (long) p, mcnt);
+ DEBUG_PRINT3 (" Setting 0x%p to %d.\n", p, mcnt);
}
else if (mcnt == 0)
{
- DEBUG_PRINT2 (" Setting two bytes from 0x%lx to no_op.\n",
- (long) (p+2));
+ DEBUG_PRINT2 (" Setting two bytes from 0x%p to no_op.\n", p+2);
p[2] = (unsigned char) no_op;
p[3] = (unsigned char) no_op;
goto on_failure;
EXTRACT_NUMBER_AND_INCR (mcnt, p);
p1 = p + mcnt;
EXTRACT_NUMBER_AND_INCR (mcnt, p);
- DEBUG_PRINT3 (" Setting 0x%lx to %d.\n", (long) p1, mcnt);
+ DEBUG_PRINT3 (" Setting 0x%p to %d.\n", p1, mcnt);
STORE_NUMBER (p1, mcnt);
break;
}
result = 1;
else
{
- const unsigned char *d_before =
- (const unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
- const unsigned char *d_after =
- (const unsigned char *) POS_AFTER_GAP_UNSAFE (d);
+ CONST unsigned char *d_before =
+ (CONST unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
+ CONST unsigned char *d_after =
+ (CONST unsigned char *) POS_AFTER_GAP_UNSAFE (d);
Emchar emch1, emch2;
DEC_CHARPTR (d_before);
break;
*/
- const unsigned char *dtmp =
- (const unsigned char *) POS_AFTER_GAP_UNSAFE (d);
+ CONST unsigned char *dtmp =
+ (CONST unsigned char *) POS_AFTER_GAP_UNSAFE (d);
Emchar emch = charptr_emchar (dtmp);
if (!WORDCHAR_P_UNSAFE (emch))
goto fail;
if (AT_STRINGS_BEG (d))
break;
- dtmp = (const unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
+ dtmp = (CONST unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
DEC_CHARPTR (dtmp);
emch = charptr_emchar (dtmp);
if (!WORDCHAR_P_UNSAFE (emch))
The or condition is incorrect (reversed).
*/
- const unsigned char *dtmp;
+ CONST unsigned char *dtmp;
Emchar emch;
if (AT_STRINGS_BEG (d))
goto fail;
- dtmp = (const unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
+ dtmp = (CONST unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
DEC_CHARPTR (dtmp);
emch = charptr_emchar (dtmp);
if (!WORDCHAR_P_UNSAFE (emch))
goto fail;
if (AT_STRINGS_END (d))
break;
- dtmp = (const unsigned char *) POS_AFTER_GAP_UNSAFE (d);
+ dtmp = (CONST unsigned char *) POS_AFTER_GAP_UNSAFE (d);
emch = charptr_emchar (dtmp);
if (!WORDCHAR_P_UNSAFE (emch))
break;
#ifdef emacs
case before_dot:
DEBUG_PRINT1 ("EXECUTING before_dot.\n");
- if (!regex_emacs_buffer_p
- || (BUF_PTR_BYTE_POS (regex_emacs_buffer, (unsigned char *) d)
- >= BUF_PT (regex_emacs_buffer)))
+ if (BUF_PTR_BYTE_POS (regex_emacs_buffer, (unsigned char *) d) >=
+ BUF_PT (regex_emacs_buffer))
goto fail;
break;
case at_dot:
DEBUG_PRINT1 ("EXECUTING at_dot.\n");
- if (!regex_emacs_buffer_p
- || (BUF_PTR_BYTE_POS (regex_emacs_buffer, (unsigned char *) d)
- != BUF_PT (regex_emacs_buffer)))
+ if (BUF_PTR_BYTE_POS (regex_emacs_buffer, (unsigned char *) d)
+ != BUF_PT (regex_emacs_buffer))
goto fail;
break;
case after_dot:
DEBUG_PRINT1 ("EXECUTING after_dot.\n");
- if (!regex_emacs_buffer_p
- || (BUF_PTR_BYTE_POS (regex_emacs_buffer, (unsigned char *) d)
- <= BUF_PT (regex_emacs_buffer)))
+ if (BUF_PTR_BYTE_POS (regex_emacs_buffer, (unsigned char *) d)
+ <= BUF_PT (regex_emacs_buffer))
goto fail;
break;
#if 0 /* not emacs19 */
Emchar emch;
PREFETCH ();
- emch = charptr_emchar ((const Bufbyte *) d);
+ emch = charptr_emchar ((CONST Bufbyte *) d);
matches = (SYNTAX_UNSAFE
(XCHAR_TABLE (regex_emacs_buffer->mirror_syntax_table),
emch) == (enum syntaxcode) mcnt);
mcnt = *p++;
PREFETCH ();
- emch = charptr_emchar ((const Bufbyte *) d);
+ emch = charptr_emchar ((CONST Bufbyte *) d);
INC_CHARPTR (d);
if (check_category_char(emch, regex_emacs_buffer->category_table,
mcnt, should_succeed))
SET_REGS_MATCHED ();
d++;
break;
-#endif /* emacs */
+#endif /* not emacs */
default:
abort ();
bytes; nonzero otherwise. */
static int
-bcmp_translate (re_char *s1, re_char *s2,
- REGISTER int len, RE_TRANSLATE_TYPE translate)
+bcmp_translate (CONST unsigned char *s1, CONST unsigned char *s2,
+ REGISTER int len, char *translate)
{
- REGISTER const unsigned char *p1 = s1, *p2 = s2;
-#ifdef MULE
- const unsigned char *p1_end = s1 + len;
- const unsigned char *p2_end = s2 + len;
-
- while (p1 != p1_end && p2 != p2_end)
- {
- Emchar p1_ch, p2_ch;
-
- p1_ch = charptr_emchar (p1);
- p2_ch = charptr_emchar (p2);
-
- if (RE_TRANSLATE (p1_ch)
- != RE_TRANSLATE (p2_ch))
- return 1;
- INC_CHARPTR (p1);
- INC_CHARPTR (p2);
- }
-#else /* not MULE */
+ REGISTER CONST unsigned char *p1 = s1, *p2 = s2;
while (len)
{
- if (RE_TRANSLATE (*p1++) != RE_TRANSLATE (*p2++)) return 1;
+ if (translate[*p1++] != translate[*p2++]) return 1;
len--;
}
-#endif /* MULE */
return 0;
}
\f
We call regex_compile to do the actual compilation. */
-const char *
-re_compile_pattern (const char *pattern, int length,
+CONST char *
+re_compile_pattern (CONST char *pattern, int length,
struct re_pattern_buffer *bufp)
{
reg_errcode_t ret;
/* Match anchors at newline. */
bufp->newline_anchor = 1;
- ret = regex_compile ((unsigned char *) pattern, length, re_syntax_options, bufp);
+ ret = regex_compile (pattern, length, re_syntax_options, bufp);
if (!ret)
return NULL;
static struct re_pattern_buffer re_comp_buf;
char *
-re_comp (const char *s)
+re_comp (CONST char *s)
{
reg_errcode_t ret;
/* Match anchors at newlines. */
re_comp_buf.newline_anchor = 1;
- ret = regex_compile ((unsigned char *)s, strlen (s), re_syntax_options, &re_comp_buf);
+ ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
if (!ret)
return NULL;
- /* Yes, we're discarding `const' here if !HAVE_LIBINTL. */
+ /* Yes, we're discarding `CONST' here if !HAVE_LIBINTL. */
return (char *) gettext (re_error_msgid[(int) ret]);
}
int
-re_exec (const char *s)
+re_exec (CONST char *s)
{
- const int len = strlen (s);
+ CONST int len = strlen (s);
return
0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
}
the return codes and their meanings.) */
int
-regcomp (regex_t *preg, const char *pattern, int cflags)
+regcomp (regex_t *preg, CONST char *pattern, int cflags)
{
reg_errcode_t ret;
unsigned syntax
/* POSIX says a null character in the pattern terminates it, so we
can use strlen here in compiling the pattern. */
- ret = regex_compile ((unsigned char *) pattern, strlen (pattern), syntax, preg);
+ ret = regex_compile (pattern, strlen (pattern), syntax, preg);
/* POSIX doesn't distinguish between an unmatched open-group and an
unmatched close-group: both are REG_EPAREN. */
We return 0 if we find a match and REG_NOMATCH if not. */
int
-regexec (const regex_t *preg, const char *string, size_t nmatch,
+regexec (CONST regex_t *preg, CONST char *string, size_t nmatch,
regmatch_t pmatch[], int eflags)
{
int ret;
from either regcomp or regexec. We don't use PREG here. */
size_t
-regerror (int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
+regerror (int errcode, CONST regex_t *preg, char *errbuf, size_t errbuf_size)
{
- const char *msg;
+ CONST char *msg;
size_t msg_size;
if (errcode < 0
projects / chise / xemacs-chise.git.1 / blobdiff