regex.c 171 KB
Newer Older
Karl Berry's avatar
Karl Berry committed
1
/* Extended regular expression matching and search library,
Jim Blandy's avatar
Jim Blandy committed
2
   version 0.12.
Karl Berry's avatar
Karl Berry committed
3 4 5
   (Implements POSIX draft P10003.2/D11.2, except for
   internationalization features.)

6
   Copyright (C) 1993, 1994 Free Software Foundation, Inc.
Karl Berry's avatar
Karl Berry committed
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */

/* AIX requires this to be the first thing in the file. */
#if defined (_AIX) && !defined (REGEX_MALLOC)
  #pragma alloca
#endif

#define _GNU_SOURCE

Jim Meyering's avatar
Jim Meyering committed
29 30 31 32
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

Karl Berry's avatar
Karl Berry committed
33 34 35
/* We need this for `regex.h', and perhaps for the Emacs include files.  */
#include <sys/types.h>

36 37 38 39 40 41 42 43
/* This is for other GNU distributions with internationalized messages.
   The GNU C Library itself does not yet support such messages.  */
#if HAVE_LIBINTL_H
# include <libintl.h>
#else
# define gettext(msgid) (msgid)
#endif

Karl Berry's avatar
Karl Berry committed
44 45 46 47 48 49 50 51
/* The `emacs' switch turns on certain matching commands
   that make sense only in Emacs. */
#ifdef emacs

#include "lisp.h"
#include "buffer.h"
#include "syntax.h"

52 53
#define WIDE_INT EMACS_INT

Karl Berry's avatar
Karl Berry committed
54 55
#else  /* not emacs */

Jim Blandy's avatar
Jim Blandy committed
56 57 58 59 60 61 62
#ifdef STDC_HEADERS
#include <stdlib.h>
#else
char *malloc ();
char *realloc ();
#endif

63 64 65 66
/* This isn't right--it needs to check for machines with 64-bit pointers
   and do something different.  But I don't know what, and I don't
   need to deal with it right now.  -- rms.  */
#define WIDE_INT int
Jim Blandy's avatar
Jim Blandy committed
67

Karl Berry's avatar
Karl Berry committed
68 69
/* We used to test for `BSTRING' here, but only GCC and Emacs define
   `BSTRING', as far as I know, and neither of them use this code.  */
Karl Heuer's avatar
Karl Heuer committed
70
#ifndef INHIBIT_STRING_HEADER
David J. MacKenzie's avatar
David J. MacKenzie committed
71
#if HAVE_STRING_H || STDC_HEADERS
Karl Berry's avatar
Karl Berry committed
72
#include <string.h>
Karl Berry's avatar
Karl Berry committed
73
#ifndef bcmp
Karl Berry's avatar
Karl Berry committed
74
#define bcmp(s1, s2, n)	memcmp ((s1), (s2), (n))
Karl Berry's avatar
Karl Berry committed
75 76
#endif
#ifndef bcopy
Karl Berry's avatar
Karl Berry committed
77
#define bcopy(s, d, n)	memcpy ((d), (s), (n))
Karl Berry's avatar
Karl Berry committed
78 79
#endif
#ifndef bzero
Karl Berry's avatar
Karl Berry committed
80
#define bzero(s, n)	memset ((s), 0, (n))
Karl Berry's avatar
Karl Berry committed
81
#endif
Karl Berry's avatar
Karl Berry committed
82 83 84
#else
#include <strings.h>
#endif
Karl Heuer's avatar
Karl Heuer committed
85
#endif
Karl Berry's avatar
Karl Berry committed
86 87 88 89 90 91 92 93 94

/* Define the syntax stuff for \<, \>, etc.  */

/* This must be nonzero for the wordchar and notwordchar pattern
   commands in re_match_2.  */
#ifndef Sword 
#define Sword 1
#endif

95 96 97 98 99 100
#ifdef SWITCH_ENUM_BUG
#define SWITCH_ENUM_CAST(x) ((int)(x))
#else
#define SWITCH_ENUM_CAST(x) (x)
#endif

Karl Berry's avatar
Karl Berry committed
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147
#ifdef SYNTAX_TABLE

extern char *re_syntax_table;

#else /* not SYNTAX_TABLE */

/* How many characters in the character set.  */
#define CHAR_SET_SIZE 256

static char re_syntax_table[CHAR_SET_SIZE];

static void
init_syntax_once ()
{
   register int c;
   static int done = 0;

   if (done)
     return;

   bzero (re_syntax_table, sizeof re_syntax_table);

   for (c = 'a'; c <= 'z'; c++)
     re_syntax_table[c] = Sword;

   for (c = 'A'; c <= 'Z'; c++)
     re_syntax_table[c] = Sword;

   for (c = '0'; c <= '9'; c++)
     re_syntax_table[c] = Sword;

   re_syntax_table['_'] = Sword;

   done = 1;
}

#endif /* not SYNTAX_TABLE */

#define SYNTAX(c) re_syntax_table[c]

#endif /* not emacs */

/* Get the interface, including the syntax bits.  */
#include "regex.h"

/* isalpha etc. are used for the character classes.  */
#include <ctype.h>
Jim Meyering's avatar
Jim Meyering committed
148

Jim Blandy's avatar
Jim Blandy committed
149 150 151 152 153 154 155 156 157 158
/* Jim Meyering writes:

   "... Some ctype macros are valid only for character codes that
   isascii says are ASCII (SGI's IRIX-4.0.5 is one such system --when
   using /bin/cc or gcc but without giving an ansi option).  So, all
   ctype uses should be through macros like ISPRINT...  If
   STDC_HEADERS is defined, then autoconf has verified that the ctype
   macros don't need to be guarded with references to isascii. ...
   Defining isascii to 1 should let any compiler worth its salt
   eliminate the && through constant folding."  */
Karl Heuer's avatar
Karl Heuer committed
159 160 161 162 163

#if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))
#define ISASCII(c) 1
#else
#define ISASCII(c) isascii(c)
Karl Berry's avatar
Karl Berry committed
164
#endif
Jim Meyering's avatar
Jim Meyering committed
165 166

#ifdef isblank
Karl Heuer's avatar
Karl Heuer committed
167
#define ISBLANK(c) (ISASCII (c) && isblank (c))
Jim Meyering's avatar
Jim Meyering committed
168 169
#else
#define ISBLANK(c) ((c) == ' ' || (c) == '\t')
Karl Berry's avatar
Karl Berry committed
170
#endif
Jim Meyering's avatar
Jim Meyering committed
171
#ifdef isgraph
Karl Heuer's avatar
Karl Heuer committed
172
#define ISGRAPH(c) (ISASCII (c) && isgraph (c))
Jim Meyering's avatar
Jim Meyering committed
173
#else
Karl Heuer's avatar
Karl Heuer committed
174
#define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
Jim Meyering's avatar
Jim Meyering committed
175 176
#endif

Karl Heuer's avatar
Karl Heuer committed
177 178 179 180 181 182 183 184 185 186
#define ISPRINT(c) (ISASCII (c) && isprint (c))
#define ISDIGIT(c) (ISASCII (c) && isdigit (c))
#define ISALNUM(c) (ISASCII (c) && isalnum (c))
#define ISALPHA(c) (ISASCII (c) && isalpha (c))
#define ISCNTRL(c) (ISASCII (c) && iscntrl (c))
#define ISLOWER(c) (ISASCII (c) && islower (c))
#define ISPUNCT(c) (ISASCII (c) && ispunct (c))
#define ISSPACE(c) (ISASCII (c) && isspace (c))
#define ISUPPER(c) (ISASCII (c) && isupper (c))
#define ISXDIGIT(c) (ISASCII (c) && isxdigit (c))
Karl Berry's avatar
Karl Berry committed
187 188 189 190 191 192 193 194 195 196 197 198

#ifndef NULL
#define NULL 0
#endif

/* We remove any previous definition of `SIGN_EXTEND_CHAR',
   since ours (we hope) works properly with all combinations of
   machines, compilers, `char' and `unsigned char' argument types.
   (Per Bothner suggested the basic approach.)  */
#undef SIGN_EXTEND_CHAR
#if __STDC__
#define SIGN_EXTEND_CHAR(c) ((signed char) (c))
Karl Berry's avatar
Karl Berry committed
199
#else  /* not __STDC__ */
Karl Berry's avatar
Karl Berry committed
200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
/* As in Harbison and Steele.  */
#define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
#endif

/* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we
   use `alloca' instead of `malloc'.  This is because using malloc in
   re_search* or re_match* could cause memory leaks when C-g is used in
   Emacs; also, malloc is slower and causes storage fragmentation.  On
   the other hand, malloc is more portable, and easier to debug.  
   
   Because we sometimes use alloca, some routines have to be macros,
   not functions -- `alloca'-allocated space disappears at the end of the
   function it is called in.  */

#ifdef REGEX_MALLOC

#define REGEX_ALLOCATE malloc
#define REGEX_REALLOCATE(source, osize, nsize) realloc (source, nsize)
218
#define REGEX_FREE free
Karl Berry's avatar
Karl Berry committed
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247

#else /* not REGEX_MALLOC  */

/* Emacs already defines alloca, sometimes.  */
#ifndef alloca

/* Make alloca work the best possible way.  */
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not __GNUC__ */
#if HAVE_ALLOCA_H
#include <alloca.h>
#else /* not __GNUC__ or HAVE_ALLOCA_H */
#ifndef _AIX /* Already did AIX, up at the top.  */
char *alloca ();
#endif /* not _AIX */
#endif /* not HAVE_ALLOCA_H */ 
#endif /* not __GNUC__ */

#endif /* not alloca */

#define REGEX_ALLOCATE alloca

/* Assumes a `char *destination' variable.  */
#define REGEX_REALLOCATE(source, osize, nsize)				\
  (destination = (char *) alloca (nsize),				\
   bcopy (source, destination, osize),					\
   destination)

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
/* No need to do anything to free, after alloca.  */
#define REGEX_FREE(arg) (0)

#endif /* not REGEX_MALLOC */

/* Define how to allocate the failure stack.  */

#ifdef REL_ALLOC
#define REGEX_ALLOCATE_STACK(size)				\
  r_alloc (&failure_stack_ptr, (size))
#define REGEX_REALLOCATE_STACK(source, osize, nsize)		\
  r_re_alloc (&failure_stack_ptr, (nsize))
#define REGEX_FREE_STACK(ptr)					\
  r_alloc_free (&failure_stack_ptr)

#else /* not REL_ALLOC */

#ifdef REGEX_MALLOC

#define REGEX_ALLOCATE_STACK malloc
#define REGEX_REALLOCATE_STACK(source, osize, nsize) realloc (source, nsize)
#define REGEX_FREE_STACK free

#else /* not REGEX_MALLOC */

#define REGEX_ALLOCATE_STACK alloca

#define REGEX_REALLOCATE_STACK(source, osize, nsize)			\
   REGEX_REALLOCATE (source, osize, nsize)
/* No need to explicitly free anything.  */
#define REGEX_FREE_STACK(arg)

Karl Berry's avatar
Karl Berry committed
280
#endif /* not REGEX_MALLOC */
281
#endif /* not REL_ALLOC */
Karl Berry's avatar
Karl Berry committed
282 283 284 285 286 287 288 289 290 291 292


/* True if `size1' is non-NULL and PTR is pointing anywhere inside
   `string1' or just past its end.  This works if PTR is NULL, which is
   a good thing.  */
#define FIRST_STRING_P(ptr) 					\
  (size1 && string1 <= (ptr) && (ptr) <= string1 + size1)

/* (Re)Allocate N items of type T using malloc, or fail.  */
#define TALLOC(n, t) ((t *) malloc ((n) * sizeof (t)))
#define RETALLOC(addr, n, t) ((addr) = (t *) realloc (addr, (n) * sizeof (t)))
Jim Blandy's avatar
Jim Blandy committed
293 294
#define RETALLOC_IF(addr, n, t) \
  if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
Karl Berry's avatar
Karl Berry committed
295 296 297 298 299 300
#define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))

#define BYTEWIDTH 8 /* In bits.  */

#define STREQ(s1, s2) ((strcmp (s1, s2) == 0))

Karl Heuer's avatar
Karl Heuer committed
301 302
#undef MAX
#undef MIN
Karl Berry's avatar
Karl Berry committed
303 304 305 306 307 308
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

typedef char boolean;
#define false 0
#define true 1
Karl Heuer's avatar
Karl Heuer committed
309 310

static int re_match_2_internal ();
Karl Berry's avatar
Karl Berry committed
311 312 313 314

/* These are the command codes that appear in compiled regular
   expressions.  Some opcodes are followed by argument bytes.  A
   command code can specify any interpretation whatsoever for its
Karl Heuer's avatar
Karl Heuer committed
315
   arguments.  Zero bytes may appear in the compiled regular expression.  */
Karl Berry's avatar
Karl Berry committed
316 317 318 319 320

typedef enum
{
  no_op = 0,

321 322 323
  /* Succeed right away--no more backtracking.  */
  succeed,

Karl Berry's avatar
Karl Berry committed
324
        /* Followed by one byte giving n, then by n literal bytes.  */
Karl Heuer's avatar
Karl Heuer committed
325
  exactn,
Karl Berry's avatar
Karl Berry committed
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544

        /* Matches any (more or less) character.  */
  anychar,

        /* Matches any one char belonging to specified set.  First
           following byte is number of bitmap bytes.  Then come bytes
           for a bitmap saying which chars are in.  Bits in each byte
           are ordered low-bit-first.  A character is in the set if its
           bit is 1.  A character too large to have a bit in the map is
           automatically not in the set.  */
  charset,

        /* Same parameters as charset, but match any character that is
           not one of those specified.  */
  charset_not,

        /* Start remembering the text that is matched, for storing in a
           register.  Followed by one byte with the register number, in
           the range 0 to one less than the pattern buffer's re_nsub
           field.  Then followed by one byte with the number of groups
           inner to this one.  (This last has to be part of the
           start_memory only because we need it in the on_failure_jump
           of re_match_2.)  */
  start_memory,

        /* Stop remembering the text that is matched and store it in a
           memory register.  Followed by one byte with the register
           number, in the range 0 to one less than `re_nsub' in the
           pattern buffer, and one byte with the number of inner groups,
           just like `start_memory'.  (We need the number of inner
           groups here because we don't have any easy way of finding the
           corresponding start_memory when we're at a stop_memory.)  */
  stop_memory,

        /* Match a duplicate of something remembered. Followed by one
           byte containing the register number.  */
  duplicate,

        /* Fail unless at beginning of line.  */
  begline,

        /* Fail unless at end of line.  */
  endline,

        /* Succeeds if at beginning of buffer (if emacs) or at beginning
           of string to be matched (if not).  */
  begbuf,

        /* Analogously, for end of buffer/string.  */
  endbuf,
 
        /* Followed by two byte relative address to which to jump.  */
  jump, 

	/* Same as jump, but marks the end of an alternative.  */
  jump_past_alt,

        /* Followed by two-byte relative address of place to resume at
           in case of failure.  */
  on_failure_jump,
	
        /* Like on_failure_jump, but pushes a placeholder instead of the
           current string position when executed.  */
  on_failure_keep_string_jump,
  
        /* Throw away latest failure point and then jump to following
           two-byte relative address.  */
  pop_failure_jump,

        /* Change to pop_failure_jump if know won't have to backtrack to
           match; otherwise change to jump.  This is used to jump
           back to the beginning of a repeat.  If what follows this jump
           clearly won't match what the repeat does, such that we can be
           sure that there is no use backtracking out of repetitions
           already matched, then we change it to a pop_failure_jump.
           Followed by two-byte address.  */
  maybe_pop_jump,

        /* Jump to following two-byte address, and push a dummy failure
           point. This failure point will be thrown away if an attempt
           is made to use it for a failure.  A `+' construct makes this
           before the first repeat.  Also used as an intermediary kind
           of jump when compiling an alternative.  */
  dummy_failure_jump,

	/* Push a dummy failure point and continue.  Used at the end of
	   alternatives.  */
  push_dummy_failure,

        /* Followed by two-byte relative address and two-byte number n.
           After matching N times, jump to the address upon failure.  */
  succeed_n,

        /* Followed by two-byte relative address, and two-byte number n.
           Jump to the address N times, then fail.  */
  jump_n,

        /* Set the following two-byte relative address to the
           subsequent two-byte number.  The address *includes* the two
           bytes of number.  */
  set_number_at,

  wordchar,	/* Matches any word-constituent character.  */
  notwordchar,	/* Matches any char that is not a word-constituent.  */

  wordbeg,	/* Succeeds if at word beginning.  */
  wordend,	/* Succeeds if at word end.  */

  wordbound,	/* Succeeds if at a word boundary.  */
  notwordbound	/* Succeeds if not at a word boundary.  */

#ifdef emacs
  ,before_dot,	/* Succeeds if before point.  */
  at_dot,	/* Succeeds if at point.  */
  after_dot,	/* Succeeds if after point.  */

	/* Matches any character whose syntax is specified.  Followed by
           a byte which contains a syntax code, e.g., Sword.  */
  syntaxspec,

	/* Matches any character whose syntax is not that specified.  */
  notsyntaxspec
#endif /* emacs */
} re_opcode_t;

/* Common operations on the compiled pattern.  */

/* Store NUMBER in two contiguous bytes starting at DESTINATION.  */

#define STORE_NUMBER(destination, number)				\
  do {									\
    (destination)[0] = (number) & 0377;					\
    (destination)[1] = (number) >> 8;					\
  } while (0)

/* Same as STORE_NUMBER, except increment DESTINATION to
   the byte after where the number is stored.  Therefore, DESTINATION
   must be an lvalue.  */

#define STORE_NUMBER_AND_INCR(destination, number)			\
  do {									\
    STORE_NUMBER (destination, number);					\
    (destination) += 2;							\
  } while (0)

/* Put into DESTINATION a number stored in two contiguous bytes starting
   at SOURCE.  */

#define EXTRACT_NUMBER(destination, source)				\
  do {									\
    (destination) = *(source) & 0377;					\
    (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8;		\
  } while (0)

#ifdef DEBUG
static void
extract_number (dest, source)
    int *dest;
    unsigned char *source;
{
  int temp = SIGN_EXTEND_CHAR (*(source + 1)); 
  *dest = *source & 0377;
  *dest += temp << 8;
}

#ifndef EXTRACT_MACROS /* To debug the macros.  */
#undef EXTRACT_NUMBER
#define EXTRACT_NUMBER(dest, src) extract_number (&dest, src)
#endif /* not EXTRACT_MACROS */

#endif /* DEBUG */

/* Same as EXTRACT_NUMBER, except increment SOURCE to after the number.
   SOURCE must be an lvalue.  */

#define EXTRACT_NUMBER_AND_INCR(destination, source)			\
  do {									\
    EXTRACT_NUMBER (destination, source);				\
    (source) += 2; 							\
  } while (0)

#ifdef DEBUG
static void
extract_number_and_incr (destination, source)
    int *destination;
    unsigned char **source;
{ 
  extract_number (destination, *source);
  *source += 2;
}

#ifndef EXTRACT_MACROS
#undef EXTRACT_NUMBER_AND_INCR
#define EXTRACT_NUMBER_AND_INCR(dest, src) \
  extract_number_and_incr (&dest, &src)
#endif /* not EXTRACT_MACROS */

#endif /* DEBUG */

/* If DEBUG is defined, Regex prints many voluminous messages about what
   it is doing (if the variable `debug' is nonzero).  If linked with the
   main program in `iregex.c', you can enter patterns and strings
   interactively.  And if linked with the main program in `main.c' and
   the other test files, you can run the already-written tests.  */

#ifdef DEBUG

/* We use standard I/O for debugging.  */
#include <stdio.h>

/* It is useful to test things that ``must'' be true when debugging.  */
#include <assert.h>

static int debug = 0;

#define DEBUG_STATEMENT(e) e
#define DEBUG_PRINT1(x) if (debug) printf (x)
#define DEBUG_PRINT2(x1, x2) if (debug) printf (x1, x2)
#define DEBUG_PRINT3(x1, x2, x3) if (debug) printf (x1, x2, x3)
Karl Berry's avatar
Karl Berry committed
545
#define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
Karl Berry's avatar
Karl Berry committed
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) 				\
  if (debug) print_partial_compiled_pattern (s, e)
#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)			\
  if (debug) print_double_string (w, s1, sz1, s2, sz2)


/* Print the fastmap in human-readable form.  */

void
print_fastmap (fastmap)
    char *fastmap;
{
  unsigned was_a_range = 0;
  unsigned i = 0;  
  
  while (i < (1 << BYTEWIDTH))
    {
      if (fastmap[i++])
	{
	  was_a_range = 0;
566
          putchar (i - 1);
Karl Berry's avatar
Karl Berry committed
567 568 569 570 571 572 573 574
          while (i < (1 << BYTEWIDTH)  &&  fastmap[i])
            {
              was_a_range = 1;
              i++;
            }
	  if (was_a_range)
            {
              printf ("-");
575
              putchar (i - 1);
Karl Berry's avatar
Karl Berry committed
576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
            }
        }
    }
  putchar ('\n'); 
}


/* Print a compiled pattern string in human-readable form, starting at
   the START pointer into it and ending just before the pointer END.  */

void
print_partial_compiled_pattern (start, end)
    unsigned char *start;
    unsigned char *end;
{
  int mcnt, mcnt2;
  unsigned char *p = start;
  unsigned char *pend = end;

  if (start == NULL)
    {
      printf ("(null)\n");
      return;
    }
    
  /* Loop over pattern commands.  */
  while (p < pend)
    {
Jim Blandy's avatar
Jim Blandy committed
604 605
      printf ("%d:\t", p - start);

Karl Berry's avatar
Karl Berry committed
606 607 608 609 610 611 612 613 614 615 616 617
      switch ((re_opcode_t) *p++)
	{
        case no_op:
          printf ("/no_op");
          break;

	case exactn:
	  mcnt = *p++;
          printf ("/exactn/%d", mcnt);
          do
	    {
              putchar ('/');
618
	      putchar (*p++);
Karl Berry's avatar
Karl Berry committed
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
            }
          while (--mcnt);
          break;

	case start_memory:
          mcnt = *p++;
          printf ("/start_memory/%d/%d", mcnt, *p++);
          break;

	case stop_memory:
          mcnt = *p++;
	  printf ("/stop_memory/%d/%d", mcnt, *p++);
          break;

	case duplicate:
	  printf ("/duplicate/%d", *p++);
	  break;

	case anychar:
	  printf ("/anychar");
	  break;

	case charset:
        case charset_not:
          {
Jim Blandy's avatar
Jim Blandy committed
644 645
            register int c, last = -100;
	    register int in_range = 0;
Karl Berry's avatar
Karl Berry committed
646

Jim Blandy's avatar
Jim Blandy committed
647 648
	    printf ("/charset [%s",
	            (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
Karl Berry's avatar
Karl Berry committed
649 650 651
            
            assert (p + *p < pend);

Jim Blandy's avatar
Jim Blandy committed
652 653 654 655 656 657 658 659 660 661 662 663
            for (c = 0; c < 256; c++)
	      if (c / 8 < *p
		  && (p[1 + (c/8)] & (1 << (c % 8))))
		{
		  /* Are we starting a range?  */
		  if (last + 1 == c && ! in_range)
		    {
		      putchar ('-');
		      in_range = 1;
		    }
		  /* Have we broken a range?  */
		  else if (last + 1 != c && in_range)
Karl Berry's avatar
Karl Berry committed
664
              {
665
		      putchar (last);
Jim Blandy's avatar
Jim Blandy committed
666 667
		      in_range = 0;
		    }
Karl Berry's avatar
Karl Berry committed
668
                
Jim Blandy's avatar
Jim Blandy committed
669
		  if (! in_range)
670
		    putchar (c);
Karl Berry's avatar
Karl Berry committed
671

Jim Blandy's avatar
Jim Blandy committed
672
		  last = c;
Karl Berry's avatar
Karl Berry committed
673
              }
Jim Blandy's avatar
Jim Blandy committed
674 675

	    if (in_range)
676
	      putchar (last);
Jim Blandy's avatar
Jim Blandy committed
677 678 679

	    putchar (']');

Karl Berry's avatar
Karl Berry committed
680 681
	    p += 1 + *p;
	  }
Jim Blandy's avatar
Jim Blandy committed
682
	  break;
Karl Berry's avatar
Karl Berry committed
683 684 685 686 687 688 689 690 691 692 693

	case begline:
	  printf ("/begline");
          break;

	case endline:
          printf ("/endline");
          break;

	case on_failure_jump:
          extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
694
  	  printf ("/on_failure_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
695 696 697 698
          break;

	case on_failure_keep_string_jump:
          extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
699
  	  printf ("/on_failure_keep_string_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
700 701 702 703
          break;

	case dummy_failure_jump:
          extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
704
  	  printf ("/dummy_failure_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
705 706 707 708 709 710 711 712
          break;

	case push_dummy_failure:
          printf ("/push_dummy_failure");
          break;
          
        case maybe_pop_jump:
          extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
713
  	  printf ("/maybe_pop_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
714 715 716 717
	  break;

        case pop_failure_jump:
	  extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
718
  	  printf ("/pop_failure_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
719 720 721 722
	  break;          
          
        case jump_past_alt:
	  extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
723
  	  printf ("/jump_past_alt to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
724 725 726 727
	  break;          
          
        case jump:
	  extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
728
  	  printf ("/jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
729 730 731 732 733
	  break;

        case succeed_n: 
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
Jim Blandy's avatar
Jim Blandy committed
734
	  printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2);
Karl Berry's avatar
Karl Berry committed
735 736 737 738 739
          break;
        
        case jump_n: 
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
Jim Blandy's avatar
Jim Blandy committed
740
	  printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2);
Karl Berry's avatar
Karl Berry committed
741 742 743 744 745
          break;
        
        case set_number_at: 
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
Jim Blandy's avatar
Jim Blandy committed
746
	  printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2);
Karl Berry's avatar
Karl Berry committed
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
          break;
        
        case wordbound:
	  printf ("/wordbound");
	  break;

	case notwordbound:
	  printf ("/notwordbound");
          break;

	case wordbeg:
	  printf ("/wordbeg");
	  break;
          
	case wordend:
	  printf ("/wordend");
          
#ifdef emacs
	case before_dot:
	  printf ("/before_dot");
          break;

	case at_dot:
	  printf ("/at_dot");
          break;

	case after_dot:
	  printf ("/after_dot");
          break;

	case syntaxspec:
          printf ("/syntaxspec");
	  mcnt = *p++;
	  printf ("/%d", mcnt);
          break;
	  
	case notsyntaxspec:
          printf ("/notsyntaxspec");
	  mcnt = *p++;
	  printf ("/%d", mcnt);
	  break;
#endif /* emacs */

	case wordchar:
	  printf ("/wordchar");
          break;
	  
	case notwordchar:
	  printf ("/notwordchar");
          break;

	case begbuf:
	  printf ("/begbuf");
          break;

	case endbuf:
	  printf ("/endbuf");
          break;

        default:
          printf ("?%d", *(p-1));
	}
Jim Blandy's avatar
Jim Blandy committed
809 810

      putchar ('\n');
Karl Berry's avatar
Karl Berry committed
811
    }
Jim Blandy's avatar
Jim Blandy committed
812 813

  printf ("%d:\tend of pattern.\n", p - start);
Karl Berry's avatar
Karl Berry committed
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
}


void
print_compiled_pattern (bufp)
    struct re_pattern_buffer *bufp;
{
  unsigned char *buffer = bufp->buffer;

  print_partial_compiled_pattern (buffer, buffer + bufp->used);
  printf ("%d bytes used/%d bytes allocated.\n", bufp->used, bufp->allocated);

  if (bufp->fastmap_accurate && bufp->fastmap)
    {
      printf ("fastmap: ");
      print_fastmap (bufp->fastmap);
    }

  printf ("re_nsub: %d\t", bufp->re_nsub);
  printf ("regs_alloc: %d\t", bufp->regs_allocated);
  printf ("can_be_null: %d\t", bufp->can_be_null);
  printf ("newline_anchor: %d\n", bufp->newline_anchor);
  printf ("no_sub: %d\t", bufp->no_sub);
  printf ("not_bol: %d\t", bufp->not_bol);
  printf ("not_eol: %d\t", bufp->not_eol);
  printf ("syntax: %d\n", bufp->syntax);
  /* Perhaps we should print the translate table?  */
}


void
print_double_string (where, string1, size1, string2, size2)
    const char *where;
    const char *string1;
    const char *string2;
    int size1;
    int size2;
{
  unsigned this_char;
  
  if (where == NULL)
    printf ("(null)");
  else
    {
      if (FIRST_STRING_P (where))
        {
          for (this_char = where - string1; this_char < size1; this_char++)
861
            putchar (string1[this_char]);
Karl Berry's avatar
Karl Berry committed
862 863 864 865 866

          where = string2;    
        }

      for (this_char = where - string2; this_char < size2; this_char++)
867
        putchar (string2[this_char]);
Karl Berry's avatar
Karl Berry committed
868 869 870 871 872 873 874 875 876 877 878 879
    }
}

#else /* not DEBUG */

#undef assert
#define assert(e)

#define DEBUG_STATEMENT(e)
#define DEBUG_PRINT1(x)
#define DEBUG_PRINT2(x1, x2)
#define DEBUG_PRINT3(x1, x2, x3)
Karl Berry's avatar
Karl Berry committed
880
#define DEBUG_PRINT4(x1, x2, x3, x4)
Karl Berry's avatar
Karl Berry committed
881 882 883 884 885 886 887 888
#define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
#define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)

#endif /* not DEBUG */

/* Set by `re_set_syntax' to the current regexp syntax to recognize.  Can
   also be assigned to arbitrarily: each pattern buffer stores its own
   syntax, so it can be changed between regex compilations.  */
889 890 891
/* This has no initializer because initialized variables in Emacs
   become read-only after dumping.  */
reg_syntax_t re_syntax_options;
Karl Berry's avatar
Karl Berry committed
892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911


/* Specify the precise syntax of regexps for compilation.  This provides
   for compatibility for various utilities which historically have
   different, incompatible syntaxes.

   The argument SYNTAX is a bit mask comprised of the various bits
   defined in regex.h.  We return the old syntax.  */

reg_syntax_t
re_set_syntax (syntax)
    reg_syntax_t syntax;
{
  reg_syntax_t ret = re_syntax_options;
  
  re_syntax_options = syntax;
  return ret;
}

/* This table gives an error message for each of the error codes listed
912 913 914
   in regex.h.  Obviously the order here has to be same as there.
   POSIX doesn't require that we do anything for REG_NOERROR,
   but why not be nice?  */
Karl Berry's avatar
Karl Berry committed
915

916 917
static const char *re_error_msgid[] =
  { "Success",					/* REG_NOERROR */
Karl Berry's avatar
Karl Berry committed
918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
    "No match",					/* REG_NOMATCH */
    "Invalid regular expression",		/* REG_BADPAT */
    "Invalid collation character",		/* REG_ECOLLATE */
    "Invalid character class name",		/* REG_ECTYPE */
    "Trailing backslash",			/* REG_EESCAPE */
    "Invalid back reference",			/* REG_ESUBREG */
    "Unmatched [ or [^",			/* REG_EBRACK */
    "Unmatched ( or \\(",			/* REG_EPAREN */
    "Unmatched \\{",				/* REG_EBRACE */
    "Invalid content of \\{\\}",		/* REG_BADBR */
    "Invalid range end",			/* REG_ERANGE */
    "Memory exhausted",				/* REG_ESPACE */
    "Invalid preceding regular expression",	/* REG_BADRPT */
    "Premature end of regular expression",	/* REG_EEND */
    "Regular expression too big",		/* REG_ESIZE */
    "Unmatched ) or \\)",			/* REG_ERPAREN */
  };

Jim Blandy's avatar
Jim Blandy committed
936 937
/* Avoiding alloca during matching, to placate r_alloc.  */

Karl Heuer's avatar
Karl Heuer committed
938
/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
Jim Blandy's avatar
Jim Blandy committed
939 940 941 942 943
   searching and matching functions should not call alloca.  On some
   systems, alloca is implemented in terms of malloc, and if we're
   using the relocating allocator routines, then malloc could cause a
   relocation, which might (if the strings being searched are in the
   ralloc heap) shift the data out from underneath the regexp
Jim Blandy's avatar
Jim Blandy committed
944 945
   routines.

946 947
   Here's another reason to avoid allocation: Emacs 
   processes input from X in a signal handler; processing X input may
Jim Blandy's avatar
Jim Blandy committed
948 949 950 951 952 953
   call malloc; if input arrives while a matching routine is calling
   malloc, then we're scrod.  But Emacs can't just block input while
   calling matching routines; then we don't notice interrupts when
   they come in.  So, Emacs blocks input around all regexp calls
   except the matching calls, which it leaves unprotected, in the
   faith that they will not malloc.  */
Jim Blandy's avatar
Jim Blandy committed
954 955 956 957

/* Normally, this is fine.  */
#define MATCH_MAY_ALLOCATE

958 959 960 961 962 963
/* When using GNU C, we are not REALLY using the C alloca, no matter
   what config.h may say.  So don't take precautions for it.  */
#ifdef __GNUC__
#undef C_ALLOCA
#endif

964
/* The match routines may not allocate if (1) they would do it with malloc
Karl Heuer's avatar
Karl Heuer committed
965
   and (2) it's not safe for them to use malloc.  */
966
#if (defined (C_ALLOCA) || defined (REGEX_MALLOC)) && (defined (emacs) || defined (REL_ALLOC))
Jim Blandy's avatar
Jim Blandy committed
967
#undef MATCH_MAY_ALLOCATE
Jim Blandy's avatar
Jim Blandy committed
968
#endif
Karl Berry's avatar
Karl Berry committed
969

Jim Blandy's avatar
Jim Blandy committed
970 971 972

/* Failure stack declarations and macros; both re_compile_fastmap and
   re_match_2 use a failure stack.  These have to be macros because of
973
   REGEX_ALLOCATE_STACK.  */
Jim Blandy's avatar
Jim Blandy committed
974
   
Karl Berry's avatar
Karl Berry committed
975

Jim Blandy's avatar
Jim Blandy committed
976 977 978 979 980 981
/* Number of failure points for which to initially allocate space
   when matching.  If this number is exceeded, we allocate more
   space, so it is not a hard limit.  */
#ifndef INIT_FAILURE_ALLOC
#define INIT_FAILURE_ALLOC 5
#endif
Karl Berry's avatar
Karl Berry committed
982

Jim Blandy's avatar
Jim Blandy committed
983 984 985 986
/* Roughly the maximum number of failure points on the stack.  Would be
   exactly that if always used MAX_FAILURE_SPACE each time we failed.
   This is a variable only so users of regex can assign to it; we never
   change it ourselves.  */
987 988 989
#ifdef REL_ALLOC
int re_max_failures = 20000000;
#else
Jim Blandy's avatar
Jim Blandy committed
990
int re_max_failures = 2000;
991
#endif
Karl Berry's avatar
Karl Berry committed
992

993
typedef unsigned char *fail_stack_elt_t;
Karl Berry's avatar
Karl Berry committed
994

Jim Blandy's avatar
Jim Blandy committed
995 996 997 998 999 1000
typedef struct
{
  fail_stack_elt_t *stack;
  unsigned size;
  unsigned avail;			/* Offset of next open position.  */
} fail_stack_type;
Karl Berry's avatar
Karl Berry committed
1001

Jim Blandy's avatar
Jim Blandy committed
1002 1003 1004 1005
#define FAIL_STACK_EMPTY()     (fail_stack.avail == 0)
#define FAIL_STACK_PTR_EMPTY() (fail_stack_ptr->avail == 0)
#define FAIL_STACK_FULL()      (fail_stack.avail == fail_stack.size)
#define FAIL_STACK_TOP()       (fail_stack.stack[fail_stack.avail])
Karl Berry's avatar
Karl Berry committed
1006 1007


Jim Blandy's avatar
Jim Blandy committed
1008
/* Initialize `fail_stack'.  Do `return -2' if the alloc fails.  */
Karl Berry's avatar
Karl Berry committed
1009

Jim Blandy's avatar
Jim Blandy committed
1010
#ifdef MATCH_MAY_ALLOCATE
Jim Blandy's avatar
Jim Blandy committed
1011
#define INIT_FAIL_STACK()						\
Karl Berry's avatar
Karl Berry committed
1012
  do {									\
Jim Blandy's avatar
Jim Blandy committed
1013
    fail_stack.stack = (fail_stack_elt_t *)				\
1014
      REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t));	\
Jim Blandy's avatar
Jim Blandy committed
1015 1016 1017 1018 1019 1020
									\
    if (fail_stack.stack == NULL)					\
      return -2;							\
									\
    fail_stack.size = INIT_FAILURE_ALLOC;				\
    fail_stack.avail = 0;						\
Karl Berry's avatar
Karl Berry committed
1021
  } while (0)
Jim Blandy's avatar
Jim Blandy committed
1022 1023
#else
#define INIT_FAIL_STACK()						\
Karl Berry's avatar
Karl Berry committed
1024
  do {									\
Jim Blandy's avatar
Jim Blandy committed
1025
    fail_stack.avail = 0;						\
Karl Berry's avatar
Karl Berry committed
1026
  } while (0)
Jim Blandy's avatar
Jim Blandy committed
1027
#endif
Karl Berry's avatar
Karl Berry committed
1028 1029


Jim Blandy's avatar
Jim Blandy committed
1030
/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.
Karl Berry's avatar
Karl Berry committed
1031

Jim Blandy's avatar
Jim Blandy committed
1032 1033 1034
   Return 1 if succeeds, and 0 if either ran out of memory
   allocating space for it or it was already too large.  
   
1035
   REGEX_REALLOCATE_STACK requires `destination' be declared.   */
Karl Berry's avatar
Karl Berry committed
1036

Jim Blandy's avatar
Jim Blandy committed
1037 1038 1039 1040
#define DOUBLE_FAIL_STACK(fail_stack)					\
  ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS		\
   ? 0									\
   : ((fail_stack).stack = (fail_stack_elt_t *)				\
1041
        REGEX_REALLOCATE_STACK ((fail_stack).stack, 			\
Jim Blandy's avatar
Jim Blandy committed
1042 1043 1044 1045 1046 1047 1048
          (fail_stack).size * sizeof (fail_stack_elt_t),		\
          ((fail_stack).size << 1) * sizeof (fail_stack_elt_t)),	\
									\
      (fail_stack).stack == NULL					\
      ? 0								\
      : ((fail_stack).size <<= 1, 					\
         1)))
Karl Berry's avatar
Karl Berry committed
1049 1050


Jim Blandy's avatar
Jim Blandy committed
1051
/* Push PATTERN_OP on FAIL_STACK. 
Karl Berry's avatar
Karl Berry committed
1052

Jim Blandy's avatar
Jim Blandy committed
1053 1054 1055 1056 1057
   Return 1 if was able to do so and 0 if ran out of memory allocating
   space to do so.  */
#define PUSH_PATTERN_OP(pattern_op, fail_stack)				\
  ((FAIL_STACK_FULL ()							\
    && !DOUBLE_FAIL_STACK (fail_stack))					\
1058 1059 1060
   ? 0									\
   : ((fail_stack).stack[(fail_stack).avail++] = pattern_op,		\
      1))
Karl Berry's avatar
Karl Berry committed
1061

1062 1063
/* Push a pointer value onto the failure stack.
   Assumes the variable `fail_stack'.  Probably should only
Jim Blandy's avatar
Jim Blandy committed
1064
   be called from within `PUSH_FAILURE_POINT'.  */
1065 1066 1067 1068 1069 1070 1071
#define PUSH_FAILURE_POINTER(item)					\
  fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) (item)

/* This pushes an integer-valued item onto the failure stack.
   Assumes the variable `fail_stack'.  Probably should only
   be called from within `PUSH_FAILURE_POINT'.  */
#define PUSH_FAILURE_INT(item)					\
1072
  fail_stack.stack[fail_stack.avail++] = (fail_stack_elt_t) (WIDE_INT) (item)
1073 1074 1075

/* The complement operation.  Assumes `fail_stack' is nonempty.  */
#define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail]
Karl Berry's avatar
Karl Berry committed
1076

Jim Blandy's avatar
Jim Blandy committed
1077
/* The complement operation.  Assumes `fail_stack' is nonempty.  */
1078
#define POP_FAILURE_INT() (WIDE_INT) fail_stack.stack[--fail_stack.avail]
Karl Berry's avatar
Karl Berry committed
1079

Jim Blandy's avatar
Jim Blandy committed
1080 1081
/* Used to omit pushing failure point id's when we're not debugging.  */
#ifdef DEBUG
1082 1083
#define DEBUG_PUSH PUSH_FAILURE_INT
#define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT ()
Jim Blandy's avatar
Jim Blandy committed
1084 1085 1086 1087
#else
#define DEBUG_PUSH(item)
#define DEBUG_POP(item_addr)
#endif
Karl Berry's avatar
Karl Berry committed
1088 1089


Jim Blandy's avatar
Jim Blandy committed
1090 1091 1092 1093 1094 1095 1096 1097
/* Push the information about the state we will need
   if we ever fail back to it.  
   
   Requires variables fail_stack, regstart, regend, reg_info, and
   num_regs be declared.  DOUBLE_FAIL_STACK requires `destination' be
   declared.
   
   Does `return FAILURE_CODE' if runs out of memory.  */
Karl Berry's avatar
Karl Berry committed
1098

Jim Blandy's avatar
Jim Blandy committed
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
#define PUSH_FAILURE_POINT(pattern_place, string_place, failure_code)	\
  do {									\
    char *destination;							\
    /* Must be int, so when we don't save any registers, the arithmetic	\
       of 0 + -1 isn't done as unsigned.  */				\
    int this_reg;							\
    									\
    DEBUG_STATEMENT (failure_id++);					\
    DEBUG_STATEMENT (nfailure_points_pushed++);				\
    DEBUG_PRINT2 ("\nPUSH_FAILURE_POINT #%u:\n", failure_id);		\
    DEBUG_PRINT2 ("  Before push, next avail: %d\n", (fail_stack).avail);\
    DEBUG_PRINT2 ("                     size: %d\n", (fail_stack).size);\
									\
    DEBUG_PRINT2 ("  slots needed: %d\n", NUM_FAILURE_ITEMS);		\
    DEBUG_PRINT2 ("     available: %d\n", REMAINING_AVAIL_SLOTS);	\
									\
    /* Ensure we have enough space allocated for what we will push.  */	\
    while (REMAINING_AVAIL_SLOTS < NUM_FAILURE_ITEMS)			\
      {									\
1118
        if (!DOUBLE_FAIL_STACK (fail_stack))				\
Jim Blandy's avatar
Jim Blandy committed
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135
          return failure_code;						\
									\
        DEBUG_PRINT2 ("\n  Doubled stack; size now: %d\n",		\
		       (fail_stack).size);				\
        DEBUG_PRINT2 ("  slots available: %d\n", REMAINING_AVAIL_SLOTS);\
      }									\
									\
    /* Push the info, starting with the registers.  */			\
    DEBUG_PRINT1 ("\n");						\
									\
    for (this_reg = lowest_active_reg; this_reg <= highest_active_reg;	\
         this_reg++)							\
      {									\
	DEBUG_PRINT2 ("  Pushing reg: %d\n", this_reg);			\
        DEBUG_STATEMENT (num_regs_pushed++);				\
									\
	DEBUG_PRINT2 ("    start: 0x%x\n", regstart[this_reg]);		\
1136
        PUSH_FAILURE_POINTER (regstart[this_reg]);			\
Jim Blandy's avatar
Jim Blandy committed
1137 1138
                                                                        \
	DEBUG_PRINT2 ("    end: 0x%x\n", regend[this_reg]);		\
1139
        PUSH_FAILURE_POINTER (regend[this_reg]);			\
Jim Blandy's avatar
Jim Blandy committed
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
									\
	DEBUG_PRINT2 ("    info: 0x%x\n      ", reg_info[this_reg]);	\
        DEBUG_PRINT2 (" match_null=%d",					\
                      REG_MATCH_NULL_STRING_P (reg_info[this_reg]));	\
        DEBUG_PRINT2 (" active=%d", IS_ACTIVE (reg_info[this_reg]));	\
        DEBUG_PRINT2 (" matched_something=%d",				\
                      MATCHED_SOMETHING (reg_info[this_reg]));		\
        DEBUG_PRINT2 (" ever_matched=%d",				\
                      EVER_MATCHED_SOMETHING (reg_info[this_reg]));	\
	DEBUG_PRINT1 ("\n");						\
1150
        PUSH_FAILURE_POINTER (reg_info[this_reg].word);			\
Jim Blandy's avatar
Jim Blandy committed
1151 1152 1153
      }									\
									\
    DEBUG_PRINT2 ("  Pushing  low active reg: %d\n", lowest_active_reg);\
1154
    PUSH_FAILURE_INT (lowest_active_reg);				\
Jim Blandy's avatar
Jim Blandy committed
1155 1156
									\
    DEBUG_PRINT2 ("  Pushing high active reg: %d\n", highest_active_reg);\
1157
    PUSH_FAILURE_INT (highest_active_reg);				\
Jim Blandy's avatar
Jim Blandy committed
1158 1159 1160
									\
    DEBUG_PRINT2 ("  Pushing pattern 0x%x: ", pattern_place);		\
    DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);		\
1161
    PUSH_FAILURE_POINTER (pattern_place);				\
Jim Blandy's avatar
Jim Blandy committed
1162 1163 1164 1165 1166
									\
    DEBUG_PRINT2 ("  Pushing string 0x%x: `", string_place);		\
    DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \
				 size2);				\
    DEBUG_PRINT1 ("'\n");						\
1167
    PUSH_FAILURE_POINTER (string_place);				\
Jim Blandy's avatar
Jim Blandy committed
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
									\
    DEBUG_PRINT2 ("  Pushing failure id: %u\n", failure_id);		\
    DEBUG_PUSH (failure_id);						\
  } while (0)

/* This is the number of items that are pushed and popped on the stack
   for each register.  */
#define NUM_REG_ITEMS  3

/* Individual items aside from the registers.  */
#ifdef DEBUG
#define NUM_NONREG_ITEMS 5 /* Includes failure point id.  */
#else
#define NUM_NONREG_ITEMS 4
#endif

/* We push at most this many items on the stack.  */
#define MAX_FAILURE_ITEMS ((num_regs - 1) * NUM_REG_ITEMS + NUM_NONREG_ITEMS)

/* We actually push this many items.  */
#define NUM_FAILURE_ITEMS						\
  ((highest_active_reg - lowest_active_reg + 1) * NUM_REG_ITEMS 	\
    + NUM_NONREG_ITEMS)

/* How many items can still be added to the stack without overflowing it.  */
#define REMAINING_AVAIL_SLOTS ((fail_stack).size - (fail_stack).avail)


/* Pops what PUSH_FAIL_STACK pushes.

   We restore into the parameters, all of which should be lvalues:
     STR -- the saved data position.
     PAT -- the saved pattern position.
     LOW_REG, HIGH_REG -- the highest and lowest active registers.
     REGSTART, REGEND -- arrays of string positions.
     REG_INFO -- array of information about each subexpression.
   
   Also assumes the variables `fail_stack' and (if debugging), `bufp',
   `pend', `string1', `size1', `string2', and `size2'.  */

#define POP_FAILURE_POINT(str, pat, low_reg, high_reg, regstart, regend, reg_info)\
{									\
  DEBUG_STATEMENT (fail_stack_elt_t failure_id;)			\
  int this_reg;								\
  const unsigned char *string_temp;					\
									\
  assert (!FAIL_STACK_EMPTY ());					\
									\
  /* Remove failure points and point to how many regs pushed.  */	\
  DEBUG_PRINT1 ("POP_FAILURE_POINT:\n");				\
  DEBUG_PRINT2 ("  Before pop, next avail: %d\n", fail_stack.avail);	\
  DEBUG_PRINT2 ("                    size: %d\n", fail_stack.size);	\
									\
  assert (fail_stack.avail >= NUM_NONREG_ITEMS);			\
									\
  DEBUG_POP (&failure_id);						\
  DEBUG_PRINT2 ("  Popping failure id: %u\n", failure_id);		\
									\
  /* If the saved string location is NULL, it came from an		\
     on_failure_keep_string_jump opcode, and we want to throw away the	\
     saved NULL, thus retaining our current position in the string.  */	\
1229
  string_temp = POP_FAILURE_POINTER ();					\
Jim Blandy's avatar
Jim Blandy committed
1230 1231 1232 1233 1234 1235 1236
  if (string_temp != NULL)						\
    str = (const char *) string_temp;					\
									\
  DEBUG_PRINT2 ("  Popping string 0x%x: `", str);			\
  DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);	\
  DEBUG_PRINT1 ("'\n");							\
									\
1237
  pat = (unsigned char *) POP_FAILURE_POINTER ();			\
Jim Blandy's avatar
Jim Blandy committed
1238 1239 1240 1241
  DEBUG_PRINT2 ("  Popping pattern 0x%x: ", pat);			\
  DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);			\
									\
  /* Restore register info.  */						\
1242
  high_reg = (unsigned) POP_FAILURE_INT ();				\
Jim Blandy's avatar
Jim Blandy committed
1243 1244
  DEBUG_PRINT2 ("  Popping high active reg: %d\n", high_reg);		\
									\
1245
  low_reg = (unsigned) POP_FAILURE_INT ();				\
Jim Blandy's avatar
Jim Blandy committed
1246 1247 1248 1249 1250 1251
  DEBUG_PRINT2 ("  Popping  low active reg: %d\n", low_reg);		\
									\
  for (this_reg = high_reg; this_reg >= low_reg; this_reg--)		\
    {									\
      DEBUG_PRINT2 ("    Popping reg: %d\n", this_reg);			\
									\
1252
      reg_info[this_reg].word = POP_FAILURE_POINTER ();			\
Jim Blandy's avatar
Jim Blandy committed
1253 1254
      DEBUG_PRINT2 ("      info: 0x%x\n", reg_info[this_reg]);		\
									\
1255
      regend[this_reg] = (const char *) POP_FAILURE_POINTER ();		\
Jim Blandy's avatar
Jim Blandy committed
1256 1257
      DEBUG_PRINT2 ("      end: 0x%x\n", regend[this_reg]);		\
									\
1258
      regstart[this_reg] = (const char *) POP_FAILURE_POINTER ();	\
Jim Blandy's avatar
Jim Blandy committed
1259 1260 1261
      DEBUG_PRINT2 ("      start: 0x%x\n", regstart[this_reg]);		\
    }									\
									\
1262
  set_regs_matched_done = 0;						\
Jim Blandy's avatar
Jim Blandy committed
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302
  DEBUG_STATEMENT (nfailure_points_popped++);				\
} /* POP_FAILURE_POINT */



/* Structure for per-register (a.k.a. per-group) information.
   This must not be longer than one word, because we push this value
   onto the failure stack.  Other register information, such as the
   starting and ending positions (which are addresses), and the list of
   inner groups (which is a bits list) are maintained in separate
   variables.  
   
   We are making a (strictly speaking) nonportable assumption here: that
   the compiler will pack our bit fields into something that fits into
   the type of `word', i.e., is something that fits into one item on the
   failure stack.  */
typedef union
{
  fail_stack_elt_t word;
  struct
  {
      /* This field is one if this group can match the empty string,
         zero if not.  If not yet determined,  `MATCH_NULL_UNSET_VALUE'.  */
#define MATCH_NULL_UNSET_VALUE 3
    unsigned match_null_string_p : 2;
    unsigned is_active : 1;
    unsigned matched_something : 1;
    unsigned ever_matched_something : 1;
  } bits;
} register_info_type;

#define REG_MATCH_NULL_STRING_P(R)  ((R).bits.match_null_string_p)
#define IS_ACTIVE(R)  ((R).bits.is_active)
#define MATCHED_SOMETHING(R)  ((R).bits.matched_something)
#define EVER_MATCHED_SOMETHING(R)  ((R).bits.ever_matched_something)


/* Call this when have matched a real character; it sets `matched' flags
   for the subexpressions which we are currently inside.  Also records
   that those subexprs have matched.  */
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
#define SET_REGS_MATCHED()						\
  do									\
    {									\
      if (!set_regs_matched_done)					\
	{								\
	  unsigned r;							\
	  set_regs_matched_done = 1;					\
	  for (r = lowest_active_reg; r <= highest_active_reg; r++)	\
	    {								\
	      MATCHED_SOMETHING (reg_info[r])				\
		= EVER_MATCHED_SOMETHING (reg_info[r])			\
		= 1;							\
	    }								\
	}								\
    }									\
  while (0)
Jim Blandy's avatar
Jim Blandy committed
1319 1320

/* Registers are set to a sentinel when they haven't yet matched.  */
1321 1322
static char reg_unset_dummy;
#define REG_UNSET_VALUE (&reg_unset_dummy)
Jim Blandy's avatar
Jim Blandy committed
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514
#define REG_UNSET(e) ((e) == REG_UNSET_VALUE)

/* Subroutine declarations and macros for regex_compile.  */

static void store_op1 (), store_op2 ();
static void insert_op1 (), insert_op2 ();
static boolean at_begline_loc_p (), at_endline_loc_p ();
static boolean group_in_compile_stack ();
static reg_errcode_t compile_range ();

/* Fetch the next character in the uncompiled pattern---translating it 
   if necessary.  Also cast from a signed character in the constant
   string passed to us by the user to an unsigned char that we can use
   as an array index (in, e.g., `translate').  */
#define PATFETCH(c)							\
  do {if (p == pend) return REG_EEND;					\
    c = (unsigned char) *p++;						\
    if (translate) c = translate[c]; 					\
  } while (0)

/* Fetch the next character in the uncompiled pattern, with no
   translation.  */
#define PATFETCH_RAW(c)							\
  do {if (p == pend) return REG_EEND;					\
    c = (unsigned char) *p++; 						\
  } while (0)

/* Go backwards one character in the pattern.  */
#define PATUNFETCH p--


/* If `translate' is non-null, return translate[D], else just D.  We
   cast the subscript to translate because some data is declared as
   `char *', to avoid warnings when a string constant is passed.  But
   when we use a character as a subscript we must make it unsigned.  */
#define TRANSLATE(d) (translate ? translate[(unsigned char) (d)] : (d))


/* Macros for outputting the compiled pattern into `buffer'.  */

/* If the buffer isn't allocated when it comes in, use this.  */
#define INIT_BUF_SIZE  32

/* Make sure we have at least N more bytes of space in buffer.  */
#define GET_BUFFER_SPACE(n)						\
    while (b - bufp->buffer + (n) > bufp->allocated)			\
      EXTEND_BUFFER ()

/* Make sure we have one more byte of buffer space and then add C to it.  */
#define BUF_PUSH(c)							\
  do {									\
    GET_BUFFER_SPACE (1);						\
    *b++ = (unsigned char) (c);						\
  } while (0)


/* Ensure we have two more bytes of buffer space and then append C1 and C2.  */
#define BUF_PUSH_2(c1, c2)						\
  do {									\
    GET_BUFFER_SPACE (2);						\
    *b++ = (unsigned char) (c1);					\
    *b++ = (unsigned char) (c2);					\
  } while (0)


/* As with BUF_PUSH_2, except for three bytes.  */
#define BUF_PUSH_3(c1, c2, c3)						\
  do {									\
    GET_BUFFER_SPACE (3);						\
    *b++ = (unsigned char) (c1);					\
    *b++ = (unsigned char) (c2);					\
    *b++ = (unsigned char) (c3);					\
  } while (0)


/* Store a jump with opcode OP at LOC to location TO.  We store a
   relative address offset by the three bytes the jump itself occupies.  */
#define STORE_JUMP(op, loc, to) \
  store_op1 (op, loc, (to) - (loc) - 3)

/* Likewise, for a two-argument jump.  */
#define STORE_JUMP2(op, loc, to, arg) \
  store_op2 (op, loc, (to) - (loc) - 3, arg)

/* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
#define INSERT_JUMP(op, loc, to) \
  insert_op1 (op, loc, (to) - (loc) - 3, b)

/* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
#define INSERT_JUMP2(op, loc, to, arg) \
  insert_op2 (op, loc, (to) - (loc) - 3, arg, b)


/* This is not an arbitrary limit: the arguments which represent offsets
   into the pattern are two bytes long.  So if 2^16 bytes turns out to
   be too small, many things would have to change.  */
#define MAX_BUF_SIZE (1L << 16)


/* Extend the buffer by twice its current size via realloc and
   reset the pointers that pointed into the old block to point to the
   correct places in the new one.  If extending the buffer results in it
   being larger than MAX_BUF_SIZE, then flag memory exhausted.  */
#define EXTEND_BUFFER()							\
  do { 									\
    unsigned char *old_buffer = bufp->buffer;				\
    if (bufp->allocated == MAX_BUF_SIZE) 				\
      return REG_ESIZE;							\
    bufp->allocated <<= 1;						\
    if (bufp->allocated > MAX_BUF_SIZE)					\
      bufp->allocated = MAX_BUF_SIZE; 					\
    bufp->buffer = (unsigned char *) realloc (bufp->buffer, bufp->allocated);\
    if (bufp->buffer == NULL)						\
      return REG_ESPACE;						\
    /* If the buffer moved, move all the pointers into it.  */		\
    if (old_buffer != bufp->buffer)					\
      {									\
        b = (b - old_buffer) + bufp->buffer;				\
        begalt = (begalt - old_buffer) + bufp->buffer;			\
        if (fixup_alt_jump)						\
          fixup_alt_jump = (fixup_alt_jump - old_buffer) + bufp->buffer;\
        if (laststart)							\
          laststart = (laststart - old_buffer) + bufp->buffer;		\
        if (pending_exact)						\
          pending_exact = (pending_exact - old_buffer) + bufp->buffer;	\
      }									\
  } while (0)


/* Since we have one byte reserved for the register number argument to
   {start,stop}_memory, the maximum number of groups we can report
   things about is what fits in that byte.  */
#define MAX_REGNUM 255

/* But patterns can have more than `MAX_REGNUM' registers.  We just
   ignore the excess.  */
typedef unsigned regnum_t;


/* Macros for the compile stack.  */

/* Since offsets can go either forwards or backwards, this type needs to
   be able to hold values from -(MAX_BUF_SIZE - 1) to MAX_BUF_SIZE - 1.  */
typedef int pattern_offset_t;

typedef struct
{
  pattern_offset_t begalt_offset;
  pattern_offset_t fixup_alt_jump;
  pattern_offset_t inner_group_offset;
  pattern_offset_t laststart_offset;  
  regnum_t regnum;
} compile_stack_elt_t;


typedef struct
{
  compile_stack_elt_t *stack;
  unsigned size;
  unsigned avail;			/* Offset of next open position.  */
} compile_stack_type;


#define INIT_COMPILE_STACK_SIZE 32

#define COMPILE_STACK_EMPTY  (compile_stack.avail == 0)
#define COMPILE_STACK_FULL  (compile_stack.avail == compile_stack.size)

/* The next available element.  */
#define COMPILE_STACK_TOP (compile_stack.stack[compile_stack.avail])


/* Set the bit for character C in a list.  */
#define SET_LIST_BIT(c)                               \
  (b[((unsigned char) (c)) / BYTEWIDTH]               \
   |= 1 << (((unsigned char) c) % BYTEWIDTH))


/* Get the next unsigned number in the uncompiled pattern.  */
#define GET_UNSIGNED_NUMBER(num) 					\
  { if (p != pend)							\
     {									\
       PATFETCH (c); 							\
       while (ISDIGIT (c)) 						\
         { 								\
           if (num < 0)							\
              num = 0;							\
           num = num * 10 + c - '0'; 					\
           if (p == pend) 						\
              break; 							\
           PATFETCH (c);						\
         } 								\
Karl Berry's avatar
Karl Berry committed
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
       } 								\
    }		

#define CHAR_CLASS_MAX_LENGTH  6 /* Namely, `xdigit'.  */

#define IS_CHAR_CLASS(string)						\
   (STREQ (string, "alpha") || STREQ (string, "upper")			\
    || STREQ (string, "lower") || STREQ (string, "digit")		\
    || STREQ (string, "alnum") || STREQ (string, "xdigit")		\
    || STREQ (string, "space") || STREQ (string, "print")		\
    || STREQ (string, "punct") || STREQ (string, "graph")		\
    || STREQ (string, "cntrl") || STREQ (string, "blank"))

1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575
#ifndef MATCH_MAY_ALLOCATE

/* If we cannot allocate large objects within re_match_2_internal,
   we make the fail stack and register vectors global.
   The fail stack, we grow to the maximum size when a regexp
   is compiled.
   The register vectors, we adjust in size each time we
   compile a regexp, according to the number of registers it needs.  */

static fail_stack_type fail_stack;

/* Size with which the following vectors are currently allocated.
   That is so we can make them bigger as needed,
   but never make them smaller.  */
static int regs_allocated_size;

static const char **     regstart, **     regend;
static const char ** old_regstart, ** old_regend;
static const char **best_regstart, **best_