get back to glibc regex

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-1
cleanup match_ctx_clean

2004-10-27  Paolo Bonzini  <bonzini@gnu.org>

	* posix/regexec.c (match_ctx_free_subtops): Remove, merge into...
	(match_ctx_clean): ... this function.
	(match_ctx_free): Call match_ctx_clean.

diff -ru lib_mio/regexec.c lib/regexec.c
--- lib_mio/regexec.c	2004-10-27 13:03:14.000000000 +0200
+++ lib/regexec.c	2004-10-27 12:56:46.000000000 +0200
@@ -22,8 +22,6 @@
 				     int n) internal_function;
 static void match_ctx_clean (re_match_context_t *mctx) internal_function;
 static void match_ctx_free (re_match_context_t *cache) internal_function;
-static void match_ctx_free_subtops (re_match_context_t *mctx)
-     internal_function;
 static reg_errcode_t match_ctx_add_entry (re_match_context_t *cache, int node,
 					  int str_idx, int from, int to)
      internal_function;
@@ -4103,28 +4101,6 @@
 match_ctx_clean (mctx)
     re_match_context_t *mctx;
 {
-  match_ctx_free_subtops (mctx);
-  mctx->nsub_tops = 0;
-  mctx->nbkref_ents = 0;
-}
-
-/* Free all the memory associated with MCTX.  */
-
-static void
-match_ctx_free (mctx)
-    re_match_context_t *mctx;
-{
-  match_ctx_free_subtops (mctx);
-  re_free (mctx->sub_tops);
-  re_free (mctx->bkref_ents);
-}
-
-/* Free all the memory associated with MCTX->SUB_TOPS.  */
-
-static void
-match_ctx_free_subtops (mctx)
-     re_match_context_t *mctx;
-{
   int st_idx;
   for (st_idx = 0; st_idx < mctx->nsub_tops; ++st_idx)
     {
@@ -4144,6 +4118,21 @@
 	}
       free (top);
     }
+
+  mctx->nsub_tops = 0;
+  mctx->nbkref_ents = 0;
+}
+
+/* Free all the memory associated with MCTX.  */
+
+static void
+match_ctx_free (mctx)
+    re_match_context_t *mctx;
+{
+  /* First, free all the memory associated with MCTX->SUB_TOPS.  */
+  match_ctx_clean (mctx);
+  re_free (mctx->sub_tops);
+  re_free (mctx->bkref_ents);
 }

 /* Add a new backreference entry to MCTX.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-2
add branch predictions to re_string functions

2004-10-27  Paolo Bonzini  <bonzini@gnu.org>

	* posix/regex_internal.c (re_string_reconstruct,
	re_string_context_at): Add several branch predictions for
	case-sensitive matching and no transition table being used.

diff -ru lib_mio/regex_internal.c lib/regex_internal.c
--- lib_mio/regex_internal.c	2004-10-27 12:47:44.000000000 +0200
+++ lib/regex_internal.c	2004-10-27 12:51:22.000000000 +0200
@@ -577,7 +577,7 @@
      int idx, eflags;
 {
   int offset = idx - pstr->raw_mbs_idx;
-  if (offset < 0)
+  if (BE (offset < 0, 0))
     {
       /* Reset buffer.  */
 #ifdef RE_ENABLE_I18N
@@ -597,10 +597,10 @@
       offset = idx;
     }

-  if (offset != 0)
+  if (BE (offset != 0, 1))
     {
       /* Are the characters which are already checked remain?  */
-      if (offset < pstr->valid_raw_len
+      if (BE (offset < pstr->valid_raw_len, 1)
 #ifdef RE_ENABLE_I18N
 	  /* Handling this would enlarge the code too much.
 	     Accept a slowdown in that case.  */
@@ -615,7 +615,7 @@
 	    memmove (pstr->wcs, pstr->wcs + offset,
 		     (pstr->valid_len - offset) * sizeof (wint_t));
 #endif /* RE_ENABLE_I18N */
-	  if (pstr->mbs_allocated)
+	  if (BE (pstr->mbs_allocated, 0))
 	    memmove (pstr->mbs, pstr->mbs + offset,
 		     pstr->valid_len - offset);
 	  pstr->valid_len -= offset;
@@ -713,7 +713,7 @@
 				      ? CONTEXT_NEWLINE : 0));
 	    }
 	}
-      if (!pstr->mbs_allocated)
+      if (!BE (pstr->mbs_allocated, 0))
 	pstr->mbs += offset;
     }
   pstr->raw_mbs_idx = idx;
@@ -735,16 +735,17 @@
     }
   else
 #endif /* RE_ENABLE_I18N */
+  if (BE (pstr->mbs_allocated, 0))
     {
       if (pstr->icase)
 	build_upper_buffer (pstr);
       else if (pstr->trans != NULL)
 	re_string_translate_buffer (pstr);
-      else
-	pstr->valid_len = pstr->len;
     }
-  pstr->cur_idx = 0;
+  else
+    pstr->valid_len = pstr->len;

+  pstr->cur_idx = 0;
   return REG_NOERROR;
 }

@@ -842,16 +843,13 @@
      int idx, eflags;
 {
   int c;
-  if (idx < 0 || idx == input->len)
-    {
-      if (idx < 0)
-	/* In this case, we use the value stored in input->tip_context,
-	   since we can't know the character in input->mbs[-1] here.  */
-	return input->tip_context;
-      else /* (idx == input->len) */
-	return ((eflags & REG_NOTEOL) ? CONTEXT_ENDBUF
-		: CONTEXT_NEWLINE | CONTEXT_ENDBUF);
-    }
+  if (BE (idx < 0, 0))
+    /* In this case, we use the value stored in input->tip_context,
+       since we can't know the character in input->mbs[-1] here.  */
+    return input->tip_context;
+  if (BE (idx == input->len, 0))
+    return ((eflags & REG_NOTEOL) ? CONTEXT_ENDBUF
+	    : CONTEXT_NEWLINE | CONTEXT_ENDBUF);
 #ifdef RE_ENABLE_I18N
   if (input->mb_cur_max > 1)
     {

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-3
speedup fastmap searching, special casing forward searches

2004-10-27  Paolo Bonzini  <bonzini@gnu.org>

	* posix/regexec.c (acquire_init_state_context): Do not
	always inline.
	(transit_state): Remove the check for out-of-bounds buffers.
	(check_matching): Check here for out-of-bounds buffers.
	(re_search_internal): Store into match_kind a set of bits
	indicating which incantation of fastmap scanning must be
	used.  Use a switch statement instead of multiple ifs.
	Exit the final "for (;;)" with goto free_return unless
	the match succeeded, thus simplifying some conditionals.

diff -ru lib_mio/regexec.c lib/regexec.c
*** lib_mio/regexec.c	2004-10-27 13:03:14.000000000 +0200
--- lib/regexec.c	2004-10-27 12:56:46.000000000 +0200
***************
*** 57,63 ****
  			      int nregs, int regs_allocated) internal_function;
  static inline re_dfastate_t *acquire_init_state_context
       (reg_errcode_t *err, const re_match_context_t *mctx, int idx)
!      __attribute ((always_inline)) internal_function;
  static reg_errcode_t prune_impossible_nodes (re_match_context_t *mctx)
       internal_function;
  static int check_matching (re_match_context_t *mctx, int fl_longest_match,
--- 55,61 ----
  			      int nregs, int regs_allocated) internal_function;
  static inline re_dfastate_t *acquire_init_state_context
       (reg_errcode_t *err, const re_match_context_t *mctx, int idx)
!      internal_function;
  static reg_errcode_t prune_impossible_nodes (re_match_context_t *mctx)
       internal_function;
  static int check_matching (re_match_context_t *mctx, int fl_longest_match,
***************
*** 603,617 ****
    reg_errcode_t err;
    re_dfa_t *dfa = (re_dfa_t *)preg->buffer;
    int left_lim, right_lim, incr;
!   int fl_longest_match, match_first, match_last = -1;
!   int fast_translate, sb;
  #if defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
    re_match_context_t mctx = { .dfa = dfa };
  #else
    re_match_context_t mctx;
  #endif
!   char *fastmap = ((preg->fastmap != NULL && preg->fastmap_accurate
! 		    && range && !preg->can_be_null) ? preg->fastmap : NULL);

  #if !(defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L))
    memset (&mctx, '\0', sizeof (re_match_context_t));
--- 601,616 ----
    reg_errcode_t err;
    re_dfa_t *dfa = (re_dfa_t *)preg->buffer;
    int left_lim, right_lim, incr;
!   int fl_longest_match, match_first, match_kind, match_last = -1;
!   int fast_translate, sb, ch;
  #if defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
    re_match_context_t mctx = { .dfa = dfa };
  #else
    re_match_context_t mctx;
  #endif
!   char *fastmap = (preg->fastmap != NULL && preg->fastmap_accurate
! 		   && range && !preg->can_be_null) ? preg->fastmap : NULL;
!   unsigned RE_TRANSLATE_TYPE t = (unsigned RE_TRANSLATE_TYPE) preg->translate;

  #if !(defined _LIBC || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L))
    memset (&mctx, '\0', sizeof (re_match_context_t));
***************
*** 684,771 ****
    left_lim = (range < 0) ? start + range : start;
    right_lim = (range < 0) ? start : start + range;
    sb = dfa->mb_cur_max == 1;
!   fast_translate = sb || !(preg->syntax & RE_ICASE || preg->translate);

!   for (;;)
      {
!       /* At first get the current byte from input string.  */
!       if (fastmap)
! 	{
! 	  if (BE (fast_translate, 1))
! 	    {
! 	      unsigned RE_TRANSLATE_TYPE t
! 		= (unsigned RE_TRANSLATE_TYPE) preg->translate;
! 	      if (BE (range >= 0, 1))
! 		{
! 		  if (BE (t != NULL, 0))
! 		    {
! 		      while (BE (match_first < right_lim, 1)
! 			     && !fastmap[t[(unsigned char) string[match_first]]])
! 			++match_first;
! 		    }
! 		  else
! 		    {
! 		      while (BE (match_first < right_lim, 1)
! 			     && !fastmap[(unsigned char) string[match_first]])
! 			++match_first;
! 		    }
! 		  if (BE (match_first == right_lim, 0))
! 		    {
! 		      int ch = match_first >= length
! 			       ? 0 : (unsigned char) string[match_first];
! 		      if (!fastmap[t ? t[ch] : ch])
! 			break;
! 		    }
! 		}
! 	      else
! 		{
! 		  while (match_first >= left_lim)
! 		    {
! 		      int ch = match_first >= length
! 			       ? 0 : (unsigned char) string[match_first];
! 		      if (fastmap[t ? t[ch] : ch])
! 			break;
! 		      --match_first;
! 		    }
! 		  if (match_first < left_lim)
! 		    break;
! 		}
  	    }
! 	  else
! 	    {
! 	      int ch;

! 	      do
  		{
! 		  /* In this case, we can't determine easily the current byte,
! 		     since it might be a component byte of a multibyte
! 		     character.  Then we use the constructed buffer
! 		     instead.  */
! 		  /* If MATCH_FIRST is out of the valid range, reconstruct the
! 		     buffers.  */
! 		  if (mctx.input.raw_mbs_idx + mctx.input.valid_raw_len
! 		      <= match_first
! 		      || match_first < mctx.input.raw_mbs_idx)
! 		    {
! 		      err = re_string_reconstruct (&mctx.input, match_first,
! 						   eflags);
! 		      if (BE (err != REG_NOERROR, 0))
! 			goto free_return;
! 		    }
! 		  /* If MATCH_FIRST is out of the buffer, leave it as '\0'.
! 		     Note that MATCH_FIRST must not be smaller than 0.  */
! 		  ch = ((match_first >= length) ? 0
! 		       : re_string_byte_at (&mctx.input,
! 					    match_first
! 					    - mctx.input.raw_mbs_idx));
! 		  if (fastmap[ch])
! 		    break;
! 		  match_first += incr;
  		}
! 	      while (match_first >= left_lim && match_first <= right_lim);
! 	      if (! fastmap[ch])
  		break;
  	    }
  	}

        /* Reconstruct the buffers so that the matcher can assume that
--- 683,781 ----
    left_lim = (range < 0) ? start + range : start;
    right_lim = (range < 0) ? start : start + range;
    sb = dfa->mb_cur_max == 1;
!   match_kind =
!     (fastmap ? 8 : 0)
!     | (sb || !(preg->syntax & RE_ICASE || t) ? 4 : 0)
!     | (range >= 0 ? 2 : 0)
!     | (t != NULL ? 1 : 0);

!   for (;; match_first += incr)
      {
!       err = REG_NOMATCH;
!       if (match_first < left_lim || right_lim < match_first)
! 	goto free_return;
!
!       /* Advance as rapidly as possible through the string, until we
! 	 find a plausible place to start matching.  This may be done
! 	 with varying efficiency, so there are various possibilities:
! 	 only the most common of them are specialized, in order to
! 	 save on code size.  We use a switch statement for speed.  */
!       switch (match_kind)
! 	{
! 	case 0: case 1: case 2: case 3:
! 	case 4: case 5: case 6: case 7:
! 	  /* No fastmap.  */
! 	  break;
!
! 	case 15:
! 	  /* Fastmap with single-byte translation, match forward.  */
! 	  while (BE (match_first < right_lim, 1)
! 		 && !fastmap[t[(unsigned char) string[match_first]]])
! 	    ++match_first;
! 	  goto forward_match_found_start_or_reached_end;
!
! 	case 14:
! 	  /* Fastmap without translation, match forward.  */
! 	  while (BE (match_first < right_lim, 1)
! 		 && !fastmap[(unsigned char) string[match_first]])
! 	    ++match_first;
!
! 	forward_match_found_start_or_reached_end:
! 	  if (BE (match_first == right_lim, 0))
! 	    {
! 	      ch = match_first >= length
! 		       ? 0 : (unsigned char) string[match_first];
! 	      if (!fastmap[t ? t[ch] : ch])
! 		goto free_return;
  	    }
! 	  break;

! 	case 12:
! 	case 13:
! 	  /* Fastmap without multi-byte translation, match backwards.  */
! 	  while (match_first >= left_lim)
! 	    {
! 	      ch = match_first >= length
! 		       ? 0 : (unsigned char) string[match_first];
! 	      if (fastmap[t ? t[ch] : ch])
! 		break;
! 	      --match_first;
! 	    }
! 	  if (match_first < left_lim)
! 	    goto free_return;
! 	  break;
!
! 	default:
! 	  /* In this case, we can't determine easily the current byte,
! 	     since it might be a component byte of a multibyte
! 	     character.  Then we use the constructed buffer instead.  */
! 	  for (;;)
! 	    {
! 	      /* If MATCH_FIRST is out of the valid range, reconstruct the
! 		 buffers.  */
! 	      if (mctx.input.raw_mbs_idx + mctx.input.valid_raw_len <= match_first
! 		  || match_first < mctx.input.raw_mbs_idx)
  		{
! 		  err = re_string_reconstruct (&mctx.input, match_first,
! 					       eflags);
! 		  if (BE (err != REG_NOERROR, 0))
! 		    goto free_return;
  		}
! 	      /* If MATCH_FIRST is out of the buffer, leave it as '\0'.
! 		 Note that MATCH_FIRST must not be smaller than 0.  */
! 	      ch = ((match_first >= length) ? 0
! 		    : re_string_byte_at (&mctx.input,
! 					 match_first - mctx.input.raw_mbs_idx));
! 	      if (fastmap[ch])
  		break;
+ 	      match_first += incr;
+ 	      if (match_first < left_lim || match_first > right_lim)
+ 	        {
+ 	          err = REG_NOMATCH;
+ 	          goto free_return;
+ 	        }
  	    }
+ 	  break;
  	}

        /* Reconstruct the buffers so that the matcher can assume that
***************
*** 773,829 ****
        err = re_string_reconstruct (&mctx.input, match_first, eflags);
        if (BE (err != REG_NOERROR, 0))
  	goto free_return;
  #ifdef RE_ENABLE_I18N
!      /* Eliminate it when it is a component of a multibyte character
! 	 and isn't the head of a multibyte character.  */
!       if (sb || re_string_first_byte (&mctx.input, 0))
  #endif
  	{
! 	  /* It seems to be appropriate one, then use the matcher.  */
! 	  /* We assume that the matching starts from 0.  */
! 	  mctx.state_log_top = mctx.nbkref_ents = mctx.max_mb_elem_len = 0;
! 	  match_last = check_matching (&mctx, fl_longest_match,
! 				       range >= 0 ? &match_first : NULL);
! 	  if (match_last != -1)
  	    {
! 	      if (BE (match_last == -2, 0))
  		{
! 		  err = REG_ESPACE;
! 		  goto free_return;
  		}
! 	      else
  		{
! 		  mctx.match_last = match_last;
! 		  if ((!preg->no_sub && nmatch > 1) || dfa->nbackref)
! 		    {
! 		      re_dfastate_t *pstate = mctx.state_log[match_last];
! 		      mctx.last_node = check_halt_state_context (&mctx, pstate,
! 								 match_last);
! 		    }
! 		  if ((!preg->no_sub && nmatch > 1 && dfa->has_plural_match)
! 		      || dfa->nbackref)
! 		    {
! 		      err = prune_impossible_nodes (&mctx);
! 		      if (err == REG_NOERROR)
! 			break;
! 		      if (BE (err != REG_NOMATCH, 0))
! 			goto free_return;
! 		      match_last = -1;
! 		    }
! 		  else
! 		    break; /* We found a match.  */
  		}
  	    }
- 	  match_ctx_clean (&mctx);
  	}
!       /* Update counter.  */
!       match_first += incr;
!       if (match_first < left_lim || right_lim < match_first)
! 	break;
      }

    /* Set pmatch[] if we need.  */
!   if (match_last != -1 && nmatch > 0)
      {
        int reg_idx;

--- 783,842 ----
        err = re_string_reconstruct (&mctx.input, match_first, eflags);
        if (BE (err != REG_NOERROR, 0))
  	goto free_return;
+
  #ifdef RE_ENABLE_I18N
!      /* Don't consider this char as a possible match start if it part,
! 	yet isn't the head, of a multibyte character.  */
!       if (!sb && !re_string_first_byte (&mctx.input, 0))
! 	continue;
  #endif
+
+       /* It seems to be appropriate one, then use the matcher.  */
+       /* We assume that the matching starts from 0.  */
+       mctx.state_log_top = mctx.nbkref_ents = mctx.max_mb_elem_len = 0;
+       match_last = check_matching (&mctx, fl_longest_match,
+ 				   range >= 0 ? &match_first : NULL);
+       if (match_last != -1)
  	{
! 	  if (BE (match_last == -2, 0))
  	    {
! 	      err = REG_ESPACE;
! 	      goto free_return;
! 	    }
! 	  else
! 	    {
! 	      mctx.match_last = match_last;
! 	      if ((!preg->no_sub && nmatch > 1) || dfa->nbackref)
  		{
! 		  re_dfastate_t *pstate = mctx.state_log[match_last];
! 		  mctx.last_node = check_halt_state_context (&mctx, pstate,
! 							     match_last);
  		}
! 	      if ((!preg->no_sub && nmatch > 1 && dfa->has_plural_match)
! 		  || dfa->nbackref)
  		{
! 		  err = prune_impossible_nodes (&mctx);
! 		  if (err == REG_NOERROR)
! 		    break;
! 		  if (BE (err != REG_NOMATCH, 0))
! 		    goto free_return;
! 		  match_last = -1;
  		}
+ 	      else
+ 		break; /* We found a match.  */
  	    }
  	}
!
!       match_ctx_clean (&mctx);
      }

+ #ifdef DEBUG
+   assert (match_last != -1);
+   assert (err == REG_NOERROR);
+ #endif
+
    /* Set pmatch[] if we need.  */
!   if (nmatch > 0)
      {
        int reg_idx;

***************
*** 868,874 ****
  	    pmatch[reg_idx].rm_eo += match_first;
  	  }
      }
!   err = (match_last == -1) ? REG_NOMATCH : REG_NOERROR;
   free_return:
    re_free (mctx.state_log);
    if (dfa->nbackref)
--- 881,887 ----
  	    pmatch[reg_idx].rm_eo += match_first;
  	  }
      }
!
   free_return:
    re_free (mctx.state_log);
    if (dfa->nbackref)
***************
*** 1073,1078 ****
--- 1086,1105 ----
    while (!re_string_eoi (&mctx->input))
      {
        re_dfastate_t *old_state = cur_state;
+       int next_char_idx = re_string_cur_idx (&mctx->input) + 1;
+
+       if (BE (next_char_idx >= mctx->input.bufs_len, 0)
+           || (BE (next_char_idx >= mctx->input.valid_len, 0)
+               && mctx->input.valid_len < mctx->input.len))
+         {
+           err = extend_buffers (mctx);
+           if (BE (err != REG_NOERROR, 0))
+ 	    {
+ 	      assert (err == REG_ESPACE);
+ 	      return -2;
+ 	    }
+         }
+
        cur_state = transit_state (&err, mctx, cur_state);
        if (mctx->state_log != NULL)
  	cur_state = merge_state_with_log (&err, mctx, cur_state);
***************
*** 1091,1100 ****
  	    break;
  	}

!       if (at_init_state)
  	{
  	  if (old_state == cur_state)
! 	    next_start_idx = re_string_cur_idx (&mctx->input);
  	  else
  	    at_init_state = 0;
  	}
--- 1118,1127 ----
  	    break;
  	}

!       if (BE (at_init_state, 0))
  	{
  	  if (old_state == cur_state)
! 	    next_start_idx = next_char_idx;
  	  else
  	    at_init_state = 0;
  	}
***************
*** 1110,1122 ****
  	      /* We found an appropriate halt state.  */
  	      match_last = re_string_cur_idx (&mctx->input);
  	      match = 1;
  	      if (!fl_longest_match)
  		break;
  	    }
  	}
!    }

!   if (match_last == -1 && p_match_first)
      *p_match_first += next_start_idx;

    return match_last;
--- 1137,1152 ----
  	      /* We found an appropriate halt state.  */
  	      match_last = re_string_cur_idx (&mctx->input);
  	      match = 1;
+
+ 	      /* We found a match, do not modify match_first below.  */
+ 	      p_match_first = NULL;
  	      if (!fl_longest_match)
  		break;
  	    }
  	}
!     }

!   if (p_match_first)
      *p_match_first += next_start_idx;

    return match_last;
***************
*** 2171,2188 ****
    re_dfastate_t **trtable;
    unsigned char ch;

-   if (re_string_cur_idx (&mctx->input) + 1 >= mctx->input.bufs_len
-       || (re_string_cur_idx (&mctx->input) + 1 >= mctx->input.valid_len
- 	  && mctx->input.valid_len < mctx->input.len))
-     {
-       *err = extend_buffers (mctx);
-       if (BE (*err != REG_NOERROR, 0))
- 	return NULL;
-     }
-
  #ifdef RE_ENABLE_I18N
        /* If the current state can accept multibyte.  */
!       if (state->accept_mb)
  	{
  	  *err = transit_state_mb (mctx, state);
  	  if (BE (*err != REG_NOERROR, 0))
--- 2201,2209 ----
    re_dfastate_t **trtable;
    unsigned char ch;

  #ifdef RE_ENABLE_I18N
        /* If the current state can accept multibyte.  */
!       if (BE (state->accept_mb, 0))
  	{
  	  *err = transit_state_mb (mctx, state);
  	  if (BE (*err != REG_NOERROR, 0))

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-4
speedup transit_state

2004-10-27  Paolo Bonzini  <bonzini@gnu.org>

	* regex_internal.h (struct re_dfastate_t): Make
	word_trtable a pointer to the 512-item transition table.
	* regexec.c (build_trtable): Fill in either state->trtable
	or state->word_trtable.  Return a boolean indicating success.
	(transit_state): Expect state->trtable to be a 256-item
	transition table.  Reorganize code to have less tests in
	the common case, and to save an indentation level.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-5
fix builds with included gettext

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-6
fix out of srcdir build

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-7
fix build when _REGEX_RE_COMP is defined

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-8
always enable regex tests when included regex is used

2004-11-03  Paolo Bonzini  <bonzini@gnu

	* bug-regex11.c: Improve portability.
	* bug-regex12.c: Improve portability.
	* bug-regex13.c: Improve portability.
	* bug-regex14.c: Improve portability.
	* bug-regex21.c: Improve portability.
	* bug-regex9.c: Improve portability.
	* tst-boost.c: Improve portability.
	* tst-pcre.c: Improve portability.
	* tst-regex.c: Improve portability.
	* tst-rxspencer.c: Improve portability.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-9
regex dead code removal

2004-11-03  Paolo Bonzini  <bonzini@gnu.org>

	* regex_internal.h (struct re_backref_cache): Remove flag field.
	(struct re_sift_context_t): Remove cur_bkref, cls_subexp_idx,
	check_subexp fields.  Move limits last.
	* regex.c (match_ctx_clear_flag): Remove.
	(sift_ctx_init): Remove check_subexp parameter.  Do not set removed
	fields.  Callers adjusted.
	(expand_bkref_cache): Remove last_str parameter.  Callers adjusted.
	(re_search_internal): Remove fast_translate variable.
	(update_cur_sifted_state): Pass candidates as the final parameter
	to sift_states_bkref.
	(sift_states_bkref): Change last unused parameter to be "candidates",
	do not fetch candidates into a local variable.
	Remove dead test for "node == sctx->bkref", and the cur_bkref_idx
	variable.
	Remove loops that set/reset the flag field of backref cache entries.
	(check_arrival_add_next_nodes): Use a signed int to hold the return
	value of re_node_set_insert.
	(group_nodes_into_DFAstates): Likewise.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-10
Remove empty_set variable to speed up regexec.c

2004-11-03  Paolo Bonzini  <bonzini@gnu.org>

	* regexec.c (empty_set): Remove.
	(sift_states_backward): Remove cur_src variable.  Move inner loop
	to build_sifted_states.
	(build_sifted_states): Extract from sift_states_backward.  Do not
	use empty_set.
	(update_cur_sifted_state): Do not use empty_set.  Special case
	dest_nodes->nelem == 0.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-11
speedup regex by up to 50%

2004-11-03  Paolo Bonzini  <bonzini@gnu.org>

	* regex_internal.h (struct re_backref_cache_entry): Add "more" field.
	* regexec.c (check_dst_limits): Hoist computation of the source
	and destination bkref_idx out of the loop.  Pass it to
	check_dst_limits_calc_pos.
	(check_dst_limits_calc_pos_1): New function, containing the recursive
	loop of check_dst_limits_calc_pos; uses the "more" field of
	struct re_backref_cache to control the loop.
	(check_dst_limits_calc_pos): Store into "boundaries" the position
	relative to lim's start and end positions.  Do not accept eclosures,
	accept bkref_idx instead.  Call check_dst_limits_calc_pos_1 to do the
	work.
	(sift_states_bkref): Use the "more" field of struct re_backref_cache
	to control the loop.  A big "if" was turned into a continue and the
	function was reindented.
	(get_subexp): Use the "more" field of struct re_backref_cache
	to control the loop.
	(match_ctx_add_entry): Initialize the bkref_ents' "more" field.
	(search_cur_bkref_entry): Return -1 if out of bounds.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-12
remove ABOUT-NLS from archive

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-13
use utf8 optimizations outside glibc

2004-09-08  Paolo Bonzini  <bonzini@gnu.org>

	* regcomp.c (init_dfa): Get the codeset name outside glibc as
	well.  Check if it is spelled UTF8 as well as UTF-8, and check
	case-insensitively.  Set dfa->map_notascii manually when outside
	glibc.
	* regex_internal.c (build_wcs_upper_buffer) [!_LIBC]: Enable
	optimizations based on map_notascii.
	* regex_internal.h [HAVE_LANGINFO_H || HAVE_LANGINFO_CODESET
	|| _LIBC]: Include langinfo.h.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-14
add tagging conventions and fix configure for gettext 0.14

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-15
merge from glibc

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-16
cache result of check_dst_limits_calc_pos_1

2004-09-11  Paolo Bonzini  <bonzini@gnu.org>

	* posix/regex_internal.h (struct re_backref_cache_entry):
	Add a map of reachable subexpression nodes from each backreference
	cache entry.
	* posix/regexec.c (check_dst_limits_calc_pos_1): Use the map
	to cut recursive paths.  Make exit condition more precise.
	(match_ctx_add_entry): Initialize the map.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-17
more portability improvements

2004-11-11  Paolo Bonzini  <bonzini@gnu

	* tst-rxspecer.c: Do not mix instructions and
	declarations.
	* basicdefs.h: Include locale.h before #defining
	gettext, to avoid breakage under Solaris.
	* sed/sed.c: do not include locale.h.

po:
2004-11-11  Paolo Bonzini  <bonzini@gnu.org>

	* Makevars: New.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-18
fix \l and \u in a multi-byte configuration

2004-11-15  Paolo Bonzini  <bonzini@gnu.org>

	* sed/execute.c (str_append_modified): Copy the first character
	when using \l or \u in a multi-byte configuration.  Use
	WCRTOMB instead of wcrtomb.
	* sed/sed.h (WCRTOMB): New.

git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-19
git-archimport-id: bonzini@gnu.org--2004b/sed--stable--4.1--patch-20