emacs: src/regex.c comparison

comparison src/regex.c @ 90054:f2ebccfa87d4

Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-74 Merge from emacs--cvs-trunk--0 Patches applied: * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-709 Update from CVS: src/indent.c (Fvertical_motion): Fix last change. * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-710 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-715 Update from CVS * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-716 Merge from gnus--rel--5.10 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-74 Update from CVS

author	Miles Bader <miles@gnu.org>
date	Wed, 08 Dec 2004 05:02:30 +0000
parents	0fe073a08cef 5f1c0193e984
children	eac554634bfa

comparison

equal deleted inserted replaced

-:fff5f1a61d92
+:f2ebccfa87d4
 The argument SYNTAX is a bit mask comprised of the various bits
 defined in regex.h.  We return the old syntax.  */
 reg_syntax_t
 re_set_syntax (syntax)
 reg_syntax_t syntax;
 {
 reg_syntax_t ret = re_syntax_options;
 re_syntax_options = syntax;
 return ret;
+}
+WEAK_ALIAS (__re_set_syntax, re_set_syntax)
+/* Regexp to use to replace spaces, or NULL meaning don't.  */
+static re_char *whitespace_regexp;
+void
+re_set_whitespace_regexp (regexp)
+re_char *regexp;
+{
+whitespace_regexp = regexp;
 }
 WEAK_ALIAS (__re_set_syntax, re_set_syntax)
 /* 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.
 #endif /* emacs */
 /* Get the next unsigned number in the uncompiled pattern.  */
 #define GET_UNSIGNED_NUMBER(num)					\
-do { if (p != pend)							\
+do {									\
-{									\
+if (p == pend)							\
-PATFETCH (c);							\
+FREE_STACK_RETURN (REG_EBRACE);					\
-if (c == ' ')							\
+else								\
-	 FREE_STACK_RETURN (REG_BADBR);					\
+{									\
-while ('0' <= c && c <= '9')					\
+	PATFETCH (c);							\
-	 {								\
+	while ('0' <= c && c <= '9')					\
-int prev;							\
+	  {								\
-	   if (num < 0)							\
+	    int prev;							\
-	     num = 0;							\
+	    if (num < 0)						\
-	   prev = num;							\
+	      num = 0;							\
-	   num = num * 10 + c - '0';					\
+	    prev = num;							\
-	   if (num / 10 != prev)					\
+	    num = num * 10 + c - '0';					\
-	     FREE_STACK_RETURN (REG_BADBR);				\
+	    if (num / 10 != prev)					\
-	   if (p == pend)						\
+	      FREE_STACK_RETURN (REG_BADBR);				\
-	     break;							\
+	    if (p == pend)						\
-	   PATFETCH (c);						\
+	      FREE_STACK_RETURN (REG_EBRACE);				\
-	 }								\
+	    PATFETCH (c);						\
-if (c == ' ')							\
+	  }								\
-	 FREE_STACK_RETURN (REG_BADBR);					\
+}									\
-}								\
+} while (0)
-} while (0)
 #if ! WIDE_CHAR_SUPPORT
 /* Map a string to the char class it names (if any).  */
 re_wctype_t
 const boolean multibyte = RE_MULTIBYTE_P (bufp);
 /* If a target of matching can contain multibyte characters.  */
 const boolean target_multibyte = RE_TARGET_MULTIBYTE_P (bufp);
+/* Nonzero if we have pushed down into a subpattern.  */
+int in_subpattern = 0;
+/* These hold the values of p, pattern, and pend from the main
+pattern when we have pushed into a subpattern.  */
+re_char *main_p;
+re_char *main_pattern;
+re_char *main_pend;
 #ifdef DEBUG
 debug++;
 DEBUG_PRINT1 ("\nCompiling pattern: ");
 if (debug > 0)
 {
 }
 begalt = b = bufp->buffer;
 /* Loop through the uncompiled pattern until we're at the end.  */
-while (p != pend)
+while (1)
 {
+if (p == pend)
+	{
+	  /* If this is the end of an included regexp,
+	     pop back to the main regexp and try again.  */
+	  if (in_subpattern)
+	    {
+	      in_subpattern = 0;
+	      pattern = main_pattern;
+	      p = main_p;
+	      pend = main_pend;
+	      continue;
+	    }
+	  /* If this is the end of the main regexp, we are done.  */
+	  break;
+	}
 PATFETCH (c);
 switch (c)
 	{
+	case ' ':
+	  {
+	    re_char *p1 = p;
+	    /* If there's no special whitespace regexp, treat
+	       spaces normally.  And don't try to do this recursively.  */
+	    if (!whitespace_regexp || in_subpattern)
+	      goto normal_char;
+	    /* Peek past following spaces.  */
+	    while (p1 != pend)
+	      {
+		if (*p1 != ' ')
+		  break;
+		p1++;
+	      }
+	    /* If the spaces are followed by a repetition op,
+	       treat them normally.  */
+	    if (p1 != pend
+		&& (*p1 == '*' || *p1 == '+' || *p1 == '?'
+		    || (*p1 == '\\' && p1 + 1 != pend && p1[1] == '{')))
+	      goto normal_char;
+	    /* Replace the spaces with the whitespace regexp.  */
+	    in_subpattern = 1;
+	    main_p = p1;
+	    main_pend = pend;
+	    main_pattern = pattern;
+	    p = pattern = whitespace_regexp;
+	    pend = p + strlen (p);
+	    break;
+	  }
 	case '^':
 	  {
 	    if (   /* If at start of pattern, it's an operator.	 */
 		   p == pattern + 1
 		   /* If context independent, it's an operator.	 */
 		/* At least (most) this many matches must be made.  */
 		int lower_bound = 0, upper_bound = -1;
 		beg_interval = p;
-		if (p == pend)
-		  FREE_STACK_RETURN (REG_EBRACE);
 		GET_UNSIGNED_NUMBER (lower_bound);
 		if (c == ',')
 		  GET_UNSIGNED_NUMBER (upper_bound);
 		else
 		if (!(syntax & RE_NO_BK_BRACES))
 		  {
 		    if (c != '\\')
 		      FREE_STACK_RETURN (REG_BADBR);
+		    if (p == pend)
+		      FREE_STACK_RETURN (REG_EESCAPE);
 		    PATFETCH (c);
 		  }
 		if (c != '}')
 		  FREE_STACK_RETURN (REG_BADBR);

Mercurial > emacs

comparison src/regex.c @ 90054:f2ebccfa87d4