xemacs-beta: src/regex.c comparison

comparison src/regex.c @ 102:a145efe76779 r20-1b3

Import from CVS: tag r20-1b3

author	cvs
date	Mon, 13 Aug 2007 09:15:49 +0200
parents	6a378aca36af
children	cf808b4c4290

comparison

equal deleted inserted replaced

-:a0ec055d74dd
+:a145efe76779
 {
 return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
 		      regs, size);
 }
+#ifndef emacs
+/* Snarfed from src/lisp.h, needed for compiling [ce]tags. */
+# define bytecount_to_charcount(ptr, len) (len)
+# define charcount_to_bytecount(ptr, len) (len)
+typedef int Charcount;
+#endif
 /* Using the compiled pattern in BUFP->buffer, first tries to match the
 virtual concatenation of STRING1 and STRING2, starting first at index
 STARTPOS, then at STARTPOS + 1, and so on.
+With MULE, STARTPOS is a byte position, not a char position.  And the
+search will increment STARTPOS by the width of the current leading
+character.
 STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
 RANGE is how far to scan while trying to match.  RANGE = 0 means try
 only at STARTPOS; in general, the last start tried is STARTPOS +
 RANGE.
+With MULE, RANGE is a byte position, not a char position.  The last
+start tried is the character starting <= STARTPOS + RANGE.
 In REGS, return the indices of the virtual concatenation of STRING1
 and STRING2 that matched the entire BUFP->buffer and its contained
 subexpressions.
 if (startpos < 0 || startpos > total_size)
 return -1;
 /* Fix up RANGE if it might eventually take us outside
 the virtual concatenation of STRING1 and STRING2.  */
+#if 0
 if (endpos < -1)
 range = -1 - startpos;
+#else
+if (endpos < 0)
+range = 0 - startpos;
+#endif
 else if (endpos > total_size)
 range = total_size - startpos;
 /* If the search isn't to be a backwards one, don't waste time in a
 search for a pattern that must be anchored.  */
 	  range > 0)
 	{
 	  /* whose stupid idea was it anyway to make this
 	     function take two strings to match?? */
 	  int lim = 0;
-	  unsigned char *p;
+	  register CONST unsigned char *d;
 	  int irange = range;
 	  if (startpos < size1 && startpos + range >= size1)
 	    lim = range - (size1 - startpos);
-	  p = ((unsigned char *)
+	  d = ((CONST unsigned char *)
-	       &(startpos >= size1 ? string2 - size1 : string1)[startpos]);
+	       (startpos >= size1 ? string2 - size1 : string1) + startpos);
-	  p--;
+	  DEC_CHARPTR(d);
 	  if (translate)
-	    {
+#ifdef MULE
-	      while (range > lim && translate[*p++] != '\n')
+	    while (range > lim && (*d >= 0x80 || translate[*d] != '\n'))
-		range--;
+#else
-	    }
+	    while (range > lim && translate[*d] != '\n')
+#endif
+	      {
+		INC_CHARPTR(d);
+		range -= charcount_to_bytecount (d, 1);
+	      }
 	  else
-	    {
+	    while (range > lim && *d != '\n')
-	      while (range > lim && *p++ != '\n')
+	      {
-		range--;
+		INC_CHARPTR(d);
-	    }
+		range -= charcount_to_bytecount (d, 1);
+	      }
 	  startpos += irange - range;
 	}
 #endif /* REGEX_BEGLINE_CHECK */
 /* If a fastmap is supplied, skip quickly over characters that
 the first null string.  */
 if (fastmap && startpos < total_size && !bufp->can_be_null)
 	{
 	  if (range > 0)	/* Searching forwards.  */
 	    {
-	      register CONST char *d;
+	      register CONST unsigned char *d;
 	      register int lim = 0;
 	      int irange = range;
 if (startpos < size1 && startpos + range >= size1)
 lim = range - (size1 - startpos);
-	      d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
+	      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)
-while (range > lim
+#ifdef MULE
-&& !fastmap[(unsigned char)
+while (range > lim && *d < 0x80 && !fastmap[translate[*d]])
-				   translate[(unsigned char) *d++]])
+#else
-range--;
+while (range > lim && !fastmap[translate[*d]])
+#endif
+		  {
+		    range -= charcount_to_bytecount (d, 1);
+		    INC_CHARPTR(d);
+		  }
 	      else
-while (range > lim && !fastmap[(unsigned char) *d++])
+while (range > lim && !fastmap[*d])
-range--;
+		  {
+		    range -= charcount_to_bytecount (d, 1);
+		    INC_CHARPTR(d);
+		  }
 	      startpos += irange - range;
 	    }
 	  else				/* Searching backwards.  */
 	    {
-	      register char c = (size1 == 0 || startpos >= size1
+	      register unsigned char c = (size1 == 0 || startpos >= size1
-? string2[startpos - size1]
+					  ? string2[startpos - size1]
-: string1[startpos]);
+					  : string1[startpos]);
+#ifdef MULE
+	      if (c < 0x80 && !fastmap[(unsigned char) TRANSLATE (c)])
+#else
 	      if (!fastmap[(unsigned char) TRANSLATE (c)])
+#endif
 		goto advance;
 	    }
 	}
 /* If can't match the null string, and that's all we have left, fail.  */
 if (val == -2)
 	return -2;
 advance:
 if (!range)
-break;
+	break;
-else if (range > 0)
+else {
-{
+	register CONST unsigned char *d;
-range--;
+	Charcount d_size;
-startpos++;
-}
+	d = ((CONST unsigned char *)
-else
+	     (startpos >= size1 ? string2 - size1 : string1) + startpos);
-{
-range++;
+	if (range > 0)
-startpos--;
+	  {
-}
+	    d_size = charcount_to_bytecount (d, 1);
+	    range -= d_size;
+	    startpos += d_size;
+	  }
+	else
+	  {
+	    DEC_CHARPTR(d);
+	    d_size = charcount_to_bytecount (d, 1);
+	    range += d_size;
+	    startpos -= d_size;
+	  }
+}
 }
 return -1;
 } /* re_search_2 */
 /* Declarations and macros for re_match_2.  */
 #ifdef DEBUG
 		register unsigned char c
 = *p2 == (unsigned char) endline ? '\n' : p2[2];
 #endif
+#if 1
+/* dmoore@ucsd.edu - emacs 19.34 uses this: */
 if ((re_opcode_t) p1[3] == exactn
-		    && ! ((int) p2[1] * BYTEWIDTH > (int) p1[4]
+&& ! ((int) p2[1] * BYTEWIDTH > (int) p1[5]
-			  && (p2[1 + p1[4] / BYTEWIDTH]
+&& (p2[2 + p1[5] / BYTEWIDTH]
-			      & (1 << (p1[4] % BYTEWIDTH)))))
+& (1 << (p1[5] % BYTEWIDTH)))))
+#else
+if ((re_opcode_t) p1[3] == exactn
+&& ! ((int) p2[1] * BYTEWIDTH > (int) p1[4]
+&& (p2[1 + p1[4] / BYTEWIDTH]
+& (1 << (p1[4] % BYTEWIDTH)))))
+#endif
 {
 		    p[-3] = (unsigned char) pop_failure_jump;
 DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
 c, p1[5]);
 }

Mercurial > hg > xemacs-beta

comparison src/regex.c @ 102:a145efe76779 r20-1b3