Changeset 3613 for trunk/src/sed/lib/regex_internal.c

Timestamp:

Sep 19, 2024, 2:34:43 AM (10 months ago)

Author:

bird

Message:

src/sed: Merged in changes between 4.1.5 and 4.9 from the vendor branch. (svn merge ^{/vendor/sed/4.1.5} /vendor/sed/current .)

Location:

trunk/src/sed

Files:

• . (modified) (1 prop)
• lib/regex_internal.c (modified) (86 diffs)

trunk/src/sed/lib/regex_internal.c

@@ -1 +1 @@
 /* Extended regular expression matching and search library.
-   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   Copyright (C) 2002-2022 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Isamu Hasegawa <isamu@yamato.ibm.com>.
@@ -15 +15 @@
 
    You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
-   02111-1307 USA.  */
-
-static void re_string_construct_common (const char *str, int len,
+   License along with the GNU C Library; if not, see
+   <https://www.gnu.org/licenses/>.  */
+
+static void re_string_construct_common (const char *str, Idx len,
                                         re_string_t *pstr,
-                                        RE_TRANSLATE_TYPE trans, int icase,
-                                        const re_dfa_t *dfa) internal_function;
+                                        RE_TRANSLATE_TYPE trans, bool icase,
+                                        const re_dfa_t *dfa);
 static re_dfastate_t *create_ci_newstate (const re_dfa_t *dfa,
                                           const re_node_set *nodes,
-                                          unsigned int hash) internal_function;
+                                          re_hashval_t hash);
 static re_dfastate_t *create_cd_newstate (const re_dfa_t *dfa,
                                           const re_node_set *nodes,
                                           unsigned int context,
-                                          unsigned int hash) internal_function;
+                                          re_hashval_t hash);
+static reg_errcode_t re_string_realloc_buffers (re_string_t *pstr,
+                                                Idx new_buf_len);
+static void build_wcs_buffer (re_string_t *pstr);
+static reg_errcode_t build_wcs_upper_buffer (re_string_t *pstr);
+static void build_upper_buffer (re_string_t *pstr);
+static void re_string_translate_buffer (re_string_t *pstr);
+static unsigned int re_string_context_at (const re_string_t *input, Idx idx,
+                                          int eflags) __attribute__ ((pure));
 
 
@@ -38 +45 @@
 
 static reg_errcode_t
-internal_function
-re_string_allocate (re_string_t *pstr, const char *str, int len, int init_len,
-                    RE_TRANSLATE_TYPE trans, int icase, const re_dfa_t *dfa)
+__attribute_warn_unused_result__
+re_string_allocate (re_string_t *pstr, const char *str, Idx len, Idx init_len,
+                    RE_TRANSLATE_TYPE trans, bool icase, const re_dfa_t *dfa)
 {
   reg_errcode_t ret;
-  int init_buf_len;
+  Idx init_buf_len;
 
   /* Ensure at least one character fits into the buffers.  */
@@ -52 +59 @@
 
   ret = re_string_realloc_buffers (pstr, init_buf_len);
-  if (BE (ret != REG_NOERROR, 0))
+  if (__glibc_unlikely (ret != REG_NOERROR))
     return ret;
 
@@ -66 +73 @@
 
 static reg_errcode_t
-internal_function
-re_string_construct (re_string_t *pstr, const char *str, int len,
-                     RE_TRANSLATE_TYPE trans, int icase, const re_dfa_t *dfa)
+__attribute_warn_unused_result__
+re_string_construct (re_string_t *pstr, const char *str, Idx len,
+                     RE_TRANSLATE_TYPE trans, bool icase, const re_dfa_t *dfa)
 {
   reg_errcode_t ret;
@@ -77 +84 @@
     {
       ret = re_string_realloc_buffers (pstr, len + 1);
-      if (BE (ret != REG_NOERROR, 0))
+      if (__glibc_unlikely (ret != REG_NOERROR))
         return ret;
     }
@@ -84 +91 @@
   if (icase)
     {
-#ifdef RE_ENABLE_I18N
       if (dfa->mb_cur_max > 1)
         {
@@ -90 +96 @@
             {
               ret = build_wcs_upper_buffer (pstr);
-              if (BE (ret != REG_NOERROR, 0))
+              if (__glibc_unlikely (ret != REG_NOERROR))
                 return ret;
               if (pstr->valid_raw_len >= len)
@@ -97 +103 @@
                 break;
               ret = re_string_realloc_buffers (pstr, pstr->bufs_len * 2);
-              if (BE (ret != REG_NOERROR, 0))
+              if (__glibc_unlikely (ret != REG_NOERROR))
                 return ret;
             }
         }
       else
-#endif /* RE_ENABLE_I18N  */
         build_upper_buffer (pstr);
     }
   else
     {
-#ifdef RE_ENABLE_I18N
       if (dfa->mb_cur_max > 1)
         build_wcs_buffer (pstr);
       else
-#endif /* RE_ENABLE_I18N  */
         {
           if (trans != NULL)
@@ -129 +132 @@
 
 static reg_errcode_t
-internal_function
-re_string_realloc_buffers (re_string_t *pstr, int new_buf_len)
-{
-#ifdef RE_ENABLE_I18N
+__attribute_warn_unused_result__
+re_string_realloc_buffers (re_string_t *pstr, Idx new_buf_len)
+{
   if (pstr->mb_cur_max > 1)
     {
-      wint_t *new_wcs = re_realloc (pstr->wcs, wint_t, new_buf_len);
-      if (BE (new_wcs == NULL, 0))
+      wint_t *new_wcs;
+
+      /* Avoid overflow in realloc.  */
+      const size_t max_object_size = MAX (sizeof (wint_t), sizeof (Idx));
+      if (__glibc_unlikely (MIN (IDX_MAX, SIZE_MAX / max_object_size)
+                            < new_buf_len))
+        return REG_ESPACE;
+
+      new_wcs = re_realloc (pstr->wcs, wint_t, new_buf_len);
+      if (__glibc_unlikely (new_wcs == NULL))
         return REG_ESPACE;
       pstr->wcs = new_wcs;
       if (pstr->offsets != NULL)
         {
-          int *new_offsets = re_realloc (pstr->offsets, int, new_buf_len);
-          if (BE (new_offsets == NULL, 0))
+          Idx *new_offsets = re_realloc (pstr->offsets, Idx, new_buf_len);
+          if (__glibc_unlikely (new_offsets == NULL))
             return REG_ESPACE;
           pstr->offsets = new_offsets;
         }
     }
-#endif /* RE_ENABLE_I18N  */
   if (pstr->mbs_allocated)
     {
       unsigned char *new_mbs = re_realloc (pstr->mbs, unsigned char,
                                            new_buf_len);
-      if (BE (new_mbs == NULL, 0))
+      if (__glibc_unlikely (new_mbs == NULL))
         return REG_ESPACE;
       pstr->mbs = new_mbs;
@@ -162 +171 @@
 
 static void
-internal_function
-re_string_construct_common (const char *str, int len, re_string_t *pstr,
-                            RE_TRANSLATE_TYPE trans, int icase,
+re_string_construct_common (const char *str, Idx len, re_string_t *pstr,
+                            RE_TRANSLATE_TYPE trans, bool icase,
                             const re_dfa_t *dfa)
 {
@@ -171 +179 @@
   pstr->raw_len = len;
   pstr->trans = trans;
-  pstr->icase = icase ? 1 : 0;
+  pstr->icase = icase;
   pstr->mbs_allocated = (trans != NULL || icase);
   pstr->mb_cur_max = dfa->mb_cur_max;
@@ -180 +188 @@
 }
 
-#ifdef RE_ENABLE_I18N
 
 /* Build wide character buffer PSTR->WCS.
@@ -194 +201 @@
 
 static void
-internal_function
 build_wcs_buffer (re_string_t *pstr)
 {
 #ifdef _LIBC
   unsigned char buf[MB_LEN_MAX];
-  assert (MB_LEN_MAX >= pstr->mb_cur_max);
+  DEBUG_ASSERT (MB_LEN_MAX >= pstr->mb_cur_max);
 #else
   unsigned char buf[64];
 #endif
   mbstate_t prev_st;
-  int byte_idx, end_idx, remain_len;
+  Idx byte_idx, end_idx, remain_len;
   size_t mbclen;
 
@@ -218 +224 @@
       prev_st = pstr->cur_state;
       /* Apply the translation if we need.  */
-      if (BE (pstr->trans != NULL, 0))
+      if (__glibc_unlikely (pstr->trans != NULL))
         {
           int i, ch;
@@ -231 +237 @@
       else
         p = (const char *) pstr->raw_mbs + pstr->raw_mbs_idx + byte_idx;
-      mbclen = mbrtowc (&wc, p, remain_len, &pstr->cur_state);
-      if (BE (mbclen == (size_t) -2, 0))
+      mbclen = __mbrtowc (&wc, p, remain_len, &pstr->cur_state);
+      if (__glibc_unlikely (mbclen == (size_t) -1 || mbclen == 0
+                            || (mbclen == (size_t) -2
+                                && pstr->bufs_len >= pstr->len)))
+        {
+          /* We treat these cases as a singlebyte character.  */
+          mbclen = 1;
+          wc = (wchar_t) pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx];
+          if (__glibc_unlikely (pstr->trans != NULL))
+            wc = pstr->trans[wc];
+          pstr->cur_state = prev_st;
+        }
+      else if (__glibc_unlikely (mbclen == (size_t) -2))
         {
           /* The buffer doesn't have enough space, finish to build.  */
           pstr->cur_state = prev_st;
           break;
-        }
-      else if (BE (mbclen == (size_t) -1 || mbclen == 0, 0))
-        {
-          /* We treat these cases as a singlebyte character.  */
-          mbclen = 1;
-          wc = (wchar_t) pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx];
-          if (BE (pstr->trans != NULL, 0))
-            wc = pstr->trans[wc];
-          pstr->cur_state = prev_st;
         }
 
@@ -261 +269 @@
    but for REG_ICASE.  */
 
-static int
-internal_function
+static reg_errcode_t
+__attribute_warn_unused_result__
 build_wcs_upper_buffer (re_string_t *pstr)
 {
   mbstate_t prev_st;
-  int src_idx, byte_idx, end_idx, remain_len;
+  Idx src_idx, byte_idx, end_idx, remain_len;
   size_t mbclen;
 #ifdef _LIBC
   char buf[MB_LEN_MAX];
-  assert (MB_LEN_MAX >= pstr->mb_cur_max);
+  DEBUG_ASSERT (pstr->mb_cur_max <= MB_LEN_MAX);
 #else
   char buf[64];
@@ -285 +293 @@
         {
           wchar_t wc;
-
-          if (isascii (pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx])
-              && mbsinit (&pstr->cur_state))
+          unsigned char ch = pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx];
+
+          if (isascii (ch) && mbsinit (&pstr->cur_state))
             {
-              /* In case of a singlebyte character.  */
-              pstr->mbs[byte_idx]
-                = toupper (pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx]);
               /* The next step uses the assumption that wchar_t is encoded
                  ASCII-safe: all ASCII values can be converted like this.  */
-              pstr->wcs[byte_idx] = (wchar_t) pstr->mbs[byte_idx];
-              ++byte_idx;
-              continue;
+              wchar_t wcu = __towupper (ch);
+              if (isascii (wcu))
+                {
+                  pstr->mbs[byte_idx] = wcu;
+                  pstr->wcs[byte_idx] = wcu;
+                  byte_idx++;
+                  continue;
+                }
             }
 
           remain_len = end_idx - byte_idx;
           prev_st = pstr->cur_state;
-          mbclen = mbrtowc (&wc,
-                            ((const char *) pstr->raw_mbs + pstr->raw_mbs_idx
-                             + byte_idx), remain_len, &pstr->cur_state);
-          if (BE (mbclen + 2 > 2, 1))
+          mbclen = __mbrtowc (&wc,
+                              ((const char *) pstr->raw_mbs + pstr->raw_mbs_idx
+                               + byte_idx), remain_len, &pstr->cur_state);
+          if (__glibc_likely (0 < mbclen && mbclen < (size_t) -2))
             {
-              wchar_t wcu = wc;
-              if (iswlower (wc))
+              wchar_t wcu = __towupper (wc);
+              if (wcu != wc)
                 {
                   size_t mbcdlen;
 
-                  wcu = towupper (wc);
-                  mbcdlen = wcrtomb (buf, wcu, &prev_st);
-                  if (BE (mbclen == mbcdlen, 1))
+                  mbcdlen = __wcrtomb (buf, wcu, &prev_st);
+                  if (__glibc_likely (mbclen == mbcdlen))
                     memcpy (pstr->mbs + byte_idx, buf, mbclen);
                   else
@@ -329 +338 @@
                 pstr->wcs[byte_idx++] = WEOF;
             }
-          else if (mbclen == (size_t) -1 || mbclen == 0)
+          else if (mbclen == (size_t) -1 || mbclen == 0
+                   || (mbclen == (size_t) -2 && pstr->bufs_len >= pstr->len))
             {
-              /* It is an invalid character or '\0'.  Just use the byte.  */
-              int ch = pstr->raw_mbs[pstr->raw_mbs_idx + byte_idx];
+              /* It is an invalid character, an incomplete character
+                 at the end of the string, or '\0'.  Just use the byte.  */
               pstr->mbs[byte_idx] = ch;
               /* And also cast it to wide char.  */
               pstr->wcs[byte_idx++] = (wchar_t) ch;
-              if (BE (mbclen == (size_t) -1, 0))
+              if (__glibc_unlikely (mbclen == (size_t) -1))
                 pstr->cur_state = prev_st;
             }
@@ -358 +368 @@
         remain_len = end_idx - byte_idx;
         prev_st = pstr->cur_state;
-        if (BE (pstr->trans != NULL, 0))
+        if (__glibc_unlikely (pstr->trans != NULL))
           {
             int i, ch;
@@ -371 +381 @@
         else
           p = (const char *) pstr->raw_mbs + pstr->raw_mbs_idx + src_idx;
-        mbclen = mbrtowc (&wc, p, remain_len, &pstr->cur_state);
-        if (BE (mbclen + 2 > 2, 1))
+        mbclen = __mbrtowc (&wc, p, remain_len, &pstr->cur_state);
+        if (__glibc_likely (0 < mbclen && mbclen < (size_t) -2))
           {
-            wchar_t wcu = wc;
-            if (iswlower (wc))
+            wchar_t wcu = __towupper (wc);
+            if (wcu != wc)
               {
                 size_t mbcdlen;
 
-                wcu = towupper (wc);
-                mbcdlen = wcrtomb ((char *) buf, wcu, &prev_st);
-                if (BE (mbclen == mbcdlen, 1))
+                mbcdlen = __wcrtomb ((char *) buf, wcu, &prev_st);
+                if (__glibc_likely (mbclen == mbcdlen))
                   memcpy (pstr->mbs + byte_idx, buf, mbclen);
                 else if (mbcdlen != (size_t) -1)
@@ -395 +404 @@
                     if (pstr->offsets == NULL)
                       {
-                        pstr->offsets = re_malloc (int, pstr->bufs_len);
+                        pstr->offsets = re_malloc (Idx, pstr->bufs_len);
 
                         if (pstr->offsets == NULL)
@@ -425 +434 @@
                     continue;
                   }
-                else
-                  memcpy (pstr->mbs + byte_idx, p, mbclen);
+                else
+                  memcpy (pstr->mbs + byte_idx, p, mbclen);
               }
             else
               memcpy (pstr->mbs + byte_idx, p, mbclen);
 
-            if (BE (pstr->offsets_needed != 0, 0))
+            if (__glibc_unlikely (pstr->offsets_needed != 0))
               {
                 size_t i;
@@ -444 +453 @@
               pstr->wcs[byte_idx++] = WEOF;
           }
-        else if (mbclen == (size_t) -1 || mbclen == 0)
+        else if (mbclen == (size_t) -1 || mbclen == 0
+                 || (mbclen == (size_t) -2 && pstr->bufs_len >= pstr->len))
           {
             /* It is an invalid character or '\0'.  Just use the byte.  */
             int ch = pstr->raw_mbs[pstr->raw_mbs_idx + src_idx];
 
-            if (BE (pstr->trans != NULL, 0))
+            if (__glibc_unlikely (pstr->trans != NULL))
               ch = pstr->trans [ch];
             pstr->mbs[byte_idx] = ch;
 
-            if (BE (pstr->offsets_needed != 0, 0))
+            if (__glibc_unlikely (pstr->offsets_needed != 0))
               pstr->offsets[byte_idx] = src_idx;
             ++src_idx;
@@ -459 +469 @@
             /* And also cast it to wide char.  */
             pstr->wcs[byte_idx++] = (wchar_t) ch;
-            if (BE (mbclen == (size_t) -1, 0))
+            if (__glibc_unlikely (mbclen == (size_t) -1))
               pstr->cur_state = prev_st;
           }
@@ -477 +487 @@
    Return the index.  */
 
-static int
-internal_function
-re_string_skip_chars (re_string_t *pstr, int new_raw_idx, wint_t *last_wc)
+static Idx
+re_string_skip_chars (re_string_t *pstr, Idx new_raw_idx, wint_t *last_wc)
 {
   mbstate_t prev_st;
-  int rawbuf_idx;
+  Idx rawbuf_idx;
   size_t mbclen;
-  wchar_t wc = 0;
+  wint_t wc = WEOF;
 
   /* Skip the characters which are not necessary to check.  */
@@ -490 +499 @@
        rawbuf_idx < new_raw_idx;)
     {
-      int remain_len;
-      remain_len = pstr->len - rawbuf_idx;
+      wchar_t wc2;
+      Idx remain_len = pstr->raw_len - rawbuf_idx;
       prev_st = pstr->cur_state;
-      mbclen = mbrtowc (&wc, (const char *) pstr->raw_mbs + rawbuf_idx,
-                        remain_len, &pstr->cur_state);
-      if (BE (mbclen == (size_t) -2 || mbclen == (size_t) -1 || mbclen == 0, 0))
-        {
-          /* We treat these cases as a singlebyte character.  */
+      mbclen = __mbrtowc (&wc2, (const char *) pstr->raw_mbs + rawbuf_idx,
+                          remain_len, &pstr->cur_state);
+      if (__glibc_unlikely (mbclen == (size_t) -2 || mbclen == (size_t) -1
+                            || mbclen == 0))
+        {
+          /* We treat these cases as a single byte character.  */
+          if (mbclen == 0 || remain_len == 0)
+            wc = L'\0';
+          else
+            wc = *(unsigned char *) (pstr->raw_mbs + rawbuf_idx);
           mbclen = 1;
           pstr->cur_state = prev_st;
         }
+      else
+        wc = wc2;
       /* Then proceed the next character.  */
       rawbuf_idx += mbclen;
     }
-  *last_wc = (wint_t) wc;
+  *last_wc = wc;
   return rawbuf_idx;
 }
-#endif /* RE_ENABLE_I18N  */
 
 /* Build the buffer PSTR->MBS, and apply the translation if we need.
@@ -513 +528 @@
 
 static void
-internal_function
 build_upper_buffer (re_string_t *pstr)
 {
-  int char_idx, end_idx;
+  Idx char_idx, end_idx;
   end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
 
@@ -522 +536 @@
     {
       int ch = pstr->raw_mbs[pstr->raw_mbs_idx + char_idx];
-      if (BE (pstr->trans != NULL, 0))
+      if (__glibc_unlikely (pstr->trans != NULL))
         ch = pstr->trans[ch];
-      if (islower (ch))
-        pstr->mbs[char_idx] = toupper (ch);
-      else
-        pstr->mbs[char_idx] = ch;
+      pstr->mbs[char_idx] = toupper (ch);
     }
   pstr->valid_len = char_idx;
@@ -536 +547 @@
 
 static void
-internal_function
 re_string_translate_buffer (re_string_t *pstr)
 {
-  int buf_idx, end_idx;
+  Idx buf_idx, end_idx;
   end_idx = (pstr->bufs_len > pstr->len) ? pstr->len : pstr->bufs_len;
 
@@ -557 +567 @@
 
 static reg_errcode_t
-internal_function
-re_string_reconstruct (re_string_t *pstr, int idx, int eflags)
-{
-  int offset = idx - pstr->raw_mbs_idx;
-  if (BE (offset < 0, 0))
+__attribute_warn_unused_result__
+re_string_reconstruct (re_string_t *pstr, Idx idx, int eflags)
+{
+  Idx offset;
+
+  if (__glibc_unlikely (pstr->raw_mbs_idx <= idx))
+    offset = idx - pstr->raw_mbs_idx;
+  else
     {
       /* Reset buffer.  */
-#ifdef RE_ENABLE_I18N
       if (pstr->mb_cur_max > 1)
         memset (&pstr->cur_state, '\0', sizeof (mbstate_t));
-#endif /* RE_ENABLE_I18N */
       pstr->len = pstr->raw_len;
       pstr->stop = pstr->raw_stop;
@@ -581 +592 @@
     }
 
-  if (BE (offset != 0, 1))
-    {
-      /* Are the characters which are already checked remain?  */
-      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.  */
-          && pstr->offsets_needed == 0
-#endif
-         )
+  if (__glibc_likely (offset != 0))
+    {
+      /* Should the already checked characters be kept?  */
+      if (__glibc_likely (offset < pstr->valid_raw_len))
         {
           /* Yes, move them to the front of the buffer.  */
-          pstr->tip_context = re_string_context_at (pstr, offset - 1, eflags);
-#ifdef RE_ENABLE_I18N
-          if (pstr->mb_cur_max > 1)
-            memmove (pstr->wcs, pstr->wcs + offset,
-                     (pstr->valid_len - offset) * sizeof (wint_t));
-#endif /* RE_ENABLE_I18N */
-          if (BE (pstr->mbs_allocated, 0))
-            memmove (pstr->mbs, pstr->mbs + offset,
-                     pstr->valid_len - offset);
-          pstr->valid_len -= offset;
-          pstr->valid_raw_len -= offset;
-#if DEBUG
-          assert (pstr->valid_len > 0);
-#endif
+          if (__glibc_unlikely (pstr->offsets_needed))
+            {
+              Idx low = 0, high = pstr->valid_len, mid;
+              do
+                {
+                  mid = (high + low) / 2;
+                  if (pstr->offsets[mid] > offset)
+                    high = mid;
+                  else if (pstr->offsets[mid] < offset)
+                    low = mid + 1;
+                  else
+                    break;
+                }
+              while (low < high);
+              if (pstr->offsets[mid] < offset)
+                ++mid;
+              pstr->tip_context = re_string_context_at (pstr, mid - 1,
+                                                        eflags);
+              /* This can be quite complicated, so handle specially
+                 only the common and easy case where the character with
+                 different length representation of lower and upper
+                 case is present at or after offset.  */
+              if (pstr->valid_len > offset
+                  && mid == offset && pstr->offsets[mid] == offset)
+                {
+                  memmove (pstr->wcs, pstr->wcs + offset,
+                           (pstr->valid_len - offset) * sizeof (wint_t));
+                  memmove (pstr->mbs, pstr->mbs + offset, pstr->valid_len - offset);
+                  pstr->valid_len -= offset;
+                  pstr->valid_raw_len -= offset;
+                  for (low = 0; low < pstr->valid_len; low++)
+                    pstr->offsets[low] = pstr->offsets[low + offset] - offset;
+                }
+              else
+                {
+                  /* Otherwise, just find out how long the partial multibyte
+                     character at offset is and fill it with WEOF/255.  */
+                  pstr->len = pstr->raw_len - idx + offset;
+                  pstr->stop = pstr->raw_stop - idx + offset;
+                  pstr->offsets_needed = 0;
+                  while (mid > 0 && pstr->offsets[mid - 1] == offset)
+                    --mid;
+                  while (mid < pstr->valid_len)
+                    if (pstr->wcs[mid] != WEOF)
+                      break;
+                    else
+                      ++mid;
+                  if (mid == pstr->valid_len)
+                    pstr->valid_len = 0;
+                  else
+                    {
+                      pstr->valid_len = pstr->offsets[mid] - offset;
+                      if (pstr->valid_len)
+                        {
+                          for (low = 0; low < pstr->valid_len; ++low)
+                            pstr->wcs[low] = WEOF;
+                          memset (pstr->mbs, 255, pstr->valid_len);
+                        }
+                    }
+                  pstr->valid_raw_len = pstr->valid_len;
+                }
+            }
+          else
+            {
+              pstr->tip_context = re_string_context_at (pstr, offset - 1,
+                                                        eflags);
+              if (pstr->mb_cur_max > 1)
+                memmove (pstr->wcs, pstr->wcs + offset,
+                         (pstr->valid_len - offset) * sizeof (wint_t));
+              if (__glibc_unlikely (pstr->mbs_allocated))
+                memmove (pstr->mbs, pstr->mbs + offset,
+                         pstr->valid_len - offset);
+              pstr->valid_len -= offset;
+              pstr->valid_raw_len -= offset;
+              DEBUG_ASSERT (pstr->valid_len > 0);
+            }
         }
       else
         {
           /* No, skip all characters until IDX.  */
-#ifdef RE_ENABLE_I18N
-          if (BE (pstr->offsets_needed, 0))
+          Idx prev_valid_len = pstr->valid_len;
+
+          if (__glibc_unlikely (pstr->offsets_needed))
             {
               pstr->len = pstr->raw_len - idx + offset;
@@ -618 +686 @@
               pstr->offsets_needed = 0;
             }
-#endif
           pstr->valid_len = 0;
-          pstr->valid_raw_len = 0;
-#ifdef RE_ENABLE_I18N
           if (pstr->mb_cur_max > 1)
             {
-              int wcs_idx;
+              Idx wcs_idx;
               wint_t wc = WEOF;
 
               if (pstr->is_utf8)
                 {
-                  const unsigned char *raw, *p, *q, *end;
+                  const unsigned char *raw, *p, *end;
 
                   /* Special case UTF-8.  Multi-byte chars start with any
@@ -635 +700 @@
                   raw = pstr->raw_mbs + pstr->raw_mbs_idx;
                   end = raw + (offset - pstr->mb_cur_max);
+                  if (end < pstr->raw_mbs)
+                    end = pstr->raw_mbs;
                   p = raw + offset - 1;
 #ifdef _LIBC
                   /* We know the wchar_t encoding is UCS4, so for the simple
                      case, ASCII characters, skip the conversion step.  */
-                  if (isascii (*p) && BE (pstr->trans == NULL, 1))
+                  if (isascii (*p) && __glibc_likely (pstr->trans == NULL))
                     {
                       memset (&pstr->cur_state, '\0', sizeof (mbstate_t));
-                      pstr->valid_len = 0;
+                      /* pstr->valid_len = 0; */
                       wc = (wchar_t) *p;
                     }
@@ -652 +719 @@
                           mbstate_t cur_state;
                           wchar_t wc2;
-                          int mlen = raw + pstr->len - p;
+                          Idx mlen = raw + pstr->len - p;
                           unsigned char buf[6];
                           size_t mbclen;
 
-                          q = p;
-                          if (BE (pstr->trans != NULL, 0))
+                          const unsigned char *pp = p;
+                          if (__glibc_unlikely (pstr->trans != NULL))
                             {
                               int i = mlen < 6 ? mlen : 6;
                               while (--i >= 0)
                                 buf[i] = pstr->trans[p[i]];
-                              q = buf;
+                              pp = buf;
                             }
                           /* XXX Don't use mbrtowc, we know which conversion
                              to use (UTF-8 -> UCS4).  */
                           memset (&cur_state, 0, sizeof (cur_state));
-                          mbclen = mbrtowc (&wc2, (const char *) p, mlen,
-                                            &cur_state);
+                          mbclen = __mbrtowc (&wc2, (const char *) pp, mlen,
+                                              &cur_state);
                           if (raw + offset - p <= mbclen
                               && mbclen < (size_t) -2)
@@ -683 +750 @@
               if (wc == WEOF)
                 pstr->valid_len = re_string_skip_chars (pstr, idx, &wc) - idx;
-              if (BE (pstr->valid_len, 0))
+              if (wc == WEOF)
+                pstr->tip_context
+                  = re_string_context_at (pstr, prev_valid_len - 1, eflags);
+              else
+                pstr->tip_context = ((__glibc_unlikely (pstr->word_ops_used != 0)
+                                      && IS_WIDE_WORD_CHAR (wc))
+                                     ? CONTEXT_WORD
+                                     : ((IS_WIDE_NEWLINE (wc)
+                                         && pstr->newline_anchor)
+                                        ? CONTEXT_NEWLINE : 0));
+              if (__glibc_unlikely (pstr->valid_len))
                 {
                   for (wcs_idx = 0; wcs_idx < pstr->valid_len; ++wcs_idx)
@@ -691 +768 @@
                 }
               pstr->valid_raw_len = pstr->valid_len;
-              pstr->tip_context = ((BE (pstr->word_ops_used != 0, 0)
-                                    && IS_WIDE_WORD_CHAR (wc))
-                                   ? CONTEXT_WORD
-                                   : ((IS_WIDE_NEWLINE (wc)
-                                       && pstr->newline_anchor)
-                                      ? CONTEXT_NEWLINE : 0));
             }
           else
-#endif /* RE_ENABLE_I18N */
             {
               int c = pstr->raw_mbs[pstr->raw_mbs_idx + offset - 1];
+              pstr->valid_raw_len = 0;
               if (pstr->trans)
                 c = pstr->trans[c];
@@ -710 +781 @@
             }
         }
-      if (!BE (pstr->mbs_allocated, 0))
+      if (!__glibc_unlikely (pstr->mbs_allocated))
         pstr->mbs += offset;
     }
@@ -718 +789 @@
 
   /* Then build the buffers.  */
-#ifdef RE_ENABLE_I18N
   if (pstr->mb_cur_max > 1)
     {
       if (pstr->icase)
         {
-          int ret = build_wcs_upper_buffer (pstr);
-          if (BE (ret != REG_NOERROR, 0))
+          reg_errcode_t ret = build_wcs_upper_buffer (pstr);
+          if (__glibc_unlikely (ret != REG_NOERROR))
             return ret;
         }
@@ -731 +801 @@
     }
   else
-#endif /* RE_ENABLE_I18N */
-    if (BE (pstr->mbs_allocated, 0))
+    if (__glibc_unlikely (pstr->mbs_allocated))
       {
         if (pstr->icase)
@@ -747 +816 @@
 
 static unsigned char
-internal_function __attribute ((pure))
-re_string_peek_byte_case (const re_string_t *pstr, int idx)
-{
-  int ch, off;
+__attribute__ ((pure))
+re_string_peek_byte_case (const re_string_t *pstr, Idx idx)
+{
+  int ch;
+  Idx off;
 
   /* Handle the common (easiest) cases first.  */
-  if (BE (!pstr->mbs_allocated, 1))
+  if (__glibc_likely (!pstr->mbs_allocated))
     return re_string_peek_byte (pstr, idx);
 
-#ifdef RE_ENABLE_I18N
   if (pstr->mb_cur_max > 1
       && ! re_string_is_single_byte_char (pstr, pstr->cur_idx + idx))
     return re_string_peek_byte (pstr, idx);
-#endif
 
   off = pstr->cur_idx + idx;
-#ifdef RE_ENABLE_I18N
   if (pstr->offsets_needed)
     off = pstr->offsets[off];
-#endif
 
   ch = pstr->raw_mbs[pstr->raw_mbs_idx + off];
 
-#ifdef RE_ENABLE_I18N
   /* Ensure that e.g. for tr_TR.UTF-8 BACKSLASH DOTLESS SMALL LETTER I
      this function returns CAPITAL LETTER I instead of first byte of
@@ -777 +842 @@
   if (pstr->offsets_needed && !isascii (ch))
     return re_string_peek_byte (pstr, idx);
-#endif
 
   return ch;
@@ -783 +847 @@
 
 static unsigned char
-internal_function
 re_string_fetch_byte_case (re_string_t *pstr)
 {
-  if (BE (!pstr->mbs_allocated, 1))
+  if (__glibc_likely (!pstr->mbs_allocated))
     return re_string_fetch_byte (pstr);
 
-#ifdef RE_ENABLE_I18N
   if (pstr->offsets_needed)
     {
-      int off, ch;
+      Idx off;
+      int ch;
 
       /* For tr_TR.UTF-8 [[:islower:]] there is
@@ -814 +877 @@
       return ch;
     }
-#endif
 
   return pstr->raw_mbs[pstr->raw_mbs_idx + pstr->cur_idx++];
@@ -820 +882 @@
 
 static void
-internal_function
 re_string_destruct (re_string_t *pstr)
 {
-#ifdef RE_ENABLE_I18N
   re_free (pstr->wcs);
   re_free (pstr->offsets);
-#endif /* RE_ENABLE_I18N  */
   if (pstr->mbs_allocated)
     re_free (pstr->mbs);
@@ -834 +893 @@
 
 static unsigned int
-internal_function
-re_string_context_at (const re_string_t *input, int idx, int eflags)
+re_string_context_at (const re_string_t *input, Idx idx, int eflags)
 {
   int c;
-  if (BE (idx < 0, 0))
+  if (__glibc_unlikely (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;
-  if (BE (idx == input->len, 0))
+  if (__glibc_unlikely (idx == input->len))
     return ((eflags & REG_NOTEOL) ? CONTEXT_ENDBUF
             : CONTEXT_NEWLINE | CONTEXT_ENDBUF);
-#ifdef RE_ENABLE_I18N
   if (input->mb_cur_max > 1)
     {
       wint_t wc;
-      int wc_idx = idx;
+      Idx wc_idx = idx;
       while(input->wcs[wc_idx] == WEOF)
         {
-#ifdef DEBUG
-          /* It must not happen.  */
-          assert (wc_idx >= 0);
-#endif
+          DEBUG_ASSERT (wc_idx >= 0);
           --wc_idx;
           if (wc_idx < 0)
@@ -861 +915 @@
         }
       wc = input->wcs[wc_idx];
-      if (BE (input->word_ops_used != 0, 0) && IS_WIDE_WORD_CHAR (wc))
+      if (__glibc_unlikely (input->word_ops_used != 0)
+          && IS_WIDE_WORD_CHAR (wc))
         return CONTEXT_WORD;
       return (IS_WIDE_NEWLINE (wc) && input->newline_anchor
@@ -867 +922 @@
     }
   else
-#endif
     {
       c = re_string_byte_at (input, idx);
@@ -880 +934 @@
 
 static reg_errcode_t
-internal_function
-re_node_set_alloc (re_node_set *set, int size)
+__attribute_warn_unused_result__
+re_node_set_alloc (re_node_set *set, Idx size)
 {
   set->alloc = size;
   set->nelem = 0;
-  set->elems = re_malloc (int, size);
-  if (BE (set->elems == NULL, 0))
+  set->elems = re_malloc (Idx, size);
+  if (__glibc_unlikely (set->elems == NULL)
+      && (MALLOC_0_IS_NONNULL || size != 0))
     return REG_ESPACE;
   return REG_NOERROR;
@@ -892 +947 @@
 
 static reg_errcode_t
-internal_function
-re_node_set_init_1 (re_node_set *set, int elem)
+__attribute_warn_unused_result__
+re_node_set_init_1 (re_node_set *set, Idx elem)
 {
   set->alloc = 1;
   set->nelem = 1;
-  set->elems = re_malloc (int, 1);
-  if (BE (set->elems == NULL, 0))
+  set->elems = re_malloc (Idx, 1);
+  if (__glibc_unlikely (set->elems == NULL))
     {
       set->alloc = set->nelem = 0;
@@ -908 +963 @@
 
 static reg_errcode_t
-internal_function
-re_node_set_init_2 (re_node_set *set, int elem1, int elem2)
+__attribute_warn_unused_result__
+re_node_set_init_2 (re_node_set *set, Idx elem1, Idx elem2)
 {
   set->alloc = 2;
-  set->elems = re_malloc (int, 2);
-  if (BE (set->elems == NULL, 0))
+  set->elems = re_malloc (Idx, 2);
+  if (__glibc_unlikely (set->elems == NULL))
     return REG_ESPACE;
   if (elem1 == elem2)
@@ -938 +993 @@
 
 static reg_errcode_t
-internal_function
+__attribute_warn_unused_result__
 re_node_set_init_copy (re_node_set *dest, const re_node_set *src)
 {
@@ -945 +1000 @@
     {
       dest->alloc = dest->nelem;
-      dest->elems = re_malloc (int, dest->alloc);
-      if (BE (dest->elems == NULL, 0))
+      dest->elems = re_malloc (Idx, dest->alloc);
+      if (__glibc_unlikely (dest->elems == NULL))
         {
           dest->alloc = dest->nelem = 0;
           return REG_ESPACE;
         }
-      memcpy (dest->elems, src->elems, src->nelem * sizeof (int));
+      memcpy (dest->elems, src->elems, src->nelem * sizeof (Idx));
     }
   else
@@ -963 +1018 @@
 
 static reg_errcode_t
-internal_function
+__attribute_warn_unused_result__
 re_node_set_add_intersect (re_node_set *dest, const re_node_set *src1,
                            const re_node_set *src2)
 {
-  int i1, i2, is, id, delta, sbase;
+  Idx i1, i2, is, id, delta, sbase;
   if (src1->nelem == 0 || src2->nelem == 0)
     return REG_NOERROR;
@@ -975 +1030 @@
   if (src1->nelem + src2->nelem + dest->nelem > dest->alloc)
     {
-      int new_alloc = src1->nelem + src2->nelem + dest->alloc;
-      int *new_elems = re_realloc (dest->elems, int, new_alloc);
-      if (BE (new_elems == NULL, 0))
-        return REG_ESPACE;
+      Idx new_alloc = src1->nelem + src2->nelem + dest->alloc;
+      Idx *new_elems = re_realloc (dest->elems, Idx, new_alloc);
+      if (__glibc_unlikely (new_elems == NULL))
+        return REG_ESPACE;
       dest->elems = new_elems;
       dest->alloc = new_alloc;
@@ -997 +1052 @@
             --id;
 
-          if (id < 0 || dest->elems[id] != src1->elems[i1])
+          if (id < 0 || dest->elems[id] != src1->elems[i1])
             dest->elems[--sbase] = src1->elems[i1];
 
@@ -1028 +1083 @@
     for (;;)
       {
-        if (dest->elems[is] > dest->elems[id])
-          {
-            /* Copy from the top.  */
-            dest->elems[id + delta--] = dest->elems[is--];
-            if (delta == 0)
-              break;
-          }
-        else
-          {
-            /* Slide from the bottom.  */
-            dest->elems[id + delta] = dest->elems[id];
-            if (--id < 0)
-              break;
-          }
+        if (dest->elems[is] > dest->elems[id])
+          {
+            /* Copy from the top.  */
+            dest->elems[id + delta--] = dest->elems[is--];
+            if (delta == 0)
+              break;
+          }
+        else
+          {
+            /* Slide from the bottom.  */
+            dest->elems[id + delta] = dest->elems[id];
+            if (--id < 0)
+              break;
+          }
       }
 
   /* Copy remaining SRC elements.  */
-  memcpy (dest->elems, dest->elems + sbase, delta * sizeof (int));
+  memcpy (dest->elems, dest->elems + sbase, delta * sizeof (Idx));
 
   return REG_NOERROR;
@@ -1054 +1109 @@
 
 static reg_errcode_t
-internal_function
+__attribute_warn_unused_result__
 re_node_set_init_union (re_node_set *dest, const re_node_set *src1,
                         const re_node_set *src2)
 {
-  int i1, i2, id;
+  Idx i1, i2, id;
   if (src1 != NULL && src1->nelem > 0 && src2 != NULL && src2->nelem > 0)
     {
       dest->alloc = src1->nelem + src2->nelem;
-      dest->elems = re_malloc (int, dest->alloc);
-      if (BE (dest->elems == NULL, 0))
+      dest->elems = re_malloc (Idx, dest->alloc);
+      if (__glibc_unlikely (dest->elems == NULL))
         return REG_ESPACE;
     }
@@ -1090 +1145 @@
     {
       memcpy (dest->elems + id, src1->elems + i1,
-             (src1->nelem - i1) * sizeof (int));
+             (src1->nelem - i1) * sizeof (Idx));
       id += src1->nelem - i1;
     }
@@ -1096 +1151 @@
     {
       memcpy (dest->elems + id, src2->elems + i2,
-             (src2->nelem - i2) * sizeof (int));
+             (src2->nelem - i2) * sizeof (Idx));
       id += src2->nelem - i2;
     }
@@ -1107 +1162 @@
 
 static reg_errcode_t
-internal_function
+__attribute_warn_unused_result__
 re_node_set_merge (re_node_set *dest, const re_node_set *src)
 {
-  int is, id, sbase, delta;
+  Idx is, id, sbase, delta;
   if (src == NULL || src->nelem == 0)
     return REG_NOERROR;
   if (dest->alloc < 2 * src->nelem + dest->nelem)
     {
-      int new_alloc = 2 * (src->nelem + dest->alloc);
-      int *new_buffer = re_realloc (dest->elems, int, new_alloc);
-      if (BE (new_buffer == NULL, 0))
+      Idx new_alloc = 2 * (src->nelem + dest->alloc);
+      Idx *new_buffer = re_realloc (dest->elems, Idx, new_alloc);
+      if (__glibc_unlikely (new_buffer == NULL))
         return REG_ESPACE;
       dest->elems = new_buffer;
@@ -1123 +1178 @@
     }
 
-  if (BE (dest->nelem == 0, 0))
-    {
+  if (__glibc_unlikely (dest->nelem == 0))
+    {
+      /* Although we already guaranteed above that dest->alloc != 0 and
+         therefore dest->elems != NULL, add a debug assertion to pacify
+         GCC 11.2.1's -fanalyzer.  */
+      DEBUG_ASSERT (dest->elems);
       dest->nelem = src->nelem;
-      memcpy (dest->elems, src->elems, src->nelem * sizeof (int));
+      memcpy (dest->elems, src->elems, src->nelem * sizeof (Idx));
       return REG_NOERROR;
     }
@@ -1136 +1195 @@
     {
       if (dest->elems[id] == src->elems[is])
-        is--, id--;
+        is--, id--;
       else if (dest->elems[id] < src->elems[is])
-        dest->elems[--sbase] = src->elems[is--];
+        dest->elems[--sbase] = src->elems[is--];
       else /* if (dest->elems[id] > src->elems[is]) */
-        --id;
+        --id;
     }
 
@@ -1147 +1206 @@
       /* If DEST is exhausted, the remaining items of SRC must be unique.  */
       sbase -= is + 1;
-      memcpy (dest->elems + sbase, src->elems, (is + 1) * sizeof (int));
+      memcpy (dest->elems + sbase, src->elems, (is + 1) * sizeof (Idx));
     }
 
@@ -1162 +1221 @@
     {
       if (dest->elems[is] > dest->elems[id])
-        {
+        {
           /* Copy from the top.  */
-          dest->elems[id + delta--] = dest->elems[is--];
+          dest->elems[id + delta--] = dest->elems[is--];
           if (delta == 0)
             break;
         }
       else
-        {
-          /* Slide from the bottom.  */
-          dest->elems[id + delta] = dest->elems[id];
+        {
+          /* Slide from the bottom.  */
+          dest->elems[id + delta] = dest->elems[id];
           if (--id < 0)
             {
               /* Copy remaining SRC elements.  */
               memcpy (dest->elems, dest->elems + sbase,
-                      delta * sizeof (int));
+                      delta * sizeof (Idx));
               break;
             }
@@ -1187 +1246 @@
 /* Insert the new element ELEM to the re_node_set* SET.
    SET should not already have ELEM.
-   return -1 if an error is occured, return 1 otherwise.  */
-
-static int
-internal_function
-re_node_set_insert (re_node_set *set, int elem)
-{
-  int idx;
+   Return true if successful.  */
+
+static bool
+__attribute_warn_unused_result__
+re_node_set_insert (re_node_set *set, Idx elem)
+{
+  Idx idx;
   /* In case the set is empty.  */
   if (set->alloc == 0)
-    {
-      if (BE (re_node_set_init_1 (set, elem) == REG_NOERROR, 1))
-        return 1;
-      else
-        return -1;
-    }
-
-  if (BE (set->nelem, 0) == 0)
-    {
-      /* We already guaranteed above that set->alloc != 0.  */
+    return __glibc_likely (re_node_set_init_1 (set, elem) == REG_NOERROR);
+
+  if (__glibc_unlikely (set->nelem) == 0)
+    {
+      /* Although we already guaranteed above that set->alloc != 0 and
+         therefore set->elems != NULL, add a debug assertion to pacify
+         GCC 11.2 -fanalyzer.  */
+      DEBUG_ASSERT (set->elems);
       set->elems[0] = elem;
       ++set->nelem;
-      return 1;
+      return true;
     }
 
@@ -1214 +1271 @@
   if (set->alloc == set->nelem)
     {
-      int *new_elems;
+      Idx *new_elems;
       set->alloc = set->alloc * 2;
-      new_elems = re_realloc (set->elems, int, set->alloc);
-      if (BE (new_elems == NULL, 0))
-        return -1;
+      new_elems = re_realloc (set->elems, Idx, set->alloc);
+      if (__glibc_unlikely (new_elems == NULL))
+        return false;
       set->elems = new_elems;
     }
@@ -1226 +1283 @@
   if (elem < set->elems[0])
     {
-      idx = 0;
       for (idx = set->nelem; idx > 0; idx--)
-        set->elems[idx] = set->elems[idx - 1];
+        set->elems[idx] = set->elems[idx - 1];
     }
   else
     {
       for (idx = set->nelem; set->elems[idx - 1] > elem; idx--)
-        set->elems[idx] = set->elems[idx - 1];
+        set->elems[idx] = set->elems[idx - 1];
+      DEBUG_ASSERT (set->elems[idx - 1] < elem);
     }
 
@@ -1239 +1296 @@
   set->elems[idx] = elem;
   ++set->nelem;
-  return 1;
+  return true;
 }
 
 /* Insert the new element ELEM to the re_node_set* SET.
    SET should not already have any element greater than or equal to ELEM.
-   Return -1 if an error is occured, return 1 otherwise.  */
-
-static int
-internal_function
-re_node_set_insert_last (re_node_set *set, int elem)
+   Return true if successful.  */
+
+static bool
+__attribute_warn_unused_result__
+re_node_set_insert_last (re_node_set *set, Idx elem)
 {
   /* Realloc if we need.  */
   if (set->alloc == set->nelem)
     {
-      int *new_elems;
+      Idx *new_elems;
       set->alloc = (set->alloc + 1) * 2;
-      new_elems = re_realloc (set->elems, int, set->alloc);
-      if (BE (new_elems == NULL, 0))
-        return -1;
+      new_elems = re_realloc (set->elems, Idx, set->alloc);
+      if (__glibc_unlikely (new_elems == NULL))
+        return false;
       set->elems = new_elems;
     }
@@ -1263 +1320 @@
   /* Insert the new element.  */
   set->elems[set->nelem++] = elem;
-  return 1;
+  return true;
 }
 
 /* Compare two node sets SET1 and SET2.
-   return 1 if SET1 and SET2 are equivalent, return 0 otherwise.  */
-
-static int
-internal_function __attribute ((pure))
+   Return true if SET1 and SET2 are equivalent.  */
+
+static bool
+__attribute__ ((pure))
 re_node_set_compare (const re_node_set *set1, const re_node_set *set2)
 {
-  int i;
+  Idx i;
   if (set1 == NULL || set2 == NULL || set1->nelem != set2->nelem)
-    return 0;
+    return false;
   for (i = set1->nelem ; --i >= 0 ; )
     if (set1->elems[i] != set2->elems[i])
-      return 0;
-  return 1;
+      return false;
+  return true;
 }
 
 /* Return (idx + 1) if SET contains the element ELEM, return 0 otherwise.  */
 
-static int
-internal_function __attribute ((pure))
-re_node_set_contains (const re_node_set *set, int elem)
-{
-  unsigned int idx, right, mid;
+static Idx
+__attribute__ ((pure))
+re_node_set_contains (const re_node_set *set, Idx elem)
+{
+  __re_size_t idx, right, mid;
   if (set->nelem <= 0)
     return 0;
@@ -1307 +1364 @@
 
 static void
-internal_function
-re_node_set_remove_at (re_node_set *set, int idx)
+re_node_set_remove_at (re_node_set *set, Idx idx)
 {
   if (idx < 0 || idx >= set->nelem)
@@ -1320 +1376 @@
 
 /* Add the token TOKEN to dfa->nodes, and return the index of the token.
-   Or return -1, if an error will be occured.  */
-
-static int
-internal_function
+   Or return -1 if an error occurred.  */
+
+static Idx
 re_dfa_add_node (re_dfa_t *dfa, re_token_t token)
 {
-  int type = token.type;
-  if (BE (dfa->nodes_len >= dfa->nodes_alloc, 0))
+  if (__glibc_unlikely (dfa->nodes_len >= dfa->nodes_alloc))
     {
       size_t new_nodes_alloc = dfa->nodes_alloc * 2;
-      int *new_nexts, *new_indices;
+      Idx *new_nexts, *new_indices;
       re_node_set *new_edests, *new_eclosures;
       re_token_t *new_nodes;
 
-      /* Avoid overflows.  */
-      if (BE (new_nodes_alloc < dfa->nodes_alloc, 0))
+      /* Avoid overflows in realloc.  */
+      const size_t max_object_size = MAX (sizeof (re_token_t),
+                                          MAX (sizeof (re_node_set),
+                                               sizeof (Idx)));
+      if (__glibc_unlikely (MIN (IDX_MAX, SIZE_MAX / max_object_size)
+                            < new_nodes_alloc))
         return -1;
 
       new_nodes = re_realloc (dfa->nodes, re_token_t, new_nodes_alloc);
-      if (BE (new_nodes == NULL, 0))
+      if (__glibc_unlikely (new_nodes == NULL))
         return -1;
       dfa->nodes = new_nodes;
-      new_nexts = re_realloc (dfa->nexts, int, new_nodes_alloc);
-      new_indices = re_realloc (dfa->org_indices, int, new_nodes_alloc);
+      dfa->nodes_alloc = new_nodes_alloc;
+      new_nexts = re_realloc (dfa->nexts, Idx, new_nodes_alloc);
+      if (new_nexts != NULL)
+        dfa->nexts = new_nexts;
+      new_indices = re_realloc (dfa->org_indices, Idx, new_nodes_alloc);
+      if (new_indices != NULL)
+        dfa->org_indices = new_indices;
       new_edests = re_realloc (dfa->edests, re_node_set, new_nodes_alloc);
+      if (new_edests != NULL)
+        dfa->edests = new_edests;
       new_eclosures = re_realloc (dfa->eclosures, re_node_set, new_nodes_alloc);
-      if (BE (new_nexts == NULL || new_indices == NULL
-              || new_edests == NULL || new_eclosures == NULL, 0))
+      if (new_eclosures != NULL)
+        dfa->eclosures = new_eclosures;
+      if (__glibc_unlikely (new_nexts == NULL || new_indices == NULL
+                            || new_edests == NULL || new_eclosures == NULL))
         return -1;
-      dfa->nexts = new_nexts;
-      dfa->org_indices = new_indices;
-      dfa->edests = new_edests;
-      dfa->eclosures = new_eclosures;
-      dfa->nodes_alloc = new_nodes_alloc;
     }
   dfa->nodes[dfa->nodes_len] = token;
   dfa->nodes[dfa->nodes_len].constraint = 0;
-#ifdef RE_ENABLE_I18N
   dfa->nodes[dfa->nodes_len].accept_mb =
-    (type == OP_PERIOD && dfa->mb_cur_max > 1) || type == COMPLEX_BRACKET;
-#endif
+    ((token.type == OP_PERIOD && dfa->mb_cur_max > 1)
+     || token.type == COMPLEX_BRACKET);
   dfa->nexts[dfa->nodes_len] = -1;
   re_node_set_init_empty (dfa->edests + dfa->nodes_len);
@@ -1367 +1428 @@
 }
 
-static inline unsigned int
-internal_function
+static re_hashval_t
 calc_state_hash (const re_node_set *nodes, unsigned int context)
 {
-  unsigned int hash = nodes->nelem + context;
-  int i;
+  re_hashval_t hash = nodes->nelem + context;
+  Idx i;
   for (i = 0 ; i < nodes->nelem ; i++)
     hash += nodes->elems[i];
@@ -1388 +1448 @@
 
 static re_dfastate_t *
-internal_function
+__attribute_warn_unused_result__
 re_acquire_state (reg_errcode_t *err, const re_dfa_t *dfa,
                   const re_node_set *nodes)
 {
-  unsigned int hash;
+  re_hashval_t hash;
   re_dfastate_t *new_state;
   struct re_state_table_entry *spot;
-  int i;
-  if (BE (nodes->nelem == 0, 0))
+  Idx i;
+#if defined GCC_LINT || defined lint
+  /* Suppress bogus uninitialized-variable warnings.  */
+  *err = REG_NOERROR;
+#endif
+  if (__glibc_unlikely (nodes->nelem == 0))
     {
       *err = REG_NOERROR;
@@ -1415 +1479 @@
   /* There are no appropriate state in the dfa, create the new one.  */
   new_state = create_ci_newstate (dfa, nodes, hash);
-  if (BE (new_state == NULL, 0))
+  if (__glibc_unlikely (new_state == NULL))
     *err = REG_ESPACE;
 
@@ -1432 +1496 @@
 
 static re_dfastate_t *
-internal_function
+__attribute_warn_unused_result__
 re_acquire_state_context (reg_errcode_t *err, const re_dfa_t *dfa,
                           const re_node_set *nodes, unsigned int context)
 {
-  unsigned int hash;
+  re_hashval_t hash;
   re_dfastate_t *new_state;
   struct re_state_table_entry *spot;
-  int i;
+  Idx i;
+#if defined GCC_LINT || defined lint
+  /* Suppress bogus uninitialized-variable warnings.  */
+  *err = REG_NOERROR;
+#endif
   if (nodes->nelem == 0)
     {
@@ -1456 +1524 @@
         return state;
     }
-  /* There are no appropriate state in `dfa', create the new one.  */
+  /* There are no appropriate state in 'dfa', create the new one.  */
   new_state = create_cd_newstate (dfa, nodes, context, hash);
-  if (BE (new_state == NULL, 0))
+  if (__glibc_unlikely (new_state == NULL))
     *err = REG_ESPACE;
 
@@ -1469 +1537 @@
 
 static reg_errcode_t
+__attribute_warn_unused_result__
 register_state (const re_dfa_t *dfa, re_dfastate_t *newstate,
-                unsigned int hash)
+                re_hashval_t hash)
 {
   struct re_state_table_entry *spot;
   reg_errcode_t err;
-  int i;
+  Idx i;
 
   newstate->hash = hash;
   err = re_node_set_alloc (&newstate->non_eps_nodes, newstate->nodes.nelem);
-  if (BE (err != REG_NOERROR, 0))
+  if (__glibc_unlikely (err != REG_NOERROR))
     return REG_ESPACE;
   for (i = 0; i < newstate->nodes.nelem; i++)
     {
-      int elem = newstate->nodes.elems[i];
+      Idx elem = newstate->nodes.elems[i];
       if (!IS_EPSILON_NODE (dfa->nodes[elem].type))
-        re_node_set_insert_last (&newstate->non_eps_nodes, elem);
+        if (! re_node_set_insert_last (&newstate->non_eps_nodes, elem))
+          return REG_ESPACE;
     }
 
   spot = dfa->state_table + (hash & dfa->state_hash_mask);
-  if (BE (spot->alloc <= spot->num, 0))
-    {
-      int new_alloc = 2 * spot->num + 2;
+  if (__glibc_unlikely (spot->alloc <= spot->num))
+    {
+      Idx new_alloc = 2 * spot->num + 2;
       re_dfastate_t **new_array = re_realloc (spot->array, re_dfastate_t *,
                                               new_alloc);
-      if (BE (new_array == NULL, 0))
+      if (__glibc_unlikely (new_array == NULL))
         return REG_ESPACE;
       spot->array = new_array;
@@ -1518 +1588 @@
 }
 
-/* Create the new state which is independ of contexts.
+/* Create the new state which is independent of contexts.
    Return the new state if succeeded, otherwise return NULL.  */
 
 static re_dfastate_t *
-internal_function
+__attribute_warn_unused_result__
 create_ci_newstate (const re_dfa_t *dfa, const re_node_set *nodes,
-                    unsigned int hash)
-{
-  int i;
+                    re_hashval_t hash)
+{
+  Idx i;
   reg_errcode_t err;
   re_dfastate_t *newstate;
 
   newstate = (re_dfastate_t *) calloc (sizeof (re_dfastate_t), 1);
-  if (BE (newstate == NULL, 0))
+  if (__glibc_unlikely (newstate == NULL))
     return NULL;
   err = re_node_set_init_copy (&newstate->nodes, nodes);
-  if (BE (err != REG_NOERROR, 0))
+  if (__glibc_unlikely (err != REG_NOERROR))
     {
       re_free (newstate);
@@ -1547 +1617 @@
       if (type == CHARACTER && !node->constraint)
         continue;
-#ifdef RE_ENABLE_I18N
       newstate->accept_mb |= node->accept_mb;
-#endif /* RE_ENABLE_I18N */
 
       /* If the state has the halt node, the state is a halt state.  */
@@ -1560 +1628 @@
     }
   err = register_state (dfa, newstate, hash);
-  if (BE (err != REG_NOERROR, 0))
+  if (__glibc_unlikely (err != REG_NOERROR))
     {
       free_state (newstate);
@@ -1572 +1640 @@
 
 static re_dfastate_t *
-internal_function
+__attribute_warn_unused_result__
 create_cd_newstate (const re_dfa_t *dfa, const re_node_set *nodes,
-                    unsigned int context, unsigned int hash)
-{
-  int i, nctx_nodes = 0;
+                    unsigned int context, re_hashval_t hash)
+{
+  Idx i, nctx_nodes = 0;
   reg_errcode_t err;
   re_dfastate_t *newstate;
 
   newstate = (re_dfastate_t *) calloc (sizeof (re_dfastate_t), 1);
-  if (BE (newstate == NULL, 0))
+  if (__glibc_unlikely (newstate == NULL))
     return NULL;
   err = re_node_set_init_copy (&newstate->nodes, nodes);
-  if (BE (err != REG_NOERROR, 0))
+  if (__glibc_unlikely (err != REG_NOERROR))
     {
       re_free (newstate);
@@ -1595 +1663 @@
   for (i = 0 ; i < nodes->nelem ; i++)
     {
-      unsigned int constraint = 0;
       re_token_t *node = dfa->nodes + nodes->elems[i];
       re_token_type_t type = node->type;
-      if (node->constraint)
-        constraint = node->constraint;
+      unsigned int constraint = node->constraint;
 
       if (type == CHARACTER && !constraint)
         continue;
-#ifdef RE_ENABLE_I18N
       newstate->accept_mb |= node->accept_mb;
-#endif /* RE_ENABLE_I18N */
 
       /* If the state has the halt node, the state is a halt state.  */
@@ -1612 +1676 @@
       else if (type == OP_BACK_REF)
         newstate->has_backref = 1;
-      else if (type == ANCHOR)
-        constraint = node->opr.ctx_type;
 
       if (constraint)
@@ -1619 +1681 @@
           if (newstate->entrance_nodes == &newstate->nodes)
             {
-              newstate->entrance_nodes = re_malloc (re_node_set, 1);
-              if (BE (newstate->entrance_nodes == NULL, 0))
+              re_node_set *entrance_nodes = re_malloc (re_node_set, 1);
+              if (__glibc_unlikely (entrance_nodes == NULL))
                 {
                   free_state (newstate);
                   return NULL;
                 }
-              re_node_set_init_copy (newstate->entrance_nodes, nodes);
+              newstate->entrance_nodes = entrance_nodes;
+              if (re_node_set_init_copy (newstate->entrance_nodes, nodes)
+                  != REG_NOERROR)
+                {
+                  free_state (newstate);
+                  return NULL;
+                }
               nctx_nodes = 0;
               newstate->has_constraint = 1;
@@ -1638 +1706 @@
     }
   err = register_state (dfa, newstate, hash);
-  if (BE (err != REG_NOERROR, 0))
+  if (__glibc_unlikely (err != REG_NOERROR))
     {
       free_state (newstate);