xemacs-beta: src/regex.c comparison

comparison src/regex.c @ 412:697ef44129c6 r21-2-14

Import from CVS: tag r21-2-14

author	cvs
date	Mon, 13 Aug 2007 11:20:41 +0200
parents	2f8bb876ab1d
children

comparison

equal deleted inserted replaced

-:12e008d41344
+:697ef44129c6
 {
 static int done = 0;
 if (!done)
 {
-const char *word_syntax_chars =
+CONST char *word_syntax_chars =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_";
 memset (re_syntax_table, 0, sizeof (re_syntax_table));
 while (*word_syntax_chars)
 if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
 #define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))
 #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))
 /* and maybe the category table? */
 }
 static void
-print_double_string (const char *where, const char *string1, int size1,
+print_double_string (CONST char *where, CONST char *string1, int size1,
-		     const char *string2, int size2)
+		     CONST char *string2, int size2)
 {
 if (where == NULL)
 printf ("(null)");
 else
 {
 /* This table gives an error message for each of the error codes listed
 in regex.h.  Obviously the order here has to be same as there.
 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 */
 "Invalid regular expression",			/* REG_BADPAT */
 "Invalid collation character",		/* REG_ECOLLATE */
 #define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\
 {									\
 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 ());					\
 									\
 /* Remove failure points and point to how many regs pushed.  */	\
 DEBUG_PRINT1 ("POP_FAILURE_POINT:\n");				\
 /* 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 = (CONST char *) 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] = (CONST char *) POP_FAILURE_POINTER ();		\
 DEBUG_PRINT2 ("      end: 0x%lx\n", (long) regend[this_reg]);	\
 									\
-regstart[this_reg] = (const char *) POP_FAILURE_POINTER ();	\
+regstart[this_reg] = (CONST char *) POP_FAILURE_POINTER ();	\
 DEBUG_PRINT2 ("      start: 0x%lx\n", (long) regstart[this_reg]);	\
 }									\
 									\
 set_regs_matched_done = 0;						\
 DEBUG_STATEMENT (nfailure_points_popped++);				\
 #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 && 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 PATUNFETCH_EXTENDED DEC_CHARPTR (p)
 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 (CONST char *pattern, CONST 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 (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 (const char **p_ptr, const char *pend,
+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 (const char **p_ptr,
+static reg_errcode_t compile_extended_range (CONST char **p_ptr,
-					     const char *pend,
+					     CONST char *pend,
 					     char *translate,
 					     reg_syntax_t syntax,
 					     Lisp_Object rtab);
 #endif /* MULE */
 static boolean group_match_null_string_p (unsigned char **p,
 static boolean alt_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,
+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,
-				const char *string1, int size1,
+				CONST char *string1, int size1,
-				const char *string2, int size2, int pos,
+				CONST 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 CONST char **     regstart, **     regend;
-static const char ** old_regstart, ** old_regend;
+static CONST char ** old_regstart, ** old_regend;
-static const char **best_regstart, **best_regend;
+static CONST char **best_regstart, **best_regend;
 static register_info_type *reg_info;
-static const 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,
 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, CONST char *);
-RETALLOC_IF (regend,	   num_regs, const char *);
+RETALLOC_IF (regend,	   num_regs, CONST char *);
-RETALLOC_IF (old_regstart,   num_regs, const char *);
+RETALLOC_IF (old_regstart,   num_regs, CONST char *);
-RETALLOC_IF (old_regend,	   num_regs, const char *);
+RETALLOC_IF (old_regend,	   num_regs, CONST char *);
-RETALLOC_IF (best_regstart,  num_regs, const char *);
+RETALLOC_IF (best_regstart,  num_regs, CONST char *);
-RETALLOC_IF (best_regend,	   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, const 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, 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 (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
 (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;
+CONST char *p1;
 /* Points to the end of the buffer, where we should append.  */
 REGISTER unsigned char *b;
 /* Keeps track of unclosed groups.  */
 compile_stack_type compile_stack;
 /* Points to the current (ending) position in the pattern.  */
-const char *p = pattern;
+CONST char *p = pattern;
-const char *pend = pattern + size;
+CONST char *pend = pattern + size;
 /* How to translate the characters in the pattern.  */
 char *translate = bufp->translate;
 /* Address of the count-byte of the most recently inserted `exactn'
 /* 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;
+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
 last -- ends with a forward jump of this sort.  */
 unsigned char *fixup_alt_jump = 0;
 }
 /* If we get here, we found another repeat character.  */
 if (!(syntax & RE_NO_MINIMAL_MATCHING))
 {
-/* "*?" and "+?" and "??" are okay (and mean match
+/* `*?' and `+?' and `??' are okay (and mean match
-minimally), but other sequences (such as "*??" and
+minimally), but other sequences (such as `*??' and
-"+++") are rejected (reserved for future use). */
+`+++') are rejected (reserved for future use). */
 if (minimal || c != '?')
 FREE_STACK_RETURN (REG_BADRPT);
 minimal = true;
 }
 else
 			   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:`]':
 undo the ending character, the letters, and leave
 	/* `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;
+	    CONST char *q = p - 1;
 	    INC_CHARPTR (q);
 	    /* If no exactn currently being built.  */
 	    if (!pending_exact
 /* 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 (CONST char *pattern, CONST char *p, reg_syntax_t syntax)
 {
-const char *prev = p - 2;
+CONST 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 (CONST char *p, CONST char *pend, int syntax)
 {
-const char *next = p;
+CONST char *next = p;
 boolean next_backslash = *next == '\\';
-const char *next_next = p + 1 < pend ? p + 1 : 0;
+CONST 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 (CONST char **p_ptr, CONST char *pend, char *translate,
 	       reg_syntax_t syntax, unsigned char *b)
 {
 unsigned this_char;
-const char *p = *p_ptr;
+CONST char *p = *p_ptr;
 int range_start, range_end;
 if (p == pend)
 return REG_ERANGE;
 is set, the range endpoints will be negative if we fetch using a
 signed char *.
 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 *.  */
+/* The SVR4 compiler on the 3B2 had trouble with unsigned CONST char *.  */
-range_start = ((const unsigned char *) p)[-2];
+range_start = ((CONST unsigned char *) p)[-2];
-range_end   = ((const unsigned char *) p)[0];
+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.  */
 (*p_ptr)++;
 }
 #ifdef MULE
 static reg_errcode_t
-compile_extended_range (const char **p_ptr, const char *pend, char *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 */
 /* We also want to fetch the endpoints without translating them; the
 appropriate translation is done in the bit-setting loop below.  */
 /* Like re_search_2, below, but only one string is specified, and
 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,
 		      regs, size);
 }
 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 *string1,
-	     int size1, const char *string2, int size2, int startpos,
+	     int size1, CONST char *string2, int size2, int startpos,
 	     int range, struct re_registers *regs, int stop)
 {
 int val;
 REGISTER char *fastmap = bufp->fastmap;
 REGISTER char *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;
+CONST unsigned char *d;
 Charcount d_size;
 /* Check for out-of-range STARTPOS.  */
 if (startpos < 0 || startpos > total_size)
 return -1;
 {
 if (startpos > 0)
 	return -1;
 else
 	{
-	  d = ((const unsigned char *)
+	  d = ((CONST unsigned char *)
 	       (startpos >= size1 ? string2 - size1 : string1) + startpos);
 	    range = charcount_to_bytecount (d, 1);
 	}
 }
 	  int irange = range;
 	  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)
 	      int irange = range;
 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)
 advance:
 if (!range)
 	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;
 	  startpos += d_size;
 	}
 else
 	{
 	  /* 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);
 	  range += d_size;
 	  startpos -= d_size;
 #ifndef emacs   /* Emacs never uses this.  */
 /* 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, string, size,
 				    pos, regs, size);
 alloca (0);
 We return -1 if no match, -2 if an internal error (such as the
 failure stack overflowing).  Otherwise, we return the length of the
 matched substring.  */
 int
-re_match_2 (struct re_pattern_buffer *bufp, const char *string1,
+re_match_2 (struct re_pattern_buffer *bufp, CONST char *string1,
-	    int size1, const char *string2, int size2, int pos,
+	    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,
 				    pos, regs, stop);
 alloca (0);
 }
 /* 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, CONST char *string1,
-		     int size1, const char *string2, int size2, int pos,
+		     int size1, CONST 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;
+CONST 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;
+CONST char *end_match_1, *end_match_2;
 /* Where we are in the data, and the end of the current string.  */
-const char *d, *dend;
+CONST 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;
 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;
+CONST 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;
+CONST 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;
+CONST 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;
+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.  */
-const char **reg_dummy;
+CONST 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, CONST char *);
-regend         = REGEX_TALLOC (num_regs, const char *);
+regend         = REGEX_TALLOC (num_regs, CONST char *);
-old_regstart   = REGEX_TALLOC (num_regs, const char *);
+old_regstart   = REGEX_TALLOC (num_regs, CONST char *);
-old_regend     = REGEX_TALLOC (num_regs, const char *);
+old_regend     = REGEX_TALLOC (num_regs, CONST char *);
-best_regstart  = REGEX_TALLOC (num_regs, const char *);
+best_regstart  = REGEX_TALLOC (num_regs, CONST char *);
-best_regend    = 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, const 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
 && best_regstart && best_regend && reg_dummy && reg_info_dummy))
 {
 	    boolean not = (re_opcode_t) *(p - 1) == charset_mule_not;
 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)))
 	      not = !not;
 	/* \<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 CONST 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]))
 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;
+CONST 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);
 	    int result;
 	    if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
 	      result = 1;
 	    else
 	      {
-		const unsigned char *d_before =
+		CONST unsigned char *d_before =
-		  (const unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
+		  (CONST unsigned char *) POS_BEFORE_GAP_UNSAFE (d);
-		const unsigned char *d_after =
+		CONST unsigned char *d_after =
-		  (const unsigned char *) POS_AFTER_GAP_UNSAFE (d);
+		  (CONST unsigned char *) POS_AFTER_GAP_UNSAFE (d);
 		Emchar emch1, emch2;
 		DEC_CHARPTR (d_before);
 		emch1 = charptr_emchar (d_before);
 		emch2 = charptr_emchar (d_after);
 	    if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1)))
 	      break;
 	      */
-	    const unsigned char *dtmp =
+	    CONST unsigned char *dtmp =
-	      (const unsigned char *) POS_AFTER_GAP_UNSAFE (d);
+	      (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))
 	      break;
 	    goto fail;
 		&& (!WORDCHAR_P (d) || AT_STRINGS_END (d)))
 	      break;
 	      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;
 	    goto fail;
 	  }
 	  {
 	    int matches;
 	    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);
 	    INC_CHARPTR (d);
 	    if (matches != should_succeed)
 	  {
 	    Emchar emch;
 	    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))
 	      goto fail;
 	    SET_REGS_MATCHED ();
 /* 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 (CONST unsigned char *s1, CONST unsigned char *s2,
 		REGISTER int len, char *translate)
 {
-REGISTER const unsigned char *p1 = s1, *p2 = s2;
+REGISTER CONST unsigned char *p1 = s1, *p2 = s2;
 while (len)
 {
 if (translate[*p1++] != translate[*p2++]) return 1;
 len--;
 }
 Assumes the `allocated' (and perhaps `buffer') and `translate' fields
 are set in BUFP on entry.
 We call regex_compile to do the actual compilation.  */
-const char *
+CONST char *
-re_compile_pattern (const char *pattern, int length,
+re_compile_pattern (CONST char *pattern, int length,
 		    struct re_pattern_buffer *bufp)
 {
 reg_errcode_t ret;
 /* GNU code is written to assume at least RE_NREGS registers will be set
 /* BSD has one and only one pattern buffer.  */
 static struct re_pattern_buffer re_comp_buf;
 char *
-re_comp (const char *s)
+re_comp (CONST char *s)
 {
 reg_errcode_t ret;
 if (!s)
 {
 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);
 }
 #endif /* _REGEX_RE_COMP */
 It returns 0 if it succeeds, nonzero if it doesn't.  (See regex.h for
 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
 = (cflags & REG_EXTENDED) ?
 RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;
 string; if REG_NOTEOL is set, then $ does not match at the end.
 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;
 struct re_registers regs;
 regex_t private_preg;
 /* Returns a message corresponding to an error code, ERRCODE, returned
 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
 || errcode >= (sizeof (re_error_msgid) / sizeof (re_error_msgid[0])))
 /* Only error codes returned by the rest of the code should be passed

Mercurial > hg > xemacs-beta

comparison src/regex.c @ 412:697ef44129c6 r21-2-14