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 52 53
/* 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"

#else  /* not emacs */

54 55 56 57 58
/* If we are not linking with Emacs proper,
   we can't use the relocating allocator
   even if config.h says that we can.  */
#undef REL_ALLOC

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

Karl Berry's avatar
Karl Berry committed
66 67
/* 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
68
#ifndef INHIBIT_STRING_HEADER
David J. MacKenzie's avatar
David J. MacKenzie committed
69
#if HAVE_STRING_H || STDC_HEADERS
Karl Berry's avatar
Karl Berry committed
70
#include <string.h>
Karl Berry's avatar
Karl Berry committed
71
#ifndef bcmp
Karl Berry's avatar
Karl Berry committed
72
#define bcmp(s1, s2, n)	memcmp ((s1), (s2), (n))
Karl Berry's avatar
Karl Berry committed
73 74
#endif
#ifndef bcopy
Karl Berry's avatar
Karl Berry committed
75
#define bcopy(s, d, n)	memcpy ((d), (s), (n))
Karl Berry's avatar
Karl Berry committed
76 77
#endif
#ifndef bzero
Karl Berry's avatar
Karl Berry committed
78
#define bzero(s, n)	memset ((s), 0, (n))
Karl Berry's avatar
Karl Berry committed
79
#endif
Karl Berry's avatar
Karl Berry committed
80 81 82
#else
#include <strings.h>
#endif
Karl Heuer's avatar
Karl Heuer committed
83
#endif
Karl Berry's avatar
Karl Berry committed
84 85 86 87 88 89 90 91 92

/* 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

93 94 95 96 97 98
#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
99 100 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
#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
146

Jim Blandy's avatar
Jim Blandy committed
147 148 149 150 151 152 153 154 155 156
/* 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
157 158 159 160 161

#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
162
#endif
Jim Meyering's avatar
Jim Meyering committed
163 164

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

Karl Heuer's avatar
Karl Heuer committed
175 176 177 178 179 180 181 182 183 184
#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
185 186 187 188 189 190 191 192 193 194 195 196

#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
197
#else  /* not __STDC__ */
Karl Berry's avatar
Karl Berry committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
/* 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)
216
#define REGEX_FREE free
Karl Berry's avatar
Karl Berry committed
217 218 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

#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)

246 247 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
/* 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
278
#endif /* not REGEX_MALLOC */
279
#endif /* not REL_ALLOC */
Karl Berry's avatar
Karl Berry committed
280 281 282 283 284 285 286 287 288 289 290


/* 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
291 292
#define RETALLOC_IF(addr, n, t) \
  if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
Karl Berry's avatar
Karl Berry committed
293 294 295 296 297 298
#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
299 300
#undef MAX
#undef MIN
Karl Berry's avatar
Karl Berry committed
301 302 303 304 305 306
#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
307 308

static int re_match_2_internal ();
Karl Berry's avatar
Karl Berry committed
309 310 311 312

/* 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
313
   arguments.  Zero bytes may appear in the compiled regular expression.  */
Karl Berry's avatar
Karl Berry committed
314 315 316 317 318

typedef enum
{
  no_op = 0,

319 320 321
  /* Succeed right away--no more backtracking.  */
  succeed,

Karl Berry's avatar
Karl Berry committed
322
        /* Followed by one byte giving n, then by n literal bytes.  */
Karl Heuer's avatar
Karl Heuer committed
323
  exactn,
Karl Berry's avatar
Karl Berry committed
324 325 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

        /* 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
543
#define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
Karl Berry's avatar
Karl Berry committed
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
#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;
564
          putchar (i - 1);
Karl Berry's avatar
Karl Berry committed
565 566 567 568 569 570 571 572
          while (i < (1 << BYTEWIDTH)  &&  fastmap[i])
            {
              was_a_range = 1;
              i++;
            }
	  if (was_a_range)
            {
              printf ("-");
573
              putchar (i - 1);
Karl Berry's avatar
Karl Berry committed
574 575 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
            }
        }
    }
  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
602 603
      printf ("%d:\t", p - start);

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

	case exactn:
	  mcnt = *p++;
          printf ("/exactn/%d", mcnt);
          do
	    {
              putchar ('/');
616
	      putchar (*p++);
Karl Berry's avatar
Karl Berry committed
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
            }
          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
642 643
            register int c, last = -100;
	    register int in_range = 0;
Karl Berry's avatar
Karl Berry committed
644

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

Jim Blandy's avatar
Jim Blandy committed
650 651 652 653 654 655 656 657 658 659 660 661
            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
662
              {
663
		      putchar (last);
Jim Blandy's avatar
Jim Blandy committed
664 665
		      in_range = 0;
		    }
Karl Berry's avatar
Karl Berry committed
666
                
Jim Blandy's avatar
Jim Blandy committed
667
		  if (! in_range)
668
		    putchar (c);
Karl Berry's avatar
Karl Berry committed
669

Jim Blandy's avatar
Jim Blandy committed
670
		  last = c;
Karl Berry's avatar
Karl Berry committed
671
              }
Jim Blandy's avatar
Jim Blandy committed
672 673

	    if (in_range)
674
	      putchar (last);
Jim Blandy's avatar
Jim Blandy committed
675 676 677

	    putchar (']');

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

	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
692
  	  printf ("/on_failure_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
693 694 695 696
          break;

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

	case dummy_failure_jump:
          extract_number_and_incr (&mcnt, &p);
Jim Blandy's avatar
Jim Blandy committed
702
  	  printf ("/dummy_failure_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
703 704 705 706 707 708 709 710
          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
711
  	  printf ("/maybe_pop_jump to %d", p + mcnt - start);
Karl Berry's avatar
Karl Berry committed
712 713 714 715
	  break;

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

        case succeed_n: 
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
Jim Blandy's avatar
Jim Blandy committed
732
	  printf ("/succeed_n to %d, %d times", p + mcnt - start, mcnt2);
Karl Berry's avatar
Karl Berry committed
733 734 735 736 737
          break;
        
        case jump_n: 
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
Jim Blandy's avatar
Jim Blandy committed
738
	  printf ("/jump_n to %d, %d times", p + mcnt - start, mcnt2);
Karl Berry's avatar
Karl Berry committed
739 740 741 742 743
          break;
        
        case set_number_at: 
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
Jim Blandy's avatar
Jim Blandy committed
744
	  printf ("/set_number_at location %d to %d", p + mcnt - start, mcnt2);
Karl Berry's avatar
Karl Berry committed
745 746 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
          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
807 808

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

  printf ("%d:\tend of pattern.\n", p - start);
Karl Berry's avatar
Karl Berry committed
812 813 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
}


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++)
859
            putchar (string1[this_char]);
Karl Berry's avatar
Karl Berry committed
860 861 862 863 864

          where = string2;    
        }

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

#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
878
#define DEBUG_PRINT4(x1, x2, x3, x4)
Karl Berry's avatar
Karl Berry committed
879 880 881 882 883 884 885 886
#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.  */
887 888 889
/* 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
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909


/* 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
910 911 912
   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
913

914 915
static const char *re_error_msgid[] =
  { "Success",					/* REG_NOERROR */
Karl Berry's avatar
Karl Berry committed
916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933
    "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
934 935
/* Avoiding alloca during matching, to placate r_alloc.  */

Karl Heuer's avatar
Karl Heuer committed
936
/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
Jim Blandy's avatar
Jim Blandy committed
937 938 939 940 941
   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
942 943
   routines.

944 945
   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
946 947 948 949 950 951
   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
952 953 954 955

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

956 957 958 959 960 961
/* 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

962
/* The match routines may not allocate if (1) they would do it with malloc
963 964 965 966 967
   and (2) it's not safe for them to use malloc.
   Note that if REL_ALLOC is defined, matching would not use malloc for the
   failure stack, but we would still use it for the register vectors;
   so REL_ALLOC should not affect this.  */
#if (defined (C_ALLOCA) || defined (REGEX_MALLOC)) && defined (emacs)
Jim Blandy's avatar
Jim Blandy committed
968
#undef MATCH_MAY_ALLOCATE
Jim Blandy's avatar
Jim Blandy committed
969
#endif
Karl Berry's avatar
Karl Berry committed
970

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

Jim Blandy's avatar
Jim Blandy committed
977 978 979 980 981 982
/* 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
983

Jim Blandy's avatar
Jim Blandy committed
984 985 986 987
/* 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.  */
988 989
#if defined (MATCH_MAY_ALLOCATE)
int re_max_failures = 200000;
990
#else
Jim Blandy's avatar
Jim Blandy committed
991
int re_max_failures = 2000;
992
#endif
Karl Berry's avatar
Karl Berry committed
993

994 995 996 997 998 999 1000
union fail_stack_elt
{
  unsigned char *pointer;
  int integer;
};

typedef union fail_stack_elt fail_stack_elt_t;
Karl Berry's avatar
Karl Berry committed
1001

Jim Blandy's avatar
Jim Blandy committed
1002 1003 1004 1005 1006 1007
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
1008

Jim Blandy's avatar
Jim Blandy committed
1009 1010 1011
#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)
Karl Berry's avatar
Karl Berry committed
1012 1013


1014 1015
/* Define macros to initialize and free the failure stack.
   Do `return -2' if the alloc fails.  */
Karl Berry's avatar
Karl Berry committed
1016

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

#define RESET_FAIL_STACK()  REGEX_FREE_STACK (fail_stack.stack)
Jim Blandy's avatar
Jim Blandy committed
1031 1032
#else
#define INIT_FAIL_STACK()						\
Karl Berry's avatar
Karl Berry committed
1033
  do {									\
Jim Blandy's avatar
Jim Blandy committed
1034
    fail_stack.avail = 0;						\
Karl Berry's avatar
Karl Berry committed
1035
  } while (0)
1036 1037

#define RESET_FAIL_STACK()
Jim Blandy's avatar
Jim Blandy committed
1038
#endif
Karl Berry's avatar
Karl Berry committed
1039 1040


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

Jim Blandy's avatar
Jim Blandy committed
1043 1044 1045
   Return 1 if succeeds, and 0 if either ran out of memory
   allocating space for it or it was already too large.  
   
1046
   REGEX_REALLOCATE_STACK requires `destination' be declared.   */
Karl Berry's avatar
Karl Berry committed
1047

Jim Blandy's avatar
Jim Blandy committed
1048 1049 1050 1051
#define DOUBLE_FAIL_STACK(fail_stack)					\
  ((fail_stack).size > re_max_failures * MAX_FAILURE_ITEMS		\
   ? 0									\
   : ((fail_stack).stack = (fail_stack_elt_t *)				\
1052
        REGEX_REALLOCATE_STACK ((fail_stack).stack, 			\
Jim Blandy's avatar
Jim Blandy committed
1053 1054 1055 1056 1057 1058 1059
          (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
1060 1061


1062
/* Push pointer POINTER on FAIL_STACK. 
Jim Blandy's avatar
Jim Blandy committed
1063 1064
   Return 1 if was able to do so and 0 if ran out of memory allocating
   space to do so.  */
1065
#define PUSH_PATTERN_OP(POINTER, FAIL_STACK)				\
Jim Blandy's avatar
Jim Blandy committed
1066
  ((FAIL_STACK_FULL ()							\
1067
    && !DOUBLE_FAIL_STACK (FAIL_STACK))					\
1068
   ? 0									\
1069
   : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER,	\
1070
      1))
Karl Berry's avatar
Karl Berry committed
1071

1072 1073
/* Push a pointer value onto the failure stack.
   Assumes the variable `fail_stack'.  Probably should only
Jim Blandy's avatar
Jim Blandy committed
1074
   be called from within `PUSH_FAILURE_POINT'.  */
1075
#define PUSH_FAILURE_POINTER(item)					\
1076
  fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (item)
1077 1078 1079 1080 1081

/* 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)					\
1082
  fail_stack.stack[fail_stack.avail++].integer = (item)
1083

1084 1085 1086 1087 1088
/* Push a fail_stack_elt_t value onto the failure stack.
   Assumes the variable `fail_stack'.  Probably should only
   be called from within `PUSH_FAILURE_POINT'.  */
#define PUSH_FAILURE_ELT(item)					\
  fail_stack.stack[fail_stack.avail++] =  (item)
Karl Berry's avatar
Karl Berry committed
1089

1090 1091 1092 1093 1094
/* These three POP... operations complement the three PUSH... operations.
   All assume that `fail_stack' is nonempty.  */
#define POP_FAILURE_POINTER() fail_stack.stack[--fail_stack.avail].pointer
#define POP_FAILURE_INT() fail_stack.stack[--fail_stack.avail].integer
#define POP_FAILURE_ELT() fail_stack.stack[--fail_stack.avail]
Karl Berry's avatar
Karl Berry committed
1095

Jim Blandy's avatar
Jim Blandy committed
1096 1097
/* Used to omit pushing failure point id's when we're not debugging.  */
#ifdef DEBUG
1098 1099
#define DEBUG_PUSH PUSH_FAILURE_INT
#define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT ()
Jim Blandy's avatar
Jim Blandy committed
1100 1101 1102 1103
#else
#define DEBUG_PUSH(item)
#define DEBUG_POP(item_addr)
#endif
Karl Berry's avatar
Karl Berry committed
1104 1105


Jim Blandy's avatar
Jim Blandy committed
1106 1107 1108 1109 1110 1111 1112 1113
/* 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
1114

Jim Blandy's avatar
Jim Blandy committed
1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
#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)			\
      {									\
1134
        if (!DOUBLE_FAIL_STACK (fail_stack))				\
Jim Blandy's avatar
Jim Blandy committed
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151
          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]);		\
1152
        PUSH_FAILURE_POINTER (regstart[this_reg]);			\
Jim Blandy's avatar
Jim Blandy committed
1153 1154
                                                                        \
	DEBUG_PRINT2 ("    end: 0x%x\n", regend[this_reg]);		\
1155
        PUSH_FAILURE_POINTER (regend[this_reg]);			\
Jim Blandy's avatar
Jim Blandy committed
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
									\
	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");						\
1166
        PUSH_FAILURE_ELT (reg_info[this_reg].word);			\
Jim Blandy's avatar
Jim Blandy committed
1167 1168 1169
      }									\
									\
    DEBUG_PRINT2 ("  Pushing  low active reg: %d\n", lowest_active_reg);\
1170
    PUSH_FAILURE_INT (lowest_active_reg);				\
Jim Blandy's avatar
Jim Blandy committed
1171 1172
									\
    DEBUG_PRINT2 ("  Pushing high active reg: %d\n", highest_active_reg);\
1173
    PUSH_FAILURE_INT (highest_active_reg);				\
Jim Blandy's avatar
Jim Blandy committed
1174 1175 1176
									\
    DEBUG_PRINT2 ("  Pushing pattern 0x%x: ", pattern_place);		\
    DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);		\
1177
    PUSH_FAILURE_POINTER (pattern_place);				\
Jim Blandy's avatar
Jim Blandy committed
1178 1179 1180 1181 1182
									\
    DEBUG_PRINT2 ("  Pushing string 0x%x: `", string_place);		\
    DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \
				 size2);				\
    DEBUG_PRINT1 ("'\n");						\
1183
    PUSH_FAILURE_POINTER (string_place);				\
Jim Blandy's avatar
Jim Blandy committed
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 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
									\
    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.  */	\
1245
  string_temp = POP_FAILURE_POINTER ();					\
Jim Blandy's avatar
Jim Blandy committed
1246 1247 1248 1249 1250 1251 1252
  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");							\
									\
1253
  pat = (unsigned char *) POP_FAILURE_POINTER ();			\
Jim Blandy's avatar
Jim Blandy committed
1254 1255 1256 1257
  DEBUG_PRINT2 ("  Popping pattern 0x%x: ", pat);			\
  DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);			\
									\
  /* Restore register info.  */						\
1258
  high_reg = (unsigned) POP_FAILURE_INT ();				\
Jim Blandy's avatar
Jim Blandy committed
1259 1260
  DEBUG_PRINT2 ("  Popping high active reg: %d\n", high_reg);		\
									\
1261
  low_reg = (unsigned) POP_FAILURE_INT ();				\
Jim Blandy's avatar
Jim Blandy committed
1262 1263 1264 1265 1266 1267
  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);			\
									\
1268
      reg_info[this_reg].word = POP_FAILURE_ELT ();			\
Jim Blandy's avatar
Jim Blandy committed
1269 1270
      DEBUG_PRINT2 ("      info: 0x%x\n", reg_info[this_reg]);		\
									\
1271
      regend[this_reg] = (const char *) POP_FAILURE_POINTER ();		\
Jim Blandy's avatar
Jim Blandy committed
1272 1273
      DEBUG_PRINT2 ("      end: 0x%x\n", regend[this_reg]);		\
									\
1274
      regstart[this_reg] = (const char *) POP_FAILURE_POINTER ();	\
Jim Blandy's avatar
Jim Blandy committed
1275 1276 1277
      DEBUG_PRINT2 ("      start: 0x%x\n", regstart[this_reg]);		\
    }									\
									\
1278
  set_regs_matched_done = 0;						\
Jim Blandy's avatar
Jim Blandy committed
1279 1280 1281 1282 1283 1284
  DEBUG_STATEMENT (nfailure_points_popped++);				\
} /* POP_FAILURE_POINT */



/* Structure for per-register (a.k.a. per-group) information.
1285
   Other register information, such as the
Jim Blandy's avatar
Jim Blandy committed
1286 1287 1288 1289 1290 1291 1292 1293
   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.  */
1294

Jim Blandy's avatar
Jim Blandy committed
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
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.  */
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
#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
1335 1336

/* Registers are set to a sentinel when they haven't yet matched.  */
1337 1338
static char reg_unset_dummy;
#define REG_UNSET_VALUE (&reg_unset_dummy)
Jim Blandy's avatar
Jim Blandy committed
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 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
#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
1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542