Home | History | Annotate | Download | only in libiberty
      1 /* Extended regular expression matching and search library,
      2    version 0.12.
      3    (Implements POSIX draft P1003.2/D11.2, except for some of the
      4    internationalization features.)
      5 
      6    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
      7    2002, 2005, 2010, 2013 Free Software Foundation, Inc.
      8    This file is part of the GNU C Library.
      9 
     10    The GNU C Library is free software; you can redistribute it and/or
     11    modify it under the terms of the GNU Lesser General Public
     12    License as published by the Free Software Foundation; either
     13    version 2.1 of the License, or (at your option) any later version.
     14 
     15    The GNU C Library is distributed in the hope that it will be useful,
     16    but WITHOUT ANY WARRANTY; without even the implied warranty of
     17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     18    Lesser General Public License for more details.
     19 
     20    You should have received a copy of the GNU Lesser General Public
     21    License along with the GNU C Library; if not, write to the Free
     22    Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     23    02110-1301 USA.  */
     24 
     25 /* This file has been modified for usage in libiberty.  It includes "xregex.h"
     26    instead of <regex.h>.  The "xregex.h" header file renames all external
     27    routines with an "x" prefix so they do not collide with the native regex
     28    routines or with other components regex routines. */
     29 /* AIX requires this to be the first thing in the file. */
     30 #if defined _AIX && !defined __GNUC__ && !defined REGEX_MALLOC
     31   #pragma alloca
     32 #endif
     33 
     34 #undef	_GNU_SOURCE
     35 #define _GNU_SOURCE
     36 
     37 #ifndef INSIDE_RECURSION
     38 # ifdef HAVE_CONFIG_H
     39 #  include <config.h>
     40 # endif
     41 #endif
     42 
     43 #include <ansidecl.h>
     44 
     45 #ifndef INSIDE_RECURSION
     46 
     47 # if defined STDC_HEADERS && !defined emacs
     48 #  include <stddef.h>
     49 #  define PTR_INT_TYPE ptrdiff_t
     50 # else
     51 /* We need this for `regex.h', and perhaps for the Emacs include files.  */
     52 #  include <sys/types.h>
     53 #  define PTR_INT_TYPE long
     54 # endif
     55 
     56 # define WIDE_CHAR_SUPPORT (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)
     57 
     58 /* For platform which support the ISO C amendement 1 functionality we
     59    support user defined character classes.  */
     60 # if defined _LIBC || WIDE_CHAR_SUPPORT
     61 /* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
     62 #  include <wchar.h>
     63 #  include <wctype.h>
     64 # endif
     65 
     66 # ifdef _LIBC
     67 /* We have to keep the namespace clean.  */
     68 #  define regfree(preg) __regfree (preg)
     69 #  define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
     70 #  define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
     71 #  define regerror(errcode, preg, errbuf, errbuf_size) \
     72 	__regerror(errcode, preg, errbuf, errbuf_size)
     73 #  define re_set_registers(bu, re, nu, st, en) \
     74 	__re_set_registers (bu, re, nu, st, en)
     75 #  define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
     76 	__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
     77 #  define re_match(bufp, string, size, pos, regs) \
     78 	__re_match (bufp, string, size, pos, regs)
     79 #  define re_search(bufp, string, size, startpos, range, regs) \
     80 	__re_search (bufp, string, size, startpos, range, regs)
     81 #  define re_compile_pattern(pattern, length, bufp) \
     82 	__re_compile_pattern (pattern, length, bufp)
     83 #  define re_set_syntax(syntax) __re_set_syntax (syntax)
     84 #  define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
     85 	__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
     86 #  define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)
     87 
     88 #  define btowc __btowc
     89 
     90 /* We are also using some library internals.  */
     91 #  include <locale/localeinfo.h>
     92 #  include <locale/elem-hash.h>
     93 #  include <langinfo.h>
     94 #  include <locale/coll-lookup.h>
     95 # endif
     96 
     97 /* This is for other GNU distributions with internationalized messages.  */
     98 # if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
     99 #  include <libintl.h>
    100 #  ifdef _LIBC
    101 #   undef gettext
    102 #   define gettext(msgid) __dcgettext ("libc", msgid, LC_MESSAGES)
    103 #  endif
    104 # else
    105 #  define gettext(msgid) (msgid)
    106 # endif
    107 
    108 # ifndef gettext_noop
    109 /* This define is so xgettext can find the internationalizable
    110    strings.  */
    111 #  define gettext_noop(String) String
    112 # endif
    113 
    114 /* The `emacs' switch turns on certain matching commands
    115    that make sense only in Emacs. */
    116 # ifdef emacs
    117 
    118 #  include "lisp.h"
    119 #  include "buffer.h"
    120 #  include "syntax.h"
    121 
    122 # else  /* not emacs */
    123 
    124 /* If we are not linking with Emacs proper,
    125    we can't use the relocating allocator
    126    even if config.h says that we can.  */
    127 #  undef REL_ALLOC
    128 
    129 #  if defined STDC_HEADERS || defined _LIBC
    130 #   include <stdlib.h>
    131 #  else
    132 char *malloc ();
    133 char *realloc ();
    134 #  endif
    135 
    136 /* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
    137    If nothing else has been done, use the method below.  */
    138 #  ifdef INHIBIT_STRING_HEADER
    139 #   if !(defined HAVE_BZERO && defined HAVE_BCOPY)
    140 #    if !defined bzero && !defined bcopy
    141 #     undef INHIBIT_STRING_HEADER
    142 #    endif
    143 #   endif
    144 #  endif
    145 
    146 /* This is the normal way of making sure we have a bcopy and a bzero.
    147    This is used in most programs--a few other programs avoid this
    148    by defining INHIBIT_STRING_HEADER.  */
    149 #  ifndef INHIBIT_STRING_HEADER
    150 #   if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
    151 #    include <string.h>
    152 #    ifndef bzero
    153 #     ifndef _LIBC
    154 #      define bzero(s, n)	((void) memset (s, '\0', n))
    155 #     else
    156 #      define bzero(s, n)	__bzero (s, n)
    157 #     endif
    158 #    endif
    159 #   else
    160 #    include <strings.h>
    161 #    ifndef memcmp
    162 #     define memcmp(s1, s2, n)	bcmp (s1, s2, n)
    163 #    endif
    164 #    ifndef memcpy
    165 #     define memcpy(d, s, n)	(bcopy (s, d, n), (d))
    166 #    endif
    167 #   endif
    168 #  endif
    169 
    170 /* Define the syntax stuff for \<, \>, etc.  */
    171 
    172 /* This must be nonzero for the wordchar and notwordchar pattern
    173    commands in re_match_2.  */
    174 #  ifndef Sword
    175 #   define Sword 1
    176 #  endif
    177 
    178 #  ifdef SWITCH_ENUM_BUG
    179 #   define SWITCH_ENUM_CAST(x) ((int)(x))
    180 #  else
    181 #   define SWITCH_ENUM_CAST(x) (x)
    182 #  endif
    183 
    184 # endif /* not emacs */
    185 
    186 # if defined _LIBC || HAVE_LIMITS_H
    187 #  include <limits.h>
    188 # endif
    189 
    190 # ifndef MB_LEN_MAX
    191 #  define MB_LEN_MAX 1
    192 # endif
    193 
    194 /* Get the interface, including the syntax bits.  */
    196 # include "xregex.h"  /* change for libiberty */
    197 
    198 /* isalpha etc. are used for the character classes.  */
    199 # include <ctype.h>
    200 
    201 /* Jim Meyering writes:
    202 
    203    "... Some ctype macros are valid only for character codes that
    204    isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when
    205    using /bin/cc or gcc but without giving an ansi option).  So, all
    206    ctype uses should be through macros like ISPRINT...  If
    207    STDC_HEADERS is defined, then autoconf has verified that the ctype
    208    macros don't need to be guarded with references to isascii. ...
    209    Defining isascii to 1 should let any compiler worth its salt
    210    eliminate the && through constant folding."
    211    Solaris defines some of these symbols so we must undefine them first.  */
    212 
    213 # undef ISASCII
    214 # if defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
    215 #  define ISASCII(c) 1
    216 # else
    217 #  define ISASCII(c) isascii(c)
    218 # endif
    219 
    220 # ifdef isblank
    221 #  define ISBLANK(c) (ISASCII (c) && isblank (c))
    222 # else
    223 #  define ISBLANK(c) ((c) == ' ' || (c) == '\t')
    224 # endif
    225 # ifdef isgraph
    226 #  define ISGRAPH(c) (ISASCII (c) && isgraph (c))
    227 # else
    228 #  define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
    229 # endif
    230 
    231 # undef ISPRINT
    232 # define ISPRINT(c) (ISASCII (c) && isprint (c))
    233 # define ISDIGIT(c) (ISASCII (c) && isdigit (c))
    234 # define ISALNUM(c) (ISASCII (c) && isalnum (c))
    235 # define ISALPHA(c) (ISASCII (c) && isalpha (c))
    236 # define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
    237 # define ISLOWER(c) (ISASCII (c) && islower (c))
    238 # define ISPUNCT(c) (ISASCII (c) && ispunct (c))
    239 # define ISSPACE(c) (ISASCII (c) && isspace (c))
    240 # define ISUPPER(c) (ISASCII (c) && isupper (c))
    241 # define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
    242 
    243 # ifdef _tolower
    244 #  define TOLOWER(c) _tolower(c)
    245 # else
    246 #  define TOLOWER(c) tolower(c)
    247 # endif
    248 
    249 # ifndef NULL
    250 #  define NULL (void *)0
    251 # endif
    252 
    253 /* We remove any previous definition of `SIGN_EXTEND_CHAR',
    254    since ours (we hope) works properly with all combinations of
    255    machines, compilers, `char' and `unsigned char' argument types.
    256    (Per Bothner suggested the basic approach.)  */
    257 # undef SIGN_EXTEND_CHAR
    258 # if __STDC__
    259 #  define SIGN_EXTEND_CHAR(c) ((signed char) (c))
    260 # else  /* not __STDC__ */
    261 /* As in Harbison and Steele.  */
    262 #  define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
    263 # endif
    264 
    265 # ifndef emacs
    267 /* How many characters in the character set.  */
    268 #  define CHAR_SET_SIZE 256
    269 
    270 #  ifdef SYNTAX_TABLE
    271 
    272 extern char *re_syntax_table;
    273 
    274 #  else /* not SYNTAX_TABLE */
    275 
    276 static char re_syntax_table[CHAR_SET_SIZE];
    277 
    278 static void init_syntax_once (void);
    279 
    280 static void
    281 init_syntax_once (void)
    282 {
    283    register int c;
    284    static int done = 0;
    285 
    286    if (done)
    287      return;
    288    bzero (re_syntax_table, sizeof re_syntax_table);
    289 
    290    for (c = 0; c < CHAR_SET_SIZE; ++c)
    291      if (ISALNUM (c))
    292 	re_syntax_table[c] = Sword;
    293 
    294    re_syntax_table['_'] = Sword;
    295 
    296    done = 1;
    297 }
    298 
    299 #  endif /* not SYNTAX_TABLE */
    300 
    301 #  define SYNTAX(c) re_syntax_table[(unsigned char) (c)]
    302 
    303 # endif /* emacs */
    304 
    305 /* Integer type for pointers.  */
    307 # if !defined _LIBC && !defined HAVE_UINTPTR_T
    308 typedef unsigned long int uintptr_t;
    309 # endif
    310 
    311 /* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we
    312    use `alloca' instead of `malloc'.  This is because using malloc in
    313    re_search* or re_match* could cause memory leaks when C-g is used in
    314    Emacs; also, malloc is slower and causes storage fragmentation.  On
    315    the other hand, malloc is more portable, and easier to debug.
    316 
    317    Because we sometimes use alloca, some routines have to be macros,
    318    not functions -- `alloca'-allocated space disappears at the end of the
    319    function it is called in.  */
    320 
    321 # ifdef REGEX_MALLOC
    322 
    323 #  define REGEX_ALLOCATE malloc
    324 #  define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)
    325 #  define REGEX_FREE free
    326 
    327 # else /* not REGEX_MALLOC  */
    328 
    329 /* Emacs already defines alloca, sometimes.  */
    330 #  ifndef alloca
    331 
    332 /* Make alloca work the best possible way.  */
    333 #   ifdef __GNUC__
    334 #    define alloca __builtin_alloca
    335 #   else /* not __GNUC__ */
    336 #    if HAVE_ALLOCA_H
    337 #     include <alloca.h>
    338 #    endif /* HAVE_ALLOCA_H */
    339 #   endif /* not __GNUC__ */
    340 
    341 #  endif /* not alloca */
    342 
    343 #  define REGEX_ALLOCATE alloca
    344 
    345 /* Assumes a `char *destination' variable.  */
    346 #  define REGEX_REALLOCATE(source, osize, nsize)			\
    347   (destination = (char *) alloca (nsize),				\
    348    memcpy (destination, source, osize))
    349 
    350 /* No need to do anything to free, after alloca.  */
    351 #  define REGEX_FREE(arg) ((void)0) /* Do nothing!  But inhibit gcc warning.  */
    352 
    353 # endif /* not REGEX_MALLOC */
    354 
    355 /* Define how to allocate the failure stack.  */
    356 
    357 # if defined REL_ALLOC && defined REGEX_MALLOC
    358 
    359 #  define REGEX_ALLOCATE_STACK(size)				\
    360   r_alloc (&failure_stack_ptr, (size))
    361 #  define REGEX_REALLOCATE_STACK(source, osize, nsize)		\
    362   r_re_alloc (&failure_stack_ptr, (nsize))
    363 #  define REGEX_FREE_STACK(ptr)					\
    364   r_alloc_free (&failure_stack_ptr)
    365 
    366 # else /* not using relocating allocator */
    367 
    368 #  ifdef REGEX_MALLOC
    369 
    370 #   define REGEX_ALLOCATE_STACK malloc
    371 #   define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize)
    372 #   define REGEX_FREE_STACK free
    373 
    374 #  else /* not REGEX_MALLOC */
    375 
    376 #   define REGEX_ALLOCATE_STACK alloca
    377 
    378 #   define REGEX_REALLOCATE_STACK(source, osize, nsize)			\
    379    REGEX_REALLOCATE (source, osize, nsize)
    380 /* No need to explicitly free anything.  */
    381 #   define REGEX_FREE_STACK(arg)
    382 
    383 #  endif /* not REGEX_MALLOC */
    384 # endif /* not using relocating allocator */
    385 
    386 
    387 /* True if `size1' is non-NULL and PTR is pointing anywhere inside
    388    `string1' or just past its end.  This works if PTR is NULL, which is
    389    a good thing.  */
    390 # define FIRST_STRING_P(ptr) 					\
    391   (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)
    392 
    393 /* (Re)Allocate N items of type T using malloc, or fail.  */
    394 # define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))
    395 # define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
    396 # define RETALLOC_IF(addr, n, t) \
    397   if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
    398 # define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))
    399 
    400 # define BYTEWIDTH 8 /* In bits.  */
    401 
    402 # define STREQ(s1, s2) ((strcmp (s1, s2) == 0))
    403 
    404 # undef MAX
    405 # undef MIN
    406 # define MAX(a, b) ((a) > (b) ? (a) : (b))
    407 # define MIN(a, b) ((a) < (b) ? (a) : (b))
    408 
    409 typedef char boolean;
    410 # define false 0
    411 # define true 1
    412 
    413 static reg_errcode_t byte_regex_compile (const char *pattern, size_t size,
    414                                          reg_syntax_t syntax,
    415                                          struct re_pattern_buffer *bufp);
    416 
    417 static int byte_re_match_2_internal (struct re_pattern_buffer *bufp,
    418                                      const char *string1, int size1,
    419                                      const char *string2, int size2,
    420                                      int pos,
    421                                      struct re_registers *regs,
    422                                      int stop);
    423 static int byte_re_search_2 (struct re_pattern_buffer *bufp,
    424                              const char *string1, int size1,
    425                              const char *string2, int size2,
    426                              int startpos, int range,
    427                              struct re_registers *regs, int stop);
    428 static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp);
    429 
    430 #ifdef MBS_SUPPORT
    431 static reg_errcode_t wcs_regex_compile (const char *pattern, size_t size,
    432                                         reg_syntax_t syntax,
    433                                         struct re_pattern_buffer *bufp);
    434 
    435 
    436 static int wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
    437                                     const char *cstring1, int csize1,
    438                                     const char *cstring2, int csize2,
    439                                     int pos,
    440                                     struct re_registers *regs,
    441                                     int stop,
    442                                     wchar_t *string1, int size1,
    443                                     wchar_t *string2, int size2,
    444                                     int *mbs_offset1, int *mbs_offset2);
    445 static int wcs_re_search_2 (struct re_pattern_buffer *bufp,
    446                             const char *string1, int size1,
    447                             const char *string2, int size2,
    448                             int startpos, int range,
    449                             struct re_registers *regs, int stop);
    450 static int wcs_re_compile_fastmap (struct re_pattern_buffer *bufp);
    451 #endif
    452 
    453 /* These are the command codes that appear in compiled regular
    455    expressions.  Some opcodes are followed by argument bytes.  A
    456    command code can specify any interpretation whatsoever for its
    457    arguments.  Zero bytes may appear in the compiled regular expression.  */
    458 
    459 typedef enum
    460 {
    461   no_op = 0,
    462 
    463   /* Succeed right away--no more backtracking.  */
    464   succeed,
    465 
    466         /* Followed by one byte giving n, then by n literal bytes.  */
    467   exactn,
    468 
    469 # ifdef MBS_SUPPORT
    470 	/* Same as exactn, but contains binary data.  */
    471   exactn_bin,
    472 # endif
    473 
    474         /* Matches any (more or less) character.  */
    475   anychar,
    476 
    477         /* Matches any one char belonging to specified set.  First
    478            following byte is number of bitmap bytes.  Then come bytes
    479            for a bitmap saying which chars are in.  Bits in each byte
    480            are ordered low-bit-first.  A character is in the set if its
    481            bit is 1.  A character too large to have a bit in the map is
    482            automatically not in the set.  */
    483         /* ifdef MBS_SUPPORT, following element is length of character
    484 	   classes, length of collating symbols, length of equivalence
    485 	   classes, length of character ranges, and length of characters.
    486 	   Next, character class element, collating symbols elements,
    487 	   equivalence class elements, range elements, and character
    488 	   elements follow.
    489 	   See regex_compile function.  */
    490   charset,
    491 
    492         /* Same parameters as charset, but match any character that is
    493            not one of those specified.  */
    494   charset_not,
    495 
    496         /* Start remembering the text that is matched, for storing in a
    497            register.  Followed by one byte with the register number, in
    498            the range 0 to one less than the pattern buffer's re_nsub
    499            field.  Then followed by one byte with the number of groups
    500            inner to this one.  (This last has to be part of the
    501            start_memory only because we need it in the on_failure_jump
    502            of re_match_2.)  */
    503   start_memory,
    504 
    505         /* Stop remembering the text that is matched and store it in a
    506            memory register.  Followed by one byte with the register
    507            number, in the range 0 to one less than `re_nsub' in the
    508            pattern buffer, and one byte with the number of inner groups,
    509            just like `start_memory'.  (We need the number of inner
    510            groups here because we don't have any easy way of finding the
    511            corresponding start_memory when we're at a stop_memory.)  */
    512   stop_memory,
    513 
    514         /* Match a duplicate of something remembered. Followed by one
    515            byte containing the register number.  */
    516   duplicate,
    517 
    518         /* Fail unless at beginning of line.  */
    519   begline,
    520 
    521         /* Fail unless at end of line.  */
    522   endline,
    523 
    524         /* Succeeds if at beginning of buffer (if emacs) or at beginning
    525            of string to be matched (if not).  */
    526   begbuf,
    527 
    528         /* Analogously, for end of buffer/string.  */
    529   endbuf,
    530 
    531         /* Followed by two byte relative address to which to jump.  */
    532   jump,
    533 
    534 	/* Same as jump, but marks the end of an alternative.  */
    535   jump_past_alt,
    536 
    537         /* Followed by two-byte relative address of place to resume at
    538            in case of failure.  */
    539         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    540   on_failure_jump,
    541 
    542         /* Like on_failure_jump, but pushes a placeholder instead of the
    543            current string position when executed.  */
    544   on_failure_keep_string_jump,
    545 
    546         /* Throw away latest failure point and then jump to following
    547            two-byte relative address.  */
    548         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    549   pop_failure_jump,
    550 
    551         /* Change to pop_failure_jump if know won't have to backtrack to
    552            match; otherwise change to jump.  This is used to jump
    553            back to the beginning of a repeat.  If what follows this jump
    554            clearly won't match what the repeat does, such that we can be
    555            sure that there is no use backtracking out of repetitions
    556            already matched, then we change it to a pop_failure_jump.
    557            Followed by two-byte address.  */
    558         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    559   maybe_pop_jump,
    560 
    561         /* Jump to following two-byte address, and push a dummy failure
    562            point. This failure point will be thrown away if an attempt
    563            is made to use it for a failure.  A `+' construct makes this
    564            before the first repeat.  Also used as an intermediary kind
    565            of jump when compiling an alternative.  */
    566         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    567   dummy_failure_jump,
    568 
    569 	/* Push a dummy failure point and continue.  Used at the end of
    570 	   alternatives.  */
    571   push_dummy_failure,
    572 
    573         /* Followed by two-byte relative address and two-byte number n.
    574            After matching N times, jump to the address upon failure.  */
    575         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    576   succeed_n,
    577 
    578         /* Followed by two-byte relative address, and two-byte number n.
    579            Jump to the address N times, then fail.  */
    580         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    581   jump_n,
    582 
    583         /* Set the following two-byte relative address to the
    584            subsequent two-byte number.  The address *includes* the two
    585            bytes of number.  */
    586         /* ifdef MBS_SUPPORT, the size of address is 1.  */
    587   set_number_at,
    588 
    589   wordchar,	/* Matches any word-constituent character.  */
    590   notwordchar,	/* Matches any char that is not a word-constituent.  */
    591 
    592   wordbeg,	/* Succeeds if at word beginning.  */
    593   wordend,	/* Succeeds if at word end.  */
    594 
    595   wordbound,	/* Succeeds if at a word boundary.  */
    596   notwordbound	/* Succeeds if not at a word boundary.  */
    597 
    598 # ifdef emacs
    599   ,before_dot,	/* Succeeds if before point.  */
    600   at_dot,	/* Succeeds if at point.  */
    601   after_dot,	/* Succeeds if after point.  */
    602 
    603 	/* Matches any character whose syntax is specified.  Followed by
    604            a byte which contains a syntax code, e.g., Sword.  */
    605   syntaxspec,
    606 
    607 	/* Matches any character whose syntax is not that specified.  */
    608   notsyntaxspec
    609 # endif /* emacs */
    610 } re_opcode_t;
    611 #endif /* not INSIDE_RECURSION */
    612 
    613 
    615 #ifdef BYTE
    616 # define CHAR_T char
    617 # define UCHAR_T unsigned char
    618 # define COMPILED_BUFFER_VAR bufp->buffer
    619 # define OFFSET_ADDRESS_SIZE 2
    620 # define PREFIX(name) byte_##name
    621 # define ARG_PREFIX(name) name
    622 # define PUT_CHAR(c) putchar (c)
    623 #else
    624 # ifdef WCHAR
    625 #  define CHAR_T wchar_t
    626 #  define UCHAR_T wchar_t
    627 #  define COMPILED_BUFFER_VAR wc_buffer
    628 #  define OFFSET_ADDRESS_SIZE 1 /* the size which STORE_NUMBER macro use */
    629 #  define CHAR_CLASS_SIZE ((__alignof__(wctype_t)+sizeof(wctype_t))/sizeof(CHAR_T)+1)
    630 #  define PREFIX(name) wcs_##name
    631 #  define ARG_PREFIX(name) c##name
    632 /* Should we use wide stream??  */
    633 #  define PUT_CHAR(c) printf ("%C", c);
    634 #  define TRUE 1
    635 #  define FALSE 0
    636 # else
    637 #  ifdef MBS_SUPPORT
    638 #   define WCHAR
    639 #   define INSIDE_RECURSION
    640 #   include "regex.c"
    641 #   undef INSIDE_RECURSION
    642 #  endif
    643 #  define BYTE
    644 #  define INSIDE_RECURSION
    645 #  include "regex.c"
    646 #  undef INSIDE_RECURSION
    647 # endif
    648 #endif
    649 
    650 #ifdef INSIDE_RECURSION
    651 /* Common operations on the compiled pattern.  */
    652 
    653 /* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
    654 /* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
    655 
    656 # ifdef WCHAR
    657 #  define STORE_NUMBER(destination, number)				\
    658   do {									\
    659     *(destination) = (UCHAR_T)(number);				\
    660   } while (0)
    661 # else /* BYTE */
    662 #  define STORE_NUMBER(destination, number)				\
    663   do {									\
    664     (destination)[0] = (number) & 0377;					\
    665     (destination)[1] = (number) >> 8;					\
    666   } while (0)
    667 # endif /* WCHAR */
    668 
    669 /* Same as STORE_NUMBER, except increment DESTINATION to
    670    the byte after where the number is stored.  Therefore, DESTINATION
    671    must be an lvalue.  */
    672 /* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
    673 
    674 # define STORE_NUMBER_AND_INCR(destination, number)			\
    675   do {									\
    676     STORE_NUMBER (destination, number);					\
    677     (destination) += OFFSET_ADDRESS_SIZE;				\
    678   } while (0)
    679 
    680 /* Put into DESTINATION a number stored in two contiguous bytes starting
    681    at SOURCE.  */
    682 /* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
    683 
    684 # ifdef WCHAR
    685 #  define EXTRACT_NUMBER(destination, source)				\
    686   do {									\
    687     (destination) = *(source);						\
    688   } while (0)
    689 # else /* BYTE */
    690 #  define EXTRACT_NUMBER(destination, source)				\
    691   do {									\
    692     (destination) = *(source) & 0377;					\
    693     (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8;		\
    694   } while (0)
    695 # endif
    696 
    697 # ifdef DEBUG
    698 static void PREFIX(extract_number) (int *dest, UCHAR_T *source);
    699 static void
    700 PREFIX(extract_number) (int *dest, UCHAR_T *source)
    701 {
    702 #  ifdef WCHAR
    703   *dest = *source;
    704 #  else /* BYTE */
    705   int temp = SIGN_EXTEND_CHAR (*(source + 1));
    706   *dest = *source & 0377;
    707   *dest += temp << 8;
    708 #  endif
    709 }
    710 
    711 #  ifndef EXTRACT_MACROS /* To debug the macros.  */
    712 #   undef EXTRACT_NUMBER
    713 #   define EXTRACT_NUMBER(dest, src) PREFIX(extract_number) (&dest, src)
    714 #  endif /* not EXTRACT_MACROS */
    715 
    716 # endif /* DEBUG */
    717 
    718 /* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
    719    SOURCE must be an lvalue.  */
    720 
    721 # define EXTRACT_NUMBER_AND_INCR(destination, source)			\
    722   do {									\
    723     EXTRACT_NUMBER (destination, source);				\
    724     (source) += OFFSET_ADDRESS_SIZE; 					\
    725   } while (0)
    726 
    727 # ifdef DEBUG
    728 static void PREFIX(extract_number_and_incr) (int *destination,
    729                                              UCHAR_T **source);
    730 static void
    731 PREFIX(extract_number_and_incr) (int *destination, UCHAR_T **source)
    732 {
    733   PREFIX(extract_number) (destination, *source);
    734   *source += OFFSET_ADDRESS_SIZE;
    735 }
    736 
    737 #  ifndef EXTRACT_MACROS
    738 #   undef EXTRACT_NUMBER_AND_INCR
    739 #   define EXTRACT_NUMBER_AND_INCR(dest, src) \
    740   PREFIX(extract_number_and_incr) (&dest, &src)
    741 #  endif /* not EXTRACT_MACROS */
    742 
    743 # endif /* DEBUG */
    744 
    745 
    746 
    748 /* If DEBUG is defined, Regex prints many voluminous messages about what
    749    it is doing (if the variable `debug' is nonzero).  If linked with the
    750    main program in `iregex.c', you can enter patterns and strings
    751    interactively.  And if linked with the main program in `main.c' and
    752    the other test files, you can run the already-written tests.  */
    753 
    754 # ifdef DEBUG
    755 
    756 #  ifndef DEFINED_ONCE
    757 
    758 /* We use standard I/O for debugging.  */
    759 #   include <stdio.h>
    760 
    761 /* It is useful to test things that ``must'' be true when debugging.  */
    762 #   include <assert.h>
    763 
    764 static int debug;
    765 
    766 #   define DEBUG_STATEMENT(e) e
    767 #   define DEBUG_PRINT1(x) if (debug) printf (x)
    768 #   define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)
    769 #   define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)
    770 #   define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
    771 #  endif /* not DEFINED_ONCE */
    772 
    773 #  define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) 			\
    774   if (debug) PREFIX(print_partial_compiled_pattern) (s, e)
    775 #  define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)		\
    776   if (debug) PREFIX(print_double_string) (w, s1, sz1, s2, sz2)
    777 
    778 
    779 /* Print the fastmap in human-readable form.  */
    780 
    781 #  ifndef DEFINED_ONCE
    782 void
    783 print_fastmap (char *fastmap)
    784 {
    785   unsigned was_a_range = 0;
    786   unsigned i = 0;
    787 
    788   while (i < (1 << BYTEWIDTH))
    789     {
    790       if (fastmap[i++])
    791 	{
    792 	  was_a_range = 0;
    793           putchar (i - 1);
    794           while (i < (1 << BYTEWIDTH)  &&  fastmap[i])
    795             {
    796               was_a_range = 1;
    797               i++;
    798             }
    799 	  if (was_a_range)
    800             {
    801               printf ("-");
    802               putchar (i - 1);
    803             }
    804         }
    805     }
    806   putchar ('\n');
    807 }
    808 #  endif /* not DEFINED_ONCE */
    809 
    810 
    811 /* Print a compiled pattern string in human-readable form, starting at
    812    the START pointer into it and ending just before the pointer END.  */
    813 
    814 void
    815 PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end)
    816 {
    817   int mcnt, mcnt2;
    818   UCHAR_T *p1;
    819   UCHAR_T *p = start;
    820   UCHAR_T *pend = end;
    821 
    822   if (start == NULL)
    823     {
    824       printf ("(null)\n");
    825       return;
    826     }
    827 
    828   /* Loop over pattern commands.  */
    829   while (p < pend)
    830     {
    831 #  ifdef _LIBC
    832       printf ("%td:\t", p - start);
    833 #  else
    834       printf ("%ld:\t", (long int) (p - start));
    835 #  endif
    836 
    837       switch ((re_opcode_t) *p++)
    838 	{
    839         case no_op:
    840           printf ("/no_op");
    841           break;
    842 
    843 	case exactn:
    844 	  mcnt = *p++;
    845           printf ("/exactn/%d", mcnt);
    846           do
    847 	    {
    848               putchar ('/');
    849 	      PUT_CHAR (*p++);
    850             }
    851           while (--mcnt);
    852           break;
    853 
    854 #  ifdef MBS_SUPPORT
    855 	case exactn_bin:
    856 	  mcnt = *p++;
    857 	  printf ("/exactn_bin/%d", mcnt);
    858           do
    859 	    {
    860 	      printf("/%lx", (long int) *p++);
    861             }
    862           while (--mcnt);
    863           break;
    864 #  endif /* MBS_SUPPORT */
    865 
    866 	case start_memory:
    867           mcnt = *p++;
    868           printf ("/start_memory/%d/%ld", mcnt, (long int) *p++);
    869           break;
    870 
    871 	case stop_memory:
    872           mcnt = *p++;
    873 	  printf ("/stop_memory/%d/%ld", mcnt, (long int) *p++);
    874           break;
    875 
    876 	case duplicate:
    877 	  printf ("/duplicate/%ld", (long int) *p++);
    878 	  break;
    879 
    880 	case anychar:
    881 	  printf ("/anychar");
    882 	  break;
    883 
    884 	case charset:
    885         case charset_not:
    886           {
    887 #  ifdef WCHAR
    888 	    int i, length;
    889 	    wchar_t *workp = p;
    890 	    printf ("/charset [%s",
    891 	            (re_opcode_t) *(workp - 1) == charset_not ? "^" : "");
    892 	    p += 5;
    893 	    length = *workp++; /* the length of char_classes */
    894 	    for (i=0 ; i<length ; i++)
    895 	      printf("[:%lx:]", (long int) *p++);
    896 	    length = *workp++; /* the length of collating_symbol */
    897 	    for (i=0 ; i<length ;)
    898 	      {
    899 		printf("[.");
    900 		while(*p != 0)
    901 		  PUT_CHAR((i++,*p++));
    902 		i++,p++;
    903 		printf(".]");
    904 	      }
    905 	    length = *workp++; /* the length of equivalence_class */
    906 	    for (i=0 ; i<length ;)
    907 	      {
    908 		printf("[=");
    909 		while(*p != 0)
    910 		  PUT_CHAR((i++,*p++));
    911 		i++,p++;
    912 		printf("=]");
    913 	      }
    914 	    length = *workp++; /* the length of char_range */
    915 	    for (i=0 ; i<length ; i++)
    916 	      {
    917 		wchar_t range_start = *p++;
    918 		wchar_t range_end = *p++;
    919 		printf("%C-%C", range_start, range_end);
    920 	      }
    921 	    length = *workp++; /* the length of char */
    922 	    for (i=0 ; i<length ; i++)
    923 	      printf("%C", *p++);
    924 	    putchar (']');
    925 #  else
    926             register int c, last = -100;
    927 	    register int in_range = 0;
    928 
    929 	    printf ("/charset [%s",
    930 	            (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
    931 
    932             assert (p + *p < pend);
    933 
    934             for (c = 0; c < 256; c++)
    935 	      if (c / 8 < *p
    936 		  && (p[1 + (c/8)] & (1 << (c % 8))))
    937 		{
    938 		  /* Are we starting a range?  */
    939 		  if (last + 1 == c && ! in_range)
    940 		    {
    941 		      putchar ('-');
    942 		      in_range = 1;
    943 		    }
    944 		  /* Have we broken a range?  */
    945 		  else if (last + 1 != c && in_range)
    946               {
    947 		      putchar (last);
    948 		      in_range = 0;
    949 		    }
    950 
    951 		  if (! in_range)
    952 		    putchar (c);
    953 
    954 		  last = c;
    955               }
    956 
    957 	    if (in_range)
    958 	      putchar (last);
    959 
    960 	    putchar (']');
    961 
    962 	    p += 1 + *p;
    963 #  endif /* WCHAR */
    964 	  }
    965 	  break;
    966 
    967 	case begline:
    968 	  printf ("/begline");
    969           break;
    970 
    971 	case endline:
    972           printf ("/endline");
    973           break;
    974 
    975 	case on_failure_jump:
    976           PREFIX(extract_number_and_incr) (&mcnt, &p);
    977 #  ifdef _LIBC
    978   	  printf ("/on_failure_jump to %td", p + mcnt - start);
    979 #  else
    980   	  printf ("/on_failure_jump to %ld", (long int) (p + mcnt - start));
    981 #  endif
    982           break;
    983 
    984 	case on_failure_keep_string_jump:
    985           PREFIX(extract_number_and_incr) (&mcnt, &p);
    986 #  ifdef _LIBC
    987   	  printf ("/on_failure_keep_string_jump to %td", p + mcnt - start);
    988 #  else
    989   	  printf ("/on_failure_keep_string_jump to %ld",
    990 		  (long int) (p + mcnt - start));
    991 #  endif
    992           break;
    993 
    994 	case dummy_failure_jump:
    995           PREFIX(extract_number_and_incr) (&mcnt, &p);
    996 #  ifdef _LIBC
    997   	  printf ("/dummy_failure_jump to %td", p + mcnt - start);
    998 #  else
    999   	  printf ("/dummy_failure_jump to %ld", (long int) (p + mcnt - start));
   1000 #  endif
   1001           break;
   1002 
   1003 	case push_dummy_failure:
   1004           printf ("/push_dummy_failure");
   1005           break;
   1006 
   1007         case maybe_pop_jump:
   1008           PREFIX(extract_number_and_incr) (&mcnt, &p);
   1009 #  ifdef _LIBC
   1010   	  printf ("/maybe_pop_jump to %td", p + mcnt - start);
   1011 #  else
   1012   	  printf ("/maybe_pop_jump to %ld", (long int) (p + mcnt - start));
   1013 #  endif
   1014 	  break;
   1015 
   1016         case pop_failure_jump:
   1017 	  PREFIX(extract_number_and_incr) (&mcnt, &p);
   1018 #  ifdef _LIBC
   1019   	  printf ("/pop_failure_jump to %td", p + mcnt - start);
   1020 #  else
   1021   	  printf ("/pop_failure_jump to %ld", (long int) (p + mcnt - start));
   1022 #  endif
   1023 	  break;
   1024 
   1025         case jump_past_alt:
   1026 	  PREFIX(extract_number_and_incr) (&mcnt, &p);
   1027 #  ifdef _LIBC
   1028   	  printf ("/jump_past_alt to %td", p + mcnt - start);
   1029 #  else
   1030   	  printf ("/jump_past_alt to %ld", (long int) (p + mcnt - start));
   1031 #  endif
   1032 	  break;
   1033 
   1034         case jump:
   1035 	  PREFIX(extract_number_and_incr) (&mcnt, &p);
   1036 #  ifdef _LIBC
   1037   	  printf ("/jump to %td", p + mcnt - start);
   1038 #  else
   1039   	  printf ("/jump to %ld", (long int) (p + mcnt - start));
   1040 #  endif
   1041 	  break;
   1042 
   1043         case succeed_n:
   1044           PREFIX(extract_number_and_incr) (&mcnt, &p);
   1045 	  p1 = p + mcnt;
   1046           PREFIX(extract_number_and_incr) (&mcnt2, &p);
   1047 #  ifdef _LIBC
   1048 	  printf ("/succeed_n to %td, %d times", p1 - start, mcnt2);
   1049 #  else
   1050 	  printf ("/succeed_n to %ld, %d times",
   1051 		  (long int) (p1 - start), mcnt2);
   1052 #  endif
   1053           break;
   1054 
   1055         case jump_n:
   1056           PREFIX(extract_number_and_incr) (&mcnt, &p);
   1057 	  p1 = p + mcnt;
   1058           PREFIX(extract_number_and_incr) (&mcnt2, &p);
   1059 	  printf ("/jump_n to %d, %d times", p1 - start, mcnt2);
   1060           break;
   1061 
   1062         case set_number_at:
   1063           PREFIX(extract_number_and_incr) (&mcnt, &p);
   1064 	  p1 = p + mcnt;
   1065           PREFIX(extract_number_and_incr) (&mcnt2, &p);
   1066 #  ifdef _LIBC
   1067 	  printf ("/set_number_at location %td to %d", p1 - start, mcnt2);
   1068 #  else
   1069 	  printf ("/set_number_at location %ld to %d",
   1070 		  (long int) (p1 - start), mcnt2);
   1071 #  endif
   1072           break;
   1073 
   1074         case wordbound:
   1075 	  printf ("/wordbound");
   1076 	  break;
   1077 
   1078 	case notwordbound:
   1079 	  printf ("/notwordbound");
   1080           break;
   1081 
   1082 	case wordbeg:
   1083 	  printf ("/wordbeg");
   1084 	  break;
   1085 
   1086 	case wordend:
   1087 	  printf ("/wordend");
   1088 	  break;
   1089 
   1090 #  ifdef emacs
   1091 	case before_dot:
   1092 	  printf ("/before_dot");
   1093           break;
   1094 
   1095 	case at_dot:
   1096 	  printf ("/at_dot");
   1097           break;
   1098 
   1099 	case after_dot:
   1100 	  printf ("/after_dot");
   1101           break;
   1102 
   1103 	case syntaxspec:
   1104           printf ("/syntaxspec");
   1105 	  mcnt = *p++;
   1106 	  printf ("/%d", mcnt);
   1107           break;
   1108 
   1109 	case notsyntaxspec:
   1110           printf ("/notsyntaxspec");
   1111 	  mcnt = *p++;
   1112 	  printf ("/%d", mcnt);
   1113 	  break;
   1114 #  endif /* emacs */
   1115 
   1116 	case wordchar:
   1117 	  printf ("/wordchar");
   1118           break;
   1119 
   1120 	case notwordchar:
   1121 	  printf ("/notwordchar");
   1122           break;
   1123 
   1124 	case begbuf:
   1125 	  printf ("/begbuf");
   1126           break;
   1127 
   1128 	case endbuf:
   1129 	  printf ("/endbuf");
   1130           break;
   1131 
   1132         default:
   1133           printf ("?%ld", (long int) *(p-1));
   1134 	}
   1135 
   1136       putchar ('\n');
   1137     }
   1138 
   1139 #  ifdef _LIBC
   1140   printf ("%td:\tend of pattern.\n", p - start);
   1141 #  else
   1142   printf ("%ld:\tend of pattern.\n", (long int) (p - start));
   1143 #  endif
   1144 }
   1145 
   1146 
   1147 void
   1148 PREFIX(print_compiled_pattern) (struct re_pattern_buffer *bufp)
   1149 {
   1150   UCHAR_T *buffer = (UCHAR_T*) bufp->buffer;
   1151 
   1152   PREFIX(print_partial_compiled_pattern) (buffer, buffer
   1153 				  + bufp->used / sizeof(UCHAR_T));
   1154   printf ("%ld bytes used/%ld bytes allocated.\n",
   1155 	  bufp->used, bufp->allocated);
   1156 
   1157   if (bufp->fastmap_accurate && bufp->fastmap)
   1158     {
   1159       printf ("fastmap: ");
   1160       print_fastmap (bufp->fastmap);
   1161     }
   1162 
   1163 #  ifdef _LIBC
   1164   printf ("re_nsub: %Zd\t", bufp->re_nsub);
   1165 #  else
   1166   printf ("re_nsub: %ld\t", (long int) bufp->re_nsub);
   1167 #  endif
   1168   printf ("regs_alloc: %d\t", bufp->regs_allocated);
   1169   printf ("can_be_null: %d\t", bufp->can_be_null);
   1170   printf ("newline_anchor: %d\n", bufp->newline_anchor);
   1171   printf ("no_sub: %d\t", bufp->no_sub);
   1172   printf ("not_bol: %d\t", bufp->not_bol);
   1173   printf ("not_eol: %d\t", bufp->not_eol);
   1174   printf ("syntax: %lx\n", bufp->syntax);
   1175   /* Perhaps we should print the translate table?  */
   1176 }
   1177 
   1178 
   1179 void
   1180 PREFIX(print_double_string) (const CHAR_T *where, const CHAR_T *string1,
   1181                              int size1, const CHAR_T *string2, int size2)
   1182 {
   1183   int this_char;
   1184 
   1185   if (where == NULL)
   1186     printf ("(null)");
   1187   else
   1188     {
   1189       int cnt;
   1190 
   1191       if (FIRST_STRING_P (where))
   1192         {
   1193           for (this_char = where - string1; this_char < size1; this_char++)
   1194 	    PUT_CHAR (string1[this_char]);
   1195 
   1196           where = string2;
   1197         }
   1198 
   1199       cnt = 0;
   1200       for (this_char = where - string2; this_char < size2; this_char++)
   1201 	{
   1202 	  PUT_CHAR (string2[this_char]);
   1203 	  if (++cnt > 100)
   1204 	    {
   1205 	      fputs ("...", stdout);
   1206 	      break;
   1207 	    }
   1208 	}
   1209     }
   1210 }
   1211 
   1212 #  ifndef DEFINED_ONCE
   1213 void
   1214 printchar (int c)
   1215 {
   1216   putc (c, stderr);
   1217 }
   1218 #  endif
   1219 
   1220 # else /* not DEBUG */
   1221 
   1222 #  ifndef DEFINED_ONCE
   1223 #   undef assert
   1224 #   define assert(e)
   1225 
   1226 #   define DEBUG_STATEMENT(e)
   1227 #   define DEBUG_PRINT1(x)
   1228 #   define DEBUG_PRINT2(x1, x2)
   1229 #   define DEBUG_PRINT3(x1, x2, x3)
   1230 #   define DEBUG_PRINT4(x1, x2, x3, x4)
   1231 #  endif /* not DEFINED_ONCE */
   1232 #  define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
   1233 #  define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
   1234 
   1235 # endif /* not DEBUG */
   1236 
   1237 
   1238 
   1240 # ifdef WCHAR
   1241 /* This  convert a multibyte string to a wide character string.
   1242    And write their correspondances to offset_buffer(see below)
   1243    and write whether each wchar_t is binary data to is_binary.
   1244    This assume invalid multibyte sequences as binary data.
   1245    We assume offset_buffer and is_binary is already allocated
   1246    enough space.  */
   1247 
   1248 static size_t convert_mbs_to_wcs (CHAR_T *dest, const unsigned char* src,
   1249 				  size_t len, int *offset_buffer,
   1250 				  char *is_binary);
   1251 static size_t
   1252 convert_mbs_to_wcs (CHAR_T *dest, const unsigned char*src, size_t len,
   1253                     int *offset_buffer, char *is_binary)
   1254      /* It hold correspondances between src(char string) and
   1255 	dest(wchar_t string) for optimization.
   1256 	e.g. src  = "xxxyzz"
   1257              dest = {'X', 'Y', 'Z'}
   1258 	      (each "xxx", "y" and "zz" represent one multibyte character
   1259 	       corresponding to 'X', 'Y' and 'Z'.)
   1260 	  offset_buffer = {0, 0+3("xxx"), 0+3+1("y"), 0+3+1+2("zz")}
   1261 	  	        = {0, 3, 4, 6}
   1262      */
   1263 {
   1264   wchar_t *pdest = dest;
   1265   const unsigned char *psrc = src;
   1266   size_t wc_count = 0;
   1267 
   1268   mbstate_t mbs;
   1269   int i, consumed;
   1270   size_t mb_remain = len;
   1271   size_t mb_count = 0;
   1272 
   1273   /* Initialize the conversion state.  */
   1274   memset (&mbs, 0, sizeof (mbstate_t));
   1275 
   1276   offset_buffer[0] = 0;
   1277   for( ; mb_remain > 0 ; ++wc_count, ++pdest, mb_remain -= consumed,
   1278 	 psrc += consumed)
   1279     {
   1280 #ifdef _LIBC
   1281       consumed = __mbrtowc (pdest, psrc, mb_remain, &mbs);
   1282 #else
   1283       consumed = mbrtowc (pdest, psrc, mb_remain, &mbs);
   1284 #endif
   1285 
   1286       if (consumed <= 0)
   1287 	/* failed to convert. maybe src contains binary data.
   1288 	   So we consume 1 byte manualy.  */
   1289 	{
   1290 	  *pdest = *psrc;
   1291 	  consumed = 1;
   1292 	  is_binary[wc_count] = TRUE;
   1293 	}
   1294       else
   1295 	is_binary[wc_count] = FALSE;
   1296       /* In sjis encoding, we use yen sign as escape character in
   1297 	 place of reverse solidus. So we convert 0x5c(yen sign in
   1298 	 sjis) to not 0xa5(yen sign in UCS2) but 0x5c(reverse
   1299 	 solidus in UCS2).  */
   1300       if (consumed == 1 && (int) *psrc == 0x5c && (int) *pdest == 0xa5)
   1301 	*pdest = (wchar_t) *psrc;
   1302 
   1303       offset_buffer[wc_count + 1] = mb_count += consumed;
   1304     }
   1305 
   1306   /* Fill remain of the buffer with sentinel.  */
   1307   for (i = wc_count + 1 ; i <= len ; i++)
   1308     offset_buffer[i] = mb_count + 1;
   1309 
   1310   return wc_count;
   1311 }
   1312 
   1313 # endif /* WCHAR */
   1314 
   1315 #else /* not INSIDE_RECURSION */
   1316 
   1317 /* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
   1318    also be assigned to arbitrarily: each pattern buffer stores its own
   1319    syntax, so it can be changed between regex compilations.  */
   1320 /* This has no initializer because initialized variables in Emacs
   1321    become read-only after dumping.  */
   1322 reg_syntax_t re_syntax_options;
   1323 
   1324 
   1325 /* Specify the precise syntax of regexps for compilation.  This provides
   1326    for compatibility for various utilities which historically have
   1327    different, incompatible syntaxes.
   1328 
   1329    The argument SYNTAX is a bit mask comprised of the various bits
   1330    defined in regex.h.  We return the old syntax.  */
   1331 
   1332 reg_syntax_t
   1333 re_set_syntax (reg_syntax_t syntax)
   1334 {
   1335   reg_syntax_t ret = re_syntax_options;
   1336 
   1337   re_syntax_options = syntax;
   1338 # ifdef DEBUG
   1339   if (syntax & RE_DEBUG)
   1340     debug = 1;
   1341   else if (debug) /* was on but now is not */
   1342     debug = 0;
   1343 # endif /* DEBUG */
   1344   return ret;
   1345 }
   1346 # ifdef _LIBC
   1347 weak_alias (__re_set_syntax, re_set_syntax)
   1348 # endif
   1349 
   1350 /* This table gives an error message for each of the error codes listed
   1352    in regex.h.  Obviously the order here has to be same as there.
   1353    POSIX doesn't require that we do anything for REG_NOERROR,
   1354    but why not be nice?  */
   1355 
   1356 static const char *re_error_msgid[] =
   1357   {
   1358     gettext_noop ("Success"),	/* REG_NOERROR */
   1359     gettext_noop ("No match"),	/* REG_NOMATCH */
   1360     gettext_noop ("Invalid regular expression"), /* REG_BADPAT */
   1361     gettext_noop ("Invalid collation character"), /* REG_ECOLLATE */
   1362     gettext_noop ("Invalid character class name"), /* REG_ECTYPE */
   1363     gettext_noop ("Trailing backslash"), /* REG_EESCAPE */
   1364     gettext_noop ("Invalid back reference"), /* REG_ESUBREG */
   1365     gettext_noop ("Unmatched [ or [^"),	/* REG_EBRACK */
   1366     gettext_noop ("Unmatched ( or \\("), /* REG_EPAREN */
   1367     gettext_noop ("Unmatched \\{"), /* REG_EBRACE */
   1368     gettext_noop ("Invalid content of \\{\\}"), /* REG_BADBR */
   1369     gettext_noop ("Invalid range end"),	/* REG_ERANGE */
   1370     gettext_noop ("Memory exhausted"), /* REG_ESPACE */
   1371     gettext_noop ("Invalid preceding regular expression"), /* REG_BADRPT */
   1372     gettext_noop ("Premature end of regular expression"), /* REG_EEND */
   1373     gettext_noop ("Regular expression too big"), /* REG_ESIZE */
   1374     gettext_noop ("Unmatched ) or \\)") /* REG_ERPAREN */
   1375   };
   1376 
   1377 #endif /* INSIDE_RECURSION */
   1379 
   1380 #ifndef DEFINED_ONCE
   1381 /* Avoiding alloca during matching, to placate r_alloc.  */
   1382 
   1383 /* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
   1384    searching and matching functions should not call alloca.  On some
   1385    systems, alloca is implemented in terms of malloc, and if we're
   1386    using the relocating allocator routines, then malloc could cause a
   1387    relocation, which might (if the strings being searched are in the
   1388    ralloc heap) shift the data out from underneath the regexp
   1389    routines.
   1390 
   1391    Here's another reason to avoid allocation: Emacs
   1392    processes input from X in a signal handler; processing X input may
   1393    call malloc; if input arrives while a matching routine is calling
   1394    malloc, then we're scrod.  But Emacs can't just block input while
   1395    calling matching routines; then we don't notice interrupts when
   1396    they come in.  So, Emacs blocks input around all regexp calls
   1397    except the matching calls, which it leaves unprotected, in the
   1398    faith that they will not malloc.  */
   1399 
   1400 /* Normally, this is fine.  */
   1401 # define MATCH_MAY_ALLOCATE
   1402 
   1403 /* When using GNU C, we are not REALLY using the C alloca, no matter
   1404    what config.h may say.  So don't take precautions for it.  */
   1405 # ifdef __GNUC__
   1406 #  undef C_ALLOCA
   1407 # endif
   1408 
   1409 /* The match routines may not allocate if (1) they would do it with malloc
   1410    and (2) it's not safe for them to use malloc.
   1411    Note that if REL_ALLOC is defined, matching would not use malloc for the
   1412    failure stack, but we would still use it for the register vectors;
   1413    so REL_ALLOC should not affect this.  */
   1414 # if (defined C_ALLOCA || defined REGEX_MALLOC) && defined emacs
   1415 #  undef MATCH_MAY_ALLOCATE
   1416 # endif
   1417 #endif /* not DEFINED_ONCE */
   1418 
   1419 #ifdef INSIDE_RECURSION
   1421 /* Failure stack declarations and macros; both re_compile_fastmap and
   1422    re_match_2 use a failure stack.  These have to be macros because of
   1423    REGEX_ALLOCATE_STACK.  */
   1424 
   1425 
   1426 /* Number of failure points for which to initially allocate space
   1427    when matching.  If this number is exceeded, we allocate more
   1428    space, so it is not a hard limit.  */
   1429 # ifndef INIT_FAILURE_ALLOC
   1430 #  define INIT_FAILURE_ALLOC 5
   1431 # endif
   1432 
   1433 /* Roughly the maximum number of failure points on the stack.  Would be
   1434    exactly that if always used MAX_FAILURE_ITEMS items each time we failed.
   1435    This is a variable only so users of regex can assign to it; we never
   1436    change it ourselves.  */
   1437 
   1438 # ifdef INT_IS_16BIT
   1439 
   1440 #  ifndef DEFINED_ONCE
   1441 #   if defined MATCH_MAY_ALLOCATE
   1442 /* 4400 was enough to cause a crash on Alpha OSF/1,
   1443    whose default stack limit is 2mb.  */
   1444 long int re_max_failures = 4000;
   1445 #   else
   1446 long int re_max_failures = 2000;
   1447 #   endif
   1448 #  endif
   1449 
   1450 union PREFIX(fail_stack_elt)
   1451 {
   1452   UCHAR_T *pointer;
   1453   long int integer;
   1454 };
   1455 
   1456 typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
   1457 
   1458 typedef struct
   1459 {
   1460   PREFIX(fail_stack_elt_t) *stack;
   1461   unsigned long int size;
   1462   unsigned long int avail;		/* Offset of next open position.  */
   1463 } PREFIX(fail_stack_type);
   1464 
   1465 # else /* not INT_IS_16BIT */
   1466 
   1467 #  ifndef DEFINED_ONCE
   1468 #   if defined MATCH_MAY_ALLOCATE
   1469 /* 4400 was enough to cause a crash on Alpha OSF/1,
   1470    whose default stack limit is 2mb.  */
   1471 int re_max_failures = 4000;
   1472 #   else
   1473 int re_max_failures = 2000;
   1474 #   endif
   1475 #  endif
   1476 
   1477 union PREFIX(fail_stack_elt)
   1478 {
   1479   UCHAR_T *pointer;
   1480   int integer;
   1481 };
   1482 
   1483 typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
   1484 
   1485 typedef struct
   1486 {
   1487   PREFIX(fail_stack_elt_t) *stack;
   1488   unsigned size;
   1489   unsigned avail;			/* Offset of next open position.  */
   1490 } PREFIX(fail_stack_type);
   1491 
   1492 # endif /* INT_IS_16BIT */
   1493 
   1494 # ifndef DEFINED_ONCE
   1495 #  define FAIL_STACK_EMPTY()     (fail_stack.avail == 0)
   1496 #  define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)
   1497 #  define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)
   1498 # endif
   1499 
   1500 
   1501 /* Define macros to initialize and free the failure stack.
   1502    Do `return -2' if the alloc fails.  */
   1503 
   1504 # ifdef MATCH_MAY_ALLOCATE
   1505 #  define INIT_FAIL_STACK()						\
   1506   do {									\
   1507     fail_stack.stack = (PREFIX(fail_stack_elt_t) *)		\
   1508       REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (PREFIX(fail_stack_elt_t))); \
   1509 									\
   1510     if (fail_stack.stack == NULL)				\
   1511       return -2;							\
   1512 									\
   1513     fail_stack.size = INIT_FAILURE_ALLOC;			\
   1514     fail_stack.avail = 0;					\
   1515   } while (0)
   1516 
   1517 #  define RESET_FAIL_STACK()  REGEX_FREE_STACK (fail_stack.stack)
   1518 # else
   1519 #  define INIT_FAIL_STACK()						\
   1520   do {									\
   1521     fail_stack.avail = 0;					\
   1522   } while (0)
   1523 
   1524 #  define RESET_FAIL_STACK()
   1525 # endif
   1526 
   1527 
   1528 /* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.
   1529 
   1530    Return 1 if succeeds, and 0 if either ran out of memory
   1531    allocating space for it or it was already too large.
   1532 
   1533    REGEX_REALLOCATE_STACK requires `destination' be declared.   */
   1534 
   1535 # define DOUBLE_FAIL_STACK(fail_stack)					\
   1536   ((fail_stack).size > (unsigned) (re_max_failures * MAX_FAILURE_ITEMS)	\
   1537    ? 0									\
   1538    : ((fail_stack).stack = (PREFIX(fail_stack_elt_t) *)			\
   1539         REGEX_REALLOCATE_STACK ((fail_stack).stack, 			\
   1540           (fail_stack).size * sizeof (PREFIX(fail_stack_elt_t)),	\
   1541           ((fail_stack).size << 1) * sizeof (PREFIX(fail_stack_elt_t))),\
   1542 									\
   1543       (fail_stack).stack == NULL					\
   1544       ? 0								\
   1545       : ((fail_stack).size <<= 1, 					\
   1546          1)))
   1547 
   1548 
   1549 /* Push pointer POINTER on FAIL_STACK.
   1550    Return 1 if was able to do so and 0 if ran out of memory allocating
   1551    space to do so.  */
   1552 # define PUSH_PATTERN_OP(POINTER, FAIL_STACK)				\
   1553   ((FAIL_STACK_FULL ()							\
   1554     && !DOUBLE_FAIL_STACK (FAIL_STACK))					\
   1555    ? 0									\
   1556    : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER,	\
   1557       1))
   1558 
   1559 /* Push a pointer value onto the failure stack.
   1560    Assumes the variable `fail_stack'.  Probably should only
   1561    be called from within `PUSH_FAILURE_POINT'.  */
   1562 # define PUSH_FAILURE_POINTER(item)					\
   1563   fail_stack.stack[fail_stack.avail++].pointer = (UCHAR_T *) (item)
   1564 
   1565 /* This pushes an integer-valued item onto the failure stack.
   1566    Assumes the variable `fail_stack'.  Probably should only
   1567    be called from within `PUSH_FAILURE_POINT'.  */
   1568 # define PUSH_FAILURE_INT(item)					\
   1569   fail_stack.stack[fail_stack.avail++].integer = (item)
   1570 
   1571 /* Push a fail_stack_elt_t value onto the failure stack.
   1572    Assumes the variable `fail_stack'.  Probably should only
   1573    be called from within `PUSH_FAILURE_POINT'.  */
   1574 # define PUSH_FAILURE_ELT(item)					\
   1575   fail_stack.stack[fail_stack.avail++] =  (item)
   1576 
   1577 /* These three POP... operations complement the three PUSH... operations.
   1578    All assume that `fail_stack' is nonempty.  */
   1579 # define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
   1580 # define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
   1581 # define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
   1582 
   1583 /* Used to omit pushing failure point id's when we're not debugging.  */
   1584 # ifdef DEBUG
   1585 #  define DEBUG_PUSH PUSH_FAILURE_INT
   1586 #  define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT ()
   1587 # else
   1588 #  define DEBUG_PUSH(item)
   1589 #  define DEBUG_POP(item_addr)
   1590 # endif
   1591 
   1592 
   1593 /* Push the information about the state we will need
   1594    if we ever fail back to it.
   1595 
   1596    Requires variables fail_stack, regstart, regend, reg_info, and
   1597    num_regs_pushed be declared.  DOUBLE_FAIL_STACK requires `destination'
   1598    be declared.
   1599 
   1600    Does `return FAILURE_CODE' if runs out of memory.  */
   1601 
   1602 # define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code)	\
   1603   do {									\
   1604     char *destination;							\
   1605     /* Must be int, so when we don't save any registers, the arithmetic	\
   1606        of 0 + -1 isn't done as unsigned.  */				\
   1607     /* Can't be int, since there is not a shred of a guarantee that int	\
   1608        is wide enough to hold a value of something to which pointer can	\
   1609        be assigned */							\
   1610     active_reg_t this_reg;						\
   1611     									\
   1612     DEBUG_STATEMENT (failure_id++);					\
   1613     DEBUG_STATEMENT (nfailure_points_pushed++);				\
   1614     DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id);		\
   1615     DEBUG_PRINT2 ("  Before push, next avail: %d\n", (fail_stack).avail);\
   1616     DEBUG_PRINT2 ("                     size: %d\n", (fail_stack).size);\
   1617 									\
   1618     DEBUG_PRINT2 ("  slots needed: %ld\n", NUM_FAILURE_ITEMS);		\
   1619     DEBUG_PRINT2 ("     available: %d\n", REMAINING_AVAIL_SLOTS);	\
   1620 									\
   1621     /* Ensure we have enough space allocated for what we will push.  */	\
   1622     while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS)			\
   1623       {									\
   1624         if (!DOUBLE_FAIL_STACK (fail_stack))				\
   1625           return failure_code;						\
   1626 									\
   1627         DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n",		\
   1628 		       (fail_stack).size);				\
   1629         DEBUG_PRINT2 ("  slots available: %d\n", REMAINING_AVAIL_SLOTS);\
   1630       }									\
   1631 									\
   1632     /* Push the info, starting with the registers.  */			\
   1633     DEBUG_PRINT1 ("\n");						\
   1634 									\
   1635     if (1)								\
   1636       for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \
   1637 	   this_reg++)							\
   1638 	{								\
   1639 	  DEBUG_PRINT2 ("  Pushing reg: %lu\n", this_reg);		\
   1640 	  DEBUG_STATEMENT (num_regs_pushed++);				\
   1641 									\
   1642 	  DEBUG_PRINT2 ("    start: %p\n", regstart[this_reg]);		\
   1643 	  PUSH_FAILURE_POINTER (regstart[this_reg]);			\
   1644 									\
   1645 	  DEBUG_PRINT2 ("    end: %p\n", regend[this_reg]);		\
   1646 	  PUSH_FAILURE_POINTER (regend[this_reg]);			\
   1647 									\
   1648 	  DEBUG_PRINT2 ("    info: %p\n      ",				\
   1649 			reg_info[this_reg].word.pointer);		\
   1650 	  DEBUG_PRINT2 (" match_null=%d",				\
   1651 			REG_MATCH_NULL_STRING_P (reg_info[this_reg]));	\
   1652 	  DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg]));	\
   1653 	  DEBUG_PRINT2 (" matched_something=%d",			\
   1654 			MATCHED_SOMETHING (reg_info[this_reg]));	\
   1655 	  DEBUG_PRINT2 (" ever_matched=%d",				\
   1656 			EVER_MATCHED_SOMETHING (reg_info[this_reg]));	\
   1657 	  DEBUG_PRINT1 ("\n");						\
   1658 	  PUSH_FAILURE_ELT (reg_info[this_reg].word);			\
   1659 	}								\
   1660 									\
   1661     DEBUG_PRINT2 ("  Pushing  low active reg: %ld\n", lowest_active_reg);\
   1662     PUSH_FAILURE_INT (lowest_active_reg);				\
   1663 									\
   1664     DEBUG_PRINT2 ("  Pushing high active reg: %ld\n", highest_active_reg);\
   1665     PUSH_FAILURE_INT (highest_active_reg);				\
   1666 									\
   1667     DEBUG_PRINT2 ("  Pushing pattern %p:\n", pattern_place);		\
   1668     DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);		\
   1669     PUSH_FAILURE_POINTER (pattern_place);				\
   1670 									\
   1671     DEBUG_PRINT2 ("  Pushing string %p: `", string_place);		\
   1672     DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \
   1673 				 size2);				\
   1674     DEBUG_PRINT1 ("'\n");						\
   1675     PUSH_FAILURE_POINTER (string_place);				\
   1676 									\
   1677     DEBUG_PRINT2 ("  Pushing failure id: %u\n", failure_id);		\
   1678     DEBUG_PUSH (failure_id);						\
   1679   } while (0)
   1680 
   1681 # ifndef DEFINED_ONCE
   1682 /* This is the number of items that are pushed and popped on the stack
   1683    for each register.  */
   1684 #  define NUM_REG_ITEMS  3
   1685 
   1686 /* Individual items aside from the registers.  */
   1687 #  ifdef DEBUG
   1688 #   define NUM_NONREG_ITEMS 5 /* Includes failure point id.  */
   1689 #  else
   1690 #   define NUM_NONREG_ITEMS 4
   1691 #  endif
   1692 
   1693 /* We push at most this many items on the stack.  */
   1694 /* We used to use (num_regs - 1), which is the number of registers
   1695    this regexp will save; but that was changed to 5
   1696    to avoid stack overflow for a regexp with lots of parens.  */
   1697 #  define MAX_FAILURE_ITEMS (5 * NUM_REG_ITEMS + NUM_NONREG_ITEMS)
   1698 
   1699 /* We actually push this many items.  */
   1700 #  define NUM_FAILURE_ITEMS				\
   1701   (((0							\
   1702      ? 0 : highest_active_reg - lowest_active_reg + 1)	\
   1703     * NUM_REG_ITEMS)					\
   1704    + NUM_NONREG_ITEMS)
   1705 
   1706 /* How many items can still be added to the stack without overflowing it.  */
   1707 #  define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)
   1708 # endif /* not DEFINED_ONCE */
   1709 
   1710 
   1711 /* Pops what PUSH_FAIL_STACK pushes.
   1712 
   1713    We restore into the parameters, all of which should be lvalues:
   1714      STR -- the saved data position.
   1715      PAT -- the saved pattern position.
   1716      LOW_REG, HIGH_REG -- the highest and lowest active registers.
   1717      REGSTART, REGEND -- arrays of string positions.
   1718      REG_INFO -- array of information about each subexpression.
   1719 
   1720    Also assumes the variables `fail_stack' and (if debugging), `bufp',
   1721    `pend', `string1', `size1', `string2', and `size2'.  */
   1722 # define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\
   1723 {									\
   1724   DEBUG_STATEMENT (unsigned failure_id;)				\
   1725   active_reg_t this_reg;						\
   1726   const UCHAR_T *string_temp;						\
   1727 									\
   1728   assert (!FAIL_STACK_EMPTY ());					\
   1729 									\
   1730   /* Remove failure points and point to how many regs pushed.  */	\
   1731   DEBUG_PRINT1 ("POP_FAILURE_POINT:\n");				\
   1732   DEBUG_PRINT2 ("  Before pop, next avail: %d\n", fail_stack.avail);	\
   1733   DEBUG_PRINT2 ("                    size: %d\n", fail_stack.size);	\
   1734 									\
   1735   assert (fail_stack.avail >= NUM_NONREG_ITEMS);			\
   1736 									\
   1737   DEBUG_POP (&failure_id);						\
   1738   DEBUG_PRINT2 ("  Popping failure id: %u\n", failure_id);		\
   1739 									\
   1740   /* If the saved string location is NULL, it came from an		\
   1741      on_failure_keep_string_jump opcode, and we want to throw away the	\
   1742      saved NULL, thus retaining our current position in the string.  */	\
   1743   string_temp = POP_FAILURE_POINTER ();					\
   1744   if (string_temp != NULL)						\
   1745     str = (const CHAR_T *) string_temp;					\
   1746 									\
   1747   DEBUG_PRINT2 ("  Popping string %p: `", str);				\
   1748   DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);	\
   1749   DEBUG_PRINT1 ("'\n");							\
   1750 									\
   1751   pat = (UCHAR_T *) POP_FAILURE_POINTER ();				\
   1752   DEBUG_PRINT2 ("  Popping pattern %p:\n", pat);			\
   1753   DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);			\
   1754 									\
   1755   /* Restore register info.  */						\
   1756   high_reg = (active_reg_t) POP_FAILURE_INT ();				\
   1757   DEBUG_PRINT2 ("  Popping high active reg: %ld\n", high_reg);		\
   1758 									\
   1759   low_reg = (active_reg_t) POP_FAILURE_INT ();				\
   1760   DEBUG_PRINT2 ("  Popping  low active reg: %ld\n", low_reg);		\
   1761 									\
   1762   if (1)								\
   1763     for (this_reg = high_reg; this_reg >= low_reg; this_reg--)		\
   1764       {									\
   1765 	DEBUG_PRINT2 ("    Popping reg: %ld\n", this_reg);		\
   1766 									\
   1767 	reg_info[this_reg].word = POP_FAILURE_ELT ();			\
   1768 	DEBUG_PRINT2 ("      info: %p\n",				\
   1769 		      reg_info[this_reg].word.pointer);			\
   1770 									\
   1771 	regend[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER ();	\
   1772 	DEBUG_PRINT2 ("      end: %p\n", regend[this_reg]);		\
   1773 									\
   1774 	regstart[this_reg] = (const CHAR_T *) POP_FAILURE_POINTER ();	\
   1775 	DEBUG_PRINT2 ("      start: %p\n", regstart[this_reg]);		\
   1776       }									\
   1777   else									\
   1778     {									\
   1779       for (this_reg = highest_active_reg; this_reg > high_reg; this_reg--) \
   1780 	{								\
   1781 	  reg_info[this_reg].word.integer = 0;				\
   1782 	  regend[this_reg] = 0;						\
   1783 	  regstart[this_reg] = 0;					\
   1784 	}								\
   1785       highest_active_reg = high_reg;					\
   1786     }									\
   1787 									\
   1788   set_regs_matched_done = 0;						\
   1789   DEBUG_STATEMENT (nfailure_points_popped++);				\
   1790 } /* POP_FAILURE_POINT */
   1791 
   1792 /* Structure for per-register (a.k.a. per-group) information.
   1794    Other register information, such as the
   1795    starting and ending positions (which are addresses), and the list of
   1796    inner groups (which is a bits list) are maintained in separate
   1797    variables.
   1798 
   1799    We are making a (strictly speaking) nonportable assumption here: that
   1800    the compiler will pack our bit fields into something that fits into
   1801    the type of `word', i.e., is something that fits into one item on the
   1802    failure stack.  */
   1803 
   1804 
   1805 /* Declarations and macros for re_match_2.  */
   1806 
   1807 typedef union
   1808 {
   1809   PREFIX(fail_stack_elt_t) word;
   1810   struct
   1811   {
   1812       /* This field is one if this group can match the empty string,
   1813          zero if not.  If not yet determined,  `MATCH_NULL_UNSET_VALUE'.  */
   1814 # define MATCH_NULL_UNSET_VALUE 3
   1815     unsigned match_null_string_p : 2;
   1816     unsigned is_active : 1;
   1817     unsigned matched_something : 1;
   1818     unsigned ever_matched_something : 1;
   1819   } bits;
   1820 } PREFIX(register_info_type);
   1821 
   1822 # ifndef DEFINED_ONCE
   1823 #  define REG_MATCH_NULL_STRING_P(R)  ((R).bits.match_null_string_p)
   1824 #  define IS_ACTIVE(R)  ((R).bits.is_active)
   1825 #  define MATCHED_SOMETHING(R)  ((R).bits.matched_something)
   1826 #  define EVER_MATCHED_SOMETHING(R)  ((R).bits.ever_matched_something)
   1827 
   1828 
   1829 /* Call this when have matched a real character; it sets `matched' flags
   1830    for the subexpressions which we are currently inside.  Also records
   1831    that those subexprs have matched.  */
   1832 #  define SET_REGS_MATCHED()						\
   1833   do									\
   1834     {									\
   1835       if (!set_regs_matched_done)					\
   1836 	{								\
   1837 	  active_reg_t r;						\
   1838 	  set_regs_matched_done = 1;					\
   1839 	  for (r = lowest_active_reg; r <= highest_active_reg; r++)	\
   1840 	    {								\
   1841 	      MATCHED_SOMETHING (reg_info[r])				\
   1842 		= EVER_MATCHED_SOMETHING (reg_info[r])			\
   1843 		= 1;							\
   1844 	    }								\
   1845 	}								\
   1846     }									\
   1847   while (0)
   1848 # endif /* not DEFINED_ONCE */
   1849 
   1850 /* Registers are set to a sentinel when they haven't yet matched.  */
   1851 static CHAR_T PREFIX(reg_unset_dummy);
   1852 # define REG_UNSET_VALUE (&PREFIX(reg_unset_dummy))
   1853 # define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
   1854 
   1855 /* Subroutine declarations and macros for regex_compile.  */
   1856 static void PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg);
   1857 static void PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc,
   1858                                int arg1, int arg2);
   1859 static void PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc,
   1860                                 int arg, UCHAR_T *end);
   1861 static void PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc,
   1862                                 int arg1, int arg2, UCHAR_T *end);
   1863 static boolean PREFIX(at_begline_loc_p) (const CHAR_T *pattern,
   1864                                          const CHAR_T *p,
   1865                                          reg_syntax_t syntax);
   1866 static boolean PREFIX(at_endline_loc_p) (const CHAR_T *p,
   1867                                          const CHAR_T *pend,
   1868                                          reg_syntax_t syntax);
   1869 # ifdef WCHAR
   1870 static reg_errcode_t wcs_compile_range (CHAR_T range_start,
   1871                                         const CHAR_T **p_ptr,
   1872                                         const CHAR_T *pend,
   1873                                         char *translate,
   1874                                         reg_syntax_t syntax,
   1875                                         UCHAR_T *b,
   1876                                         CHAR_T *char_set);
   1877 static void insert_space (int num, CHAR_T *loc, CHAR_T *end);
   1878 # else /* BYTE */
   1879 static reg_errcode_t byte_compile_range (unsigned int range_start,
   1880                                          const char **p_ptr,
   1881                                          const char *pend,
   1882                                          char *translate,
   1883                                          reg_syntax_t syntax,
   1884                                          unsigned char *b);
   1885 # endif /* WCHAR */
   1886 
   1887 /* Fetch the next character in the uncompiled pattern---translating it
   1888    if necessary.  Also cast from a signed character in the constant
   1889    string passed to us by the user to an unsigned char that we can use
   1890    as an array index (in, e.g., `translate').  */
   1891 /* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
   1892    because it is impossible to allocate 4GB array for some encodings
   1893    which have 4 byte character_set like UCS4.  */
   1894 # ifndef PATFETCH
   1895 #  ifdef WCHAR
   1896 #   define PATFETCH(c)							\
   1897   do {if (p == pend) return REG_EEND;					\
   1898     c = (UCHAR_T) *p++;							\
   1899     if (translate && (c <= 0xff)) c = (UCHAR_T) translate[c];		\
   1900   } while (0)
   1901 #  else /* BYTE */
   1902 #   define PATFETCH(c)							\
   1903   do {if (p == pend) return REG_EEND;					\
   1904     c = (unsigned char) *p++;						\
   1905     if (translate) c = (unsigned char) translate[c];			\
   1906   } while (0)
   1907 #  endif /* WCHAR */
   1908 # endif
   1909 
   1910 /* Fetch the next character in the uncompiled pattern, with no
   1911    translation.  */
   1912 # define PATFETCH_RAW(c)						\
   1913   do {if (p == pend) return REG_EEND;					\
   1914     c = (UCHAR_T) *p++; 	       					\
   1915   } while (0)
   1916 
   1917 /* Go backwards one character in the pattern.  */
   1918 # define PATUNFETCH p--
   1919 
   1920 
   1921 /* If `translate' is non-null, return translate[D], else just D.  We
   1922    cast the subscript to translate because some data is declared as
   1923    `char *', to avoid warnings when a string constant is passed.  But
   1924    when we use a character as a subscript we must make it unsigned.  */
   1925 /* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
   1926    because it is impossible to allocate 4GB array for some encodings
   1927    which have 4 byte character_set like UCS4.  */
   1928 
   1929 # ifndef TRANSLATE
   1930 #  ifdef WCHAR
   1931 #   define TRANSLATE(d) \
   1932   ((translate && ((UCHAR_T) (d)) <= 0xff) \
   1933    ? (char) translate[(unsigned char) (d)] : (d))
   1934 # else /* BYTE */
   1935 #   define TRANSLATE(d) \
   1936   (translate ? (char) translate[(unsigned char) (d)] : (char) (d))
   1937 #  endif /* WCHAR */
   1938 # endif
   1939 
   1940 
   1941 /* Macros for outputting the compiled pattern into `buffer'.  */
   1942 
   1943 /* If the buffer isn't allocated when it comes in, use this.  */
   1944 # define INIT_BUF_SIZE  (32 * sizeof(UCHAR_T))
   1945 
   1946 /* Make sure we have at least N more bytes of space in buffer.  */
   1947 # ifdef WCHAR
   1948 #  define GET_BUFFER_SPACE(n)						\
   1949     while (((unsigned long)b - (unsigned long)COMPILED_BUFFER_VAR	\
   1950             + (n)*sizeof(CHAR_T)) > bufp->allocated)			\
   1951       EXTEND_BUFFER ()
   1952 # else /* BYTE */
   1953 #  define GET_BUFFER_SPACE(n)						\
   1954     while ((unsigned long) (b - bufp->buffer + (n)) > bufp->allocated)	\
   1955       EXTEND_BUFFER ()
   1956 # endif /* WCHAR */
   1957 
   1958 /* Make sure we have one more byte of buffer space and then add C to it.  */
   1959 # define BUF_PUSH(c)							\
   1960   do {									\
   1961     GET_BUFFER_SPACE (1);						\
   1962     *b++ = (UCHAR_T) (c);						\
   1963   } while (0)
   1964 
   1965 
   1966 /* Ensure we have two more bytes of buffer space and then append C1 and C2.  */
   1967 # define BUF_PUSH_2(c1, c2)						\
   1968   do {									\
   1969     GET_BUFFER_SPACE (2);						\
   1970     *b++ = (UCHAR_T) (c1);						\
   1971     *b++ = (UCHAR_T) (c2);						\
   1972   } while (0)
   1973 
   1974 
   1975 /* As with BUF_PUSH_2, except for three bytes.  */
   1976 # define BUF_PUSH_3(c1, c2, c3)						\
   1977   do {									\
   1978     GET_BUFFER_SPACE (3);						\
   1979     *b++ = (UCHAR_T) (c1);						\
   1980     *b++ = (UCHAR_T) (c2);						\
   1981     *b++ = (UCHAR_T) (c3);						\
   1982   } while (0)
   1983 
   1984 /* Store a jump with opcode OP at LOC to location TO.  We store a
   1985    relative address offset by the three bytes the jump itself occupies.  */
   1986 # define STORE_JUMP(op, loc, to) \
   1987  PREFIX(store_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)))
   1988 
   1989 /* Likewise, for a two-argument jump.  */
   1990 # define STORE_JUMP2(op, loc, to, arg) \
   1991   PREFIX(store_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), arg)
   1992 
   1993 /* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
   1994 # define INSERT_JUMP(op, loc, to) \
   1995   PREFIX(insert_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), b)
   1996 
   1997 /* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
   1998 # define INSERT_JUMP2(op, loc, to, arg) \
   1999   PREFIX(insert_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)),\
   2000 	      arg, b)
   2001 
   2002 /* This is not an arbitrary limit: the arguments which represent offsets
   2003    into the pattern are two bytes long.  So if 2^16 bytes turns out to
   2004    be too small, many things would have to change.  */
   2005 /* Any other compiler which, like MSC, has allocation limit below 2^16
   2006    bytes will have to use approach similar to what was done below for
   2007    MSC and drop MAX_BUF_SIZE a bit.  Otherwise you may end up
   2008    reallocating to 0 bytes.  Such thing is not going to work too well.
   2009    You have been warned!!  */
   2010 # ifndef DEFINED_ONCE
   2011 #  if defined _MSC_VER  && !defined WIN32
   2012 /* Microsoft C 16-bit versions limit malloc to approx 65512 bytes.
   2013    The REALLOC define eliminates a flurry of conversion warnings,
   2014    but is not required. */
   2015 #   define MAX_BUF_SIZE  65500L
   2016 #   define REALLOC(p,s) realloc ((p), (size_t) (s))
   2017 #  else
   2018 #   define MAX_BUF_SIZE (1L << 16)
   2019 #   define REALLOC(p,s) realloc ((p), (s))
   2020 #  endif
   2021 
   2022 /* Extend the buffer by twice its current size via realloc and
   2023    reset the pointers that pointed into the old block to point to the
   2024    correct places in the new one.  If extending the buffer results in it
   2025    being larger than MAX_BUF_SIZE, then flag memory exhausted.  */
   2026 #  if __BOUNDED_POINTERS__
   2027 #   define SET_HIGH_BOUND(P) (__ptrhigh (P) = __ptrlow (P) + bufp->allocated)
   2028 #   define MOVE_BUFFER_POINTER(P) \
   2029   (__ptrlow (P) += incr, SET_HIGH_BOUND (P), __ptrvalue (P) += incr)
   2030 #   define ELSE_EXTEND_BUFFER_HIGH_BOUND	\
   2031   else						\
   2032     {						\
   2033       SET_HIGH_BOUND (b);			\
   2034       SET_HIGH_BOUND (begalt);			\
   2035       if (fixup_alt_jump)			\
   2036 	SET_HIGH_BOUND (fixup_alt_jump);	\
   2037       if (laststart)				\
   2038 	SET_HIGH_BOUND (laststart);		\
   2039       if (pending_exact)			\
   2040 	SET_HIGH_BOUND (pending_exact);		\
   2041     }
   2042 #  else
   2043 #   define MOVE_BUFFER_POINTER(P) (P) += incr
   2044 #   define ELSE_EXTEND_BUFFER_HIGH_BOUND
   2045 #  endif
   2046 # endif /* not DEFINED_ONCE */
   2047 
   2048 # ifdef WCHAR
   2049 #  define EXTEND_BUFFER()						\
   2050   do {									\
   2051     UCHAR_T *old_buffer = COMPILED_BUFFER_VAR;				\
   2052     int wchar_count;							\
   2053     if (bufp->allocated + sizeof(UCHAR_T) > MAX_BUF_SIZE)		\
   2054       return REG_ESIZE;							\
   2055     bufp->allocated <<= 1;						\
   2056     if (bufp->allocated > MAX_BUF_SIZE)					\
   2057       bufp->allocated = MAX_BUF_SIZE;					\
   2058     /* How many characters the new buffer can have?  */			\
   2059     wchar_count = bufp->allocated / sizeof(UCHAR_T);			\
   2060     if (wchar_count == 0) wchar_count = 1;				\
   2061     /* Truncate the buffer to CHAR_T align.  */				\
   2062     bufp->allocated = wchar_count * sizeof(UCHAR_T);			\
   2063     RETALLOC (COMPILED_BUFFER_VAR, wchar_count, UCHAR_T);		\
   2064     bufp->buffer = (char*)COMPILED_BUFFER_VAR;				\
   2065     if (COMPILED_BUFFER_VAR == NULL)					\
   2066       return REG_ESPACE;						\
   2067     /* If the buffer moved, move all the pointers into it.  */		\
   2068     if (old_buffer != COMPILED_BUFFER_VAR)				\
   2069       {									\
   2070 	PTR_INT_TYPE incr = COMPILED_BUFFER_VAR - old_buffer;		\
   2071 	MOVE_BUFFER_POINTER (b);					\
   2072 	MOVE_BUFFER_POINTER (begalt);					\
   2073 	if (fixup_alt_jump)						\
   2074 	  MOVE_BUFFER_POINTER (fixup_alt_jump);				\
   2075 	if (laststart)							\
   2076 	  MOVE_BUFFER_POINTER (laststart);				\
   2077 	if (pending_exact)						\
   2078 	  MOVE_BUFFER_POINTER (pending_exact);				\
   2079       }									\
   2080     ELSE_EXTEND_BUFFER_HIGH_BOUND					\
   2081   } while (0)
   2082 # else /* BYTE */
   2083 #  define EXTEND_BUFFER()						\
   2084   do {									\
   2085     UCHAR_T *old_buffer = COMPILED_BUFFER_VAR;				\
   2086     if (bufp->allocated == MAX_BUF_SIZE)				\
   2087       return REG_ESIZE;							\
   2088     bufp->allocated <<= 1;						\
   2089     if (bufp->allocated > MAX_BUF_SIZE)					\
   2090       bufp->allocated = MAX_BUF_SIZE;					\
   2091     bufp->buffer = (UCHAR_T *) REALLOC (COMPILED_BUFFER_VAR,		\
   2092 						bufp->allocated);	\
   2093     if (COMPILED_BUFFER_VAR == NULL)					\
   2094       return REG_ESPACE;						\
   2095     /* If the buffer moved, move all the pointers into it.  */		\
   2096     if (old_buffer != COMPILED_BUFFER_VAR)				\
   2097       {									\
   2098 	PTR_INT_TYPE incr = COMPILED_BUFFER_VAR - old_buffer;		\
   2099 	MOVE_BUFFER_POINTER (b);					\
   2100 	MOVE_BUFFER_POINTER (begalt);					\
   2101 	if (fixup_alt_jump)						\
   2102 	  MOVE_BUFFER_POINTER (fixup_alt_jump);				\
   2103 	if (laststart)							\
   2104 	  MOVE_BUFFER_POINTER (laststart);				\
   2105 	if (pending_exact)						\
   2106 	  MOVE_BUFFER_POINTER (pending_exact);				\
   2107       }									\
   2108     ELSE_EXTEND_BUFFER_HIGH_BOUND					\
   2109   } while (0)
   2110 # endif /* WCHAR */
   2111 
   2112 # ifndef DEFINED_ONCE
   2113 /* Since we have one byte reserved for the register number argument to
   2114    {start,stop}_memory, the maximum number of groups we can report
   2115    things about is what fits in that byte.  */
   2116 #  define MAX_REGNUM 255
   2117 
   2118 /* But patterns can have more than `MAX_REGNUM' registers.  We just
   2119    ignore the excess.  */
   2120 typedef unsigned regnum_t;
   2121 
   2122 
   2123 /* Macros for the compile stack.  */
   2124 
   2125 /* Since offsets can go either forwards or backwards, this type needs to
   2126    be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1.  */
   2127 /* int may be not enough when sizeof(int) == 2.  */
   2128 typedef long pattern_offset_t;
   2129 
   2130 typedef struct
   2131 {
   2132   pattern_offset_t begalt_offset;
   2133   pattern_offset_t fixup_alt_jump;
   2134   pattern_offset_t inner_group_offset;
   2135   pattern_offset_t laststart_offset;
   2136   regnum_t regnum;
   2137 } compile_stack_elt_t;
   2138 
   2139 
   2140 typedef struct
   2141 {
   2142   compile_stack_elt_t *stack;
   2143   unsigned size;
   2144   unsigned avail;			/* Offset of next open position.  */
   2145 } compile_stack_type;
   2146 
   2147 
   2148 #  define INIT_COMPILE_STACK_SIZE 32
   2149 
   2150 #  define COMPILE_STACK_EMPTY  (compile_stack.avail == 0)
   2151 #  define COMPILE_STACK_FULL  (compile_stack.avail == compile_stack.size)
   2152 
   2153 /* The next available element.  */
   2154 #  define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])
   2155 
   2156 # endif /* not DEFINED_ONCE */
   2157 
   2158 /* Set the bit for character C in a list.  */
   2159 # ifndef DEFINED_ONCE
   2160 #  define SET_LIST_BIT(c)                               \
   2161   (b[((unsigned char) (c)) / BYTEWIDTH]               \
   2162    |= 1 << (((unsigned char) c) % BYTEWIDTH))
   2163 # endif /* DEFINED_ONCE */
   2164 
   2165 /* Get the next unsigned number in the uncompiled pattern.  */
   2166 # define GET_UNSIGNED_NUMBER(num) \
   2167   {									\
   2168     while (p != pend)							\
   2169       {									\
   2170 	PATFETCH (c);							\
   2171 	if (c < '0' || c > '9')						\
   2172 	  break;							\
   2173 	if (num <= RE_DUP_MAX)						\
   2174 	  {								\
   2175 	    if (num < 0)						\
   2176 	      num = 0;							\
   2177 	    num = num * 10 + c - '0';					\
   2178 	  }								\
   2179       }									\
   2180   }
   2181 
   2182 # ifndef DEFINED_ONCE
   2183 #  if defined _LIBC || WIDE_CHAR_SUPPORT
   2184 /* The GNU C library provides support for user-defined character classes
   2185    and the functions from ISO C amendement 1.  */
   2186 #   ifdef CHARCLASS_NAME_MAX
   2187 #    define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
   2188 #   else
   2189 /* This shouldn't happen but some implementation might still have this
   2190    problem.  Use a reasonable default value.  */
   2191 #    define CHAR_CLASS_MAX_LENGTH 256
   2192 #   endif
   2193 
   2194 #   ifdef _LIBC
   2195 #    define IS_CHAR_CLASS(string) __wctype (string)
   2196 #   else
   2197 #    define IS_CHAR_CLASS(string) wctype (string)
   2198 #   endif
   2199 #  else
   2200 #   define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */
   2201 
   2202 #   define IS_CHAR_CLASS(string)					\
   2203    (STREQ (string, "alpha") || STREQ (string, "upper")			\
   2204     || STREQ (string, "lower") || STREQ (string, "digit")		\
   2205     || STREQ (string, "alnum") || STREQ (string, "xdigit")		\
   2206     || STREQ (string, "space") || STREQ (string, "print")		\
   2207     || STREQ (string, "punct") || STREQ (string, "graph")		\
   2208     || STREQ (string, "cntrl") || STREQ (string, "blank"))
   2209 #  endif
   2210 # endif /* DEFINED_ONCE */
   2211 
   2212 # ifndef MATCH_MAY_ALLOCATE
   2214 
   2215 /* If we cannot allocate large objects within re_match_2_internal,
   2216    we make the fail stack and register vectors global.
   2217    The fail stack, we grow to the maximum size when a regexp
   2218    is compiled.
   2219    The register vectors, we adjust in size each time we
   2220    compile a regexp, according to the number of registers it needs.  */
   2221 
   2222 static PREFIX(fail_stack_type) fail_stack;
   2223 
   2224 /* Size with which the following vectors are currently allocated.
   2225    That is so we can make them bigger as needed,
   2226    but never make them smaller.  */
   2227 #  ifdef DEFINED_ONCE
   2228 static int regs_allocated_size;
   2229 
   2230 static const char **     regstart, **     regend;
   2231 static const char ** old_regstart, ** old_regend;
   2232 static const char **best_regstart, **best_regend;
   2233 static const char **reg_dummy;
   2234 #  endif /* DEFINED_ONCE */
   2235 
   2236 static PREFIX(register_info_type) *PREFIX(reg_info);
   2237 static PREFIX(register_info_type) *PREFIX(reg_info_dummy);
   2238 
   2239 /* Make the register vectors big enough for NUM_REGS registers,
   2240    but don't make them smaller.  */
   2241 
   2242 static void
   2243 PREFIX(regex_grow_registers) (int num_regs)
   2244 {
   2245   if (num_regs > regs_allocated_size)
   2246     {
   2247       RETALLOC_IF (regstart,	 num_regs, const char *);
   2248       RETALLOC_IF (regend,	 num_regs, const char *);
   2249       RETALLOC_IF (old_regstart, num_regs, const char *);
   2250       RETALLOC_IF (old_regend,	 num_regs, const char *);
   2251       RETALLOC_IF (best_regstart, num_regs, const char *);
   2252       RETALLOC_IF (best_regend,	 num_regs, const char *);
   2253       RETALLOC_IF (PREFIX(reg_info), num_regs, PREFIX(register_info_type));
   2254       RETALLOC_IF (reg_dummy,	 num_regs, const char *);
   2255       RETALLOC_IF (PREFIX(reg_info_dummy), num_regs, PREFIX(register_info_type));
   2256 
   2257       regs_allocated_size = num_regs;
   2258     }
   2259 }
   2260 
   2261 # endif /* not MATCH_MAY_ALLOCATE */
   2262 
   2263 # ifndef DEFINED_ONCE
   2265 static boolean group_in_compile_stack (compile_stack_type compile_stack,
   2266                                        regnum_t regnum);
   2267 # endif /* not DEFINED_ONCE */
   2268 
   2269 /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.
   2270    Returns one of error codes defined in `regex.h', or zero for success.
   2271 
   2272    Assumes the `allocated' (and perhaps `buffer') and `translate'
   2273    fields are set in BUFP on entry.
   2274 
   2275    If it succeeds, results are put in BUFP (if it returns an error, the
   2276    contents of BUFP are undefined):
   2277      `buffer' is the compiled pattern;
   2278      `syntax' is set to SYNTAX;
   2279      `used' is set to the length of the compiled pattern;
   2280      `fastmap_accurate' is zero;
   2281      `re_nsub' is the number of subexpressions in PATTERN;
   2282      `not_bol' and `not_eol' are zero;
   2283 
   2284    The `fastmap' and `newline_anchor' fields are neither
   2285    examined nor set.  */
   2286 
   2287 /* Return, freeing storage we allocated.  */
   2288 # ifdef WCHAR
   2289 #  define FREE_STACK_RETURN(value)		\
   2290   return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value)
   2291 # else
   2292 #  define FREE_STACK_RETURN(value)		\
   2293   return (free (compile_stack.stack), value)
   2294 # endif /* WCHAR */
   2295 
   2296 static reg_errcode_t
   2297 PREFIX(regex_compile) (const char *ARG_PREFIX(pattern),
   2298                        size_t ARG_PREFIX(size), reg_syntax_t syntax,
   2299                        struct re_pattern_buffer *bufp)
   2300 {
   2301   /* We fetch characters from PATTERN here.  Even though PATTERN is
   2302      `char *' (i.e., signed), we declare these variables as unsigned, so
   2303      they can be reliably used as array indices.  */
   2304   register UCHAR_T c, c1;
   2305 
   2306 #ifdef WCHAR
   2307   /* A temporary space to keep wchar_t pattern and compiled pattern.  */
   2308   CHAR_T *pattern, *COMPILED_BUFFER_VAR;
   2309   size_t size;
   2310   /* offset buffer for optimization. See convert_mbs_to_wc.  */
   2311   int *mbs_offset = NULL;
   2312   /* It hold whether each wchar_t is binary data or not.  */
   2313   char *is_binary = NULL;
   2314   /* A flag whether exactn is handling binary data or not.  */
   2315   char is_exactn_bin = FALSE;
   2316 #endif /* WCHAR */
   2317 
   2318   /* A random temporary spot in PATTERN.  */
   2319   const CHAR_T *p1;
   2320 
   2321   /* Points to the end of the buffer, where we should append.  */
   2322   register UCHAR_T *b;
   2323 
   2324   /* Keeps track of unclosed groups.  */
   2325   compile_stack_type compile_stack;
   2326 
   2327   /* Points to the current (ending) position in the pattern.  */
   2328 #ifdef WCHAR
   2329   const CHAR_T *p;
   2330   const CHAR_T *pend;
   2331 #else /* BYTE */
   2332   const CHAR_T *p = pattern;
   2333   const CHAR_T *pend = pattern + size;
   2334 #endif /* WCHAR */
   2335 
   2336   /* How to translate the characters in the pattern.  */
   2337   RE_TRANSLATE_TYPE translate = bufp->translate;
   2338 
   2339   /* Address of the count-byte of the most recently inserted `exactn'
   2340      command.  This makes it possible to tell if a new exact-match
   2341      character can be added to that command or if the character requires
   2342      a new `exactn' command.  */
   2343   UCHAR_T *pending_exact = 0;
   2344 
   2345   /* Address of start of the most recently finished expression.
   2346      This tells, e.g., postfix * where to find the start of its
   2347      operand.  Reset at the beginning of groups and alternatives.  */
   2348   UCHAR_T *laststart = 0;
   2349 
   2350   /* Address of beginning of regexp, or inside of last group.  */
   2351   UCHAR_T *begalt;
   2352 
   2353   /* Address of the place where a forward jump should go to the end of
   2354      the containing expression.  Each alternative of an `or' -- except the
   2355      last -- ends with a forward jump of this sort.  */
   2356   UCHAR_T *fixup_alt_jump = 0;
   2357 
   2358   /* Counts open-groups as they are encountered.  Remembered for the
   2359      matching close-group on the compile stack, so the same register
   2360      number is put in the stop_memory as the start_memory.  */
   2361   regnum_t regnum = 0;
   2362 
   2363 #ifdef WCHAR
   2364   /* Initialize the wchar_t PATTERN and offset_buffer.  */
   2365   p = pend = pattern = TALLOC(csize + 1, CHAR_T);
   2366   mbs_offset = TALLOC(csize + 1, int);
   2367   is_binary = TALLOC(csize + 1, char);
   2368   if (pattern == NULL || mbs_offset == NULL || is_binary == NULL)
   2369     {
   2370       free(pattern);
   2371       free(mbs_offset);
   2372       free(is_binary);
   2373       return REG_ESPACE;
   2374     }
   2375   pattern[csize] = L'\0';	/* sentinel */
   2376   size = convert_mbs_to_wcs(pattern, cpattern, csize, mbs_offset, is_binary);
   2377   pend = p + size;
   2378   if (size < 0)
   2379     {
   2380       free(pattern);
   2381       free(mbs_offset);
   2382       free(is_binary);
   2383       return REG_BADPAT;
   2384     }
   2385 #endif
   2386 
   2387 #ifdef DEBUG
   2388   DEBUG_PRINT1 ("\nCompiling pattern: ");
   2389   if (debug)
   2390     {
   2391       unsigned debug_count;
   2392 
   2393       for (debug_count = 0; debug_count < size; debug_count++)
   2394         PUT_CHAR (pattern[debug_count]);
   2395       putchar ('\n');
   2396     }
   2397 #endif /* DEBUG */
   2398 
   2399   /* Initialize the compile stack.  */
   2400   compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
   2401   if (compile_stack.stack == NULL)
   2402     {
   2403 #ifdef WCHAR
   2404       free(pattern);
   2405       free(mbs_offset);
   2406       free(is_binary);
   2407 #endif
   2408       return REG_ESPACE;
   2409     }
   2410 
   2411   compile_stack.size = INIT_COMPILE_STACK_SIZE;
   2412   compile_stack.avail = 0;
   2413 
   2414   /* Initialize the pattern buffer.  */
   2415   bufp->syntax = syntax;
   2416   bufp->fastmap_accurate = 0;
   2417   bufp->not_bol = bufp->not_eol = 0;
   2418 
   2419   /* Set `used' to zero, so that if we return an error, the pattern
   2420      printer (for debugging) will think there's no pattern.  We reset it
   2421      at the end.  */
   2422   bufp->used = 0;
   2423 
   2424   /* Always count groups, whether or not bufp->no_sub is set.  */
   2425   bufp->re_nsub = 0;
   2426 
   2427 #if !defined emacs && !defined SYNTAX_TABLE
   2428   /* Initialize the syntax table.  */
   2429    init_syntax_once ();
   2430 #endif
   2431 
   2432   if (bufp->allocated == 0)
   2433     {
   2434       if (bufp->buffer)
   2435 	{ /* If zero allocated, but buffer is non-null, try to realloc
   2436              enough space.  This loses if buffer's address is bogus, but
   2437              that is the user's responsibility.  */
   2438 #ifdef WCHAR
   2439 	  /* Free bufp->buffer and allocate an array for wchar_t pattern
   2440 	     buffer.  */
   2441           free(bufp->buffer);
   2442           COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE/sizeof(UCHAR_T),
   2443 					UCHAR_T);
   2444 #else
   2445           RETALLOC (COMPILED_BUFFER_VAR, INIT_BUF_SIZE, UCHAR_T);
   2446 #endif /* WCHAR */
   2447         }
   2448       else
   2449         { /* Caller did not allocate a buffer.  Do it for them.  */
   2450           COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE / sizeof(UCHAR_T),
   2451 					UCHAR_T);
   2452         }
   2453 
   2454       if (!COMPILED_BUFFER_VAR) FREE_STACK_RETURN (REG_ESPACE);
   2455 #ifdef WCHAR
   2456       bufp->buffer = (char*)COMPILED_BUFFER_VAR;
   2457 #endif /* WCHAR */
   2458       bufp->allocated = INIT_BUF_SIZE;
   2459     }
   2460 #ifdef WCHAR
   2461   else
   2462     COMPILED_BUFFER_VAR = (UCHAR_T*) bufp->buffer;
   2463 #endif
   2464 
   2465   begalt = b = COMPILED_BUFFER_VAR;
   2466 
   2467   /* Loop through the uncompiled pattern until we're at the end.  */
   2468   while (p != pend)
   2469     {
   2470       PATFETCH (c);
   2471 
   2472       switch (c)
   2473         {
   2474         case '^':
   2475           {
   2476             if (   /* If at start of pattern, it's an operator.  */
   2477                    p == pattern + 1
   2478                    /* If context independent, it's an operator.  */
   2479                 || syntax & RE_CONTEXT_INDEP_ANCHORS
   2480                    /* Otherwise, depends on what's come before.  */
   2481                 || PREFIX(at_begline_loc_p) (pattern, p, syntax))
   2482               BUF_PUSH (begline);
   2483             else
   2484               goto normal_char;
   2485           }
   2486           break;
   2487 
   2488 
   2489         case '$':
   2490           {
   2491             if (   /* If at end of pattern, it's an operator.  */
   2492                    p == pend
   2493                    /* If context independent, it's an operator.  */
   2494                 || syntax & RE_CONTEXT_INDEP_ANCHORS
   2495                    /* Otherwise, depends on what's next.  */
   2496                 || PREFIX(at_endline_loc_p) (p, pend, syntax))
   2497                BUF_PUSH (endline);
   2498              else
   2499                goto normal_char;
   2500            }
   2501            break;
   2502 
   2503 
   2504 	case '+':
   2505         case '?':
   2506           if ((syntax & RE_BK_PLUS_QM)
   2507               || (syntax & RE_LIMITED_OPS))
   2508             goto normal_char;
   2509         handle_plus:
   2510         case '*':
   2511           /* If there is no previous pattern... */
   2512           if (!laststart)
   2513             {
   2514               if (syntax & RE_CONTEXT_INVALID_OPS)
   2515                 FREE_STACK_RETURN (REG_BADRPT);
   2516               else if (!(syntax & RE_CONTEXT_INDEP_OPS))
   2517                 goto normal_char;
   2518             }
   2519 
   2520           {
   2521             /* Are we optimizing this jump?  */
   2522             boolean keep_string_p = false;
   2523 
   2524             /* 1 means zero (many) matches is allowed.  */
   2525             char zero_times_ok = 0, many_times_ok = 0;
   2526 
   2527             /* If there is a sequence of repetition chars, collapse it
   2528                down to just one (the right one).  We can't combine
   2529                interval operators with these because of, e.g., `a{2}*',
   2530                which should only match an even number of `a's.  */
   2531 
   2532             for (;;)
   2533               {
   2534                 zero_times_ok |= c != '+';
   2535                 many_times_ok |= c != '?';
   2536 
   2537                 if (p == pend)
   2538                   break;
   2539 
   2540                 PATFETCH (c);
   2541 
   2542                 if (c == '*'
   2543                     || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?')))
   2544                   ;
   2545 
   2546                 else if (syntax & RE_BK_PLUS_QM  &&  c == '\\')
   2547                   {
   2548                     if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
   2549 
   2550                     PATFETCH (c1);
   2551                     if (!(c1 == '+' || c1 == '?'))
   2552                       {
   2553                         PATUNFETCH;
   2554                         PATUNFETCH;
   2555                         break;
   2556                       }
   2557 
   2558                     c = c1;
   2559                   }
   2560                 else
   2561                   {
   2562                     PATUNFETCH;
   2563                     break;
   2564                   }
   2565 
   2566                 /* If we get here, we found another repeat character.  */
   2567                }
   2568 
   2569             /* Star, etc. applied to an empty pattern is equivalent
   2570                to an empty pattern.  */
   2571             if (!laststart)
   2572               break;
   2573 
   2574             /* Now we know whether or not zero matches is allowed
   2575                and also whether or not two or more matches is allowed.  */
   2576             if (many_times_ok)
   2577               { /* More than one repetition is allowed, so put in at the
   2578                    end a backward relative jump from `b' to before the next
   2579                    jump we're going to put in below (which jumps from
   2580                    laststart to after this jump).
   2581 
   2582                    But if we are at the `*' in the exact sequence `.*\n',
   2583                    insert an unconditional jump backwards to the .,
   2584                    instead of the beginning of the loop.  This way we only
   2585                    push a failure point once, instead of every time
   2586                    through the loop.  */
   2587                 assert (p - 1 > pattern);
   2588 
   2589                 /* Allocate the space for the jump.  */
   2590                 GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
   2591 
   2592                 /* We know we are not at the first character of the pattern,
   2593                    because laststart was nonzero.  And we've already
   2594                    incremented `p', by the way, to be the character after
   2595                    the `*'.  Do we have to do something analogous here
   2596                    for null bytes, because of RE_DOT_NOT_NULL?  */
   2597                 if (TRANSLATE (*(p - 2)) == TRANSLATE ('.')
   2598 		    && zero_times_ok
   2599                     && p < pend && TRANSLATE (*p) == TRANSLATE ('\n')
   2600                     && !(syntax & RE_DOT_NEWLINE))
   2601                   { /* We have .*\n.  */
   2602                     STORE_JUMP (jump, b, laststart);
   2603                     keep_string_p = true;
   2604                   }
   2605                 else
   2606                   /* Anything else.  */
   2607                   STORE_JUMP (maybe_pop_jump, b, laststart -
   2608 			      (1 + OFFSET_ADDRESS_SIZE));
   2609 
   2610                 /* We've added more stuff to the buffer.  */
   2611                 b += 1 + OFFSET_ADDRESS_SIZE;
   2612               }
   2613 
   2614             /* On failure, jump from laststart to b + 3, which will be the
   2615                end of the buffer after this jump is inserted.  */
   2616 	    /* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE' instead of
   2617 	       'b + 3'.  */
   2618             GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
   2619             INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump
   2620                                        : on_failure_jump,
   2621                          laststart, b + 1 + OFFSET_ADDRESS_SIZE);
   2622             pending_exact = 0;
   2623             b += 1 + OFFSET_ADDRESS_SIZE;
   2624 
   2625             if (!zero_times_ok)
   2626               {
   2627                 /* At least one repetition is required, so insert a
   2628                    `dummy_failure_jump' before the initial
   2629                    `on_failure_jump' instruction of the loop. This
   2630                    effects a skip over that instruction the first time
   2631                    we hit that loop.  */
   2632                 GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
   2633                 INSERT_JUMP (dummy_failure_jump, laststart, laststart +
   2634 			     2 + 2 * OFFSET_ADDRESS_SIZE);
   2635                 b += 1 + OFFSET_ADDRESS_SIZE;
   2636               }
   2637             }
   2638 	  break;
   2639 
   2640 
   2641 	case '.':
   2642           laststart = b;
   2643           BUF_PUSH (anychar);
   2644           break;
   2645 
   2646 
   2647         case '[':
   2648           {
   2649             boolean had_char_class = false;
   2650 #ifdef WCHAR
   2651 	    CHAR_T range_start = 0xffffffff;
   2652 #else
   2653 	    unsigned int range_start = 0xffffffff;
   2654 #endif
   2655             if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   2656 
   2657 #ifdef WCHAR
   2658 	    /* We assume a charset(_not) structure as a wchar_t array.
   2659 	       charset[0] = (re_opcode_t) charset(_not)
   2660                charset[1] = l (= length of char_classes)
   2661                charset[2] = m (= length of collating_symbols)
   2662                charset[3] = n (= length of equivalence_classes)
   2663 	       charset[4] = o (= length of char_ranges)
   2664 	       charset[5] = p (= length of chars)
   2665 
   2666                charset[6] = char_class (wctype_t)
   2667                charset[6+CHAR_CLASS_SIZE] = char_class (wctype_t)
   2668                          ...
   2669                charset[l+5]  = char_class (wctype_t)
   2670 
   2671                charset[l+6]  = collating_symbol (wchar_t)
   2672                             ...
   2673                charset[l+m+5]  = collating_symbol (wchar_t)
   2674 					ifdef _LIBC we use the index if
   2675 					_NL_COLLATE_SYMB_EXTRAMB instead of
   2676 					wchar_t string.
   2677 
   2678                charset[l+m+6]  = equivalence_classes (wchar_t)
   2679                               ...
   2680                charset[l+m+n+5]  = equivalence_classes (wchar_t)
   2681 					ifdef _LIBC we use the index in
   2682 					_NL_COLLATE_WEIGHT instead of
   2683 					wchar_t string.
   2684 
   2685 	       charset[l+m+n+6] = range_start
   2686 	       charset[l+m+n+7] = range_end
   2687 	                       ...
   2688 	       charset[l+m+n+2o+4] = range_start
   2689 	       charset[l+m+n+2o+5] = range_end
   2690 					ifdef _LIBC we use the value looked up
   2691 					in _NL_COLLATE_COLLSEQ instead of
   2692 					wchar_t character.
   2693 
   2694 	       charset[l+m+n+2o+6] = char
   2695 	                          ...
   2696 	       charset[l+m+n+2o+p+5] = char
   2697 
   2698 	     */
   2699 
   2700 	    /* We need at least 6 spaces: the opcode, the length of
   2701                char_classes, the length of collating_symbols, the length of
   2702                equivalence_classes, the length of char_ranges, the length of
   2703                chars.  */
   2704 	    GET_BUFFER_SPACE (6);
   2705 
   2706 	    /* Save b as laststart. And We use laststart as the pointer
   2707 	       to the first element of the charset here.
   2708 	       In other words, laststart[i] indicates charset[i].  */
   2709             laststart = b;
   2710 
   2711             /* We test `*p == '^' twice, instead of using an if
   2712                statement, so we only need one BUF_PUSH.  */
   2713             BUF_PUSH (*p == '^' ? charset_not : charset);
   2714             if (*p == '^')
   2715               p++;
   2716 
   2717             /* Push the length of char_classes, the length of
   2718                collating_symbols, the length of equivalence_classes, the
   2719                length of char_ranges and the length of chars.  */
   2720             BUF_PUSH_3 (0, 0, 0);
   2721             BUF_PUSH_2 (0, 0);
   2722 
   2723             /* Remember the first position in the bracket expression.  */
   2724             p1 = p;
   2725 
   2726             /* charset_not matches newline according to a syntax bit.  */
   2727             if ((re_opcode_t) b[-6] == charset_not
   2728                 && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
   2729 	      {
   2730 		BUF_PUSH('\n');
   2731 		laststart[5]++; /* Update the length of characters  */
   2732 	      }
   2733 
   2734             /* Read in characters and ranges, setting map bits.  */
   2735             for (;;)
   2736               {
   2737                 if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   2738 
   2739                 PATFETCH (c);
   2740 
   2741                 /* \ might escape characters inside [...] and [^...].  */
   2742                 if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
   2743                   {
   2744                     if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
   2745 
   2746                     PATFETCH (c1);
   2747 		    BUF_PUSH(c1);
   2748 		    laststart[5]++; /* Update the length of chars  */
   2749 		    range_start = c1;
   2750                     continue;
   2751                   }
   2752 
   2753                 /* Could be the end of the bracket expression.  If it's
   2754                    not (i.e., when the bracket expression is `[]' so
   2755                    far), the ']' character bit gets set way below.  */
   2756                 if (c == ']' && p != p1 + 1)
   2757                   break;
   2758 
   2759                 /* Look ahead to see if it's a range when the last thing
   2760                    was a character class.  */
   2761                 if (had_char_class && c == '-' && *p != ']')
   2762                   FREE_STACK_RETURN (REG_ERANGE);
   2763 
   2764                 /* Look ahead to see if it's a range when the last thing
   2765                    was a character: if this is a hyphen not at the
   2766                    beginning or the end of a list, then it's the range
   2767                    operator.  */
   2768                 if (c == '-'
   2769                     && !(p - 2 >= pattern && p[-2] == '[')
   2770                     && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
   2771                     && *p != ']')
   2772                   {
   2773                     reg_errcode_t ret;
   2774 		    /* Allocate the space for range_start and range_end.  */
   2775 		    GET_BUFFER_SPACE (2);
   2776 		    /* Update the pointer to indicate end of buffer.  */
   2777                     b += 2;
   2778                     ret = wcs_compile_range (range_start, &p, pend, translate,
   2779                                          syntax, b, laststart);
   2780                     if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
   2781                     range_start = 0xffffffff;
   2782                   }
   2783                 else if (p[0] == '-' && p[1] != ']')
   2784                   { /* This handles ranges made up of characters only.  */
   2785                     reg_errcode_t ret;
   2786 
   2787 		    /* Move past the `-'.  */
   2788                     PATFETCH (c1);
   2789 		    /* Allocate the space for range_start and range_end.  */
   2790 		    GET_BUFFER_SPACE (2);
   2791 		    /* Update the pointer to indicate end of buffer.  */
   2792                     b += 2;
   2793                     ret = wcs_compile_range (c, &p, pend, translate, syntax, b,
   2794                                          laststart);
   2795                     if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
   2796 		    range_start = 0xffffffff;
   2797                   }
   2798 
   2799                 /* See if we're at the beginning of a possible character
   2800                    class.  */
   2801                 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
   2802                   { /* Leave room for the null.  */
   2803                     char str[CHAR_CLASS_MAX_LENGTH + 1];
   2804 
   2805                     PATFETCH (c);
   2806                     c1 = 0;
   2807 
   2808                     /* If pattern is `[[:'.  */
   2809                     if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   2810 
   2811                     for (;;)
   2812                       {
   2813                         PATFETCH (c);
   2814                         if ((c == ':' && *p == ']') || p == pend)
   2815                           break;
   2816 			if (c1 < CHAR_CLASS_MAX_LENGTH)
   2817 			  str[c1++] = c;
   2818 			else
   2819 			  /* This is in any case an invalid class name.  */
   2820 			  str[0] = '\0';
   2821                       }
   2822                     str[c1] = '\0';
   2823 
   2824                     /* If isn't a word bracketed by `[:' and `:]':
   2825                        undo the ending character, the letters, and leave
   2826                        the leading `:' and `[' (but store them as character).  */
   2827                     if (c == ':' && *p == ']')
   2828                       {
   2829 			wctype_t wt;
   2830 			uintptr_t alignedp;
   2831 
   2832 			/* Query the character class as wctype_t.  */
   2833 			wt = IS_CHAR_CLASS (str);
   2834 			if (wt == 0)
   2835 			  FREE_STACK_RETURN (REG_ECTYPE);
   2836 
   2837                         /* Throw away the ] at the end of the character
   2838                            class.  */
   2839                         PATFETCH (c);
   2840 
   2841                         if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   2842 
   2843 			/* Allocate the space for character class.  */
   2844                         GET_BUFFER_SPACE(CHAR_CLASS_SIZE);
   2845 			/* Update the pointer to indicate end of buffer.  */
   2846                         b += CHAR_CLASS_SIZE;
   2847 			/* Move data which follow character classes
   2848 			    not to violate the data.  */
   2849                         insert_space(CHAR_CLASS_SIZE,
   2850 				     laststart + 6 + laststart[1],
   2851 				     b - 1);
   2852 			alignedp = ((uintptr_t)(laststart + 6 + laststart[1])
   2853 				    + __alignof__(wctype_t) - 1)
   2854 			  	    & ~(uintptr_t)(__alignof__(wctype_t) - 1);
   2855 			/* Store the character class.  */
   2856                         *((wctype_t*)alignedp) = wt;
   2857                         /* Update length of char_classes */
   2858                         laststart[1] += CHAR_CLASS_SIZE;
   2859 
   2860                         had_char_class = true;
   2861                       }
   2862                     else
   2863                       {
   2864                         c1++;
   2865                         while (c1--)
   2866                           PATUNFETCH;
   2867                         BUF_PUSH ('[');
   2868                         BUF_PUSH (':');
   2869                         laststart[5] += 2; /* Update the length of characters  */
   2870 			range_start = ':';
   2871                         had_char_class = false;
   2872                       }
   2873                   }
   2874                 else if (syntax & RE_CHAR_CLASSES && c == '[' && (*p == '='
   2875 							  || *p == '.'))
   2876 		  {
   2877 		    CHAR_T str[128];	/* Should be large enough.  */
   2878 		    CHAR_T delim = *p; /* '=' or '.'  */
   2879 # ifdef _LIBC
   2880 		    uint32_t nrules =
   2881 		      _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
   2882 # endif
   2883 		    PATFETCH (c);
   2884 		    c1 = 0;
   2885 
   2886 		    /* If pattern is `[[=' or '[[.'.  */
   2887 		    if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   2888 
   2889 		    for (;;)
   2890 		      {
   2891 			PATFETCH (c);
   2892 			if ((c == delim && *p == ']') || p == pend)
   2893 			  break;
   2894 			if (c1 < sizeof (str) - 1)
   2895 			  str[c1++] = c;
   2896 			else
   2897 			  /* This is in any case an invalid class name.  */
   2898 			  str[0] = '\0';
   2899                       }
   2900 		    str[c1] = '\0';
   2901 
   2902 		    if (c == delim && *p == ']' && str[0] != '\0')
   2903 		      {
   2904                         unsigned int i, offset;
   2905 			/* If we have no collation data we use the default
   2906 			   collation in which each character is in a class
   2907 			   by itself.  It also means that ASCII is the
   2908 			   character set and therefore we cannot have character
   2909 			   with more than one byte in the multibyte
   2910 			   representation.  */
   2911 
   2912                         /* If not defined _LIBC, we push the name and
   2913 			   `\0' for the sake of matching performance.  */
   2914 			int datasize = c1 + 1;
   2915 
   2916 # ifdef _LIBC
   2917 			int32_t idx = 0;
   2918 			if (nrules == 0)
   2919 # endif
   2920 			  {
   2921 			    if (c1 != 1)
   2922 			      FREE_STACK_RETURN (REG_ECOLLATE);
   2923 			  }
   2924 # ifdef _LIBC
   2925 			else
   2926 			  {
   2927 			    const int32_t *table;
   2928 			    const int32_t *weights;
   2929 			    const int32_t *extra;
   2930 			    const int32_t *indirect;
   2931 			    wint_t *cp;
   2932 
   2933 			    /* This #include defines a local function!  */
   2934 #  include <locale/weightwc.h>
   2935 
   2936 			    if(delim == '=')
   2937 			      {
   2938 				/* We push the index for equivalence class.  */
   2939 				cp = (wint_t*)str;
   2940 
   2941 				table = (const int32_t *)
   2942 				  _NL_CURRENT (LC_COLLATE,
   2943 					       _NL_COLLATE_TABLEWC);
   2944 				weights = (const int32_t *)
   2945 				  _NL_CURRENT (LC_COLLATE,
   2946 					       _NL_COLLATE_WEIGHTWC);
   2947 				extra = (const int32_t *)
   2948 				  _NL_CURRENT (LC_COLLATE,
   2949 					       _NL_COLLATE_EXTRAWC);
   2950 				indirect = (const int32_t *)
   2951 				  _NL_CURRENT (LC_COLLATE,
   2952 					       _NL_COLLATE_INDIRECTWC);
   2953 
   2954 				idx = findidx ((const wint_t**)&cp);
   2955 				if (idx == 0 || cp < (wint_t*) str + c1)
   2956 				  /* This is no valid character.  */
   2957 				  FREE_STACK_RETURN (REG_ECOLLATE);
   2958 
   2959 				str[0] = (wchar_t)idx;
   2960 			      }
   2961 			    else /* delim == '.' */
   2962 			      {
   2963 				/* We push collation sequence value
   2964 				   for collating symbol.  */
   2965 				int32_t table_size;
   2966 				const int32_t *symb_table;
   2967 				const unsigned char *extra;
   2968 				int32_t idx;
   2969 				int32_t elem;
   2970 				int32_t second;
   2971 				int32_t hash;
   2972 				char char_str[c1];
   2973 
   2974 				/* We have to convert the name to a single-byte
   2975 				   string.  This is possible since the names
   2976 				   consist of ASCII characters and the internal
   2977 				   representation is UCS4.  */
   2978 				for (i = 0; i < c1; ++i)
   2979 				  char_str[i] = str[i];
   2980 
   2981 				table_size =
   2982 				  _NL_CURRENT_WORD (LC_COLLATE,
   2983 						    _NL_COLLATE_SYMB_HASH_SIZEMB);
   2984 				symb_table = (const int32_t *)
   2985 				  _NL_CURRENT (LC_COLLATE,
   2986 					       _NL_COLLATE_SYMB_TABLEMB);
   2987 				extra = (const unsigned char *)
   2988 				  _NL_CURRENT (LC_COLLATE,
   2989 					       _NL_COLLATE_SYMB_EXTRAMB);
   2990 
   2991 				/* Locate the character in the hashing table.  */
   2992 				hash = elem_hash (char_str, c1);
   2993 
   2994 				idx = 0;
   2995 				elem = hash % table_size;
   2996 				second = hash % (table_size - 2);
   2997 				while (symb_table[2 * elem] != 0)
   2998 				  {
   2999 				    /* First compare the hashing value.  */
   3000 				    if (symb_table[2 * elem] == hash
   3001 					&& c1 == extra[symb_table[2 * elem + 1]]
   3002 					&& memcmp (char_str,
   3003 						   &extra[symb_table[2 * elem + 1]
   3004 							 + 1], c1) == 0)
   3005 				      {
   3006 					/* Yep, this is the entry.  */
   3007 					idx = symb_table[2 * elem + 1];
   3008 					idx += 1 + extra[idx];
   3009 					break;
   3010 				      }
   3011 
   3012 				    /* Next entry.  */
   3013 				    elem += second;
   3014 				  }
   3015 
   3016 				if (symb_table[2 * elem] != 0)
   3017 				  {
   3018 				    /* Compute the index of the byte sequence
   3019 				       in the table.  */
   3020 				    idx += 1 + extra[idx];
   3021 				    /* Adjust for the alignment.  */
   3022 				    idx = (idx + 3) & ~3;
   3023 
   3024 				    str[0] = (wchar_t) idx + 4;
   3025 				  }
   3026 				else if (symb_table[2 * elem] == 0 && c1 == 1)
   3027 				  {
   3028 				    /* No valid character.  Match it as a
   3029 				       single byte character.  */
   3030 				    had_char_class = false;
   3031 				    BUF_PUSH(str[0]);
   3032 				    /* Update the length of characters  */
   3033 				    laststart[5]++;
   3034 				    range_start = str[0];
   3035 
   3036 				    /* Throw away the ] at the end of the
   3037 				       collating symbol.  */
   3038 				    PATFETCH (c);
   3039 				    /* exit from the switch block.  */
   3040 				    continue;
   3041 				  }
   3042 				else
   3043 				  FREE_STACK_RETURN (REG_ECOLLATE);
   3044 			      }
   3045 			    datasize = 1;
   3046 			  }
   3047 # endif
   3048                         /* Throw away the ] at the end of the equivalence
   3049                            class (or collating symbol).  */
   3050                         PATFETCH (c);
   3051 
   3052 			/* Allocate the space for the equivalence class
   3053 			   (or collating symbol) (and '\0' if needed).  */
   3054                         GET_BUFFER_SPACE(datasize);
   3055 			/* Update the pointer to indicate end of buffer.  */
   3056                         b += datasize;
   3057 
   3058 			if (delim == '=')
   3059 			  { /* equivalence class  */
   3060 			    /* Calculate the offset of char_ranges,
   3061 			       which is next to equivalence_classes.  */
   3062 			    offset = laststart[1] + laststart[2]
   3063 			      + laststart[3] +6;
   3064 			    /* Insert space.  */
   3065 			    insert_space(datasize, laststart + offset, b - 1);
   3066 
   3067 			    /* Write the equivalence_class and \0.  */
   3068 			    for (i = 0 ; i < datasize ; i++)
   3069 			      laststart[offset + i] = str[i];
   3070 
   3071 			    /* Update the length of equivalence_classes.  */
   3072 			    laststart[3] += datasize;
   3073 			    had_char_class = true;
   3074 			  }
   3075 			else /* delim == '.' */
   3076 			  { /* collating symbol  */
   3077 			    /* Calculate the offset of the equivalence_classes,
   3078 			       which is next to collating_symbols.  */
   3079 			    offset = laststart[1] + laststart[2] + 6;
   3080 			    /* Insert space and write the collationg_symbol
   3081 			       and \0.  */
   3082 			    insert_space(datasize, laststart + offset, b-1);
   3083 			    for (i = 0 ; i < datasize ; i++)
   3084 			      laststart[offset + i] = str[i];
   3085 
   3086 			    /* In re_match_2_internal if range_start < -1, we
   3087 			       assume -range_start is the offset of the
   3088 			       collating symbol which is specified as
   3089 			       the character of the range start.  So we assign
   3090 			       -(laststart[1] + laststart[2] + 6) to
   3091 			       range_start.  */
   3092 			    range_start = -(laststart[1] + laststart[2] + 6);
   3093 			    /* Update the length of collating_symbol.  */
   3094 			    laststart[2] += datasize;
   3095 			    had_char_class = false;
   3096 			  }
   3097 		      }
   3098                     else
   3099                       {
   3100                         c1++;
   3101                         while (c1--)
   3102                           PATUNFETCH;
   3103                         BUF_PUSH ('[');
   3104                         BUF_PUSH (delim);
   3105                         laststart[5] += 2; /* Update the length of characters  */
   3106 			range_start = delim;
   3107                         had_char_class = false;
   3108                       }
   3109 		  }
   3110                 else
   3111                   {
   3112                     had_char_class = false;
   3113 		    BUF_PUSH(c);
   3114 		    laststart[5]++;  /* Update the length of characters  */
   3115 		    range_start = c;
   3116                   }
   3117 	      }
   3118 
   3119 #else /* BYTE */
   3120             /* Ensure that we have enough space to push a charset: the
   3121                opcode, the length count, and the bitset; 34 bytes in all.  */
   3122 	    GET_BUFFER_SPACE (34);
   3123 
   3124             laststart = b;
   3125 
   3126             /* We test `*p == '^' twice, instead of using an if
   3127                statement, so we only need one BUF_PUSH.  */
   3128             BUF_PUSH (*p == '^' ? charset_not : charset);
   3129             if (*p == '^')
   3130               p++;
   3131 
   3132             /* Remember the first position in the bracket expression.  */
   3133             p1 = p;
   3134 
   3135             /* Push the number of bytes in the bitmap.  */
   3136             BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
   3137 
   3138             /* Clear the whole map.  */
   3139             bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
   3140 
   3141             /* charset_not matches newline according to a syntax bit.  */
   3142             if ((re_opcode_t) b[-2] == charset_not
   3143                 && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
   3144               SET_LIST_BIT ('\n');
   3145 
   3146             /* Read in characters and ranges, setting map bits.  */
   3147             for (;;)
   3148               {
   3149                 if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   3150 
   3151                 PATFETCH (c);
   3152 
   3153                 /* \ might escape characters inside [...] and [^...].  */
   3154                 if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
   3155                   {
   3156                     if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
   3157 
   3158                     PATFETCH (c1);
   3159                     SET_LIST_BIT (c1);
   3160 		    range_start = c1;
   3161                     continue;
   3162                   }
   3163 
   3164                 /* Could be the end of the bracket expression.  If it's
   3165                    not (i.e., when the bracket expression is `[]' so
   3166                    far), the ']' character bit gets set way below.  */
   3167                 if (c == ']' && p != p1 + 1)
   3168                   break;
   3169 
   3170                 /* Look ahead to see if it's a range when the last thing
   3171                    was a character class.  */
   3172                 if (had_char_class && c == '-' && *p != ']')
   3173                   FREE_STACK_RETURN (REG_ERANGE);
   3174 
   3175                 /* Look ahead to see if it's a range when the last thing
   3176                    was a character: if this is a hyphen not at the
   3177                    beginning or the end of a list, then it's the range
   3178                    operator.  */
   3179                 if (c == '-'
   3180                     && !(p - 2 >= pattern && p[-2] == '[')
   3181                     && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
   3182                     && *p != ']')
   3183                   {
   3184                     reg_errcode_t ret
   3185                       = byte_compile_range (range_start, &p, pend, translate,
   3186 					    syntax, b);
   3187                     if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
   3188 		    range_start = 0xffffffff;
   3189                   }
   3190 
   3191                 else if (p[0] == '-' && p[1] != ']')
   3192                   { /* This handles ranges made up of characters only.  */
   3193                     reg_errcode_t ret;
   3194 
   3195 		    /* Move past the `-'.  */
   3196                     PATFETCH (c1);
   3197 
   3198                     ret = byte_compile_range (c, &p, pend, translate, syntax, b);
   3199                     if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
   3200 		    range_start = 0xffffffff;
   3201                   }
   3202 
   3203                 /* See if we're at the beginning of a possible character
   3204                    class.  */
   3205 
   3206                 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
   3207                   { /* Leave room for the null.  */
   3208                     char str[CHAR_CLASS_MAX_LENGTH + 1];
   3209 
   3210                     PATFETCH (c);
   3211                     c1 = 0;
   3212 
   3213                     /* If pattern is `[[:'.  */
   3214                     if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   3215 
   3216                     for (;;)
   3217                       {
   3218                         PATFETCH (c);
   3219                         if ((c == ':' && *p == ']') || p == pend)
   3220                           break;
   3221 			if (c1 < CHAR_CLASS_MAX_LENGTH)
   3222 			  str[c1++] = c;
   3223 			else
   3224 			  /* This is in any case an invalid class name.  */
   3225 			  str[0] = '\0';
   3226                       }
   3227                     str[c1] = '\0';
   3228 
   3229                     /* If isn't a word bracketed by `[:' and `:]':
   3230                        undo the ending character, the letters, and leave
   3231                        the leading `:' and `[' (but set bits for them).  */
   3232                     if (c == ':' && *p == ']')
   3233                       {
   3234 # if defined _LIBC || WIDE_CHAR_SUPPORT
   3235                         boolean is_lower = STREQ (str, "lower");
   3236                         boolean is_upper = STREQ (str, "upper");
   3237 			wctype_t wt;
   3238                         int ch;
   3239 
   3240 			wt = IS_CHAR_CLASS (str);
   3241 			if (wt == 0)
   3242 			  FREE_STACK_RETURN (REG_ECTYPE);
   3243 
   3244                         /* Throw away the ] at the end of the character
   3245                            class.  */
   3246                         PATFETCH (c);
   3247 
   3248                         if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   3249 
   3250                         for (ch = 0; ch < 1 << BYTEWIDTH; ++ch)
   3251 			  {
   3252 #  ifdef _LIBC
   3253 			    if (__iswctype (__btowc (ch), wt))
   3254 			      SET_LIST_BIT (ch);
   3255 #  else
   3256 			    if (iswctype (btowc (ch), wt))
   3257 			      SET_LIST_BIT (ch);
   3258 #  endif
   3259 
   3260 			    if (translate && (is_upper || is_lower)
   3261 				&& (ISUPPER (ch) || ISLOWER (ch)))
   3262 			      SET_LIST_BIT (ch);
   3263 			  }
   3264 
   3265                         had_char_class = true;
   3266 # else
   3267                         int ch;
   3268                         boolean is_alnum = STREQ (str, "alnum");
   3269                         boolean is_alpha = STREQ (str, "alpha");
   3270                         boolean is_blank = STREQ (str, "blank");
   3271                         boolean is_cntrl = STREQ (str, "cntrl");
   3272                         boolean is_digit = STREQ (str, "digit");
   3273                         boolean is_graph = STREQ (str, "graph");
   3274                         boolean is_lower = STREQ (str, "lower");
   3275                         boolean is_print = STREQ (str, "print");
   3276                         boolean is_punct = STREQ (str, "punct");
   3277                         boolean is_space = STREQ (str, "space");
   3278                         boolean is_upper = STREQ (str, "upper");
   3279                         boolean is_xdigit = STREQ (str, "xdigit");
   3280 
   3281                         if (!IS_CHAR_CLASS (str))
   3282 			  FREE_STACK_RETURN (REG_ECTYPE);
   3283 
   3284                         /* Throw away the ] at the end of the character
   3285                            class.  */
   3286                         PATFETCH (c);
   3287 
   3288                         if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   3289 
   3290                         for (ch = 0; ch < 1 << BYTEWIDTH; ch++)
   3291                           {
   3292 			    /* This was split into 3 if's to
   3293 			       avoid an arbitrary limit in some compiler.  */
   3294                             if (   (is_alnum  && ISALNUM (ch))
   3295                                 || (is_alpha  && ISALPHA (ch))
   3296                                 || (is_blank  && ISBLANK (ch))
   3297                                 || (is_cntrl  && ISCNTRL (ch)))
   3298 			      SET_LIST_BIT (ch);
   3299 			    if (   (is_digit  && ISDIGIT (ch))
   3300                                 || (is_graph  && ISGRAPH (ch))
   3301                                 || (is_lower  && ISLOWER (ch))
   3302                                 || (is_print  && ISPRINT (ch)))
   3303 			      SET_LIST_BIT (ch);
   3304 			    if (   (is_punct  && ISPUNCT (ch))
   3305                                 || (is_space  && ISSPACE (ch))
   3306                                 || (is_upper  && ISUPPER (ch))
   3307                                 || (is_xdigit && ISXDIGIT (ch)))
   3308 			      SET_LIST_BIT (ch);
   3309 			    if (   translate && (is_upper || is_lower)
   3310 				&& (ISUPPER (ch) || ISLOWER (ch)))
   3311 			      SET_LIST_BIT (ch);
   3312                           }
   3313                         had_char_class = true;
   3314 # endif	/* libc || wctype.h */
   3315                       }
   3316                     else
   3317                       {
   3318                         c1++;
   3319                         while (c1--)
   3320                           PATUNFETCH;
   3321                         SET_LIST_BIT ('[');
   3322                         SET_LIST_BIT (':');
   3323 			range_start = ':';
   3324                         had_char_class = false;
   3325                       }
   3326                   }
   3327                 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '=')
   3328 		  {
   3329 		    unsigned char str[MB_LEN_MAX + 1];
   3330 # ifdef _LIBC
   3331 		    uint32_t nrules =
   3332 		      _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
   3333 # endif
   3334 
   3335 		    PATFETCH (c);
   3336 		    c1 = 0;
   3337 
   3338 		    /* If pattern is `[[='.  */
   3339 		    if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   3340 
   3341 		    for (;;)
   3342 		      {
   3343 			PATFETCH (c);
   3344 			if ((c == '=' && *p == ']') || p == pend)
   3345 			  break;
   3346 			if (c1 < MB_LEN_MAX)
   3347 			  str[c1++] = c;
   3348 			else
   3349 			  /* This is in any case an invalid class name.  */
   3350 			  str[0] = '\0';
   3351                       }
   3352 		    str[c1] = '\0';
   3353 
   3354 		    if (c == '=' && *p == ']' && str[0] != '\0')
   3355 		      {
   3356 			/* If we have no collation data we use the default
   3357 			   collation in which each character is in a class
   3358 			   by itself.  It also means that ASCII is the
   3359 			   character set and therefore we cannot have character
   3360 			   with more than one byte in the multibyte
   3361 			   representation.  */
   3362 # ifdef _LIBC
   3363 			if (nrules == 0)
   3364 # endif
   3365 			  {
   3366 			    if (c1 != 1)
   3367 			      FREE_STACK_RETURN (REG_ECOLLATE);
   3368 
   3369 			    /* Throw away the ] at the end of the equivalence
   3370 			       class.  */
   3371 			    PATFETCH (c);
   3372 
   3373 			    /* Set the bit for the character.  */
   3374 			    SET_LIST_BIT (str[0]);
   3375 			  }
   3376 # ifdef _LIBC
   3377 			else
   3378 			  {
   3379 			    /* Try to match the byte sequence in `str' against
   3380 			       those known to the collate implementation.
   3381 			       First find out whether the bytes in `str' are
   3382 			       actually from exactly one character.  */
   3383 			    const int32_t *table;
   3384 			    const unsigned char *weights;
   3385 			    const unsigned char *extra;
   3386 			    const int32_t *indirect;
   3387 			    int32_t idx;
   3388 			    const unsigned char *cp = str;
   3389 			    int ch;
   3390 
   3391 			    /* This #include defines a local function!  */
   3392 #  include <locale/weight.h>
   3393 
   3394 			    table = (const int32_t *)
   3395 			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
   3396 			    weights = (const unsigned char *)
   3397 			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
   3398 			    extra = (const unsigned char *)
   3399 			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
   3400 			    indirect = (const int32_t *)
   3401 			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
   3402 
   3403 			    idx = findidx (&cp);
   3404 			    if (idx == 0 || cp < str + c1)
   3405 			      /* This is no valid character.  */
   3406 			      FREE_STACK_RETURN (REG_ECOLLATE);
   3407 
   3408 			    /* Throw away the ] at the end of the equivalence
   3409 			       class.  */
   3410 			    PATFETCH (c);
   3411 
   3412 			    /* Now we have to go through the whole table
   3413 			       and find all characters which have the same
   3414 			       first level weight.
   3415 
   3416 			       XXX Note that this is not entirely correct.
   3417 			       we would have to match multibyte sequences
   3418 			       but this is not possible with the current
   3419 			       implementation.  */
   3420 			    for (ch = 1; ch < 256; ++ch)
   3421 			      /* XXX This test would have to be changed if we
   3422 				 would allow matching multibyte sequences.  */
   3423 			      if (table[ch] > 0)
   3424 				{
   3425 				  int32_t idx2 = table[ch];
   3426 				  size_t len = weights[idx2];
   3427 
   3428 				  /* Test whether the lenghts match.  */
   3429 				  if (weights[idx] == len)
   3430 				    {
   3431 				      /* They do.  New compare the bytes of
   3432 					 the weight.  */
   3433 				      size_t cnt = 0;
   3434 
   3435 				      while (cnt < len
   3436 					     && (weights[idx + 1 + cnt]
   3437 						 == weights[idx2 + 1 + cnt]))
   3438 					++cnt;
   3439 
   3440 				      if (cnt == len)
   3441 					/* They match.  Mark the character as
   3442 					   acceptable.  */
   3443 					SET_LIST_BIT (ch);
   3444 				    }
   3445 				}
   3446 			  }
   3447 # endif
   3448 			had_char_class = true;
   3449 		      }
   3450                     else
   3451                       {
   3452                         c1++;
   3453                         while (c1--)
   3454                           PATUNFETCH;
   3455                         SET_LIST_BIT ('[');
   3456                         SET_LIST_BIT ('=');
   3457 			range_start = '=';
   3458                         had_char_class = false;
   3459                       }
   3460 		  }
   3461                 else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.')
   3462 		  {
   3463 		    unsigned char str[128];	/* Should be large enough.  */
   3464 # ifdef _LIBC
   3465 		    uint32_t nrules =
   3466 		      _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
   3467 # endif
   3468 
   3469 		    PATFETCH (c);
   3470 		    c1 = 0;
   3471 
   3472 		    /* If pattern is `[[.'.  */
   3473 		    if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
   3474 
   3475 		    for (;;)
   3476 		      {
   3477 			PATFETCH (c);
   3478 			if ((c == '.' && *p == ']') || p == pend)
   3479 			  break;
   3480 			if (c1 < sizeof (str))
   3481 			  str[c1++] = c;
   3482 			else
   3483 			  /* This is in any case an invalid class name.  */
   3484 			  str[0] = '\0';
   3485                       }
   3486 		    str[c1] = '\0';
   3487 
   3488 		    if (c == '.' && *p == ']' && str[0] != '\0')
   3489 		      {
   3490 			/* If we have no collation data we use the default
   3491 			   collation in which each character is the name
   3492 			   for its own class which contains only the one
   3493 			   character.  It also means that ASCII is the
   3494 			   character set and therefore we cannot have character
   3495 			   with more than one byte in the multibyte
   3496 			   representation.  */
   3497 # ifdef _LIBC
   3498 			if (nrules == 0)
   3499 # endif
   3500 			  {
   3501 			    if (c1 != 1)
   3502 			      FREE_STACK_RETURN (REG_ECOLLATE);
   3503 
   3504 			    /* Throw away the ] at the end of the equivalence
   3505 			       class.  */
   3506 			    PATFETCH (c);
   3507 
   3508 			    /* Set the bit for the character.  */
   3509 			    SET_LIST_BIT (str[0]);
   3510 			    range_start = ((const unsigned char *) str)[0];
   3511 			  }
   3512 # ifdef _LIBC
   3513 			else
   3514 			  {
   3515 			    /* Try to match the byte sequence in `str' against
   3516 			       those known to the collate implementation.
   3517 			       First find out whether the bytes in `str' are
   3518 			       actually from exactly one character.  */
   3519 			    int32_t table_size;
   3520 			    const int32_t *symb_table;
   3521 			    const unsigned char *extra;
   3522 			    int32_t idx;
   3523 			    int32_t elem;
   3524 			    int32_t second;
   3525 			    int32_t hash;
   3526 
   3527 			    table_size =
   3528 			      _NL_CURRENT_WORD (LC_COLLATE,
   3529 						_NL_COLLATE_SYMB_HASH_SIZEMB);
   3530 			    symb_table = (const int32_t *)
   3531 			      _NL_CURRENT (LC_COLLATE,
   3532 					   _NL_COLLATE_SYMB_TABLEMB);
   3533 			    extra = (const unsigned char *)
   3534 			      _NL_CURRENT (LC_COLLATE,
   3535 					   _NL_COLLATE_SYMB_EXTRAMB);
   3536 
   3537 			    /* Locate the character in the hashing table.  */
   3538 			    hash = elem_hash (str, c1);
   3539 
   3540 			    idx = 0;
   3541 			    elem = hash % table_size;
   3542 			    second = hash % (table_size - 2);
   3543 			    while (symb_table[2 * elem] != 0)
   3544 			      {
   3545 				/* First compare the hashing value.  */
   3546 				if (symb_table[2 * elem] == hash
   3547 				    && c1 == extra[symb_table[2 * elem + 1]]
   3548 				    && memcmp (str,
   3549 					       &extra[symb_table[2 * elem + 1]
   3550 						     + 1],
   3551 					       c1) == 0)
   3552 				  {
   3553 				    /* Yep, this is the entry.  */
   3554 				    idx = symb_table[2 * elem + 1];
   3555 				    idx += 1 + extra[idx];
   3556 				    break;
   3557 				  }
   3558 
   3559 				/* Next entry.  */
   3560 				elem += second;
   3561 			      }
   3562 
   3563 			    if (symb_table[2 * elem] == 0)
   3564 			      /* This is no valid character.  */
   3565 			      FREE_STACK_RETURN (REG_ECOLLATE);
   3566 
   3567 			    /* Throw away the ] at the end of the equivalence
   3568 			       class.  */
   3569 			    PATFETCH (c);
   3570 
   3571 			    /* Now add the multibyte character(s) we found
   3572 			       to the accept list.
   3573 
   3574 			       XXX Note that this is not entirely correct.
   3575 			       we would have to match multibyte sequences
   3576 			       but this is not possible with the current
   3577 			       implementation.  Also, we have to match
   3578 			       collating symbols, which expand to more than
   3579 			       one file, as a whole and not allow the
   3580 			       individual bytes.  */
   3581 			    c1 = extra[idx++];
   3582 			    if (c1 == 1)
   3583 			      range_start = extra[idx];
   3584 			    while (c1-- > 0)
   3585 			      {
   3586 				SET_LIST_BIT (extra[idx]);
   3587 				++idx;
   3588 			      }
   3589 			  }
   3590 # endif
   3591 			had_char_class = false;
   3592 		      }
   3593                     else
   3594                       {
   3595                         c1++;
   3596                         while (c1--)
   3597                           PATUNFETCH;
   3598                         SET_LIST_BIT ('[');
   3599                         SET_LIST_BIT ('.');
   3600 			range_start = '.';
   3601                         had_char_class = false;
   3602                       }
   3603 		  }
   3604                 else
   3605                   {
   3606                     had_char_class = false;
   3607                     SET_LIST_BIT (c);
   3608 		    range_start = c;
   3609                   }
   3610               }
   3611 
   3612             /* Discard any (non)matching list bytes that are all 0 at the
   3613                end of the map.  Decrease the map-length byte too.  */
   3614             while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
   3615               b[-1]--;
   3616             b += b[-1];
   3617 #endif /* WCHAR */
   3618           }
   3619           break;
   3620 
   3621 
   3622 	case '(':
   3623           if (syntax & RE_NO_BK_PARENS)
   3624             goto handle_open;
   3625           else
   3626             goto normal_char;
   3627 
   3628 
   3629         case ')':
   3630           if (syntax & RE_NO_BK_PARENS)
   3631             goto handle_close;
   3632           else
   3633             goto normal_char;
   3634 
   3635 
   3636         case '\n':
   3637           if (syntax & RE_NEWLINE_ALT)
   3638             goto handle_alt;
   3639           else
   3640             goto normal_char;
   3641 
   3642 
   3643 	case '|':
   3644           if (syntax & RE_NO_BK_VBAR)
   3645             goto handle_alt;
   3646           else
   3647             goto normal_char;
   3648 
   3649 
   3650         case '{':
   3651            if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES)
   3652              goto handle_interval;
   3653            else
   3654              goto normal_char;
   3655 
   3656 
   3657         case '\\':
   3658           if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);
   3659 
   3660           /* Do not translate the character after the \, so that we can
   3661              distinguish, e.g., \B from \b, even if we normally would
   3662              translate, e.g., B to b.  */
   3663           PATFETCH_RAW (c);
   3664 
   3665           switch (c)
   3666             {
   3667             case '(':
   3668               if (syntax & RE_NO_BK_PARENS)
   3669                 goto normal_backslash;
   3670 
   3671             handle_open:
   3672               bufp->re_nsub++;
   3673               regnum++;
   3674 
   3675               if (COMPILE_STACK_FULL)
   3676                 {
   3677                   RETALLOC (compile_stack.stack, compile_stack.size << 1,
   3678                             compile_stack_elt_t);
   3679                   if (compile_stack.stack == NULL) return REG_ESPACE;
   3680 
   3681                   compile_stack.size <<= 1;
   3682                 }
   3683 
   3684               /* These are the values to restore when we hit end of this
   3685                  group.  They are all relative offsets, so that if the
   3686                  whole pattern moves because of realloc, they will still
   3687                  be valid.  */
   3688               COMPILE_STACK_TOP.begalt_offset = begalt - COMPILED_BUFFER_VAR;
   3689               COMPILE_STACK_TOP.fixup_alt_jump
   3690                 = fixup_alt_jump ? fixup_alt_jump - COMPILED_BUFFER_VAR + 1 : 0;
   3691               COMPILE_STACK_TOP.laststart_offset = b - COMPILED_BUFFER_VAR;
   3692               COMPILE_STACK_TOP.regnum = regnum;
   3693 
   3694               /* We will eventually replace the 0 with the number of
   3695                  groups inner to this one.  But do not push a
   3696                  start_memory for groups beyond the last one we can
   3697                  represent in the compiled pattern.  */
   3698               if (regnum <= MAX_REGNUM)
   3699                 {
   3700                   COMPILE_STACK_TOP.inner_group_offset = b
   3701 		    - COMPILED_BUFFER_VAR + 2;
   3702                   BUF_PUSH_3 (start_memory, regnum, 0);
   3703                 }
   3704 
   3705               compile_stack.avail++;
   3706 
   3707               fixup_alt_jump = 0;
   3708               laststart = 0;
   3709               begalt = b;
   3710 	      /* If we've reached MAX_REGNUM groups, then this open
   3711 		 won't actually generate any code, so we'll have to
   3712 		 clear pending_exact explicitly.  */
   3713 	      pending_exact = 0;
   3714               break;
   3715 
   3716 
   3717             case ')':
   3718               if (syntax & RE_NO_BK_PARENS) goto normal_backslash;
   3719 
   3720               if (COMPILE_STACK_EMPTY)
   3721 		{
   3722 		  if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
   3723 		    goto normal_backslash;
   3724 		  else
   3725 		    FREE_STACK_RETURN (REG_ERPAREN);
   3726 		}
   3727 
   3728             handle_close:
   3729               if (fixup_alt_jump)
   3730                 { /* Push a dummy failure point at the end of the
   3731                      alternative for a possible future
   3732                      `pop_failure_jump' to pop.  See comments at
   3733                      `push_dummy_failure' in `re_match_2'.  */
   3734                   BUF_PUSH (push_dummy_failure);
   3735 
   3736                   /* We allocated space for this jump when we assigned
   3737                      to `fixup_alt_jump', in the `handle_alt' case below.  */
   3738                   STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);
   3739                 }
   3740 
   3741               /* See similar code for backslashed left paren above.  */
   3742               if (COMPILE_STACK_EMPTY)
   3743 		{
   3744 		  if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
   3745 		    goto normal_char;
   3746 		  else
   3747 		    FREE_STACK_RETURN (REG_ERPAREN);
   3748 		}
   3749 
   3750               /* Since we just checked for an empty stack above, this
   3751                  ``can't happen''.  */
   3752               assert (compile_stack.avail != 0);
   3753               {
   3754                 /* We don't just want to restore into `regnum', because
   3755                    later groups should continue to be numbered higher,
   3756                    as in `(ab)c(de)' -- the second group is #2.  */
   3757                 regnum_t this_group_regnum;
   3758 
   3759                 compile_stack.avail--;
   3760                 begalt = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.begalt_offset;
   3761                 fixup_alt_jump
   3762                   = COMPILE_STACK_TOP.fixup_alt_jump
   3763                     ? COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.fixup_alt_jump - 1
   3764                     : 0;
   3765                 laststart = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.laststart_offset;
   3766                 this_group_regnum = COMPILE_STACK_TOP.regnum;
   3767 		/* If we've reached MAX_REGNUM groups, then this open
   3768 		   won't actually generate any code, so we'll have to
   3769 		   clear pending_exact explicitly.  */
   3770 		pending_exact = 0;
   3771 
   3772                 /* We're at the end of the group, so now we know how many
   3773                    groups were inside this one.  */
   3774                 if (this_group_regnum <= MAX_REGNUM)
   3775                   {
   3776 		    UCHAR_T *inner_group_loc
   3777                       = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.inner_group_offset;
   3778 
   3779                     *inner_group_loc = regnum - this_group_regnum;
   3780                     BUF_PUSH_3 (stop_memory, this_group_regnum,
   3781                                 regnum - this_group_regnum);
   3782                   }
   3783               }
   3784               break;
   3785 
   3786 
   3787             case '|':					/* `\|'.  */
   3788               if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR)
   3789                 goto normal_backslash;
   3790             handle_alt:
   3791               if (syntax & RE_LIMITED_OPS)
   3792                 goto normal_char;
   3793 
   3794               /* Insert before the previous alternative a jump which
   3795                  jumps to this alternative if the former fails.  */
   3796               GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
   3797               INSERT_JUMP (on_failure_jump, begalt,
   3798 			   b + 2 + 2 * OFFSET_ADDRESS_SIZE);
   3799               pending_exact = 0;
   3800               b += 1 + OFFSET_ADDRESS_SIZE;
   3801 
   3802               /* The alternative before this one has a jump after it
   3803                  which gets executed if it gets matched.  Adjust that
   3804                  jump so it will jump to this alternative's analogous
   3805                  jump (put in below, which in turn will jump to the next
   3806                  (if any) alternative's such jump, etc.).  The last such
   3807                  jump jumps to the correct final destination.  A picture:
   3808                           _____ _____
   3809                           |   | |   |
   3810                           |   v |   v
   3811                          a | b   | c
   3812 
   3813                  If we are at `b', then fixup_alt_jump right now points to a
   3814                  three-byte space after `a'.  We'll put in the jump, set
   3815                  fixup_alt_jump to right after `b', and leave behind three
   3816                  bytes which we'll fill in when we get to after `c'.  */
   3817 
   3818               if (fixup_alt_jump)
   3819                 STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
   3820 
   3821               /* Mark and leave space for a jump after this alternative,
   3822                  to be filled in later either by next alternative or
   3823                  when know we're at the end of a series of alternatives.  */
   3824               fixup_alt_jump = b;
   3825               GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
   3826               b += 1 + OFFSET_ADDRESS_SIZE;
   3827 
   3828               laststart = 0;
   3829               begalt = b;
   3830               break;
   3831 
   3832 
   3833             case '{':
   3834               /* If \{ is a literal.  */
   3835               if (!(syntax & RE_INTERVALS)
   3836                      /* If we're at `\{' and it's not the open-interval
   3837                         operator.  */
   3838 		  || (syntax & RE_NO_BK_BRACES))
   3839                 goto normal_backslash;
   3840 
   3841             handle_interval:
   3842               {
   3843                 /* If got here, then the syntax allows intervals.  */
   3844 
   3845                 /* At least (most) this many matches must be made.  */
   3846                 int lower_bound = -1, upper_bound = -1;
   3847 
   3848 		/* Place in the uncompiled pattern (i.e., just after
   3849 		   the '{') to go back to if the interval is invalid.  */
   3850 		const CHAR_T *beg_interval = p;
   3851 
   3852                 if (p == pend)
   3853 		  goto invalid_interval;
   3854 
   3855                 GET_UNSIGNED_NUMBER (lower_bound);
   3856 
   3857                 if (c == ',')
   3858                   {
   3859                     GET_UNSIGNED_NUMBER (upper_bound);
   3860 		    if (upper_bound < 0)
   3861 		      upper_bound = RE_DUP_MAX;
   3862                   }
   3863                 else
   3864                   /* Interval such as `{1}' => match exactly once. */
   3865                   upper_bound = lower_bound;
   3866 
   3867                 if (! (0 <= lower_bound && lower_bound <= upper_bound))
   3868 		  goto invalid_interval;
   3869 
   3870                 if (!(syntax & RE_NO_BK_BRACES))
   3871                   {
   3872 		    if (c != '\\' || p == pend)
   3873 		      goto invalid_interval;
   3874                     PATFETCH (c);
   3875                   }
   3876 
   3877                 if (c != '}')
   3878 		  goto invalid_interval;
   3879 
   3880                 /* If it's invalid to have no preceding re.  */
   3881                 if (!laststart)
   3882                   {
   3883 		    if (syntax & RE_CONTEXT_INVALID_OPS
   3884 			&& !(syntax & RE_INVALID_INTERVAL_ORD))
   3885                       FREE_STACK_RETURN (REG_BADRPT);
   3886                     else if (syntax & RE_CONTEXT_INDEP_OPS)
   3887                       laststart = b;
   3888                     else
   3889                       goto unfetch_interval;
   3890                   }
   3891 
   3892                 /* We just parsed a valid interval.  */
   3893 
   3894                 if (RE_DUP_MAX < upper_bound)
   3895 		  FREE_STACK_RETURN (REG_BADBR);
   3896 
   3897                 /* If the upper bound is zero, don't want to succeed at
   3898                    all; jump from `laststart' to `b + 3', which will be
   3899 		   the end of the buffer after we insert the jump.  */
   3900 		/* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE'
   3901 		   instead of 'b + 3'.  */
   3902                  if (upper_bound == 0)
   3903                    {
   3904                      GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
   3905                      INSERT_JUMP (jump, laststart, b + 1
   3906 				  + OFFSET_ADDRESS_SIZE);
   3907                      b += 1 + OFFSET_ADDRESS_SIZE;
   3908                    }
   3909 
   3910                  /* Otherwise, we have a nontrivial interval.  When
   3911                     we're all done, the pattern will look like:
   3912                       set_number_at <jump count> <upper bound>
   3913                       set_number_at <succeed_n count> <lower bound>
   3914                       succeed_n <after jump addr> <succeed_n count>
   3915                       <body of loop>
   3916                       jump_n <succeed_n addr> <jump count>
   3917                     (The upper bound and `jump_n' are omitted if
   3918                     `upper_bound' is 1, though.)  */
   3919                  else
   3920                    { /* If the upper bound is > 1, we need to insert
   3921                         more at the end of the loop.  */
   3922                      unsigned nbytes = 2 + 4 * OFFSET_ADDRESS_SIZE +
   3923 		       (upper_bound > 1) * (2 + 4 * OFFSET_ADDRESS_SIZE);
   3924 
   3925                      GET_BUFFER_SPACE (nbytes);
   3926 
   3927                      /* Initialize lower bound of the `succeed_n', even
   3928                         though it will be set during matching by its
   3929                         attendant `set_number_at' (inserted next),
   3930                         because `re_compile_fastmap' needs to know.
   3931                         Jump to the `jump_n' we might insert below.  */
   3932                      INSERT_JUMP2 (succeed_n, laststart,
   3933                                    b + 1 + 2 * OFFSET_ADDRESS_SIZE
   3934 				   + (upper_bound > 1) * (1 + 2 * OFFSET_ADDRESS_SIZE)
   3935 				   , lower_bound);
   3936                      b += 1 + 2 * OFFSET_ADDRESS_SIZE;
   3937 
   3938                      /* Code to initialize the lower bound.  Insert
   3939                         before the `succeed_n'.  The `5' is the last two
   3940                         bytes of this `set_number_at', plus 3 bytes of
   3941                         the following `succeed_n'.  */
   3942 		     /* ifdef WCHAR, The '1+2*OFFSET_ADDRESS_SIZE'
   3943 			is the 'set_number_at', plus '1+OFFSET_ADDRESS_SIZE'
   3944 			of the following `succeed_n'.  */
   3945                      PREFIX(insert_op2) (set_number_at, laststart, 1
   3946 				 + 2 * OFFSET_ADDRESS_SIZE, lower_bound, b);
   3947                      b += 1 + 2 * OFFSET_ADDRESS_SIZE;
   3948 
   3949                      if (upper_bound > 1)
   3950                        { /* More than one repetition is allowed, so
   3951                             append a backward jump to the `succeed_n'
   3952                             that starts this interval.
   3953 
   3954                             When we've reached this during matching,
   3955                             we'll have matched the interval once, so
   3956                             jump back only `upper_bound - 1' times.  */
   3957                          STORE_JUMP2 (jump_n, b, laststart
   3958 				      + 2 * OFFSET_ADDRESS_SIZE + 1,
   3959                                       upper_bound - 1);
   3960                          b += 1 + 2 * OFFSET_ADDRESS_SIZE;
   3961 
   3962                          /* The location we want to set is the second
   3963                             parameter of the `jump_n'; that is `b-2' as
   3964                             an absolute address.  `laststart' will be
   3965                             the `set_number_at' we're about to insert;
   3966                             `laststart+3' the number to set, the source
   3967                             for the relative address.  But we are
   3968                             inserting into the middle of the pattern --
   3969                             so everything is getting moved up by 5.
   3970                             Conclusion: (b - 2) - (laststart + 3) + 5,
   3971                             i.e., b - laststart.
   3972 
   3973                             We insert this at the beginning of the loop
   3974                             so that if we fail during matching, we'll
   3975                             reinitialize the bounds.  */
   3976                          PREFIX(insert_op2) (set_number_at, laststart,
   3977 					     b - laststart,
   3978 					     upper_bound - 1, b);
   3979                          b += 1 + 2 * OFFSET_ADDRESS_SIZE;
   3980                        }
   3981                    }
   3982                 pending_exact = 0;
   3983 		break;
   3984 
   3985 	      invalid_interval:
   3986 		if (!(syntax & RE_INVALID_INTERVAL_ORD))
   3987 		  FREE_STACK_RETURN (p == pend ? REG_EBRACE : REG_BADBR);
   3988 	      unfetch_interval:
   3989 		/* Match the characters as literals.  */
   3990 		p = beg_interval;
   3991 		c = '{';
   3992 		if (syntax & RE_NO_BK_BRACES)
   3993 		  goto normal_char;
   3994 		else
   3995 		  goto normal_backslash;
   3996 	      }
   3997 
   3998 #ifdef emacs
   3999             /* There is no way to specify the before_dot and after_dot
   4000                operators.  rms says this is ok.  --karl  */
   4001             case '=':
   4002               BUF_PUSH (at_dot);
   4003               break;
   4004 
   4005             case 's':
   4006               laststart = b;
   4007               PATFETCH (c);
   4008               BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
   4009               break;
   4010 
   4011             case 'S':
   4012               laststart = b;
   4013               PATFETCH (c);
   4014               BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]);
   4015               break;
   4016 #endif /* emacs */
   4017 
   4018 
   4019             case 'w':
   4020 	      if (syntax & RE_NO_GNU_OPS)
   4021 		goto normal_char;
   4022               laststart = b;
   4023               BUF_PUSH (wordchar);
   4024               break;
   4025 
   4026 
   4027             case 'W':
   4028 	      if (syntax & RE_NO_GNU_OPS)
   4029 		goto normal_char;
   4030               laststart = b;
   4031               BUF_PUSH (notwordchar);
   4032               break;
   4033 
   4034 
   4035             case '<':
   4036 	      if (syntax & RE_NO_GNU_OPS)
   4037 		goto normal_char;
   4038               BUF_PUSH (wordbeg);
   4039               break;
   4040 
   4041             case '>':
   4042 	      if (syntax & RE_NO_GNU_OPS)
   4043 		goto normal_char;
   4044               BUF_PUSH (wordend);
   4045               break;
   4046 
   4047             case 'b':
   4048 	      if (syntax & RE_NO_GNU_OPS)
   4049 		goto normal_char;
   4050               BUF_PUSH (wordbound);
   4051               break;
   4052 
   4053             case 'B':
   4054 	      if (syntax & RE_NO_GNU_OPS)
   4055 		goto normal_char;
   4056               BUF_PUSH (notwordbound);
   4057               break;
   4058 
   4059             case '`':
   4060 	      if (syntax & RE_NO_GNU_OPS)
   4061 		goto normal_char;
   4062               BUF_PUSH (begbuf);
   4063               break;
   4064 
   4065             case '\'':
   4066 	      if (syntax & RE_NO_GNU_OPS)
   4067 		goto normal_char;
   4068               BUF_PUSH (endbuf);
   4069               break;
   4070 
   4071             case '1': case '2': case '3': case '4': case '5':
   4072             case '6': case '7': case '8': case '9':
   4073               if (syntax & RE_NO_BK_REFS)
   4074                 goto normal_char;
   4075 
   4076               c1 = c - '0';
   4077 
   4078               if (c1 > regnum)
   4079                 FREE_STACK_RETURN (REG_ESUBREG);
   4080 
   4081               /* Can't back reference to a subexpression if inside of it.  */
   4082               if (group_in_compile_stack (compile_stack, (regnum_t) c1))
   4083                 goto normal_char;
   4084 
   4085               laststart = b;
   4086               BUF_PUSH_2 (duplicate, c1);
   4087               break;
   4088 
   4089 
   4090             case '+':
   4091             case '?':
   4092               if (syntax & RE_BK_PLUS_QM)
   4093                 goto handle_plus;
   4094               else
   4095                 goto normal_backslash;
   4096 
   4097             default:
   4098             normal_backslash:
   4099               /* You might think it would be useful for \ to mean
   4100                  not to translate; but if we don't translate it
   4101                  it will never match anything.  */
   4102               c = TRANSLATE (c);
   4103               goto normal_char;
   4104             }
   4105           break;
   4106 
   4107 
   4108 	default:
   4109         /* Expects the character in `c'.  */
   4110 	normal_char:
   4111 	      /* If no exactn currently being built.  */
   4112           if (!pending_exact
   4113 #ifdef WCHAR
   4114 	      /* If last exactn handle binary(or character) and
   4115 		 new exactn handle character(or binary).  */
   4116 	      || is_exactn_bin != is_binary[p - 1 - pattern]
   4117 #endif /* WCHAR */
   4118 
   4119               /* If last exactn not at current position.  */
   4120               || pending_exact + *pending_exact + 1 != b
   4121 
   4122               /* We have only one byte following the exactn for the count.  */
   4123 	      || *pending_exact == (1 << BYTEWIDTH) - 1
   4124 
   4125               /* If followed by a repetition operator.  */
   4126               || *p == '*' || *p == '^'
   4127 	      || ((syntax & RE_BK_PLUS_QM)
   4128 		  ? *p == '\\' && (p[1] == '+' || p[1] == '?')
   4129 		  : (*p == '+' || *p == '?'))
   4130 	      || ((syntax & RE_INTERVALS)
   4131                   && ((syntax & RE_NO_BK_BRACES)
   4132 		      ? *p == '{'
   4133                       : (p[0] == '\\' && p[1] == '{'))))
   4134 	    {
   4135 	      /* Start building a new exactn.  */
   4136 
   4137               laststart = b;
   4138 
   4139 #ifdef WCHAR
   4140 	      /* Is this exactn binary data or character? */
   4141 	      is_exactn_bin = is_binary[p - 1 - pattern];
   4142 	      if (is_exactn_bin)
   4143 		  BUF_PUSH_2 (exactn_bin, 0);
   4144 	      else
   4145 		  BUF_PUSH_2 (exactn, 0);
   4146 #else
   4147 	      BUF_PUSH_2 (exactn, 0);
   4148 #endif /* WCHAR */
   4149 	      pending_exact = b - 1;
   4150             }
   4151 
   4152 	  BUF_PUSH (c);
   4153           (*pending_exact)++;
   4154 	  break;
   4155         } /* switch (c) */
   4156     } /* while p != pend */
   4157 
   4158 
   4159   /* Through the pattern now.  */
   4160 
   4161   if (fixup_alt_jump)
   4162     STORE_JUMP (jump_past_alt, fixup_alt_jump, b);
   4163 
   4164   if (!COMPILE_STACK_EMPTY)
   4165     FREE_STACK_RETURN (REG_EPAREN);
   4166 
   4167   /* If we don't want backtracking, force success
   4168      the first time we reach the end of the compiled pattern.  */
   4169   if (syntax & RE_NO_POSIX_BACKTRACKING)
   4170     BUF_PUSH (succeed);
   4171 
   4172 #ifdef WCHAR
   4173   free (pattern);
   4174   free (mbs_offset);
   4175   free (is_binary);
   4176 #endif
   4177   free (compile_stack.stack);
   4178 
   4179   /* We have succeeded; set the length of the buffer.  */
   4180 #ifdef WCHAR
   4181   bufp->used = (uintptr_t) b - (uintptr_t) COMPILED_BUFFER_VAR;
   4182 #else
   4183   bufp->used = b - bufp->buffer;
   4184 #endif
   4185 
   4186 #ifdef DEBUG
   4187   if (debug)
   4188     {
   4189       DEBUG_PRINT1 ("\nCompiled pattern: \n");
   4190       PREFIX(print_compiled_pattern) (bufp);
   4191     }
   4192 #endif /* DEBUG */
   4193 
   4194 #ifndef MATCH_MAY_ALLOCATE
   4195   /* Initialize the failure stack to the largest possible stack.  This
   4196      isn't necessary unless we're trying to avoid calling alloca in
   4197      the search and match routines.  */
   4198   {
   4199     int num_regs = bufp->re_nsub + 1;
   4200 
   4201     /* Since DOUBLE_FAIL_STACK refuses to double only if the current size
   4202        is strictly greater than re_max_failures, the largest possible stack
   4203        is 2 * re_max_failures failure points.  */
   4204     if (fail_stack.size < (2 * re_max_failures * MAX_FAILURE_ITEMS))
   4205       {
   4206 	fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS);
   4207 
   4208 # ifdef emacs
   4209 	if (! fail_stack.stack)
   4210 	  fail_stack.stack
   4211 	    = (PREFIX(fail_stack_elt_t) *) xmalloc (fail_stack.size
   4212 				    * sizeof (PREFIX(fail_stack_elt_t)));
   4213 	else
   4214 	  fail_stack.stack
   4215 	    = (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack,
   4216 				     (fail_stack.size
   4217 				      * sizeof (PREFIX(fail_stack_elt_t))));
   4218 # else /* not emacs */
   4219 	if (! fail_stack.stack)
   4220 	  fail_stack.stack
   4221 	    = (PREFIX(fail_stack_elt_t) *) malloc (fail_stack.size
   4222 				   * sizeof (PREFIX(fail_stack_elt_t)));
   4223 	else
   4224 	  fail_stack.stack
   4225 	    = (PREFIX(fail_stack_elt_t) *) realloc (fail_stack.stack,
   4226 					    (fail_stack.size
   4227 				     * sizeof (PREFIX(fail_stack_elt_t))));
   4228 # endif /* not emacs */
   4229       }
   4230 
   4231    PREFIX(regex_grow_registers) (num_regs);
   4232   }
   4233 #endif /* not MATCH_MAY_ALLOCATE */
   4234 
   4235   return REG_NOERROR;
   4236 } /* regex_compile */
   4237 
   4238 /* Subroutines for `regex_compile'.  */
   4239 
   4240 /* Store OP at LOC followed by two-byte integer parameter ARG.  */
   4241 /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
   4242 
   4243 static void
   4244 PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg)
   4245 {
   4246   *loc = (UCHAR_T) op;
   4247   STORE_NUMBER (loc + 1, arg);
   4248 }
   4249 
   4250 
   4251 /* Like `store_op1', but for two two-byte parameters ARG1 and ARG2.  */
   4252 /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
   4253 
   4254 static void
   4255 PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2)
   4256 {
   4257   *loc = (UCHAR_T) op;
   4258   STORE_NUMBER (loc + 1, arg1);
   4259   STORE_NUMBER (loc + 1 + OFFSET_ADDRESS_SIZE, arg2);
   4260 }
   4261 
   4262 
   4263 /* Copy the bytes from LOC to END to open up three bytes of space at LOC
   4264    for OP followed by two-byte integer parameter ARG.  */
   4265 /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
   4266 
   4267 static void
   4268 PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc, int arg, UCHAR_T *end)
   4269 {
   4270   register UCHAR_T *pfrom = end;
   4271   register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE;
   4272 
   4273   while (pfrom != loc)
   4274     *--pto = *--pfrom;
   4275 
   4276   PREFIX(store_op1) (op, loc, arg);
   4277 }
   4278 
   4279 
   4280 /* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2.  */
   4281 /* ifdef WCHAR, integer parameter is 1 wchar_t.  */
   4282 
   4283 static void
   4284 PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, int arg1,
   4285                     int arg2, UCHAR_T *end)
   4286 {
   4287   register UCHAR_T *pfrom = end;
   4288   register UCHAR_T *pto = end + 1 + 2 * OFFSET_ADDRESS_SIZE;
   4289 
   4290   while (pfrom != loc)
   4291     *--pto = *--pfrom;
   4292 
   4293   PREFIX(store_op2) (op, loc, arg1, arg2);
   4294 }
   4295 
   4296 
   4297 /* P points to just after a ^ in PATTERN.  Return true if that ^ comes
   4298    after an alternative or a begin-subexpression.  We assume there is at
   4299    least one character before the ^.  */
   4300 
   4301 static boolean
   4302 PREFIX(at_begline_loc_p) (const CHAR_T *pattern, const CHAR_T *p,
   4303                           reg_syntax_t syntax)
   4304 {
   4305   const CHAR_T *prev = p - 2;
   4306   boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';
   4307 
   4308   return
   4309        /* After a subexpression?  */
   4310        (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
   4311        /* After an alternative?  */
   4312     || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash));
   4313 }
   4314 
   4315 
   4316 /* The dual of at_begline_loc_p.  This one is for $.  We assume there is
   4317    at least one character after the $, i.e., `P < PEND'.  */
   4318 
   4319 static boolean
   4320 PREFIX(at_endline_loc_p) (const CHAR_T *p, const CHAR_T *pend,
   4321                           reg_syntax_t syntax)
   4322 {
   4323   const CHAR_T *next = p;
   4324   boolean next_backslash = *next == '\\';
   4325   const CHAR_T *next_next = p + 1 < pend ? p + 1 : 0;
   4326 
   4327   return
   4328        /* Before a subexpression?  */
   4329        (syntax & RE_NO_BK_PARENS ? *next == ')'
   4330         : next_backslash && next_next && *next_next == ')')
   4331        /* Before an alternative?  */
   4332     || (syntax & RE_NO_BK_VBAR ? *next == '|'
   4333         : next_backslash && next_next && *next_next == '|');
   4334 }
   4335 
   4336 #else /* not INSIDE_RECURSION */
   4337 
   4338 /* Returns true if REGNUM is in one of COMPILE_STACK's elements and
   4339    false if it's not.  */
   4340 
   4341 static boolean
   4342 group_in_compile_stack (compile_stack_type compile_stack, regnum_t regnum)
   4343 {
   4344   int this_element;
   4345 
   4346   for (this_element = compile_stack.avail - 1;
   4347        this_element >= 0;
   4348        this_element--)
   4349     if (compile_stack.stack[this_element].regnum == regnum)
   4350       return true;
   4351 
   4352   return false;
   4353 }
   4354 #endif /* not INSIDE_RECURSION */
   4355 
   4356 #ifdef INSIDE_RECURSION
   4357 
   4358 #ifdef WCHAR
   4359 /* This insert space, which size is "num", into the pattern at "loc".
   4360    "end" must point the end of the allocated buffer.  */
   4361 static void
   4362 insert_space (int num, CHAR_T *loc, CHAR_T *end)
   4363 {
   4364   register CHAR_T *pto = end;
   4365   register CHAR_T *pfrom = end - num;
   4366 
   4367   while (pfrom >= loc)
   4368     *pto-- = *pfrom--;
   4369 }
   4370 #endif /* WCHAR */
   4371 
   4372 #ifdef WCHAR
   4373 static reg_errcode_t
   4374 wcs_compile_range (CHAR_T range_start_char, const CHAR_T **p_ptr,
   4375                    const CHAR_T *pend, RE_TRANSLATE_TYPE translate,
   4376                    reg_syntax_t syntax, CHAR_T *b, CHAR_T *char_set)
   4377 {
   4378   const CHAR_T *p = *p_ptr;
   4379   CHAR_T range_start, range_end;
   4380   reg_errcode_t ret;
   4381 # ifdef _LIBC
   4382   uint32_t nrules;
   4383   uint32_t start_val, end_val;
   4384 # endif
   4385   if (p == pend)
   4386     return REG_ERANGE;
   4387 
   4388 # ifdef _LIBC
   4389   nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
   4390   if (nrules != 0)
   4391     {
   4392       const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE,
   4393 						       _NL_COLLATE_COLLSEQWC);
   4394       const unsigned char *extra = (const unsigned char *)
   4395 	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
   4396 
   4397       if (range_start_char < -1)
   4398 	{
   4399 	  /* range_start is a collating symbol.  */
   4400 	  int32_t *wextra;
   4401 	  /* Retreive the index and get collation sequence value.  */
   4402 	  wextra = (int32_t*)(extra + char_set[-range_start_char]);
   4403 	  start_val = wextra[1 + *wextra];
   4404 	}
   4405       else
   4406 	start_val = collseq_table_lookup(collseq, TRANSLATE(range_start_char));
   4407 
   4408       end_val = collseq_table_lookup (collseq, TRANSLATE (p[0]));
   4409 
   4410       /* Report an error if the range is empty and the syntax prohibits
   4411 	 this.  */
   4412       ret = ((syntax & RE_NO_EMPTY_RANGES)
   4413 	     && (start_val > end_val))? REG_ERANGE : REG_NOERROR;
   4414 
   4415       /* Insert space to the end of the char_ranges.  */
   4416       insert_space(2, b - char_set[5] - 2, b - 1);
   4417       *(b - char_set[5] - 2) = (wchar_t)start_val;
   4418       *(b - char_set[5] - 1) = (wchar_t)end_val;
   4419       char_set[4]++; /* ranges_index */
   4420     }
   4421   else
   4422 # endif
   4423     {
   4424       range_start = (range_start_char >= 0)? TRANSLATE (range_start_char):
   4425 	range_start_char;
   4426       range_end = TRANSLATE (p[0]);
   4427       /* Report an error if the range is empty and the syntax prohibits
   4428 	 this.  */
   4429       ret = ((syntax & RE_NO_EMPTY_RANGES)
   4430 	     && (range_start > range_end))? REG_ERANGE : REG_NOERROR;
   4431 
   4432       /* Insert space to the end of the char_ranges.  */
   4433       insert_space(2, b - char_set[5] - 2, b - 1);
   4434       *(b - char_set[5] - 2) = range_start;
   4435       *(b - char_set[5] - 1) = range_end;
   4436       char_set[4]++; /* ranges_index */
   4437     }
   4438   /* Have to increment the pointer into the pattern string, so the
   4439      caller isn't still at the ending character.  */
   4440   (*p_ptr)++;
   4441 
   4442   return ret;
   4443 }
   4444 #else /* BYTE */
   4445 /* Read the ending character of a range (in a bracket expression) from the
   4446    uncompiled pattern *P_PTR (which ends at PEND).  We assume the
   4447    starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)
   4448    Then we set the translation of all bits between the starting and
   4449    ending characters (inclusive) in the compiled pattern B.
   4450 
   4451    Return an error code.
   4452 
   4453    We use these short variable names so we can use the same macros as
   4454    `regex_compile' itself.  */
   4455 
   4456 static reg_errcode_t
   4457 byte_compile_range (unsigned int range_start_char, const char **p_ptr,
   4458                     const char *pend, RE_TRANSLATE_TYPE translate,
   4459                     reg_syntax_t syntax, unsigned char *b)
   4460 {
   4461   unsigned this_char;
   4462   const char *p = *p_ptr;
   4463   reg_errcode_t ret;
   4464 # if _LIBC
   4465   const unsigned char *collseq;
   4466   unsigned int start_colseq;
   4467   unsigned int end_colseq;
   4468 # else
   4469   unsigned end_char;
   4470 # endif
   4471 
   4472   if (p == pend)
   4473     return REG_ERANGE;
   4474 
   4475   /* Have to increment the pointer into the pattern string, so the
   4476      caller isn't still at the ending character.  */
   4477   (*p_ptr)++;
   4478 
   4479   /* Report an error if the range is empty and the syntax prohibits this.  */
   4480   ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
   4481 
   4482 # if _LIBC
   4483   collseq = (const unsigned char *) _NL_CURRENT (LC_COLLATE,
   4484 						 _NL_COLLATE_COLLSEQMB);
   4485 
   4486   start_colseq = collseq[(unsigned char) TRANSLATE (range_start_char)];
   4487   end_colseq = collseq[(unsigned char) TRANSLATE (p[0])];
   4488   for (this_char = 0; this_char <= (unsigned char) -1; ++this_char)
   4489     {
   4490       unsigned int this_colseq = collseq[(unsigned char) TRANSLATE (this_char)];
   4491 
   4492       if (start_colseq <= this_colseq && this_colseq <= end_colseq)
   4493 	{
   4494 	  SET_LIST_BIT (TRANSLATE (this_char));
   4495 	  ret = REG_NOERROR;
   4496 	}
   4497     }
   4498 # else
   4499   /* Here we see why `this_char' has to be larger than an `unsigned
   4500      char' -- we would otherwise go into an infinite loop, since all
   4501      characters <= 0xff.  */
   4502   range_start_char = TRANSLATE (range_start_char);
   4503   /* TRANSLATE(p[0]) is casted to char (not unsigned char) in TRANSLATE,
   4504      and some compilers cast it to int implicitly, so following for_loop
   4505      may fall to (almost) infinite loop.
   4506      e.g. If translate[p[0]] = 0xff, end_char may equals to 0xffffffff.
   4507      To avoid this, we cast p[0] to unsigned int and truncate it.  */
   4508   end_char = ((unsigned)TRANSLATE(p[0]) & ((1 << BYTEWIDTH) - 1));
   4509 
   4510   for (this_char = range_start_char; this_char <= end_char; ++this_char)
   4511     {
   4512       SET_LIST_BIT (TRANSLATE (this_char));
   4513       ret = REG_NOERROR;
   4514     }
   4515 # endif
   4516 
   4517   return ret;
   4518 }
   4519 #endif /* WCHAR */
   4520 
   4521 /* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
   4523    BUFP.  A fastmap records which of the (1 << BYTEWIDTH) possible
   4524    characters can start a string that matches the pattern.  This fastmap
   4525    is used by re_search to skip quickly over impossible starting points.
   4526 
   4527    The caller must supply the address of a (1 << BYTEWIDTH)-byte data
   4528    area as BUFP->fastmap.
   4529 
   4530    We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
   4531    the pattern buffer.
   4532 
   4533    Returns 0 if we succeed, -2 if an internal error.   */
   4534 
   4535 #ifdef WCHAR
   4536 /* local function for re_compile_fastmap.
   4537    truncate wchar_t character to char.  */
   4538 static unsigned char truncate_wchar (CHAR_T c);
   4539 
   4540 static unsigned char
   4541 truncate_wchar (CHAR_T c)
   4542 {
   4543   unsigned char buf[MB_CUR_MAX];
   4544   mbstate_t state;
   4545   int retval;
   4546   memset (&state, '\0', sizeof (state));
   4547 # ifdef _LIBC
   4548   retval = __wcrtomb (buf, c, &state);
   4549 # else
   4550   retval = wcrtomb (buf, c, &state);
   4551 # endif
   4552   return retval > 0 ? buf[0] : (unsigned char) c;
   4553 }
   4554 #endif /* WCHAR */
   4555 
   4556 static int
   4557 PREFIX(re_compile_fastmap) (struct re_pattern_buffer *bufp)
   4558 {
   4559   int j, k;
   4560 #ifdef MATCH_MAY_ALLOCATE
   4561   PREFIX(fail_stack_type) fail_stack;
   4562 #endif
   4563 #ifndef REGEX_MALLOC
   4564   char *destination;
   4565 #endif
   4566 
   4567   register char *fastmap = bufp->fastmap;
   4568 
   4569 #ifdef WCHAR
   4570   /* We need to cast pattern to (wchar_t*), because we casted this compiled
   4571      pattern to (char*) in regex_compile.  */
   4572   UCHAR_T *pattern = (UCHAR_T*)bufp->buffer;
   4573   register UCHAR_T *pend = (UCHAR_T*) (bufp->buffer + bufp->used);
   4574 #else /* BYTE */
   4575   UCHAR_T *pattern = bufp->buffer;
   4576   register UCHAR_T *pend = pattern + bufp->used;
   4577 #endif /* WCHAR */
   4578   UCHAR_T *p = pattern;
   4579 
   4580 #ifdef REL_ALLOC
   4581   /* This holds the pointer to the failure stack, when
   4582      it is allocated relocatably.  */
   4583   fail_stack_elt_t *failure_stack_ptr;
   4584 #endif
   4585 
   4586   /* Assume that each path through the pattern can be null until
   4587      proven otherwise.  We set this false at the bottom of switch
   4588      statement, to which we get only if a particular path doesn't
   4589      match the empty string.  */
   4590   boolean path_can_be_null = true;
   4591 
   4592   /* We aren't doing a `succeed_n' to begin with.  */
   4593   boolean succeed_n_p = false;
   4594 
   4595   assert (fastmap != NULL && p != NULL);
   4596 
   4597   INIT_FAIL_STACK ();
   4598   bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
   4599   bufp->fastmap_accurate = 1;	    /* It will be when we're done.  */
   4600   bufp->can_be_null = 0;
   4601 
   4602   while (1)
   4603     {
   4604       if (p == pend || *p == (UCHAR_T) succeed)
   4605 	{
   4606 	  /* We have reached the (effective) end of pattern.  */
   4607 	  if (!FAIL_STACK_EMPTY ())
   4608 	    {
   4609 	      bufp->can_be_null |= path_can_be_null;
   4610 
   4611 	      /* Reset for next path.  */
   4612 	      path_can_be_null = true;
   4613 
   4614 	      p = fail_stack.stack[--fail_stack.avail].pointer;
   4615 
   4616 	      continue;
   4617 	    }
   4618 	  else
   4619 	    break;
   4620 	}
   4621 
   4622       /* We should never be about to go beyond the end of the pattern.  */
   4623       assert (p < pend);
   4624 
   4625       switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
   4626 	{
   4627 
   4628         /* I guess the idea here is to simply not bother with a fastmap
   4629            if a backreference is used, since it's too hard to figure out
   4630            the fastmap for the corresponding group.  Setting
   4631            `can_be_null' stops `re_search_2' from using the fastmap, so
   4632            that is all we do.  */
   4633 	case duplicate:
   4634 	  bufp->can_be_null = 1;
   4635           goto done;
   4636 
   4637 
   4638       /* Following are the cases which match a character.  These end
   4639          with `break'.  */
   4640 
   4641 #ifdef WCHAR
   4642 	case exactn:
   4643           fastmap[truncate_wchar(p[1])] = 1;
   4644 	  break;
   4645 #else /* BYTE */
   4646 	case exactn:
   4647           fastmap[p[1]] = 1;
   4648 	  break;
   4649 #endif /* WCHAR */
   4650 #ifdef MBS_SUPPORT
   4651 	case exactn_bin:
   4652 	  fastmap[p[1]] = 1;
   4653 	  break;
   4654 #endif
   4655 
   4656 #ifdef WCHAR
   4657         /* It is hard to distinguish fastmap from (multi byte) characters
   4658            which depends on current locale.  */
   4659         case charset:
   4660 	case charset_not:
   4661 	case wordchar:
   4662 	case notwordchar:
   4663           bufp->can_be_null = 1;
   4664           goto done;
   4665 #else /* BYTE */
   4666         case charset:
   4667           for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
   4668 	    if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
   4669               fastmap[j] = 1;
   4670 	  break;
   4671 
   4672 
   4673 	case charset_not:
   4674 	  /* Chars beyond end of map must be allowed.  */
   4675 	  for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
   4676             fastmap[j] = 1;
   4677 
   4678 	  for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
   4679 	    if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
   4680               fastmap[j] = 1;
   4681           break;
   4682 
   4683 
   4684 	case wordchar:
   4685 	  for (j = 0; j < (1 << BYTEWIDTH); j++)
   4686 	    if (SYNTAX (j) == Sword)
   4687 	      fastmap[j] = 1;
   4688 	  break;
   4689 
   4690 
   4691 	case notwordchar:
   4692 	  for (j = 0; j < (1 << BYTEWIDTH); j++)
   4693 	    if (SYNTAX (j) != Sword)
   4694 	      fastmap[j] = 1;
   4695 	  break;
   4696 #endif /* WCHAR */
   4697 
   4698         case anychar:
   4699 	  {
   4700 	    int fastmap_newline = fastmap['\n'];
   4701 
   4702 	    /* `.' matches anything ...  */
   4703 	    for (j = 0; j < (1 << BYTEWIDTH); j++)
   4704 	      fastmap[j] = 1;
   4705 
   4706 	    /* ... except perhaps newline.  */
   4707 	    if (!(bufp->syntax & RE_DOT_NEWLINE))
   4708 	      fastmap['\n'] = fastmap_newline;
   4709 
   4710 	    /* Return if we have already set `can_be_null'; if we have,
   4711 	       then the fastmap is irrelevant.  Something's wrong here.  */
   4712 	    else if (bufp->can_be_null)
   4713 	      goto done;
   4714 
   4715 	    /* Otherwise, have to check alternative paths.  */
   4716 	    break;
   4717 	  }
   4718 
   4719 #ifdef emacs
   4720         case syntaxspec:
   4721 	  k = *p++;
   4722 	  for (j = 0; j < (1 << BYTEWIDTH); j++)
   4723 	    if (SYNTAX (j) == (enum syntaxcode) k)
   4724 	      fastmap[j] = 1;
   4725 	  break;
   4726 
   4727 
   4728 	case notsyntaxspec:
   4729 	  k = *p++;
   4730 	  for (j = 0; j < (1 << BYTEWIDTH); j++)
   4731 	    if (SYNTAX (j) != (enum syntaxcode) k)
   4732 	      fastmap[j] = 1;
   4733 	  break;
   4734 
   4735 
   4736       /* All cases after this match the empty string.  These end with
   4737          `continue'.  */
   4738 
   4739 
   4740 	case before_dot:
   4741 	case at_dot:
   4742 	case after_dot:
   4743           continue;
   4744 #endif /* emacs */
   4745 
   4746 
   4747         case no_op:
   4748         case begline:
   4749         case endline:
   4750 	case begbuf:
   4751 	case endbuf:
   4752 	case wordbound:
   4753 	case notwordbound:
   4754 	case wordbeg:
   4755 	case wordend:
   4756         case push_dummy_failure:
   4757           continue;
   4758 
   4759 
   4760 	case jump_n:
   4761         case pop_failure_jump:
   4762 	case maybe_pop_jump:
   4763 	case jump:
   4764         case jump_past_alt:
   4765 	case dummy_failure_jump:
   4766           EXTRACT_NUMBER_AND_INCR (j, p);
   4767 	  p += j;
   4768 	  if (j > 0)
   4769 	    continue;
   4770 
   4771           /* Jump backward implies we just went through the body of a
   4772              loop and matched nothing.  Opcode jumped to should be
   4773              `on_failure_jump' or `succeed_n'.  Just treat it like an
   4774              ordinary jump.  For a * loop, it has pushed its failure
   4775              point already; if so, discard that as redundant.  */
   4776           if ((re_opcode_t) *p != on_failure_jump
   4777 	      && (re_opcode_t) *p != succeed_n)
   4778 	    continue;
   4779 
   4780           p++;
   4781           EXTRACT_NUMBER_AND_INCR (j, p);
   4782           p += j;
   4783 
   4784           /* If what's on the stack is where we are now, pop it.  */
   4785           if (!FAIL_STACK_EMPTY ()
   4786 	      && fail_stack.stack[fail_stack.avail - 1].pointer == p)
   4787             fail_stack.avail--;
   4788 
   4789           continue;
   4790 
   4791 
   4792         case on_failure_jump:
   4793         case on_failure_keep_string_jump:
   4794 	handle_on_failure_jump:
   4795           EXTRACT_NUMBER_AND_INCR (j, p);
   4796 
   4797           /* For some patterns, e.g., `(a?)?', `p+j' here points to the
   4798              end of the pattern.  We don't want to push such a point,
   4799              since when we restore it above, entering the switch will
   4800              increment `p' past the end of the pattern.  We don't need
   4801              to push such a point since we obviously won't find any more
   4802              fastmap entries beyond `pend'.  Such a pattern can match
   4803              the null string, though.  */
   4804           if (p + j < pend)
   4805             {
   4806               if (!PUSH_PATTERN_OP (p + j, fail_stack))
   4807 		{
   4808 		  RESET_FAIL_STACK ();
   4809 		  return -2;
   4810 		}
   4811             }
   4812           else
   4813             bufp->can_be_null = 1;
   4814 
   4815           if (succeed_n_p)
   4816             {
   4817               EXTRACT_NUMBER_AND_INCR (k, p);	/* Skip the n.  */
   4818               succeed_n_p = false;
   4819 	    }
   4820 
   4821           continue;
   4822 
   4823 
   4824 	case succeed_n:
   4825           /* Get to the number of times to succeed.  */
   4826           p += OFFSET_ADDRESS_SIZE;
   4827 
   4828           /* Increment p past the n for when k != 0.  */
   4829           EXTRACT_NUMBER_AND_INCR (k, p);
   4830           if (k == 0)
   4831 	    {
   4832               p -= 2 * OFFSET_ADDRESS_SIZE;
   4833   	      succeed_n_p = true;  /* Spaghetti code alert.  */
   4834               goto handle_on_failure_jump;
   4835             }
   4836           continue;
   4837 
   4838 
   4839 	case set_number_at:
   4840           p += 2 * OFFSET_ADDRESS_SIZE;
   4841           continue;
   4842 
   4843 
   4844 	case start_memory:
   4845         case stop_memory:
   4846 	  p += 2;
   4847 	  continue;
   4848 
   4849 
   4850 	default:
   4851           abort (); /* We have listed all the cases.  */
   4852         } /* switch *p++ */
   4853 
   4854       /* Getting here means we have found the possible starting
   4855          characters for one path of the pattern -- and that the empty
   4856          string does not match.  We need not follow this path further.
   4857          Instead, look at the next alternative (remembered on the
   4858          stack), or quit if no more.  The test at the top of the loop
   4859          does these things.  */
   4860       path_can_be_null = false;
   4861       p = pend;
   4862     } /* while p */
   4863 
   4864   /* Set `can_be_null' for the last path (also the first path, if the
   4865      pattern is empty).  */
   4866   bufp->can_be_null |= path_can_be_null;
   4867 
   4868  done:
   4869   RESET_FAIL_STACK ();
   4870   return 0;
   4871 }
   4872 
   4873 #else /* not INSIDE_RECURSION */
   4874 
   4875 int
   4876 re_compile_fastmap (struct re_pattern_buffer *bufp)
   4877 {
   4878 # ifdef MBS_SUPPORT
   4879   if (MB_CUR_MAX != 1)
   4880     return wcs_re_compile_fastmap(bufp);
   4881   else
   4882 # endif
   4883     return byte_re_compile_fastmap(bufp);
   4884 } /* re_compile_fastmap */
   4885 #ifdef _LIBC
   4886 weak_alias (__re_compile_fastmap, re_compile_fastmap)
   4887 #endif
   4888 
   4889 
   4891 /* Set REGS to hold NUM_REGS registers, storing them in STARTS and
   4892    ENDS.  Subsequent matches using PATTERN_BUFFER and REGS will use
   4893    this memory for recording register information.  STARTS and ENDS
   4894    must be allocated using the malloc library routine, and must each
   4895    be at least NUM_REGS * sizeof (regoff_t) bytes long.
   4896 
   4897    If NUM_REGS == 0, then subsequent matches should allocate their own
   4898    register data.
   4899 
   4900    Unless this function is called, the first search or match using
   4901    PATTERN_BUFFER will allocate its own register data, without
   4902    freeing the old data.  */
   4903 
   4904 void
   4905 re_set_registers (struct re_pattern_buffer *bufp,
   4906                   struct re_registers *regs, unsigned num_regs,
   4907                   regoff_t *starts, regoff_t *ends)
   4908 {
   4909   if (num_regs)
   4910     {
   4911       bufp->regs_allocated = REGS_REALLOCATE;
   4912       regs->num_regs = num_regs;
   4913       regs->start = starts;
   4914       regs->end = ends;
   4915     }
   4916   else
   4917     {
   4918       bufp->regs_allocated = REGS_UNALLOCATED;
   4919       regs->num_regs = 0;
   4920       regs->start = regs->end = (regoff_t *) 0;
   4921     }
   4922 }
   4923 #ifdef _LIBC
   4924 weak_alias (__re_set_registers, re_set_registers)
   4925 #endif
   4926 
   4927 /* Searching routines.  */
   4929 
   4930 /* Like re_search_2, below, but only one string is specified, and
   4931    doesn't let you say where to stop matching.  */
   4932 
   4933 int
   4934 re_search (struct re_pattern_buffer *bufp, const char *string, int size,
   4935            int startpos, int range, struct re_registers *regs)
   4936 {
   4937   return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
   4938 		      regs, size);
   4939 }
   4940 #ifdef _LIBC
   4941 weak_alias (__re_search, re_search)
   4942 #endif
   4943 
   4944 
   4945 /* Using the compiled pattern in BUFP->buffer, first tries to match the
   4946    virtual concatenation of STRING1 and STRING2, starting first at index
   4947    STARTPOS, then at STARTPOS + 1, and so on.
   4948 
   4949    STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.
   4950 
   4951    RANGE is how far to scan while trying to match.  RANGE = 0 means try
   4952    only at STARTPOS; in general, the last start tried is STARTPOS +
   4953    RANGE.
   4954 
   4955    In REGS, return the indices of the virtual concatenation of STRING1
   4956    and STRING2 that matched the entire BUFP->buffer and its contained
   4957    subexpressions.
   4958 
   4959    Do not consider matching one past the index STOP in the virtual
   4960    concatenation of STRING1 and STRING2.
   4961 
   4962    We return either the position in the strings at which the match was
   4963    found, -1 if no match, or -2 if error (such as failure
   4964    stack overflow).  */
   4965 
   4966 int
   4967 re_search_2 (struct re_pattern_buffer *bufp, const char *string1, int size1,
   4968              const char *string2, int size2, int startpos, int range,
   4969              struct re_registers *regs, int stop)
   4970 {
   4971 # ifdef MBS_SUPPORT
   4972   if (MB_CUR_MAX != 1)
   4973     return wcs_re_search_2 (bufp, string1, size1, string2, size2, startpos,
   4974 			    range, regs, stop);
   4975   else
   4976 # endif
   4977     return byte_re_search_2 (bufp, string1, size1, string2, size2, startpos,
   4978 			     range, regs, stop);
   4979 } /* re_search_2 */
   4980 #ifdef _LIBC
   4981 weak_alias (__re_search_2, re_search_2)
   4982 #endif
   4983 
   4984 #endif /* not INSIDE_RECURSION */
   4985 
   4986 #ifdef INSIDE_RECURSION
   4987 
   4988 #ifdef MATCH_MAY_ALLOCATE
   4989 # define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL
   4990 #else
   4991 # define FREE_VAR(var) free (var); var = NULL
   4992 #endif
   4993 
   4994 #ifdef WCHAR
   4995 # define MAX_ALLOCA_SIZE	2000
   4996 
   4997 # define FREE_WCS_BUFFERS() \
   4998   do {									      \
   4999     if (size1 > MAX_ALLOCA_SIZE)					      \
   5000       {									      \
   5001 	free (wcs_string1);						      \
   5002 	free (mbs_offset1);						      \
   5003       }									      \
   5004     else								      \
   5005       {									      \
   5006 	FREE_VAR (wcs_string1);						      \
   5007 	FREE_VAR (mbs_offset1);						      \
   5008       }									      \
   5009     if (size2 > MAX_ALLOCA_SIZE) 					      \
   5010       {									      \
   5011 	free (wcs_string2);						      \
   5012 	free (mbs_offset2);						      \
   5013       }									      \
   5014     else								      \
   5015       {									      \
   5016 	FREE_VAR (wcs_string2);						      \
   5017 	FREE_VAR (mbs_offset2);						      \
   5018       }									      \
   5019   } while (0)
   5020 
   5021 #endif
   5022 
   5023 
   5024 static int
   5025 PREFIX(re_search_2) (struct re_pattern_buffer *bufp, const char *string1,
   5026                      int size1, const char *string2, int size2,
   5027                      int startpos, int range,
   5028                      struct re_registers *regs, int stop)
   5029 {
   5030   int val;
   5031   register char *fastmap = bufp->fastmap;
   5032   register RE_TRANSLATE_TYPE translate = bufp->translate;
   5033   int total_size = size1 + size2;
   5034   int endpos = startpos + range;
   5035 #ifdef WCHAR
   5036   /* We need wchar_t* buffers correspond to cstring1, cstring2.  */
   5037   wchar_t *wcs_string1 = NULL, *wcs_string2 = NULL;
   5038   /* We need the size of wchar_t buffers correspond to csize1, csize2.  */
   5039   int wcs_size1 = 0, wcs_size2 = 0;
   5040   /* offset buffer for optimizatoin. See convert_mbs_to_wc.  */
   5041   int *mbs_offset1 = NULL, *mbs_offset2 = NULL;
   5042   /* They hold whether each wchar_t is binary data or not.  */
   5043   char *is_binary = NULL;
   5044 #endif /* WCHAR */
   5045 
   5046   /* Check for out-of-range STARTPOS.  */
   5047   if (startpos < 0 || startpos > total_size)
   5048     return -1;
   5049 
   5050   /* Fix up RANGE if it might eventually take us outside
   5051      the virtual concatenation of STRING1 and STRING2.
   5052      Make sure we won't move STARTPOS below 0 or above TOTAL_SIZE.  */
   5053   if (endpos < 0)
   5054     range = 0 - startpos;
   5055   else if (endpos > total_size)
   5056     range = total_size - startpos;
   5057 
   5058   /* If the search isn't to be a backwards one, don't waste time in a
   5059      search for a pattern that must be anchored.  */
   5060   if (bufp->used > 0 && range > 0
   5061       && ((re_opcode_t) bufp->buffer[0] == begbuf
   5062 	  /* `begline' is like `begbuf' if it cannot match at newlines.  */
   5063 	  || ((re_opcode_t) bufp->buffer[0] == begline
   5064 	      && !bufp->newline_anchor)))
   5065     {
   5066       if (startpos > 0)
   5067 	return -1;
   5068       else
   5069 	range = 1;
   5070     }
   5071 
   5072 #ifdef emacs
   5073   /* In a forward search for something that starts with \=.
   5074      don't keep searching past point.  */
   5075   if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == at_dot && range > 0)
   5076     {
   5077       range = PT - startpos;
   5078       if (range <= 0)
   5079 	return -1;
   5080     }
   5081 #endif /* emacs */
   5082 
   5083   /* Update the fastmap now if not correct already.  */
   5084   if (fastmap && !bufp->fastmap_accurate)
   5085     if (re_compile_fastmap (bufp) == -2)
   5086       return -2;
   5087 
   5088 #ifdef WCHAR
   5089   /* Allocate wchar_t array for wcs_string1 and wcs_string2 and
   5090      fill them with converted string.  */
   5091   if (size1 != 0)
   5092     {
   5093       if (size1 > MAX_ALLOCA_SIZE)
   5094 	{
   5095 	  wcs_string1 = TALLOC (size1 + 1, CHAR_T);
   5096 	  mbs_offset1 = TALLOC (size1 + 1, int);
   5097 	  is_binary = TALLOC (size1 + 1, char);
   5098 	}
   5099       else
   5100 	{
   5101 	  wcs_string1 = REGEX_TALLOC (size1 + 1, CHAR_T);
   5102 	  mbs_offset1 = REGEX_TALLOC (size1 + 1, int);
   5103 	  is_binary = REGEX_TALLOC (size1 + 1, char);
   5104 	}
   5105       if (!wcs_string1 || !mbs_offset1 || !is_binary)
   5106 	{
   5107 	  if (size1 > MAX_ALLOCA_SIZE)
   5108 	    {
   5109 	      free (wcs_string1);
   5110 	      free (mbs_offset1);
   5111 	      free (is_binary);
   5112 	    }
   5113 	  else
   5114 	    {
   5115 	      FREE_VAR (wcs_string1);
   5116 	      FREE_VAR (mbs_offset1);
   5117 	      FREE_VAR (is_binary);
   5118 	    }
   5119 	  return -2;
   5120 	}
   5121       wcs_size1 = convert_mbs_to_wcs(wcs_string1, string1, size1,
   5122 				     mbs_offset1, is_binary);
   5123       wcs_string1[wcs_size1] = L'\0'; /* for a sentinel  */
   5124       if (size1 > MAX_ALLOCA_SIZE)
   5125 	free (is_binary);
   5126       else
   5127 	FREE_VAR (is_binary);
   5128     }
   5129   if (size2 != 0)
   5130     {
   5131       if (size2 > MAX_ALLOCA_SIZE)
   5132 	{
   5133 	  wcs_string2 = TALLOC (size2 + 1, CHAR_T);
   5134 	  mbs_offset2 = TALLOC (size2 + 1, int);
   5135 	  is_binary = TALLOC (size2 + 1, char);
   5136 	}
   5137       else
   5138 	{
   5139 	  wcs_string2 = REGEX_TALLOC (size2 + 1, CHAR_T);
   5140 	  mbs_offset2 = REGEX_TALLOC (size2 + 1, int);
   5141 	  is_binary = REGEX_TALLOC (size2 + 1, char);
   5142 	}
   5143       if (!wcs_string2 || !mbs_offset2 || !is_binary)
   5144 	{
   5145 	  FREE_WCS_BUFFERS ();
   5146 	  if (size2 > MAX_ALLOCA_SIZE)
   5147 	    free (is_binary);
   5148 	  else
   5149 	    FREE_VAR (is_binary);
   5150 	  return -2;
   5151 	}
   5152       wcs_size2 = convert_mbs_to_wcs(wcs_string2, string2, size2,
   5153 				     mbs_offset2, is_binary);
   5154       wcs_string2[wcs_size2] = L'\0'; /* for a sentinel  */
   5155       if (size2 > MAX_ALLOCA_SIZE)
   5156 	free (is_binary);
   5157       else
   5158 	FREE_VAR (is_binary);
   5159     }
   5160 #endif /* WCHAR */
   5161 
   5162 
   5163   /* Loop through the string, looking for a place to start matching.  */
   5164   for (;;)
   5165     {
   5166       /* If a fastmap is supplied, skip quickly over characters that
   5167          cannot be the start of a match.  If the pattern can match the
   5168          null string, however, we don't need to skip characters; we want
   5169          the first null string.  */
   5170       if (fastmap && startpos < total_size && !bufp->can_be_null)
   5171 	{
   5172 	  if (range > 0)	/* Searching forwards.  */
   5173 	    {
   5174 	      register const char *d;
   5175 	      register int lim = 0;
   5176 	      int irange = range;
   5177 
   5178               if (startpos < size1 && startpos + range >= size1)
   5179                 lim = range - (size1 - startpos);
   5180 
   5181 	      d = (startpos >= size1 ? string2 - size1 : string1) + startpos;
   5182 
   5183               /* Written out as an if-else to avoid testing `translate'
   5184                  inside the loop.  */
   5185 	      if (translate)
   5186                 while (range > lim
   5187                        && !fastmap[(unsigned char)
   5188 				   translate[(unsigned char) *d++]])
   5189                   range--;
   5190 	      else
   5191                 while (range > lim && !fastmap[(unsigned char) *d++])
   5192                   range--;
   5193 
   5194 	      startpos += irange - range;
   5195 	    }
   5196 	  else				/* Searching backwards.  */
   5197 	    {
   5198 	      register CHAR_T c = (size1 == 0 || startpos >= size1
   5199 				      ? string2[startpos - size1]
   5200 				      : string1[startpos]);
   5201 
   5202 	      if (!fastmap[(unsigned char) TRANSLATE (c)])
   5203 		goto advance;
   5204 	    }
   5205 	}
   5206 
   5207       /* If can't match the null string, and that's all we have left, fail.  */
   5208       if (range >= 0 && startpos == total_size && fastmap
   5209           && !bufp->can_be_null)
   5210        {
   5211 #ifdef WCHAR
   5212          FREE_WCS_BUFFERS ();
   5213 #endif
   5214          return -1;
   5215        }
   5216 
   5217 #ifdef WCHAR
   5218       val = wcs_re_match_2_internal (bufp, string1, size1, string2,
   5219 				     size2, startpos, regs, stop,
   5220 				     wcs_string1, wcs_size1,
   5221 				     wcs_string2, wcs_size2,
   5222 				     mbs_offset1, mbs_offset2);
   5223 #else /* BYTE */
   5224       val = byte_re_match_2_internal (bufp, string1, size1, string2,
   5225 				      size2, startpos, regs, stop);
   5226 #endif /* BYTE */
   5227 
   5228 #ifndef REGEX_MALLOC
   5229 # ifdef C_ALLOCA
   5230       alloca (0);
   5231 # endif
   5232 #endif
   5233 
   5234       if (val >= 0)
   5235 	{
   5236 #ifdef WCHAR
   5237 	  FREE_WCS_BUFFERS ();
   5238 #endif
   5239 	  return startpos;
   5240 	}
   5241 
   5242       if (val == -2)
   5243 	{
   5244 #ifdef WCHAR
   5245 	  FREE_WCS_BUFFERS ();
   5246 #endif
   5247 	  return -2;
   5248 	}
   5249 
   5250     advance:
   5251       if (!range)
   5252         break;
   5253       else if (range > 0)
   5254         {
   5255           range--;
   5256           startpos++;
   5257         }
   5258       else
   5259         {
   5260           range++;
   5261           startpos--;
   5262         }
   5263     }
   5264 #ifdef WCHAR
   5265   FREE_WCS_BUFFERS ();
   5266 #endif
   5267   return -1;
   5268 }
   5269 
   5270 #ifdef WCHAR
   5271 /* This converts PTR, a pointer into one of the search wchar_t strings
   5272    `string1' and `string2' into an multibyte string offset from the
   5273    beginning of that string. We use mbs_offset to optimize.
   5274    See convert_mbs_to_wcs.  */
   5275 # define POINTER_TO_OFFSET(ptr)						\
   5276   (FIRST_STRING_P (ptr)							\
   5277    ? ((regoff_t)(mbs_offset1 != NULL? mbs_offset1[(ptr)-string1] : 0))	\
   5278    : ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0)	\
   5279 		 + csize1)))
   5280 #else /* BYTE */
   5281 /* This converts PTR, a pointer into one of the search strings `string1'
   5282    and `string2' into an offset from the beginning of that string.  */
   5283 # define POINTER_TO_OFFSET(ptr)			\
   5284   (FIRST_STRING_P (ptr)				\
   5285    ? ((regoff_t) ((ptr) - string1))		\
   5286    : ((regoff_t) ((ptr) - string2 + size1)))
   5287 #endif /* WCHAR */
   5288 
   5289 /* Macros for dealing with the split strings in re_match_2.  */
   5290 
   5291 #define MATCHING_IN_FIRST_STRING  (dend == end_match_1)
   5292 
   5293 /* Call before fetching a character with *d.  This switches over to
   5294    string2 if necessary.  */
   5295 #define PREFETCH()							\
   5296   while (d == dend)						    	\
   5297     {									\
   5298       /* End of string2 => fail.  */					\
   5299       if (dend == end_match_2) 						\
   5300         goto fail;							\
   5301       /* End of string1 => advance to string2.  */ 			\
   5302       d = string2;						        \
   5303       dend = end_match_2;						\
   5304     }
   5305 
   5306 /* Test if at very beginning or at very end of the virtual concatenation
   5307    of `string1' and `string2'.  If only one string, it's `string2'.  */
   5308 #define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
   5309 #define AT_STRINGS_END(d) ((d) == end2)
   5310 
   5311 
   5312 /* Test if D points to a character which is word-constituent.  We have
   5313    two special cases to check for: if past the end of string1, look at
   5314    the first character in string2; and if before the beginning of
   5315    string2, look at the last character in string1.  */
   5316 #ifdef WCHAR
   5317 /* Use internationalized API instead of SYNTAX.  */
   5318 # define WORDCHAR_P(d)							\
   5319   (iswalnum ((wint_t)((d) == end1 ? *string2				\
   5320            : (d) == string2 - 1 ? *(end1 - 1) : *(d))) != 0		\
   5321    || ((d) == end1 ? *string2						\
   5322        : (d) == string2 - 1 ? *(end1 - 1) : *(d)) == L'_')
   5323 #else /* BYTE */
   5324 # define WORDCHAR_P(d)							\
   5325   (SYNTAX ((d) == end1 ? *string2					\
   5326            : (d) == string2 - 1 ? *(end1 - 1) : *(d))			\
   5327    == Sword)
   5328 #endif /* WCHAR */
   5329 
   5330 /* Disabled due to a compiler bug -- see comment at case wordbound */
   5331 #if 0
   5332 /* Test if the character before D and the one at D differ with respect
   5333    to being word-constituent.  */
   5334 #define AT_WORD_BOUNDARY(d)						\
   5335   (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)				\
   5336    || WORDCHAR_P (d - 1) != WORDCHAR_P (d))
   5337 #endif
   5338 
   5339 /* Free everything we malloc.  */
   5340 #ifdef MATCH_MAY_ALLOCATE
   5341 # ifdef WCHAR
   5342 #  define FREE_VARIABLES()						\
   5343   do {									\
   5344     REGEX_FREE_STACK (fail_stack.stack);				\
   5345     FREE_VAR (regstart);						\
   5346     FREE_VAR (regend);							\
   5347     FREE_VAR (old_regstart);						\
   5348     FREE_VAR (old_regend);						\
   5349     FREE_VAR (best_regstart);						\
   5350     FREE_VAR (best_regend);						\
   5351     FREE_VAR (reg_info);						\
   5352     FREE_VAR (reg_dummy);						\
   5353     FREE_VAR (reg_info_dummy);						\
   5354     if (!cant_free_wcs_buf)						\
   5355       {									\
   5356         FREE_VAR (string1);						\
   5357         FREE_VAR (string2);						\
   5358         FREE_VAR (mbs_offset1);						\
   5359         FREE_VAR (mbs_offset2);						\
   5360       }									\
   5361   } while (0)
   5362 # else /* BYTE */
   5363 #  define FREE_VARIABLES()						\
   5364   do {									\
   5365     REGEX_FREE_STACK (fail_stack.stack);				\
   5366     FREE_VAR (regstart);						\
   5367     FREE_VAR (regend);							\
   5368     FREE_VAR (old_regstart);						\
   5369     FREE_VAR (old_regend);						\
   5370     FREE_VAR (best_regstart);						\
   5371     FREE_VAR (best_regend);						\
   5372     FREE_VAR (reg_info);						\
   5373     FREE_VAR (reg_dummy);						\
   5374     FREE_VAR (reg_info_dummy);						\
   5375   } while (0)
   5376 # endif /* WCHAR */
   5377 #else
   5378 # ifdef WCHAR
   5379 #  define FREE_VARIABLES()						\
   5380   do {									\
   5381     if (!cant_free_wcs_buf)						\
   5382       {									\
   5383         FREE_VAR (string1);						\
   5384         FREE_VAR (string2);						\
   5385         FREE_VAR (mbs_offset1);						\
   5386         FREE_VAR (mbs_offset2);						\
   5387       }									\
   5388   } while (0)
   5389 # else /* BYTE */
   5390 #  define FREE_VARIABLES() ((void)0) /* Do nothing!  But inhibit gcc warning. */
   5391 # endif /* WCHAR */
   5392 #endif /* not MATCH_MAY_ALLOCATE */
   5393 
   5394 /* These values must meet several constraints.  They must not be valid
   5395    register values; since we have a limit of 255 registers (because
   5396    we use only one byte in the pattern for the register number), we can
   5397    use numbers larger than 255.  They must differ by 1, because of
   5398    NUM_FAILURE_ITEMS above.  And the value for the lowest register must
   5399    be larger than the value for the highest register, so we do not try
   5400    to actually save any registers when none are active.  */
   5401 #define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)
   5402 #define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)
   5403 
   5404 #else /* not INSIDE_RECURSION */
   5406 /* Matching routines.  */
   5407 
   5408 #ifndef emacs   /* Emacs never uses this.  */
   5409 /* re_match is like re_match_2 except it takes only a single string.  */
   5410 
   5411 int
   5412 re_match (struct re_pattern_buffer *bufp, const char *string,
   5413           int size, int pos, struct re_registers *regs)
   5414 {
   5415   int result;
   5416 # ifdef MBS_SUPPORT
   5417   if (MB_CUR_MAX != 1)
   5418     result = wcs_re_match_2_internal (bufp, NULL, 0, string, size,
   5419 				      pos, regs, size,
   5420 				      NULL, 0, NULL, 0, NULL, NULL);
   5421   else
   5422 # endif
   5423     result = byte_re_match_2_internal (bufp, NULL, 0, string, size,
   5424 				  pos, regs, size);
   5425 # ifndef REGEX_MALLOC
   5426 #  ifdef C_ALLOCA
   5427   alloca (0);
   5428 #  endif
   5429 # endif
   5430   return result;
   5431 }
   5432 # ifdef _LIBC
   5433 weak_alias (__re_match, re_match)
   5434 # endif
   5435 #endif /* not emacs */
   5436 
   5437 #endif /* not INSIDE_RECURSION */
   5438 
   5439 #ifdef INSIDE_RECURSION
   5440 static boolean PREFIX(group_match_null_string_p) (UCHAR_T **p,
   5441                                                   UCHAR_T *end,
   5442 					PREFIX(register_info_type) *reg_info);
   5443 static boolean PREFIX(alt_match_null_string_p) (UCHAR_T *p,
   5444                                                 UCHAR_T *end,
   5445 					PREFIX(register_info_type) *reg_info);
   5446 static boolean PREFIX(common_op_match_null_string_p) (UCHAR_T **p,
   5447                                                       UCHAR_T *end,
   5448 					PREFIX(register_info_type) *reg_info);
   5449 static int PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2,
   5450                                    int len, char *translate);
   5451 #else /* not INSIDE_RECURSION */
   5452 
   5453 /* re_match_2 matches the compiled pattern in BUFP against the
   5454    the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
   5455    and SIZE2, respectively).  We start matching at POS, and stop
   5456    matching at STOP.
   5457 
   5458    If REGS is non-null and the `no_sub' field of BUFP is nonzero, we
   5459    store offsets for the substring each group matched in REGS.  See the
   5460    documentation for exactly how many groups we fill.
   5461 
   5462    We return -1 if no match, -2 if an internal error (such as the
   5463    failure stack overflowing).  Otherwise, we return the length of the
   5464    matched substring.  */
   5465 
   5466 int
   5467 re_match_2 (struct re_pattern_buffer *bufp, const char *string1, int size1,
   5468             const char *string2, int size2, int pos,
   5469             struct re_registers *regs, int stop)
   5470 {
   5471   int result;
   5472 # ifdef MBS_SUPPORT
   5473   if (MB_CUR_MAX != 1)
   5474     result = wcs_re_match_2_internal (bufp, string1, size1, string2, size2,
   5475 				      pos, regs, stop,
   5476 				      NULL, 0, NULL, 0, NULL, NULL);
   5477   else
   5478 # endif
   5479     result = byte_re_match_2_internal (bufp, string1, size1, string2, size2,
   5480 				  pos, regs, stop);
   5481 
   5482 #ifndef REGEX_MALLOC
   5483 # ifdef C_ALLOCA
   5484   alloca (0);
   5485 # endif
   5486 #endif
   5487   return result;
   5488 }
   5489 #ifdef _LIBC
   5490 weak_alias (__re_match_2, re_match_2)
   5491 #endif
   5492 
   5493 #endif /* not INSIDE_RECURSION */
   5494 
   5495 #ifdef INSIDE_RECURSION
   5496 
   5497 #ifdef WCHAR
   5498 static int count_mbs_length (int *, int);
   5499 
   5500 /* This check the substring (from 0, to length) of the multibyte string,
   5501    to which offset_buffer correspond. And count how many wchar_t_characters
   5502    the substring occupy. We use offset_buffer to optimization.
   5503    See convert_mbs_to_wcs.  */
   5504 
   5505 static int
   5506 count_mbs_length(int *offset_buffer, int length)
   5507 {
   5508   int upper, lower;
   5509 
   5510   /* Check whether the size is valid.  */
   5511   if (length < 0)
   5512     return -1;
   5513 
   5514   if (offset_buffer == NULL)
   5515     return 0;
   5516 
   5517   /* If there are no multibyte character, offset_buffer[i] == i.
   5518    Optmize for this case.  */
   5519   if (offset_buffer[length] == length)
   5520     return length;
   5521 
   5522   /* Set up upper with length. (because for all i, offset_buffer[i] >= i)  */
   5523   upper = length;
   5524   lower = 0;
   5525 
   5526   while (true)
   5527     {
   5528       int middle = (lower + upper) / 2;
   5529       if (middle == lower || middle == upper)
   5530 	break;
   5531       if (offset_buffer[middle] > length)
   5532 	upper = middle;
   5533       else if (offset_buffer[middle] < length)
   5534 	lower = middle;
   5535       else
   5536 	return middle;
   5537     }
   5538 
   5539   return -1;
   5540 }
   5541 #endif /* WCHAR */
   5542 
   5543 /* This is a separate function so that we can force an alloca cleanup
   5544    afterwards.  */
   5545 #ifdef WCHAR
   5546 static int
   5547 wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
   5548                          const char *cstring1, int csize1,
   5549                          const char *cstring2, int csize2,
   5550                          int pos,
   5551 			 struct re_registers *regs,
   5552                          int stop,
   5553      /* string1 == string2 == NULL means string1/2, size1/2 and
   5554 	mbs_offset1/2 need seting up in this function.  */
   5555      /* We need wchar_t* buffers correspond to cstring1, cstring2.  */
   5556                          wchar_t *string1, int size1,
   5557                          wchar_t *string2, int size2,
   5558      /* offset buffer for optimizatoin. See convert_mbs_to_wc.  */
   5559 			 int *mbs_offset1, int *mbs_offset2)
   5560 #else /* BYTE */
   5561 static int
   5562 byte_re_match_2_internal (struct re_pattern_buffer *bufp,
   5563                           const char *string1, int size1,
   5564                           const char *string2, int size2,
   5565                           int pos,
   5566 			  struct re_registers *regs, int stop)
   5567 #endif /* BYTE */
   5568 {
   5569   /* General temporaries.  */
   5570   int mcnt;
   5571   UCHAR_T *p1;
   5572 #ifdef WCHAR
   5573   /* They hold whether each wchar_t is binary data or not.  */
   5574   char *is_binary = NULL;
   5575   /* If true, we can't free string1/2, mbs_offset1/2.  */
   5576   int cant_free_wcs_buf = 1;
   5577 #endif /* WCHAR */
   5578 
   5579   /* Just past the end of the corresponding string.  */
   5580   const CHAR_T *end1, *end2;
   5581 
   5582   /* Pointers into string1 and string2, just past the last characters in
   5583      each to consider matching.  */
   5584   const CHAR_T *end_match_1, *end_match_2;
   5585 
   5586   /* Where we are in the data, and the end of the current string.  */
   5587   const CHAR_T *d, *dend;
   5588 
   5589   /* Where we are in the pattern, and the end of the pattern.  */
   5590 #ifdef WCHAR
   5591   UCHAR_T *pattern, *p;
   5592   register UCHAR_T *pend;
   5593 #else /* BYTE */
   5594   UCHAR_T *p = bufp->buffer;
   5595   register UCHAR_T *pend = p + bufp->used;
   5596 #endif /* WCHAR */
   5597 
   5598   /* Mark the opcode just after a start_memory, so we can test for an
   5599      empty subpattern when we get to the stop_memory.  */
   5600   UCHAR_T *just_past_start_mem = 0;
   5601 
   5602   /* We use this to map every character in the string.  */
   5603   RE_TRANSLATE_TYPE translate = bufp->translate;
   5604 
   5605   /* Failure point stack.  Each place that can handle a failure further
   5606      down the line pushes a failure point on this stack.  It consists of
   5607      restart, regend, and reg_info for all registers corresponding to
   5608      the subexpressions we're currently inside, plus the number of such
   5609      registers, and, finally, two char *'s.  The first char * is where
   5610      to resume scanning the pattern; the second one is where to resume
   5611      scanning the strings.  If the latter is zero, the failure point is
   5612      a ``dummy''; if a failure happens and the failure point is a dummy,
   5613      it gets discarded and the next next one is tried.  */
   5614 #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
   5615   PREFIX(fail_stack_type) fail_stack;
   5616 #endif
   5617 #ifdef DEBUG
   5618   static unsigned failure_id;
   5619   unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
   5620 #endif
   5621 
   5622 #ifdef REL_ALLOC
   5623   /* This holds the pointer to the failure stack, when
   5624      it is allocated relocatably.  */
   5625   fail_stack_elt_t *failure_stack_ptr;
   5626 #endif
   5627 
   5628   /* We fill all the registers internally, independent of what we
   5629      return, for use in backreferences.  The number here includes
   5630      an element for register zero.  */
   5631   size_t num_regs = bufp->re_nsub + 1;
   5632 
   5633   /* The currently active registers.  */
   5634   active_reg_t lowest_active_reg = NO_LOWEST_ACTIVE_REG;
   5635   active_reg_t highest_active_reg = NO_HIGHEST_ACTIVE_REG;
   5636 
   5637   /* Information on the contents of registers. These are pointers into
   5638      the input strings; they record just what was matched (on this
   5639      attempt) by a subexpression part of the pattern, that is, the
   5640      regnum-th regstart pointer points to where in the pattern we began
   5641      matching and the regnum-th regend points to right after where we
   5642      stopped matching the regnum-th subexpression.  (The zeroth register
   5643      keeps track of what the whole pattern matches.)  */
   5644 #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
   5645   const CHAR_T **regstart, **regend;
   5646 #endif
   5647 
   5648   /* If a group that's operated upon by a repetition operator fails to
   5649      match anything, then the register for its start will need to be
   5650      restored because it will have been set to wherever in the string we
   5651      are when we last see its open-group operator.  Similarly for a
   5652      register's end.  */
   5653 #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
   5654   const CHAR_T **old_regstart, **old_regend;
   5655 #endif
   5656 
   5657   /* The is_active field of reg_info helps us keep track of which (possibly
   5658      nested) subexpressions we are currently in. The matched_something
   5659      field of reg_info[reg_num] helps us tell whether or not we have
   5660      matched any of the pattern so far this time through the reg_num-th
   5661      subexpression.  These two fields get reset each time through any
   5662      loop their register is in.  */
   5663 #ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
   5664   PREFIX(register_info_type) *reg_info;
   5665 #endif
   5666 
   5667   /* The following record the register info as found in the above
   5668      variables when we find a match better than any we've seen before.
   5669      This happens as we backtrack through the failure points, which in
   5670      turn happens only if we have not yet matched the entire string. */
   5671   unsigned best_regs_set = false;
   5672 #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
   5673   const CHAR_T **best_regstart, **best_regend;
   5674 #endif
   5675 
   5676   /* Logically, this is `best_regend[0]'.  But we don't want to have to
   5677      allocate space for that if we're not allocating space for anything
   5678      else (see below).  Also, we never need info about register 0 for
   5679      any of the other register vectors, and it seems rather a kludge to
   5680      treat `best_regend' differently than the rest.  So we keep track of
   5681      the end of the best match so far in a separate variable.  We
   5682      initialize this to NULL so that when we backtrack the first time
   5683      and need to test it, it's not garbage.  */
   5684   const CHAR_T *match_end = NULL;
   5685 
   5686   /* This helps SET_REGS_MATCHED avoid doing redundant work.  */
   5687   int set_regs_matched_done = 0;
   5688 
   5689   /* Used when we pop values we don't care about.  */
   5690 #ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
   5691   const CHAR_T **reg_dummy;
   5692   PREFIX(register_info_type) *reg_info_dummy;
   5693 #endif
   5694 
   5695 #ifdef DEBUG
   5696   /* Counts the total number of registers pushed.  */
   5697   unsigned num_regs_pushed = 0;
   5698 #endif
   5699 
   5700   DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");
   5701 
   5702   INIT_FAIL_STACK ();
   5703 
   5704 #ifdef MATCH_MAY_ALLOCATE
   5705   /* Do not bother to initialize all the register variables if there are
   5706      no groups in the pattern, as it takes a fair amount of time.  If
   5707      there are groups, we include space for register 0 (the whole
   5708      pattern), even though we never use it, since it simplifies the
   5709      array indexing.  We should fix this.  */
   5710   if (bufp->re_nsub)
   5711     {
   5712       regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
   5713       regend = REGEX_TALLOC (num_regs, const CHAR_T *);
   5714       old_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
   5715       old_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
   5716       best_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
   5717       best_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
   5718       reg_info = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
   5719       reg_dummy = REGEX_TALLOC (num_regs, const CHAR_T *);
   5720       reg_info_dummy = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
   5721 
   5722       if (!(regstart && regend && old_regstart && old_regend && reg_info
   5723             && best_regstart && best_regend && reg_dummy && reg_info_dummy))
   5724         {
   5725           FREE_VARIABLES ();
   5726           return -2;
   5727         }
   5728     }
   5729   else
   5730     {
   5731       /* We must initialize all our variables to NULL, so that
   5732          `FREE_VARIABLES' doesn't try to free them.  */
   5733       regstart = regend = old_regstart = old_regend = best_regstart
   5734         = best_regend = reg_dummy = NULL;
   5735       reg_info = reg_info_dummy = (PREFIX(register_info_type) *) NULL;
   5736     }
   5737 #endif /* MATCH_MAY_ALLOCATE */
   5738 
   5739   /* The starting position is bogus.  */
   5740 #ifdef WCHAR
   5741   if (pos < 0 || pos > csize1 + csize2)
   5742 #else /* BYTE */
   5743   if (pos < 0 || pos > size1 + size2)
   5744 #endif
   5745     {
   5746       FREE_VARIABLES ();
   5747       return -1;
   5748     }
   5749 
   5750 #ifdef WCHAR
   5751   /* Allocate wchar_t array for string1 and string2 and
   5752      fill them with converted string.  */
   5753   if (string1 == NULL && string2 == NULL)
   5754     {
   5755       /* We need seting up buffers here.  */
   5756 
   5757       /* We must free wcs buffers in this function.  */
   5758       cant_free_wcs_buf = 0;
   5759 
   5760       if (csize1 != 0)
   5761 	{
   5762 	  string1 = REGEX_TALLOC (csize1 + 1, CHAR_T);
   5763 	  mbs_offset1 = REGEX_TALLOC (csize1 + 1, int);
   5764 	  is_binary = REGEX_TALLOC (csize1 + 1, char);
   5765 	  if (!string1 || !mbs_offset1 || !is_binary)
   5766 	    {
   5767 	      FREE_VAR (string1);
   5768 	      FREE_VAR (mbs_offset1);
   5769 	      FREE_VAR (is_binary);
   5770 	      return -2;
   5771 	    }
   5772 	}
   5773       if (csize2 != 0)
   5774 	{
   5775 	  string2 = REGEX_TALLOC (csize2 + 1, CHAR_T);
   5776 	  mbs_offset2 = REGEX_TALLOC (csize2 + 1, int);
   5777 	  is_binary = REGEX_TALLOC (csize2 + 1, char);
   5778 	  if (!string2 || !mbs_offset2 || !is_binary)
   5779 	    {
   5780 	      FREE_VAR (string1);
   5781 	      FREE_VAR (mbs_offset1);
   5782 	      FREE_VAR (string2);
   5783 	      FREE_VAR (mbs_offset2);
   5784 	      FREE_VAR (is_binary);
   5785 	      return -2;
   5786 	    }
   5787 	  size2 = convert_mbs_to_wcs(string2, cstring2, csize2,
   5788 				     mbs_offset2, is_binary);
   5789 	  string2[size2] = L'\0'; /* for a sentinel  */
   5790 	  FREE_VAR (is_binary);
   5791 	}
   5792     }
   5793 
   5794   /* We need to cast pattern to (wchar_t*), because we casted this compiled
   5795      pattern to (char*) in regex_compile.  */
   5796   p = pattern = (CHAR_T*)bufp->buffer;
   5797   pend = (CHAR_T*)(bufp->buffer + bufp->used);
   5798 
   5799 #endif /* WCHAR */
   5800 
   5801   /* Initialize subexpression text positions to -1 to mark ones that no
   5802      start_memory/stop_memory has been seen for. Also initialize the
   5803      register information struct.  */
   5804   for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
   5805     {
   5806       regstart[mcnt] = regend[mcnt]
   5807         = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;
   5808 
   5809       REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
   5810       IS_ACTIVE (reg_info[mcnt]) = 0;
   5811       MATCHED_SOMETHING (reg_info[mcnt]) = 0;
   5812       EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;
   5813     }
   5814 
   5815   /* We move `string1' into `string2' if the latter's empty -- but not if
   5816      `string1' is null.  */
   5817   if (size2 == 0 && string1 != NULL)
   5818     {
   5819       string2 = string1;
   5820       size2 = size1;
   5821       string1 = 0;
   5822       size1 = 0;
   5823 #ifdef WCHAR
   5824       mbs_offset2 = mbs_offset1;
   5825       csize2 = csize1;
   5826       mbs_offset1 = NULL;
   5827       csize1 = 0;
   5828 #endif
   5829     }
   5830   end1 = string1 + size1;
   5831   end2 = string2 + size2;
   5832 
   5833   /* Compute where to stop matching, within the two strings.  */
   5834 #ifdef WCHAR
   5835   if (stop <= csize1)
   5836     {
   5837       mcnt = count_mbs_length(mbs_offset1, stop);
   5838       end_match_1 = string1 + mcnt;
   5839       end_match_2 = string2;
   5840     }
   5841   else
   5842     {
   5843       if (stop > csize1 + csize2)
   5844 	stop = csize1 + csize2;
   5845       end_match_1 = end1;
   5846       mcnt = count_mbs_length(mbs_offset2, stop-csize1);
   5847       end_match_2 = string2 + mcnt;
   5848     }
   5849   if (mcnt < 0)
   5850     { /* count_mbs_length return error.  */
   5851       FREE_VARIABLES ();
   5852       return -1;
   5853     }
   5854 #else
   5855   if (stop <= size1)
   5856     {
   5857       end_match_1 = string1 + stop;
   5858       end_match_2 = string2;
   5859     }
   5860   else
   5861     {
   5862       end_match_1 = end1;
   5863       end_match_2 = string2 + stop - size1;
   5864     }
   5865 #endif /* WCHAR */
   5866 
   5867   /* `p' scans through the pattern as `d' scans through the data.
   5868      `dend' is the end of the input string that `d' points within.  `d'
   5869      is advanced into the following input string whenever necessary, but
   5870      this happens before fetching; therefore, at the beginning of the
   5871      loop, `d' can be pointing at the end of a string, but it cannot
   5872      equal `string2'.  */
   5873 #ifdef WCHAR
   5874   if (size1 > 0 && pos <= csize1)
   5875     {
   5876       mcnt = count_mbs_length(mbs_offset1, pos);
   5877       d = string1 + mcnt;
   5878       dend = end_match_1;
   5879     }
   5880   else
   5881     {
   5882       mcnt = count_mbs_length(mbs_offset2, pos-csize1);
   5883       d = string2 + mcnt;
   5884       dend = end_match_2;
   5885     }
   5886 
   5887   if (mcnt < 0)
   5888     { /* count_mbs_length return error.  */
   5889       FREE_VARIABLES ();
   5890       return -1;
   5891     }
   5892 #else
   5893   if (size1 > 0 && pos <= size1)
   5894     {
   5895       d = string1 + pos;
   5896       dend = end_match_1;
   5897     }
   5898   else
   5899     {
   5900       d = string2 + pos - size1;
   5901       dend = end_match_2;
   5902     }
   5903 #endif /* WCHAR */
   5904 
   5905   DEBUG_PRINT1 ("The compiled pattern is:\n");
   5906   DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
   5907   DEBUG_PRINT1 ("The string to match is: `");
   5908   DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
   5909   DEBUG_PRINT1 ("'\n");
   5910 
   5911   /* This loops over pattern commands.  It exits by returning from the
   5912      function if the match is complete, or it drops through if the match
   5913      fails at this starting point in the input data.  */
   5914   for (;;)
   5915     {
   5916 #ifdef _LIBC
   5917       DEBUG_PRINT2 ("\n%p: ", p);
   5918 #else
   5919       DEBUG_PRINT2 ("\n0x%x: ", p);
   5920 #endif
   5921 
   5922       if (p == pend)
   5923 	{ /* End of pattern means we might have succeeded.  */
   5924           DEBUG_PRINT1 ("end of pattern ... ");
   5925 
   5926 	  /* If we haven't matched the entire string, and we want the
   5927              longest match, try backtracking.  */
   5928           if (d != end_match_2)
   5929 	    {
   5930 	      /* 1 if this match ends in the same string (string1 or string2)
   5931 		 as the best previous match.  */
   5932 	      boolean same_str_p;
   5933 
   5934 	      /* 1 if this match is the best seen so far.  */
   5935 	      boolean best_match_p;
   5936 
   5937               same_str_p = (FIRST_STRING_P (match_end)
   5938                             == MATCHING_IN_FIRST_STRING);
   5939 
   5940 	      /* AIX compiler got confused when this was combined
   5941 		 with the previous declaration.  */
   5942 	      if (same_str_p)
   5943 		best_match_p = d > match_end;
   5944 	      else
   5945 		best_match_p = !MATCHING_IN_FIRST_STRING;
   5946 
   5947               DEBUG_PRINT1 ("backtracking.\n");
   5948 
   5949               if (!FAIL_STACK_EMPTY ())
   5950                 { /* More failure points to try.  */
   5951 
   5952                   /* If exceeds best match so far, save it.  */
   5953                   if (!best_regs_set || best_match_p)
   5954                     {
   5955                       best_regs_set = true;
   5956                       match_end = d;
   5957 
   5958                       DEBUG_PRINT1 ("\nSAVING match as best so far.\n");
   5959 
   5960                       for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
   5961                         {
   5962                           best_regstart[mcnt] = regstart[mcnt];
   5963                           best_regend[mcnt] = regend[mcnt];
   5964                         }
   5965                     }
   5966                   goto fail;
   5967                 }
   5968 
   5969               /* If no failure points, don't restore garbage.  And if
   5970                  last match is real best match, don't restore second
   5971                  best one. */
   5972               else if (best_regs_set && !best_match_p)
   5973                 {
   5974   	        restore_best_regs:
   5975                   /* Restore best match.  It may happen that `dend ==
   5976                      end_match_1' while the restored d is in string2.
   5977                      For example, the pattern `x.*y.*z' against the
   5978                      strings `x-' and `y-z-', if the two strings are
   5979                      not consecutive in memory.  */
   5980                   DEBUG_PRINT1 ("Restoring best registers.\n");
   5981 
   5982                   d = match_end;
   5983                   dend = ((d >= string1 && d <= end1)
   5984 		           ? end_match_1 : end_match_2);
   5985 
   5986 		  for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
   5987 		    {
   5988 		      regstart[mcnt] = best_regstart[mcnt];
   5989 		      regend[mcnt] = best_regend[mcnt];
   5990 		    }
   5991                 }
   5992             } /* d != end_match_2 */
   5993 
   5994 	succeed_label:
   5995           DEBUG_PRINT1 ("Accepting match.\n");
   5996           /* If caller wants register contents data back, do it.  */
   5997           if (regs && !bufp->no_sub)
   5998 	    {
   5999 	      /* Have the register data arrays been allocated?  */
   6000               if (bufp->regs_allocated == REGS_UNALLOCATED)
   6001                 { /* No.  So allocate them with malloc.  We need one
   6002                      extra element beyond `num_regs' for the `-1' marker
   6003                      GNU code uses.  */
   6004                   regs->num_regs = MAX (RE_NREGS, num_regs + 1);
   6005                   regs->start = TALLOC (regs->num_regs, regoff_t);
   6006                   regs->end = TALLOC (regs->num_regs, regoff_t);
   6007                   if (regs->start == NULL || regs->end == NULL)
   6008 		    {
   6009 		      FREE_VARIABLES ();
   6010 		      return -2;
   6011 		    }
   6012                   bufp->regs_allocated = REGS_REALLOCATE;
   6013                 }
   6014               else if (bufp->regs_allocated == REGS_REALLOCATE)
   6015                 { /* Yes.  If we need more elements than were already
   6016                      allocated, reallocate them.  If we need fewer, just
   6017                      leave it alone.  */
   6018                   if (regs->num_regs < num_regs + 1)
   6019                     {
   6020                       regs->num_regs = num_regs + 1;
   6021                       RETALLOC (regs->start, regs->num_regs, regoff_t);
   6022                       RETALLOC (regs->end, regs->num_regs, regoff_t);
   6023                       if (regs->start == NULL || regs->end == NULL)
   6024 			{
   6025 			  FREE_VARIABLES ();
   6026 			  return -2;
   6027 			}
   6028                     }
   6029                 }
   6030               else
   6031 		{
   6032 		  /* These braces fend off a "empty body in an else-statement"
   6033 		     warning under GCC when assert expands to nothing.  */
   6034 		  assert (bufp->regs_allocated == REGS_FIXED);
   6035 		}
   6036 
   6037               /* Convert the pointer data in `regstart' and `regend' to
   6038                  indices.  Register zero has to be set differently,
   6039                  since we haven't kept track of any info for it.  */
   6040               if (regs->num_regs > 0)
   6041                 {
   6042                   regs->start[0] = pos;
   6043 #ifdef WCHAR
   6044 		  if (MATCHING_IN_FIRST_STRING)
   6045 		    regs->end[0] = mbs_offset1 != NULL ?
   6046 					mbs_offset1[d-string1] : 0;
   6047 		  else
   6048 		    regs->end[0] = csize1 + (mbs_offset2 != NULL ?
   6049 					     mbs_offset2[d-string2] : 0);
   6050 #else
   6051                   regs->end[0] = (MATCHING_IN_FIRST_STRING
   6052 				  ? ((regoff_t) (d - string1))
   6053 			          : ((regoff_t) (d - string2 + size1)));
   6054 #endif /* WCHAR */
   6055                 }
   6056 
   6057               /* Go through the first `min (num_regs, regs->num_regs)'
   6058                  registers, since that is all we initialized.  */
   6059 	      for (mcnt = 1; (unsigned) mcnt < MIN (num_regs, regs->num_regs);
   6060 		   mcnt++)
   6061 		{
   6062                   if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt]))
   6063                     regs->start[mcnt] = regs->end[mcnt] = -1;
   6064                   else
   6065                     {
   6066 		      regs->start[mcnt]
   6067 			= (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]);
   6068                       regs->end[mcnt]
   6069 			= (regoff_t) POINTER_TO_OFFSET (regend[mcnt]);
   6070                     }
   6071 		}
   6072 
   6073               /* If the regs structure we return has more elements than
   6074                  were in the pattern, set the extra elements to -1.  If
   6075                  we (re)allocated the registers, this is the case,
   6076                  because we always allocate enough to have at least one
   6077                  -1 at the end.  */
   6078               for (mcnt = num_regs; (unsigned) mcnt < regs->num_regs; mcnt++)
   6079                 regs->start[mcnt] = regs->end[mcnt] = -1;
   6080 	    } /* regs && !bufp->no_sub */
   6081 
   6082           DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",
   6083                         nfailure_points_pushed, nfailure_points_popped,
   6084                         nfailure_points_pushed - nfailure_points_popped);
   6085           DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);
   6086 
   6087 #ifdef WCHAR
   6088 	  if (MATCHING_IN_FIRST_STRING)
   6089 	    mcnt = mbs_offset1 != NULL ? mbs_offset1[d-string1] : 0;
   6090 	  else
   6091 	    mcnt = (mbs_offset2 != NULL ? mbs_offset2[d-string2] : 0) +
   6092 			csize1;
   6093           mcnt -= pos;
   6094 #else
   6095           mcnt = d - pos - (MATCHING_IN_FIRST_STRING
   6096 			    ? string1
   6097 			    : string2 - size1);
   6098 #endif /* WCHAR */
   6099 
   6100           DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);
   6101 
   6102           FREE_VARIABLES ();
   6103           return mcnt;
   6104         }
   6105 
   6106       /* Otherwise match next pattern command.  */
   6107       switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
   6108 	{
   6109         /* Ignore these.  Used to ignore the n of succeed_n's which
   6110            currently have n == 0.  */
   6111         case no_op:
   6112           DEBUG_PRINT1 ("EXECUTING no_op.\n");
   6113           break;
   6114 
   6115 	case succeed:
   6116           DEBUG_PRINT1 ("EXECUTING succeed.\n");
   6117 	  goto succeed_label;
   6118 
   6119         /* Match the next n pattern characters exactly.  The following
   6120            byte in the pattern defines n, and the n bytes after that
   6121            are the characters to match.  */
   6122 	case exactn:
   6123 #ifdef MBS_SUPPORT
   6124 	case exactn_bin:
   6125 #endif
   6126 	  mcnt = *p++;
   6127           DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);
   6128 
   6129           /* This is written out as an if-else so we don't waste time
   6130              testing `translate' inside the loop.  */
   6131           if (translate)
   6132 	    {
   6133 	      do
   6134 		{
   6135 		  PREFETCH ();
   6136 #ifdef WCHAR
   6137 		  if (*d <= 0xff)
   6138 		    {
   6139 		      if ((UCHAR_T) translate[(unsigned char) *d++]
   6140 			  != (UCHAR_T) *p++)
   6141 			goto fail;
   6142 		    }
   6143 		  else
   6144 		    {
   6145 		      if (*d++ != (CHAR_T) *p++)
   6146 			goto fail;
   6147 		    }
   6148 #else
   6149 		  if ((UCHAR_T) translate[(unsigned char) *d++]
   6150 		      != (UCHAR_T) *p++)
   6151                     goto fail;
   6152 #endif /* WCHAR */
   6153 		}
   6154 	      while (--mcnt);
   6155 	    }
   6156 	  else
   6157 	    {
   6158 	      do
   6159 		{
   6160 		  PREFETCH ();
   6161 		  if (*d++ != (CHAR_T) *p++) goto fail;
   6162 		}
   6163 	      while (--mcnt);
   6164 	    }
   6165 	  SET_REGS_MATCHED ();
   6166           break;
   6167 
   6168 
   6169         /* Match any character except possibly a newline or a null.  */
   6170 	case anychar:
   6171           DEBUG_PRINT1 ("EXECUTING anychar.\n");
   6172 
   6173           PREFETCH ();
   6174 
   6175           if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n')
   6176               || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000'))
   6177 	    goto fail;
   6178 
   6179           SET_REGS_MATCHED ();
   6180           DEBUG_PRINT2 ("  Matched `%ld'.\n", (long int) *d);
   6181           d++;
   6182 	  break;
   6183 
   6184 
   6185 	case charset:
   6186 	case charset_not:
   6187 	  {
   6188 	    register UCHAR_T c;
   6189 #ifdef WCHAR
   6190 	    unsigned int i, char_class_length, coll_symbol_length,
   6191               equiv_class_length, ranges_length, chars_length, length;
   6192 	    CHAR_T *workp, *workp2, *charset_top;
   6193 #define WORK_BUFFER_SIZE 128
   6194             CHAR_T str_buf[WORK_BUFFER_SIZE];
   6195 # ifdef _LIBC
   6196 	    uint32_t nrules;
   6197 # endif /* _LIBC */
   6198 #endif /* WCHAR */
   6199 	    boolean negate = (re_opcode_t) *(p - 1) == charset_not;
   6200 
   6201             DEBUG_PRINT2 ("EXECUTING charset%s.\n", negate ? "_not" : "");
   6202 	    PREFETCH ();
   6203 	    c = TRANSLATE (*d); /* The character to match.  */
   6204 #ifdef WCHAR
   6205 # ifdef _LIBC
   6206 	    nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
   6207 # endif /* _LIBC */
   6208 	    charset_top = p - 1;
   6209 	    char_class_length = *p++;
   6210 	    coll_symbol_length = *p++;
   6211 	    equiv_class_length = *p++;
   6212 	    ranges_length = *p++;
   6213 	    chars_length = *p++;
   6214 	    /* p points charset[6], so the address of the next instruction
   6215 	       (charset[l+m+n+2o+k+p']) equals p[l+m+n+2*o+p'],
   6216 	       where l=length of char_classes, m=length of collating_symbol,
   6217 	       n=equivalence_class, o=length of char_range,
   6218 	       p'=length of character.  */
   6219 	    workp = p;
   6220 	    /* Update p to indicate the next instruction.  */
   6221 	    p += char_class_length + coll_symbol_length+ equiv_class_length +
   6222               2*ranges_length + chars_length;
   6223 
   6224             /* match with char_class?  */
   6225 	    for (i = 0; i < char_class_length ; i += CHAR_CLASS_SIZE)
   6226 	      {
   6227 		wctype_t wctype;
   6228 		uintptr_t alignedp = ((uintptr_t)workp
   6229 				      + __alignof__(wctype_t) - 1)
   6230 		  		      & ~(uintptr_t)(__alignof__(wctype_t) - 1);
   6231 		wctype = *((wctype_t*)alignedp);
   6232 		workp += CHAR_CLASS_SIZE;
   6233 # ifdef _LIBC
   6234 		if (__iswctype((wint_t)c, wctype))
   6235 		  goto char_set_matched;
   6236 # else
   6237 		if (iswctype((wint_t)c, wctype))
   6238 		  goto char_set_matched;
   6239 # endif
   6240 	      }
   6241 
   6242             /* match with collating_symbol?  */
   6243 # ifdef _LIBC
   6244 	    if (nrules != 0)
   6245 	      {
   6246 		const unsigned char *extra = (const unsigned char *)
   6247 		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
   6248 
   6249 		for (workp2 = workp + coll_symbol_length ; workp < workp2 ;
   6250 		     workp++)
   6251 		  {
   6252 		    int32_t *wextra;
   6253 		    wextra = (int32_t*)(extra + *workp++);
   6254 		    for (i = 0; i < *wextra; ++i)
   6255 		      if (TRANSLATE(d[i]) != wextra[1 + i])
   6256 			break;
   6257 
   6258 		    if (i == *wextra)
   6259 		      {
   6260 			/* Update d, however d will be incremented at
   6261 			   char_set_matched:, we decrement d here.  */
   6262 			d += i - 1;
   6263 			goto char_set_matched;
   6264 		      }
   6265 		  }
   6266 	      }
   6267 	    else /* (nrules == 0) */
   6268 # endif
   6269 	      /* If we can't look up collation data, we use wcscoll
   6270 		 instead.  */
   6271 	      {
   6272 		for (workp2 = workp + coll_symbol_length ; workp < workp2 ;)
   6273 		  {
   6274 		    const CHAR_T *backup_d = d, *backup_dend = dend;
   6275 # ifdef _LIBC
   6276 		    length = __wcslen (workp);
   6277 # else
   6278 		    length = wcslen (workp);
   6279 # endif
   6280 
   6281 		    /* If wcscoll(the collating symbol, whole string) > 0,
   6282 		       any substring of the string never match with the
   6283 		       collating symbol.  */
   6284 # ifdef _LIBC
   6285 		    if (__wcscoll (workp, d) > 0)
   6286 # else
   6287 		    if (wcscoll (workp, d) > 0)
   6288 # endif
   6289 		      {
   6290 			workp += length + 1;
   6291 			continue;
   6292 		      }
   6293 
   6294 		    /* First, we compare the collating symbol with
   6295 		       the first character of the string.
   6296 		       If it don't match, we add the next character to
   6297 		       the compare buffer in turn.  */
   6298 		    for (i = 0 ; i < WORK_BUFFER_SIZE-1 ; i++, d++)
   6299 		      {
   6300 			int match;
   6301 			if (d == dend)
   6302 			  {
   6303 			    if (dend == end_match_2)
   6304 			      break;
   6305 			    d = string2;
   6306 			    dend = end_match_2;
   6307 			  }
   6308 
   6309 			/* add next character to the compare buffer.  */
   6310 			str_buf[i] = TRANSLATE(*d);
   6311 			str_buf[i+1] = '\0';
   6312 
   6313 # ifdef _LIBC
   6314 			match = __wcscoll (workp, str_buf);
   6315 # else
   6316 			match = wcscoll (workp, str_buf);
   6317 # endif
   6318 			if (match == 0)
   6319 			  goto char_set_matched;
   6320 
   6321 			if (match < 0)
   6322 			  /* (str_buf > workp) indicate (str_buf + X > workp),
   6323 			     because for all X (str_buf + X > str_buf).
   6324 			     So we don't need continue this loop.  */
   6325 			  break;
   6326 
   6327 			/* Otherwise(str_buf < workp),
   6328 			   (str_buf+next_character) may equals (workp).
   6329 			   So we continue this loop.  */
   6330 		      }
   6331 		    /* not matched */
   6332 		    d = backup_d;
   6333 		    dend = backup_dend;
   6334 		    workp += length + 1;
   6335 		  }
   6336               }
   6337             /* match with equivalence_class?  */
   6338 # ifdef _LIBC
   6339 	    if (nrules != 0)
   6340 	      {
   6341                 const CHAR_T *backup_d = d, *backup_dend = dend;
   6342 		/* Try to match the equivalence class against
   6343 		   those known to the collate implementation.  */
   6344 		const int32_t *table;
   6345 		const int32_t *weights;
   6346 		const int32_t *extra;
   6347 		const int32_t *indirect;
   6348 		int32_t idx, idx2;
   6349 		wint_t *cp;
   6350 		size_t len;
   6351 
   6352 		/* This #include defines a local function!  */
   6353 #  include <locale/weightwc.h>
   6354 
   6355 		table = (const int32_t *)
   6356 		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
   6357 		weights = (const wint_t *)
   6358 		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
   6359 		extra = (const wint_t *)
   6360 		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
   6361 		indirect = (const int32_t *)
   6362 		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
   6363 
   6364 		/* Write 1 collating element to str_buf, and
   6365 		   get its index.  */
   6366 		idx2 = 0;
   6367 
   6368 		for (i = 0 ; idx2 == 0 && i < WORK_BUFFER_SIZE - 1; i++)
   6369 		  {
   6370 		    cp = (wint_t*)str_buf;
   6371 		    if (d == dend)
   6372 		      {
   6373 			if (dend == end_match_2)
   6374 			  break;
   6375 			d = string2;
   6376 			dend = end_match_2;
   6377 		      }
   6378 		    str_buf[i] = TRANSLATE(*(d+i));
   6379 		    str_buf[i+1] = '\0'; /* sentinel */
   6380 		    idx2 = findidx ((const wint_t**)&cp);
   6381 		  }
   6382 
   6383 		/* Update d, however d will be incremented at
   6384 		   char_set_matched:, we decrement d here.  */
   6385 		d = backup_d + ((wchar_t*)cp - (wchar_t*)str_buf - 1);
   6386 		if (d >= dend)
   6387 		  {
   6388 		    if (dend == end_match_2)
   6389 			d = dend;
   6390 		    else
   6391 		      {
   6392 			d = string2;
   6393 			dend = end_match_2;
   6394 		      }
   6395 		  }
   6396 
   6397 		len = weights[idx2];
   6398 
   6399 		for (workp2 = workp + equiv_class_length ; workp < workp2 ;
   6400 		     workp++)
   6401 		  {
   6402 		    idx = (int32_t)*workp;
   6403 		    /* We already checked idx != 0 in regex_compile. */
   6404 
   6405 		    if (idx2 != 0 && len == weights[idx])
   6406 		      {
   6407 			int cnt = 0;
   6408 			while (cnt < len && (weights[idx + 1 + cnt]
   6409 					     == weights[idx2 + 1 + cnt]))
   6410 			  ++cnt;
   6411 
   6412 			if (cnt == len)
   6413 			  goto char_set_matched;
   6414 		      }
   6415 		  }
   6416 		/* not matched */
   6417                 d = backup_d;
   6418                 dend = backup_dend;
   6419 	      }
   6420 	    else /* (nrules == 0) */
   6421 # endif
   6422 	      /* If we can't look up collation data, we use wcscoll
   6423 		 instead.  */
   6424 	      {
   6425 		for (workp2 = workp + equiv_class_length ; workp < workp2 ;)
   6426 		  {
   6427 		    const CHAR_T *backup_d = d, *backup_dend = dend;
   6428 # ifdef _LIBC
   6429 		    length = __wcslen (workp);
   6430 # else
   6431 		    length = wcslen (workp);
   6432 # endif
   6433 
   6434 		    /* If wcscoll(the collating symbol, whole string) > 0,
   6435 		       any substring of the string never match with the
   6436 		       collating symbol.  */
   6437 # ifdef _LIBC
   6438 		    if (__wcscoll (workp, d) > 0)
   6439 # else
   6440 		    if (wcscoll (workp, d) > 0)
   6441 # endif
   6442 		      {
   6443 			workp += length + 1;
   6444 			break;
   6445 		      }
   6446 
   6447 		    /* First, we compare the equivalence class with
   6448 		       the first character of the string.
   6449 		       If it don't match, we add the next character to
   6450 		       the compare buffer in turn.  */
   6451 		    for (i = 0 ; i < WORK_BUFFER_SIZE - 1 ; i++, d++)
   6452 		      {
   6453 			int match;
   6454 			if (d == dend)
   6455 			  {
   6456 			    if (dend == end_match_2)
   6457 			      break;
   6458 			    d = string2;
   6459 			    dend = end_match_2;
   6460 			  }
   6461 
   6462 			/* add next character to the compare buffer.  */
   6463 			str_buf[i] = TRANSLATE(*d);
   6464 			str_buf[i+1] = '\0';
   6465 
   6466 # ifdef _LIBC
   6467 			match = __wcscoll (workp, str_buf);
   6468 # else
   6469 			match = wcscoll (workp, str_buf);
   6470 # endif
   6471 
   6472 			if (match == 0)
   6473 			  goto char_set_matched;
   6474 
   6475 			if (match < 0)
   6476 			/* (str_buf > workp) indicate (str_buf + X > workp),
   6477 			   because for all X (str_buf + X > str_buf).
   6478 			   So we don't need continue this loop.  */
   6479 			  break;
   6480 
   6481 			/* Otherwise(str_buf < workp),
   6482 			   (str_buf+next_character) may equals (workp).
   6483 			   So we continue this loop.  */
   6484 		      }
   6485 		    /* not matched */
   6486 		    d = backup_d;
   6487 		    dend = backup_dend;
   6488 		    workp += length + 1;
   6489 		  }
   6490 	      }
   6491 
   6492             /* match with char_range?  */
   6493 # ifdef _LIBC
   6494 	    if (nrules != 0)
   6495 	      {
   6496 		uint32_t collseqval;
   6497 		const char *collseq = (const char *)
   6498 		  _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
   6499 
   6500 		collseqval = collseq_table_lookup (collseq, c);
   6501 
   6502 		for (; workp < p - chars_length ;)
   6503 		  {
   6504 		    uint32_t start_val, end_val;
   6505 
   6506 		    /* We already compute the collation sequence value
   6507 		       of the characters (or collating symbols).  */
   6508 		    start_val = (uint32_t) *workp++; /* range_start */
   6509 		    end_val = (uint32_t) *workp++; /* range_end */
   6510 
   6511 		    if (start_val <= collseqval && collseqval <= end_val)
   6512 		      goto char_set_matched;
   6513 		  }
   6514 	      }
   6515 	    else
   6516 # endif
   6517 	      {
   6518 		/* We set range_start_char at str_buf[0], range_end_char
   6519 		   at str_buf[4], and compared char at str_buf[2].  */
   6520 		str_buf[1] = 0;
   6521 		str_buf[2] = c;
   6522 		str_buf[3] = 0;
   6523 		str_buf[5] = 0;
   6524 		for (; workp < p - chars_length ;)
   6525 		  {
   6526 		    wchar_t *range_start_char, *range_end_char;
   6527 
   6528 		    /* match if (range_start_char <= c <= range_end_char).  */
   6529 
   6530 		    /* If range_start(or end) < 0, we assume -range_start(end)
   6531 		       is the offset of the collating symbol which is specified
   6532 		       as the character of the range start(end).  */
   6533 
   6534 		    /* range_start */
   6535 		    if (*workp < 0)
   6536 		      range_start_char = charset_top - (*workp++);
   6537 		    else
   6538 		      {
   6539 			str_buf[0] = *workp++;
   6540 			range_start_char = str_buf;
   6541 		      }
   6542 
   6543 		    /* range_end */
   6544 		    if (*workp < 0)
   6545 		      range_end_char = charset_top - (*workp++);
   6546 		    else
   6547 		      {
   6548 			str_buf[4] = *workp++;
   6549 			range_end_char = str_buf + 4;
   6550 		      }
   6551 
   6552 # ifdef _LIBC
   6553 		    if (__wcscoll (range_start_char, str_buf+2) <= 0
   6554 			&& __wcscoll (str_buf+2, range_end_char) <= 0)
   6555 # else
   6556 		    if (wcscoll (range_start_char, str_buf+2) <= 0
   6557 			&& wcscoll (str_buf+2, range_end_char) <= 0)
   6558 # endif
   6559 		      goto char_set_matched;
   6560 		  }
   6561 	      }
   6562 
   6563             /* match with char?  */
   6564 	    for (; workp < p ; workp++)
   6565 	      if (c == *workp)
   6566 		goto char_set_matched;
   6567 
   6568 	    negate = !negate;
   6569 
   6570 	  char_set_matched:
   6571 	    if (negate) goto fail;
   6572 #else
   6573             /* Cast to `unsigned' instead of `unsigned char' in case the
   6574                bit list is a full 32 bytes long.  */
   6575 	    if (c < (unsigned) (*p * BYTEWIDTH)
   6576 		&& p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
   6577 	      negate = !negate;
   6578 
   6579 	    p += 1 + *p;
   6580 
   6581 	    if (!negate) goto fail;
   6582 #undef WORK_BUFFER_SIZE
   6583 #endif /* WCHAR */
   6584 	    SET_REGS_MATCHED ();
   6585             d++;
   6586 	    break;
   6587 	  }
   6588 
   6589 
   6590         /* The beginning of a group is represented by start_memory.
   6591            The arguments are the register number in the next byte, and the
   6592            number of groups inner to this one in the next.  The text
   6593            matched within the group is recorded (in the internal
   6594            registers data structure) under the register number.  */
   6595         case start_memory:
   6596 	  DEBUG_PRINT3 ("EXECUTING start_memory %ld (%ld):\n",
   6597 			(long int) *p, (long int) p[1]);
   6598 
   6599           /* Find out if this group can match the empty string.  */
   6600 	  p1 = p;		/* To send to group_match_null_string_p.  */
   6601 
   6602           if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)
   6603             REG_MATCH_NULL_STRING_P (reg_info[*p])
   6604               = PREFIX(group_match_null_string_p) (&p1, pend, reg_info);
   6605 
   6606           /* Save the position in the string where we were the last time
   6607              we were at this open-group operator in case the group is
   6608              operated upon by a repetition operator, e.g., with `(a*)*b'
   6609              against `ab'; then we want to ignore where we are now in
   6610              the string in case this attempt to match fails.  */
   6611           old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
   6612                              ? REG_UNSET (regstart[*p]) ? d : regstart[*p]
   6613                              : regstart[*p];
   6614 	  DEBUG_PRINT2 ("  old_regstart: %d\n",
   6615 			 POINTER_TO_OFFSET (old_regstart[*p]));
   6616 
   6617           regstart[*p] = d;
   6618 	  DEBUG_PRINT2 ("  regstart: %d\n", POINTER_TO_OFFSET (regstart[*p]));
   6619 
   6620           IS_ACTIVE (reg_info[*p]) = 1;
   6621           MATCHED_SOMETHING (reg_info[*p]) = 0;
   6622 
   6623 	  /* Clear this whenever we change the register activity status.  */
   6624 	  set_regs_matched_done = 0;
   6625 
   6626           /* This is the new highest active register.  */
   6627           highest_active_reg = *p;
   6628 
   6629           /* If nothing was active before, this is the new lowest active
   6630              register.  */
   6631           if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
   6632             lowest_active_reg = *p;
   6633 
   6634           /* Move past the register number and inner group count.  */
   6635           p += 2;
   6636 	  just_past_start_mem = p;
   6637 
   6638           break;
   6639 
   6640 
   6641         /* The stop_memory opcode represents the end of a group.  Its
   6642            arguments are the same as start_memory's: the register
   6643            number, and the number of inner groups.  */
   6644 	case stop_memory:
   6645 	  DEBUG_PRINT3 ("EXECUTING stop_memory %ld (%ld):\n",
   6646 			(long int) *p, (long int) p[1]);
   6647 
   6648           /* We need to save the string position the last time we were at
   6649              this close-group operator in case the group is operated
   6650              upon by a repetition operator, e.g., with `((a*)*(b*)*)*'
   6651              against `aba'; then we want to ignore where we are now in
   6652              the string in case this attempt to match fails.  */
   6653           old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
   6654                            ? REG_UNSET (regend[*p]) ? d : regend[*p]
   6655 			   : regend[*p];
   6656 	  DEBUG_PRINT2 ("      old_regend: %d\n",
   6657 			 POINTER_TO_OFFSET (old_regend[*p]));
   6658 
   6659           regend[*p] = d;
   6660 	  DEBUG_PRINT2 ("      regend: %d\n", POINTER_TO_OFFSET (regend[*p]));
   6661 
   6662           /* This register isn't active anymore.  */
   6663           IS_ACTIVE (reg_info[*p]) = 0;
   6664 
   6665 	  /* Clear this whenever we change the register activity status.  */
   6666 	  set_regs_matched_done = 0;
   6667 
   6668           /* If this was the only register active, nothing is active
   6669              anymore.  */
   6670           if (lowest_active_reg == highest_active_reg)
   6671             {
   6672               lowest_active_reg = NO_LOWEST_ACTIVE_REG;
   6673               highest_active_reg = NO_HIGHEST_ACTIVE_REG;
   6674             }
   6675           else
   6676             { /* We must scan for the new highest active register, since
   6677                  it isn't necessarily one less than now: consider
   6678                  (a(b)c(d(e)f)g).  When group 3 ends, after the f), the
   6679                  new highest active register is 1.  */
   6680               UCHAR_T r = *p - 1;
   6681               while (r > 0 && !IS_ACTIVE (reg_info[r]))
   6682                 r--;
   6683 
   6684               /* If we end up at register zero, that means that we saved
   6685                  the registers as the result of an `on_failure_jump', not
   6686                  a `start_memory', and we jumped to past the innermost
   6687                  `stop_memory'.  For example, in ((.)*) we save
   6688                  registers 1 and 2 as a result of the *, but when we pop
   6689                  back to the second ), we are at the stop_memory 1.
   6690                  Thus, nothing is active.  */
   6691 	      if (r == 0)
   6692                 {
   6693                   lowest_active_reg = NO_LOWEST_ACTIVE_REG;
   6694                   highest_active_reg = NO_HIGHEST_ACTIVE_REG;
   6695                 }
   6696               else
   6697                 highest_active_reg = r;
   6698             }
   6699 
   6700           /* If just failed to match something this time around with a
   6701              group that's operated on by a repetition operator, try to
   6702              force exit from the ``loop'', and restore the register
   6703              information for this group that we had before trying this
   6704              last match.  */
   6705           if ((!MATCHED_SOMETHING (reg_info[*p])
   6706                || just_past_start_mem == p - 1)
   6707 	      && (p + 2) < pend)
   6708             {
   6709               boolean is_a_jump_n = false;
   6710 
   6711               p1 = p + 2;
   6712               mcnt = 0;
   6713               switch ((re_opcode_t) *p1++)
   6714                 {
   6715                   case jump_n:
   6716 		    is_a_jump_n = true;
   6717                   case pop_failure_jump:
   6718 		  case maybe_pop_jump:
   6719 		  case jump:
   6720 		  case dummy_failure_jump:
   6721                     EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   6722 		    if (is_a_jump_n)
   6723 		      p1 += OFFSET_ADDRESS_SIZE;
   6724                     break;
   6725 
   6726                   default:
   6727                     /* do nothing */ ;
   6728                 }
   6729 	      p1 += mcnt;
   6730 
   6731               /* If the next operation is a jump backwards in the pattern
   6732 	         to an on_failure_jump right before the start_memory
   6733                  corresponding to this stop_memory, exit from the loop
   6734                  by forcing a failure after pushing on the stack the
   6735                  on_failure_jump's jump in the pattern, and d.  */
   6736               if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump
   6737                   && (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == start_memory
   6738 		  && p1[2+OFFSET_ADDRESS_SIZE] == *p)
   6739 		{
   6740                   /* If this group ever matched anything, then restore
   6741                      what its registers were before trying this last
   6742                      failed match, e.g., with `(a*)*b' against `ab' for
   6743                      regstart[1], and, e.g., with `((a*)*(b*)*)*'
   6744                      against `aba' for regend[3].
   6745 
   6746                      Also restore the registers for inner groups for,
   6747                      e.g., `((a*)(b*))*' against `aba' (register 3 would
   6748                      otherwise get trashed).  */
   6749 
   6750                   if (EVER_MATCHED_SOMETHING (reg_info[*p]))
   6751 		    {
   6752 		      unsigned r;
   6753 
   6754                       EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;
   6755 
   6756 		      /* Restore this and inner groups' (if any) registers.  */
   6757                       for (r = *p; r < (unsigned) *p + (unsigned) *(p + 1);
   6758 			   r++)
   6759                         {
   6760                           regstart[r] = old_regstart[r];
   6761 
   6762                           /* xx why this test?  */
   6763                           if (old_regend[r] >= regstart[r])
   6764                             regend[r] = old_regend[r];
   6765                         }
   6766                     }
   6767 		  p1++;
   6768                   EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   6769                   PUSH_FAILURE_POINT (p1 + mcnt, d, -2);
   6770 
   6771                   goto fail;
   6772                 }
   6773             }
   6774 
   6775           /* Move past the register number and the inner group count.  */
   6776           p += 2;
   6777           break;
   6778 
   6779 
   6780 	/* \<digit> has been turned into a `duplicate' command which is
   6781            followed by the numeric value of <digit> as the register number.  */
   6782         case duplicate:
   6783 	  {
   6784 	    register const CHAR_T *d2, *dend2;
   6785 	    int regno = *p++;   /* Get which register to match against.  */
   6786 	    DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);
   6787 
   6788 	    /* Can't back reference a group which we've never matched.  */
   6789             if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
   6790               goto fail;
   6791 
   6792             /* Where in input to try to start matching.  */
   6793             d2 = regstart[regno];
   6794 
   6795             /* Where to stop matching; if both the place to start and
   6796                the place to stop matching are in the same string, then
   6797                set to the place to stop, otherwise, for now have to use
   6798                the end of the first string.  */
   6799 
   6800             dend2 = ((FIRST_STRING_P (regstart[regno])
   6801 		      == FIRST_STRING_P (regend[regno]))
   6802 		     ? regend[regno] : end_match_1);
   6803 	    for (;;)
   6804 	      {
   6805 		/* If necessary, advance to next segment in register
   6806                    contents.  */
   6807 		while (d2 == dend2)
   6808 		  {
   6809 		    if (dend2 == end_match_2) break;
   6810 		    if (dend2 == regend[regno]) break;
   6811 
   6812                     /* End of string1 => advance to string2. */
   6813                     d2 = string2;
   6814                     dend2 = regend[regno];
   6815 		  }
   6816 		/* At end of register contents => success */
   6817 		if (d2 == dend2) break;
   6818 
   6819 		/* If necessary, advance to next segment in data.  */
   6820 		PREFETCH ();
   6821 
   6822 		/* How many characters left in this segment to match.  */
   6823 		mcnt = dend - d;
   6824 
   6825 		/* Want how many consecutive characters we can match in
   6826                    one shot, so, if necessary, adjust the count.  */
   6827                 if (mcnt > dend2 - d2)
   6828 		  mcnt = dend2 - d2;
   6829 
   6830 		/* Compare that many; failure if mismatch, else move
   6831                    past them.  */
   6832 		if (translate
   6833                     ? PREFIX(bcmp_translate) (d, d2, mcnt, translate)
   6834                     : memcmp (d, d2, mcnt*sizeof(UCHAR_T)))
   6835 		  goto fail;
   6836 		d += mcnt, d2 += mcnt;
   6837 
   6838 		/* Do this because we've match some characters.  */
   6839 		SET_REGS_MATCHED ();
   6840 	      }
   6841 	  }
   6842 	  break;
   6843 
   6844 
   6845         /* begline matches the empty string at the beginning of the string
   6846            (unless `not_bol' is set in `bufp'), and, if
   6847            `newline_anchor' is set, after newlines.  */
   6848 	case begline:
   6849           DEBUG_PRINT1 ("EXECUTING begline.\n");
   6850 
   6851           if (AT_STRINGS_BEG (d))
   6852             {
   6853               if (!bufp->not_bol) break;
   6854             }
   6855           else if (d[-1] == '\n' && bufp->newline_anchor)
   6856             {
   6857               break;
   6858             }
   6859           /* In all other cases, we fail.  */
   6860           goto fail;
   6861 
   6862 
   6863         /* endline is the dual of begline.  */
   6864 	case endline:
   6865           DEBUG_PRINT1 ("EXECUTING endline.\n");
   6866 
   6867           if (AT_STRINGS_END (d))
   6868             {
   6869               if (!bufp->not_eol) break;
   6870             }
   6871 
   6872           /* We have to ``prefetch'' the next character.  */
   6873           else if ((d == end1 ? *string2 : *d) == '\n'
   6874                    && bufp->newline_anchor)
   6875             {
   6876               break;
   6877             }
   6878           goto fail;
   6879 
   6880 
   6881 	/* Match at the very beginning of the data.  */
   6882         case begbuf:
   6883           DEBUG_PRINT1 ("EXECUTING begbuf.\n");
   6884           if (AT_STRINGS_BEG (d))
   6885             break;
   6886           goto fail;
   6887 
   6888 
   6889 	/* Match at the very end of the data.  */
   6890         case endbuf:
   6891           DEBUG_PRINT1 ("EXECUTING endbuf.\n");
   6892 	  if (AT_STRINGS_END (d))
   6893 	    break;
   6894           goto fail;
   6895 
   6896 
   6897         /* on_failure_keep_string_jump is used to optimize `.*\n'.  It
   6898            pushes NULL as the value for the string on the stack.  Then
   6899            `pop_failure_point' will keep the current value for the
   6900            string, instead of restoring it.  To see why, consider
   6901            matching `foo\nbar' against `.*\n'.  The .* matches the foo;
   6902            then the . fails against the \n.  But the next thing we want
   6903            to do is match the \n against the \n; if we restored the
   6904            string value, we would be back at the foo.
   6905 
   6906            Because this is used only in specific cases, we don't need to
   6907            check all the things that `on_failure_jump' does, to make
   6908            sure the right things get saved on the stack.  Hence we don't
   6909            share its code.  The only reason to push anything on the
   6910            stack at all is that otherwise we would have to change
   6911            `anychar's code to do something besides goto fail in this
   6912            case; that seems worse than this.  */
   6913         case on_failure_keep_string_jump:
   6914           DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");
   6915 
   6916           EXTRACT_NUMBER_AND_INCR (mcnt, p);
   6917 #ifdef _LIBC
   6918           DEBUG_PRINT3 (" %d (to %p):\n", mcnt, p + mcnt);
   6919 #else
   6920           DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);
   6921 #endif
   6922 
   6923           PUSH_FAILURE_POINT (p + mcnt, NULL, -2);
   6924           break;
   6925 
   6926 
   6927 	/* Uses of on_failure_jump:
   6928 
   6929            Each alternative starts with an on_failure_jump that points
   6930            to the beginning of the next alternative.  Each alternative
   6931            except the last ends with a jump that in effect jumps past
   6932            the rest of the alternatives.  (They really jump to the
   6933            ending jump of the following alternative, because tensioning
   6934            these jumps is a hassle.)
   6935 
   6936            Repeats start with an on_failure_jump that points past both
   6937            the repetition text and either the following jump or
   6938            pop_failure_jump back to this on_failure_jump.  */
   6939 	case on_failure_jump:
   6940         on_failure:
   6941           DEBUG_PRINT1 ("EXECUTING on_failure_jump");
   6942 
   6943           EXTRACT_NUMBER_AND_INCR (mcnt, p);
   6944 #ifdef _LIBC
   6945           DEBUG_PRINT3 (" %d (to %p)", mcnt, p + mcnt);
   6946 #else
   6947           DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt);
   6948 #endif
   6949 
   6950           /* If this on_failure_jump comes right before a group (i.e.,
   6951              the original * applied to a group), save the information
   6952              for that group and all inner ones, so that if we fail back
   6953              to this point, the group's information will be correct.
   6954              For example, in \(a*\)*\1, we need the preceding group,
   6955              and in \(zz\(a*\)b*\)\2, we need the inner group.  */
   6956 
   6957           /* We can't use `p' to check ahead because we push
   6958              a failure point to `p + mcnt' after we do this.  */
   6959           p1 = p;
   6960 
   6961           /* We need to skip no_op's before we look for the
   6962              start_memory in case this on_failure_jump is happening as
   6963              the result of a completed succeed_n, as in \(a\)\{1,3\}b\1
   6964              against aba.  */
   6965           while (p1 < pend && (re_opcode_t) *p1 == no_op)
   6966             p1++;
   6967 
   6968           if (p1 < pend && (re_opcode_t) *p1 == start_memory)
   6969             {
   6970               /* We have a new highest active register now.  This will
   6971                  get reset at the start_memory we are about to get to,
   6972                  but we will have saved all the registers relevant to
   6973                  this repetition op, as described above.  */
   6974               highest_active_reg = *(p1 + 1) + *(p1 + 2);
   6975               if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
   6976                 lowest_active_reg = *(p1 + 1);
   6977             }
   6978 
   6979           DEBUG_PRINT1 (":\n");
   6980           PUSH_FAILURE_POINT (p + mcnt, d, -2);
   6981           break;
   6982 
   6983 
   6984         /* A smart repeat ends with `maybe_pop_jump'.
   6985 	   We change it to either `pop_failure_jump' or `jump'.  */
   6986         case maybe_pop_jump:
   6987           EXTRACT_NUMBER_AND_INCR (mcnt, p);
   6988           DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt);
   6989           {
   6990 	    register UCHAR_T *p2 = p;
   6991 
   6992             /* Compare the beginning of the repeat with what in the
   6993                pattern follows its end. If we can establish that there
   6994                is nothing that they would both match, i.e., that we
   6995                would have to backtrack because of (as in, e.g., `a*a')
   6996                then we can change to pop_failure_jump, because we'll
   6997                never have to backtrack.
   6998 
   6999                This is not true in the case of alternatives: in
   7000                `(a|ab)*' we do need to backtrack to the `ab' alternative
   7001                (e.g., if the string was `ab').  But instead of trying to
   7002                detect that here, the alternative has put on a dummy
   7003                failure point which is what we will end up popping.  */
   7004 
   7005 	    /* Skip over open/close-group commands.
   7006 	       If what follows this loop is a ...+ construct,
   7007 	       look at what begins its body, since we will have to
   7008 	       match at least one of that.  */
   7009 	    while (1)
   7010 	      {
   7011 		if (p2 + 2 < pend
   7012 		    && ((re_opcode_t) *p2 == stop_memory
   7013 			|| (re_opcode_t) *p2 == start_memory))
   7014 		  p2 += 3;
   7015 		else if (p2 + 2 + 2 * OFFSET_ADDRESS_SIZE < pend
   7016 			 && (re_opcode_t) *p2 == dummy_failure_jump)
   7017 		  p2 += 2 + 2 * OFFSET_ADDRESS_SIZE;
   7018 		else
   7019 		  break;
   7020 	      }
   7021 
   7022 	    p1 = p + mcnt;
   7023 	    /* p1[0] ... p1[2] are the `on_failure_jump' corresponding
   7024 	       to the `maybe_finalize_jump' of this case.  Examine what
   7025 	       follows.  */
   7026 
   7027             /* If we're at the end of the pattern, we can change.  */
   7028             if (p2 == pend)
   7029 	      {
   7030 		/* Consider what happens when matching ":\(.*\)"
   7031 		   against ":/".  I don't really understand this code
   7032 		   yet.  */
   7033   	        p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
   7034 		  pop_failure_jump;
   7035                 DEBUG_PRINT1
   7036                   ("  End of pattern: change to `pop_failure_jump'.\n");
   7037               }
   7038 
   7039             else if ((re_opcode_t) *p2 == exactn
   7040 #ifdef MBS_SUPPORT
   7041 		     || (re_opcode_t) *p2 == exactn_bin
   7042 #endif
   7043 		     || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
   7044 	      {
   7045 		register UCHAR_T c
   7046                   = *p2 == (UCHAR_T) endline ? '\n' : p2[2];
   7047 
   7048                 if (((re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn
   7049 #ifdef MBS_SUPPORT
   7050 		     || (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn_bin
   7051 #endif
   7052 		    ) && p1[3+OFFSET_ADDRESS_SIZE] != c)
   7053                   {
   7054   		    p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
   7055 		      pop_failure_jump;
   7056 #ifdef WCHAR
   7057 		      DEBUG_PRINT3 ("  %C != %C => pop_failure_jump.\n",
   7058 				    (wint_t) c,
   7059 				    (wint_t) p1[3+OFFSET_ADDRESS_SIZE]);
   7060 #else
   7061 		      DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
   7062 				    (char) c,
   7063 				    (char) p1[3+OFFSET_ADDRESS_SIZE]);
   7064 #endif
   7065                   }
   7066 
   7067 #ifndef WCHAR
   7068 		else if ((re_opcode_t) p1[3] == charset
   7069 			 || (re_opcode_t) p1[3] == charset_not)
   7070 		  {
   7071 		    int negate = (re_opcode_t) p1[3] == charset_not;
   7072 
   7073 		    if (c < (unsigned) (p1[4] * BYTEWIDTH)
   7074 			&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
   7075 		      negate = !negate;
   7076 
   7077                     /* `negate' is equal to 1 if c would match, which means
   7078                         that we can't change to pop_failure_jump.  */
   7079 		    if (!negate)
   7080                       {
   7081   		        p[-3] = (unsigned char) pop_failure_jump;
   7082                         DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
   7083                       }
   7084 		  }
   7085 #endif /* not WCHAR */
   7086 	      }
   7087 #ifndef WCHAR
   7088             else if ((re_opcode_t) *p2 == charset)
   7089 	      {
   7090 		/* We win if the first character of the loop is not part
   7091                    of the charset.  */
   7092                 if ((re_opcode_t) p1[3] == exactn
   7093  		    && ! ((int) p2[1] * BYTEWIDTH > (int) p1[5]
   7094  			  && (p2[2 + p1[5] / BYTEWIDTH]
   7095  			      & (1 << (p1[5] % BYTEWIDTH)))))
   7096 		  {
   7097 		    p[-3] = (unsigned char) pop_failure_jump;
   7098 		    DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
   7099                   }
   7100 
   7101 		else if ((re_opcode_t) p1[3] == charset_not)
   7102 		  {
   7103 		    int idx;
   7104 		    /* We win if the charset_not inside the loop
   7105 		       lists every character listed in the charset after.  */
   7106 		    for (idx = 0; idx < (int) p2[1]; idx++)
   7107 		      if (! (p2[2 + idx] == 0
   7108 			     || (idx < (int) p1[4]
   7109 				 && ((p2[2 + idx] & ~ p1[5 + idx]) == 0))))
   7110 			break;
   7111 
   7112 		    if (idx == p2[1])
   7113                       {
   7114   		        p[-3] = (unsigned char) pop_failure_jump;
   7115                         DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
   7116                       }
   7117 		  }
   7118 		else if ((re_opcode_t) p1[3] == charset)
   7119 		  {
   7120 		    int idx;
   7121 		    /* We win if the charset inside the loop
   7122 		       has no overlap with the one after the loop.  */
   7123 		    for (idx = 0;
   7124 			 idx < (int) p2[1] && idx < (int) p1[4];
   7125 			 idx++)
   7126 		      if ((p2[2 + idx] & p1[5 + idx]) != 0)
   7127 			break;
   7128 
   7129 		    if (idx == p2[1] || idx == p1[4])
   7130                       {
   7131   		        p[-3] = (unsigned char) pop_failure_jump;
   7132                         DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
   7133                       }
   7134 		  }
   7135 	      }
   7136 #endif /* not WCHAR */
   7137 	  }
   7138 	  p -= OFFSET_ADDRESS_SIZE;	/* Point at relative address again.  */
   7139 	  if ((re_opcode_t) p[-1] != pop_failure_jump)
   7140 	    {
   7141 	      p[-1] = (UCHAR_T) jump;
   7142               DEBUG_PRINT1 ("  Match => jump.\n");
   7143 	      goto unconditional_jump;
   7144 	    }
   7145         /* Note fall through.  */
   7146 
   7147 
   7148 	/* The end of a simple repeat has a pop_failure_jump back to
   7149            its matching on_failure_jump, where the latter will push a
   7150            failure point.  The pop_failure_jump takes off failure
   7151            points put on by this pop_failure_jump's matching
   7152            on_failure_jump; we got through the pattern to here from the
   7153            matching on_failure_jump, so didn't fail.  */
   7154         case pop_failure_jump:
   7155           {
   7156             /* We need to pass separate storage for the lowest and
   7157                highest registers, even though we don't care about the
   7158                actual values.  Otherwise, we will restore only one
   7159                register from the stack, since lowest will == highest in
   7160                `pop_failure_point'.  */
   7161             active_reg_t dummy_low_reg, dummy_high_reg;
   7162             UCHAR_T *pdummy ATTRIBUTE_UNUSED = NULL;
   7163             const CHAR_T *sdummy ATTRIBUTE_UNUSED = NULL;
   7164 
   7165             DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");
   7166             POP_FAILURE_POINT (sdummy, pdummy,
   7167                                dummy_low_reg, dummy_high_reg,
   7168                                reg_dummy, reg_dummy, reg_info_dummy);
   7169           }
   7170 	  /* Note fall through.  */
   7171 
   7172 	unconditional_jump:
   7173 #ifdef _LIBC
   7174 	  DEBUG_PRINT2 ("\n%p: ", p);
   7175 #else
   7176 	  DEBUG_PRINT2 ("\n0x%x: ", p);
   7177 #endif
   7178           /* Note fall through.  */
   7179 
   7180         /* Unconditionally jump (without popping any failure points).  */
   7181         case jump:
   7182 	  EXTRACT_NUMBER_AND_INCR (mcnt, p);	/* Get the amount to jump.  */
   7183           DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
   7184 	  p += mcnt;				/* Do the jump.  */
   7185 #ifdef _LIBC
   7186           DEBUG_PRINT2 ("(to %p).\n", p);
   7187 #else
   7188           DEBUG_PRINT2 ("(to 0x%x).\n", p);
   7189 #endif
   7190 	  break;
   7191 
   7192 
   7193         /* We need this opcode so we can detect where alternatives end
   7194            in `group_match_null_string_p' et al.  */
   7195         case jump_past_alt:
   7196           DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n");
   7197           goto unconditional_jump;
   7198 
   7199 
   7200         /* Normally, the on_failure_jump pushes a failure point, which
   7201            then gets popped at pop_failure_jump.  We will end up at
   7202            pop_failure_jump, also, and with a pattern of, say, `a+', we
   7203            are skipping over the on_failure_jump, so we have to push
   7204            something meaningless for pop_failure_jump to pop.  */
   7205         case dummy_failure_jump:
   7206           DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");
   7207           /* It doesn't matter what we push for the string here.  What
   7208              the code at `fail' tests is the value for the pattern.  */
   7209           PUSH_FAILURE_POINT (NULL, NULL, -2);
   7210           goto unconditional_jump;
   7211 
   7212 
   7213         /* At the end of an alternative, we need to push a dummy failure
   7214            point in case we are followed by a `pop_failure_jump', because
   7215            we don't want the failure point for the alternative to be
   7216            popped.  For example, matching `(a|ab)*' against `aab'
   7217            requires that we match the `ab' alternative.  */
   7218         case push_dummy_failure:
   7219           DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");
   7220           /* See comments just above at `dummy_failure_jump' about the
   7221              two zeroes.  */
   7222           PUSH_FAILURE_POINT (NULL, NULL, -2);
   7223           break;
   7224 
   7225         /* Have to succeed matching what follows at least n times.
   7226            After that, handle like `on_failure_jump'.  */
   7227         case succeed_n:
   7228           EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
   7229           DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);
   7230 
   7231           assert (mcnt >= 0);
   7232           /* Originally, this is how many times we HAVE to succeed.  */
   7233           if (mcnt > 0)
   7234             {
   7235                mcnt--;
   7236 	       p += OFFSET_ADDRESS_SIZE;
   7237                STORE_NUMBER_AND_INCR (p, mcnt);
   7238 #ifdef _LIBC
   7239                DEBUG_PRINT3 ("  Setting %p to %d.\n", p - OFFSET_ADDRESS_SIZE
   7240 			     , mcnt);
   7241 #else
   7242                DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p - OFFSET_ADDRESS_SIZE
   7243 			     , mcnt);
   7244 #endif
   7245             }
   7246 	  else if (mcnt == 0)
   7247             {
   7248 #ifdef _LIBC
   7249               DEBUG_PRINT2 ("  Setting two bytes from %p to no_op.\n",
   7250 			    p + OFFSET_ADDRESS_SIZE);
   7251 #else
   7252               DEBUG_PRINT2 ("  Setting two bytes from 0x%x to no_op.\n",
   7253 			    p + OFFSET_ADDRESS_SIZE);
   7254 #endif /* _LIBC */
   7255 
   7256 #ifdef WCHAR
   7257 	      p[1] = (UCHAR_T) no_op;
   7258 #else
   7259 	      p[2] = (UCHAR_T) no_op;
   7260               p[3] = (UCHAR_T) no_op;
   7261 #endif /* WCHAR */
   7262               goto on_failure;
   7263             }
   7264           break;
   7265 
   7266         case jump_n:
   7267           EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
   7268           DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);
   7269 
   7270           /* Originally, this is how many times we CAN jump.  */
   7271           if (mcnt)
   7272             {
   7273                mcnt--;
   7274                STORE_NUMBER (p + OFFSET_ADDRESS_SIZE, mcnt);
   7275 
   7276 #ifdef _LIBC
   7277                DEBUG_PRINT3 ("  Setting %p to %d.\n", p + OFFSET_ADDRESS_SIZE,
   7278 			     mcnt);
   7279 #else
   7280                DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p + OFFSET_ADDRESS_SIZE,
   7281 			     mcnt);
   7282 #endif /* _LIBC */
   7283 	       goto unconditional_jump;
   7284             }
   7285           /* If don't have to jump any more, skip over the rest of command.  */
   7286 	  else
   7287 	    p += 2 * OFFSET_ADDRESS_SIZE;
   7288           break;
   7289 
   7290 	case set_number_at:
   7291 	  {
   7292             DEBUG_PRINT1 ("EXECUTING set_number_at.\n");
   7293 
   7294             EXTRACT_NUMBER_AND_INCR (mcnt, p);
   7295             p1 = p + mcnt;
   7296             EXTRACT_NUMBER_AND_INCR (mcnt, p);
   7297 #ifdef _LIBC
   7298             DEBUG_PRINT3 ("  Setting %p to %d.\n", p1, mcnt);
   7299 #else
   7300             DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p1, mcnt);
   7301 #endif
   7302 	    STORE_NUMBER (p1, mcnt);
   7303             break;
   7304           }
   7305 
   7306 #if 0
   7307 	/* The DEC Alpha C compiler 3.x generates incorrect code for the
   7308 	   test  WORDCHAR_P (d - 1) != WORDCHAR_P (d)  in the expansion of
   7309 	   AT_WORD_BOUNDARY, so this code is disabled.  Expanding the
   7310 	   macro and introducing temporary variables works around the bug.  */
   7311 
   7312 	case wordbound:
   7313 	  DEBUG_PRINT1 ("EXECUTING wordbound.\n");
   7314 	  if (AT_WORD_BOUNDARY (d))
   7315 	    break;
   7316 	  goto fail;
   7317 
   7318 	case notwordbound:
   7319 	  DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
   7320 	  if (AT_WORD_BOUNDARY (d))
   7321 	    goto fail;
   7322 	  break;
   7323 #else
   7324 	case wordbound:
   7325 	{
   7326 	  boolean prevchar, thischar;
   7327 
   7328 	  DEBUG_PRINT1 ("EXECUTING wordbound.\n");
   7329 	  if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
   7330 	    break;
   7331 
   7332 	  prevchar = WORDCHAR_P (d - 1);
   7333 	  thischar = WORDCHAR_P (d);
   7334 	  if (prevchar != thischar)
   7335 	    break;
   7336 	  goto fail;
   7337 	}
   7338 
   7339       case notwordbound:
   7340 	{
   7341 	  boolean prevchar, thischar;
   7342 
   7343 	  DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
   7344 	  if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
   7345 	    goto fail;
   7346 
   7347 	  prevchar = WORDCHAR_P (d - 1);
   7348 	  thischar = WORDCHAR_P (d);
   7349 	  if (prevchar != thischar)
   7350 	    goto fail;
   7351 	  break;
   7352 	}
   7353 #endif
   7354 
   7355 	case wordbeg:
   7356           DEBUG_PRINT1 ("EXECUTING wordbeg.\n");
   7357 	  if (!AT_STRINGS_END (d) && WORDCHAR_P (d)
   7358 	      && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1)))
   7359 	    break;
   7360           goto fail;
   7361 
   7362 	case wordend:
   7363           DEBUG_PRINT1 ("EXECUTING wordend.\n");
   7364 	  if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1)
   7365               && (AT_STRINGS_END (d) || !WORDCHAR_P (d)))
   7366 	    break;
   7367           goto fail;
   7368 
   7369 #ifdef emacs
   7370   	case before_dot:
   7371           DEBUG_PRINT1 ("EXECUTING before_dot.\n");
   7372  	  if (PTR_CHAR_POS ((unsigned char *) d) >= point)
   7373   	    goto fail;
   7374   	  break;
   7375 
   7376   	case at_dot:
   7377           DEBUG_PRINT1 ("EXECUTING at_dot.\n");
   7378  	  if (PTR_CHAR_POS ((unsigned char *) d) != point)
   7379   	    goto fail;
   7380   	  break;
   7381 
   7382   	case after_dot:
   7383           DEBUG_PRINT1 ("EXECUTING after_dot.\n");
   7384           if (PTR_CHAR_POS ((unsigned char *) d) <= point)
   7385   	    goto fail;
   7386   	  break;
   7387 
   7388 	case syntaxspec:
   7389           DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt);
   7390 	  mcnt = *p++;
   7391 	  goto matchsyntax;
   7392 
   7393         case wordchar:
   7394           DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n");
   7395 	  mcnt = (int) Sword;
   7396         matchsyntax:
   7397 	  PREFETCH ();
   7398 	  /* Can't use *d++ here; SYNTAX may be an unsafe macro.  */
   7399 	  d++;
   7400 	  if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt)
   7401 	    goto fail;
   7402           SET_REGS_MATCHED ();
   7403 	  break;
   7404 
   7405 	case notsyntaxspec:
   7406           DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt);
   7407 	  mcnt = *p++;
   7408 	  goto matchnotsyntax;
   7409 
   7410         case notwordchar:
   7411           DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n");
   7412 	  mcnt = (int) Sword;
   7413         matchnotsyntax:
   7414 	  PREFETCH ();
   7415 	  /* Can't use *d++ here; SYNTAX may be an unsafe macro.  */
   7416 	  d++;
   7417 	  if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt)
   7418 	    goto fail;
   7419 	  SET_REGS_MATCHED ();
   7420           break;
   7421 
   7422 #else /* not emacs */
   7423 	case wordchar:
   7424           DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n");
   7425 	  PREFETCH ();
   7426           if (!WORDCHAR_P (d))
   7427             goto fail;
   7428 	  SET_REGS_MATCHED ();
   7429           d++;
   7430 	  break;
   7431 
   7432 	case notwordchar:
   7433           DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");
   7434 	  PREFETCH ();
   7435 	  if (WORDCHAR_P (d))
   7436             goto fail;
   7437           SET_REGS_MATCHED ();
   7438           d++;
   7439 	  break;
   7440 #endif /* not emacs */
   7441 
   7442         default:
   7443           abort ();
   7444 	}
   7445       continue;  /* Successfully executed one pattern command; keep going.  */
   7446 
   7447 
   7448     /* We goto here if a matching operation fails. */
   7449     fail:
   7450       if (!FAIL_STACK_EMPTY ())
   7451 	{ /* A restart point is known.  Restore to that state.  */
   7452           DEBUG_PRINT1 ("\nFAIL:\n");
   7453           POP_FAILURE_POINT (d, p,
   7454                              lowest_active_reg, highest_active_reg,
   7455                              regstart, regend, reg_info);
   7456 
   7457           /* If this failure point is a dummy, try the next one.  */
   7458           if (!p)
   7459 	    goto fail;
   7460 
   7461           /* If we failed to the end of the pattern, don't examine *p.  */
   7462 	  assert (p <= pend);
   7463           if (p < pend)
   7464             {
   7465               boolean is_a_jump_n = false;
   7466 
   7467               /* If failed to a backwards jump that's part of a repetition
   7468                  loop, need to pop this failure point and use the next one.  */
   7469               switch ((re_opcode_t) *p)
   7470                 {
   7471                 case jump_n:
   7472                   is_a_jump_n = true;
   7473                 case maybe_pop_jump:
   7474                 case pop_failure_jump:
   7475                 case jump:
   7476                   p1 = p + 1;
   7477                   EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7478                   p1 += mcnt;
   7479 
   7480                   if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)
   7481                       || (!is_a_jump_n
   7482                           && (re_opcode_t) *p1 == on_failure_jump))
   7483                     goto fail;
   7484                   break;
   7485                 default:
   7486                   /* do nothing */ ;
   7487                 }
   7488             }
   7489 
   7490           if (d >= string1 && d <= end1)
   7491 	    dend = end_match_1;
   7492         }
   7493       else
   7494         break;   /* Matching at this starting point really fails.  */
   7495     } /* for (;;) */
   7496 
   7497   if (best_regs_set)
   7498     goto restore_best_regs;
   7499 
   7500   FREE_VARIABLES ();
   7501 
   7502   return -1;         			/* Failure to match.  */
   7503 } /* re_match_2 */
   7504 
   7505 /* Subroutine definitions for re_match_2.  */
   7507 
   7508 
   7509 /* We are passed P pointing to a register number after a start_memory.
   7510 
   7511    Return true if the pattern up to the corresponding stop_memory can
   7512    match the empty string, and false otherwise.
   7513 
   7514    If we find the matching stop_memory, sets P to point to one past its number.
   7515    Otherwise, sets P to an undefined byte less than or equal to END.
   7516 
   7517    We don't handle duplicates properly (yet).  */
   7518 
   7519 static boolean
   7520 PREFIX(group_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
   7521                                    PREFIX(register_info_type) *reg_info)
   7522 {
   7523   int mcnt;
   7524   /* Point to after the args to the start_memory.  */
   7525   UCHAR_T *p1 = *p + 2;
   7526 
   7527   while (p1 < end)
   7528     {
   7529       /* Skip over opcodes that can match nothing, and return true or
   7530 	 false, as appropriate, when we get to one that can't, or to the
   7531          matching stop_memory.  */
   7532 
   7533       switch ((re_opcode_t) *p1)
   7534         {
   7535         /* Could be either a loop or a series of alternatives.  */
   7536         case on_failure_jump:
   7537           p1++;
   7538           EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7539 
   7540           /* If the next operation is not a jump backwards in the
   7541 	     pattern.  */
   7542 
   7543 	  if (mcnt >= 0)
   7544 	    {
   7545               /* Go through the on_failure_jumps of the alternatives,
   7546                  seeing if any of the alternatives cannot match nothing.
   7547                  The last alternative starts with only a jump,
   7548                  whereas the rest start with on_failure_jump and end
   7549                  with a jump, e.g., here is the pattern for `a|b|c':
   7550 
   7551                  /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6
   7552                  /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3
   7553                  /exactn/1/c
   7554 
   7555                  So, we have to first go through the first (n-1)
   7556                  alternatives and then deal with the last one separately.  */
   7557 
   7558 
   7559               /* Deal with the first (n-1) alternatives, which start
   7560                  with an on_failure_jump (see above) that jumps to right
   7561                  past a jump_past_alt.  */
   7562 
   7563               while ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] ==
   7564 		     jump_past_alt)
   7565                 {
   7566                   /* `mcnt' holds how many bytes long the alternative
   7567                      is, including the ending `jump_past_alt' and
   7568                      its number.  */
   7569 
   7570                   if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt -
   7571 						(1 + OFFSET_ADDRESS_SIZE),
   7572 						reg_info))
   7573                     return false;
   7574 
   7575                   /* Move to right after this alternative, including the
   7576 		     jump_past_alt.  */
   7577                   p1 += mcnt;
   7578 
   7579                   /* Break if it's the beginning of an n-th alternative
   7580                      that doesn't begin with an on_failure_jump.  */
   7581                   if ((re_opcode_t) *p1 != on_failure_jump)
   7582                     break;
   7583 
   7584 		  /* Still have to check that it's not an n-th
   7585 		     alternative that starts with an on_failure_jump.  */
   7586 		  p1++;
   7587                   EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7588                   if ((re_opcode_t) p1[mcnt-(1+OFFSET_ADDRESS_SIZE)] !=
   7589 		      jump_past_alt)
   7590                     {
   7591 		      /* Get to the beginning of the n-th alternative.  */
   7592                       p1 -= 1 + OFFSET_ADDRESS_SIZE;
   7593                       break;
   7594                     }
   7595                 }
   7596 
   7597               /* Deal with the last alternative: go back and get number
   7598                  of the `jump_past_alt' just before it.  `mcnt' contains
   7599                  the length of the alternative.  */
   7600               EXTRACT_NUMBER (mcnt, p1 - OFFSET_ADDRESS_SIZE);
   7601 
   7602               if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt, reg_info))
   7603                 return false;
   7604 
   7605               p1 += mcnt;	/* Get past the n-th alternative.  */
   7606             } /* if mcnt > 0 */
   7607           break;
   7608 
   7609 
   7610         case stop_memory:
   7611 	  assert (p1[1] == **p);
   7612           *p = p1 + 2;
   7613           return true;
   7614 
   7615 
   7616         default:
   7617           if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
   7618             return false;
   7619         }
   7620     } /* while p1 < end */
   7621 
   7622   return false;
   7623 } /* group_match_null_string_p */
   7624 
   7625 
   7626 /* Similar to group_match_null_string_p, but doesn't deal with alternatives:
   7627    It expects P to be the first byte of a single alternative and END one
   7628    byte past the last. The alternative can contain groups.  */
   7629 
   7630 static boolean
   7631 PREFIX(alt_match_null_string_p) (UCHAR_T *p, UCHAR_T *end,
   7632                                  PREFIX(register_info_type) *reg_info)
   7633 {
   7634   int mcnt;
   7635   UCHAR_T *p1 = p;
   7636 
   7637   while (p1 < end)
   7638     {
   7639       /* Skip over opcodes that can match nothing, and break when we get
   7640          to one that can't.  */
   7641 
   7642       switch ((re_opcode_t) *p1)
   7643         {
   7644 	/* It's a loop.  */
   7645         case on_failure_jump:
   7646           p1++;
   7647           EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7648           p1 += mcnt;
   7649           break;
   7650 
   7651 	default:
   7652           if (!PREFIX(common_op_match_null_string_p) (&p1, end, reg_info))
   7653             return false;
   7654         }
   7655     }  /* while p1 < end */
   7656 
   7657   return true;
   7658 } /* alt_match_null_string_p */
   7659 
   7660 
   7661 /* Deals with the ops common to group_match_null_string_p and
   7662    alt_match_null_string_p.
   7663 
   7664    Sets P to one after the op and its arguments, if any.  */
   7665 
   7666 static boolean
   7667 PREFIX(common_op_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
   7668                                        PREFIX(register_info_type) *reg_info)
   7669 {
   7670   int mcnt;
   7671   boolean ret;
   7672   int reg_no;
   7673   UCHAR_T *p1 = *p;
   7674 
   7675   switch ((re_opcode_t) *p1++)
   7676     {
   7677     case no_op:
   7678     case begline:
   7679     case endline:
   7680     case begbuf:
   7681     case endbuf:
   7682     case wordbeg:
   7683     case wordend:
   7684     case wordbound:
   7685     case notwordbound:
   7686 #ifdef emacs
   7687     case before_dot:
   7688     case at_dot:
   7689     case after_dot:
   7690 #endif
   7691       break;
   7692 
   7693     case start_memory:
   7694       reg_no = *p1;
   7695       assert (reg_no > 0 && reg_no <= MAX_REGNUM);
   7696       ret = PREFIX(group_match_null_string_p) (&p1, end, reg_info);
   7697 
   7698       /* Have to set this here in case we're checking a group which
   7699          contains a group and a back reference to it.  */
   7700 
   7701       if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE)
   7702         REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret;
   7703 
   7704       if (!ret)
   7705         return false;
   7706       break;
   7707 
   7708     /* If this is an optimized succeed_n for zero times, make the jump.  */
   7709     case jump:
   7710       EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7711       if (mcnt >= 0)
   7712         p1 += mcnt;
   7713       else
   7714         return false;
   7715       break;
   7716 
   7717     case succeed_n:
   7718       /* Get to the number of times to succeed.  */
   7719       p1 += OFFSET_ADDRESS_SIZE;
   7720       EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7721 
   7722       if (mcnt == 0)
   7723         {
   7724           p1 -= 2 * OFFSET_ADDRESS_SIZE;
   7725           EXTRACT_NUMBER_AND_INCR (mcnt, p1);
   7726           p1 += mcnt;
   7727         }
   7728       else
   7729         return false;
   7730       break;
   7731 
   7732     case duplicate:
   7733       if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))
   7734         return false;
   7735       break;
   7736 
   7737     case set_number_at:
   7738       p1 += 2 * OFFSET_ADDRESS_SIZE;
   7739 
   7740     default:
   7741       /* All other opcodes mean we cannot match the empty string.  */
   7742       return false;
   7743   }
   7744 
   7745   *p = p1;
   7746   return true;
   7747 } /* common_op_match_null_string_p */
   7748 
   7749 
   7750 /* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
   7751    bytes; nonzero otherwise.  */
   7752 
   7753 static int
   7754 PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2, register int len,
   7755                         RE_TRANSLATE_TYPE translate)
   7756 {
   7757   register const UCHAR_T *p1 = (const UCHAR_T *) s1;
   7758   register const UCHAR_T *p2 = (const UCHAR_T *) s2;
   7759   while (len)
   7760     {
   7761 #ifdef WCHAR
   7762       if (((*p1<=0xff)?translate[*p1++]:*p1++)
   7763 	  != ((*p2<=0xff)?translate[*p2++]:*p2++))
   7764 	return 1;
   7765 #else /* BYTE */
   7766       if (translate[*p1++] != translate[*p2++]) return 1;
   7767 #endif /* WCHAR */
   7768       len--;
   7769     }
   7770   return 0;
   7771 }
   7772 
   7773 
   7775 #else /* not INSIDE_RECURSION */
   7776 
   7777 /* Entry points for GNU code.  */
   7778 
   7779 /* re_compile_pattern is the GNU regular expression compiler: it
   7780    compiles PATTERN (of length SIZE) and puts the result in BUFP.
   7781    Returns 0 if the pattern was valid, otherwise an error string.
   7782 
   7783    Assumes the `allocated' (and perhaps `buffer') and `translate' fields
   7784    are set in BUFP on entry.
   7785 
   7786    We call regex_compile to do the actual compilation.  */
   7787 
   7788 const char *
   7789 re_compile_pattern (const char *pattern, size_t length,
   7790                     struct re_pattern_buffer *bufp)
   7791 {
   7792   reg_errcode_t ret;
   7793 
   7794   /* GNU code is written to assume at least RE_NREGS registers will be set
   7795      (and at least one extra will be -1).  */
   7796   bufp->regs_allocated = REGS_UNALLOCATED;
   7797 
   7798   /* And GNU code determines whether or not to get register information
   7799      by passing null for the REGS argument to re_match, etc., not by
   7800      setting no_sub.  */
   7801   bufp->no_sub = 0;
   7802 
   7803   /* Match anchors at newline.  */
   7804   bufp->newline_anchor = 1;
   7805 
   7806 # ifdef MBS_SUPPORT
   7807   if (MB_CUR_MAX != 1)
   7808     ret = wcs_regex_compile (pattern, length, re_syntax_options, bufp);
   7809   else
   7810 # endif
   7811     ret = byte_regex_compile (pattern, length, re_syntax_options, bufp);
   7812 
   7813   if (!ret)
   7814     return NULL;
   7815   return gettext (re_error_msgid[(int) ret]);
   7816 }
   7817 #ifdef _LIBC
   7818 weak_alias (__re_compile_pattern, re_compile_pattern)
   7819 #endif
   7820 
   7821 /* Entry points compatible with 4.2 BSD regex library.  We don't define
   7823    them unless specifically requested.  */
   7824 
   7825 #if defined _REGEX_RE_COMP || defined _LIBC
   7826 
   7827 /* BSD has one and only one pattern buffer.  */
   7828 static struct re_pattern_buffer re_comp_buf;
   7829 
   7830 char *
   7831 #ifdef _LIBC
   7832 /* Make these definitions weak in libc, so POSIX programs can redefine
   7833    these names if they don't use our functions, and still use
   7834    regcomp/regexec below without link errors.  */
   7835 weak_function
   7836 #endif
   7837 re_comp (const char *s)
   7838 {
   7839   reg_errcode_t ret;
   7840 
   7841   if (!s)
   7842     {
   7843       if (!re_comp_buf.buffer)
   7844 	return (char *) gettext ("No previous regular expression");
   7845       return 0;
   7846     }
   7847 
   7848   if (!re_comp_buf.buffer)
   7849     {
   7850       re_comp_buf.buffer = (unsigned char *) malloc (200);
   7851       if (re_comp_buf.buffer == NULL)
   7852         return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
   7853       re_comp_buf.allocated = 200;
   7854 
   7855       re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);
   7856       if (re_comp_buf.fastmap == NULL)
   7857 	return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
   7858     }
   7859 
   7860   /* Since `re_exec' always passes NULL for the `regs' argument, we
   7861      don't need to initialize the pattern buffer fields which affect it.  */
   7862 
   7863   /* Match anchors at newlines.  */
   7864   re_comp_buf.newline_anchor = 1;
   7865 
   7866 # ifdef MBS_SUPPORT
   7867   if (MB_CUR_MAX != 1)
   7868     ret = wcs_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
   7869   else
   7870 # endif
   7871     ret = byte_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
   7872 
   7873   if (!ret)
   7874     return NULL;
   7875 
   7876   /* Yes, we're discarding `const' here if !HAVE_LIBINTL.  */
   7877   return (char *) gettext (re_error_msgid[(int) ret]);
   7878 }
   7879 
   7880 
   7881 int
   7882 #ifdef _LIBC
   7883 weak_function
   7884 #endif
   7885 re_exec (const char *s)
   7886 {
   7887   const int len = strlen (s);
   7888   return
   7889     0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
   7890 }
   7891 
   7892 #endif /* _REGEX_RE_COMP */
   7893 
   7894 /* POSIX.2 functions.  Don't define these for Emacs.  */
   7896 
   7897 #ifndef emacs
   7898 
   7899 /* regcomp takes a regular expression as a string and compiles it.
   7900 
   7901    PREG is a regex_t *.  We do not expect any fields to be initialized,
   7902    since POSIX says we shouldn't.  Thus, we set
   7903 
   7904      `buffer' to the compiled pattern;
   7905      `used' to the length of the compiled pattern;
   7906      `syntax' to RE_SYNTAX_POSIX_EXTENDED if the
   7907        REG_EXTENDED bit in CFLAGS is set; otherwise, to
   7908        RE_SYNTAX_POSIX_BASIC;
   7909      `newline_anchor' to REG_NEWLINE being set in CFLAGS;
   7910      `fastmap' to an allocated space for the fastmap;
   7911      `fastmap_accurate' to zero;
   7912      `re_nsub' to the number of subexpressions in PATTERN.
   7913 
   7914    PATTERN is the address of the pattern string.
   7915 
   7916    CFLAGS is a series of bits which affect compilation.
   7917 
   7918      If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
   7919      use POSIX basic syntax.
   7920 
   7921      If REG_NEWLINE is set, then . and [^...] don't match newline.
   7922      Also, regexec will try a match beginning after every newline.
   7923 
   7924      If REG_ICASE is set, then we considers upper- and lowercase
   7925      versions of letters to be equivalent when matching.
   7926 
   7927      If REG_NOSUB is set, then when PREG is passed to regexec, that
   7928      routine will report only success or failure, and nothing about the
   7929      registers.
   7930 
   7931    It returns 0 if it succeeds, nonzero if it doesn't.  (See regex.h for
   7932    the return codes and their meanings.)  */
   7933 
   7934 int
   7935 regcomp (regex_t *preg, const char *pattern, int cflags)
   7936 {
   7937   reg_errcode_t ret;
   7938   reg_syntax_t syntax
   7939     = (cflags & REG_EXTENDED) ?
   7940       RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;
   7941 
   7942   /* regex_compile will allocate the space for the compiled pattern.  */
   7943   preg->buffer = 0;
   7944   preg->allocated = 0;
   7945   preg->used = 0;
   7946 
   7947   /* Try to allocate space for the fastmap.  */
   7948   preg->fastmap = (char *) malloc (1 << BYTEWIDTH);
   7949 
   7950   if (cflags & REG_ICASE)
   7951     {
   7952       int i;
   7953 
   7954       preg->translate
   7955 	= (RE_TRANSLATE_TYPE) malloc (CHAR_SET_SIZE
   7956 				      * sizeof (*(RE_TRANSLATE_TYPE)0));
   7957       if (preg->translate == NULL)
   7958         return (int) REG_ESPACE;
   7959 
   7960       /* Map uppercase characters to corresponding lowercase ones.  */
   7961       for (i = 0; i < CHAR_SET_SIZE; i++)
   7962         preg->translate[i] = ISUPPER (i) ? TOLOWER (i) : i;
   7963     }
   7964   else
   7965     preg->translate = NULL;
   7966 
   7967   /* If REG_NEWLINE is set, newlines are treated differently.  */
   7968   if (cflags & REG_NEWLINE)
   7969     { /* REG_NEWLINE implies neither . nor [^...] match newline.  */
   7970       syntax &= ~RE_DOT_NEWLINE;
   7971       syntax |= RE_HAT_LISTS_NOT_NEWLINE;
   7972       /* It also changes the matching behavior.  */
   7973       preg->newline_anchor = 1;
   7974     }
   7975   else
   7976     preg->newline_anchor = 0;
   7977 
   7978   preg->no_sub = !!(cflags & REG_NOSUB);
   7979 
   7980   /* POSIX says a null character in the pattern terminates it, so we
   7981      can use strlen here in compiling the pattern.  */
   7982 # ifdef MBS_SUPPORT
   7983   if (MB_CUR_MAX != 1)
   7984     ret = wcs_regex_compile (pattern, strlen (pattern), syntax, preg);
   7985   else
   7986 # endif
   7987     ret = byte_regex_compile (pattern, strlen (pattern), syntax, preg);
   7988 
   7989   /* POSIX doesn't distinguish between an unmatched open-group and an
   7990      unmatched close-group: both are REG_EPAREN.  */
   7991   if (ret == REG_ERPAREN) ret = REG_EPAREN;
   7992 
   7993   if (ret == REG_NOERROR && preg->fastmap)
   7994     {
   7995       /* Compute the fastmap now, since regexec cannot modify the pattern
   7996 	 buffer.  */
   7997       if (re_compile_fastmap (preg) == -2)
   7998 	{
   7999 	  /* Some error occurred while computing the fastmap, just forget
   8000 	     about it.  */
   8001 	  free (preg->fastmap);
   8002 	  preg->fastmap = NULL;
   8003 	}
   8004     }
   8005 
   8006   return (int) ret;
   8007 }
   8008 #ifdef _LIBC
   8009 weak_alias (__regcomp, regcomp)
   8010 #endif
   8011 
   8012 
   8013 /* regexec searches for a given pattern, specified by PREG, in the
   8014    string STRING.
   8015 
   8016    If NMATCH is zero or REG_NOSUB was set in the cflags argument to
   8017    `regcomp', we ignore PMATCH.  Otherwise, we assume PMATCH has at
   8018    least NMATCH elements, and we set them to the offsets of the
   8019    corresponding matched substrings.
   8020 
   8021    EFLAGS specifies `execution flags' which affect matching: if
   8022    REG_NOTBOL is set, then ^ does not match at the beginning of the
   8023    string; if REG_NOTEOL is set, then $ does not match at the end.
   8024 
   8025    We return 0 if we find a match and REG_NOMATCH if not.  */
   8026 
   8027 int
   8028 regexec (const regex_t *preg, const char *string, size_t nmatch,
   8029          regmatch_t pmatch[], int eflags)
   8030 {
   8031   int ret;
   8032   struct re_registers regs;
   8033   regex_t private_preg;
   8034   int len = strlen (string);
   8035   boolean want_reg_info = !preg->no_sub && nmatch > 0;
   8036 
   8037   private_preg = *preg;
   8038 
   8039   private_preg.not_bol = !!(eflags & REG_NOTBOL);
   8040   private_preg.not_eol = !!(eflags & REG_NOTEOL);
   8041 
   8042   /* The user has told us exactly how many registers to return
   8043      information about, via `nmatch'.  We have to pass that on to the
   8044      matching routines.  */
   8045   private_preg.regs_allocated = REGS_FIXED;
   8046 
   8047   if (want_reg_info)
   8048     {
   8049       regs.num_regs = nmatch;
   8050       regs.start = TALLOC (nmatch * 2, regoff_t);
   8051       if (regs.start == NULL)
   8052         return (int) REG_NOMATCH;
   8053       regs.end = regs.start + nmatch;
   8054     }
   8055 
   8056   /* Perform the searching operation.  */
   8057   ret = re_search (&private_preg, string, len,
   8058                    /* start: */ 0, /* range: */ len,
   8059                    want_reg_info ? &regs : (struct re_registers *) 0);
   8060 
   8061   /* Copy the register information to the POSIX structure.  */
   8062   if (want_reg_info)
   8063     {
   8064       if (ret >= 0)
   8065         {
   8066           unsigned r;
   8067 
   8068           for (r = 0; r < nmatch; r++)
   8069             {
   8070               pmatch[r].rm_so = regs.start[r];
   8071               pmatch[r].rm_eo = regs.end[r];
   8072             }
   8073         }
   8074 
   8075       /* If we needed the temporary register info, free the space now.  */
   8076       free (regs.start);
   8077     }
   8078 
   8079   /* We want zero return to mean success, unlike `re_search'.  */
   8080   return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
   8081 }
   8082 #ifdef _LIBC
   8083 weak_alias (__regexec, regexec)
   8084 #endif
   8085 
   8086 
   8087 /* Returns a message corresponding to an error code, ERRCODE, returned
   8088    from either regcomp or regexec.   We don't use PREG here.  */
   8089 
   8090 size_t
   8091 regerror (int errcode, const regex_t *preg ATTRIBUTE_UNUSED,
   8092           char *errbuf, size_t errbuf_size)
   8093 {
   8094   const char *msg;
   8095   size_t msg_size;
   8096 
   8097   if (errcode < 0
   8098       || errcode >= (int) (sizeof (re_error_msgid)
   8099 			   / sizeof (re_error_msgid[0])))
   8100     /* Only error codes returned by the rest of the code should be passed
   8101        to this routine.  If we are given anything else, or if other regex
   8102        code generates an invalid error code, then the program has a bug.
   8103        Dump core so we can fix it.  */
   8104     abort ();
   8105 
   8106   msg = gettext (re_error_msgid[errcode]);
   8107 
   8108   msg_size = strlen (msg) + 1; /* Includes the null.  */
   8109 
   8110   if (errbuf_size != 0)
   8111     {
   8112       if (msg_size > errbuf_size)
   8113         {
   8114 #if defined HAVE_MEMPCPY || defined _LIBC
   8115 	  *((char *) mempcpy (errbuf, msg, errbuf_size - 1)) = '\0';
   8116 #else
   8117           (void) memcpy (errbuf, msg, errbuf_size - 1);
   8118           errbuf[errbuf_size - 1] = 0;
   8119 #endif
   8120         }
   8121       else
   8122         (void) memcpy (errbuf, msg, msg_size);
   8123     }
   8124 
   8125   return msg_size;
   8126 }
   8127 #ifdef _LIBC
   8128 weak_alias (__regerror, regerror)
   8129 #endif
   8130 
   8131 
   8132 /* Free dynamically allocated space used by PREG.  */
   8133 
   8134 void
   8135 regfree (regex_t *preg)
   8136 {
   8137   free (preg->buffer);
   8138   preg->buffer = NULL;
   8139 
   8140   preg->allocated = 0;
   8141   preg->used = 0;
   8142 
   8143   free (preg->fastmap);
   8144   preg->fastmap = NULL;
   8145   preg->fastmap_accurate = 0;
   8146 
   8147   free (preg->translate);
   8148   preg->translate = NULL;
   8149 }
   8150 #ifdef _LIBC
   8151 weak_alias (__regfree, regfree)
   8152 #endif
   8153 
   8154 #endif /* not emacs  */
   8155 
   8156 #endif /* not INSIDE_RECURSION */
   8157 
   8158 
   8159 #undef STORE_NUMBER
   8161 #undef STORE_NUMBER_AND_INCR
   8162 #undef EXTRACT_NUMBER
   8163 #undef EXTRACT_NUMBER_AND_INCR
   8164 
   8165 #undef DEBUG_PRINT_COMPILED_PATTERN
   8166 #undef DEBUG_PRINT_DOUBLE_STRING
   8167 
   8168 #undef INIT_FAIL_STACK
   8169 #undef RESET_FAIL_STACK
   8170 #undef DOUBLE_FAIL_STACK
   8171 #undef PUSH_PATTERN_OP
   8172 #undef PUSH_FAILURE_POINTER
   8173 #undef PUSH_FAILURE_INT
   8174 #undef PUSH_FAILURE_ELT
   8175 #undef POP_FAILURE_POINTER
   8176 #undef POP_FAILURE_INT
   8177 #undef POP_FAILURE_ELT
   8178 #undef DEBUG_PUSH
   8179 #undef DEBUG_POP
   8180 #undef PUSH_FAILURE_POINT
   8181 #undef POP_FAILURE_POINT
   8182 
   8183 #undef REG_UNSET_VALUE
   8184 #undef REG_UNSET
   8185 
   8186 #undef PATFETCH
   8187 #undef PATFETCH_RAW
   8188 #undef PATUNFETCH
   8189 #undef TRANSLATE
   8190 
   8191 #undef INIT_BUF_SIZE
   8192 #undef GET_BUFFER_SPACE
   8193 #undef BUF_PUSH
   8194 #undef BUF_PUSH_2
   8195 #undef BUF_PUSH_3
   8196 #undef STORE_JUMP
   8197 #undef STORE_JUMP2
   8198 #undef INSERT_JUMP
   8199 #undef INSERT_JUMP2
   8200 #undef EXTEND_BUFFER
   8201 #undef GET_UNSIGNED_NUMBER
   8202 #undef FREE_STACK_RETURN
   8203 
   8204 # undef POINTER_TO_OFFSET
   8205 # undef MATCHING_IN_FRST_STRING
   8206 # undef PREFETCH
   8207 # undef AT_STRINGS_BEG
   8208 # undef AT_STRINGS_END
   8209 # undef WORDCHAR_P
   8210 # undef FREE_VAR
   8211 # undef FREE_VARIABLES
   8212 # undef NO_HIGHEST_ACTIVE_REG
   8213 # undef NO_LOWEST_ACTIVE_REG
   8214 
   8215 # undef CHAR_T
   8216 # undef UCHAR_T
   8217 # undef COMPILED_BUFFER_VAR
   8218 # undef OFFSET_ADDRESS_SIZE
   8219 # undef CHAR_CLASS_SIZE
   8220 # undef PREFIX
   8221 # undef ARG_PREFIX
   8222 # undef PUT_CHAR
   8223 # undef BYTE
   8224 # undef WCHAR
   8225 
   8226 # define DEFINED_ONCE
   8227