libiberty/regex.c

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