xemacs-beta: src/regex.c comparison

comparison src/regex.c @ 446:1ccc32a20af4 r21-2-38

Import from CVS: tag r21-2-38

author	cvs
date	Mon, 13 Aug 2007 11:37:21 +0200
parents	576fb035e263
children	98528da0b7fc

comparison

equal deleted inserted replaced

-:34f3776fcf0e
+:1ccc32a20af4
 void
 complex_vars_of_regex (void)
 {
 }
-#endif /* not MULE */
+#endif /* MULE */
+#define RE_TRANSLATE(ch) TRT_TABLE_OF (translate, (Emchar) ch)
+#define TRANSLATE_P(tr) (!NILP (tr))
 #else  /* not emacs */
 /* If we are not linking with Emacs proper,
 we can't use the relocating allocator
 done = 1;
 }
 }
-#endif /* not SYNTAX_TABLE */
+#endif /* SYNTAX_TABLE */
 #define SYNTAX_UNSAFE(ignored, c) re_syntax_table[c]
-#endif /* not emacs */
+#define RE_TRANSLATE(c) translate[(unsigned char) (c)]
+#define TRANSLATE_P(tr) tr
+#endif /* emacs */
 /* Under XEmacs, this is needed because we don't define it elsewhere. */
 #ifdef SWITCH_ENUM_BUG
 #define SWITCH_ENUM_CAST(x) ((int)(x))
 #else
 #include <alloca.h>
 #else /* not __GNUC__ or HAVE_ALLOCA_H */
 #ifndef _AIX /* Already did AIX, up at the top.  */
 void *alloca ();
 #endif /* not _AIX */
-#endif /* not HAVE_ALLOCA_H */
+#endif /* HAVE_ALLOCA_H */
-#endif /* not __GNUC__ */
+#endif /* __GNUC__ */
 #endif /* not alloca */
 #define REGEX_ALLOCATE alloca
 destination)
 /* No need to do anything to free, after alloca.  */
 #define REGEX_FREE(arg) ((void)0) /* Do nothing!  But inhibit gcc warning.  */
-#endif /* not REGEX_MALLOC */
+#endif /* REGEX_MALLOC */
 /* Define how to allocate the failure stack.  */
 #ifdef REL_ALLOC
 #define REGEX_ALLOCATE_STACK(size)				\
 #define REGEX_REALLOCATE_STACK(source, osize, nsize)			\
 REGEX_REALLOCATE (source, osize, nsize)
 /* No need to explicitly free anything.  */
 #define REGEX_FREE_STACK(arg)
-#endif /* not REGEX_MALLOC */
+#endif /* REGEX_MALLOC */
-#endif /* not REL_ALLOC */
+#endif /* REL_ALLOC */
 /* True if `size1' is non-NULL and PTR is pointing anywhere inside
 `string1' or just past its end.  This works if PTR is NULL, which is
 a good thing.  */
 #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
 (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8;		\
 } while (0)
 #ifdef DEBUG
 static void
-extract_number (int *dest, unsigned char *source)
+extract_number (int *dest, re_char *source)
 {
 int temp = SIGN_EXTEND_CHAR (*(source + 1));
 *dest = *source & 0377;
 *dest += temp << 8;
 }
 /* Print a compiled pattern string in human-readable form, starting at
 the START pointer into it and ending just before the pointer END.  */
 static void
-print_partial_compiled_pattern (unsigned char *start, unsigned char *end)
+print_partial_compiled_pattern (re_char *start, re_char *end)
 {
 int mcnt, mcnt2;
-unsigned char *p = start;
+unsigned char *p = (unsigned char *) start;
-unsigned char *pend = end;
+re_char *pend = end;
 if (start == NULL)
 {
 puts ("(null)");
 return;
 static void
 print_compiled_pattern (struct re_pattern_buffer *bufp)
 {
-unsigned char *buffer = bufp->buffer;
+re_char *buffer = bufp->buffer;
 print_partial_compiled_pattern (buffer, buffer + bufp->used);
 printf ("%ld bytes used/%ld bytes allocated.\n", bufp->used,
 	  bufp->allocated);
 /* and maybe the category table? */
 }
 static void
-print_double_string (const char *where, const char *string1, int size1,
+print_double_string (re_char *where, re_char *string1, int size1,
-		     const char *string2, int size2)
+		     re_char *string2, int size2)
 {
 if (where == NULL)
 printf ("(null)");
 else
 {
 #define DEBUG_PRINT3(x1, x2, x3)
 #define DEBUG_PRINT4(x1, x2, x3, x4)
 #define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
 #define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
-#endif /* not DEBUG */
+#endif /* DEBUG */
 /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
 also be assigned to arbitrarily: each pattern buffer stores its own
 syntax, so it can be changed between regex compilations.  */
 /* This has no initializer because initialized variables in Emacs
 int re_max_failures = 2000;
 #endif
 union fail_stack_elt
 {
-unsigned char *pointer;
+re_char *pointer;
 int integer;
 };
 typedef union fail_stack_elt fail_stack_elt_t;
 typedef struct
 {
 fail_stack_elt_t *stack;
-unsigned size;
+size_t size;
-unsigned avail;			/* Offset of next open position.  */
+size_t avail;			/* Offset of next open position.  */
 } fail_stack_type;
 #define FAIL_STACK_EMPTY()     (fail_stack.avail == 0)
 #define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)
 #define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)
 PUSH_FAILURE_INT (lowest_active_reg);				\
 									\
 DEBUG_PRINT2 ("  Pushing high active reg: %d\n", highest_active_reg);\
 PUSH_FAILURE_INT (highest_active_reg);				\
 									\
-DEBUG_PRINT2 ("  Pushing pattern 0x%lx: ", (long) pattern_place);	\
+DEBUG_PRINT2 ("  Pushing pattern 0x%lx: \n", (long) 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_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \
 /* If the saved string location is NULL, it came from an		\
 on_failure_keep_string_jump opcode, and we want to throw away the	\
 saved NULL, thus retaining our current position in the string.  */	\
 string_temp = POP_FAILURE_POINTER ();					\
 if (string_temp != NULL)						\
-str = (const char *) string_temp;					\
+str = string_temp;							\
 									\
 DEBUG_PRINT2 ("  Popping string 0x%lx: `",  (long) str);		\
 DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);	\
 DEBUG_PRINT1 ("'\n");							\
 									\
 									\
 reg_info[this_reg].word = POP_FAILURE_ELT ();			\
 DEBUG_PRINT2 ("      info: 0x%lx\n",				\
 		    * (long *) &reg_info[this_reg]);			\
 									\
-regend[this_reg] = (const char *) POP_FAILURE_POINTER ();		\
+regend[this_reg] = POP_FAILURE_POINTER ();			\
 DEBUG_PRINT2 ("      end: 0x%lx\n", (long) regend[this_reg]);	\
 									\
-regstart[this_reg] = (const char *) POP_FAILURE_POINTER ();	\
+regstart[this_reg] = POP_FAILURE_POINTER ();			\
 DEBUG_PRINT2 ("      start: 0x%lx\n", (long) regstart[this_reg]);	\
 }									\
 									\
 set_regs_matched_done = 0;						\
 DEBUG_STATEMENT (nfailure_points_popped++);				\
 	}								\
 }									\
 while (0)
 /* Registers are set to a sentinel when they haven't yet matched.  */
-static char reg_unset_dummy;
+static unsigned char reg_unset_dummy;
 #define REG_UNSET_VALUE (&reg_unset_dummy)
 #define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
 /* Subroutine declarations and macros for regex_compile.  */
 /* Fetch the next character in the uncompiled pattern---translating it
 if necessary.  Also cast from a signed character in the constant
 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 {if (p == pend) return REG_EEND;					\
+do {									\
-assert (p < pend);							\
+PATFETCH_RAW (c);							\
-c = (unsigned char) *p++;						\
+c = TRANSLATE (c);							\
-if (translate) c = (unsigned char) translate[c]; 			\
 } while (0)
 /* Fetch the next character in the uncompiled pattern, with no
 translation.  */
 #define PATFETCH_RAW(c)							\
 do {if (p == pend) return REG_EEND;					\
 assert (p < pend);							\
-c = (unsigned char) *p++; 						\
+c = charptr_emchar (p); 						\
+INC_CHARPTR (p);							\
 } while (0)
 /* Go backwards one character in the pattern.  */
-#define PATUNFETCH p--
+#define PATUNFETCH DEC_CHARPTR (p)
 #ifdef MULE
 #define PATFETCH_EXTENDED(emch)						\
 do {if (p == pend) return REG_EEND;					\
 assert (p < pend);							\
 emch = charptr_emchar ((const Bufbyte *) p);			\
 INC_CHARPTR (p);							\
-if (translate && emch < 0x80)					\
+if (TRANSLATE_P (translate) && emch < 0x80)				\
-emch = (Emchar) (unsigned char) translate[emch];			\
+emch = (Emchar) (unsigned char) RE_TRANSLATE (emch);		\
 } while (0)
 #define PATFETCH_RAW_EXTENDED(emch)					\
 do {if (p == pend) return REG_EEND;					\
 assert (p < pend);							\
 #define PATFETCH_EITHER(emch) PATFETCH (emch)
 #define PATFETCH_RAW_EITHER(emch) PATFETCH_RAW (emch)
 #define PATUNFETCH_EITHER PATUNFETCH
-#endif /* not MULE */
+#endif /* 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 ? translate[(unsigned char) (d)] : (d))
+#define TRANSLATE(d) (TRANSLATE_P (translate) ? RE_TRANSLATE (d) : (d))
 #ifdef MULE
 #define TRANSLATE_EXTENDED_UNSAFE(emch) \
-(translate && emch < 0x80 ? translate[emch] : (emch))
+(TRANSLATE_P (translate) && emch < 0x80 ? RE_TRANSLATE (emch) : (emch))
 #endif
 /* Macros for outputting the compiled pattern into `buffer'.  */
 /* If the buffer isn't allocated when it comes in, use this.  */
 #define INIT_BUF_SIZE  32
 /* Make sure we have at least N more bytes of space in buffer.  */
 #define GET_BUFFER_SPACE(n)						\
-while (b - bufp->buffer + (n) > bufp->allocated)			\
+while (buf_end - 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);						\
-*b++ = (unsigned char) (c);						\
+*buf_end++ = (unsigned char) (c);					\
 } while (0)
 /* Ensure we have two more bytes of buffer space and then append C1 and C2.  */
 #define BUF_PUSH_2(c1, c2)						\
 do {									\
 GET_BUFFER_SPACE (2);						\
-*b++ = (unsigned char) (c1);					\
+*buf_end++ = (unsigned char) (c1);					\
-*b++ = (unsigned char) (c2);					\
+*buf_end++ = (unsigned char) (c2);					\
 } while (0)
 /* As with BUF_PUSH_2, except for three bytes.  */
 #define BUF_PUSH_3(c1, c2, c3)						\
 do {									\
 GET_BUFFER_SPACE (3);						\
-*b++ = (unsigned char) (c1);					\
+*buf_end++ = (unsigned char) (c1);					\
-*b++ = (unsigned char) (c2);					\
+*buf_end++ = (unsigned char) (c2);					\
-*b++ = (unsigned char) (c3);					\
+*buf_end++ = (unsigned char) (c3);					\
 } while (0)
 /* Store a jump with opcode OP at LOC to location TO.  We store a
 relative address offset by the three bytes the jump itself occupies.  */
 /* Likewise, for a two-argument jump.  */
 #define STORE_JUMP2(op, loc, to, arg) \
 store_op2 (op, loc, (to) - (loc) - 3, arg)
-/* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
+/* Like `STORE_JUMP', but for inserting.  Assume `buf_end' is the
+buffer end.  */
 #define INSERT_JUMP(op, loc, to) \
-insert_op1 (op, loc, (to) - (loc) - 3, b)
+insert_op1 (op, loc, (to) - (loc) - 3, buf_end)
-/* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
+/* Like `STORE_JUMP2', but for inserting.  Assume `buf_end' is the
+buffer end.  */
 #define INSERT_JUMP2(op, loc, to, arg) \
-insert_op2 (op, loc, (to) - (loc) - 3, arg, b)
+insert_op2 (op, loc, (to) - (loc) - 3, arg, buf_end)
 /* This is not an arbitrary limit: the arguments which represent offsets
 into the pattern are two bytes long.  So if 2^16 bytes turns out to
 be too small, many things would have to change.  */
 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()							\
 do { 									\
-unsigned char *old_buffer = bufp->buffer;				\
+re_char *old_buffer = bufp->buffer;				\
 if (bufp->allocated == MAX_BUF_SIZE) 				\
 return REG_ESIZE;							\
 bufp->allocated <<= 1;						\
 if (bufp->allocated > MAX_BUF_SIZE)					\
 bufp->allocated = MAX_BUF_SIZE; 					\
 if (bufp->buffer == NULL)						\
 return REG_ESPACE;						\
 /* If the buffer moved, move all the pointers into it.  */		\
 if (old_buffer != bufp->buffer)					\
 {									\
-b = (b - old_buffer) + bufp->buffer;				\
+buf_end = (buf_end - old_buffer) + bufp->buffer;		\
 begalt = (begalt - old_buffer) + bufp->buffer;			\
 if (fixup_alt_jump)						\
 fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\
 if (laststart)							\
 laststart = (laststart - old_buffer) + bufp->buffer;		\
 #define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
 /* Set the bit for character C in a bit vector.  */
 #define SET_LIST_BIT(c)				\
-(b[((unsigned char) (c)) / BYTEWIDTH]		\
+(buf_end[((unsigned char) (c)) / BYTEWIDTH]	\
 |= 1 << (((unsigned char) c) % BYTEWIDTH))
 #ifdef MULE
 /* Set the "bit" for character C in a range table. */
 static void store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2);
 static void insert_op1 (re_opcode_t op, unsigned char *loc, int arg,
 			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 (const char *pattern, const char *p,
+static boolean at_begline_loc_p (re_char *pattern, re_char *p,
 				 reg_syntax_t syntax);
-static boolean at_endline_loc_p (const char *p, const char *pend, int syntax);
+static boolean at_endline_loc_p (re_char *p, re_char *pend, int syntax);
 static boolean group_in_compile_stack (compile_stack_type compile_stack,
 				       regnum_t regnum);
-static reg_errcode_t compile_range (const char **p_ptr, const char *pend,
+static reg_errcode_t compile_range (re_char **p_ptr, re_char *pend,
-				    char *translate, reg_syntax_t syntax,
+				    RE_TRANSLATE_TYPE translate,
+				    reg_syntax_t syntax,
 				    unsigned char *b);
 #ifdef MULE
-static reg_errcode_t compile_extended_range (const char **p_ptr,
+static reg_errcode_t compile_extended_range (re_char **p_ptr,
-					     const char *pend,
+					     re_char *pend,
-					     char *translate,
+					     RE_TRANSLATE_TYPE translate,
 					     reg_syntax_t syntax,
 					     Lisp_Object rtab);
 #endif /* MULE */
 static boolean group_match_null_string_p (unsigned char **p,
 					  unsigned char *end,
 					register_info_type *reg_info);
 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, char *translate);
+			   REGISTER int len, RE_TRANSLATE_TYPE translate);
 static int re_match_2_internal (struct re_pattern_buffer *bufp,
-				const char *string1, int size1,
+				re_char *string1, int size1,
-				const char *string2, int size2, int pos,
+				re_char *string2, int size2, int pos,
 				struct re_registers *regs, int stop);
 #ifndef MATCH_MAY_ALLOCATE
 /* If we cannot allocate large objects within re_match_2_internal,
 /* Size with which the following vectors are currently allocated.
 That is so we can make them bigger as needed,
 but never make them smaller.  */
 static int regs_allocated_size;
-static const char **     regstart, **     regend;
+static re_char **     regstart, **     regend;
-static const char ** old_regstart, ** old_regend;
+static re_char ** old_regstart, ** old_regend;
-static const char **best_regstart, **best_regend;
+static re_char **best_regstart, **best_regend;
 static register_info_type *reg_info;
-static const char **reg_dummy;
+static re_char **reg_dummy;
 static register_info_type *reg_info_dummy;
 /* Make the register vectors big enough for NUM_REGS registers,
 but don't make them smaller.  */
 static
 regex_grow_registers (int num_regs)
 {
 if (num_regs > regs_allocated_size)
 {
-RETALLOC_IF (regstart,	   num_regs, const char *);
+RETALLOC_IF (regstart,	   num_regs, re_char *);
-RETALLOC_IF (regend,	   num_regs, const char *);
+RETALLOC_IF (regend,	   num_regs, re_char *);
-RETALLOC_IF (old_regstart,   num_regs, const char *);
+RETALLOC_IF (old_regstart,   num_regs, re_char *);
-RETALLOC_IF (old_regend,	   num_regs, const char *);
+RETALLOC_IF (old_regend,	   num_regs, re_char *);
-RETALLOC_IF (best_regstart,  num_regs, const char *);
+RETALLOC_IF (best_regstart,  num_regs, re_char *);
-RETALLOC_IF (best_regend,	   num_regs, const char *);
+RETALLOC_IF (best_regend,	   num_regs, re_char *);
 RETALLOC_IF (reg_info,	   num_regs, register_info_type);
-RETALLOC_IF (reg_dummy,	   num_regs, const char *);
+RETALLOC_IF (reg_dummy,	   num_regs, re_char *);
 RETALLOC_IF (reg_info_dummy, num_regs, register_info_type);
 regs_allocated_size = num_regs;
 }
 }
 /* Return, freeing storage we allocated.  */
 #define FREE_STACK_RETURN(value)		\
 return (free (compile_stack.stack), value)
 static reg_errcode_t
-regex_compile (const char *pattern, int size, reg_syntax_t syntax,
+regex_compile (re_char *pattern, int size, reg_syntax_t syntax,
 	       struct re_pattern_buffer *bufp)
 {
 /* We fetch characters from PATTERN here.  We declare these as int
 (or possibly long) so that chars above 127 can be used as
 array indices.  The macros that fetch a character from the pattern
 get bitten by negative numbers here. */
 /* XEmacs change: used to be unsigned char. */
 REGISTER EMACS_INT c, c1;
 /* A random temporary spot in PATTERN.  */
-const char *p1;
+re_char *p1;
 /* Points to the end of the buffer, where we should append.  */
-REGISTER unsigned char *b;
+REGISTER unsigned char *buf_end;
 /* Keeps track of unclosed groups.  */
 compile_stack_type compile_stack;
 /* Points to the current (ending) position in the pattern.  */
-const char *p = pattern;
+re_char *p = pattern;
-const char *pend = pattern + size;
+re_char *pend = pattern + size;
 /* How to translate the characters in the pattern.  */
-char *translate = bufp->translate;
+RE_TRANSLATE_TYPE 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
 character can be added to that command or if the character requires
 a new `exactn' command.  */
 /* Address of beginning of regexp, or inside of last group.  */
 unsigned char *begalt;
 /* Place in the uncompiled pattern (i.e., the {) to
 which to go back if the interval is invalid.  */
-const char *beg_interval;
+re_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
 last -- ends with a forward jump of this sort.  */
 unsigned char *fixup_alt_jump = 0;
 if (!bufp->buffer) FREE_STACK_RETURN (REG_ESPACE);
 bufp->allocated = INIT_BUF_SIZE;
 }
-begalt = b = bufp->buffer;
+begalt = buf_end = bufp->buffer;
 /* Loop through the uncompiled pattern until we're at the end.  */
 while (p != pend)
 {
 PATFETCH (c);
 3: /jump to 9
 6: /exactn/1/A
 9: end of pattern.
 */
 GET_BUFFER_SPACE (6);
-INSERT_JUMP (jump, laststart, b + 3);
+INSERT_JUMP (jump, laststart, buf_end + 3);
-b += 3;
+buf_end += 3;
 INSERT_JUMP (on_failure_jump, laststart, laststart + 6);
-b += 3;
+buf_end += 3;
 }
 else if (zero_times_ok)
 {
 /* "a*?" becomes:
 0: /jump to 6
 3: /exactn/1/A
 6: /on_failure_jump to 3
 9: end of pattern.
 */
 GET_BUFFER_SPACE (6);
-INSERT_JUMP (jump, laststart, b + 3);
+INSERT_JUMP (jump, laststart, buf_end + 3);
-b += 3;
+buf_end += 3;
-STORE_JUMP (on_failure_jump, b, laststart + 3);
+STORE_JUMP (on_failure_jump, buf_end, laststart + 3);
-b += 3;
+buf_end += 3;
 }
 else
 {
 /* "a+?" becomes:
 0: /exactn/1/A
 3: /on_failure_jump to 0
 6: end of pattern.
 */
 GET_BUFFER_SPACE (3);
-STORE_JUMP (on_failure_jump, b, laststart);
+STORE_JUMP (on_failure_jump, buf_end, laststart);
-b += 3;
+buf_end += 3;
 }
 }
 else
 {
 /* Are we optimizing this jump?  */
 boolean keep_string_p = false;
 if (many_times_ok)
-{ /* More than one repetition is allowed, so put in at the
+{ /* More than one repetition is allowed, so put in
-end a backward relative jump from `b' to before the next
+at the end a backward relative jump from
-jump we're going to put in below (which jumps from
+`buf_end' to before the next jump we're going
-laststart to after this jump).
+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 .,
 instead of the beginning of the loop.  This way we only
 push a failure point once, instead of every time
 pattern, because laststart was nonzero.  And we've
 already incremented `p', by the way, to be the
 character after the `*'.  Do we have to do something
 analogous here for null bytes, because of
 RE_DOT_NOT_NULL? */
-if (TRANSLATE (*(p - 2)) == TRANSLATE ('.')
+if (*(p - 2) == '.'
 && zero_times_ok
-&& p < pend && TRANSLATE (*p) == TRANSLATE ('\n')
+&& p < pend && *p == '\n'
 && !(syntax & RE_DOT_NEWLINE))
 { /* We have .*\n.  */
-STORE_JUMP (jump, b, laststart);
+STORE_JUMP (jump, buf_end, laststart);
 keep_string_p = true;
 }
 else
 /* Anything else.  */
-STORE_JUMP (maybe_pop_jump, b, laststart - 3);
+STORE_JUMP (maybe_pop_jump, buf_end, laststart - 3);
 /* We've added more stuff to the buffer.  */
-b += 3;
+buf_end += 3;
 }
-/* On failure, jump from laststart to b + 3, which will be the
+/* On failure, jump from laststart to buf_end + 3,
-end of the buffer after this jump is inserted.  */
+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, b + 3);
+laststart, buf_end + 3);
-b += 3;
+buf_end += 3;
 if (!zero_times_ok)
 {
 /* At least one repetition is required, so insert a
 `dummy_failure_jump' before the initial
 `on_failure_jump' instruction of the loop. This
 effects a skip over that instruction the first time
 we hit that loop.  */
 GET_BUFFER_SPACE (3);
 INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6);
-b += 3;
+buf_end += 3;
 }
 }
 pending_exact = 0;
 }
 	  break;
 	case '.':
-laststart = b;
+laststart = buf_end;
 BUF_PUSH (anychar);
 break;
 case '[':
 /* Ensure that we have enough space to push a charset: the
 opcode, the length count, and the bitset; 34 bytes in all.  */
 	    GET_BUFFER_SPACE (34);
-laststart = b;
+laststart = buf_end;
 /* We test `*p == '^' twice, instead of using an if
 statement, so we only need one BUF_PUSH.  */
 BUF_PUSH (*p == '^' ? charset_not : charset);
 if (*p == '^')
 /* Push the number of bytes in the bitmap.  */
 BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
 /* Clear the whole map.  */
-memset (b, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
+memset (buf_end, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
 /* charset_not matches newline according to a syntax bit.  */
-if ((re_opcode_t) b[-2] == charset_not
+if ((re_opcode_t) buf_end[-2] == charset_not
 && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
 SET_LIST_BIT ('\n');
 #ifdef MULE
 	  start_over_with_extended:
 	    if (has_extended_chars)
 	      {
 		/* There are extended chars here, which means we need to start
 		   over and shift to unified range-table format. */
-		if (b[-2] == charset)
+		if (buf_end[-2] == charset)
-		  b[-2] = charset_mule;
+		  buf_end[-2] = charset_mule;
 		else
-		  b[-2] = charset_mule_not;
+		  buf_end[-2] = charset_mule_not;
-		b--;
+		buf_end--;
 		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) b[-1] == charset_mule_not
+		if ((re_opcode_t) buf_end[-1] == charset_mule_not
 		    && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
 		  SET_EITHER_BIT ('\n');
 	      }
 #endif /* MULE */
 /* Read in characters and ranges, setting map bits.  */
 for (;;)
 {
 if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
-PATFETCH_EITHER (c);
+PATFETCH (c);
 #ifdef MULE
 		if (c >= 0x80 && !has_extended_chars)
 		  {
 		    has_extended_chars = 1;
 /* \ might escape characters inside [...] and [^...].  */
 if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
 {
 if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
-PATFETCH_EITHER (c1);
+PATFETCH (c1);
 #ifdef MULE
 		    if (c1 >= 0x80 && !has_extended_chars)
 		      {
 		        has_extended_chars = 1;
 		        goto start_over_with_extended;
 was a character: if this is a hyphen not at the
 beginning or the end of a list, then it's the range
 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;
 #ifdef MULE
 if (has_extended_chars)
 		      ret = compile_extended_range (&p, pend, translate,
 						    syntax, rtab);
 		    else
 #endif /* MULE */
-		      ret = compile_range (&p, pend, translate, syntax, b);
+		      ret = compile_range (&p, pend, translate, syntax, buf_end);
 if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
 }
 else if (p[0] == '-' && p[1] != ']')
 { /* This handles ranges made up of characters only.  */
 if (has_extended_chars)
 		      ret = compile_extended_range (&p, pend, translate,
 						    syntax, rtab);
 		    else
 #endif /* MULE */
-		      ret = compile_range (&p, pend, translate, syntax, b);
+		      ret = compile_range (&p, pend, translate, syntax, buf_end);
 if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
 }
 /* See if we're at the beginning of a possible character
 class.  */
 /* If pattern is `[[:'.  */
 if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
 for (;;)
 {
-			/* Do not do PATFETCH_EITHER() here.  We want
+			/* #### This code is unused.
-			   to just see if the bytes match particular
+			   Correctness is not checked after TRT
-			   strings, and we put them all back if not.
+			   table change.  */
-			   #### 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] = '\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 ch;
 	      {
 		/* We have a range table, not a bit vector. */
 		int bytes_needed =
 		  unified_range_table_bytes_needed (rtab);
 		GET_BUFFER_SPACE (bytes_needed);
-		unified_range_table_copy_data (rtab, b);
+		unified_range_table_copy_data (rtab, buf_end);
-		b += unified_range_table_bytes_used (b);
+		buf_end += unified_range_table_bytes_used (buf_end);
 		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) b[-1] > 0 && b[b[-1] - 1] == 0)
+while ((int) buf_end[-1] > 0 && buf_end[buf_end[-1] - 1] == 0)
-b[-1]--;
+buf_end[-1]--;
-b += b[-1];
+buf_end += buf_end[-1];
 	  }
 	  break;
 	case '(':
 {
 regnum_t r;
 if (!(syntax & RE_NO_SHY_GROUPS)
 && p != pend
-&& TRANSLATE(*p) == TRANSLATE('?'))
+&& *p == '?')
 {
 p++;
-PATFETCH(c);
+PATFETCH (c);
 switch (c)
 {
 case ':': /* shy groups */
 r = MAX_REGNUM + 1;
 break;
 whole pattern moves because of realloc, they will still
 be valid.  */
 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 = b - bufp->buffer;
+COMPILE_STACK_TOP.laststart_offset = buf_end - bufp->buffer;
 COMPILE_STACK_TOP.regnum = r;
 /* We will eventually replace the 0 with the number of
 groups inner to this one.  But do not push a
 start_memory for groups beyond the last one we can
 represent in the compiled pattern.  */
 if (r <= MAX_REGNUM)
 {
 COMPILE_STACK_TOP.inner_group_offset
-= b - bufp->buffer + 2;
+= buf_end - bufp->buffer + 2;
 BUF_PUSH_3 (start_memory, r, 0);
 }
 compile_stack.avail++;
 fixup_alt_jump = 0;
 laststart = 0;
-begalt = b;
+begalt = buf_end;
 /* 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.  */
 pending_exact = 0;
 }
 `push_dummy_failure' in `re_match_2'.  */
 BUF_PUSH (push_dummy_failure);
 /* 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, b - 1);
+STORE_JUMP (jump_past_alt, fixup_alt_jump, buf_end - 1);
 }
 /* See similar code for backslashed left paren above.  */
 if (COMPILE_STACK_EMPTY) {
 if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
 goto normal_char;
 /* 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, b + 6);
+INSERT_JUMP (on_failure_jump, begalt, buf_end + 6);
 pending_exact = 0;
-b += 3;
+buf_end += 3;
 /* The alternative before this one has a jump after it
 which gets executed if it gets matched.  Adjust that
 jump so it will jump to this alternative's analogous
 jump (put in below, which in turn will jump to the next
 three-byte space after `a'.  We'll put in the jump, set
 fixup_alt_jump to right after `b', and leave behind three
 bytes which we'll fill in when we get to after `c'.  */
 if (fixup_alt_jump)
-STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
+STORE_JUMP (jump_past_alt, fixup_alt_jump, buf_end);
 /* 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 = b;
+fixup_alt_jump = buf_end;
 GET_BUFFER_SPACE (3);
-b += 3;
+buf_end += 3;
 laststart = 0;
-begalt = b;
+begalt = buf_end;
 break;
 case '{':
 /* If \{ is a literal.  */
 if (!laststart)
 {
 if (syntax & RE_CONTEXT_INVALID_OPS)
 FREE_STACK_RETURN (REG_BADRPT);
 else if (syntax & RE_CONTEXT_INDEP_OPS)
-laststart = b;
+laststart = buf_end;
 else
 goto unfetch_interval;
 }
 /* If the upper bound is zero, don't want to succeed at
 all; jump from `laststart' to `b + 3', which will be
 the end of the buffer after we insert the jump.  */
 if (upper_bound == 0)
 {
 GET_BUFFER_SPACE (3);
-INSERT_JUMP (jump, laststart, b + 3);
+INSERT_JUMP (jump, laststart, buf_end + 3);
-b += 3;
+buf_end += 3;
 }
 /* Otherwise, we have a nontrivial interval.  When
 we're all done, the pattern will look like:
 set_number_at <jump count> <upper bound>
 though it will be set during matching by its
 attendant `set_number_at' (inserted next),
 because `re_compile_fastmap' needs to know.
 Jump to the `jump_n' we might insert below.  */
 INSERT_JUMP2 (succeed_n, laststart,
-b + 5 + (upper_bound > 1) * 5,
+buf_end + 5 + (upper_bound > 1) * 5,
 lower_bound);
-b += 5;
+buf_end += 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, b);
+insert_op2 (set_number_at, laststart, 5, lower_bound, buf_end);
-b += 5;
+buf_end += 5;
 if (upper_bound > 1)
 { /* More than one repetition is allowed, so
 append a backward jump to the `succeed_n'
 that starts this interval.
 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, b, laststart + 5,
+STORE_JUMP2 (jump_n, buf_end, laststart + 5,
 upper_bound - 1);
-b += 5;
+buf_end += 5;
 /* The location we want to set is the second
 parameter of the `jump_n'; that is `b-2' as
 an absolute address.  `laststart' will be
 the `set_number_at' we're about to insert;
 i.e., b - laststart.
 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, b - laststart,
+insert_op2 (set_number_at, laststart,
-upper_bound - 1, b);
+				     buf_end - laststart,
-b += 5;
+upper_bound - 1, buf_end);
+buf_end += 5;
 }
 }
 pending_exact = 0;
 beg_interval = NULL;
 }
 case '=':
 BUF_PUSH (at_dot);
 break;
 case 's':
-laststart = b;
+laststart = buf_end;
 PATFETCH (c);
 	      /* XEmacs addition */
 	      if (c >= 0x80 || syntax_spec_code[c] == 0377)
 		FREE_STACK_RETURN (REG_ESYNTAX);
 BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
 break;
 case 'S':
-laststart = b;
+laststart = buf_end;
 PATFETCH (c);
 	      /* XEmacs addition */
 	      if (c >= 0x80 || syntax_spec_code[c] == 0377)
 		FREE_STACK_RETURN (REG_ESYNTAX);
 BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]);
 break;
 #ifdef MULE
 /* 97.2.17 jhod merged in to XEmacs from mule-2.3 */
 	    case 'c':
-	      laststart = b;
+	      laststart = buf_end;
 	      PATFETCH_RAW (c);
 	      if (c < 32 || c > 127)
 		FREE_STACK_RETURN (REG_ECATEGORY);
 	      BUF_PUSH_2 (categoryspec, c);
 	      break;
 	    case 'C':
-	      laststart = b;
+	      laststart = buf_end;
 	      PATFETCH_RAW (c);
 	      if (c < 32 || c > 127)
 		FREE_STACK_RETURN (REG_ECATEGORY);
 	      BUF_PUSH_2 (notcategoryspec, c);
 	      break;
 #endif /* MULE */
 #endif /* emacs */
 case 'w':
-laststart = b;
+laststart = buf_end;
 BUF_PUSH (wordchar);
 break;
 case 'W':
-laststart = b;
+laststart = buf_end;
 BUF_PUSH (notwordchar);
 break;
 case '<':
 BUF_PUSH (endbuf);
 break;
 case '1': case '2': case '3': case '4': case '5':
 case '6': case '7': case '8': case '9':
-if (syntax & RE_NO_BK_REFS)
+	      {
-goto normal_char;
+		regnum_t reg;
+		if (syntax & RE_NO_BK_REFS)
-c1 = c - '0';
+		  goto normal_char;
-if (c1 > regnum)
+		reg = c - '0';
-FREE_STACK_RETURN (REG_ESUBREG);
+		if (reg > regnum)
-/* Can't back reference to a subexpression if inside of it.  */
+		  FREE_STACK_RETURN (REG_ESUBREG);
-if (group_in_compile_stack (compile_stack, c1))
-goto normal_char;
+		/* Can't back reference to a subexpression if inside of it.  */
+		if (group_in_compile_stack (compile_stack, reg))
-laststart = b;
+		  goto normal_char;
-BUF_PUSH_2 (duplicate, c1);
+		laststart = buf_end;
+		BUF_PUSH_2 (duplicate, reg);
+	      }
 break;
 case '+':
 case '?':
 	/* `p' points to the location after where `c' came from. */
 	normal_char:
 	  {
 	    /* XEmacs: modifications here for Mule. */
 	    /* `q' points to the beginning of the next char. */
-	    const char *q = p - 1;
+	    re_char *q = p;
-	    INC_CHARPTR (q);
 	    /* If no exactn currently being built.  */
 	    if (!pending_exact
 		/* If last exactn not at current position.  */
-		|| pending_exact + *pending_exact + 1 != b
+		|| pending_exact + *pending_exact + 1 != buf_end
 		/* We have only one byte following the exactn for the count. */
 		|| ((unsigned int) (*pending_exact + (q - p)) >=
 		    ((unsigned int) (1 << BYTEWIDTH) - 1))
 			? *q == '{'
 			: (q[0] == '\\' && q[1] == '{'))))
 	      {
 		/* Start building a new exactn.  */
-		laststart = b;
+		laststart = buf_end;
 		BUF_PUSH_2 (exactn, 0);
-		pending_exact = b - 1;
+		pending_exact = buf_end - 1;
 	      }
+#ifndef MULE
 	    BUF_PUSH (c);
 	    (*pending_exact)++;
+#else
-	    while (p < q)
+	    {
-	      {
+	      Bytecount bt_count;
-		PATFETCH (c);
+	      Bufbyte tmp_buf[MAX_EMCHAR_LEN];
-		BUF_PUSH (c);
+	      int i;
-		(*pending_exact)++;
-	      }
+	      bt_count = set_charptr_emchar (tmp_buf, c);
+	      for (i = 0; i < bt_count; i++)
+		{
+		  BUF_PUSH (tmp_buf[i]);
+		  (*pending_exact)++;
+		}
+	    }
+#endif
 	    break;
 	  }
 } /* switch (c) */
 } /* while p != pend */
 /* Through the pattern now.  */
 if (fixup_alt_jump)
-STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
+STORE_JUMP (jump_past_alt, fixup_alt_jump, buf_end);
 if (!COMPILE_STACK_EMPTY)
 FREE_STACK_RETURN (REG_EPAREN);
 /* If we don't want backtracking, force success
 BUF_PUSH (succeed);
 free (compile_stack.stack);
 /* We have succeeded; set the length of the buffer.  */
-bufp->used = b - bufp->buffer;
+bufp->used = buf_end - bufp->buffer;
 #ifdef DEBUG
 if (debug)
 {
 DEBUG_PRINT1 ("\nCompiled pattern: \n");
 	else
 	  fail_stack.stack
 	    = (fail_stack_elt_t *) realloc (fail_stack.stack,
 					    (fail_stack.size
 					     * sizeof (fail_stack_elt_t)));
-#endif /* not emacs */
+#endif /* emacs */
 }
 regex_grow_registers (num_regs);
 }
 #endif /* not MATCH_MAY_ALLOCATE */
 /* P points to just after a ^ in PATTERN.  Return true if that ^ comes
 after an alternative or a begin-subexpression.  We assume there is at
 least one character before the ^.  */
 static boolean
-at_begline_loc_p (const char *pattern, const char *p, reg_syntax_t syntax)
+at_begline_loc_p (re_char *pattern, re_char *p, reg_syntax_t syntax)
 {
-const char *prev = p - 2;
+re_char *prev = p - 2;
 boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
 return
 /* After a subexpression?  */
 (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
 /* The dual of at_begline_loc_p.  This one is for $.  We assume there is
 at least one character after the $, i.e., `P < PEND'.  */
 static boolean
-at_endline_loc_p (const char *p, const char *pend, int syntax)
+at_endline_loc_p (re_char *p, re_char *pend, int syntax)
 {
-const char *next = p;
+re_char *next = p;
 boolean next_backslash = *next == '\\';
-const char *next_next = p + 1 < pend ? p + 1 : 0;
+re_char *next_next = p + 1 < pend ? p + 1 : 0;
 return
 /* Before a subexpression?  */
 (syntax & RE_NO_BK_PARENS ? *next == ')'
 : next_backslash && next_next && *next_next == ')')
 We use these short variable names so we can use the same macros as
 `regex_compile' itself.  */
 static reg_errcode_t
-compile_range (const char **p_ptr, const char *pend, char *translate,
+compile_range (re_char **p_ptr, re_char *pend, RE_TRANSLATE_TYPE translate,
-	       reg_syntax_t syntax, unsigned char *b)
+	       reg_syntax_t syntax, unsigned char *buf_end)
 {
 unsigned this_char;
-const char *p = *p_ptr;
+re_char *p = *p_ptr;
 int range_start, range_end;
 if (p == pend)
 return REG_ERANGE;
 }
 #ifdef MULE
 static reg_errcode_t
-compile_extended_range (const char **p_ptr, const char *pend, char *translate,
+compile_extended_range (re_char **p_ptr, re_char *pend,
+			RE_TRANSLATE_TYPE translate,
 			reg_syntax_t syntax, Lisp_Object rtab)
 {
 Emchar this_char, range_start, range_end;
 const Bufbyte *p;
 	      bufp->can_be_null |= path_can_be_null;
 	      /* Reset for next path.  */
 	      path_can_be_null = true;
-	      p = fail_stack.stack[--fail_stack.avail].pointer;
+	      p = (unsigned char *) fail_stack.stack[--fail_stack.avail].pointer;
 	      continue;
 	    }
 	  else
 	    break;
 	  for (j = *p * BYTEWIDTH; j < 0x80; j++)
 fastmap[j] = 1;
 	  /* And all extended characters must be allowed, too. */
 	  for (j = 0x80; j < 0xA0; j++)
 	    fastmap[j] = 1;
-#else /* ! MULE */
+#else /* not 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))))
 fastmap[j] = 1;
 break;
 			  == Sword || multi_p)
 			fastmap[j] = 1;
 		    }
 		}
 	    }
-#else /* ! MULE */
+#else /* not 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;
 	case notsyntaxspec:
 	  k = *p++;
 			  != Sword || multi_p)
 			fastmap[j] = 1;
 		    }
 		}
 	    }
-#else /* ! MULE */
+#else /* not 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
 /* 97/2/17 jhod category patch */
 	case categoryspec:
 We return either the position in the strings at which the match was
 found, -1 if no match, or -2 if error (such as failure
 stack overflow).  */
 int
-re_search_2 (struct re_pattern_buffer *bufp, const char *string1,
+re_search_2 (struct re_pattern_buffer *bufp, const char *str1,
-	     int size1, const char *string2, int size2, int startpos,
+	     int size1, const char *str2, 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 char *translate = bufp->translate;
+REGISTER RE_TRANSLATE_TYPE translate = bufp->translate;
 int total_size = size1 + size2;
 int endpos = startpos + range;
 #ifdef REGEX_BEGLINE_CHECK
 int anchored_at_begline = 0;
 #endif
-const unsigned char *d;
+re_char *d;
 Charcount d_size;
 /* Check for out-of-range STARTPOS.  */
 if (startpos < 0 || startpos > total_size)
 return -1;
 	  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)
+	  if (TRANSLATE_P (translate))
-#ifdef MULE
+	    while (range > lim && *d != '\n')
-	    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);
 		range -= d_size;
 	      }
 	      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)
+	      if (TRANSLATE_P (translate))
-while (range > lim &&
+while (range > lim)
+		  {
 #ifdef MULE
-		       *d < 0x80 &&
+		    Emchar buf_ch;
-#endif
-		       !fastmap[(unsigned char)translate[*d]])
+		    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_size = charcount_to_bytecount (d, 1);
 		    range -= d_size;
 		    d += d_size; /* Speedier INC_CHARPTR(d) */
 		  }
 	      else
 	      startpos += irange - range;
 	    }
 	  else				/* Searching backwards.  */
 	    {
-	      unsigned char c = (size1 == 0 || startpos >= size1
+	      Emchar c = (size1 == 0 || startpos >= size1
-				 ? string2[startpos - size1]
+			  ? charptr_emchar (string2 + startpos - size1)
-				 : string1[startpos]);
+			  : charptr_emchar (string1 + startpos));
+	      c = TRANSLATE (c);
 #ifdef MULE
-	      if (c < 0x80 && !fastmap[(unsigned char) TRANSLATE (c)])
+	      if (!(c >= 0200 || fastmap[(unsigned char) c]))
+		goto advance;
 #else
-	      if (!fastmap[(unsigned char) TRANSLATE (c)])
+	      if (!fastmap[(unsigned char) c])
+		goto advance;
 #endif
-		goto advance;
 	    }
 	}
 /* If can't match the null string, and that's all we have left, fail.  */
 if (range >= 0 && startpos == total_size && fastmap
 FREE_VAR (best_regend);						\
 FREE_VAR (reg_info);						\
 FREE_VAR (reg_dummy);						\
 FREE_VAR (reg_info_dummy);						\
 } while (0)
-#else
+#else /* not MATCH_MAY_ALLOCATE */
 #define FREE_VARIABLES() ((void)0) /* Do nothing!  But inhibit gcc warning.  */
-#endif /* not MATCH_MAY_ALLOCATE */
+#endif /* 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
 we use only one byte in the pattern for the register number), we can
 use numbers larger than 255.  They must differ by 1, because of
 int
 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, string, size,
+int result = re_match_2_internal (bufp, NULL, 0, (re_char *) string, size,
 				    pos, regs, size);
 alloca (0);
 return result;
 }
 #endif /* not emacs */
 int
 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, string1, size1, string2, size2,
+int result = re_match_2_internal (bufp, (re_char *) string1, size1,
+				    (re_char *) 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, const char *string1,
+re_match_2_internal (struct re_pattern_buffer *bufp, re_char *string1,
-		     int size1, const char *string2, int size2, int pos,
+		     int size1, re_char *string2, int size2, int pos,
 		     struct re_registers *regs, int stop)
 {
 /* General temporaries.  */
 int mcnt;
 unsigned char *p1;
 int should_succeed; /* XEmacs change */
 /* Just past the end of the corresponding string.  */
-const char *end1, *end2;
+re_char *end1, *end2;
 /* Pointers into string1 and string2, just past the last characters in
 each to consider matching.  */
-const char *end_match_1, *end_match_2;
+re_char *end_match_1, *end_match_2;
 /* Where we are in the data, and the end of the current string.  */
-const char *d, *dend;
+re_char *d, *dend;
 /* Where we are in the pattern, and the end of the pattern.  */
 unsigned char *p = bufp->buffer;
 REGISTER unsigned char *pend = p + bufp->used;
 /* Mark the opcode just after a start_memory, so we can test for an
 empty subpattern when we get to the stop_memory.  */
-unsigned char *just_past_start_mem = 0;
+re_char *just_past_start_mem = 0;
 /* We use this to map every character in the string.  */
-char *translate = bufp->translate;
+RE_TRANSLATE_TYPE 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
 restart, regend, and reg_info for all registers corresponding to
 the subexpressions we're currently inside, plus the number of such
 regnum-th regstart pointer points to where in the pattern we began
 matching and the regnum-th regend points to right after where we
 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.  */
-const char **regstart, **regend;
+re_char **regstart, **regend;
 #endif
 /* If a group that's operated upon by a repetition operator fails to
 match anything, then the register for its start will need to be
 restored because it will have been set to wherever in the string we
 are when we last see its open-group operator.  Similarly for a
 register's end.  */
 #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
-const char **old_regstart, **old_regend;
+re_char **old_regstart, **old_regend;
 #endif
 /* The is_active field of reg_info helps us keep track of which (possibly
 nested) subexpressions we are currently in. The matched_something
 field of reg_info[reg_num] helps us tell whether or not we have
 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;
 #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
-const char **best_regstart, **best_regend;
+re_char **best_regstart, **best_regend;
 #endif
 /* Logically, this is `best_regend[0]'.  But we don't want to have to
 allocate space for that if we're not allocating space for anything
 else (see below).  Also, we never need info about register 0 for
 any of the other register vectors, and it seems rather a kludge to
 treat `best_regend' differently than the rest.  So we keep track of
 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.  */
-const char *match_end = NULL;
+re_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.  */
-const char **reg_dummy;
+re_char **reg_dummy;
 register_info_type *reg_info_dummy;
 #endif
 #ifdef DEBUG
 /* Counts the total number of registers pushed.  */
 there are groups, we include space for register 0 (the whole
 pattern), even though we never use it, since it simplifies the
 array indexing.  We should fix this.  */
 if (bufp->re_nsub)
 {
-regstart       = REGEX_TALLOC (num_regs, const char *);
+regstart       = REGEX_TALLOC (num_regs, re_char *);
-regend         = REGEX_TALLOC (num_regs, const char *);
+regend         = REGEX_TALLOC (num_regs, re_char *);
-old_regstart   = REGEX_TALLOC (num_regs, const char *);
+old_regstart   = REGEX_TALLOC (num_regs, re_char *);
-old_regend     = REGEX_TALLOC (num_regs, const char *);
+old_regend     = REGEX_TALLOC (num_regs, re_char *);
-best_regstart  = REGEX_TALLOC (num_regs, const char *);
+best_regstart  = REGEX_TALLOC (num_regs, re_char *);
-best_regend    = REGEX_TALLOC (num_regs, const char *);
+best_regend    = REGEX_TALLOC (num_regs, re_char *);
 reg_info       = REGEX_TALLOC (num_regs, register_info_type);
-reg_dummy      = REGEX_TALLOC (num_regs, const char *);
+reg_dummy      = REGEX_TALLOC (num_regs, re_char *);
 reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type);
 if (!(regstart && regend && old_regstart && old_regend && reg_info
 && best_regstart && best_regend && reg_dummy && reg_info_dummy))
 {
 REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
 IS_ACTIVE (reg_info[mcnt]) = 0;
 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)
 {
 string2 = string1;
 {
 d = string2 + pos - size1;
 dend = end_match_2;
 }
-DEBUG_PRINT1 ("The compiled pattern is: ");
+DEBUG_PRINT1 ("The compiled pattern is: \n");
 DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
 DEBUG_PRINT1 ("The string to match is: `");
 DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
 DEBUG_PRINT1 ("'\n");
 	  mcnt = *p++;
 DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);
 /* This is written out as an if-else so we don't waste time
 testing `translate' inside the loop.  */
-if (translate)
+if (TRANSLATE_P (translate))
 	    {
 	      do
 		{
+#ifdef MULE
+		  Emchar pat_ch, buf_ch;
+		  Bytecount pat_len;
 		  PREFETCH ();
-		  if (translate[(unsigned char) *d++] != (char) *p++)
+		  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++)
+goto fail;
+		  mcnt--;
+#endif
 		}
-	      while (--mcnt);
+	      while (mcnt > 0);
 	    }
 	  else
 	    {
 	      do
 		{
 		  PREFETCH ();
-		  if (*d++ != (char) *p++) goto fail;
+		  if (*d++ != *p++) goto fail;
 		}
 	      while (--mcnt);
 	    }
 	  SET_REGS_MATCHED ();
 break;
 	/* \<digit> has been turned into a `duplicate' command which is
 followed by the numeric value of <digit> as the register number.  */
 case duplicate:
 	  {
-	    REGISTER const char *d2, *dend2;
+	    REGISTER re_char *d2, *dend2;
 	    int regno = *p++;   /* Get which register to match against.  */
 	    DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);
 	    /* Can't back reference a group which we've never matched.  */
 if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
 if (mcnt > dend2 - d2)
 		  mcnt = dend2 - d2;
 		/* Compare that many; failure if mismatch, else move
 past them.  */
-		if (translate
+		if (TRANSLATE_P (translate)
 ? bcmp_translate ((unsigned char *) d,
 				      (unsigned char *) d2, mcnt, translate)
 : memcmp (d, d2, mcnt))
 		  goto fail;
 		d += mcnt, 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));
-PUSH_FAILURE_POINT (p + mcnt, (char *) 0, -2);
+PUSH_FAILURE_POINT (p + mcnt, (unsigned char *) 0, -2);
 break;
 	/* Uses of on_failure_jump:
 actual values.  Otherwise, we will restore only one
 register from the stack, since lowest will == highest in
 `pop_failure_point'.  */
 unsigned dummy_low_reg, dummy_high_reg;
 unsigned char *pdummy;
-const char *sdummy = NULL;
+re_char *sdummy = NULL;
 DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");
 POP_FAILURE_POINT (sdummy, pdummy,
 dummy_low_reg, dummy_high_reg,
 reg_dummy, reg_dummy, reg_info_dummy);
 something meaningless for pop_failure_jump to pop.  */
 case dummy_failure_jump:
 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, (char *) 0, -2);
+PUSH_FAILURE_POINT ((unsigned char *) 0, (unsigned char *) 0, -2);
 goto unconditional_jump;
 /* At the end of an alternative, we need to push a dummy failure
 point in case we are followed by a `pop_failure_jump', because
 requires that we match the `ab' alternative.  */
 case push_dummy_failure:
 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, (char *) 0, -2);
+PUSH_FAILURE_POINT ((unsigned char *) 0, (unsigned char *) 0, -2);
 break;
 /* Have to succeed matching what follows at least n times.
 After that, handle like `on_failure_jump'.  */
 case succeed_n:
 if (!WORDCHAR_P_UNSAFE ((int) (*d)))
 goto fail;
 SET_REGS_MATCHED ();
 d++;
 	  break;
-#endif /* not emacs */
+#endif /* emacs */
 default:
 abort ();
 	}
 continue;  /* Successfully executed one pattern command; keep going.  */
 /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
 bytes; nonzero otherwise.  */
 static int
-bcmp_translate (const unsigned char *s1, const unsigned char *s2,
+bcmp_translate (re_char *s1, re_char *s2,
-		REGISTER int len, char *translate)
+		REGISTER int len, RE_TRANSLATE_TYPE 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 */
 while (len)
 {
-if (translate[*p1++] != translate[*p2++]) return 1;
+if (RE_TRANSLATE (*p1++) != RE_TRANSLATE (*p2++)) return 1;
 len--;
 }
+#endif /* MULE */
 return 0;
 }
 /* Entry points for GNU code.  */
 bufp->no_sub = 0;
 /* Match anchors at newline.  */
 bufp->newline_anchor = 1;
-ret = regex_compile (pattern, length, re_syntax_options, bufp);
+ret = regex_compile ((unsigned char *) pattern, length, re_syntax_options, bufp);
 if (!ret)
 return NULL;
 return gettext (re_error_msgid[(int) ret]);
 }
 don't need to initialize the pattern buffer fields which affect it.  */
 /* Match anchors at newlines.  */
 re_comp_buf.newline_anchor = 1;
-ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
+ret = regex_compile ((unsigned char *)s, strlen (s), re_syntax_options, &re_comp_buf);
 if (!ret)
 return NULL;
 /* Yes, we're discarding `const' here if !HAVE_LIBINTL.  */
 preg->no_sub = !!(cflags & REG_NOSUB);
 /* POSIX says a null character in the pattern terminates it, so we
 can use strlen here in compiling the pattern.  */
-ret = regex_compile (pattern, strlen (pattern), syntax, preg);
+ret = regex_compile ((unsigned char *) pattern, strlen (pattern), syntax, preg);
 /* POSIX doesn't distinguish between an unmatched open-group and an
 unmatched close-group: both are REG_EPAREN.  */
 if (ret == REG_ERPAREN) ret = REG_EPAREN;

Mercurial > hg > xemacs-beta

comparison src/regex.c @ 446:1ccc32a20af4 r21-2-38