Attachment #6012 for bug #13935

View | Details | Raw Unified | Return to bug 13935
Collapse All | Expand All




to James Woods.  He also contributed some code to early versions of
GNU grep.

Mike Haertel would like to thank Andrew Hume for many fascinating discussions
of string searching issues over the years.  Hume & Sunday's excellent
paper on fast string searching (AT&T Bell Laboratories CSTR #156)
describes some of the history of the subject, as well as providing
exhaustive performance analysis of various implementation alternatives.
The inner loop of GNU grep is similar to Hume & Sunday's recommended
"Tuned Boyer Moore" inner loop.

More work was done on regex.[ch] by Ulrich Drepper and Arnold
Robbins. Regex is now part of GNU C library, see this package
for complete details and credits.

Arnold Robbins contributed to improve dfa.[ch]. In fact
it came straight from gawk-3.0.3 with small editing and fixes.

Many folks contributed see THANKS, if I omited someone please
send me email.

Alain Magloire is the current maintainer.




		       Version 2, June 1991

 Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.



		     END OF TERMS AND CONDITIONS

	    How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it

the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    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


    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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

    Gnomovision version 69, Copyright (C) year  name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

Lines 4-13 Link Here

(-)grep/Makefile (-2 / +3 lines)
4	GREP_FTS= YES	4	GREP_FTS= YES
5		5
6	PROG= grep	6	PROG= grep
7	SRCS= dfa.c grep.c getopt.c kwset.c obstack.c search.c	7	SRCS= dfa.c grep.c getopt.c getopt1.c kwset.c obstack.c search.c memchr.c \
		8	savedir.c grepmat.c stpcpy.c
8	CFLAGS+=-DGREP -DHAVE_STRING_H=1 -DHAVE_SYS_PARAM_H=1 -DHAVE_UNISTD_H=1 \	9	CFLAGS+=-DGREP -DHAVE_STRING_H=1 -DHAVE_SYS_PARAM_H=1 -DHAVE_UNISTD_H=1 \
9	-DHAVE_GETPAGESIZE=1 -DHAVE_MEMCHR=1 -DHAVE_STRERROR=1 \	10	-DHAVE_GETPAGESIZE=1 -DHAVE_MEMCHR=1 -DHAVE_STRERROR=1 \
10	-DHAVE_VALLOC=1	11	-DHAVE_VALLOC=1 -DHAVE_DIRENT_H=1 -DVERSION=\"2.3\"
11		12
12	LINKS+= ${BINDIR}/grep ${BINDIR}/egrep \	13	LINKS+= ${BINDIR}/grep ${BINDIR}/egrep \
13	${BINDIR}/grep ${BINDIR}/fgrep	14	${BINDIR}/grep ${BINDIR}/fgrep




Version 2.3:

  - When searching a binary file FOO, grep now just reports
    `Binary file FOO matches' instead of outputting binary data.
    This is typically more useful than the old behavior,
    and it is also more consistent with other utilities like `diff'.
    A file is considered to be binary if it contains a NUL (i.e. zero) byte.

    The new -a or --text option causes `grep' to assume that all
    input is text.  (This option has the same meaning as with `diff'.)
    Use it if you want binary data in your output.

  - `grep' now searches directories just like ordinary files; it no longer
    silently skips directories.  This is the traditional behavior of
    Unix text utilities (in particular, of traditional `grep').
    Hence `grep PATTERN DIRECTORY' should report
    `grep: DIRECTORY: Is a directory' on hosts where the operating system
    does not permit programs to read directories directly, and
    `grep: DIRECTORY: Binary file matches' (or nothing) otherwise.

    The new -d ACTION or --directories=ACTION option affects directory handling.
    `-d skip' causes `grep' to silently skip directories, as in grep 2.2;
    `-d read' (the default) causes `grep' to read directories if possible,
    as in earlier versions of grep.

  - The MS-DOS and Microsoft Windows ports now behave identically to the
    GNU and Unix ports with respect to binary files and directories.

Version 2.2:

Bug fix release.

  - Status error number fix.
  - Skipping directories removed.
  - Many typos fix.
  - -f /dev/null fix(not to consider as an empty pattern).
  - Checks for wctype/wchar.
  - -E was using the wrong matcher fix.
  - bug in regex char class fix
  - Fixes for DJGPP

Version 2.1:

This is a bug fix release(see Changelog) i.e. no new features.

  - More compliance to GNU standard.
  - Long options.
  - Internationalisation.
  - Use automake/autoconf.
  - Directory hierarchy change.
  - Sigvec with -e on Linux corrected.
  - Sigvec with -f on Linux corrected.
  - Sigvec with the mmap() corrected.
  - Bug in kwset corrected.
  - -q, -L and -l stop on first match.
  - New and improve regex.[ch] from Ulrich Drepper.
  - New and improve dfa.[ch] from Arnold Robbins.
  - Prototypes for over zealous C compiler.
  - Not scanning a file, if it's a directory
    (cause problems on Sun).
  - Ported to MS-DOS/MS-Windows with DJGPP tools.

See Changelog for the full story and proper credits.

Version 2.0:

The most important user visible change is that egrep and fgrep have




Write Texinfo documentation for grep.  The manual page would be a good
place to start, but Info documents are also supposed to contain a
tutorial and examples.

Fix the DFA matcher to never use exponential space.  (Fortunately, these
cases are rare.)

Improve the performance of the regex backtracking matcher.  This matcher
is agonizingly slow, and is responsible for grep sometimes being slower
than Unix grep when backreferences are used.

Provide support for the Posix [= =] and [. .] constructs.  This is
difficult because it requires locale-dependent details of the character
set and collating sequence, but Posix does not standardize any method
for accessing this information!




/* alloca.c -- allocate automatically reclaimed memory
   (Mostly) portable public-domain implementation -- D A Gwyn

   This implementation of the PWB library alloca function,
   which is used to allocate space off the run-time stack so
   that it is automatically reclaimed upon procedure exit,
   was inspired by discussions with J. Q. Johnson of Cornell.
   J.Otto Tennant <jot@cray.com> contributed the Cray support.

   There are some preprocessor constants that can
   be defined when compiling for your specific system, for
   improved efficiency; however, the defaults should be okay.

   The general concept of this implementation is to keep
   track of all alloca-allocated blocks, and reclaim any
   that are found to be deeper in the stack than the current
   invocation.  This heuristic does not reclaim storage as
   soon as it becomes invalid, but it will do so eventually.

   As a special case, alloca(0) reclaims storage without
   allocating any.  It is a good idea to use alloca(0) in
   your main control loop, etc. to force garbage collection.  */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif

#ifdef emacs
#include "blockinput.h"
#endif

/* If compiling with GCC 2, this file's not needed.  */
#if !defined (__GNUC__) || __GNUC__ < 2

/* If someone has defined alloca as a macro,
   there must be some other way alloca is supposed to work.  */
#ifndef alloca

#ifdef emacs
#ifdef static
/* actually, only want this if static is defined as ""
   -- this is for usg, in which emacs must undefine static
   in order to make unexec workable
   */
#ifndef STACK_DIRECTION
you
lose
-- must know STACK_DIRECTION at compile-time
#endif /* STACK_DIRECTION undefined */
#endif /* static */
#endif /* emacs */

/* If your stack is a linked list of frames, you have to
   provide an "address metric" ADDRESS_FUNCTION macro.  */

#if defined (CRAY) && defined (CRAY_STACKSEG_END)
long i00afunc ();
#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
#else
#define ADDRESS_FUNCTION(arg) &(arg)
#endif

#if __STDC__
typedef void *pointer;
#else
typedef char *pointer;
#endif

#ifndef NULL
#define	NULL	0
#endif

/* Different portions of Emacs need to call different versions of
   malloc.  The Emacs executable needs alloca to call xmalloc, because
   ordinary malloc isn't protected from input signals.  On the other
   hand, the utilities in lib-src need alloca to call malloc; some of
   them are very simple, and don't have an xmalloc routine.

   Non-Emacs programs expect this to call use xmalloc.

   Callers below should use malloc.  */

#ifndef emacs
#define malloc xmalloc
#endif
extern pointer malloc ();

/* Define STACK_DIRECTION if you know the direction of stack
   growth for your system; otherwise it will be automatically
   deduced at run-time.

   STACK_DIRECTION > 0 => grows toward higher addresses
   STACK_DIRECTION < 0 => grows toward lower addresses
   STACK_DIRECTION = 0 => direction of growth unknown  */

#ifndef STACK_DIRECTION
#define	STACK_DIRECTION	0	/* Direction unknown.  */
#endif

#if STACK_DIRECTION != 0

#define	STACK_DIR	STACK_DIRECTION	/* Known at compile-time.  */

#else /* STACK_DIRECTION == 0; need run-time code.  */

static int stack_dir;		/* 1 or -1 once known.  */
#define	STACK_DIR	stack_dir

static void
find_stack_direction ()
{
  static char *addr = NULL;	/* Address of first `dummy', once known.  */
  auto char dummy;		/* To get stack address.  */

  if (addr == NULL)
    {				/* Initial entry.  */
      addr = ADDRESS_FUNCTION (dummy);

      find_stack_direction ();	/* Recurse once.  */
    }
  else
    {
      /* Second entry.  */
      if (ADDRESS_FUNCTION (dummy) > addr)
	stack_dir = 1;		/* Stack grew upward.  */
      else
	stack_dir = -1;		/* Stack grew downward.  */
    }
}

#endif /* STACK_DIRECTION == 0 */

/* An "alloca header" is used to:
   (a) chain together all alloca'ed blocks;
   (b) keep track of stack depth.

   It is very important that sizeof(header) agree with malloc
   alignment chunk size.  The following default should work okay.  */

#ifndef	ALIGN_SIZE
#define	ALIGN_SIZE	sizeof(double)
#endif

typedef union hdr
{
  char align[ALIGN_SIZE];	/* To force sizeof(header).  */
  struct
    {
      union hdr *next;		/* For chaining headers.  */
      char *deep;		/* For stack depth measure.  */
    } h;
} header;

static header *last_alloca_header = NULL;	/* -> last alloca header.  */

/* Return a pointer to at least SIZE bytes of storage,
   which will be automatically reclaimed upon exit from
   the procedure that called alloca.  Originally, this space
   was supposed to be taken from the current stack frame of the
   caller, but that method cannot be made to work for some
   implementations of C, for example under Gould's UTX/32.  */

pointer
alloca (size)
     unsigned size;
{
  auto char probe;		/* Probes stack depth: */
  register char *depth = ADDRESS_FUNCTION (probe);

#if STACK_DIRECTION == 0
  if (STACK_DIR == 0)		/* Unknown growth direction.  */
    find_stack_direction ();
#endif

  /* Reclaim garbage, defined as all alloca'd storage that
     was allocated from deeper in the stack than currently.  */

  {
    register header *hp;	/* Traverses linked list.  */

#ifdef emacs
    BLOCK_INPUT;
#endif

    for (hp = last_alloca_header; hp != NULL;)
      if ((STACK_DIR > 0 && hp->h.deep > depth)
	  || (STACK_DIR < 0 && hp->h.deep < depth))
	{
	  register header *np = hp->h.next;

	  free ((pointer) hp);	/* Collect garbage.  */

	  hp = np;		/* -> next header.  */
	}
      else
	break;			/* Rest are not deeper.  */

    last_alloca_header = hp;	/* -> last valid storage.  */

#ifdef emacs
    UNBLOCK_INPUT;
#endif
  }

  if (size == 0)
    return NULL;		/* No allocation required.  */

  /* Allocate combined header + user data storage.  */

  {
    register pointer new = malloc (sizeof (header) + size);
    /* Address of header.  */

    if (new == 0)
      abort();

    ((header *) new)->h.next = last_alloca_header;
    ((header *) new)->h.deep = depth;

    last_alloca_header = (header *) new;

    /* User storage begins just after header.  */

    return (pointer) ((char *) new + sizeof (header));
  }
}

#if defined (CRAY) && defined (CRAY_STACKSEG_END)

#ifdef DEBUG_I00AFUNC
#include <stdio.h>
#endif

#ifndef CRAY_STACK
#define CRAY_STACK
#ifndef CRAY2
/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
struct stack_control_header
  {
    long shgrow:32;		/* Number of times stack has grown.  */
    long shaseg:32;		/* Size of increments to stack.  */
    long shhwm:32;		/* High water mark of stack.  */
    long shsize:32;		/* Current size of stack (all segments).  */
  };

/* The stack segment linkage control information occurs at
   the high-address end of a stack segment.  (The stack
   grows from low addresses to high addresses.)  The initial
   part of the stack segment linkage control information is
   0200 (octal) words.  This provides for register storage
   for the routine which overflows the stack.  */

struct stack_segment_linkage
  {
    long ss[0200];		/* 0200 overflow words.  */
    long sssize:32;		/* Number of words in this segment.  */
    long ssbase:32;		/* Offset to stack base.  */
    long:32;
    long sspseg:32;		/* Offset to linkage control of previous
				   segment of stack.  */
    long:32;
    long sstcpt:32;		/* Pointer to task common address block.  */
    long sscsnm;		/* Private control structure number for
				   microtasking.  */
    long ssusr1;		/* Reserved for user.  */
    long ssusr2;		/* Reserved for user.  */
    long sstpid;		/* Process ID for pid based multi-tasking.  */
    long ssgvup;		/* Pointer to multitasking thread giveup.  */
    long sscray[7];		/* Reserved for Cray Research.  */
    long ssa0;
    long ssa1;
    long ssa2;
    long ssa3;
    long ssa4;
    long ssa5;
    long ssa6;
    long ssa7;
    long sss0;
    long sss1;
    long sss2;
    long sss3;
    long sss4;
    long sss5;
    long sss6;
    long sss7;
  };

#else /* CRAY2 */
/* The following structure defines the vector of words
   returned by the STKSTAT library routine.  */
struct stk_stat
  {
    long now;			/* Current total stack size.  */
    long maxc;			/* Amount of contiguous space which would
				   be required to satisfy the maximum
				   stack demand to date.  */
    long high_water;		/* Stack high-water mark.  */
    long overflows;		/* Number of stack overflow ($STKOFEN) calls.  */
    long hits;			/* Number of internal buffer hits.  */
    long extends;		/* Number of block extensions.  */
    long stko_mallocs;		/* Block allocations by $STKOFEN.  */
    long underflows;		/* Number of stack underflow calls ($STKRETN).  */
    long stko_free;		/* Number of deallocations by $STKRETN.  */
    long stkm_free;		/* Number of deallocations by $STKMRET.  */
    long segments;		/* Current number of stack segments.  */
    long maxs;			/* Maximum number of stack segments so far.  */
    long pad_size;		/* Stack pad size.  */
    long current_address;	/* Current stack segment address.  */
    long current_size;		/* Current stack segment size.  This
				   number is actually corrupted by STKSTAT to
				   include the fifteen word trailer area.  */
    long initial_address;	/* Address of initial segment.  */
    long initial_size;		/* Size of initial segment.  */
  };

/* The following structure describes the data structure which trails
   any stack segment.  I think that the description in 'asdef' is
   out of date.  I only describe the parts that I am sure about.  */

struct stk_trailer
  {
    long this_address;		/* Address of this block.  */
    long this_size;		/* Size of this block (does not include
				   this trailer).  */
    long unknown2;
    long unknown3;
    long link;			/* Address of trailer block of previous
				   segment.  */
    long unknown5;
    long unknown6;
    long unknown7;
    long unknown8;
    long unknown9;
    long unknown10;
    long unknown11;
    long unknown12;
    long unknown13;
    long unknown14;
  };

#endif /* CRAY2 */
#endif /* not CRAY_STACK */

#ifdef CRAY2
/* Determine a "stack measure" for an arbitrary ADDRESS.
   I doubt that "lint" will like this much.  */

static long
i00afunc (long *address)
{
  struct stk_stat status;
  struct stk_trailer *trailer;
  long *block, size;
  long result = 0;

  /* We want to iterate through all of the segments.  The first
     step is to get the stack status structure.  We could do this
     more quickly and more directly, perhaps, by referencing the
     $LM00 common block, but I know that this works.  */

  STKSTAT (&status);

  /* Set up the iteration.  */

  trailer = (struct stk_trailer *) (status.current_address
				    + status.current_size
				    - 15);

  /* There must be at least one stack segment.  Therefore it is
     a fatal error if "trailer" is null.  */

  if (trailer == 0)
    abort ();

  /* Discard segments that do not contain our argument address.  */

  while (trailer != 0)
    {
      block = (long *) trailer->this_address;
      size = trailer->this_size;
      if (block == 0 || size == 0)
	abort ();
      trailer = (struct stk_trailer *) trailer->link;
      if ((block <= address) && (address < (block + size)))
	break;
    }

  /* Set the result to the offset in this segment and add the sizes
     of all predecessor segments.  */

  result = address - block;

  if (trailer == 0)
    {
      return result;
    }

  do
    {
      if (trailer->this_size <= 0)
	abort ();
      result += trailer->this_size;
      trailer = (struct stk_trailer *) trailer->link;
    }
  while (trailer != 0);

  /* We are done.  Note that if you present a bogus address (one
     not in any segment), you will get a different number back, formed
     from subtracting the address of the first block.  This is probably
     not what you want.  */

  return (result);
}

#else /* not CRAY2 */
/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP.
   Determine the number of the cell within the stack,
   given the address of the cell.  The purpose of this
   routine is to linearize, in some sense, stack addresses
   for alloca.  */

static long
i00afunc (long address)
{
  long stkl = 0;

  long size, pseg, this_segment, stack;
  long result = 0;

  struct stack_segment_linkage *ssptr;

  /* Register B67 contains the address of the end of the
     current stack segment.  If you (as a subprogram) store
     your registers on the stack and find that you are past
     the contents of B67, you have overflowed the segment.

     B67 also points to the stack segment linkage control
     area, which is what we are really interested in.  */

  stkl = CRAY_STACKSEG_END ();
  ssptr = (struct stack_segment_linkage *) stkl;

  /* If one subtracts 'size' from the end of the segment,
     one has the address of the first word of the segment.

     If this is not the first segment, 'pseg' will be
     nonzero.  */

  pseg = ssptr->sspseg;
  size = ssptr->sssize;

  this_segment = stkl - size;

  /* It is possible that calling this routine itself caused
     a stack overflow.  Discard stack segments which do not
     contain the target address.  */

  while (!(this_segment <= address && address <= stkl))
    {
#ifdef DEBUG_I00AFUNC
      fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
#endif
      if (pseg == 0)
	break;
      stkl = stkl - pseg;
      ssptr = (struct stack_segment_linkage *) stkl;
      size = ssptr->sssize;
      pseg = ssptr->sspseg;
      this_segment = stkl - size;
    }

  result = address - this_segment;

  /* If you subtract pseg from the current end of the stack,
     you get the address of the previous stack segment's end.
     This seems a little convoluted to me, but I'll bet you save
     a cycle somewhere.  */

  while (pseg != 0)
    {
#ifdef DEBUG_I00AFUNC
      fprintf (stderr, "%011o %011o\n", pseg, size);
#endif
      stkl = stkl - pseg;
      ssptr = (struct stack_segment_linkage *) stkl;
      size = ssptr->sssize;
      pseg = ssptr->sspseg;
      result += size;
    }
  return (result);
}

#endif /* not CRAY2 */
#endif /* CRAY */

#endif /* no alloca */
#endif /* not GCC version 2 */




/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper, <drepper@gnu.ai.mit.edu>

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

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdio.h>

#if ! defined(HAVE_WCHAR_H) || defined(__CYGWIN__)
typedef unsigned int wint_t;
# undef WEOF
# define WEOF ((wint_t)-1)
#else
#include <wchar.h>
#endif

#ifndef weak_alias
#  define __btowc btowc
#endif

/* We use UTF8 encoding for multibyte strings and therefore a valid
   one byte multibyte string only can have a value from 0 to 0x7f.  */
wint_t
__btowc (c)
     int c;
{
  if (WEOF != (wint_t) EOF || c < 0 || c > 0x7f)
    return WEOF;
  else
    return (wint_t) c;
}

#ifdef weak_alias
weak_alias (__btowc, btowc)
#endif




/* dfa.c - deterministic extended regexp routines for GNU
   Copyright (C) 1988, 1998 Free Software Foundation, Inc.

   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


   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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA */

/* Written June, 1988 by Mike Haertel
   Modified July, 1988 by Arthur David Olson to assist BMG speedups  */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <assert.h>
#include <ctype.h>
#include <stdio.h>

#include <sys/types.h>
#ifdef STDC_HEADERS
#include <stdlib.h>
#else
#include <sys/types.h>
extern char *calloc(), *malloc(), *realloc();
extern void free();
#endif

#include <strings.h>
#endif

#ifndef DEBUG	/* use the same approach as regex.c */
#undef assert
#define assert(e)
#endif /* DEBUG */

#ifndef isgraph
#define isgraph(C) (isprint(C) && !isspace(C))
#endif

#if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))
#define ISALPHA(C) isalpha(C)
#define ISUPPER(C) isupper(C)
#define ISLOWER(C) islower(C)
#define ISDIGIT(C) isdigit(C)
#define ISXDIGIT(C) isxdigit(C)
#define ISSPACE(C) isspace(C)
#define ISPUNCT(C) ispunct(C)
#define ISALNUM(C) isalnum(C)
#define ISPRINT(C) isprint(C)
#define ISGRAPH(C) isgraph(C)
#define ISCNTRL(C) iscntrl(C)
#else
#define ISALPHA(C) (isascii(C) && isalpha(C))
#define ISUPPER(C) (isascii(C) && isupper(C))
#define ISLOWER(C) (isascii(C) && islower(C))
#define ISDIGIT(C) (isascii(C) && isdigit(C))
#define ISXDIGIT(C) (isascii(C) && isxdigit(C))
#define ISSPACE(C) (isascii(C) && isspace(C))
#define ISPUNCT(C) (isascii(C) && ispunct(C))
#define ISALNUM(C) (isascii(C) && isalnum(C))
#define ISPRINT(C) (isascii(C) && isprint(C))
#define ISGRAPH(C) (isascii(C) && isgraph(C))
#define ISCNTRL(C) (isascii(C) && iscntrl(C))
#endif

/* If we (don't) have I18N.  */
/* glibc defines _ */
#ifndef _
# ifdef HAVE_LIBINTL_H
#  include <libintl.h>
#  ifndef _
#   define _(Str) gettext (Str)
#  endif
# else
#  define _(Str) (Str)
# endif
#endif

#include "regex.h"
#include "dfa.h"
#include <gnuregex.h>

/* HPUX, define those as macros in sys/param.h */
#ifdef setbit
# undef setbit
#endif
#ifdef clrbit
# undef clrbit
#endif

static void dfamust PARAMS ((struct dfa *dfa));

static ptr_t xcalloc PARAMS ((size_t n, size_t s));
static ptr_t xmalloc PARAMS ((size_t n));
static ptr_t xrealloc PARAMS ((ptr_t p, size_t n));
#ifdef DEBUG
static void prtok PARAMS ((token t));
	static char s[2][2];

	if ((unsigned char)a == (unsigned char)b)
		return 0;
	s[0][0] = a;
	s[1][0] = b;
	if ((r = strcoll(s[0], s[1])) == 0)
		r = (unsigned char)a - (unsigned char)b;
	return r;
}
#endif
static int tstbit PARAMS ((int b, charclass c));
static void setbit PARAMS ((int b, charclass c));
static void clrbit PARAMS ((int b, charclass c));
static void copyset PARAMS ((charclass src, charclass dst));
static void zeroset PARAMS ((charclass s));
static void notset PARAMS ((charclass s));
static int equal PARAMS ((charclass s1, charclass s2));
static int charclass_index PARAMS ((charclass s));
static int looking_at PARAMS ((const char *s));
static token lex PARAMS ((void));
static void addtok PARAMS ((token t));
static void atom PARAMS ((void));
static int nsubtoks PARAMS ((int tindex));
static void copytoks PARAMS ((int tindex, int ntokens));
static void closure PARAMS ((void));
static void branch PARAMS ((void));
static void regexp PARAMS ((int toplevel));
static void copy PARAMS ((position_set *src, position_set *dst));
static void insert PARAMS ((position p, position_set *s));
static void merge PARAMS ((position_set *s1, position_set *s2, position_set *m));
static void delete PARAMS ((position p, position_set *s));
static int state_index PARAMS ((struct dfa *d, position_set *s,
			  int newline, int letter));
static void build_state PARAMS ((int s, struct dfa *d));
static void build_state_zero PARAMS ((struct dfa *d));
static char *icatalloc PARAMS ((char *old, char *new));
static char *icpyalloc PARAMS ((char *string));
static char *istrstr PARAMS ((char *lookin, char *lookfor));
static void ifree PARAMS ((char *cp));
static void freelist PARAMS ((char **cpp));
static char **enlist PARAMS ((char **cpp, char *new, size_t len));
static char **comsubs PARAMS ((char *left, char *right));
static char **addlists PARAMS ((char **old, char **new));
static char **inboth PARAMS ((char **left, char **right));

static ptr_t
xcalloc(n, s)
     size_t n;
     size_t s;
{
  ptr_t r = calloc(n, s);

  if (!r)
    dfaerror(_("Memory exhausted"));
  return r;
}



  assert(n != 0);
  if (!r)
    dfaerror(_("Memory exhausted"));
  return r;
}



  assert(n != 0);
  if (!r)
    dfaerror(_("Memory exhausted"));
  return r;
}

#define CALLOC(p, t, n) ((p) = (t *) xcalloc((size_t)(n), sizeof (t)))
#define MALLOC(p, t, n) ((p) = (t *) xmalloc((n) * sizeof (t)))
#define REALLOC(p, t, n) ((p) = (t *) xrealloc((ptr_t) (p), (n) * sizeof (t)))


}

/* Syntax bits controlling the behavior of the lexical analyzer. */
static reg_syntax_t syntax_bits, syntax_bits_set;

/* Flag for case-folding letters into sets. */
static int case_fold;

/* Entry point to set syntax options. */
void
dfasyntax(bits, fold)
     reg_syntax_t bits;
     int fold;
{
  syntax_bits_set = 1;


static char *lexstart;		/* Pointer to beginning of input string. */
static char *lexptr;		/* Pointer to next input character. */
static int lexleft;		/* Number of characters remaining. */
static token lasttok;		/* Previous token returned; initially END. */
static int laststart;		/* True if we're separated from beginning or (, |
				   only by zero-width characters. */

      if (eoferr != 0)	   	      \
	dfaerror(eoferr);  	      \
      else		   	      \
	return lasttok = END;	      \
    (c) = (unsigned char) *lexptr++;  \
    --lexleft;		   	      \
  }

#ifdef __STDC__
#define FUNC(F, P) static int F(int c) { return P(c); }
#else
#define FUNC(F, P) static int F(c) int c; { return P(c); }
#endif

FUNC(is_alpha, ISALPHA)
FUNC(is_upper, ISUPPER)

FUNC(is_graph, ISGRAPH)
FUNC(is_cntrl, ISCNTRL)

static int is_blank(c)
int c;
{
   return (c == ' ' || c == '\t');
}

/* The following list maps the names of the Posix named character classes
   to predicate functions that determine whether a given character is in
   the class.  The leading [ has already been eaten by the lexical analyzer. */
static struct {
  const char *name;
  int (*pred) PARAMS ((int));
} prednames[] = {
  { ":alpha:]", is_alpha },
  { ":upper:]", is_upper },
  { ":lower:]", is_lower },
  { ":digit:]", is_digit },
  { ":xdigit:]", is_xdigit },
  { ":space:]", is_space },
  { ":punct:]", is_punct },
  { ":alnum:]", is_alnum },
  { ":print:]", is_print },
  { ":graph:]", is_graph },
  { ":cntrl:]", is_cntrl },
  { ":blank:]", is_blank },
  { 0 }
};

/* Return non-zero if C is a `word-constituent' byte; zero otherwise.  */
#define IS_WORD_CONSTITUENT(C) (ISALNUM(C) || (C) == '_')

static int
looking_at(s)
     const char *s;
{
  size_t len;

  len = strlen(s);
  if (lexleft < len)

	  if (backslash)
	    goto normal_char;
	  if (lexleft == 0)
	    dfaerror(_("Unfinished \\ escape"));
	  backslash = 1;
	  break;


	    }
	  goto normal_char;

	case '`':
	  if (backslash && !(syntax_bits & RE_NO_GNU_OPS))
	    return lasttok = BEGLINE;	/* FIXME: should be beginning of string */
	  goto normal_char;

	case '\'':
	  if (backslash && !(syntax_bits & RE_NO_GNU_OPS))
	    return lasttok = ENDLINE;	/* FIXME: should be end of string */
	  goto normal_char;

	case '<':
	  if (backslash && !(syntax_bits & RE_NO_GNU_OPS))
	    return lasttok = BEGWORD;
	  goto normal_char;

	case '>':
	  if (backslash && !(syntax_bits & RE_NO_GNU_OPS))
	    return lasttok = ENDWORD;
	  goto normal_char;

	case 'b':
	  if (backslash && !(syntax_bits & RE_NO_GNU_OPS))
	    return lasttok = LIMWORD;
	  goto normal_char;

	case 'B':
	  if (backslash && !(syntax_bits & RE_NO_GNU_OPS))
	    return lasttok = NOTLIMWORD;
	  goto normal_char;


	     {M,} - minimum count, maximum is infinity
	     {,M} - 0 through M
	     {M,N} - M through N */
	  FETCH(c, _("unfinished repeat count"));
	  if (ISDIGIT(c))
	    {
	      minrep = c - '0';
	      for (;;)
		{
		  FETCH(c, _("unfinished repeat count"));
		  if (!ISDIGIT(c))
		    break;
		  minrep = 10 * minrep + c - '0';
		}
	    }
	  else if (c != ',')
	    dfaerror(_("malformed repeat count"));
	  if (c == ',')
	    for (;;)
	      {
		FETCH(c, _("unfinished repeat count"));
		if (!ISDIGIT(c))
		  break;
		maxrep = 10 * maxrep + c - '0';

	  if (!(syntax_bits & RE_NO_BK_BRACES))
	    {
	      if (c != '\\')
		dfaerror(_("malformed repeat count"));
	      FETCH(c, _("unfinished repeat count"));
	    }
	  if (c != '}')
	    dfaerror(_("malformed repeat count"));
	  laststart = 0;
	  return lasttok = REPMN;



	case 'w':
	case 'W':
	  if (!backslash || (syntax_bits & RE_NO_GNU_OPS))
	    goto normal_char;
	  zeroset(ccl);
	  for (c2 = 0; c2 < NOTCHAR; ++c2)
	    if (IS_WORD_CONSTITUENT(c2))
	      setbit(c2, ccl);
	  if (c == 'W')
	    notset(ccl);

	  if (backslash)
	    goto normal_char;
	  zeroset(ccl);
	  FETCH(c, _("Unbalanced ["));
	  if (c == '^')
	    {
	      FETCH(c, _("Unbalanced ["));
	      invert = 1;
	    }
	  else

		for (c1 = 0; prednames[c1].name; ++c1)
		  if (looking_at(prednames[c1].name))
		    {
			int (*pred)() = prednames[c1].pred;
			if (case_fold
			    && (pred == is_upper || pred == is_lower))
				pred = is_alpha;

		      for (c2 = 0; c2 < NOTCHAR; ++c2)
			if ((*pred)(c2))
			  setbit(c2, ccl);
		      lexptr += strlen(prednames[c1].name);
		      lexleft -= strlen(prednames[c1].name);
		      FETCH(c1, _("Unbalanced ["));
		      goto skip;
		    }
	      if (c == '\\' && (syntax_bits & RE_BACKSLASH_ESCAPE_IN_LISTS))
		FETCH(c, _("Unbalanced ["));
	      FETCH(c1, _("Unbalanced ["));
	      if (c1 == '-')
		{
		  FETCH(c2, _("Unbalanced ["));
		  if (c2 == ']')
		    {
		      /* In the case [x-], the - is an ordinary hyphen,

		    {
		      if (c2 == '\\'
			  && (syntax_bits & RE_BACKSLASH_ESCAPE_IN_LISTS))
			FETCH(c2, _("Unbalanced ["));
		      FETCH(c1, _("Unbalanced ["));
		    }
		}
	      else
		c2 = c;
#ifdef __FreeBSD__
	      { token c3;

		if (collate_range_cmp(c, c2) > 0) {
		  FETCH(c2, "Invalid range");
		  goto skip;
		}

		for (c3 = 0; c3 < NOTCHAR; ++c3)
		  if (   collate_range_cmp(c, c3) <= 0
		      && collate_range_cmp(c3, c2) <= 0
		     ) {
		    setbit(c3, ccl);
		    if (case_fold)
		      if (ISUPPER(c3))
			setbit(tolower((unsigned char)c3), ccl);
		      else if (ISLOWER(c3))
			setbit(toupper((unsigned char)c3), ccl);
		  }
	      }
#else
	      while (c <= c2)
		{
		  setbit(c, ccl);
		  if (case_fold)
		    if (ISUPPER(c))
		      setbit(tolower(c), ccl);
		    else if (ISLOWER(c))
		      setbit(toupper(c), ccl);
		  ++c;
		}
#endif
	    skip:
	      ;
	    }

	    {
	      zeroset(ccl);
	      setbit(c, ccl);
	      if (isupper(c))
		setbit(tolower(c), ccl);
	      else
		setbit(toupper(c), ccl);
	      return lasttok = CSET + charclass_index(ccl);
	    }
	  return c;

  /* The above loop should consume at most a backslash
     and some other character. */
  abort();
  return END;	/* keeps pedantic compilers happy. */
}

/* Recursive descent parser for regular expressions. */

static token tok;		/* Lookahead token. */
static int depth;		/* Current depth of a hypothetical stack
				   holding deferred productions.  This is
				   used to determine the depth that will be
				   required of the real stack later on in


   The parser builds a parse tree in postfix form in an array of tokens. */

#if __STDC__
static void regexp(int);
#else
static void regexp();
#endif

static void
atom()
{

      tok = lex();
      regexp(0);
      if (tok != RPAREN)
	dfaerror(_("Unbalanced ("));
      tok = lex();
    }
  else

/* Return the number of tokens in the given subexpression. */
static int
nsubtoks(tindex)
int tindex;
{
  int ntoks1;


  parens = 0;

  if (! syntax_bits_set)
    dfaerror(_("No syntax specified"));

  tok = lex();
  depth = d->depth;

  regexp(1);

  if (tok != END)
    dfaerror(_("Unbalanced )"));

  addtok(END - d->nregexps);
  addtok(CAT);

  position t1, t2;

  for (i = 0; i < s->nelem && p.index < s->elems[i].index; ++i)
    continue;
  if (i < s->nelem && p.index == s->elems[i].index)
    s->elems[i].constraint |= p.constraint;
  else

   that position with the elements of its follow labeled with an appropriate
   constraint.  Repeat exhaustively until no funny positions are left.
   S->elems must be large enough to hold the result. */
static void epsclosure PARAMS ((position_set *s, struct dfa *d));

static void
epsclosure(s, d)
     position_set *s;
     struct dfa *d;

  int state_newline;		/* New state on a newline transition. */
  int wants_letter;		/* New state wants to know letter context. */
  int state_letter;		/* New state on a letter transition. */
  static int initialized;	/* Flag for static initialization. */
  int i, j, k;

  /* Initialize the set of letters, if necessary. */

    {
      initialized = 1;
      for (i = 0; i < NOTCHAR; ++i)
	if (IS_WORD_CONSTITUENT(i))
	  setbit(i, letters);
      setbit('\n', newline);
    }


	  /* If there are no characters left, there's no point in going on. */
	  for (j = 0; j < CHARCLASS_INTS && !matches[j]; ++j)
	    continue;
	  if (j == CHARCLASS_INTS)
	    continue;
	}

	     matches. */
	  intersectf = 0;
	  for (k = 0; k < CHARCLASS_INTS; ++k)
	    (intersect[k] = matches[k] & labels[j][k]) ? (intersectf = 1) : 0;
	  if (! intersectf)
	    continue;


	      /* Even an optimizing compiler can't know this for sure. */
	      int match = matches[k], label = labels[j][k];

	      (leftovers[k] = ~match & label) ? (leftoversf = 1) : 0;
	      (matches[k] = match & ~label) ? (matchesf = 1) : 0;
	    }

	  /* If there were leftovers, create a new group labeled with them. */

      else
	state_letter = state;
      for (i = 0; i < NOTCHAR; ++i)
	trans[i] = (IS_WORD_CONSTITUENT(i)) ? state_letter : state;
      trans['\n'] = state_newline;
	else if (ISALNUM(i))
	  trans[i] = state_letter;
	else
	  trans[i] = state;
    }
  else
    for (i = 0; i < NOTCHAR; ++i)


	      if (c == '\n')
		trans[c] = state_newline;
	      else if (IS_WORD_CONSTITUENT(c))
		trans[c] = state_letter;
	      else if (c < NOTCHAR)
		trans[c] = state;

     int *count;
     int *backref;
{
  register int s, s1, tmp;	/* Current state. */
  register unsigned char *p;	/* Current input character. */
  register int **trans, *t;	/* Copy of d->trans so it can be optimized
				   into a register. */
  static int sbit[NOTCHAR];	/* Table for anding with d->success. */
  static int sbit_init;

  if (! sbit_init)
    {


      sbit_init = 1;
      for (i = 0; i < NOTCHAR; ++i)
	sbit[i] = (IS_WORD_CONSTITUENT(i)) ? 2 : 1;
      sbit['\n'] = 4;
	else if (ISALNUM(i))
	  sbit[i] = 2;
	else
	  sbit[i] = 1;
    }

  if (! d->tralloc)


  for (;;)
    {
      while ((t = trans[s]) != 0) { /* hand-optimized loop */
	s1 = t[*p++];
        if ((t = trans[s1]) == 0) {
           tmp = s ; s = s1 ; s1 = tmp ; /* swap */
           break;
        }
	s = t[*p++];
      }
	  }
        while ((t = trans[s]) != 0);
      goto last_was_s1;
    last_was_s:
      tmp = s, s = s1, s1 = tmp;
    last_was_s1:

      if (s >= 0 && p <= (unsigned char *) end && d->fails[s])
	{
	  if (d->success[s] & sbit[*p])
	    {
	      if (backref)
		*backref = (d->states[s].backref != 0);
		  *backref = 1;
		else
		  *backref = 0;
	      return (char *) p;
	    }


{
  if (case_fold)	/* dummy folding in service of dfamust() */
    {
      char *lcopy;
      int i;

      lcopy = malloc(len);
      if (!lcopy)
	dfaerror(_("out of memory"));

      /* This is a kludge. */
      case_fold = 0;
      for (i = 0; i < len; ++i)
	if (ISUPPER ((unsigned char) s[i]))
	  lcopy[i] = tolower ((unsigned char) s[i]);
	else
	  lcopy[i] = s[i];

      dfainit(d);
      dfaparse(lcopy, len, d);
      free(lcopy);
      dfamust(d);
      d->cindex = d->tindex = d->depth = d->nleaves = d->nregexps = 0;
      case_fold = 1;

      free((ptr_t) d->trans[i]);
    else if (d->fails[i])
      free((ptr_t) d->fails[i]);
  if (d->realtrans) free((ptr_t) d->realtrans);
  if (d->fails) free((ptr_t) d->fails);
  if (d->newlines) free((ptr_t) d->newlines);
  if (d->success) free((ptr_t) d->success);
  for (dm = d->musts; dm; dm = ndm)
    {
      ndm = dm->next;

     char *new;
{
  char *result;
  size_t oldsize, newsize;

  newsize = (new == NULL) ? 0 : strlen(new);
  if (old == NULL)

     char *lookfor;
{
  char *cp;
  size_t len;

  len = strlen(lookfor);
  for (cp = lookin; *cp != '\0'; ++cp)

enlist(cpp, new, len)
     char **cpp;
     char *new;
     size_t len;
{
  int i, j;


  char **cpp;
  char *lcp;
  char *rcp;
  size_t i, len;

  if (left == NULL || right == NULL)
    return NULL;

      while (rcp != NULL)
	{
	  for (i = 1; lcp[i] != '\0' && lcp[i] == rcp[i]; ++i)
	    continue;
	  if (i > len)
	    len = i;
	  rcp = index(rcp + 1, *lcp);

	    }
	  both = addlists(both, temp);
	  freelist(temp);
	  free(temp);
	  if (both == NULL)
	    return NULL;
	}

  token t;
  static must must0;
  struct dfamust *dm;
  static char empty_string[] = "";

  result = empty_string;
  exact = 0;
  musts = (must *) malloc((dfa->tindex + 1) * sizeof *musts);
  if (musts == NULL)

	      resetmust(mp);
	      mp->is[0] = mp->left[0] = mp->right[0] = t;
	      mp->is[1] = mp->left[1] = mp->right[1] = '\0';
	      mp->in = enlist(mp->in, mp->is, (size_t)1);
	      if (mp->in == NULL)
		goto done;
	    }




/* dfa.h - declarations for GNU deterministic regexp compiler
   Copyright (C) 1988, 1998 Free Software Foundation, Inc.

   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


   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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA */

/* Written June, 1988 by Mike Haertel */


   In addition to clobbering modularity, we eat up valuable
   name space. */

# undef PARAMS
#if __STDC__
# ifndef _PTR_T
# define _PTR_T
  typedef void * ptr_t;
# endif
# define PARAMS(x) x
#else
# ifndef _PTR_T
# define _PTR_T
  typedef char * ptr_t;
# endif
# define PARAMS(x) ()
#endif

/* Number of bits in an unsigned char. */
#ifndef CHARBITS
#define CHARBITS 8
#endif

/* First integer value that is greater than any character code. */
#define NOTCHAR (1 << CHARBITS)

/* INTBITS need not be exact, just a lower bound. */
#ifndef INTBITS
#define INTBITS (CHARBITS * sizeof (int))
#endif

/* Number of ints required to hold a bit for every character. */
#define CHARCLASS_INTS ((NOTCHAR + INTBITS - 1) / INTBITS)


/* Entry points. */

#if __STDC__

/* dfasyntax() takes two arguments; the first sets the syntax bits described
   earlier in this file, and the second sets the case-folding flag. */
extern void dfasyntax PARAMS ((reg_syntax_t, int));

/* Compile the given string of the given length into the given struct dfa.
   Final argument is a flag specifying whether to build a searching or an
   exact matcher. */
extern void dfacomp PARAMS ((char *, size_t, struct dfa *, int));

/* Execute the given struct dfa on the buffer of characters.  The
   first char * points to the beginning, and the second points to the

   order to verify backreferencing; otherwise the flag will be cleared.
   Returns NULL if no match is found, or a pointer to the first
   character after the first & shortest matching string in the buffer. */
extern char *dfaexec PARAMS ((struct dfa *, char *, char *, int, int *, int *));

/* Free the storage held by the components of a struct dfa. */
extern void dfafree PARAMS ((struct dfa *));

/* Entry points for people who know what they're doing. */

/* Initialize the components of a struct dfa. */
extern void dfainit PARAMS ((struct dfa *));

/* Incrementally parse a string of given length into a struct dfa. */
extern void dfaparse PARAMS ((char *, size_t, struct dfa *));

/* Analyze a parsed regexp; second argument tells whether to build a searching
   or an exact matcher. */
extern void dfaanalyze PARAMS ((struct dfa *, int));

/* Compute, for each possible character, the transitions out of a given
   state, storing them in an array of integers. */
extern void dfastate PARAMS ((int, struct dfa *, int []));

/* Error handling. */


   takes a single argument, a NUL-terminated string describing the error.
   The default dfaerror() prints the error message to stderr and exits.
   The user can provide a different dfafree() if so desired. */
extern void dfaerror PARAMS ((const char *));

#else /* ! __STDC__ */
extern void dfasyntax(), dfacomp(), dfafree(), dfainit(), dfaparse();
extern void dfaanalyze(), dfastate(), dfaerror();
extern char *dfaexec();
#endif /* ! __STDC__ */




/* Messy DOS-specific code for correctly treating binary, Unix text
   and DOS text files.

   This has several aspects:

     * Guessing the file type (unless the user tells us);
     * Stripping CR characters from DOS text files (otherwise regex
       functions won't work correctly);
     * Reporting correct byte count with -b for any kind of file.

*/

typedef enum {
  UNKNOWN, DOS_BINARY, DOS_TEXT, UNIX_TEXT
} File_type;

struct dos_map {
  off_t pos;	/* position in buffer passed to matcher */
  off_t add;	/* how much to add when reporting char position */
};

static int       dos_report_unix_offset = 0;

static File_type dos_file_type     = UNKNOWN;
static File_type dos_use_file_type = UNKNOWN;
static off_t     dos_stripped_crs  = 0;
static struct dos_map *dos_pos_map;
static int       dos_pos_map_size  = 0;
static int       dos_pos_map_used  = 0;
static int       inp_map_idx = 0, out_map_idx = 1;

/* Guess DOS file type by looking at its contents.  */
static inline File_type
guess_type(buf, buflen)
	char *buf;
	register size_t buflen;
{
  int crlf_seen = 0;
  register char *bp = buf;

  while (buflen--)
    {
      /* Treat a file as binary if it has a NUL character.  */
      if (!*bp)
        return DOS_BINARY;

      /* CR before LF means DOS text file (unless we later see
         binary characters).  */
      else if (*bp == '\r' && buflen && bp[1] == '\n')
        crlf_seen = 1;

      bp++;
    }

  return crlf_seen ? DOS_TEXT : UNIX_TEXT;
}

/* Convert external DOS file representation to internal.
   Return the count of characters left in the buffer.
   Build table to map character positions when reporting byte counts.  */
static inline int
undossify_input(buf, buflen)
	register char *buf;
	size_t buflen;
{
  int chars_left = 0;

  if (totalcc == 0)
    {
      /* New file: forget everything we knew about character
         position mapping table and file type.  */
      inp_map_idx = 0;
      out_map_idx = 1;
      dos_pos_map_used = 0;
      dos_stripped_crs = 0;
      dos_file_type = dos_use_file_type;
    }

  /* Guess if this file is binary, unless we already know that.  */
  if (dos_file_type == UNKNOWN)
    dos_file_type = guess_type(buf, buflen);

  /* If this file is to be treated as DOS Text, strip the CR characters
     and maybe build the table for character position mapping on output.  */
  if (dos_file_type == DOS_TEXT)
    {
      char   *destp   = buf;

      while (buflen--)
        {
          if (*buf != '\r')
            {
              *destp++ = *buf++;
              chars_left++;
            }
          else
            {
              buf++;
              if (out_byte && !dos_report_unix_offset)
                {
                  dos_stripped_crs++;
                  while (buflen && *buf == '\r')
                    {
                      dos_stripped_crs++;
                      buflen--;
                      buf++;
                    }
                  if (inp_map_idx >= dos_pos_map_size - 1)
                    {
                      dos_pos_map_size = inp_map_idx ? inp_map_idx * 2 : 1000;
                      dos_pos_map =
                        (struct dos_map *)xrealloc((char *)dos_pos_map,
						   dos_pos_map_size *
						   sizeof(struct dos_map));
                    }

                  if (!inp_map_idx)
                    {
                      /* Add sentinel entry.  */
                      dos_pos_map[inp_map_idx].pos = 0;
                      dos_pos_map[inp_map_idx++].add = 0;

                      /* Initialize first real entry.  */
                      dos_pos_map[inp_map_idx].add = 0;
                    }

                  /* Put the new entry.  If the stripped CR characters
                     precede a Newline (the usual case), pretend that
                     they were found *after* the Newline.  This makes
                     displayed byte offsets more reasonable in some
                     cases, and fits better the intuitive notion that
                     the line ends *before* the CR, not *after* it.  */
                  inp_map_idx++;
                  dos_pos_map[inp_map_idx-1].pos =
                    (*buf == '\n' ? destp + 1 : destp ) - bufbeg + totalcc;
                  dos_pos_map[inp_map_idx].add = dos_stripped_crs;
                  dos_pos_map_used = inp_map_idx;

                  /* The following will be updated on the next pass.  */
                  dos_pos_map[inp_map_idx].pos = destp - bufbeg + totalcc + 1;
                }
            }
        }

      return chars_left;
    }

  return buflen;
}

/* Convert internal byte count into external.  */
static inline off_t
dossified_pos (byteno)
	off_t byteno;
{
  off_t pos_lo;
  off_t pos_hi;

  if (dos_file_type != DOS_TEXT || dos_report_unix_offset)
    return byteno;

  /* Optimization: usually the file will be scanned sequentially.
     So in most cases, this byte position will be found in the
     table near the previous one, as recorded in `out_map_idx'.  */
  pos_lo = dos_pos_map[out_map_idx-1].pos;
  pos_hi = dos_pos_map[out_map_idx].pos;

  /* If the initial guess failed, search up or down, as
     appropriate, beginning with the previous place.  */
  if (byteno >= pos_hi)
    {
      out_map_idx++;
      while (out_map_idx < dos_pos_map_used &&
             byteno >= dos_pos_map[out_map_idx].pos)
        out_map_idx++;
    }

  else if (byteno < pos_lo)
    {
      out_map_idx--;
      while (out_map_idx > 1 && byteno < dos_pos_map[out_map_idx-1].pos)
        out_map_idx--;
    }

  return byteno + dos_pos_map[out_map_idx].add;
}

Line 0 Link Here

(-)grep/egrepmat.c (+6 lines)
	1	#ifdef HAVE_CONFIG_H
	2	# include <config.h>
	3	#endif
	4	#include "system.h"
	5	#include "grep.h"
	6	char const default_matcher[] = "egrep";

Line 0 Link Here

(-)grep/fgrepmat.c (+6 lines)
	1	#ifdef HAVE_CONFIG_H
	2	# include <config.h>
	3	#endif
	4	#include "system.h"
	5	#include "grep.h"
	6	char const default_matcher[] = "fgrep";




   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
   before changing it!

   Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97
   	Free Software Foundation, Inc.

   This file is part of the GNU C Library.  Its master source is NOT part of
   the C library, however.  The master source lives in /gd/gnu/lib.
   Free Software Foundation; either version 2, or (at your option) any
   later version.

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

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
   Ditto for AIX 3.2 and <stdlib.h>.  */
#ifndef _NO_PROTO
#define _NO_PROTO
#endif

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not __GNUC__ */
#if defined (HAVE_ALLOCA_H) || (defined(sparc) && (defined(sun) || (!defined(USG) && !defined(SVR4) && !defined(__svr4__))))
#include <alloca.h>
#else
#ifndef _AIX
char *alloca ();
#endif
#endif /* alloca.h */
#endif /* not __GNUC__ */

#if !defined (__STDC__) || !__STDC__
/* This is a separate conditional since some stdc systems
   reject `defined (const)'.  */
#ifndef const
#define const
#endif

/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.  */
#ifndef _NO_PROTO
#define _NO_PROTO
#endif

#include <stdio.h>

   program understand `configure --with-gnu-libc' and omit the object files,
   it is simpler to just do this in the source for each such file.  */

#define GETOPT_INTERFACE_VERSION 2
#if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
#include <gnu-versions.h>
#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
#define ELIDE_CODE
#endif
#endif

#ifndef ELIDE_CODE


/* This needs to come after some library #include
   to get __GNU_LIBRARY__ defined.  */
#ifdef	__GNU_LIBRARY__
#undef	alloca
/* Don't include stdlib.h for non-GNU C libraries because some of them
   contain conflicting prototypes for getopt.  */
#include <stdlib.h>
#include <unistd.h>
#define	__alloca	alloca
#endif	/* GNU C library.  */

#ifdef VMS
#include <unixlib.h>
#if HAVE_STRING_H - 0
#include <string.h>
#endif
#endif

#if defined (WIN32) && !defined (__CYGWIN32__)
/* It's not Unix, really.  See?  Capital letters.  */
#include <windows.h>
#define getpid() GetCurrentProcessId()
#endif

#ifndef _
/* This is for other GNU distributions with internationalized messages.
   When compiling libc, the _ macro is predefined.  */
#ifdef HAVE_LIBINTL_H
# include <libintl.h>
# define _(msgid)	gettext (msgid)
#else
# define _(msgid)	(msgid)
#endif
#endif

/* This version of `getopt' appears to the caller like standard Unix `getopt'
   but it behaves differently for the user, since it allows the user

   Also, when `ordering' is RETURN_IN_ORDER,
   each non-option ARGV-element is returned here.  */

char *optarg = NULL;

/* Index in ARGV of the next element to be scanned.
   This is used for communication to and from the caller


   On entry to `getopt', zero means this is the first call; initialize.

   When `getopt' returns -1, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `optind' communicates from one call to the next
   how much of ARGV has been scanned so far.  */

/* 1003.2 says this must be 1 before any call.  */
int optind = 1;

/* Formerly, initialization of getopt depended on optind==0, which
   causes problems with re-calling getopt as programs generally don't
   know that. */

int __getopt_initialized = 0;

/* The next char to be scanned in the option-element
   in which the last option character we returned was found.


   The special argument `--' forces an end of option-scanning regardless
   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */

static enum
{
  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
} ordering;

/* Value of POSIXLY_CORRECT environment variable.  */
static char *posixly_correct;

#ifdef	__GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries

   in GCC.  */
#include <string.h>
#define	my_index	strchr
#define	my_bcopy(src, dst, n)	memcpy ((dst), (src), (n))
#else

/* Avoid depending on library functions or files

  return 0;
}

/* If using GCC, we can safely declare strlen this way.
   If not using GCC, it is ok not to declare it.  */
#ifdef __GNUC__
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
   That was relevant to code that was here before.  */
#if !defined (__STDC__) || !__STDC__
/* gcc with -traditional declares the built-in strlen to return int,
   and has done so at least since version 2.4.5. -- rms.  */
extern int strlen (const char *);
#endif /* not __STDC__ */
#endif /* __GNUC__ */

#endif /* not __GNU_LIBRARY__ */

/* Handle permutation of arguments.  */


static int first_nonopt;
static int last_nonopt;

#ifdef _LIBC
/* Bash 2.0 gives us an environment variable containing flags
   indicating ARGV elements that should not be considered arguments.  */

static const char *nonoption_flags;
static int nonoption_flags_len;

static int original_argc;
static char *const *original_argv;

/* Make sure the environment variable bash 2.0 puts in the environment
   is valid for the getopt call we must make sure that the ARGV passed
   to getopt is that one passed to the process.  */
static void store_args (int argc, char *const *argv) __attribute__ ((unused));
static void
store_args (int argc, char *const *argv)
{
  /* XXX This is no good solution.  We should rather copy the args so
     that we can compare them later.  But we must not use malloc(3).  */
  original_argc = argc;
  original_argv = argv;
}
text_set_element (__libc_subinit, store_args);
#endif

/* Exchange two adjacent subsequences of ARGV.
   One subsequence is elements [first_nonopt,last_nonopt)
   which contains all the non-options that have been skipped so far.

   `first_nonopt' and `last_nonopt' are relocated so that they describe
   the new indices of the non-options in ARGV after they are moved.  */

#if defined (__STDC__) && __STDC__
static void exchange (char **);
#endif

static void
exchange (argv)
     char **argv;
{
  int bottom = first_nonopt;
  int middle = last_nonopt;
  int top = optind;
  char *tem;

  /* Exchange the shorter segment with the far end of the longer segment.
     That puts the shorter segment into the right place.
     It leaves the longer segment in the right place overall,
     but it consists of two parts that need to be swapped next.  */

  while (top > middle && middle > bottom)
    {
      if (top - middle > middle - bottom)
	{
	  /* Bottom segment is the short one.  */
	  int len = middle - bottom;
	  register int i;

	  /* Swap it with the top part of the top segment.  */
	  for (i = 0; i < len; i++)
	    {
	      tem = argv[bottom + i];
	      argv[bottom + i] = argv[top - (middle - bottom) + i];
	      argv[top - (middle - bottom) + i] = tem;
	    }
	  /* Exclude the moved bottom segment from further swapping.  */
	  top -= len;
	}
      else
	{
	  /* Top segment is the short one.  */
	  int len = top - middle;
	  register int i;

	  /* Swap it with the bottom part of the bottom segment.  */
	  for (i = 0; i < len; i++)
	    {
	      tem = argv[bottom + i];
	      argv[bottom + i] = argv[middle + i];
	      argv[middle + i] = tem;
	    }
	  /* Exclude the moved top segment from further swapping.  */
	  bottom += len;
	}
    }

  /* Update records for the slots the non-options now occupy.  */

  first_nonopt += (optind - last_nonopt);
  last_nonopt = optind;
}

/* Initialize the internal data when the first call is made.  */

#if defined (__STDC__) && __STDC__
static const char *_getopt_initialize (int, char *const *, const char *);
#endif
static const char *
_getopt_initialize (argc, argv, optstring)
     int argc;
     char *const *argv;
     const char *optstring;
{
  /* Start processing options with ARGV-element 1 (since ARGV-element 0
     is the program name); the sequence of previously skipped
     non-option ARGV-elements is empty.  */

  first_nonopt = last_nonopt = optind = 1;

  nextchar = NULL;

  posixly_correct = getenv ("POSIXLY_CORRECT");

  /* Determine how to handle the ordering of options and nonoptions.  */

  if (optstring[0] == '-')
    {
      ordering = RETURN_IN_ORDER;
      ++optstring;
    }
  else if (optstring[0] == '+')
    {
      ordering = REQUIRE_ORDER;
      ++optstring;
    }
  else if (posixly_correct != NULL)
    ordering = REQUIRE_ORDER;
  else
    ordering = PERMUTE;

#ifdef _LIBC
  if (posixly_correct == NULL
      && argc == original_argc && argv == original_argv)
    {
      /* Bash 2.0 puts a special variable in the environment for each
	 command it runs, specifying which ARGV elements are the results of
	 file name wildcard expansion and therefore should not be
	 considered as options.  */
      char var[100];
      sprintf (var, "_%d_GNU_nonoption_argv_flags_", getpid ());
      nonoption_flags = getenv (var);
      if (nonoption_flags == NULL)
	nonoption_flags_len = 0;
      else
	nonoption_flags_len = strlen (nonoption_flags);
    }
  else
    nonoption_flags_len = 0;
#endif

  return optstring;
}

/* Scan elements of ARGV (whose length is ARGC) for option characters
   given in OPTSTRING.

   updating `optind' and `nextchar' so that the next call to `getopt' can
   resume the scan with the following option character or ARGV-element.

   If there are no more option characters, `getopt' returns -1.
   Then `optind' is the index in ARGV of the first ARGV-element
   that is not an option.  (The ARGV-elements have been permuted
   so that those that are not options now come last.)

     int *longind;
     int long_only;
{
  optarg = NULL;

  if (!__getopt_initialized || optind == 0)

  /* Initialize the internal data when the first call is made.
     Start processing options with ARGV-element 1 (since ARGV-element 0
     is the program name); the sequence of previously skipped
     non-option ARGV-elements is empty.  */

  if (optind == 0)
    {
      optstring = _getopt_initialize (argc, argv, optstring);
      optind = 1;		/* Don't scan ARGV[0], the program name.  */
      __getopt_initialized = 1;

      /* Determine how to handle the ordering of options and nonoptions.  */

      if (optstring[0] == '-')
	{
	  ordering = RETURN_IN_ORDER;
	  ++optstring;
	}
      else if (optstring[0] == '+')
	{
	  ordering = REQUIRE_ORDER;
	  ++optstring;
	}
      else if (getenv ("POSIXLY_CORRECT") != NULL)
	ordering = REQUIRE_ORDER;
      else
	ordering = PERMUTE;
    }

  /* Test whether ARGV[optind] points to a non-option argument.
     Either it does not have option syntax, or there is an environment flag
     from the shell indicating it is not an option.  The later information
     is only used when the used in the GNU libc.  */
#ifdef _LIBC
#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'	      \
		     || (optind < nonoption_flags_len			      \
			 && nonoption_flags[optind] == '1'))
#else
#define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
#endif

  if (nextchar == NULL || *nextchar == '\0')
    {
      /* Advance to the next ARGV-element.  */

      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
	 moved back by the user (who may also have changed the arguments).  */
      if (last_nonopt > optind)
	last_nonopt = optind;
      if (first_nonopt > optind)
	first_nonopt = optind;

      if (ordering == PERMUTE)
	{
	  /* If we have just processed some options following some non-options,

	  else if (last_nonopt != optind)
	    first_nonopt = optind;

	  /* Skip any additional non-options
	     and extend the range of non-options previously skipped.  */

	  while (optind < argc && NONOPTION_P)
		 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
#ifdef GETOPT_COMPAT
		 && (longopts == NULL
		     || argv[optind][0] != '+' || argv[optind][1] == '\0')
#endif				/* GETOPT_COMPAT */
		 )
	    optind++;
	  last_nonopt = optind;
	}

      /* The special ARGV-element `--' means premature end of options.
	 Skip it like a null option,
	 then exchange with previous non-options as if it were an option,
	 then skip everything else like a non-option.  */

	     that we previously skipped, so the caller will digest them.  */
	  if (first_nonopt != last_nonopt)
	    optind = first_nonopt;
	  return -1;
	}

      /* If we have come to a non-option and did not permute it,
	 either stop the scan or describe it to the caller and pass it by.  */

      if (NONOPTION_P)
#ifdef GETOPT_COMPAT
	  && (longopts == NULL
	      || argv[optind][0] != '+' || argv[optind][1] == '\0')
#endif				/* GETOPT_COMPAT */
	  )
	{
	  if (ordering == REQUIRE_ORDER)
	    return -1;
	  optarg = argv[optind++];
	  return 1;
	}

      /* We have found another option-ARGV-element.
	 Skip the initial punctuation.  */

      nextchar = (argv[optind] + 1
		  + (longopts != NULL && argv[optind][1] == '-'));
    }

  /* Decode the current option-ARGV-element.  */

  /* Check whether the ARGV-element is a long option.

     If long_only and the ARGV-element has the form "-f", where f is
     a valid short option, don't consider it an abbreviated form of
     a long option that starts with f.  Otherwise there would be no
     way to give the -f short option.

     On the other hand, if there's a long option "fubar" and
     the ARGV-element is "-fu", do consider that an abbreviation of
     the long option, just like "--fu", and not "-f" with arg "u".

     This distinction seems to be the most useful approach.  */

  if (longopts != NULL
      && (argv[optind][1] == '-'
	  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
#ifdef GETOPT_COMPAT
	  || argv[optind][0] == '+'
#endif				/* GETOPT_COMPAT */
	  ))
    {
      char *nameend;
      const struct option *p;
      const struct option *pfound = NULL;
      int exact = 0;
      int ambig = 0;
      int indfound = -1;
      int option_index;

      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
	/* Do nothing.  */ ;

      /* Test all long options for either exact match
	 or abbreviated matches.  */
      for (p = longopts, option_index = 0; p->name; p++, option_index++)
	if (!strncmp (p->name, nextchar, nameend - nextchar))
	  {
	    if ((unsigned int) (nameend - nextchar)
		== (unsigned int) strlen (p->name))
	      {
		/* Exact match found.  */
		pfound = p;

		indfound = option_index;
	      }
	    else
	      /* Second or later nonexact match found.  */
	      ambig = 1;
	  }

      if (ambig && !exact)
	{
	  if (opterr)
	    fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
		     argv[0], argv[optind]);
	  nextchar += strlen (nextchar);
	  optind++;
	  optopt = 0;
	  return '?';
	}


	{
	  option_index = indfound;
	  optind++;
	  if (*nameend)
	    {
	      /* Don't test has_arg with >, because some C compilers don't
		 allow it to be used on enums.  */
	      if (pfound->has_arg)
		optarg = nameend + 1;
	      else
		{
		  if (opterr)
		   if (argv[optind - 1][1] == '-')
		    /* --option */
		    fprintf (stderr,
		     _("%s: option `--%s' doesn't allow an argument\n"),
		     argv[0], pfound->name);
		   else
		    /* +option or -option */
		    fprintf (stderr,
		     _("%s: option `%c%s' doesn't allow an argument\n"),
		     argv[0], argv[optind - 1][0], pfound->name);

		    }
		  nextchar += strlen (nextchar);

		  optopt = pfound->val;
		  return '?';
		}
	    }

	      else
		{
		  if (opterr)
		    fprintf (stderr,
			   _("%s: option `%s' requires an argument\n"),
			   argv[0], argv[optind - 1]);
		  nextchar += strlen (nextchar);
		  optopt = pfound->val;
		  return optstring[0] == ':' ? ':' : '?';
		}
	    }

	    }
	  return pfound->val;
	}

      /* Can't find it as a long option.  If this is not getopt_long_only,
	 or the option starts with '--' or is not a valid short
	 option, then it's an error.
	 Otherwise interpret it as a short option.  */
      if (!long_only || argv[optind][1] == '-'
#ifdef GETOPT_COMPAT
	  || argv[optind][0] == '+'
#endif				/* GETOPT_COMPAT */
	  || my_index (optstring, *nextchar) == NULL)
	{
	  if (opterr)
	    {
	      if (argv[optind][1] == '-')
		/* --option */
		fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
			 argv[0], nextchar);
	      else
		/* +option or -option */
		fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
			 argv[0], argv[optind][0], nextchar);
	    }
	  nextchar = (char *) "";
	  optind++;
	  optopt = 0;
	  return '?';
	}
    }

  /* Look at and handle the next short option-character.  */

  {
    char c = *nextchar++;

      {
	if (opterr)
	  {
	    if (posixly_correct)
	      /* 1003.2 specifies the format of this message.  */
	      fprintf (stderr, _("%s: illegal option -- %c\n"),
		       argv[0], c);
	    else
	      fprintf (stderr, _("%s: invalid option -- %c\n"),
		       argv[0], c);
	    /* 1003.2 specifies the format of this message.  */
	    fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
#endif
	  }
	optopt = c;
	return '?';
      }
    /* Convenience. Treat POSIX -W foo same as long option --foo */
    if (temp[0] == 'W' && temp[1] == ';')
      {
	char *nameend;
	const struct option *p;
	const struct option *pfound = NULL;
	int exact = 0;
	int ambig = 0;
	int indfound = 0;
	int option_index;

	/* This is an option that requires an argument.  */
	if (*nextchar != '\0')
	  {
	    optarg = nextchar;
	    /* If we end this ARGV-element by taking the rest as an arg,
	       we must advance to the next element now.  */
	    optind++;
	  }
	else if (optind == argc)
	  {
	    if (opterr)
	      {
		/* 1003.2 specifies the format of this message.  */
		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
			 argv[0], c);
	      }
	    optopt = c;
	    if (optstring[0] == ':')
	      c = ':';
	    else
	      c = '?';
	    return c;
	  }
	else
	  /* We already incremented `optind' once;
	     increment it again when taking next ARGV-elt as argument.  */
	  optarg = argv[optind++];

	/* optarg is now the argument, see if it's in the
	   table of longopts.  */

	for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
	  /* Do nothing.  */ ;

	/* Test all long options for either exact match
	   or abbreviated matches.  */
	for (p = longopts, option_index = 0; p->name; p++, option_index++)
	  if (!strncmp (p->name, nextchar, nameend - nextchar))
	    {
	      if ((unsigned int) (nameend - nextchar) == strlen (p->name))
		{
		  /* Exact match found.  */
		  pfound = p;
		  indfound = option_index;
		  exact = 1;
		  break;
		}
	      else if (pfound == NULL)
		{
		  /* First nonexact match found.  */
		  pfound = p;
		  indfound = option_index;
		}
	      else
		/* Second or later nonexact match found.  */
		ambig = 1;
	    }
	if (ambig && !exact)
	  {
	    if (opterr)
	      fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
		       argv[0], argv[optind]);
	    nextchar += strlen (nextchar);
	    optind++;
	    return '?';
	  }
	if (pfound != NULL)
	  {
	    option_index = indfound;
	    if (*nameend)
	      {
		/* Don't test has_arg with >, because some C compilers don't
		   allow it to be used on enums.  */
		if (pfound->has_arg)
		  optarg = nameend + 1;
		else
		  {
		    if (opterr)
		      fprintf (stderr, _("\
%s: option `-W %s' doesn't allow an argument\n"),
			       argv[0], pfound->name);

		    nextchar += strlen (nextchar);
		    return '?';
		  }
	      }
	    else if (pfound->has_arg == 1)
	      {
		if (optind < argc)
		  optarg = argv[optind++];
		else
		  {
		    if (opterr)
		      fprintf (stderr,
			       _("%s: option `%s' requires an argument\n"),
			       argv[0], argv[optind - 1]);
		    nextchar += strlen (nextchar);
		    return optstring[0] == ':' ? ':' : '?';
		  }
	      }
	    nextchar += strlen (nextchar);
	    if (longind != NULL)
	      *longind = option_index;
	    if (pfound->flag)
	      {
		*(pfound->flag) = pfound->val;
		return 0;
	      }
	    return pfound->val;
	  }
	  nextchar = NULL;
	  return 'W';	/* Let the application handle it.   */
      }
    if (temp[1] == ':')
      {
	if (temp[2] == ':')

		optind++;
	      }
	    else
	      optarg = NULL;
	    nextchar = NULL;
	  }
	else

	      {
		if (opterr)
		  {
#if 0
		    fprintf (stderr, "%s: option `-%c' requires an argument\n",
			     argv[0], c);
#else
		    /* 1003.2 specifies the format of this message.  */
		    fprintf (stderr,
			   _("%s: option requires an argument -- %c\n"),
			   argv[0], c);
		  }
		optopt = c;
		if (optstring[0] == ':')

			   0);
}

#endif	/* Not ELIDE_CODE.  */

#ifdef TEST


      int this_option_optind = optind ? optind : 1;

      c = getopt (argc, argv, "abc:d:0123456789");
      if (c == -1)
	break;

      switch (c)




/* Declarations for getopt.
   Copyright (C) 1989,90,91,92,93,94,96,97, 98 Free Software Foundation, Inc.

   This file is part of the GNU C Library.  Its master source is NOT part of
   the C library, however.  The master source lives in /gd/gnu/lib.
   Free Software Foundation; either version 2, or (at your option) any
   later version.

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

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifndef _GETOPT_H
#define _GETOPT_H 1


   On entry to `getopt', zero means this is the first call; initialize.

   When `getopt' returns -1, this is the index of the first of the
   non-option elements that the caller should itself scan.

   Otherwise, `optind' communicates from one call to the next


struct option
{
#if defined (__STDC__) && __STDC__
  const char *name;
#else
  char *name;

#define required_argument	1
#define optional_argument	2

#if defined (__STDC__) && __STDC__
#ifdef __GNU_LIBRARY__
/* Many other libraries have conflicting prototypes for getopt, with
   differences in the consts, in stdlib.h.  To avoid compilation
   errors, only prototype getopt for the GNU C library.  */
extern int getopt (int argc, char *const *argv, const char *shortopts);
#else /* not __GNU_LIBRARY__ */
extern int getopt ();
#endif /* __GNU_LIBRARY__ */
extern int getopt_long (int argc, char *const *argv, const char *shortopts,
		        const struct option *longopts, int *longind);
extern int getopt_long_only (int argc, char *const *argv,

extern int getopt_long_only ();

extern int _getopt_internal ();
#endif /* __STDC__ */

#ifdef	__cplusplus
}




/* getopt_long and getopt_long_only entry points for GNU getopt.
   Copyright (C) 1987,88,89,90,91,92,93,94,96,97, 98 Free Software Foundation, Inc.

   This file is part of the GNU C Library.  Its master source is NOT part of
   the C library, however.  The master source lives in /gd/gnu/lib.

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

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "getopt.h"

#if !defined (__STDC__) || !__STDC__
/* This is a separate conditional since some stdc systems
   reject `defined (const)'.  */
#ifndef const
#define const
#endif
#endif

#include <stdio.h>

/* Comment out all this code if we are using the GNU C Library, and are not
   actually compiling the library itself.  This code is part of the GNU C
   Library, but also included in many other GNU distributions.  Compiling
   and linking in this code is a waste when using the GNU C library
   (especially if it is a shared library).  Rather than having every GNU
   program understand `configure --with-gnu-libc' and omit the object files,
   it is simpler to just do this in the source for each such file.  */

#define GETOPT_INTERFACE_VERSION 2
#if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
#include <gnu-versions.h>
#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
#define ELIDE_CODE
#endif
#endif

#ifndef ELIDE_CODE


/* This needs to come after some library #include
   to get __GNU_LIBRARY__ defined.  */
#ifdef __GNU_LIBRARY__
#include <stdlib.h>
#endif

#ifndef	NULL
#define NULL 0
#endif

int
getopt_long (argc, argv, options, long_options, opt_index)
     int argc;
     char *const *argv;
     const char *options;
     const struct option *long_options;
     int *opt_index;
{
  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}

/* Like getopt_long, but '-' as well as '--' can indicate a long option.
   If an option that starts with '-' (not '--') doesn't match a long option,
   but does match a short option, it is parsed as a short option
   instead.  */

int
getopt_long_only (argc, argv, options, long_options, opt_index)
     int argc;
     char *const *argv;
     const char *options;
     const struct option *long_options;
     int *opt_index;
{
  return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
}


#endif	/* Not ELIDE_CODE.  */

#ifdef TEST

#include <stdio.h>

int
main (argc, argv)
     int argc;
     char **argv;
{
  int c;
  int digit_optind = 0;

  while (1)
    {
      int this_option_optind = optind ? optind : 1;
      int option_index = 0;
      static struct option long_options[] =
      {
	{"add", 1, 0, 0},
	{"append", 0, 0, 0},
	{"delete", 1, 0, 0},
	{"verbose", 0, 0, 0},
	{"create", 0, 0, 0},
	{"file", 1, 0, 0},
	{0, 0, 0, 0}
      };

      c = getopt_long (argc, argv, "abc:d:0123456789",
		       long_options, &option_index);
      if (c == -1)
	break;

      switch (c)
	{
	case 0:
	  printf (_("option %s"), long_options[option_index].name);
	  if (optarg)
	    printf (_(" with arg %s"), optarg);
	  printf ("\n");
	  break;

	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	  if (digit_optind != 0 && digit_optind != this_option_optind)
	    printf (_("digits occur in two different argv-elements.\n"));
	  digit_optind = this_option_optind;
	  printf (_("option %c\n"), c);
	  break;

	case 'a':
	  printf (_("option a\n"));
	  break;

	case 'b':
	  printf (_("option b\n"));
	  break;

	case 'c':
	  printf (_("option c with value `%s'\n"), optarg);
	  break;

	case 'd':
	  printf (_("option d with value `%s'\n"), optarg);
	  break;

	case '?':
	  break;

	default:
	  printf (_("?? getopt returned character code 0%o ??\n"), c);
	}
    }

  if (optind < argc)
    {
      printf (_("non-option ARGV-elements: "));
      while (optind < argc)
	printf ("%s ", argv[optind++]);
      printf ("\n");
    }

  exit (0);
}

#endif /* TEST */




/* Emulate getpagesize on systems that lack it.  */
#ifndef BSD4_1
#define HAVE_GETPAGESIZE
#endif
#endif

#ifndef HAVE_GETPAGESIZE

# ifdef VMS
#  define getpagesize() 512
# endif

# ifdef HAVE_UNISTD_H
#  include <unistd.h>
# endif

# ifdef _SC_PAGESIZE
#  define getpagesize() sysconf(_SC_PAGESIZE)
# else /* no _SC_PAGESIZE */
#  ifdef HAVE_SYS_PARAM_H
#   include <sys/param.h>
#   ifdef EXEC_PAGESIZE
#    define getpagesize() EXEC_PAGESIZE
#   else /* no EXEC_PAGESIZE */
#    ifdef NBPG
#     define getpagesize() NBPG * CLSIZE
#     ifndef CLSIZE
#      define CLSIZE 1
#     endif /* no CLSIZE */
#    else /* no NBPG */
#     ifdef NBPC
#      define getpagesize() NBPC
#     else /* no NBPC */
#      ifdef PAGESIZE
#       define getpagesize() PAGESIZE
#      endif /* PAGESIZE */
#     endif /* no NBPC */
#    endif /* no NBPG */
#   endif /* no EXEC_PAGESIZE */
#  else /* no HAVE_SYS_PARAM_H */
#   define getpagesize() 8192	/* punt totally */
#  endif /* no HAVE_SYS_PARAM_H */
# endif /* no _SC_PAGESIZE */

#endif /* no HAVE_GETPAGESIZE */




/* grep.c - main driver file for grep.
   Copyright (C) 1992, 1997, 1998, 1999 Free Software Foundation, Inc.

   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


   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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

/* Written July 1992 by Mike Haertel.  */

#ifdef HAVE_CONFIG_H
# include <config.h>

#include <errno.h>
#include <stdio.h>
#ifdef __FreeBSD__
#include <locale.h>
#endif

#ifndef errno
extern int errno;
#endif

#ifdef STDC_HEADERS
#include <stdlib.h>
#else
#include <sys/types.h>
#include <sys/stat.h>
#if defined(HAVE_MMAP)
# include <sys/mman.h>

#if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
#include <string.h>
#ifdef NEED_MEMORY_H
#include <memory.h>
#endif
#else
#include <strings.h>
#ifdef __STDC__
extern void *memchr();
#else
extern char *memchr();
#endif
#if defined(HAVE_SETRLIMIT)
# include <sys/time.h>
# include <sys/resource.h>
#endif
#include <stdio.h>
#include "system.h"
#include "getopt.h"
#include <fcntl.h>
#include <unistd.h>
#else
#define O_RDONLY 0
#define STDIN_FILENO 0
extern int open(), read(), close();
#endif

#include "getpagesize.h"
#include "grep.h"
#include "savedir.h"

#undef MAX
#define MAX(A,B) ((A) > (B) ? (A) : (B))

struct stats
{
  struct stats *parent;
  struct stat stat;
};

/* base of chain of stat buffers, used to detect directory loops */
static struct stats stats_base;
extern char *sys_errlist[];
#define strerror(E) ((E) < sys_nerr ? sys_errlist[(E)] : "bogus error number")
#endif

/* if non-zero, display usage information and exit */
static int show_help;
#define VOID void
#else
#define VOID char
#endif
VOID *
memchr(vp, c, n)
     VOID *vp;
     int c;
     size_t n;
{
  unsigned char *p;

  for (p = (unsigned char *) vp; n--; ++p)
    if (*p == c)
      return (VOID *) p;
  return 0;
}
#endif

/* If non-zero, print the version on standard output and exit.  */
static int show_version;
#include <sys/types.h>
#include <sys/stat.h>
#include <fts.h>
#endif

/* Long options equivalences. */
static struct option long_options[] =
{
  {"after-context", required_argument, NULL, 'A'},
  {"basic-regexp", no_argument, NULL, 'G'},
  {"before-context", required_argument, NULL, 'B'},
  {"byte-offset", no_argument, NULL, 'b'},
  {"context", optional_argument, NULL, 'C'},
  {"count", no_argument, NULL, 'c'},
  {"directories", required_argument, NULL, 'd'},
  {"extended-regexp", no_argument, NULL, 'E'},
  {"file", required_argument, NULL, 'f'},
  {"files-with-matches", no_argument, NULL, 'l'},
  {"files-without-match", no_argument, NULL, 'L'},
  {"fixed-regexp", no_argument, NULL, 'F'},
  {"fixed-strings", no_argument, NULL, 'F'},
  {"help", no_argument, &show_help, 1},
  {"ignore-case", no_argument, NULL, 'i'},
  {"line-number", no_argument, NULL, 'n'},
  {"line-regexp", no_argument, NULL, 'x'},
  {"no-filename", no_argument, NULL, 'h'},
  {"no-messages", no_argument, NULL, 's'},
  {"quiet", no_argument, NULL, 'q'},
  {"recursive", no_argument, NULL, 'r'},
  {"regexp", required_argument, NULL, 'e'},
  {"revert-match", no_argument, NULL, 'v'},
  {"silent", no_argument, NULL, 'q'},
  {"text", no_argument, NULL, 'a'},
#if O_BINARY
  {"binary", no_argument, NULL, 'U'},
  {"unix-byte-offsets", no_argument, NULL, 'u'},
#endif
  {"version", no_argument, NULL, 'V'},
  {"with-filename", no_argument, NULL, 'H'},
  {"word-regexp", no_argument, NULL, 'w'},
  {0, 0, 0, 0}
};

/* Define flags declared in grep.h. */
char const *matcher;
int match_icase;
int match_words;
int match_lines;

/* Functions we'll use to search. */
static void (*compile)();
static char *(*execute)();

/* For error messages. */
static char *prog;
static char const *filename;
static int errseen;

/* How to handle directories.  */
static enum
  {
    READ_DIRECTORIES,
    RECURSE_DIRECTORIES,
    SKIP_DIRECTORIES
  } directories;

static int  ck_atoi PARAMS ((char const *, int *));
static void usage PARAMS ((int)) __attribute__((noreturn));
static void error PARAMS ((const char *, int));
static int  setmatcher PARAMS ((char const *));
static char *page_alloc PARAMS ((size_t, char **));
static int  reset PARAMS ((int, char const *, struct stats *));
static int  fillbuf PARAMS ((size_t, struct stats *));
static int  grepbuf PARAMS ((char *, char *));
static void prtext PARAMS ((char *, char *, int *));
static void prpending PARAMS ((char *));
static void prline PARAMS ((char *, char *, int));
static void print_offset_sep PARAMS ((off_t, int));
static void nlscan PARAMS ((char *));
static int  grep PARAMS ((int, char const *, struct stats *));
static int  grepdir PARAMS ((char const *, struct stats *));
static int  grepfile PARAMS ((char const *, struct stats *));
#if O_BINARY
static inline int undossify_input PARAMS ((register char *, size_t));
#endif

/* Functions we'll use to search. */
static void (*compile) PARAMS ((char *, size_t));
static char *(*execute) PARAMS ((char *, size_t, char **));

/* Print a message and possibly an error string.  Remember
   that something awful happened. */
static void
error (mesg, errnum)
     const char *mesg;
     const
#endif
     char *mesg;
     int errnum;
{
  if (errnum)
    fprintf (stderr, "%s: %s: %s\n", prog, mesg, strerror (errnum));
  else
    fprintf (stderr, "%s: %s\n", prog, mesg);
  errseen = 1;
}

/* Like error (), but die horribly after printing. */
void
fatal (mesg, errnum)
     const char *mesg;
     const
#endif
     char *mesg;
     int errnum;
{
  error (mesg, errnum);
  exit (2);
}

/* Interface to handle errors and fix library lossage. */
char *
xmalloc (size)
     size_t size;
{
  char *result;

  result = malloc (size);
  if (size && !result)
    fatal (_("memory exhausted"), 0);
  return result;
}

/* Interface to handle errors and fix some library lossage. */
char *
xrealloc (ptr, size)
     char *ptr;
     size_t size;
{
  char *result;

  if (ptr)
    result = realloc (ptr, size);
  else
    result = malloc (size);
  if (size && !result)
    fatal (_("memory exhausted"), 0);
  return result;
}

/* Convert STR to a positive integer, storing the result in *OUT.
   If STR is not a valid integer, return -1 (otherwise 0). */
static int
ck_atoi (str, out)
     char const *str;
     int *out;
{
  char const *p;
  for (p = str; *p; p++)
    if (*p < '0' || *p > '9')
      return -1;

  *out = atoi (optarg);
  return 0;
}


/* Hairy buffering mechanism for grep.  The intent is to keep
   all reads aligned on a page boundary and multiples of the
   page size. */

static char *ubuffer;		/* Unaligned base of buffer. */
static char *buffer;		/* Base of buffer. */
static size_t bufsalloc;	/* Allocated size of buffer save region. */
static size_t bufalloc;		/* Total buffer size. */
static int bufdesc;		/* File descriptor. */
static char *bufbeg;		/* Beginning of user-visible stuff. */
static char *buflim;		/* Limit of user-visible stuff. */
static size_t pagesize;		/* alignment of memory pages */

#if defined(HAVE_MMAP)
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>

static int bufmapped;		/* True for ordinary files. */
static struct stat bufstat;	/* From fstat(). */
static off_t bufoffset;		/* What read() normally remembers. */
static off_t initial_bufoffset;	/* Initial value of bufoffset. */
#endif

/* Return VAL aligned to the next multiple of ALIGNMENT.  VAL can be
   an integer or a pointer.  Both args must be free of side effects.  */
#define ALIGN_TO(val, alignment) \
  ((size_t) (val) % (alignment) == 0 \
   ? (val) \
   : (val) + ((alignment) - (size_t) (val) % (alignment)))

/* Return the address of a new page-aligned buffer of size SIZE.  Set
   *UP to the newly allocated (but possibly unaligned) buffer used to
   *build the aligned buffer.  To free the buffer, free (*UP).  */
static char *
page_alloc (size, up)
     size_t size;
     char **up;
{
  /* HAVE_WORKING_VALLOC means that valloc is properly declared, and
     you can free the result of valloc.  This symbol is not (yet)
     autoconfigured.  It can be useful to define HAVE_WORKING_VALLOC
     while debugging, since some debugging memory allocators might
     catch more bugs if this symbol is enabled.  */
#if HAVE_WORKING_VALLOC
  *up = valloc (size);
  return *up;
#else
  size_t asize = size + pagesize - 1;
  if (size <= asize)
    {
      *up = malloc (asize);
      if (*up)
	return ALIGN_TO (*up, pagesize);
    }
  return NULL;
#endif
}

/* Reset the buffer for a new file, returning zero if we should skip it.
   Initialize on the first time through. */
static int
reset (fd, file, stats)
     int fd;
     char const *file;
     struct stats *stats;
{
  if (pagesize == 0)

  if (!initialized)
    {
      size_t ubufsalloc;
      pagesize = getpagesize ();
      if (pagesize == 0)
	abort ();
#ifndef BUFSALLOC
      ubufsalloc = MAX (8192, pagesize);
#else
      ubufsalloc = BUFSALLOC;
#endif
      bufsalloc = ALIGN_TO (ubufsalloc, pagesize);
      bufalloc = 5 * bufsalloc;
      /* The 1 byte of overflow is a kludge for dfaexec(), which
	 inserts a sentinel newline at the end of the buffer
	 being searched.  There's gotta be a better way... */
      if (bufsalloc < ubufsalloc
	  || bufalloc / 5 != bufsalloc || bufalloc + 1 < bufalloc
	  || ! (buffer = page_alloc (bufalloc + 1, &ubuffer)))
	fatal (_("memory exhausted"), 0);
      bufbeg = buffer;
      buflim = buffer;
    }
  bufdesc = fd;

    gzbufdesc = gzdopen(fd, "r");
    if (gzbufdesc == NULL) 
      fatal("memory exhausted", 0); 
  }
#endif
    bufdesc = fd;
#if defined(HAVE_WORKING_MMAP)
  if (
#if defined(HAVE_MMAP)
      1
#else
      directories != READ_DIRECTORIES
#endif
      )
    if (fstat (fd, &stats->stat) != 0)
      {
	error ("fstat", errno);
	return 0;
      }
  if (directories == SKIP_DIRECTORIES && S_ISDIR (stats->stat.st_mode))
    return 0;
#if defined(HAVE_MMAP)
  if (!S_ISREG (stats->stat.st_mode))
    bufmapped = 0;
  else
    {
      bufmapped = 1;
      bufoffset = initial_bufoffset = file ? 0 : lseek (fd, 0, 1);
    }
#endif
  return 1;
}

/* Read new stuff into the buffer, saving the specified

   to the beginning of the buffer contents, and 'buflim'
   points just after the end.  Return count of new stuff. */
static int
fillbuf (save, stats)
     size_t save;
     struct stats *stats;
{
  char *nbuffer, *dp, *sp;
  int cc;
#if defined(HAVE_MMAP)
  caddr_t maddr;
#endif
  static int pagesize;

  if (pagesize == 0 && (pagesize = getpagesize()) == 0)
    abort();

  if (save > bufsalloc)
    {
      char *nubuffer;
      char *nbuffer;

      while (save > bufsalloc)
	bufsalloc *= 2;
      bufalloc = 5 * bufsalloc;
      if (bufalloc / 5 != bufsalloc || bufalloc + 1 < bufalloc
	  || ! (nbuffer = page_alloc (bufalloc + 1, &nubuffer)))
	fatal (_("memory exhausted"), 0);

      bufbeg = nbuffer + bufsalloc - save;
      memcpy (bufbeg, buflim - save, save);
      free (ubuffer);
      ubuffer = nubuffer;
      buffer = nbuffer;
    }
  else
    {
      bufbeg = buffer + bufsalloc - save;
      memcpy (bufbeg, buflim - save, save);
    }
  bufbeg = dp;
  while (save--)
    *dp++ = *sp++;

  /* We may have allocated a new, larger buffer.  Since
     there is no portable vfree(), we just have to forget
     about the old one.  Sorry. */
  buffer = nbuffer;

#if defined(HAVE_MMAP)
  if (bufmapped && bufoffset % pagesize == 0
      && stats->stat.st_size - bufoffset >= bufalloc - bufsalloc)
    {
      maddr = buffer + bufsalloc;
      maddr = mmap (maddr, bufalloc - bufsalloc, PROT_READ | PROT_WRITE,
		   MAP_PRIVATE | MAP_FIXED, bufdesc, bufoffset);
      if (maddr == (caddr_t) -1)
	{
          /* This used to issue a warning, but on some hosts
             (e.g. Solaris 2.5) mmap can fail merely because some
             other process has an advisory read lock on the file.
             There's no point alarming the user about this misfeature.  */
#if 0
	  fprintf (stderr, _("%s: warning: %s: %s\n"), prog, filename,
		  strerror (errno));
#endif
	  goto tryread;
	}
#if 0
      /* You might thing this (or MADV_WILLNEED) would help,
	 but it doesn't, at least not on a Sun running 4.1.
	 In fact, it actually slows us down about 30%! */
      madvise (maddr, bufalloc - bufsalloc, MADV_SEQUENTIAL);
#endif
      cc = bufalloc - bufsalloc;
      bufoffset += cc;

      if (bufmapped)
	{
	  bufmapped = 0;
	  if (bufoffset != initial_bufoffset)
	    lseek (bufdesc, bufoffset, 0);
	}
      cc = read (bufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
      if (Zflag) 
    	cc = gzread(gzbufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
      else	
#endif
        cc = read(bufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
    }
#else
  cc = read (bufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
#endif /*HAVE_MMAP*/
#if O_BINARY
  if (cc > 0)
    cc = undossify_input (buffer + bufsalloc, cc);
    cc = read(bufdesc, buffer + bufsalloc, bufalloc - bufsalloc);
#endif
  if (cc > 0)
    buflim = buffer + bufsalloc + cc;

}

/* Flags controlling the style of output. */
static int always_text;		/* Assume the input is always text. */
static int out_quiet;		/* Suppress all normal output. */
static int out_invert;		/* Print nonmatching stuff. */
static int out_file;		/* Print filenames. */

static int out_byte;		/* Print byte offsets. */
static int out_before;		/* Lines of leading context. */
static int out_after;		/* Lines of trailing context. */
static int count_matches;	/* Count matching lines.  */
static int list_files;		/* List matching files.  */
static int no_filenames;	/* Suppress file names.  */
static int suppress_errors;	/* Suppress diagnostics.  */

/* Internal variables to keep track of byte count, context, etc. */
static off_t totalcc;		/* Total character count before bufbeg. */
static char *lastnl;		/* Pointer after last newline counted. */
static char *lastout;		/* Pointer after last character output;
				   NULL if no character has been output
				   or if it's conceptually before bufbeg. */
static off_t totalnl;		/* Total newline count before lastnl. */
static int pending;		/* Pending lines of output. */
static int done_on_match;		/* Stop scanning file on first match */

#if O_BINARY
# include "dosbuf.c"
#endif

static void
nlscan (lim)
     char *lim;
{
  char *beg;

}

static void
print_offset_sep (pos, sep)
     off_t pos;
     int sep;
{
  /* Do not rely on printf to print pos, since off_t may be longer than long,
     and long long is not portable.  */

  char buf[sizeof pos * CHAR_BIT];
  char *p = buf + sizeof buf - 1;
  *p = sep;

  do
    *--p = '0' + pos % 10;
  while ((pos /= 10) != 0);

  fwrite (p, 1, buf + sizeof buf - p, stdout);
}

static void
prline (beg, lim, sep)
     char *beg;
     char *lim;
     int sep;
{
  if (out_file)
    printf ("%s%c", filename, sep);
  if (out_line)
    {
      nlscan (beg);
      print_offset_sep (++totalnl, sep);
      lastnl = lim;
    }
  if (out_byte)
    {
      off_t pos = totalcc + (beg - bufbeg);
#if O_BINARY
      pos = dossified_pos (pos);
#endif
      print_offset_sep (pos, sep);
    }
  fwrite (beg, 1, lim - beg, stdout);
  if (ferror (stdout))
    error (_("writing output"), errno);
  lastout = lim;
}

/* Print pending lines of trailing context prior to LIM. */
static void
prpending (lim)
     char *lim;
{
  char *nl;

  while (pending > 0 && lastout < lim)
    {
      --pending;
      if ((nl = memchr (lastout, '\n', lim - lastout)) != 0)
	++nl;
      else
	nl = lim;
      prline (lastout, nl, '-');
    }
}

/* Print the lines between BEG and LIM.  Deal with context crap.
   If NLINESP is non-null, store a count of lines between BEG and LIM. */
static void
prtext (beg, lim, nlinesp)
     char *beg;
     char *lim;
     int *nlinesp;

  int i, n;

  if (!out_quiet && pending > 0)
    prpending (beg);

  p = beg;


      /* We only print the "--" separator if our output is
	 discontiguous from the last output in the file. */
      if ((out_before || out_after) && used && p != lastout)
	puts ("--");

      while (p < beg)
	{
	  nl = memchr (p, '\n', beg - p);
	  prline (p, nl + 1, '-');
	  p = nl + 1;
	}
    }

      /* Caller wants a line count. */
      for (n = 0; p < lim; ++n)
	{
	  if ((nl = memchr (p, '\n', lim - p)) != 0)
	    ++nl;
	  else
	    nl = lim;
	  if (!out_quiet)
	    prline (p, nl, ':');
	  p = nl;
	}
      *nlinesp = n;
    }
  else
    if (!out_quiet)
      prline (beg, lim, ':');

  pending = out_after;
  used = 1;

   between matching lines if OUT_INVERT is true).  Return a count of
   lines printed. */
static int
grepbuf (beg, lim)
     char *beg;
     char *lim;
{

	break;
      if (!out_invert)
	{
	  prtext (b, endp, (int *) 0);
	  nlines += 1;
	  if (done_on_match)
	    return nlines;
	}
      else if (p < b)
	{
	  prtext (p, b, &n);
	  nlines += n;
	}
      p = endp;
    }
  if (out_invert && p < lim)
    {
      prtext (p, lim, &n);
      nlines += n;
    }
  return nlines;
}

/* Search a given file.  Normally, return a count of lines printed;
   but if the file is a directory and we search it recursively, then
   return -2 if there was a match, and -1 otherwise.  */
 */

int isBinaryFile(buf, len)
     char *buf;
     int len;
{
#define BINARY_BUF_LEN 32
  int i;

  len = (len < BINARY_BUF_LEN ? len : BINARY_BUF_LEN);

  /* look for non-printable chars */
  for(i = 0; i < len; i++, buf++)
    if (!isprint(*buf) && !isspace(*buf))
      return(1);
  
  return(0);
}



/* Search a given file.  Return a count of lines printed. */
static int
grep (fd, file, stats)
     int fd;
     char const *file;
     struct stats *stats;
{
  int nlines, i;
  int not_text;
  size_t residue, save;
  char *beg, *lim;
  int first, cc;	

  if (!reset (fd, file, stats))
    return 0;

  if (file && directories == RECURSE_DIRECTORIES
      && S_ISDIR (stats->stat.st_mode))
    {
      /* Close fd now, so that we don't open a lot of file descriptors
	 when we recurse deeply.  */
      if (close (fd) != 0)
	error (file, errno);
      return grepdir (file, stats) - 2;
    }

  totalcc = 0;
  lastout = 0;

  nlines = 0;
  residue = 0;
  save = 0;
  first = 0;
  cc = 0;	

  if (fillbuf (save, stats) < 0)
    {
      if (! (is_EISDIR (errno, file) && suppress_errors))
	error (filename, errno);
      return nlines;
    }
	}

  not_text = (! (always_text | out_quiet)
	      && memchr (bufbeg, '\0', buflim - bufbeg));
  done_on_match += not_text;
  out_quiet += not_text;

  for (;;)
    {
      lastnl = bufbeg;
      if (lastout)
	lastout = bufbeg;

      residue = buflim - lim;
      if (beg < lim)
	{
	  nlines += grepbuf (beg, lim);
	  if (pending)
	    prpending (lim);
	  if (nlines && done_on_match && !out_invert)
	    goto finish_grep;
	    return(nlines);
	}
      i = 0;
      beg = lim;

      save = residue + lim - beg;
      totalcc += buflim - bufbeg - save;
      if (out_line)
	nlscan (beg);
      if (fillbuf (save, stats) < 0)
	{
	  if (! (is_EISDIR (errno, file) && suppress_errors))
	    error (filename, errno);
	  goto finish_grep;
	}
    }
  if (residue)
    {
      nlines += grepbuf (bufbeg + save - residue, buflim);
      if (pending)
	prpending (buflim);
    }

 finish_grep:
  done_on_match -= not_text;
  out_quiet -= not_text;
  if ((not_text & ~out_quiet) && nlines != 0)
    printf (_("Binary file %s matches\n"), filename);
  return nlines;
}

static int
grepfile (file, stats)
     char const *file;
     struct stats *stats;
{
  int desc;
  int count;
  int status;

  if (! file)
    {
      desc = 0;
      filename = _("(standard input)");
    }
  else
    {
      desc = open (file, O_RDONLY);

      if (desc < 0)
	{
	  int e = errno;
	    
	  if (is_EISDIR (e, file) && directories == RECURSE_DIRECTORIES)
	    {
	      if (stat (file, &stats->stat) != 0)
		{
		  error (file, errno);
		  return 1;
		}

	      return grepdir (file, stats);
	    }
	      
	  if (!suppress_errors)
	    {
	      if (directories == SKIP_DIRECTORIES)
		switch (e)
		  {
#ifdef EISDIR
		  case EISDIR:
		    return 1;
#endif
		  case EACCES:
		    /* When skipping directories, don't worry about
		       directories that can't be opened.  */
		    if (stat (file, &stats->stat) == 0
			&& S_ISDIR (stats->stat.st_mode))
		      return 1;
		    break;
		  }

	      error (file, e);
	    }

	  return 1;
	}

      filename = file;
    }

#if O_BINARY
  /* Set input to binary mode.  Pipes are simulated with files
     on DOS, so this includes the case of "foo | grep bar".  */
  if (!isatty (desc))
    SET_BINARY (desc);
#endif

  count = grep (desc, file, stats);
  if (count < 0)
    status = count + 2;
  else
    {
      if (count_matches)
	{
	  if (out_file)
	    printf ("%s:", filename);
	  printf ("%d\n", count);
	}

      if (count)
	{
	  status = 0;
	  if (list_files == 1)
	    printf ("%s\n", filename);
	}
      else
	{
	  status = 1;
	  if (list_files == -1)
	    printf ("%s\n", filename);
	}

      if (file && close (desc) != 0)
	error (file, errno);
    }

  return status;
}

static int
grepdir (dir, stats)
     char const *dir;
     struct stats *stats;
{
  int status = 1;
  struct stats *ancestor;
  char *name_space;

  for (ancestor = stats;  (ancestor = ancestor->parent) != 0;  )
    if (! ((ancestor->stat.st_ino ^ stats->stat.st_ino)
	   | (ancestor->stat.st_dev ^ stats->stat.st_dev)))
      {
	if (!suppress_errors)
	  fprintf (stderr, _("%s: warning: %s: %s\n"), prog, dir,
		   _("recursive directory loop"));
	return 1;
      }

  name_space = savedir (dir, (unsigned) stats->stat.st_size);

  if (! name_space)
    {
      if (errno)
	{
	  if (!suppress_errors)
	    error (dir, errno);
	}
      else
	fatal (_("Memory exhausted"), 0);
    }
  else
    {
      size_t dirlen = strlen (dir);
      int needs_slash = ! (dirlen == FILESYSTEM_PREFIX_LEN (dir)
			   || IS_SLASH (dir[dirlen - 1]));
      char *file = NULL;
      char *namep = name_space;
      struct stats child;
      child.parent = stats;
      out_file += !no_filenames;
      while (*namep)
	{
	  size_t namelen = strlen (namep);
	  file = xrealloc (file, dirlen + 1 + namelen + 1);
	  strcpy (file, dir);
	  file[dirlen] = '/';
	  strcpy (file + dirlen + needs_slash, namep);
	  namep += namelen + 1;
	  status &= grepfile (file, &child);
	}
      out_file -= !no_filenames;
      if (file)
        free (file);
      free (name_space);
    }

  return status;
}

static void
usage(status)
int status;
{
  if (status != 0)
    {
      fprintf (stderr, _("Usage: %s [OPTION]... PATTERN [FILE]...\n"), prog);
      fprintf (stderr, _("Try `%s --help' for more information.\n"), prog);
    }
  else
    {
      printf (_("Usage: %s [OPTION]... PATTERN [FILE] ...\n"), prog);
      printf (_("\
Search for PATTERN in each FILE or standard input.\n\
\n\
Regexp selection and interpretation:\n\
  -E, --extended-regexp     PATTERN is an extended regular expression\n\
  -F, --fixed-regexp        PATTERN is a fixed string separated by newlines\n\
  -G, --basic-regexp        PATTERN is a basic regular expression\n\
  -e, --regexp=PATTERN      use PATTERN as a regular expression\n\
  -f, --file=FILE           obtain PATTERN from FILE\n\
  -i, --ignore-case         ignore case distinctions\n\
  -w, --word-regexp         force PATTERN to match only whole words\n\
  -x, --line-regexp         force PATTERN to match only whole lines\n"));
      printf (_("\
\n\
Miscellaneous:\n\
  -s, --no-messages         suppress error messages\n\
  -v, --revert-match        select non-matching lines\n\
  -V, --version             print version information and exit\n\
      --help                display this help and exit\n"));
      printf (_("\
\n\
Output control:\n\
  -b, --byte-offset         print the byte offset with output lines\n\
  -n, --line-number         print line number with output lines\n\
  -H, --with-filename       print the filename for each match\n\
  -h, --no-filename         suppress the prefixing filename on output\n\
  -q, --quiet, --silent     suppress all normal output\n\
  -a, --text                do not suppress binary output\n\
  -d, --directories=ACTION  how to handle directories\n\
                            ACTION is 'read', 'recurse', or 'skip'.\n\
  -r, --recursive           equivalent to --directories=recurse.\n\
  -L, --files-without-match only print FILE names containing no match\n\
  -l, --files-with-matches  only print FILE names containing matches\n\
  -c, --count               only print a count of matching lines per FILE\n"));
      printf (_("\
\n\
Context control:\n\
  -B, --before-context=NUM  print NUM lines of leading context\n\
  -A, --after-context=NUM   print NUM lines of trailing context\n\
  -C, --context[=NUM]       print NUM (default 2) lines of output context\n\
                            unless overriden by -A or -B\n\
  -NUM                      same as --context=NUM\n\
  -U, --binary              do not strip CR characters at EOL (MSDOS)\n\
  -u, --unix-byte-offsets   report offsets as if CRs were not there (MSDOS)\n\
\n\
If no -[GEF], then `egrep' assumes -E, `fgrep' -F, else -G.\n\
With no FILE, or when FILE is -, read standard input. If less than\n\
two FILEs given, assume -h. Exit with 0 if matches, with 1 if none.\n\
Exit with 2 if syntax errors or system errors.\n"));
      printf (_("\nReport bugs to <bug-gnu-utils@gnu.org>.\n"));
    }
  exit (status);
}

/* Go through the matchers vector and look for the specified matcher.
   If we find it, install it in compile and execute, and return 1.  */
static int
setmatcher (name)
     char const *name;
{
  int i;
#ifdef HAVE_SETRLIMIT
  struct rlimit rlim;
#endif

  for (i = 0; matchers[i].name; ++i)
    if (strcmp (name, matchers[i].name) == 0)
      {
	compile = matchers[i].compile;
	execute = matchers[i].execute;
#if HAVE_SETRLIMIT && defined(RLIMIT_STACK)
	/* I think every platform needs to do this, so that regex.c
	   doesn't oveflow the stack.  The default value of
	   `re_max_failures' is too large for some platforms: it needs
	   more than 3MB-large stack.

	   The test for HAVE_SETRLIMIT should go into `configure'.  */
	if (!getrlimit (RLIMIT_STACK, &rlim))
	  {
	    long newlim;
	    extern long int re_max_failures; /* from regex.c */

	    /* Approximate the amount regex.c needs, plus some more.  */
	    newlim = re_max_failures * 2 * 20 * sizeof (char *);
	    if (newlim > rlim.rlim_max)
	      {
		newlim = rlim.rlim_max;
		re_max_failures = newlim / (2 * 20 * sizeof (char *));
	      }
	    if (rlim.rlim_cur < newlim)
	      rlim.rlim_cur = newlim;

	    setrlimit (RLIMIT_STACK, &rlim);
	  }
#endif
	return 1;
      }
  return 0;
}



int
main (argc, argv)
     int argc;
     char *argv[];
{
  char *keys;
  size_t keycc, oldcc, keyalloc;
  int with_filenames;
  int opt, cc, status;
  unsigned digit_args_val, default_context;
  FILE *fp;
  extern char *optarg;
  extern int optind;
#if HAVE_FTS > 0
  int Rflag, Hflag, Pflag, Lflag;
  FTS *ftsp;
  FTSENT *ftsent;
  int fts_options;
#endif

  initialize_main (&argc, &argv);
  (void) setlocale(LC_ALL, "");
#endif
  prog = argv[0];
  if (prog && strrchr (prog, '/'))
    prog = strrchr (prog, '/') + 1;

#if defined(__MSDOS__) || defined(_WIN32)
  /* DOS and MS-Windows use backslashes as directory separators, and usually
     have an .exe suffix.  They also have case-insensitive filesystems.  */
  if (prog)
    {
      char *p = prog;
      char *bslash = strrchr (argv[0], '\\');

      if (bslash && bslash >= prog) /* for mixed forward/backslash case */
	prog = bslash + 1;
      else if (prog == argv[0]
	       && argv[0][0] && argv[0][1] == ':') /* "c:progname" */
	prog = argv[0] + 2;

      /* Collapse the letter-case, so `strcmp' could be used hence.  */
      for ( ; *p; p++)
	if (*p >= 'A' && *p <= 'Z')
	  *p += 'a' - 'A';

      /* Remove the .exe extension, if any.  */
      if ((p = strrchr (prog, '.')) && strcmp (p, ".exe") == 0)
	*p = '\0';
    }
#endif

  keys = NULL;
  keycc = 0;
  with_filenames = 0;
  count_matches = 0;
  no_filenames = 0;
  list_files = 0;
  suppress_errors = 0;
  matcher = NULL;
  aflag = 0;
#if HAVE_FTS > 0
  Rflag = Hflag = Pflag = Lflag = 0;
#endif
#if HAVE_LIBZ > 0
    if (*prog == 'z') {
	prog++;
	Zflag = 1;
    }
#endif

  /* The value -1 means to use DEFAULT_CONTEXT. */
  out_after = out_before = -1;
  /* Default before/after context: chaged by -C/-NUM options */
  default_context = 0;
  /* Accumulated value of individual digits in a -NUM option */
  digit_args_val = 0;


/* Internationalization. */
#if HAVE_SETLOCALE
  setlocale (LC_ALL, "");
#endif
#if ENABLE_NLS
  bindtextdomain (PACKAGE, LOCALEDIR);
  textdomain (PACKAGE);
#endif

  while ((opt = getopt_long (argc, argv,
#if O_BINARY
         "0123456789A:B:C::EFGHVX:abcd:e:f:hiLlnqrsvwxyUu",
#else
         "0123456789A:B:C::EFGHVX:abcd:e:f:hiLlnqrsvwxy",
#endif
         long_options, NULL)) != EOF)
    switch (opt)
      {
      case '0':

      case '7':
      case '8':
      case '9':
	digit_args_val = 10 * digit_args_val + opt - '0';
	default_context = digit_args_val;
	break;
      case 'A':
	if (optarg)
	  {
	    if (ck_atoi (optarg, &out_after))
	      fatal (_("invalid context length argument"), 0);
	  }
	break;
      case 'B':
	if (optarg)
	  {
	    if (ck_atoi (optarg, &out_before))
	      fatal (_("invalid context length argument"), 0);
	  }
	break;
      case 'C':
	/* Set output match context, but let any explicit leading or
	   trailing amount specified with -A or -B stand. */
	if (optarg)
	  {
	    if (ck_atoi (optarg, &default_context))
	      fatal (_("invalid context length argument"), 0);
	  }
	else
	  default_context = 2;
	break;
      case 'E':
	if (matcher && strcmp (matcher, "posix-egrep") != 0)
	  fatal (_("you may specify only one of -E, -F, or -G"), 0);
	matcher = "posix-egrep";
	break;
      case 'F':
	if (matcher && strcmp(matcher, "fgrep") != 0)
	  fatal(_("you may specify only one of -E, -F, or -G"), 0);;
	matcher = "fgrep";
	break;
      case 'G':
	if (matcher && strcmp (matcher, "grep") != 0)
	  fatal (_("you may specify only one of -E, -F, or -G"), 0);
	matcher = "grep";
	break;
      case 'H':
	with_filenames = 1;
	break;
#if O_BINARY
      case 'U':
	dos_use_file_type = DOS_BINARY;
	matcher = optarg;
	break;
      case 'u':
	dos_report_unix_offset = 1;
	Zflag = 1;
	break;
#endif
      case 'V':
	show_version = 1;
      case 'H': 
	Hflag = 1;
	Lflag = Pflag = 0;
	break;

	/* no symbolic links are followed */
      case 'P':
	Pflag = 1;
	Hflag = Lflag = 0;
	break;

	/* traverse file hierarchies */
      case 'R':
	Rflag = 1;
	break;
      case 'X':
	if (matcher)
	  fatal (_("matcher already specified"), 0);
	matcher = optarg;
	Hflag = Pflag = 0;
	break;
#endif
      case 'a':
	always_text = 1;
	break;
      case 'b':
	out_byte = 1;

	out_quiet = 1;
	count_matches = 1;
	break;
      case 'd':
	if (strcmp (optarg, "read") == 0)
	  directories = READ_DIRECTORIES;
	else if (strcmp (optarg, "skip") == 0)
	  directories = SKIP_DIRECTORIES;
	else if (strcmp (optarg, "recurse") == 0)
	  directories = RECURSE_DIRECTORIES;
	else
	  fatal (_("unknown directories method"), 0);
	break;
      case 'e':
	cc = strlen (optarg);
	keys = xrealloc (keys, keycc + cc + 1);
	strcpy (&keys[keycc], optarg);
	  keys[keycc++] = '\n';
	strcpy(&keys[keycc], optarg);
	keycc += cc;
	keys[keycc++] = '\n';
	break;
      case 'f':
	fp = strcmp (optarg, "-") != 0 ? fopen (optarg, "r") : stdin;
	if (!fp)
	  fatal (optarg, errno);
	for (keyalloc = 1; keyalloc <= keycc + 1; keyalloc *= 2)
	  ;
	keys = xrealloc (keys, keyalloc);
	oldcc = keycc;
	while (!feof (fp)
	       && (cc = fread (keys + keycc, 1, keyalloc - 1 - keycc, fp)) > 0)
	while (!feof(fp)
	       && (cc = fread(keys + keycc, 1, keyalloc - keycc, fp)) > 0)
	  {
	    keycc += cc;
	    if (keycc == keyalloc - 1)
	      keys = xrealloc (keys, keyalloc *= 2);
	  }
	if (fp != stdin)
	  fclose(fp);
	/* Append final newline if file ended in non-newline. */
	if (oldcc != keycc && keys[keycc - 1] != '\n')
	  keys[keycc++] = '\n';
	keyfound = 1;
	break;
      case 'h':
	no_filenames = 1;

	   Inspired by the same option in Hume's gre. */
	out_quiet = 1;
	list_files = -1;
	done_on_match = 1;
	break;
      case 'l':
	out_quiet = 1;
	list_files = 1;
	done_on_match = 1;
	break;
      case 'n':
	out_line = 1;
	break;
      case 'q':
	done_on_match = 1;
	out_quiet = 1;
	break;
      case 'r':
	directories = RECURSE_DIRECTORIES;
	break;
      case 's':
	suppress_errors = 1;
	break;

      case 'x':
	match_lines = 1;
	break;
      case 0:
	/* long options */
	break;
      default:
	usage (2);
	break;
      }

  if (out_after < 0)
    out_after = default_context;
  if (out_before < 0)
    out_before = default_context;

  if (show_version)
    {
      printf (_("grep (GNU grep) %s\n"), VERSION);
      printf ("\n");
      printf (_("\
Copyright (C) 1988, 1992-1998, 1999 Free Software Foundation, Inc.\n"));
      printf (_("\
This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"));
      printf ("\n");
      exit (0);
    }

  if (show_help)
    usage (0);

  if (keys)
    {
      if (keycc == 0)
	/* No keys were specified (e.g. -f /dev/null).  Match nothing.  */
        out_invert ^= 1;
      else
	/* Strip trailing newline. */
        --keycc;
    }
  else
    if (optind < argc)
      {
	keys = argv[optind++];
	keycc = strlen (keys);
      }
    else
      usage (2);

  if (! matcher)
    matcher = default_matcher;

  if (!setmatcher (matcher) && !setmatcher ("default"))
    abort ();

  (*compile)(keys, keycc);

  if ((argc - optind > 1 && !no_filenames) || with_filenames)
  if ((argc - optind > 1 || Rflag) && !no_filenames)
#else
  if (argc - optind > 1 && !no_filenames)
#endif
    out_file = 1;

#if O_BINARY
  /* Output is set to binary mode because we shouldn't convert
     NL to CR-LF pairs, especially when grepping binary files.  */
  if (!isatty (1))
    SET_BINARY (1);

    if (Hflag)
      fts_options |= FTS_COMFOLLOW;

    if (Lflag) {
      fts_options |= FTS_LOGICAL;
      fts_options &= ~FTS_PHYSICAL;
    }

    if (Pflag) {
      fts_options &= ~FTS_LOGICAL & ~FTS_COMFOLLOW;
      fts_options |= FTS_PHYSICAL;
    }      
  }

  if (Rflag && optind < argc) {
    int i;

    /* replace "-" with "/dev/stdin" */
    for (i = optind; i < argc; i++)
      if (strcmp(argv[i], "-") == 0)
	*(argv + i) = "/dev/stdin";

    if ((ftsp = fts_open(argv + optind, fts_options,  
			 (int(*)())NULL)) == NULL) {
      if (!suppress_errors)
	error("", errno);
    } else {

      while((ftsent = fts_read(ftsp)) != NULL) {
	filename = ftsent->fts_accpath;

	switch(ftsent->fts_info) {

	  /* regular file */
	case FTS_F:
	  break;

	  /* directory */
	case FTS_D:
	case FTS_DC:
	case FTS_DP:
	  continue; break;

	  /* errors */
	case FTS_DNR:
	  error(filename, errno);
	  continue; break;

	case FTS_ERR:
	case FTS_NS:
	  error(filename, ftsent->fts_errno);
	  continue; break;

	  /* dead symlink */
	case FTS_SLNONE:
	  continue; break;

	  /* symlink, don't skip */
	case FTS_SL:
	  break;

	default:
	  /* 
	  if (!suppress_errors)
	    fprintf(stderr, "%s: ignored\n", filename);
	  continue; break;
	  */

	}

	if ((desc = open(filename, O_RDONLY)) == -1) {
	  error(filename, errno);
	  continue;
	}

	count = grep(desc);
	if (count_matches)
	  {
	    if (out_file)
	      printf("%s:", filename);
	    printf("%d\n", count);
	  }
	if (count)
	  {
	    status = 0;
	    if (list_files == 1)
	      printf("%s\n", filename);
	  }
	else if (list_files == -1)
	  printf("%s\n", filename);

	if (desc != STDIN_FILENO) {
#if HAVE_LIBZ > 0
	  if (Zflag)
	    gzclose(gzbufdesc);
	  else
#endif
	  close(desc);
	}
      }

      if (fts_close(ftsp) == -1)
	error("fts_close", errno);
    }

  /* ! Rflag */
  } else

#endif /* HAVE_FTS */

  /* search in file names from arguments, not from stdin */
  if (optind < argc)

    while (optind < argc)
      {
	desc = strcmp(argv[optind], "-") ? 
	    open(argv[optind], O_RDONLY) : STDIN_FILENO;
	if (desc < 0)
	  {
	    if (!suppress_errors)
	      error(argv[optind], errno);
	  }
	else
	  {
	    filename = desc == STDIN_FILENO ? 
		"(standard input)" : argv[optind];
	    count = grep(desc);
	    if (count_matches)
	      {
		if (out_file)
		  printf("%s:", filename);
		printf("%d\n", count);
	      }
	    if (count)
	      {
		status = 0;
		if (list_files == 1)
		  printf("%s\n", filename);
	      }
	    else if (list_files == -1)
	      printf("%s\n", filename);

	    if (desc != STDIN_FILENO) {
#if HAVE_LIBZ > 0
	      if (Zflag)
	        gzclose(gzbufdesc);
	    else
#endif
	      close(desc);

	    }
          }
	++optind;
      }

  /* read input from stdin */
  else
    {
	status = 1;
	do
      if (count_matches)
	printf("%d\n", count);
      if (count)
	{
	  char *file = argv[optind];
	  status &= grepfile (strcmp (file, "-") == 0 ? (char *) NULL : file,
			      &stats_base);
	}
	while ( ++optind < argc);
	printf("(standard input)\n");
    }
  else
    status = grepfile ((char *) NULL, &stats_base);

  if (fclose (stdout) == EOF)
    error (_("writing output"), errno);

  exit (errseen ? 2 : status);
}

Lines 1-5 Link Here

(-)grep/grep.h (-20 / +15 lines)
1	/* grep.h - interface to grep driver for searching subroutines.	1	/* grep.h - interface to grep driver for searching subroutines.
2	Copyright (C) 1992 Free Software Foundation, Inc.	2	Copyright (C) 1992, 1998 Free Software Foundation, Inc.
3		3
4	This program is free software; you can redistribute it and/or modify	4	This program is free software; you can redistribute it and/or modify
5	it under the terms of the GNU General Public License as published by	5	it under the terms of the GNU General Public License as published by
Lines 13-23 Link Here
13		13
14	You should have received a copy of the GNU General Public License	14	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software	15	along with this program; if not, write to the Free Software
16	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
		17	02111-1307, USA. */
17		18
18	#if __STDC__	19	#if __GNUC__ < 2 \|\| (__GNUC__ == 2 && __GNUC_MINOR__ < 6) \|\| __STRICT_ANSI__
		20	# define __attribute__(x)
		21	#endif
19		22
20	extern void fatal(const char *, int);	23	extern void fatal PARAMS ((const char *, int)) __attribute__((noreturn));
		24	extern char *xmalloc PARAMS ((size_t size));
		25	extern char xrealloc PARAMS ((char ptr, size_t size));
21		26
22	/* Grep.c expects the matchers vector to be terminated	27	/* Grep.c expects the matchers vector to be terminated
23	by an entry with a NULL name, and to contain at least	28	by an entry with a NULL name, and to contain at least
Lines 26-50 Link Here
26	extern struct matcher	31	extern struct matcher
27	{	32	{
28	char *name;	33	char *name;
29	void (compile)(char , size_t);	34	void (compile) PARAMS ((char , size_t));
30	char (execute)(char , size_t, char *);	35	char (execute) PARAMS ((char , size_t, char *));
31	} matchers[];	36	} matchers[];
32		37
33	#else
34
35	extern void fatal();
36
37	extern struct matcher
38	{
39	char *name;
40	void (*compile)();
41	char (execute)();
42	} matchers[];
43
44	#endif
45
46	/* Exported from grep.c. */	38	/* Exported from grep.c. */
47	extern char *matcher;	39	extern char const *matcher;
		40
		41	/* Exported from fgrepmat.c, egrepmat.c, grepmat.c. */
		42	extern char const default_matcher[];
48		43
49	/* The following flags are exported from grep for the matchers	44	/* The following flags are exported from grep for the matchers
50	to look at. */	45	to look at. */

Line 0 Link Here

(-)grep/grepmat.c (+6 lines)
	1	#ifdef HAVE_CONFIG_H
	2	# include <config.h>
	3	#endif
	4	#include "system.h"
	5	#include "grep.h"
	6	char const default_matcher[] = "grep";




/* kwset.c - search for any of a set of keywords.
   Copyright (C) 1989, 1998 Free Software Foundation, Inc.
		  Written August 1989 by Mike Haertel.

   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,


   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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

/* Written August 1989 by Mike Haertel.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation. */


   String Matching:  An Aid to Bibliographic Search," CACM June 1975,
   Vol. 18, No. 6, which describes the failure function used below. */

#ifdef HAVE_CONFIG_H
# include <config.h>
#include <limits.h>
#include <stdlib.h>
#else
#define INT_MAX 2147483647
#define UCHAR_MAX 255
#ifdef __STDC__
#include <stddef.h>
#else
#include <sys/types.h>
#endif
extern char *malloc();
extern void free();
#endif

#ifdef HAVE_MEMCHR
#include <string.h>
#ifdef NEED_MEMORY_H
#include <memory.h>
#endif
#else
#ifdef __STDC__
extern void *memchr();
#else
extern char *memchr();
#endif
#endif
#include <sys/types.h>
#include "system.h"
#include "kwset.h"
#include "obstack.h"

#ifdef GREP
extern char *xmalloc();
# undef malloc
# define malloc xmalloc
#endif

#include "kwset.h"
#include "obstack.h"

#define NCHAR (UCHAR_MAX + 1)
#define obstack_chunk_alloc malloc
#define obstack_chunk_free free

  char *trans;			/* Character translation table. */
};

/* prototypes */
static void enqueue PARAMS((struct tree *, struct trie **));
static void treefails PARAMS((register struct tree *, struct trie *, struct trie *));
static void treedelta PARAMS((register struct tree *,register unsigned int, unsigned char *));
static int  hasevery PARAMS((register struct tree *, register struct tree *));
static void treenext PARAMS((struct tree *, struct trie **));
static char * bmexec PARAMS((kwset_t, char *, size_t));
static char * cwexec PARAMS((kwset_t, char *, size_t, struct kwsmatch *));

/* Allocate and initialize a keyword set object, returning an opaque
   pointer to it.  Return NULL if memory is not available. */
kwset_t

	  link = (struct tree *) obstack_alloc(&kwset->obstack,
					       sizeof (struct tree));
	  if (!link)
	    return _("memory exhausted");
	  link->llink = 0;
	  link->rlink = 0;
	  link->trie = (struct trie *) obstack_alloc(&kwset->obstack,
						     sizeof (struct trie));
	  if (!link->trie)
	    return _("memory exhausted");
	  link->trie->accepting = 0;
	  link->trie->links = 0;
	  link->trie->parent = trie;

		      r->balance = t->balance != (char) -1 ? 0 : 1;
		      t->balance = 0;
		      break;
		    default:
		      abort ();
		    }
		  break;
		case 2:

		      r->balance = t->balance != (char) -1 ? 0 : 1;
		      t->balance = 0;
		      break;
		    default:
		      abort ();
		    }
		  break;
		default:
		  abort ();
		}

	      if (dirs[depth - 1] == L)

      d = d1[U((tp += d)[-1])];
      if (d != 0)
	continue;
      if (U(tp[-2]) == gc)
	{
	  for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)
	    ;

  register char *end, *qlim;
  register struct tree *tree;
  register char *trans;

#ifdef lint
  accept = NULL;
#endif

  /* Initialize register copies and look for easy ways out. */
  kwset = (struct kwset *) kws;




/* kwset.h - header declaring the keyword set library.
   Copyright (C) 1989, 1998 Free Software Foundation, Inc.
		  Written August 1989 by Mike Haertel.

   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,


   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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

/* Written August 1989 by Mike Haertel.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation. */


  size_t size[1];		/* Length of each submatch. */
};

typedef ptr_t kwset_t;

typedef void *kwset_t;

/* Return an opaque pointer to a newly allocated keyword set, or NULL
   if enough memory cannot be obtained.  The argument if non-NULL
   specifies a table of character translations to be applied to all
   pattern and search text. */
extern kwset_t kwsalloc PARAMS((char *));

/* Incrementally extend the keyword set to include the given string.
   Return NULL for success, or an error message.  Remember an index
   number for each keyword included in the set. */
extern char *kwsincr PARAMS((kwset_t, char *, size_t));

/* When the keyword set has been completely built, prepare it for
   use.  Return NULL for success, or an error message. */
extern char *kwsprep PARAMS((kwset_t));

/* Search through the given buffer for a member of the keyword set.
   Return a pointer to the leftmost longest match found, or NULL if

   the matching substring in the integer it points to.  Similarly,
   if foundindex is non-NULL, store the index of the particular
   keyword found therein. */
extern char *kwsexec PARAMS((kwset_t, char *, size_t, struct kwsmatch *));

/* Deallocate the given keyword set and all its associated storage. */
extern void kwsfree PARAMS((kwset_t));

#else

typedef char *kwset_t;

extern kwset_t kwsalloc();
extern char *kwsincr();
extern char *kwsprep();
extern char *kwsexec();
extern void kwsfree();

#endif




/* Copyright (C) 1991, 1993, 1998 Free Software Foundation, Inc.
   Based on strlen implemention by Torbjorn Granlund (tege@sics.se),
   with help from Dan Sahlin (dan@sics.se) and
   commentary by Jim Blandy (jimb@ai.mit.edu);
   adaptation to memchr suggested by Dick Karpinski (dick@cca.ucsf.edu),
   and implemented by Roland McGrath (roland@ai.mit.edu).

NOTE: The canonical source of this file is maintained with the GNU C Library.
Bugs can be reported to bug-glibc@prep.ai.mit.edu.

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, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#undef __ptr_t
#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
# define __ptr_t void *
#else /* Not C++ or ANSI C.  */
# define __ptr_t char *
#endif /* C++ or ANSI C.  */

#if defined (_LIBC)
# include <string.h>
#endif

#if defined (HAVE_LIMITS_H) || defined (_LIBC)
# include <limits.h>
#endif

#define LONG_MAX_32_BITS 2147483647

#ifndef LONG_MAX
#define LONG_MAX LONG_MAX_32_BITS
#endif

#include <sys/types.h>


/* Search no more than N bytes of S for C.  */

__ptr_t
memchr (s, c, n)
     const __ptr_t s;
     int c;
     size_t n;
{
  const unsigned char *char_ptr;
  const unsigned long int *longword_ptr;
  unsigned long int longword, magic_bits, charmask;

  c = (unsigned char) c;

  /* Handle the first few characters by reading one character at a time.
     Do this until CHAR_PTR is aligned on a longword boundary.  */
  for (char_ptr = (const unsigned char *) s;
       n > 0 && ((unsigned long int) char_ptr
		 & (sizeof (longword) - 1)) != 0;
       --n, ++char_ptr)
    if (*char_ptr == c)
      return (__ptr_t) char_ptr;

  /* All these elucidatory comments refer to 4-byte longwords,
     but the theory applies equally well to 8-byte longwords.  */

  longword_ptr = (unsigned long int *) char_ptr;

  /* Bits 31, 24, 16, and 8 of this number are zero.  Call these bits
     the "holes."  Note that there is a hole just to the left of
     each byte, with an extra at the end:

     bits:  01111110 11111110 11111110 11111111
     bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD

     The 1-bits make sure that carries propagate to the next 0-bit.
     The 0-bits provide holes for carries to fall into.  */

  if (sizeof (longword) != 4 && sizeof (longword) != 8)
    abort ();

#if LONG_MAX <= LONG_MAX_32_BITS
  magic_bits = 0x7efefeff;
#else
  magic_bits = ((unsigned long int) 0x7efefefe << 32) | 0xfefefeff;
#endif

  /* Set up a longword, each of whose bytes is C.  */
  charmask = c | (c << 8);
  charmask |= charmask << 16;
#if LONG_MAX > LONG_MAX_32_BITS
  charmask |= charmask << 32;
#endif

  /* Instead of the traditional loop which tests each character,
     we will test a longword at a time.  The tricky part is testing
     if *any of the four* bytes in the longword in question are zero.  */
  while (n >= sizeof (longword))
    {
      /* We tentatively exit the loop if adding MAGIC_BITS to
	 LONGWORD fails to change any of the hole bits of LONGWORD.

	 1) Is this safe?  Will it catch all the zero bytes?
	 Suppose there is a byte with all zeros.  Any carry bits
	 propagating from its left will fall into the hole at its
	 least significant bit and stop.  Since there will be no
	 carry from its most significant bit, the LSB of the
	 byte to the left will be unchanged, and the zero will be
	 detected.

	 2) Is this worthwhile?  Will it ignore everything except
	 zero bytes?  Suppose every byte of LONGWORD has a bit set
	 somewhere.  There will be a carry into bit 8.  If bit 8
	 is set, this will carry into bit 16.  If bit 8 is clear,
	 one of bits 9-15 must be set, so there will be a carry
	 into bit 16.  Similarly, there will be a carry into bit
	 24.  If one of bits 24-30 is set, there will be a carry
	 into bit 31, so all of the hole bits will be changed.

	 The one misfire occurs when bits 24-30 are clear and bit
	 31 is set; in this case, the hole at bit 31 is not
	 changed.  If we had access to the processor carry flag,
	 we could close this loophole by putting the fourth hole
	 at bit 32!

	 So it ignores everything except 128's, when they're aligned
	 properly.

	 3) But wait!  Aren't we looking for C, not zero?
	 Good point.  So what we do is XOR LONGWORD with a longword,
	 each of whose bytes is C.  This turns each byte that is C
	 into a zero.  */

      longword = *longword_ptr++ ^ charmask;

      /* Add MAGIC_BITS to LONGWORD.  */
      if ((((longword + magic_bits)

	    /* Set those bits that were unchanged by the addition.  */
	    ^ ~longword)

	   /* Look at only the hole bits.  If any of the hole bits
	      are unchanged, most likely one of the bytes was a
	      zero.  */
	   & ~magic_bits) != 0)
	{
	  /* Which of the bytes was C?  If none of them were, it was
	     a misfire; continue the search.  */

	  const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);

	  if (cp[0] == c)
	    return (__ptr_t) cp;
	  if (cp[1] == c)
	    return (__ptr_t) &cp[1];
	  if (cp[2] == c)
	    return (__ptr_t) &cp[2];
	  if (cp[3] == c)
	    return (__ptr_t) &cp[3];
#if LONG_MAX > 2147483647
	  if (cp[4] == c)
	    return (__ptr_t) &cp[4];
	  if (cp[5] == c)
	    return (__ptr_t) &cp[5];
	  if (cp[6] == c)
	    return (__ptr_t) &cp[6];
	  if (cp[7] == c)
	    return (__ptr_t) &cp[7];
#endif
	}

      n -= sizeof (longword);
    }

  char_ptr = (const unsigned char *) longword_ptr;

  while (n-- > 0)
    {
      if (*char_ptr == c)
	return (__ptr_t) char_ptr;
      else
	++char_ptr;
    }

  return 0;
}

Lines 1-5 Link Here

(-)grep/obstack.c (-42 / +181 lines)
1	/* obstack.c - subroutines used implicitly by object stack macros	1	/* obstack.h - object stack macros
2	Copyright (C) 1988, 1993 Free Software Foundation, Inc.	2	Copyright (C) 1988,89,90,91,92,93,94,96,97, 98 Free Software Foundation, Inc.
		3
		4	the C library, however. The master source lives in /gd/gnu/lib.
		5
		6	NOTE: The canonical source of this file is maintained with the
		7	GNU C Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
3		8
4	This program is free software; you can redistribute it and/or modify it	9	This program is free software; you can redistribute it and/or modify it
5	under the terms of the GNU General Public License as published by the	10	under the terms of the GNU General Public License as published by the
Lines 12-37 Link Here
12	GNU General Public License for more details.	17	GNU General Public License for more details.
13		18
14	You should have received a copy of the GNU General Public License	19	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software	20	along with this program; if not, write to the Free Software Foundation,
16	Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */	21	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
		22
		23	#ifdef HAVE_CONFIG_H
		24	#include <config.h>
		25	#endif
17		26
18	#include "obstack.h"	27	#include "obstack.h"
19		28
20	/* This is just to get __GNU_LIBRARY__ defined. */	29	/* NOTE BEFORE MODIFYING THIS FILE: This version number must be
21	#include <stdio.h>	30	incremented whenever callers compiled using an old obstack.h can no
		31	longer properly call the functions in this obstack.c. */
		32	#define OBSTACK_INTERFACE_VERSION 1
22		33
23	/* Comment out all this code if we are using the GNU C Library, and are not	34	/* Comment out all this code if we are using the GNU C Library, and are not
24	actually compiling the library itself. This code is part of the GNU C	35	actually compiling the library itself, and the installed library
25	Library, but also included in many other GNU distributions. Compiling	36	supports the same library interface we do. This code is part of the GNU
		37	C Library, but also included in many other GNU distributions. Compiling
26	and linking in this code is a waste when using the GNU C library	38	and linking in this code is a waste when using the GNU C library
27	(especially if it is a shared library). Rather than having every GNU	39	(especially if it is a shared library). Rather than having every GNU
28	program understand `configure --with-gnu-libc' and omit the object files,	40	program understand `configure --with-gnu-libc' and omit the object
29	it is simpler to just do this in the source for each such file. */	41	files, it is simpler to just do this in the source for each such file. */
		42
		43	#include <stdio.h> /* Random thing to get __GNU_LIBRARY__. */
		44	#if !defined (_LIBC) && defined (__GNU_LIBRARY__) && __GNU_LIBRARY__ > 1
		45	#include <gnu-versions.h>
		46	#if _GNU_OBSTACK_INTERFACE_VERSION == OBSTACK_INTERFACE_VERSION
		47	#define ELIDE_CODE
		48	#endif
		49	#endif
		50
30		51
31	#if defined (_LIBC) \|\| !defined (__GNU_LIBRARY__)	52	#ifndef ELIDE_CODE
32		53
33		54
34	#ifdef __STDC__	55	#if defined (__STDC__) && __STDC__
35	#define POINTER void *	56	#define POINTER void *
36	#else	57	#else
37	#define POINTER char *	58	#define POINTER char *
Lines 40-46 Link Here
40	/* Determine default alignment. */	61	/* Determine default alignment. */
41	struct fooalign {char x; double d;};	62	struct fooalign {char x; double d;};
42	#define DEFAULT_ALIGNMENT \	63	#define DEFAULT_ALIGNMENT \
43	((PTR_INT_TYPE) ((char )&((struct fooalign ) 0)->d - (char *)0))	64	((PTR_INT_TYPE) ((char ) &((struct fooalign ) 0)->d - (char *) 0))
44	/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.	65	/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT.
45	But in fact it might be less smart and round addresses to as much as	66	But in fact it might be less smart and round addresses to as much as
46	DEFAULT_ROUNDING. So we prepare for it to do that. */	67	DEFAULT_ROUNDING. So we prepare for it to do that. */
Lines 55-60 Link Here
55	#define COPYING_UNIT int	76	#define COPYING_UNIT int
56	#endif	77	#endif
57		78
		79
		80	/* The functions allocating more room by calling `obstack_chunk_alloc'
		81	jump to the handler pointed to by `obstack_alloc_failed_handler'.
		82	This variable by default points to the internal function
		83	`print_and_abort'. */
		84	#if defined (__STDC__) && __STDC__
		85	static void print_and_abort (void);
		86	void (*obstack_alloc_failed_handler) (void) = print_and_abort;
		87	#else
		88	static void print_and_abort ();
		89	void (*obstack_alloc_failed_handler) () = print_and_abort;
		90	#endif
		91
		92	/* Exit value used when `print_and_abort' is used. */
		93	#if defined __GNU_LIBRARY__ \|\| defined HAVE_STDLIB_H
		94	#include <stdlib.h>
		95	#endif
		96	#ifndef EXIT_FAILURE
		97	#define EXIT_FAILURE 1
		98	#endif
		99	int obstack_exit_failure = EXIT_FAILURE;
		100
58	/* The non-GNU-C macros copy the obstack into this global variable	101	/* The non-GNU-C macros copy the obstack into this global variable
59	to avoid multiple evaluation. */	102	to avoid multiple evaluation. */
60		103
Lines 66-102 Link Here
66	For free, do not use ?:, since some compilers, like the MIPS compilers,	109	For free, do not use ?:, since some compilers, like the MIPS compilers,
67	do not allow (expr) ? void : void. */	110	do not allow (expr) ? void : void. */
68		111
		112	#if defined (__STDC__) && __STDC__
69	#define CALL_CHUNKFUN(h, size) \	113	#define CALL_CHUNKFUN(h, size) \
70	(((h) -> use_extra_arg) \	114	(((h) -> use_extra_arg) \
71	? (*(h)->chunkfun) ((h)->extra_arg, (size)) \	115	? (*(h)->chunkfun) ((h)->extra_arg, (size)) \
72	: (*(h)->chunkfun) ((size)))	116	: ((struct _obstack_chunk (*) (long)) (h)->chunkfun) ((size)))
73		117
74	#define CALL_FREEFUN(h, old_chunk) \	118	#define CALL_FREEFUN(h, old_chunk) \
75	do { \	119	do { \
76	if ((h) -> use_extra_arg) \	120	if ((h) -> use_extra_arg) \
77	(*(h)->freefun) ((h)->extra_arg, (old_chunk)); \	121	(*(h)->freefun) ((h)->extra_arg, (old_chunk)); \
78	else \	122	else \
79	(*(h)->freefun) ((old_chunk)); \	123	((void () (void *)) (h)->freefun) ((old_chunk)); \
80	} while (0)	124	} while (0)
		125	#else
		126	#define CALL_CHUNKFUN(h, size) \
		127	(((h) -> use_extra_arg) \
		128	? (*(h)->chunkfun) ((h)->extra_arg, (size)) \
		129	: ((struct _obstack_chunk (*) ()) (h)->chunkfun) ((size)))
		130
		131	#define CALL_FREEFUN(h, old_chunk) \
		132	do { \
		133	if ((h) -> use_extra_arg) \
		134	(*(h)->freefun) ((h)->extra_arg, (old_chunk)); \
		135	else \
		136	((void () ()) (h)->freefun) ((old_chunk)); \
		137	} while (0)
		138	#endif
81		139
82		140
83	/* Initialize an obstack H for use. Specify chunk size SIZE (0 means default).	141	/* Initialize an obstack H for use. Specify chunk size SIZE (0 means default).
84	Objects start on multiples of ALIGNMENT (0 means use default).	142	Objects start on multiples of ALIGNMENT (0 means use default).
85	CHUNKFUN is the function to use to allocate chunks,	143	CHUNKFUN is the function to use to allocate chunks,
86	and FREEFUN the function to free them. */	144	and FREEFUN the function to free them.
87		145
88	void	146	Return nonzero if successful, zero if out of memory.
		147	To recover from an out of memory error,
		148	free up some memory, then call this again. */
		149
		150	int
89	_obstack_begin (h, size, alignment, chunkfun, freefun)	151	_obstack_begin (h, size, alignment, chunkfun, freefun)
90	struct obstack *h;	152	struct obstack *h;
91	int size;	153	int size;
92	int alignment;	154	int alignment;
		155	#if defined (__STDC__) && __STDC__
		156	POINTER (*chunkfun) (long);
		157	void (freefun) (void );
		158	#else
93	POINTER (*chunkfun) ();	159	POINTER (*chunkfun) ();
94	void (*freefun) ();	160	void (*freefun) ();
		161	#endif
95	{	162	{
96	register struct _obstack_chunk* chunk; /* points to new chunk */	163	register struct _obstack_chunk chunk; / points to new chunk */
97		164
98	if (alignment == 0)	165	if (alignment == 0)
99	alignment = DEFAULT_ALIGNMENT;	166	alignment = (int) DEFAULT_ALIGNMENT;
100	if (size == 0)	167	if (size == 0)
101	/* Default size is what GNU malloc can fit in a 4096-byte block. */	168	/* Default size is what GNU malloc can fit in a 4096-byte block. */
102	{	169	{
Lines 114-147 Link Here
114	size = 4096 - extra;	181	size = 4096 - extra;
115	}	182	}
116		183
		184	#if defined (__STDC__) && __STDC__
		185	h->chunkfun = (struct _obstack_chunk * ()(void , long)) chunkfun;
		186	h->freefun = (void () (void , struct _obstack_chunk *)) freefun;
		187	#else
117	h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun;	188	h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun;
118	h->freefun = freefun;	189	h->freefun = freefun;
		190	#endif
119	h->chunk_size = size;	191	h->chunk_size = size;
120	h->alignment_mask = alignment - 1;	192	h->alignment_mask = alignment - 1;
121	h->use_extra_arg = 0;	193	h->use_extra_arg = 0;
122		194
123	chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);	195	chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);
		196	if (!chunk)
		197	(*obstack_alloc_failed_handler) ();
124	h->next_free = h->object_base = chunk->contents;	198	h->next_free = h->object_base = chunk->contents;
125	h->chunk_limit = chunk->limit	199	h->chunk_limit = chunk->limit
126	= (char *) chunk + h->chunk_size;	200	= (char *) chunk + h->chunk_size;
127	chunk->prev = 0;	201	chunk->prev = 0;
128	/* The initial chunk now contains no empty object. */	202	/* The initial chunk now contains no empty object. */
129	h->maybe_empty_object = 0;	203	h->maybe_empty_object = 0;
		204	h->alloc_failed = 0;
		205	return 1;
130	}	206	}
131		207
132	void	208	int
133	_obstack_begin_1 (h, size, alignment, chunkfun, freefun, arg)	209	_obstack_begin_1 (h, size, alignment, chunkfun, freefun, arg)
134	struct obstack *h;	210	struct obstack *h;
135	int size;	211	int size;
136	int alignment;	212	int alignment;
		213	#if defined (__STDC__) && __STDC__
		214	POINTER (*chunkfun) (POINTER, long);
		215	void (*freefun) (POINTER, POINTER);
		216	#else
137	POINTER (*chunkfun) ();	217	POINTER (*chunkfun) ();
138	void (*freefun) ();	218	void (*freefun) ();
		219	#endif
139	POINTER arg;	220	POINTER arg;
140	{	221	{
141	register struct _obstack_chunk* chunk; /* points to new chunk */	222	register struct _obstack_chunk chunk; / points to new chunk */
142		223
143	if (alignment == 0)	224	if (alignment == 0)
144	alignment = DEFAULT_ALIGNMENT;	225	alignment = (int) DEFAULT_ALIGNMENT;
145	if (size == 0)	226	if (size == 0)
146	/* Default size is what GNU malloc can fit in a 4096-byte block. */	227	/* Default size is what GNU malloc can fit in a 4096-byte block. */
147	{	228	{
Lines 159-178 Link Here
159	size = 4096 - extra;	240	size = 4096 - extra;
160	}	241	}
161		242
		243	#if defined(__STDC__) && __STDC__
		244	h->chunkfun = (struct _obstack_chunk * ()(void ,long)) chunkfun;
		245	h->freefun = (void () (void , struct _obstack_chunk *)) freefun;
		246	#else
162	h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun;	247	h->chunkfun = (struct _obstack_chunk * (*)()) chunkfun;
163	h->freefun = freefun;	248	h->freefun = freefun;
		249	#endif
164	h->chunk_size = size;	250	h->chunk_size = size;
165	h->alignment_mask = alignment - 1;	251	h->alignment_mask = alignment - 1;
166	h->extra_arg = arg;	252	h->extra_arg = arg;
167	h->use_extra_arg = 1;	253	h->use_extra_arg = 1;
168		254
169	chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);	255	chunk = h->chunk = CALL_CHUNKFUN (h, h -> chunk_size);
		256	if (!chunk)
		257	(*obstack_alloc_failed_handler) ();
170	h->next_free = h->object_base = chunk->contents;	258	h->next_free = h->object_base = chunk->contents;
171	h->chunk_limit = chunk->limit	259	h->chunk_limit = chunk->limit
172	= (char *) chunk + h->chunk_size;	260	= (char *) chunk + h->chunk_size;
173	chunk->prev = 0;	261	chunk->prev = 0;
174	/* The initial chunk now contains no empty object. */	262	/* The initial chunk now contains no empty object. */
175	h->maybe_empty_object = 0;	263	h->maybe_empty_object = 0;
		264	h->alloc_failed = 0;
		265	return 1;
176	}	266	}
177		267
178	/* Allocate a new current chunk for the obstack *H	268	/* Allocate a new current chunk for the obstack *H
Lines 186-197 Link Here
186	struct obstack *h;	276	struct obstack *h;
187	int length;	277	int length;
188	{	278	{
189	register struct _obstack_chunk* old_chunk = h->chunk;	279	register struct _obstack_chunk *old_chunk = h->chunk;
190	register struct _obstack_chunk* new_chunk;	280	register struct _obstack_chunk *new_chunk;
191	register long new_size;	281	register long new_size;
192	register int obj_size = h->next_free - h->object_base;	282	register long obj_size = h->next_free - h->object_base;
193	register int i;	283	register long i;
194	int already;	284	long already;
195		285
196	/* Compute size for new chunk. */	286	/* Compute size for new chunk. */
197	new_size = (obj_size + length) + (obj_size >> 3) + 100;	287	new_size = (obj_size + length) + (obj_size >> 3) + 100;
Lines 199-205 Link Here
199	new_size = h->chunk_size;	289	new_size = h->chunk_size;
200		290
201	/* Allocate and initialize the new chunk. */	291	/* Allocate and initialize the new chunk. */
202	new_chunk = h->chunk = CALL_CHUNKFUN (h, new_size);	292	new_chunk = CALL_CHUNKFUN (h, new_size);
		293	if (!new_chunk)
		294	(*obstack_alloc_failed_handler) ();
		295	h->chunk = new_chunk;
203	new_chunk->prev = old_chunk;	296	new_chunk->prev = old_chunk;
204	new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;	297	new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size;
205		298
Lines 242-260 Link Here
242	This is here for debugging.	335	This is here for debugging.
243	If you use it in a program, you are probably losing. */	336	If you use it in a program, you are probably losing. */
244		337
		338	#if defined (__STDC__) && __STDC__
		339	/* Suppress -Wmissing-prototypes warning. We don't want to declare this in
		340	obstack.h because it is just for debugging. */
		341	int _obstack_allocated_p (struct obstack *h, POINTER obj);
		342	#endif
		343
245	int	344	int
246	_obstack_allocated_p (h, obj)	345	_obstack_allocated_p (h, obj)
247	struct obstack *h;	346	struct obstack *h;
248	POINTER obj;	347	POINTER obj;
249	{	348	{
250	register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */	349	register struct _obstack_chunk lp; / below addr of any objects in this chunk */
251	register struct _obstack_chunk* plp; /* point to previous chunk if any */	350	register struct _obstack_chunk plp; / point to previous chunk if any */
252		351
253	lp = (h)->chunk;	352	lp = (h)->chunk;
254	/* We use >= rather than > since the object cannot be exactly at	353	/* We use >= rather than > since the object cannot be exactly at
255	the beginning of the chunk but might be an empty object exactly	354	the beginning of the chunk but might be an empty object exactly
256	at the end of an adjacent chunk. */	355	at the end of an adjacent chunk. */
257	while (lp != 0 && ((POINTER)lp >= obj \|\| (POINTER)(lp)->limit < obj))	356	while (lp != 0 && ((POINTER) lp >= obj \|\| (POINTER) (lp)->limit < obj))
258	{	357	{
259	plp = lp->prev;	358	plp = lp->prev;
260	lp = plp;	359	lp = plp;
Lines 275-288 Link Here
275	struct obstack *h;	374	struct obstack *h;
276	POINTER obj;	375	POINTER obj;
277	{	376	{
278	register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */	377	register struct _obstack_chunk lp; / below addr of any objects in this chunk */
279	register struct _obstack_chunk* plp; /* point to previous chunk if any */	378	register struct _obstack_chunk plp; / point to previous chunk if any */
280		379
281	lp = h->chunk;	380	lp = h->chunk;
282	/* We use >= because there cannot be an object at the beginning of a chunk.	381	/* We use >= because there cannot be an object at the beginning of a chunk.
283	But there can be an empty object at that address	382	But there can be an empty object at that address
284	at the end of another chunk. */	383	at the end of another chunk. */
285	while (lp != 0 && ((POINTER)lp >= obj \|\| (POINTER)(lp)->limit < obj))	384	while (lp != 0 && ((POINTER) lp >= obj \|\| (POINTER) (lp)->limit < obj))
286	{	385	{
287	plp = lp->prev;	386	plp = lp->prev;
288	CALL_FREEFUN (h, lp);	387	CALL_FREEFUN (h, lp);
Lines 293-299 Link Here
293	}	392	}
294	if (lp)	393	if (lp)
295	{	394	{
296	h->object_base = h->next_free = (char *)(obj);	395	h->object_base = h->next_free = (char *) (obj);
297	h->chunk_limit = lp->limit;	396	h->chunk_limit = lp->limit;
298	h->chunk = lp;	397	h->chunk = lp;
299	}	398	}
Lines 309-322 Link Here
309	struct obstack *h;	408	struct obstack *h;
310	POINTER obj;	409	POINTER obj;
311	{	410	{
312	register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */	411	register struct _obstack_chunk lp; / below addr of any objects in this chunk */
313	register struct _obstack_chunk* plp; /* point to previous chunk if any */	412	register struct _obstack_chunk plp; / point to previous chunk if any */
314		413
315	lp = h->chunk;	414	lp = h->chunk;
316	/* We use >= because there cannot be an object at the beginning of a chunk.	415	/* We use >= because there cannot be an object at the beginning of a chunk.
317	But there can be an empty object at that address	416	But there can be an empty object at that address
318	at the end of another chunk. */	417	at the end of another chunk. */
319	while (lp != 0 && ((POINTER)lp >= obj \|\| (POINTER)(lp)->limit < obj))	418	while (lp != 0 && ((POINTER) lp >= obj \|\| (POINTER) (lp)->limit < obj))
320	{	419	{
321	plp = lp->prev;	420	plp = lp->prev;
322	CALL_FREEFUN (h, lp);	421	CALL_FREEFUN (h, lp);
Lines 327-333 Link Here
327	}	426	}
328	if (lp)	427	if (lp)
329	{	428	{
330	h->object_base = h->next_free = (char *)(obj);	429	h->object_base = h->next_free = (char *) (obj);
331	h->chunk_limit = lp->limit;	430	h->chunk_limit = lp->limit;
332	h->chunk = lp;	431	h->chunk = lp;
333	}	432	}
Lines 336-341 Link Here
336	abort ();	435	abort ();
337	}	436	}
338		437
		438	int
		439	_obstack_memory_used (h)
		440	struct obstack *h;
		441	{
		442	register struct _obstack_chunk* lp;
		443	register int nbytes = 0;
		444
		445	for (lp = h->chunk; lp != 0; lp = lp->prev)
		446	{
		447	nbytes += lp->limit - (char *) lp;
		448	}
		449	return nbytes;
		450	}
		451
		452	/* Define the error handler. */
		453	#ifndef _
		454	# ifdef HAVE_LIBINTL_H
		455	# include <libintl.h>
		456	# ifndef _
		457	# define _(Str) gettext (Str)
		458	# endif
		459	# else
		460	# define _(Str) (Str)
		461	# endif
		462	#endif
		463
		464	static void
		465	print_and_abort ()
		466	{
		467	fputs (_("memory exhausted\n"), stderr);
		468	exit (obstack_exit_failure);
		469	}
		470
339	#if 0	471	#if 0
340	/* These are now turned off because the applications do not use it	472	/* These are now turned off because the applications do not use it
341	and it uses bcopy via obstack_grow, which causes trouble on sysV. */	473	and it uses bcopy via obstack_grow, which causes trouble on sysV. */
Lines 343-349 Link Here
343	/* Now define the functional versions of the obstack macros.	475	/* Now define the functional versions of the obstack macros.
344	Define them to simply use the corresponding macros to do the job. */	476	Define them to simply use the corresponding macros to do the job. */
345		477
346	#ifdef __STDC__	478	#if defined (__STDC__) && __STDC__
347	/* These function definitions do not work with non-ANSI preprocessors;	479	/* These function definitions do not work with non-ANSI preprocessors;
348	they won't pass through the macro names in parentheses. */	480	they won't pass through the macro names in parentheses. */
349		481
Lines 374-379 Link Here
374	return obstack_room (obstack);	506	return obstack_room (obstack);
375	}	507	}
376		508
		509	int (obstack_make_room) (obstack, length)
		510	struct obstack *obstack;
		511	int length;
		512	{
		513	return obstack_make_room (obstack, length);
		514	}
		515
377	void (obstack_grow) (obstack, pointer, length)	516	void (obstack_grow) (obstack, pointer, length)
378	struct obstack *obstack;	517	struct obstack *obstack;
379	POINTER pointer;	518	POINTER pointer;
Lines 451-454 Link Here
451		590
452	#endif /* 0 */	591	#endif /* 0 */
453		592
454	#endif /* _LIBC or not __GNU_LIBRARY__. */	593	#endif /* !ELIDE_CODE */

Lines 1-5 Link Here

(-)grep/obstack.h (-66 / +173 lines)
1	/* obstack.h - object stack macros	1	/* obstack.h - object stack macros
2	Copyright (C) 1988, 1992 Free Software Foundation, Inc.	2	Copyright (C) 1988,89,90,91,92,93,94,96,97, 98 Free Software Foundation, Inc.
		3
		4	the C library, however. The master source lives in /gd/gnu/lib.
		5
		6	NOTE: The canonical source of this file is maintained with the
		7	GNU C Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu.
3		8
4	This program is free software; you can redistribute it and/or modify it	9	This program is free software; you can redistribute it and/or modify it
5	under the terms of the GNU General Public License as published by the	10	under the terms of the GNU General Public License as published by the
Lines 12-19 Link Here
12	GNU General Public License for more details.	17	GNU General Public License for more details.
13		18
14	You should have received a copy of the GNU General Public License	19	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software	20	along with this program; if not, write to the Free Software Foundation,
16	Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */	21	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
17		22
18	/* Summary:	23	/* Summary:
19		24
Lines 100-146 Link Here
100		105
101	/* Don't do the contents of this file more than once. */	106	/* Don't do the contents of this file more than once. */
102		107
103	#ifndef __OBSTACKS__	108	#ifndef _OBSTACK_H
104	#define __OBSTACKS__	109	#define _OBSTACK_H 1
		110
		111	#ifdef __cplusplus
		112	extern "C" {
		113	#endif
105		114
106	/* We use subtraction of (char *)0 instead of casting to int	115	/* We use subtraction of (char *) 0 instead of casting to int
107	because on word-addressable machines a simple cast to int	116	because on word-addressable machines a simple cast to int
108	may ignore the byte-within-word field of the pointer. */	117	may ignore the byte-within-word field of the pointer. */
109		118
110	#ifndef __PTR_TO_INT	119	#ifndef __PTR_TO_INT
111	#define __PTR_TO_INT(P) ((P) - (char *)0)	120	#define __PTR_TO_INT(P) ((P) - (char *) 0)
112	#endif	121	#endif
113		122
114	#ifndef __INT_TO_PTR	123	#ifndef __INT_TO_PTR
115	#define __INT_TO_PTR(P) ((P) + (char *)0)	124	#define __INT_TO_PTR(P) ((P) + (char *) 0)
116	#endif	125	#endif
117		126
118	/* We need the type of the resulting object. In ANSI C it is ptrdiff_t	127	/* We need the type of the resulting object. In ANSI C it is ptrdiff_t
119	but in traditional C it is usually long. If we are in ANSI C and	128	but in traditional C it is usually long. If we are in ANSI C and
120	don't already have ptrdiff_t get it. */	129	don't already have ptrdiff_t get it. */
121		130
122	#if defined (__STDC__) && ! defined (offsetof)	131	#if defined (__STDC__) && __STDC__ && ! defined (offsetof)
123	#if defined (__GNUC__) && defined (IN_GCC)	132	#if defined (__GNUC__) && defined (IN_GCC)
124	/* On Next machine, the system's stddef.h screws up if included	133	/* On Next machine, the system's stddef.h screws up if included
125	after we have defined just ptrdiff_t, so include all of gstddef.h.	134	after we have defined just ptrdiff_t, so include all of stddef.h.
126	Otherwise, define just ptrdiff_t, which is all we need. */	135	Otherwise, define just ptrdiff_t, which is all we need. */
127	#ifndef __NeXT__	136	#ifndef __NeXT__
128	#define __need_ptrdiff_t	137	#define __need_ptrdiff_t
129	#endif	138	#endif
		139	#endif
130		140
131	/* While building GCC, the stddef.h that goes with GCC has this name. */
132	#include "gstddef.h"
133	#else
134	#include <stddef.h>	141	#include <stddef.h>
135	#endif	142	#endif
136	#endif
137		143
138	#ifdef __STDC__	144	#if defined (__STDC__) && __STDC__
139	#define PTR_INT_TYPE ptrdiff_t	145	#define PTR_INT_TYPE ptrdiff_t
140	#else	146	#else
141	#define PTR_INT_TYPE long	147	#define PTR_INT_TYPE long
142	#endif	148	#endif
143		149
		150	#if defined (_LIBC) \|\| defined (HAVE_STRING_H)
		151	#include <string.h>
		152	#define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N))
		153	#else
		154	#ifdef memcpy
		155	#define _obstack_memcpy(To, From, N) memcpy ((To), (From), (N))
		156	#else
		157	#define _obstack_memcpy(To, From, N) bcopy ((From), (To), (N))
		158	#endif
		159	#endif
		160
144	struct _obstack_chunk /* Lives at front of each chunk. */	161	struct _obstack_chunk /* Lives at front of each chunk. */
145	{	162	{
146	char limit; / 1 past end of this chunk */	163	char limit; / 1 past end of this chunk */
Lines 151-189 Link Here
151	struct obstack /* control current object in current chunk */	168	struct obstack /* control current object in current chunk */
152	{	169	{
153	long chunk_size; /* preferred size to allocate chunks in */	170	long chunk_size; /* preferred size to allocate chunks in */
154	struct _obstack_chunk* chunk; /* address of current struct obstack_chunk */	171	struct _obstack_chunk chunk; / address of current struct obstack_chunk */
155	char object_base; / address of object we are building */	172	char object_base; / address of object we are building */
156	char next_free; / where to add next char to current object */	173	char next_free; / where to add next char to current object */
157	char chunk_limit; / address of char after current chunk */	174	char chunk_limit; / address of char after current chunk */
158	PTR_INT_TYPE temp; /* Temporary for some macros. */	175	PTR_INT_TYPE temp; /* Temporary for some macros. */
159	int alignment_mask; /* Mask of alignment for each object. */	176	int alignment_mask; /* Mask of alignment for each object. */
		177	#if defined (__STDC__) && __STDC__
		178	/* These prototypes vary based on `use_extra_arg', and we use
		179	casts to the prototypeless function type in all assignments,
		180	but having prototypes here quiets -Wstrict-prototypes. */
		181	struct _obstack_chunk (chunkfun) (void *, long);
		182	void (freefun) (void , struct _obstack_chunk *);
		183	void extra_arg; / first arg for chunk alloc/dealloc funcs */
		184	#else
160	struct _obstack_chunk (chunkfun) (); /* User's fcn to allocate a chunk. */	185	struct _obstack_chunk (chunkfun) (); /* User's fcn to allocate a chunk. */
161	void (freefun) (); / User's function to free a chunk. */	186	void (freefun) (); / User's function to free a chunk. */
162	char extra_arg; / first arg for chunk alloc/dealloc funcs */	187	char extra_arg; / first arg for chunk alloc/dealloc funcs */
		188	#endif
163	unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */	189	unsigned use_extra_arg:1; /* chunk alloc/dealloc funcs take extra arg */
164	unsigned maybe_empty_object:1;/* There is a possibility that the current	190	unsigned maybe_empty_object:1;/* There is a possibility that the current
165	chunk contains a zero-length object. This	191	chunk contains a zero-length object. This
166	prevents freeing the chunk if we allocate	192	prevents freeing the chunk if we allocate
167	a bigger chunk to replace it. */	193	a bigger chunk to replace it. */
		194	unsigned alloc_failed:1; /* No longer used, as we now call the failed
		195	handler on error, but retained for binary
		196	compatibility. */
168	};	197	};
169		198
170	/* Declare the external functions we use; they are in obstack.c. */	199	/* Declare the external functions we use; they are in obstack.c. */
171		200
172	#ifdef __STDC__	201	#if defined (__STDC__) && __STDC__
173	extern void _obstack_newchunk (struct obstack *, int);	202	extern void _obstack_newchunk (struct obstack *, int);
174	extern void _obstack_free (struct obstack , void );	203	extern void _obstack_free (struct obstack , void );
175	extern void _obstack_begin (struct obstack *, int, int,	204	extern int _obstack_begin (struct obstack *, int, int,
176	void () (), void (*) ());	205	void () (long), void () (void ));
177	extern void _obstack_begin_1 (struct obstack *, int, int,	206	extern int _obstack_begin_1 (struct obstack *, int, int,
178	void () (), void () (), void );	207	void () (void *, long),
		208	void () (void , void ), void );
		209	extern int _obstack_memory_used (struct obstack *);
179	#else	210	#else
180	extern void _obstack_newchunk ();	211	extern void _obstack_newchunk ();
181	extern void _obstack_free ();	212	extern void _obstack_free ();
182	extern void _obstack_begin ();	213	extern int _obstack_begin ();
183	extern void _obstack_begin_1 ();	214	extern int _obstack_begin_1 ();
		215	extern int _obstack_memory_used ();
184	#endif	216	#endif
185		217
186	#ifdef __STDC__	218	#if defined (__STDC__) && __STDC__
187		219
188	/* Do the function-declarations after the structs	220	/* Do the function-declarations after the structs
189	but before defining the macros. */	221	but before defining the macros. */
Lines 211-216 Link Here
211	int obstack_object_size (struct obstack *obstack);	243	int obstack_object_size (struct obstack *obstack);
212		244
213	int obstack_room (struct obstack *obstack);	245	int obstack_room (struct obstack *obstack);
		246	void obstack_make_room (struct obstack *obstack, int size);
214	void obstack_1grow_fast (struct obstack *obstack, int data_char);	247	void obstack_1grow_fast (struct obstack *obstack, int data_char);
215	void obstack_ptr_grow_fast (struct obstack obstack, void data);	248	void obstack_ptr_grow_fast (struct obstack obstack, void data);
216	void obstack_int_grow_fast (struct obstack *obstack, int data);	249	void obstack_int_grow_fast (struct obstack *obstack, int data);
Lines 220-230 Link Here
220	void * obstack_next_free (struct obstack *obstack);	253	void * obstack_next_free (struct obstack *obstack);
221	int obstack_alignment_mask (struct obstack *obstack);	254	int obstack_alignment_mask (struct obstack *obstack);
222	int obstack_chunk_size (struct obstack *obstack);	255	int obstack_chunk_size (struct obstack *obstack);
		256	int obstack_memory_used (struct obstack *obstack);
223		257
224	#endif /* __STDC__ */	258	#endif /* __STDC__ */
225		259
226	/* Non-ANSI C cannot really support alternative functions for these macros,	260	/* Non-ANSI C cannot really support alternative functions for these macros,
227	so we do not declare them. */	261	so we do not declare them. */
		262
		263	/* Error handler called when `obstack_chunk_alloc' failed to allocate
		264	more memory. This can be set to a user defined function. The
		265	default action is to print a message and abort. */
		266	#if defined (__STDC__) && __STDC__
		267	extern void (*obstack_alloc_failed_handler) (void);
		268	#else
		269	extern void (*obstack_alloc_failed_handler) ();
		270	#endif
		271
		272	/* Exit value used when `print_and_abort' is used. */
		273	extern int obstack_exit_failure;
228		274
229	/* Pointer to beginning of object being allocated or to be allocated next.	275	/* Pointer to beginning of object being allocated or to be allocated next.
230	Note that this might not be the final address of the object	276	Note that this might not be the final address of the object
Lines 244-249 Link Here
244		290
245	#define obstack_alignment_mask(h) ((h)->alignment_mask)	291	#define obstack_alignment_mask(h) ((h)->alignment_mask)
246		292
		293	/* To prevent prototype warnings provide complete argument list in
		294	standard C version. */
		295	#if defined (__STDC__) && __STDC__
		296
		297	#define obstack_init(h) \
		298	_obstack_begin ((h), 0, 0, \
		299	(void () (long)) obstack_chunk_alloc, (void () (void )) obstack_chunk_free)
		300
		301	#define obstack_begin(h, size) \
		302	_obstack_begin ((h), (size), 0, \
		303	(void () (long)) obstack_chunk_alloc, (void () (void )) obstack_chunk_free)
		304
		305	#define obstack_specify_allocation(h, size, alignment, chunkfun, freefun) \
		306	_obstack_begin ((h), (size), (alignment), \
		307	(void () (long)) (chunkfun), (void () (void )) (freefun))
		308
		309	#define obstack_specify_allocation_with_arg(h, size, alignment, chunkfun, freefun, arg) \
		310	_obstack_begin_1 ((h), (size), (alignment), \
		311	(void () (void *, long)) (chunkfun), \
		312	(void () (void , void *)) (freefun), (arg))
		313
		314	#define obstack_chunkfun(h, newchunkfun) \
		315	((h) -> chunkfun = (struct _obstack_chunk ()(void *, long)) (newchunkfun))
		316
		317	#define obstack_freefun(h, newfreefun) \
		318	((h) -> freefun = (void ()(void , struct _obstack_chunk *)) (newfreefun))
		319
		320	#else
		321
247	#define obstack_init(h) \	322	#define obstack_init(h) \
248	_obstack_begin ((h), 0, 0, \	323	_obstack_begin ((h), 0, 0, \
249	(void () ()) obstack_chunk_alloc, (void (*) ()) obstack_chunk_free)	324	(void () ()) obstack_chunk_alloc, (void (*) ()) obstack_chunk_free)
Lines 260-271 Link Here
260	_obstack_begin_1 ((h), (size), (alignment), \	335	_obstack_begin_1 ((h), (size), (alignment), \
261	(void () ()) (chunkfun), (void (*) ()) (freefun), (arg))	336	(void () ()) (chunkfun), (void (*) ()) (freefun), (arg))
262		337
		338	#define obstack_chunkfun(h, newchunkfun) \
		339	((h) -> chunkfun = (struct _obstack_chunk ()()) (newchunkfun))
		340
		341	#define obstack_freefun(h, newfreefun) \
		342	((h) -> freefun = (void (*)()) (newfreefun))
		343
		344	#endif
		345
263	#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar)	346	#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar)
264		347
265	#define obstack_blank_fast(h,n) ((h)->next_free += (n))	348	#define obstack_blank_fast(h,n) ((h)->next_free += (n))
		349
		350	#define obstack_memory_used(h) _obstack_memory_used (h)
266		351
267	#if defined (__GNUC__) && defined (__STDC__)	352	#if defined (__GNUC__) && defined (__STDC__) && __STDC__
268	#if __GNUC__ < 2 \|\| defined(NeXT)	353	/* NextStep 2.0 cc is really gcc 1.93 but it defines __GNUC__ = 2 and
		354	does not implement __extension__. But that compiler doesn't define
		355	__GNUC_MINOR__. */
		356	#if __GNUC__ < 2 \|\| (__NeXT__ && !__GNUC_MINOR__)
269	#define __extension__	357	#define __extension__
270	#endif	358	#endif
271		359
Lines 284-301 Link Here
284	({ struct obstack *__o = (OBSTACK); \	372	({ struct obstack *__o = (OBSTACK); \
285	(unsigned) (__o->chunk_limit - __o->next_free); })	373	(unsigned) (__o->chunk_limit - __o->next_free); })
286		374
287	/* Note that the call to _obstack_newchunk is enclosed in (..., 0)	375	#define obstack_make_room(OBSTACK,length) \
288	so that we can avoid having void expressions	376	__extension__ \
289	in the arms of the conditional expression.	377	({ struct obstack *__o = (OBSTACK); \
290	Casting the third operand to void was tried before,	378	int __len = (length); \
291	but some compilers won't accept it. */	379	if (__o->chunk_limit - __o->next_free < __len) \
		380	_obstack_newchunk (__o, __len); \
		381	(void) 0; })
		382
292	#define obstack_grow(OBSTACK,where,length) \	383	#define obstack_grow(OBSTACK,where,length) \
293	__extension__ \	384	__extension__ \
294	({ struct obstack *__o = (OBSTACK); \	385	({ struct obstack *__o = (OBSTACK); \
295	int __len = (length); \	386	int __len = (length); \
296	((__o->next_free + __len > __o->chunk_limit) \	387	if (__o->next_free + __len > __o->chunk_limit) \
297	? (_obstack_newchunk (__o, __len), 0) : 0); \	388	_obstack_newchunk (__o, __len); \
298	bcopy (where, __o->next_free, __len); \	389	_obstack_memcpy (__o->next_free, (char *) (where), __len); \
299	__o->next_free += __len; \	390	__o->next_free += __len; \
300	(void) 0; })	391	(void) 0; })
301		392
Lines 303-320 Link Here
303	__extension__ \	394	__extension__ \
304	({ struct obstack *__o = (OBSTACK); \	395	({ struct obstack *__o = (OBSTACK); \
305	int __len = (length); \	396	int __len = (length); \
306	((__o->next_free + __len + 1 > __o->chunk_limit) \	397	if (__o->next_free + __len + 1 > __o->chunk_limit) \
307	? (_obstack_newchunk (__o, __len + 1), 0) : 0), \	398	_obstack_newchunk (__o, __len + 1); \
308	bcopy (where, __o->next_free, __len), \	399	_obstack_memcpy (__o->next_free, (char *) (where), __len); \
309	__o->next_free += __len, \	400	__o->next_free += __len; \
310	*(__o->next_free)++ = 0; \	401	*(__o->next_free)++ = 0; \
311	(void) 0; })	402	(void) 0; })
312		403
313	#define obstack_1grow(OBSTACK,datum) \	404	#define obstack_1grow(OBSTACK,datum) \
314	__extension__ \	405	__extension__ \
315	({ struct obstack *__o = (OBSTACK); \	406	({ struct obstack *__o = (OBSTACK); \
316	((__o->next_free + 1 > __o->chunk_limit) \	407	if (__o->next_free + 1 > __o->chunk_limit) \
317	? (_obstack_newchunk (__o, 1), 0) : 0), \	408	_obstack_newchunk (__o, 1); \
318	*(__o->next_free)++ = (datum); \	409	*(__o->next_free)++ = (datum); \
319	(void) 0; })	410	(void) 0; })
320		411
Lines 325-352 Link Here
325	#define obstack_ptr_grow(OBSTACK,datum) \	416	#define obstack_ptr_grow(OBSTACK,datum) \
326	__extension__ \	417	__extension__ \
327	({ struct obstack *__o = (OBSTACK); \	418	({ struct obstack *__o = (OBSTACK); \
328	((__o->next_free + sizeof (void *) > __o->chunk_limit) \	419	if (__o->next_free + sizeof (void *) > __o->chunk_limit) \
329	? (_obstack_newchunk (__o, sizeof (void *)), 0) : 0), \	420	_obstack_newchunk (__o, sizeof (void *)); \
330	((void )__o->next_free)++ = ((void )datum); \	421	((void )__o->next_free)++ = ((void )datum); \
331	(void) 0; })	422	(void) 0; })
332		423
333	#define obstack_int_grow(OBSTACK,datum) \	424	#define obstack_int_grow(OBSTACK,datum) \
334	__extension__ \	425	__extension__ \
335	({ struct obstack *__o = (OBSTACK); \	426	({ struct obstack *__o = (OBSTACK); \
336	((__o->next_free + sizeof (int) > __o->chunk_limit) \	427	if (__o->next_free + sizeof (int) > __o->chunk_limit) \
337	? (_obstack_newchunk (__o, sizeof (int)), 0) : 0), \	428	_obstack_newchunk (__o, sizeof (int)); \
338	((int )__o->next_free)++ = ((int)datum); \	429	((int )__o->next_free)++ = ((int)datum); \
339	(void) 0; })	430	(void) 0; })
340		431
341	#define obstack_ptr_grow_fast(h,aptr) (((void )(h)->next_free)++ = (void )aptr)	432	#define obstack_ptr_grow_fast(h,aptr) (((void ) (h)->next_free)++ = (void )aptr)
342	#define obstack_int_grow_fast(h,aint) (((int )(h)->next_free)++ = (int)aint)	433	#define obstack_int_grow_fast(h,aint) (((int ) (h)->next_free)++ = (int) aint)
343		434
344	#define obstack_blank(OBSTACK,length) \	435	#define obstack_blank(OBSTACK,length) \
345	__extension__ \	436	__extension__ \
346	({ struct obstack *__o = (OBSTACK); \	437	({ struct obstack *__o = (OBSTACK); \
347	int __len = (length); \	438	int __len = (length); \
348	((__o->chunk_limit - __o->next_free < __len) \	439	if (__o->chunk_limit - __o->next_free < __len) \
349	? (_obstack_newchunk (__o, __len), 0) : 0); \	440	_obstack_newchunk (__o, __len); \
350	__o->next_free += __len; \	441	__o->next_free += __len; \
351	(void) 0; })	442	(void) 0; })
352		443
Lines 373-387 Link Here
373	#define obstack_finish(OBSTACK) \	464	#define obstack_finish(OBSTACK) \
374	__extension__ \	465	__extension__ \
375	({ struct obstack *__o1 = (OBSTACK); \	466	({ struct obstack *__o1 = (OBSTACK); \
376	void value = (void ) __o1->object_base; \	467	void *value; \
		468	value = (void *) __o1->object_base; \
377	if (__o1->next_free == value) \	469	if (__o1->next_free == value) \
378	__o1->maybe_empty_object = 1; \	470	__o1->maybe_empty_object = 1; \
379	__o1->next_free \	471	__o1->next_free \
380	= __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\	472	= __INT_TO_PTR ((__PTR_TO_INT (__o1->next_free)+__o1->alignment_mask)\
381	& ~ (__o1->alignment_mask)); \	473	& ~ (__o1->alignment_mask)); \
382	((__o1->next_free - (char *)__o1->chunk \	474	if (__o1->next_free - (char *)__o1->chunk \
383	> __o1->chunk_limit - (char *)__o1->chunk) \	475	> __o1->chunk_limit - (char *)__o1->chunk) \
384	? (__o1->next_free = __o1->chunk_limit) : 0); \	476	__o1->next_free = __o1->chunk_limit; \
385	__o1->object_base = __o1->next_free; \	477	__o1->object_base = __o1->next_free; \
386	value; })	478	value; })
387		479
Lines 401-444 Link Here
401	#define obstack_room(h) \	493	#define obstack_room(h) \
402	(unsigned) ((h)->chunk_limit - (h)->next_free)	494	(unsigned) ((h)->chunk_limit - (h)->next_free)
403		495
		496	/* Note that the call to _obstack_newchunk is enclosed in (..., 0)
		497	so that we can avoid having void expressions
		498	in the arms of the conditional expression.
		499	Casting the third operand to void was tried before,
		500	but some compilers won't accept it. */
		501
		502	#define obstack_make_room(h,length) \
		503	( (h)->temp = (length), \
		504	(((h)->next_free + (h)->temp > (h)->chunk_limit) \
		505	? (_obstack_newchunk ((h), (h)->temp), 0) : 0))
		506
404	#define obstack_grow(h,where,length) \	507	#define obstack_grow(h,where,length) \
405	( (h)->temp = (length), \	508	( (h)->temp = (length), \
406	(((h)->next_free + (h)->temp > (h)->chunk_limit) \	509	(((h)->next_free + (h)->temp > (h)->chunk_limit) \
407	? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \	510	? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \
408	bcopy (where, (h)->next_free, (h)->temp), \	511	_obstack_memcpy ((h)->next_free, (char *) (where), (h)->temp), \
409	(h)->next_free += (h)->temp)	512	(h)->next_free += (h)->temp)
410		513
411	#define obstack_grow0(h,where,length) \	514	#define obstack_grow0(h,where,length) \
412	( (h)->temp = (length), \	515	( (h)->temp = (length), \
413	(((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \	516	(((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \
414	? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \	517	? (_obstack_newchunk ((h), (h)->temp + 1), 0) : 0), \
415	bcopy (where, (h)->next_free, (h)->temp), \	518	_obstack_memcpy ((h)->next_free, (char *) (where), (h)->temp), \
416	(h)->next_free += (h)->temp, \	519	(h)->next_free += (h)->temp, \
417	*((h)->next_free)++ = 0)	520	*((h)->next_free)++ = 0)
418		521
419	#define obstack_1grow(h,datum) \	522	#define obstack_1grow(h,datum) \
420	( (((h)->next_free + 1 > (h)->chunk_limit) \	523	( (((h)->next_free + 1 > (h)->chunk_limit) \
421	? (_obstack_newchunk ((h), 1), 0) : 0), \	524	? (_obstack_newchunk ((h), 1), 0) : 0), \
422	*((h)->next_free)++ = (datum))	525	(*((h)->next_free)++ = (datum)))
423		526
424	#define obstack_ptr_grow(h,datum) \	527	#define obstack_ptr_grow(h,datum) \
425	( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \	528	( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \
426	? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \	529	? (_obstack_newchunk ((h), sizeof (char *)), 0) : 0), \
427	((char )(((h)->next_free+=sizeof(char ))-sizeof(char ))) = ((char )datum))	530	(((char ) (((h)->next_free+=sizeof(char ))-sizeof(char ))) = ((char ) datum)))
428		531
429	#define obstack_int_grow(h,datum) \	532	#define obstack_int_grow(h,datum) \
430	( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \	533	( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \
431	? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \	534	? (_obstack_newchunk ((h), sizeof (int)), 0) : 0), \
432	((int )(((h)->next_free+=sizeof(int))-sizeof(int))) = ((int)datum))	535	(((int ) (((h)->next_free+=sizeof(int))-sizeof(int))) = ((int) datum)))
433		536
434	#define obstack_ptr_grow_fast(h,aptr) (((char )(h)->next_free)++ = (char )aptr)	537	#define obstack_ptr_grow_fast(h,aptr) (((char ) (h)->next_free)++ = (char ) aptr)
435	#define obstack_int_grow_fast(h,aint) (((int )(h)->next_free)++ = (int)aint)	538	#define obstack_int_grow_fast(h,aint) (((int ) (h)->next_free)++ = (int) aint)
436		539
437	#define obstack_blank(h,length) \	540	#define obstack_blank(h,length) \
438	( (h)->temp = (length), \	541	( (h)->temp = (length), \
439	(((h)->chunk_limit - (h)->next_free < (h)->temp) \	542	(((h)->chunk_limit - (h)->next_free < (h)->temp) \
440	? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \	543	? (_obstack_newchunk ((h), (h)->temp), 0) : 0), \
441	(h)->next_free += (h)->temp)	544	((h)->next_free += (h)->temp))
442		545
443	#define obstack_alloc(h,length) \	546	#define obstack_alloc(h,length) \
444	(obstack_blank ((h), (length)), obstack_finish ((h)))	547	(obstack_blank ((h), (length)), obstack_finish ((h)))
Lines 457-478 Link Here
457	(h)->next_free \	560	(h)->next_free \
458	= __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \	561	= __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \
459	& ~ ((h)->alignment_mask)), \	562	& ~ ((h)->alignment_mask)), \
460	(((h)->next_free - (char *)(h)->chunk \	563	(((h)->next_free - (char *) (h)->chunk \
461	> (h)->chunk_limit - (char *)(h)->chunk) \	564	> (h)->chunk_limit - (char *) (h)->chunk) \
462	? ((h)->next_free = (h)->chunk_limit) : 0), \	565	? ((h)->next_free = (h)->chunk_limit) : 0), \
463	(h)->object_base = (h)->next_free, \	566	(h)->object_base = (h)->next_free, \
464	__INT_TO_PTR ((h)->temp))	567	__INT_TO_PTR ((h)->temp))
465		568
466	#ifdef __STDC__	569	#if defined (__STDC__) && __STDC__
467	#define obstack_free(h,obj) \	570	#define obstack_free(h,obj) \
468	( (h)->temp = (char )(obj) - (char ) (h)->chunk, \	571	( (h)->temp = (char ) (obj) - (char ) (h)->chunk, \
469	(((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\	572	(((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
470	? (int) ((h)->next_free = (h)->object_base \	573	? (int) ((h)->next_free = (h)->object_base \
471	= (h)->temp + (char *) (h)->chunk) \	574	= (h)->temp + (char *) (h)->chunk) \
472	: (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0)))	575	: (((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0), 0)))
473	#else	576	#else
474	#define obstack_free(h,obj) \	577	#define obstack_free(h,obj) \
475	( (h)->temp = (char )(obj) - (char ) (h)->chunk, \	578	( (h)->temp = (char ) (obj) - (char ) (h)->chunk, \
476	(((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\	579	(((h)->temp > 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\
477	? (int) ((h)->next_free = (h)->object_base \	580	? (int) ((h)->next_free = (h)->object_base \
478	= (h)->temp + (char *) (h)->chunk) \	581	= (h)->temp + (char *) (h)->chunk) \
Lines 481-484 Link Here
481		584
482	#endif /* not __GNUC__ or not __STDC__ */	585	#endif /* not __GNUC__ or not __STDC__ */
483		586
484	#endif /* not __OBSTACKS__ */	587	#ifdef __cplusplus
		588	} /* C++ */
		589	#endif
		590
		591	#endif /* obstack.h */




/* Extended regular expression matching and search library,
   version 0.12.
   (Implements POSIX draft P1003.2/D11.2, except for some of the
   internationalization features.)
   Copyright (C) 1993, 94, 95, 96, 97, 98 Free Software Foundation, Inc.

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

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

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

#undef	_GNU_SOURCE
#define _GNU_SOURCE

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#ifndef PARAMS
# if defined __GNUC__ || (defined __STDC__ && __STDC__)
#  define PARAMS(args) args
# else
#  define PARAMS(args) ()
# endif  /* GCC.  */
#endif  /* Not PARAMS.  */

#if defined STDC_HEADERS && !defined emacs
# include <stddef.h>
#else
/* We need this for `regex.h', and perhaps for the Emacs include files.  */
# include <sys/types.h>
#endif

#define WIDE_CHAR_SUPPORT (HAVE_WCTYPE_H && HAVE_WCHAR_H && HAVE_BTOWC)

/* For platform which support the ISO C amendement 1 functionality we
   support user defined character classes.  */
#if defined _LIBC || WIDE_CHAR_SUPPORT
/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
# include <wchar.h>
# include <wctype.h>
#endif

#ifdef _LIBC
/* We have to keep the namespace clean.  */
# define regfree(preg) __regfree (preg)
# define regexec(pr, st, nm, pm, ef) __regexec (pr, st, nm, pm, ef)
# define regcomp(preg, pattern, cflags) __regcomp (preg, pattern, cflags)
# define regerror(errcode, preg, errbuf, errbuf_size) \
	__regerror(errcode, preg, errbuf, errbuf_size)
# define re_set_registers(bu, re, nu, st, en) \
	__re_set_registers (bu, re, nu, st, en)
# define re_match_2(bufp, string1, size1, string2, size2, pos, regs, stop) \
	__re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
# define re_match(bufp, string, size, pos, regs) \
	__re_match (bufp, string, size, pos, regs)
# define re_search(bufp, string, size, startpos, range, regs) \
	__re_search (bufp, string, size, startpos, range, regs)
# define re_compile_pattern(pattern, length, bufp) \
	__re_compile_pattern (pattern, length, bufp)
# define re_set_syntax(syntax) __re_set_syntax (syntax)
# define re_search_2(bufp, st1, s1, st2, s2, startpos, range, regs, stop) \
	__re_search_2 (bufp, st1, s1, st2, s2, startpos, range, regs, stop)
# define re_compile_fastmap(bufp) __re_compile_fastmap (bufp)

#define btowc __btowc
#endif

/* This is for other GNU distributions with internationalized messages.  */
#if HAVE_LIBINTL_H || defined _LIBC
# include <libintl.h>
#else
# define gettext(msgid) (msgid)
#endif

#ifndef gettext_noop
/* This define is so xgettext can find the internationalizable
   strings.  */
# define gettext_noop(String) String
#endif

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

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

# if defined STDC_HEADERS || defined _LIBC
#  include <stdlib.h>
# else
char *malloc ();
char *realloc ();
# endif

/* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
   If nothing else has been done, use the method below.  */
# ifdef INHIBIT_STRING_HEADER
#  if !(defined HAVE_BZERO && defined HAVE_BCOPY)
#   if !defined bzero && !defined bcopy
#    undef INHIBIT_STRING_HEADER
#   endif
#  endif
# endif

/* This is the normal way of making sure we have a bcopy and a bzero.
   This is used in most programs--a few other programs avoid this
   by defining INHIBIT_STRING_HEADER.  */
# ifndef INHIBIT_STRING_HEADER
#  if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
#   include <string.h>
#   ifndef bzero
#    ifndef _LIBC
#     define bzero(s, n)	(memset (s, '\0', n), (s))
#    else
#     define bzero(s, n)	__bzero (s, n)
#    endif
#   endif
#  else
#   include <strings.h>
#   ifndef memcmp
#    define memcmp(s1, s2, n)	bcmp (s1, s2, n)
#   endif
#   ifndef memcpy
#    define memcpy(d, s, n)	(bcopy (s, d, n), (d))
#   endif
#  endif
# endif

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

# ifdef SWITCH_ENUM_BUG
#  define SWITCH_ENUM_CAST(x) ((int)(x))
# else
#  define SWITCH_ENUM_CAST(x) (x)
# endif

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

# ifdef SYNTAX_TABLE

extern char *re_syntax_table;

# else /* not SYNTAX_TABLE */

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 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."
   Solaris defines some of these symbols so we must undefine them first.  */

#undef ISASCII
#if defined STDC_HEADERS || (!defined isascii && !defined HAVE_ISASCII)
# define ISASCII(c) 1
#else
# define ISASCII(c) isascii(c)
#endif

#ifdef isblank
# define ISBLANK(c) (ISASCII (c) && isblank (c))
#else
# define ISBLANK(c) ((c) == ' ' || (c) == '\t')
#endif
#ifdef isgraph
# define ISGRAPH(c) (ISASCII (c) && isgraph (c))
#else
# define ISGRAPH(c) (ISASCII (c) && isprint (c) && !isspace (c))
#endif

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

#ifndef NULL
# define NULL (void *)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))
#else  /* not __STDC__ */
/* 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)
# define REGEX_FREE free

#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>
#   endif /* 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),				\
   memcpy (destination, source, osize))

/* No need to do anything to free, after alloca.  */
# define REGEX_FREE(arg) ((void)0) /* Do nothing!  But inhibit gcc warning.  */

#endif /* not REGEX_MALLOC */

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

#if defined REL_ALLOC && defined REGEX_MALLOC

# 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 using relocating allocator */

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

# endif /* not REGEX_MALLOC */
#endif /* not using relocating allocator */


/* 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)))
#define RETALLOC_IF(addr, n, t) \
  if (addr) RETALLOC((addr), (n), t); else (addr) = TALLOC ((n), t)
#define REGEX_TALLOC(n, t) ((t *) REGEX_ALLOCATE ((n) * sizeof (t)))

#define BYTEWIDTH 8 /* In bits.  */

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

#undef MAX
#undef MIN
#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

static int re_match_2_internal PARAMS ((struct re_pattern_buffer *bufp,
					const char *string1, int size1,
					const char *string2, int size2,
					int pos,
					struct re_registers *regs,
					int stop));

/* 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
   arguments.  Zero bytes may appear in the compiled regular expression.  */

typedef enum
{
  no_op = 0,

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

        /* Followed by one byte giving n, then by n literal bytes.  */
  exactn,

        /* 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 _RE_ARGS ((int *dest, unsigned char *source));
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 _RE_ARGS ((int *destination,
					       unsigned char **source));
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)
# define DEBUG_PRINT4(x1, x2, x3, x4) if (debug) printf (x1, x2, x3, x4)
# 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;
          putchar (i - 1);
          while (i < (1 << BYTEWIDTH)  &&  fastmap[i])
            {
              was_a_range = 1;
              i++;
            }
	  if (was_a_range)
            {
              printf ("-");
              putchar (i - 1);
            }
        }
    }
  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 *p1;
  unsigned char *p = start;
  unsigned char *pend = end;

  if (start == NULL)
    {
      printf ("(null)\n");
      return;
    }

  /* Loop over pattern commands.  */
  while (p < pend)
    {
      printf ("%d:\t", p - start);

      switch ((re_opcode_t) *p++)
	{
        case no_op:
          printf ("/no_op");
          break;

	case exactn:
	  mcnt = *p++;
          printf ("/exactn/%d", mcnt);
          do
	    {
              putchar ('/');
	      putchar (*p++);
            }
          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:
          {
            register int c, last = -100;
	    register int in_range = 0;

	    printf ("/charset [%s",
	            (re_opcode_t) *(p - 1) == charset_not ? "^" : "");

            assert (p + *p < pend);

            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)
              {
		      putchar (last);
		      in_range = 0;
		    }

		  if (! in_range)
		    putchar (c);

		  last = c;
              }

	    if (in_range)
	      putchar (last);

	    putchar (']');

	    p += 1 + *p;
	  }
	  break;

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

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

	case on_failure_jump:
          extract_number_and_incr (&mcnt, &p);
  	  printf ("/on_failure_jump to %d", p + mcnt - start);
          break;

	case on_failure_keep_string_jump:
          extract_number_and_incr (&mcnt, &p);
  	  printf ("/on_failure_keep_string_jump to %d", p + mcnt - start);
          break;

	case dummy_failure_jump:
          extract_number_and_incr (&mcnt, &p);
  	  printf ("/dummy_failure_jump to %d", p + mcnt - start);
          break;

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

        case maybe_pop_jump:
          extract_number_and_incr (&mcnt, &p);
  	  printf ("/maybe_pop_jump to %d", p + mcnt - start);
	  break;

        case pop_failure_jump:
	  extract_number_and_incr (&mcnt, &p);
  	  printf ("/pop_failure_jump to %d", p + mcnt - start);
	  break;

        case jump_past_alt:
	  extract_number_and_incr (&mcnt, &p);
  	  printf ("/jump_past_alt to %d", p + mcnt - start);
	  break;

        case jump:
	  extract_number_and_incr (&mcnt, &p);
  	  printf ("/jump to %d", p + mcnt - start);
	  break;

        case succeed_n:
          extract_number_and_incr (&mcnt, &p);
	  p1 = p + mcnt;
          extract_number_and_incr (&mcnt2, &p);
	  printf ("/succeed_n to %d, %d times", p1 - start, mcnt2);
          break;

        case jump_n:
          extract_number_and_incr (&mcnt, &p);
	  p1 = p + mcnt;
          extract_number_and_incr (&mcnt2, &p);
	  printf ("/jump_n to %d, %d times", p1 - start, mcnt2);
          break;

        case set_number_at:
          extract_number_and_incr (&mcnt, &p);
	  p1 = p + mcnt;
          extract_number_and_incr (&mcnt2, &p);
	  printf ("/set_number_at location %d to %d", p1 - start, mcnt2);
          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));
	}

      putchar ('\n');
    }

  printf ("%d:\tend of pattern.\n", p - start);
}


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

  print_partial_compiled_pattern (buffer, buffer + bufp->used);
  printf ("%ld bytes used/%ld 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: %lx\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;
{
  int this_char;

  if (where == NULL)
    printf ("(null)");
  else
    {
      if (FIRST_STRING_P (where))
        {
          for (this_char = where - string1; this_char < size1; this_char++)
            putchar (string1[this_char]);

          where = string2;
        }

      for (this_char = where - string2; this_char < size2; this_char++)
        putchar (string2[this_char]);
    }
}

void
printchar (c)
     int c;
{
  putc (c, stderr);
}

#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)
# define DEBUG_PRINT4(x1, x2, x3, x4)
# 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.  */
/* This has no initializer because initialized variables in Emacs
   become read-only after dumping.  */
reg_syntax_t re_syntax_options;


/* 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;
#ifdef DEBUG
  if (syntax & RE_DEBUG)
    debug = 1;
  else if (debug) /* was on but now is not */
    debug = 0;
#endif /* DEBUG */
  return ret;
}
#ifdef _LIBC
weak_alias (__re_set_syntax, re_set_syntax)
#endif

/* This table gives an error message for each of the error codes listed
   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?  */

static const char *re_error_msgid[] =
  {
    gettext_noop ("Success"),	/* REG_NOERROR */
    gettext_noop ("No match"),	/* REG_NOMATCH */
    gettext_noop ("Invalid regular expression"), /* REG_BADPAT */
    gettext_noop ("Invalid collation character"), /* REG_ECOLLATE */
    gettext_noop ("Invalid character class name"), /* REG_ECTYPE */
    gettext_noop ("Trailing backslash"), /* REG_EESCAPE */
    gettext_noop ("Invalid back reference"), /* REG_ESUBREG */
    gettext_noop ("Unmatched [ or [^"),	/* REG_EBRACK */
    gettext_noop ("Unmatched ( or \\("), /* REG_EPAREN */
    gettext_noop ("Unmatched \\{"), /* REG_EBRACE */
    gettext_noop ("Invalid content of \\{\\}"), /* REG_BADBR */
    gettext_noop ("Invalid range end"),	/* REG_ERANGE */
    gettext_noop ("Memory exhausted"), /* REG_ESPACE */
    gettext_noop ("Invalid preceding regular expression"), /* REG_BADRPT */
    gettext_noop ("Premature end of regular expression"), /* REG_EEND */
    gettext_noop ("Regular expression too big"), /* REG_ESIZE */
    gettext_noop ("Unmatched ) or \\)"), /* REG_ERPAREN */
  };

/* Avoiding alloca during matching, to placate r_alloc.  */

/* Define MATCH_MAY_ALLOCATE unless we need to make sure that the
   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
   routines.

   Here's another reason to avoid allocation: Emacs
   processes input from X in a signal handler; processing X input may
   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.  */

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

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

/* The match routines may not allocate if (1) they would do it with malloc
   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
# undef MATCH_MAY_ALLOCATE
#endif


/* Failure stack declarations and macros; both re_compile_fastmap and
   re_match_2 use a failure stack.  These have to be macros because of
   REGEX_ALLOCATE_STACK.  */


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

/* Roughly the maximum number of failure points on the stack.  Would be
   exactly that if always used MAX_FAILURE_ITEMS items each time we failed.
   This is a variable only so users of regex can assign to it; we never
   change it ourselves.  */

#ifdef INT_IS_16BIT

# if defined MATCH_MAY_ALLOCATE
/* 4400 was enough to cause a crash on Alpha OSF/1,
   whose default stack limit is 2mb.  */
long int re_max_failures = 4000;
# else
long int re_max_failures = 2000;
# endif

union fail_stack_elt
{
  unsigned char *pointer;
  long int integer;
};

typedef union fail_stack_elt fail_stack_elt_t;

typedef struct
{
  fail_stack_elt_t *stack;
  unsigned long int size;
  unsigned long int avail;		/* Offset of next open position.  */
} fail_stack_type;

#else /* not INT_IS_16BIT */

# if defined MATCH_MAY_ALLOCATE
/* 4400 was enough to cause a crash on Alpha OSF/1,
   whose default stack limit is 2mb.  */
int re_max_failures = 20000;
# else
int re_max_failures = 2000;
# endif

union fail_stack_elt
{
  unsigned char *pointer;
  int integer;
};

typedef union fail_stack_elt fail_stack_elt_t;

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

#endif /* INT_IS_16BIT */

#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 macros to initialize and free the failure stack.
   Do `return -2' if the alloc fails.  */

#ifdef MATCH_MAY_ALLOCATE
# define INIT_FAIL_STACK()						\
  do {									\
    fail_stack.stack = (fail_stack_elt_t *)				\
      REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (fail_stack_elt_t)); \
									\
    if (fail_stack.stack == NULL)					\
      return -2;							\
									\
    fail_stack.size = INIT_FAILURE_ALLOC;				\
    fail_stack.avail = 0;						\
  } while (0)

# define RESET_FAIL_STACK()  REGEX_FREE_STACK (fail_stack.stack)
#else
# define INIT_FAIL_STACK()						\
  do {									\
    fail_stack.avail = 0;						\
  } while (0)

# define RESET_FAIL_STACK()
#endif


/* Double the size of FAIL_STACK, up to approximately `re_max_failures' items.

   Return 1 if succeeds, and 0 if either ran out of memory
   allocating space for it or it was already too large.

   REGEX_REALLOCATE_STACK requires `destination' be declared.   */

#define DOUBLE_FAIL_STACK(fail_stack)					\
  ((fail_stack).size > (unsigned) (re_max_failures * MAX_FAILURE_ITEMS)	\
   ? 0									\
   : ((fail_stack).stack = (fail_stack_elt_t *)				\
        REGEX_REALLOCATE_STACK ((fail_stack).stack, 			\
          (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)))


/* Push pointer POINTER on FAIL_STACK.
   Return 1 if was able to do so and 0 if ran out of memory allocating
   space to do so.  */
#define PUSH_PATTERN_OP(POINTER, FAIL_STACK)				\
  ((FAIL_STACK_FULL ()							\
    && !DOUBLE_FAIL_STACK (FAIL_STACK))					\
   ? 0									\
   : ((FAIL_STACK).stack[(FAIL_STACK).avail++].pointer = POINTER,	\
      1))

/* Push a pointer value onto the failure stack.
   Assumes the variable `fail_stack'.  Probably should only
   be called from within `PUSH_FAILURE_POINT'.  */
#define PUSH_FAILURE_POINTER(item)					\
  fail_stack.stack[fail_stack.avail++].pointer = (unsigned char *) (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)					\
  fail_stack.stack[fail_stack.avail++].integer = (item)

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

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

/* Used to omit pushing failure point id's when we're not debugging.  */
#ifdef DEBUG
# define DEBUG_PUSH PUSH_FAILURE_INT
# define DEBUG_POP(item_addr) *(item_addr) = POP_FAILURE_INT ()
#else
# define DEBUG_PUSH(item)
# define DEBUG_POP(item_addr)
#endif


/* 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_pushed be declared.  DOUBLE_FAIL_STACK requires `destination'
   be declared.

   Does `return FAILURE_CODE' if runs out of memory.  */

#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.  */				\
    /* Can't be int, since there is not a shred of a guarantee that int	\
       is wide enough to hold a value of something to which pointer can	\
       be assigned */							\
    active_reg_t 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: %ld\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)			\
      {									\
        if (!DOUBLE_FAIL_STACK (fail_stack))				\
          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");						\
									\
    if (1)								\
      for (this_reg = lowest_active_reg; this_reg <= highest_active_reg; \
	   this_reg++)							\
	{								\
	  DEBUG_PRINT2 ("  Pushing reg: %lu\n", this_reg);		\
	  DEBUG_STATEMENT (num_regs_pushed++);				\
									\
	  DEBUG_PRINT2 ("    start: %p\n", regstart[this_reg]);		\
	  PUSH_FAILURE_POINTER (regstart[this_reg]);			\
									\
	  DEBUG_PRINT2 ("    end: %p\n", regend[this_reg]);		\
	  PUSH_FAILURE_POINTER (regend[this_reg]);			\
									\
	  DEBUG_PRINT2 ("    info: %p\n      ",				\
			reg_info[this_reg].word.pointer);		\
	  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");						\
	  PUSH_FAILURE_ELT (reg_info[this_reg].word);			\
	}								\
									\
    DEBUG_PRINT2 ("  Pushing  low active reg: %ld\n", lowest_active_reg);\
    PUSH_FAILURE_INT (lowest_active_reg);				\
									\
    DEBUG_PRINT2 ("  Pushing high active reg: %ld\n", highest_active_reg);\
    PUSH_FAILURE_INT (highest_active_reg);				\
									\
    DEBUG_PRINT2 ("  Pushing pattern %p:\n", pattern_place);		\
    DEBUG_PRINT_COMPILED_PATTERN (bufp, pattern_place, pend);		\
    PUSH_FAILURE_POINTER (pattern_place);				\
									\
    DEBUG_PRINT2 ("  Pushing string %p: `", string_place);		\
    DEBUG_PRINT_DOUBLE_STRING (string_place, string1, size1, string2,   \
				 size2);				\
    DEBUG_PRINT1 ("'\n");						\
    PUSH_FAILURE_POINTER (string_place);				\
									\
    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.  */
/* We used to use (num_regs - 1), which is the number of registers
   this regexp will save; but that was changed to 5
   to avoid stack overflow for a regexp with lots of parens.  */
#define MAX_FAILURE_ITEMS (5 * NUM_REG_ITEMS + NUM_NONREG_ITEMS)

/* We actually push this many items.  */
#define NUM_FAILURE_ITEMS				\
  (((0							\
     ? 0 : 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 (unsigned failure_id;)				\
  active_reg_t 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.  */	\
  string_temp = POP_FAILURE_POINTER ();					\
  if (string_temp != NULL)						\
    str = (const char *) string_temp;					\
									\
  DEBUG_PRINT2 ("  Popping string %p: `", str);				\
  DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);	\
  DEBUG_PRINT1 ("'\n");							\
									\
  pat = (unsigned char *) POP_FAILURE_POINTER ();			\
  DEBUG_PRINT2 ("  Popping pattern %p:\n", pat);			\
  DEBUG_PRINT_COMPILED_PATTERN (bufp, pat, pend);			\
									\
  /* Restore register info.  */						\
  high_reg = (active_reg_t) POP_FAILURE_INT ();				\
  DEBUG_PRINT2 ("  Popping high active reg: %ld\n", high_reg);		\
									\
  low_reg = (active_reg_t) POP_FAILURE_INT ();				\
  DEBUG_PRINT2 ("  Popping  low active reg: %ld\n", low_reg);		\
									\
  if (1)								\
    for (this_reg = high_reg; this_reg >= low_reg; this_reg--)		\
      {									\
	DEBUG_PRINT2 ("    Popping reg: %ld\n", this_reg);		\
									\
	reg_info[this_reg].word = POP_FAILURE_ELT ();			\
	DEBUG_PRINT2 ("      info: %p\n",				\
		      reg_info[this_reg].word.pointer);			\
									\
	regend[this_reg] = (const char *) POP_FAILURE_POINTER ();	\
	DEBUG_PRINT2 ("      end: %p\n", regend[this_reg]);		\
									\
	regstart[this_reg] = (const char *) POP_FAILURE_POINTER ();	\
	DEBUG_PRINT2 ("      start: %p\n", regstart[this_reg]);		\
      }									\
  else									\
    {									\
      for (this_reg = highest_active_reg; this_reg > high_reg; this_reg--) \
	{								\
	  reg_info[this_reg].word.integer = 0;				\
	  regend[this_reg] = 0;						\
	  regstart[this_reg] = 0;					\
	}								\
      highest_active_reg = high_reg;					\
    }									\
									\
  set_regs_matched_done = 0;						\
  DEBUG_STATEMENT (nfailure_points_popped++);				\
} /* POP_FAILURE_POINT */



/* Structure for per-register (a.k.a. per-group) information.
   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.  */


/* Declarations and macros for re_match_2.  */

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.  */
#define SET_REGS_MATCHED()						\
  do									\
    {									\
      if (!set_regs_matched_done)					\
	{								\
	  active_reg_t 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)

/* Registers are set to a sentinel when they haven't yet matched.  */
static char reg_unset_dummy;
#define REG_UNSET_VALUE (&reg_unset_dummy)
#define REG_UNSET(e) ((e) == REG_UNSET_VALUE)

/* Subroutine declarations and macros for regex_compile.  */

static reg_errcode_t regex_compile _RE_ARGS ((const char *pattern, size_t size,
					      reg_syntax_t syntax,
					      struct re_pattern_buffer *bufp));
static void store_op1 _RE_ARGS ((re_opcode_t op, unsigned char *loc, int arg));
static void store_op2 _RE_ARGS ((re_opcode_t op, unsigned char *loc,
				 int arg1, int arg2));
static void insert_op1 _RE_ARGS ((re_opcode_t op, unsigned char *loc,
				  int arg, unsigned char *end));
static void insert_op2 _RE_ARGS ((re_opcode_t op, unsigned char *loc,
				  int arg1, int arg2, unsigned char *end));
static boolean at_begline_loc_p _RE_ARGS ((const char *pattern, const char *p,
					   reg_syntax_t syntax));
static boolean at_endline_loc_p _RE_ARGS ((const char *p, const char *pend,
					   reg_syntax_t syntax));
static reg_errcode_t compile_range _RE_ARGS ((const char **p_ptr,
					      const char *pend,
					      char *translate,
					      reg_syntax_t syntax,
					      unsigned char *b));

/* 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').  */
#ifndef PATFETCH
# define PATFETCH(c)							\
  do {if (p == pend) return REG_EEND;					\
    c = (unsigned char) *p++;						\
    if (translate) c = (unsigned char) translate[c];			\
  } while (0)
#endif

/* 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.  */
#ifndef TRANSLATE
# define TRANSLATE(d) \
  (translate ? (char) translate[(unsigned char) (d)] : (d))
#endif


/* 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 ((unsigned long) (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, (int) ((to) - (loc) - 3))

/* Likewise, for a two-argument jump.  */
#define STORE_JUMP2(op, loc, to, arg) \
  store_op2 (op, loc, (int) ((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, (int) ((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, (int) ((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.  */
/* Any other compiler which, like MSC, has allocation limit below 2^16
   bytes will have to use approach similar to what was done below for
   MSC and drop MAX_BUF_SIZE a bit.  Otherwise you may end up
   reallocating to 0 bytes.  Such thing is not going to work too well.
   You have been warned!!  */
#if defined _MSC_VER  && !defined WIN32
/* Microsoft C 16-bit versions limit malloc to approx 65512 bytes.
   The REALLOC define eliminates a flurry of conversion warnings,
   but is not required. */
# define MAX_BUF_SIZE  65500L
# define REALLOC(p,s) realloc ((p), (size_t) (s))
#else
# define MAX_BUF_SIZE (1L << 16)
# define REALLOC(p,s) realloc ((p), (s))
#endif

/* 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.  */
/* int may be not enough when sizeof(int) == 2.  */
typedef long 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);						\
         } 								\
       } 								\
    }

#if defined _LIBC || WIDE_CHAR_SUPPORT
/* The GNU C library provides support for user-defined character classes
   and the functions from ISO C amendement 1.  */
# ifdef CHARCLASS_NAME_MAX
#  define CHAR_CLASS_MAX_LENGTH CHARCLASS_NAME_MAX
# else
/* This shouldn't happen but some implementation might still have this
   problem.  Use a reasonable default value.  */
#  define CHAR_CLASS_MAX_LENGTH 256
# endif

# ifdef _LIBC
#  define IS_CHAR_CLASS(string) __wctype (string)
# else
#  define IS_CHAR_CLASS(string) wctype (string)
# endif
#else
# 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"))
#endif

#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_regend;
static register_info_type *reg_info;
static const char **reg_dummy;
static register_info_type *reg_info_dummy;

/* Make the register vectors big enough for NUM_REGS registers,
   but don't make them smaller.  */

static
regex_grow_registers (num_regs)
     int num_regs;
{
  if (num_regs > regs_allocated_size)
    {
      RETALLOC_IF (regstart,	 num_regs, const char *);
      RETALLOC_IF (regend,	 num_regs, const char *);
      RETALLOC_IF (old_regstart, num_regs, const char *);
      RETALLOC_IF (old_regend,	 num_regs, const char *);
      RETALLOC_IF (best_regstart, num_regs, const char *);
      RETALLOC_IF (best_regend,	 num_regs, const char *);
      RETALLOC_IF (reg_info,	 num_regs, register_info_type);
      RETALLOC_IF (reg_dummy,	 num_regs, const char *);
      RETALLOC_IF (reg_info_dummy, num_regs, register_info_type);

      regs_allocated_size = num_regs;
    }
}

#endif /* not MATCH_MAY_ALLOCATE */

static boolean group_in_compile_stack _RE_ARGS ((compile_stack_type
						 compile_stack,
						 regnum_t regnum));

/* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.
   Returns one of error codes defined in `regex.h', or zero for success.

   Assumes the `allocated' (and perhaps `buffer') and `translate'
   fields are set in BUFP on entry.

   If it succeeds, results are put in BUFP (if it returns an error, the
   contents of BUFP are undefined):
     `buffer' is the compiled pattern;
     `syntax' is set to SYNTAX;
     `used' is set to the length of the compiled pattern;
     `fastmap_accurate' is zero;
     `re_nsub' is the number of subexpressions in PATTERN;
     `not_bol' and `not_eol' are zero;

   The `fastmap' and `newline_anchor' fields are neither
   examined nor set.  */

/* Return, freeing storage we allocated.  */
#define FREE_STACK_RETURN(value)		\
  return (free (compile_stack.stack), value)

static reg_errcode_t
regex_compile (pattern, size, syntax, bufp)
     const char *pattern;
     size_t size;
     reg_syntax_t syntax;
     struct re_pattern_buffer *bufp;
{
  /* We fetch characters from PATTERN here.  Even though PATTERN is
     `char *' (i.e., signed), we declare these variables as unsigned, so
     they can be reliably used as array indices.  */
  register unsigned char c, c1;

  /* A random temporary spot in PATTERN.  */
  const char *p1;

  /* Points to the end of the buffer, where we should append.  */
  register unsigned char *b;

  /* Keeps track of unclosed groups.  */
  compile_stack_type compile_stack;

  /* Points to the current (ending) position in the pattern.  */
  const char *p = pattern;
  const char *pend = pattern + size;

  /* How to translate the characters in the pattern.  */
  RE_TRANSLATE_TYPE translate = bufp->translate;

  /* Address of the count-byte of the most recently inserted `exactn'
     command.  This makes it possible to tell if a new exact-match
     character can be added to that command or if the character requires
     a new `exactn' command.  */
  unsigned char *pending_exact = 0;

  /* Address of start of the most recently finished expression.
     This tells, e.g., postfix * where to find the start of its
     operand.  Reset at the beginning of groups and alternatives.  */
  unsigned char *laststart = 0;

  /* Address of beginning of regexp, or inside of last group.  */
  unsigned char *begalt;

  /* Place in the uncompiled pattern (i.e., the {) to
     which to go back if the interval is invalid.  */
  const char *beg_interval;

  /* Address of the place where a forward jump should go to the end of
     the containing expression.  Each alternative of an `or' -- except the
     last -- ends with a forward jump of this sort.  */
  unsigned char *fixup_alt_jump = 0;

  /* Counts open-groups as they are encountered.  Remembered for the
     matching close-group on the compile stack, so the same register
     number is put in the stop_memory as the start_memory.  */
  regnum_t regnum = 0;

#ifdef DEBUG
  DEBUG_PRINT1 ("\nCompiling pattern: ");
  if (debug)
    {
      unsigned debug_count;

      for (debug_count = 0; debug_count < size; debug_count++)
        putchar (pattern[debug_count]);
      putchar ('\n');
    }
#endif /* DEBUG */

  /* Initialize the compile stack.  */
  compile_stack.stack = TALLOC (INIT_COMPILE_STACK_SIZE, compile_stack_elt_t);
  if (compile_stack.stack == NULL)
    return REG_ESPACE;

  compile_stack.size = INIT_COMPILE_STACK_SIZE;
  compile_stack.avail = 0;

  /* Initialize the pattern buffer.  */
  bufp->syntax = syntax;
  bufp->fastmap_accurate = 0;
  bufp->not_bol = bufp->not_eol = 0;

  /* Set `used' to zero, so that if we return an error, the pattern
     printer (for debugging) will think there's no pattern.  We reset it
     at the end.  */
  bufp->used = 0;

  /* Always count groups, whether or not bufp->no_sub is set.  */
  bufp->re_nsub = 0;

#if !defined emacs && !defined SYNTAX_TABLE
  /* Initialize the syntax table.  */
   init_syntax_once ();
#endif

  if (bufp->allocated == 0)
    {
      if (bufp->buffer)
	{ /* If zero allocated, but buffer is non-null, try to realloc
             enough space.  This loses if buffer's address is bogus, but
             that is the user's responsibility.  */
          RETALLOC (bufp->buffer, INIT_BUF_SIZE, unsigned char);
        }
      else
        { /* Caller did not allocate a buffer.  Do it for them.  */
          bufp->buffer = TALLOC (INIT_BUF_SIZE, unsigned char);
        }
      if (!bufp->buffer) FREE_STACK_RETURN (REG_ESPACE);

      bufp->allocated = INIT_BUF_SIZE;
    }

  begalt = b = bufp->buffer;

  /* Loop through the uncompiled pattern until we're at the end.  */
  while (p != pend)
    {
      PATFETCH (c);

      switch (c)
        {
        case '^':
          {
            if (   /* If at start of pattern, it's an operator.  */
                   p == pattern + 1
                   /* If context independent, it's an operator.  */
                || syntax & RE_CONTEXT_INDEP_ANCHORS
                   /* Otherwise, depends on what's come before.  */
                || at_begline_loc_p (pattern, p, syntax))
              BUF_PUSH (begline);
            else
              goto normal_char;
          }
          break;


        case '$':
          {
            if (   /* If at end of pattern, it's an operator.  */
                   p == pend
                   /* If context independent, it's an operator.  */
                || syntax & RE_CONTEXT_INDEP_ANCHORS
                   /* Otherwise, depends on what's next.  */
                || at_endline_loc_p (p, pend, syntax))
               BUF_PUSH (endline);
             else
               goto normal_char;
           }
           break;


	case '+':
        case '?':
          if ((syntax & RE_BK_PLUS_QM)
              || (syntax & RE_LIMITED_OPS))
            goto normal_char;
        handle_plus:
        case '*':
          /* If there is no previous pattern... */
          if (!laststart)
            {
              if (syntax & RE_CONTEXT_INVALID_OPS)
                FREE_STACK_RETURN (REG_BADRPT);
              else if (!(syntax & RE_CONTEXT_INDEP_OPS))
                goto normal_char;
            }

          {
            /* Are we optimizing this jump?  */
            boolean keep_string_p = false;

            /* 1 means zero (many) matches is allowed.  */
            char zero_times_ok = 0, many_times_ok = 0;

            /* If there is a sequence of repetition chars, collapse it
               down to just one (the right one).  We can't combine
               interval operators with these because of, e.g., `a{2}*',
               which should only match an even number of `a's.  */

            for (;;)
              {
                zero_times_ok |= c != '+';
                many_times_ok |= c != '?';

                if (p == pend)
                  break;

                PATFETCH (c);

                if (c == '*'
                    || (!(syntax & RE_BK_PLUS_QM) && (c == '+' || c == '?')))
                  ;

                else if (syntax & RE_BK_PLUS_QM  &&  c == '\\')
                  {
                    if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);

                    PATFETCH (c1);
                    if (!(c1 == '+' || c1 == '?'))
                      {
                        PATUNFETCH;
                        PATUNFETCH;
                        break;
                      }

                    c = c1;
                  }
                else
                  {
                    PATUNFETCH;
                    break;
                  }

                /* If we get here, we found another repeat character.  */
               }

            /* Star, etc. applied to an empty pattern is equivalent
               to an empty pattern.  */
            if (!laststart)
              break;

            /* Now we know whether or not zero matches is allowed
               and also whether or not two or more matches is allowed.  */
            if (many_times_ok)
              { /* More than one repetition is allowed, so put in at the
                   end a backward relative jump from `b' to before the next
                   jump we're going to put in below (which jumps from
                   laststart to after this jump).

                   But if we are at the `*' in the exact sequence `.*\n',
                   insert an unconditional jump backwards to the .,
                   instead of the beginning of the loop.  This way we only
                   push a failure point once, instead of every time
                   through the loop.  */
                assert (p - 1 > pattern);

                /* Allocate the space for the jump.  */
                GET_BUFFER_SPACE (3);

                /* We know we are not at the first character of the pattern,
                   because laststart was nonzero.  And we've already
                   incremented `p', by the way, to be the character after
                   the `*'.  Do we have to do something analogous here
                   for null bytes, because of RE_DOT_NOT_NULL?  */
                if (TRANSLATE (*(p - 2)) == TRANSLATE ('.')
		    && zero_times_ok
                    && p < pend && TRANSLATE (*p) == TRANSLATE ('\n')
                    && !(syntax & RE_DOT_NEWLINE))
                  { /* We have .*\n.  */
                    STORE_JUMP (jump, b, laststart);
                    keep_string_p = true;
                  }
                else
                  /* Anything else.  */
                  STORE_JUMP (maybe_pop_jump, b, laststart - 3);

                /* We've added more stuff to the buffer.  */
                b += 3;
              }

            /* On failure, jump from laststart to b + 3, which will be the
               end of the buffer after this jump is inserted.  */
            GET_BUFFER_SPACE (3);
            INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump
                                       : on_failure_jump,
                         laststart, b + 3);
            pending_exact = 0;
            b += 3;

            if (!zero_times_ok)
              {
                /* At least one repetition is required, so insert a
                   `dummy_failure_jump' before the initial
                   `on_failure_jump' instruction of the loop. This
                   effects a skip over that instruction the first time
                   we hit that loop.  */
                GET_BUFFER_SPACE (3);
                INSERT_JUMP (dummy_failure_jump, laststart, laststart + 6);
                b += 3;
              }
            }
	  break;


	case '.':
          laststart = b;
          BUF_PUSH (anychar);
          break;


        case '[':
          {
            boolean had_char_class = false;

            if (p == pend) FREE_STACK_RETURN (REG_EBRACK);

            /* Ensure that we have enough space to push a charset: the
               opcode, the length count, and the bitset; 34 bytes in all.  */
	    GET_BUFFER_SPACE (34);

            laststart = b;

            /* We test `*p == '^' twice, instead of using an if
               statement, so we only need one BUF_PUSH.  */
            BUF_PUSH (*p == '^' ? charset_not : charset);
            if (*p == '^')
              p++;

            /* Remember the first position in the bracket expression.  */
            p1 = p;

            /* Push the number of bytes in the bitmap.  */
            BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);

            /* Clear the whole map.  */
            bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);

            /* charset_not matches newline according to a syntax bit.  */
            if ((re_opcode_t) b[-2] == charset_not
                && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
              SET_LIST_BIT ('\n');

            /* Read in characters and ranges, setting map bits.  */
            for (;;)
              {
                if (p == pend) FREE_STACK_RETURN (REG_EBRACK);

                PATFETCH (c);

                /* \ might escape characters inside [...] and [^...].  */
                if ((syntax & RE_BACKSLASH_ESCAPE_IN_LISTS) && c == '\\')
                  {
                    if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);

                    PATFETCH (c1);
                    SET_LIST_BIT (c1);
                    continue;
                  }

                /* Could be the end of the bracket expression.  If it's
                   not (i.e., when the bracket expression is `[]' so
                   far), the ']' character bit gets set way below.  */
                if (c == ']' && p != p1 + 1)
                  break;

                /* Look ahead to see if it's a range when the last thing
                   was a character class.  */
                if (had_char_class && c == '-' && *p != ']')
                  FREE_STACK_RETURN (REG_ERANGE);

                /* Look ahead to see if it's a range when the last thing
                   was a character: if this is a hyphen not at the
                   beginning or the end of a list, then it's the range
                   operator.  */
                if (c == '-'
                    && !(p - 2 >= pattern && p[-2] == '[')
                    && !(p - 3 >= pattern && p[-3] == '[' && p[-2] == '^')
                    && *p != ']')
                  {
                    reg_errcode_t ret
                      = compile_range (&p, pend, translate, syntax, b);
                    if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
                  }

                else if (p[0] == '-' && p[1] != ']')
                  { /* This handles ranges made up of characters only.  */
                    reg_errcode_t ret;

		    /* Move past the `-'.  */
                    PATFETCH (c1);

                    ret = compile_range (&p, pend, translate, syntax, b);
                    if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
                  }

                /* See if we're at the beginning of a possible character
                   class.  */

                else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == ':')
                  { /* Leave room for the null.  */
                    char str[CHAR_CLASS_MAX_LENGTH + 1];

                    PATFETCH (c);
                    c1 = 0;

                    /* If pattern is `[[:'.  */
                    if (p == pend) FREE_STACK_RETURN (REG_EBRACK);

                    for (;;)
                      {
                        PATFETCH (c);
                        if ((c == ':' && *p == ']') || p == pend)
                          break;
			if (c1 < CHAR_CLASS_MAX_LENGTH)
			  str[c1++] = c;
			else
			  /* This is in any case an invalid class name.  */
			  str[0] = '\0';
                      }
                    str[c1] = '\0';

                    /* If isn't a word bracketed by `[:' and `:]':
                       undo the ending character, the letters, and leave
                       the leading `:' and `[' (but set bits for them).  */
                    if (c == ':' && *p == ']')
                      {
#if defined _LIBC || WIDE_CHAR_SUPPORT
                        boolean is_lower = STREQ (str, "lower");
                        boolean is_upper = STREQ (str, "upper");
			wctype_t wt;
                        int ch;

			wt = IS_CHAR_CLASS (str);
			if (wt == 0)
			  FREE_STACK_RETURN (REG_ECTYPE);

                        /* Throw away the ] at the end of the character
                           class.  */
                        PATFETCH (c);

                        if (p == pend) FREE_STACK_RETURN (REG_EBRACK);

                        for (ch = 0; ch < 1 << BYTEWIDTH; ++ch)
			  {
# ifdef _LIBC
			    if (__iswctype (__btowc (ch), wt))
			      SET_LIST_BIT (ch);
# else
			    if (iswctype (btowc (ch), wt))
			      SET_LIST_BIT (ch);
# endif

			    if (translate && (is_upper || is_lower)
				&& (ISUPPER (ch) || ISLOWER (ch)))
			      SET_LIST_BIT (ch);
			  }

                        had_char_class = true;
#else
                        int ch;
                        boolean is_alnum = STREQ (str, "alnum");
                        boolean is_alpha = STREQ (str, "alpha");
                        boolean is_blank = STREQ (str, "blank");
                        boolean is_cntrl = STREQ (str, "cntrl");
                        boolean is_digit = STREQ (str, "digit");
                        boolean is_graph = STREQ (str, "graph");
                        boolean is_lower = STREQ (str, "lower");
                        boolean is_print = STREQ (str, "print");
                        boolean is_punct = STREQ (str, "punct");
                        boolean is_space = STREQ (str, "space");
                        boolean is_upper = STREQ (str, "upper");
                        boolean is_xdigit = STREQ (str, "xdigit");

                        if (!IS_CHAR_CLASS (str))
			  FREE_STACK_RETURN (REG_ECTYPE);

                        /* Throw away the ] at the end of the character
                           class.  */
                        PATFETCH (c);

                        if (p == pend) FREE_STACK_RETURN (REG_EBRACK);

                        for (ch = 0; ch < 1 << BYTEWIDTH; ch++)
                          {
			    /* This was split into 3 if's to
			       avoid an arbitrary limit in some compiler.  */
                            if (   (is_alnum  && ISALNUM (ch))
                                || (is_alpha  && ISALPHA (ch))
                                || (is_blank  && ISBLANK (ch))
                                || (is_cntrl  && ISCNTRL (ch)))
			      SET_LIST_BIT (ch);
			    if (   (is_digit  && ISDIGIT (ch))
                                || (is_graph  && ISGRAPH (ch))
                                || (is_lower  && ISLOWER (ch))
                                || (is_print  && ISPRINT (ch)))
			      SET_LIST_BIT (ch);
			    if (   (is_punct  && ISPUNCT (ch))
                                || (is_space  && ISSPACE (ch))
                                || (is_upper  && ISUPPER (ch))
                                || (is_xdigit && ISXDIGIT (ch)))
			      SET_LIST_BIT (ch);
			    if (   translate && (is_upper || is_lower)
				&& (ISUPPER (ch) || ISLOWER (ch)))
			      SET_LIST_BIT (ch);
                          }
                        had_char_class = true;
#endif	/* libc || wctype.h */
                      }
                    else
                      {
                        c1++;
                        while (c1--)
                          PATUNFETCH;
                        SET_LIST_BIT ('[');
                        SET_LIST_BIT (':');
                        had_char_class = false;
                      }
                  }
                else
                  {
                    had_char_class = false;
                    SET_LIST_BIT (c);
                  }
              }

            /* Discard any (non)matching list bytes that are all 0 at the
               end of the map.  Decrease the map-length byte too.  */
            while ((int) b[-1] > 0 && b[b[-1] - 1] == 0)
              b[-1]--;
            b += b[-1];
          }
          break;


	case '(':
          if (syntax & RE_NO_BK_PARENS)
            goto handle_open;
          else
            goto normal_char;


        case ')':
          if (syntax & RE_NO_BK_PARENS)
            goto handle_close;
          else
            goto normal_char;


        case '\n':
          if (syntax & RE_NEWLINE_ALT)
            goto handle_alt;
          else
            goto normal_char;


	case '|':
          if (syntax & RE_NO_BK_VBAR)
            goto handle_alt;
          else
            goto normal_char;


        case '{':
           if (syntax & RE_INTERVALS && syntax & RE_NO_BK_BRACES)
             goto handle_interval;
           else
             goto normal_char;


        case '\\':
          if (p == pend) FREE_STACK_RETURN (REG_EESCAPE);

          /* Do not translate the character after the \, so that we can
             distinguish, e.g., \B from \b, even if we normally would
             translate, e.g., B to b.  */
          PATFETCH_RAW (c);

          switch (c)
            {
            case '(':
              if (syntax & RE_NO_BK_PARENS)
                goto normal_backslash;

            handle_open:
              bufp->re_nsub++;
              regnum++;

              if (COMPILE_STACK_FULL)
                {
                  RETALLOC (compile_stack.stack, compile_stack.size << 1,
                            compile_stack_elt_t);
                  if (compile_stack.stack == NULL) return REG_ESPACE;

                  compile_stack.size <<= 1;
                }

              /* These are the values to restore when we hit end of this
                 group.  They are all relative offsets, so that if the
                 whole pattern moves because of realloc, they will still
                 be valid.  */
              COMPILE_STACK_TOP.begalt_offset = begalt - bufp->buffer;
              COMPILE_STACK_TOP.fixup_alt_jump
                = fixup_alt_jump ? fixup_alt_jump - bufp->buffer + 1 : 0;
              COMPILE_STACK_TOP.laststart_offset = b - bufp->buffer;
              COMPILE_STACK_TOP.regnum = regnum;

              /* We will eventually replace the 0 with the number of
                 groups inner to this one.  But do not push a
                 start_memory for groups beyond the last one we can
                 represent in the compiled pattern.  */
              if (regnum <= MAX_REGNUM)
                {
                  COMPILE_STACK_TOP.inner_group_offset = b - bufp->buffer + 2;
                  BUF_PUSH_3 (start_memory, regnum, 0);
                }

              compile_stack.avail++;

              fixup_alt_jump = 0;
              laststart = 0;
              begalt = b;
	      /* If we've reached MAX_REGNUM groups, then this open
		 won't actually generate any code, so we'll have to
		 clear pending_exact explicitly.  */
	      pending_exact = 0;
              break;


            case ')':
              if (syntax & RE_NO_BK_PARENS) goto normal_backslash;

              if (COMPILE_STACK_EMPTY)
		{
		  if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
		    goto normal_backslash;
		  else
		    FREE_STACK_RETURN (REG_ERPAREN);
		}

            handle_close:
              if (fixup_alt_jump)
                { /* Push a dummy failure point at the end of the
                     alternative for a possible future
                     `pop_failure_jump' to pop.  See comments at
                     `push_dummy_failure' in `re_match_2'.  */
                  BUF_PUSH (push_dummy_failure);

                  /* We allocated space for this jump when we assigned
                     to `fixup_alt_jump', in the `handle_alt' case below.  */
                  STORE_JUMP (jump_past_alt, fixup_alt_jump, b - 1);
                }

              /* See similar code for backslashed left paren above.  */
              if (COMPILE_STACK_EMPTY)
		{
		  if (syntax & RE_UNMATCHED_RIGHT_PAREN_ORD)
		    goto normal_char;
		  else
		    FREE_STACK_RETURN (REG_ERPAREN);
		}

              /* Since we just checked for an empty stack above, this
                 ``can't happen''.  */
              assert (compile_stack.avail != 0);
              {
                /* We don't just want to restore into `regnum', because
                   later groups should continue to be numbered higher,
                   as in `(ab)c(de)' -- the second group is #2.  */
                regnum_t this_group_regnum;

                compile_stack.avail--;
                begalt = bufp->buffer + COMPILE_STACK_TOP.begalt_offset;
                fixup_alt_jump
                  = COMPILE_STACK_TOP.fixup_alt_jump
                    ? bufp->buffer + COMPILE_STACK_TOP.fixup_alt_jump - 1
                    : 0;
                laststart = bufp->buffer + COMPILE_STACK_TOP.laststart_offset;
                this_group_regnum = COMPILE_STACK_TOP.regnum;
		/* If we've reached MAX_REGNUM groups, then this open
		   won't actually generate any code, so we'll have to
		   clear pending_exact explicitly.  */
		pending_exact = 0;

                /* We're at the end of the group, so now we know how many
                   groups were inside this one.  */
                if (this_group_regnum <= MAX_REGNUM)
                  {
                    unsigned char *inner_group_loc
                      = bufp->buffer + COMPILE_STACK_TOP.inner_group_offset;

                    *inner_group_loc = regnum - this_group_regnum;
                    BUF_PUSH_3 (stop_memory, this_group_regnum,
                                regnum - this_group_regnum);
                  }
              }
              break;


            case '|':					/* `\|'.  */
              if (syntax & RE_LIMITED_OPS || syntax & RE_NO_BK_VBAR)
                goto normal_backslash;
            handle_alt:
              if (syntax & RE_LIMITED_OPS)
                goto normal_char;

              /* Insert before the previous alternative a jump which
                 jumps to this alternative if the former fails.  */
              GET_BUFFER_SPACE (3);
              INSERT_JUMP (on_failure_jump, begalt, b + 6);
              pending_exact = 0;
              b += 3;

              /* The alternative before this one has a jump after it
                 which gets executed if it gets matched.  Adjust that
                 jump so it will jump to this alternative's analogous
                 jump (put in below, which in turn will jump to the next
                 (if any) alternative's such jump, etc.).  The last such
                 jump jumps to the correct final destination.  A picture:
                          _____ _____
                          |   | |   |
                          |   v |   v
                         a | b   | c

                 If we are at `b', then fixup_alt_jump right now points to a
                 three-byte space after `a'.  We'll put in the jump, set
                 fixup_alt_jump to right after `b', and leave behind three
                 bytes which we'll fill in when we get to after `c'.  */

              if (fixup_alt_jump)
                STORE_JUMP (jump_past_alt, fixup_alt_jump, b);

              /* Mark and leave space for a jump after this alternative,
                 to be filled in later either by next alternative or
                 when know we're at the end of a series of alternatives.  */
              fixup_alt_jump = b;
              GET_BUFFER_SPACE (3);
              b += 3;

              laststart = 0;
              begalt = b;
              break;


            case '{':
              /* If \{ is a literal.  */
              if (!(syntax & RE_INTERVALS)
                     /* If we're at `\{' and it's not the open-interval
                        operator.  */
                  || ((syntax & RE_INTERVALS) && (syntax & RE_NO_BK_BRACES))
                  || (p - 2 == pattern  &&  p == pend))
                goto normal_backslash;

            handle_interval:
              {
                /* If got here, then the syntax allows intervals.  */

                /* At least (most) this many matches must be made.  */
                int lower_bound = -1, upper_bound = -1;

                beg_interval = p - 1;

                if (p == pend)
                  {
                    if (syntax & RE_NO_BK_BRACES)
                      goto unfetch_interval;
                    else
                      FREE_STACK_RETURN (REG_EBRACE);
                  }

                GET_UNSIGNED_NUMBER (lower_bound);

                if (c == ',')
                  {
                    GET_UNSIGNED_NUMBER (upper_bound);
                    if (upper_bound < 0) upper_bound = RE_DUP_MAX;
                  }
                else
                  /* Interval such as `{1}' => match exactly once. */
                  upper_bound = lower_bound;

                if (lower_bound < 0 || upper_bound > RE_DUP_MAX
                    || lower_bound > upper_bound)
                  {
                    if (syntax & RE_NO_BK_BRACES)
                      goto unfetch_interval;
                    else
                      FREE_STACK_RETURN (REG_BADBR);
                  }

                if (!(syntax & RE_NO_BK_BRACES))
                  {
                    if (c != '\\') FREE_STACK_RETURN (REG_EBRACE);

                    PATFETCH (c);
                  }

                if (c != '}')
                  {
                    if (syntax & RE_NO_BK_BRACES)
                      goto unfetch_interval;
                    else
                      FREE_STACK_RETURN (REG_BADBR);
                  }

                /* We just parsed a valid interval.  */

                /* If it's invalid to have no preceding re.  */
                if (!laststart)
                  {
                    if (syntax & RE_CONTEXT_INVALID_OPS)
                      FREE_STACK_RETURN (REG_BADRPT);
                    else if (syntax & RE_CONTEXT_INDEP_OPS)
                      laststart = b;
                    else
                      goto unfetch_interval;
                  }

                /* If the upper bound is zero, don't want to succeed at
                   all; jump from `laststart' to `b + 3', which will be
                   the end of the buffer after we insert the jump.  */
                 if (upper_bound == 0)
                   {
                     GET_BUFFER_SPACE (3);
                     INSERT_JUMP (jump, laststart, b + 3);
                     b += 3;
                   }

                 /* Otherwise, we have a nontrivial interval.  When
                    we're all done, the pattern will look like:
                      set_number_at <jump count> <upper bound>
                      set_number_at <succeed_n count> <lower bound>
                      succeed_n <after jump addr> <succeed_n count>
                      <body of loop>
                      jump_n <succeed_n addr> <jump count>
                    (The upper bound and `jump_n' are omitted if
                    `upper_bound' is 1, though.)  */
                 else
                   { /* If the upper bound is > 1, we need to insert
                        more at the end of the loop.  */
                     unsigned nbytes = 10 + (upper_bound > 1) * 10;

                     GET_BUFFER_SPACE (nbytes);

                     /* Initialize lower bound of the `succeed_n', even
                        though it will be set during matching by its
                        attendant `set_number_at' (inserted next),
                        because `re_compile_fastmap' needs to know.
                        Jump to the `jump_n' we might insert below.  */
                     INSERT_JUMP2 (succeed_n, laststart,
                                   b + 5 + (upper_bound > 1) * 5,
                                   lower_bound);
                     b += 5;

                     /* Code to initialize the lower bound.  Insert
                        before the `succeed_n'.  The `5' is the last two
                        bytes of this `set_number_at', plus 3 bytes of
                        the following `succeed_n'.  */
                     insert_op2 (set_number_at, laststart, 5, lower_bound, b);
                     b += 5;

                     if (upper_bound > 1)
                       { /* More than one repetition is allowed, so
                            append a backward jump to the `succeed_n'
                            that starts this interval.

                            When we've reached this during matching,
                            we'll have matched the interval once, so
                            jump back only `upper_bound - 1' times.  */
                         STORE_JUMP2 (jump_n, b, laststart + 5,
                                      upper_bound - 1);
                         b += 5;

                         /* The location we want to set is the second
                            parameter of the `jump_n'; that is `b-2' as
                            an absolute address.  `laststart' will be
                            the `set_number_at' we're about to insert;
                            `laststart+3' the number to set, the source
                            for the relative address.  But we are
                            inserting into the middle of the pattern --
                            so everything is getting moved up by 5.
                            Conclusion: (b - 2) - (laststart + 3) + 5,
                            i.e., b - laststart.

                            We insert this at the beginning of the loop
                            so that if we fail during matching, we'll
                            reinitialize the bounds.  */
                         insert_op2 (set_number_at, laststart, b - laststart,
                                     upper_bound - 1, b);
                         b += 5;
                       }
                   }
                pending_exact = 0;
                beg_interval = NULL;
              }
              break;

            unfetch_interval:
              /* If an invalid interval, match the characters as literals.  */
               assert (beg_interval);
               p = beg_interval;
               beg_interval = NULL;

               /* normal_char and normal_backslash need `c'.  */
               PATFETCH (c);

               if (!(syntax & RE_NO_BK_BRACES))
                 {
                   if (p > pattern  &&  p[-1] == '\\')
                     goto normal_backslash;
                 }
               goto normal_char;

#ifdef emacs
            /* There is no way to specify the before_dot and after_dot
               operators.  rms says this is ok.  --karl  */
            case '=':
              BUF_PUSH (at_dot);
              break;

            case 's':
              laststart = b;
              PATFETCH (c);
              BUF_PUSH_2 (syntaxspec, syntax_spec_code[c]);
              break;

            case 'S':
              laststart = b;
              PATFETCH (c);
              BUF_PUSH_2 (notsyntaxspec, syntax_spec_code[c]);
              break;
#endif /* emacs */


            case 'w':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              laststart = b;
              BUF_PUSH (wordchar);
              break;


            case 'W':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              laststart = b;
              BUF_PUSH (notwordchar);
              break;


            case '<':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              BUF_PUSH (wordbeg);
              break;

            case '>':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              BUF_PUSH (wordend);
              break;

            case 'b':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              BUF_PUSH (wordbound);
              break;

            case 'B':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              BUF_PUSH (notwordbound);
              break;

            case '`':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              BUF_PUSH (begbuf);
              break;

            case '\'':
	      if (syntax & RE_NO_GNU_OPS)
		goto normal_char;
              BUF_PUSH (endbuf);
              break;

            case '1': case '2': case '3': case '4': case '5':
            case '6': case '7': case '8': case '9':
              if (syntax & RE_NO_BK_REFS)
                goto normal_char;

              c1 = c - '0';

              if (c1 > regnum)
                FREE_STACK_RETURN (REG_ESUBREG);

              /* Can't back reference to a subexpression if inside of it.  */
              if (group_in_compile_stack (compile_stack, (regnum_t) c1))
                goto normal_char;

              laststart = b;
              BUF_PUSH_2 (duplicate, c1);
              break;


            case '+':
            case '?':
              if (syntax & RE_BK_PLUS_QM)
                goto handle_plus;
              else
                goto normal_backslash;

            default:
            normal_backslash:
              /* You might think it would be useful for \ to mean
                 not to translate; but if we don't translate it
                 it will never match anything.  */
              c = TRANSLATE (c);
              goto normal_char;
            }
          break;


	default:
        /* Expects the character in `c'.  */
	normal_char:
	      /* If no exactn currently being built.  */
          if (!pending_exact

              /* If last exactn not at current position.  */
              || pending_exact + *pending_exact + 1 != b

              /* We have only one byte following the exactn for the count.  */
	      || *pending_exact == (1 << BYTEWIDTH) - 1

              /* If followed by a repetition operator.  */
              || *p == '*' || *p == '^'
	      || ((syntax & RE_BK_PLUS_QM)
		  ? *p == '\\' && (p[1] == '+' || p[1] == '?')
		  : (*p == '+' || *p == '?'))
	      || ((syntax & RE_INTERVALS)
                  && ((syntax & RE_NO_BK_BRACES)
		      ? *p == '{'
                      : (p[0] == '\\' && p[1] == '{'))))
	    {
	      /* Start building a new exactn.  */

              laststart = b;

	      BUF_PUSH_2 (exactn, 0);
	      pending_exact = b - 1;
            }

	  BUF_PUSH (c);
          (*pending_exact)++;
	  break;
        } /* switch (c) */
    } /* while p != pend */


  /* Through the pattern now.  */

  if (fixup_alt_jump)
    STORE_JUMP (jump_past_alt, fixup_alt_jump, b);

  if (!COMPILE_STACK_EMPTY)
    FREE_STACK_RETURN (REG_EPAREN);

  /* If we don't want backtracking, force success
     the first time we reach the end of the compiled pattern.  */
  if (syntax & RE_NO_POSIX_BACKTRACKING)
    BUF_PUSH (succeed);

  free (compile_stack.stack);

  /* We have succeeded; set the length of the buffer.  */
  bufp->used = b - bufp->buffer;

#ifdef DEBUG
  if (debug)
    {
      DEBUG_PRINT1 ("\nCompiled pattern: \n");
      print_compiled_pattern (bufp);
    }
#endif /* DEBUG */

#ifndef MATCH_MAY_ALLOCATE
  /* Initialize the failure stack to the largest possible stack.  This
     isn't necessary unless we're trying to avoid calling alloca in
     the search and match routines.  */
  {
    int num_regs = bufp->re_nsub + 1;

    /* Since DOUBLE_FAIL_STACK refuses to double only if the current size
       is strictly greater than re_max_failures, the largest possible stack
       is 2 * re_max_failures failure points.  */
    if (fail_stack.size < (2 * re_max_failures * MAX_FAILURE_ITEMS))
      {
	fail_stack.size = (2 * re_max_failures * MAX_FAILURE_ITEMS);

# ifdef emacs
	if (! fail_stack.stack)
	  fail_stack.stack
	    = (fail_stack_elt_t *) xmalloc (fail_stack.size
					    * sizeof (fail_stack_elt_t));
	else
	  fail_stack.stack
	    = (fail_stack_elt_t *) xrealloc (fail_stack.stack,
					     (fail_stack.size
					      * sizeof (fail_stack_elt_t)));
# else /* not emacs */
	if (! fail_stack.stack)
	  fail_stack.stack
	    = (fail_stack_elt_t *) malloc (fail_stack.size
					   * sizeof (fail_stack_elt_t));
	else
	  fail_stack.stack
	    = (fail_stack_elt_t *) realloc (fail_stack.stack,
					    (fail_stack.size
					     * sizeof (fail_stack_elt_t)));
# endif /* not emacs */
      }

    regex_grow_registers (num_regs);
  }
#endif /* not MATCH_MAY_ALLOCATE */

  return REG_NOERROR;
} /* regex_compile */

/* Subroutines for `regex_compile'.  */

/* Store OP at LOC followed by two-byte integer parameter ARG.  */

static void
store_op1 (op, loc, arg)
    re_opcode_t op;
    unsigned char *loc;
    int arg;
{
  *loc = (unsigned char) op;
  STORE_NUMBER (loc + 1, arg);
}


/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2.  */

static void
store_op2 (op, loc, arg1, arg2)
    re_opcode_t op;
    unsigned char *loc;
    int arg1, arg2;
{
  *loc = (unsigned char) op;
  STORE_NUMBER (loc + 1, arg1);
  STORE_NUMBER (loc + 3, arg2);
}


/* Copy the bytes from LOC to END to open up three bytes of space at LOC
   for OP followed by two-byte integer parameter ARG.  */

static void
insert_op1 (op, loc, arg, end)
    re_opcode_t op;
    unsigned char *loc;
    int arg;
    unsigned char *end;
{
  register unsigned char *pfrom = end;
  register unsigned char *pto = end + 3;

  while (pfrom != loc)
    *--pto = *--pfrom;

  store_op1 (op, loc, arg);
}


/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2.  */

static void
insert_op2 (op, loc, arg1, arg2, end)
    re_opcode_t op;
    unsigned char *loc;
    int arg1, arg2;
    unsigned char *end;
{
  register unsigned char *pfrom = end;
  register unsigned char *pto = end + 5;

  while (pfrom != loc)
    *--pto = *--pfrom;

  store_op2 (op, loc, arg1, arg2);
}


/* P points to just after a ^ in PATTERN.  Return true if that ^ comes
   after an alternative or a begin-subexpression.  We assume there is at
   least one character before the ^.  */

static boolean
at_begline_loc_p (pattern, p, syntax)
    const char *pattern, *p;
    reg_syntax_t syntax;
{
  const char *prev = p - 2;
  boolean prev_prev_backslash = prev > pattern && prev[-1] == '\\';

  return
       /* After a subexpression?  */
       (*prev == '(' && (syntax & RE_NO_BK_PARENS || prev_prev_backslash))
       /* After an alternative?  */
    || (*prev == '|' && (syntax & RE_NO_BK_VBAR || prev_prev_backslash));
}


/* The dual of at_begline_loc_p.  This one is for $.  We assume there is
   at least one character after the $, i.e., `P < PEND'.  */

static boolean
at_endline_loc_p (p, pend, syntax)
    const char *p, *pend;
    reg_syntax_t syntax;
{
  const char *next = p;
  boolean next_backslash = *next == '\\';
  const char *next_next = p + 1 < pend ? p + 1 : 0;

  return
       /* Before a subexpression?  */
       (syntax & RE_NO_BK_PARENS ? *next == ')'
        : next_backslash && next_next && *next_next == ')')
       /* Before an alternative?  */
    || (syntax & RE_NO_BK_VBAR ? *next == '|'
        : next_backslash && next_next && *next_next == '|');
}


/* Returns true if REGNUM is in one of COMPILE_STACK's elements and
   false if it's not.  */

static boolean
group_in_compile_stack (compile_stack, regnum)
    compile_stack_type compile_stack;
    regnum_t regnum;
{
  int this_element;

  for (this_element = compile_stack.avail - 1;
       this_element >= 0;
       this_element--)
    if (compile_stack.stack[this_element].regnum == regnum)
      return true;

  return false;
}


/* Read the ending character of a range (in a bracket expression) from the
   uncompiled pattern *P_PTR (which ends at PEND).  We assume the
   starting character is in `P[-2]'.  (`P[-1]' is the character `-'.)
   Then we set the translation of all bits between the starting and
   ending characters (inclusive) in the compiled pattern B.

   Return an error code.

   We use these short variable names so we can use the same macros as
   `regex_compile' itself.  */

static reg_errcode_t
compile_range (p_ptr, pend, translate, syntax, b)
    const char **p_ptr, *pend;
    RE_TRANSLATE_TYPE translate;
    reg_syntax_t syntax;
    unsigned char *b;
{
  unsigned this_char;

  const char *p = *p_ptr;
  unsigned int range_start, range_end;

  if (p == pend)
    return REG_ERANGE;

  /* Even though the pattern is a signed `char *', we need to fetch
     with unsigned char *'s; if the high bit of the pattern character
     is set, the range endpoints will be negative if we fetch using a
     signed char *.

     We also want to fetch the endpoints without translating them; the
     appropriate translation is done in the bit-setting loop below.  */
  /* The SVR4 compiler on the 3B2 had trouble with unsigned const char *.  */
  range_start = ((const unsigned char *) p)[-2];
  range_end   = ((const unsigned char *) p)[0];

  /* Have to increment the pointer into the pattern string, so the
     caller isn't still at the ending character.  */
  (*p_ptr)++;

  /* If the start is after the end, the range is empty.  */
  if (range_start > range_end)
    return syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;

  /* Here we see why `this_char' has to be larger than an `unsigned
     char' -- the range is inclusive, so if `range_end' == 0xff
     (assuming 8-bit characters), we would otherwise go into an infinite
     loop, since all characters <= 0xff.  */
  for (this_char = range_start; this_char <= range_end; this_char++)
    {
      SET_LIST_BIT (TRANSLATE (this_char));
    }

  return REG_NOERROR;
}

/* re_compile_fastmap computes a ``fastmap'' for the compiled pattern in
   BUFP.  A fastmap records which of the (1 << BYTEWIDTH) possible
   characters can start a string that matches the pattern.  This fastmap
   is used by re_search to skip quickly over impossible starting points.

   The caller must supply the address of a (1 << BYTEWIDTH)-byte data
   area as BUFP->fastmap.

   We set the `fastmap', `fastmap_accurate', and `can_be_null' fields in
   the pattern buffer.

   Returns 0 if we succeed, -2 if an internal error.   */

int
re_compile_fastmap (bufp)
     struct re_pattern_buffer *bufp;
{
  int j, k;
#ifdef MATCH_MAY_ALLOCATE
  fail_stack_type fail_stack;
#endif
#ifndef REGEX_MALLOC
  char *destination;
#endif

  register char *fastmap = bufp->fastmap;
  unsigned char *pattern = bufp->buffer;
  unsigned char *p = pattern;
  register unsigned char *pend = pattern + bufp->used;

#ifdef REL_ALLOC
  /* This holds the pointer to the failure stack, when
     it is allocated relocatably.  */
  fail_stack_elt_t *failure_stack_ptr;
#endif

  /* Assume that each path through the pattern can be null until
     proven otherwise.  We set this false at the bottom of switch
     statement, to which we get only if a particular path doesn't
     match the empty string.  */
  boolean path_can_be_null = true;

  /* We aren't doing a `succeed_n' to begin with.  */
  boolean succeed_n_p = false;

  assert (fastmap != NULL && p != NULL);

  INIT_FAIL_STACK ();
  bzero (fastmap, 1 << BYTEWIDTH);  /* Assume nothing's valid.  */
  bufp->fastmap_accurate = 1;	    /* It will be when we're done.  */
  bufp->can_be_null = 0;

  while (1)
    {
      if (p == pend || *p == succeed)
	{
	  /* We have reached the (effective) end of pattern.  */
	  if (!FAIL_STACK_EMPTY ())
	    {
	      bufp->can_be_null |= path_can_be_null;

	      /* Reset for next path.  */
	      path_can_be_null = true;

	      p = fail_stack.stack[--fail_stack.avail].pointer;

	      continue;
	    }
	  else
	    break;
	}

      /* We should never be about to go beyond the end of the pattern.  */
      assert (p < pend);

      switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
	{

        /* I guess the idea here is to simply not bother with a fastmap
           if a backreference is used, since it's too hard to figure out
           the fastmap for the corresponding group.  Setting
           `can_be_null' stops `re_search_2' from using the fastmap, so
           that is all we do.  */
	case duplicate:
	  bufp->can_be_null = 1;
          goto done;


      /* Following are the cases which match a character.  These end
         with `break'.  */

	case exactn:
          fastmap[p[1]] = 1;
	  break;


        case charset:
          for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
	    if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))
              fastmap[j] = 1;
	  break;


	case charset_not:
	  /* Chars beyond end of map must be allowed.  */
	  for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++)
            fastmap[j] = 1;

	  for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--)
	    if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))))
              fastmap[j] = 1;
          break;


	case wordchar:
	  for (j = 0; j < (1 << BYTEWIDTH); j++)
	    if (SYNTAX (j) == Sword)
	      fastmap[j] = 1;
	  break;


	case notwordchar:
	  for (j = 0; j < (1 << BYTEWIDTH); j++)
	    if (SYNTAX (j) != Sword)
	      fastmap[j] = 1;
	  break;


        case anychar:
	  {
	    int fastmap_newline = fastmap['\n'];

	    /* `.' matches anything ...  */
	    for (j = 0; j < (1 << BYTEWIDTH); j++)
	      fastmap[j] = 1;

	    /* ... except perhaps newline.  */
	    if (!(bufp->syntax & RE_DOT_NEWLINE))
	      fastmap['\n'] = fastmap_newline;

	    /* Return if we have already set `can_be_null'; if we have,
	       then the fastmap is irrelevant.  Something's wrong here.  */
	    else if (bufp->can_be_null)
	      goto done;

	    /* Otherwise, have to check alternative paths.  */
	    break;
	  }

#ifdef emacs
        case syntaxspec:
	  k = *p++;
	  for (j = 0; j < (1 << BYTEWIDTH); j++)
	    if (SYNTAX (j) == (enum syntaxcode) k)
	      fastmap[j] = 1;
	  break;


	case notsyntaxspec:
	  k = *p++;
	  for (j = 0; j < (1 << BYTEWIDTH); j++)
	    if (SYNTAX (j) != (enum syntaxcode) k)
	      fastmap[j] = 1;
	  break;


      /* All cases after this match the empty string.  These end with
         `continue'.  */


	case before_dot:
	case at_dot:
	case after_dot:
          continue;
#endif /* emacs */


        case no_op:
        case begline:
        case endline:
	case begbuf:
	case endbuf:
	case wordbound:
	case notwordbound:
	case wordbeg:
	case wordend:
        case push_dummy_failure:
          continue;


	case jump_n:
        case pop_failure_jump:
	case maybe_pop_jump:
	case jump:
        case jump_past_alt:
	case dummy_failure_jump:
          EXTRACT_NUMBER_AND_INCR (j, p);
	  p += j;
	  if (j > 0)
	    continue;

          /* Jump backward implies we just went through the body of a
             loop and matched nothing.  Opcode jumped to should be
             `on_failure_jump' or `succeed_n'.  Just treat it like an
             ordinary jump.  For a * loop, it has pushed its failure
             point already; if so, discard that as redundant.  */
          if ((re_opcode_t) *p != on_failure_jump
	      && (re_opcode_t) *p != succeed_n)
	    continue;

          p++;
          EXTRACT_NUMBER_AND_INCR (j, p);
          p += j;

          /* If what's on the stack is where we are now, pop it.  */
          if (!FAIL_STACK_EMPTY ()
	      && fail_stack.stack[fail_stack.avail - 1].pointer == p)
            fail_stack.avail--;

          continue;


        case on_failure_jump:
        case on_failure_keep_string_jump:
	handle_on_failure_jump:
          EXTRACT_NUMBER_AND_INCR (j, p);

          /* For some patterns, e.g., `(a?)?', `p+j' here points to the
             end of the pattern.  We don't want to push such a point,
             since when we restore it above, entering the switch will
             increment `p' past the end of the pattern.  We don't need
             to push such a point since we obviously won't find any more
             fastmap entries beyond `pend'.  Such a pattern can match
             the null string, though.  */
          if (p + j < pend)
            {
              if (!PUSH_PATTERN_OP (p + j, fail_stack))
		{
		  RESET_FAIL_STACK ();
		  return -2;
		}
            }
          else
            bufp->can_be_null = 1;

          if (succeed_n_p)
            {
              EXTRACT_NUMBER_AND_INCR (k, p);	/* Skip the n.  */
              succeed_n_p = false;
	    }

          continue;


	case succeed_n:
          /* Get to the number of times to succeed.  */
          p += 2;

          /* Increment p past the n for when k != 0.  */
          EXTRACT_NUMBER_AND_INCR (k, p);
          if (k == 0)
	    {
              p -= 4;
  	      succeed_n_p = true;  /* Spaghetti code alert.  */
              goto handle_on_failure_jump;
            }
          continue;


	case set_number_at:
          p += 4;
          continue;


	case start_memory:
        case stop_memory:
	  p += 2;
	  continue;


	default:
          abort (); /* We have listed all the cases.  */
        } /* switch *p++ */

      /* Getting here means we have found the possible starting
         characters for one path of the pattern -- and that the empty
         string does not match.  We need not follow this path further.
         Instead, look at the next alternative (remembered on the
         stack), or quit if no more.  The test at the top of the loop
         does these things.  */
      path_can_be_null = false;
      p = pend;
    } /* while p */

  /* Set `can_be_null' for the last path (also the first path, if the
     pattern is empty).  */
  bufp->can_be_null |= path_can_be_null;

 done:
  RESET_FAIL_STACK ();
  return 0;
} /* re_compile_fastmap */
#ifdef _LIBC
weak_alias (__re_compile_fastmap, re_compile_fastmap)
#endif

/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
   ENDS.  Subsequent matches using PATTERN_BUFFER and REGS will use
   this memory for recording register information.  STARTS and ENDS
   must be allocated using the malloc library routine, and must each
   be at least NUM_REGS * sizeof (regoff_t) bytes long.

   If NUM_REGS == 0, then subsequent matches should allocate their own
   register data.

   Unless this function is called, the first search or match using
   PATTERN_BUFFER will allocate its own register data, without
   freeing the old data.  */

void
re_set_registers (bufp, regs, num_regs, starts, ends)
    struct re_pattern_buffer *bufp;
    struct re_registers *regs;
    unsigned num_regs;
    regoff_t *starts, *ends;
{
  if (num_regs)
    {
      bufp->regs_allocated = REGS_REALLOCATE;
      regs->num_regs = num_regs;
      regs->start = starts;
      regs->end = ends;
    }
  else
    {
      bufp->regs_allocated = REGS_UNALLOCATED;
      regs->num_regs = 0;
      regs->start = regs->end = (regoff_t *) 0;
    }
}
#ifdef _LIBC
weak_alias (__re_set_registers, re_set_registers)
#endif

/* Searching routines.  */

/* Like re_search_2, below, but only one string is specified, and
   doesn't let you say where to stop matching. */

int
re_search (bufp, string, size, startpos, range, regs)
     struct re_pattern_buffer *bufp;
     const char *string;
     int size, startpos, range;
     struct re_registers *regs;
{
  return re_search_2 (bufp, NULL, 0, string, size, startpos, range,
		      regs, size);
}
#ifdef _LIBC
weak_alias (__re_search, re_search)
#endif


/* Using the compiled pattern in BUFP->buffer, first tries to match the
   virtual concatenation of STRING1 and STRING2, starting first at index
   STARTPOS, then at STARTPOS + 1, and so on.

   STRING1 and STRING2 have length SIZE1 and SIZE2, respectively.

   RANGE is how far to scan while trying to match.  RANGE = 0 means try
   only at STARTPOS; in general, the last start tried is STARTPOS +
   RANGE.

   In REGS, return the indices of the virtual concatenation of STRING1
   and STRING2 that matched the entire BUFP->buffer and its contained
   subexpressions.

   Do not consider matching one past the index STOP in the virtual
   concatenation of STRING1 and STRING2.

   We return either the position in the strings at which the match was
   found, -1 if no match, or -2 if error (such as failure
   stack overflow).  */

int
re_search_2 (bufp, string1, size1, string2, size2, startpos, range, regs, stop)
     struct re_pattern_buffer *bufp;
     const char *string1, *string2;
     int size1, size2;
     int startpos;
     int range;
     struct re_registers *regs;
     int stop;
{
  int val;
  register char *fastmap = bufp->fastmap;
  register RE_TRANSLATE_TYPE translate = bufp->translate;
  int total_size = size1 + size2;
  int endpos = startpos + range;

  /* Check for out-of-range STARTPOS.  */
  if (startpos < 0 || startpos > total_size)
    return -1;

  /* Fix up RANGE if it might eventually take us outside
     the virtual concatenation of STRING1 and STRING2.
     Make sure we won't move STARTPOS below 0 or above TOTAL_SIZE.  */
  if (endpos < 0)
    range = 0 - startpos;
  else if (endpos > total_size)
    range = total_size - startpos;

  /* If the search isn't to be a backwards one, don't waste time in a
     search for a pattern that must be anchored.  */
  if (bufp->used > 0 && range > 0
      && ((re_opcode_t) bufp->buffer[0] == begbuf
	  /* `begline' is like `begbuf' if it cannot match at newlines.  */
	  || ((re_opcode_t) bufp->buffer[0] == begline
	      && !bufp->newline_anchor)))
    {
      if (startpos > 0)
	return -1;
      else
	range = 1;
    }

#ifdef emacs
  /* In a forward search for something that starts with \=.
     don't keep searching past point.  */
  if (bufp->used > 0 && (re_opcode_t) bufp->buffer[0] == at_dot && range > 0)
    {
      range = PT - startpos;
      if (range <= 0)
	return -1;
    }
#endif /* emacs */

  /* Update the fastmap now if not correct already.  */
  if (fastmap && !bufp->fastmap_accurate)
    if (re_compile_fastmap (bufp) == -2)
      return -2;

  /* Loop through the string, looking for a place to start matching.  */
  for (;;)
    {
      /* If a fastmap is supplied, skip quickly over characters that
         cannot be the start of a match.  If the pattern can match the
         null string, however, we don't need to skip characters; we want
         the first null string.  */
      if (fastmap && startpos < total_size && !bufp->can_be_null)
	{
	  if (range > 0)	/* Searching forwards.  */
	    {
	      register const char *d;
	      register int lim = 0;
	      int irange = range;

              if (startpos < size1 && startpos + range >= size1)
                lim = range - (size1 - startpos);

	      d = (startpos >= size1 ? string2 - size1 : string1) + startpos;

              /* Written out as an if-else to avoid testing `translate'
                 inside the loop.  */
	      if (translate)
                while (range > lim
                       && !fastmap[(unsigned char)
				   translate[(unsigned char) *d++]])
                  range--;
	      else
                while (range > lim && !fastmap[(unsigned char) *d++])
                  range--;

	      startpos += irange - range;
	    }
	  else				/* Searching backwards.  */
	    {
	      register char c = (size1 == 0 || startpos >= size1
                                 ? string2[startpos - size1]
                                 : string1[startpos]);

	      if (!fastmap[(unsigned char) TRANSLATE (c)])
		goto advance;
	    }
	}

      /* If can't match the null string, and that's all we have left, fail.  */
      if (range >= 0 && startpos == total_size && fastmap
          && !bufp->can_be_null)
	return -1;

      val = re_match_2_internal (bufp, string1, size1, string2, size2,
				 startpos, regs, stop);
#ifndef REGEX_MALLOC
# ifdef C_ALLOCA
      alloca (0);
# endif
#endif

      if (val >= 0)
	return startpos;

      if (val == -2)
	return -2;

    advance:
      if (!range)
        break;
      else if (range > 0)
        {
          range--;
          startpos++;
        }
      else
        {
          range++;
          startpos--;
        }
    }
  return -1;
} /* re_search_2 */
#ifdef _LIBC
weak_alias (__re_search_2, re_search_2)
#endif

/* This converts PTR, a pointer into one of the search strings `string1'
   and `string2' into an offset from the beginning of that string.  */
#define POINTER_TO_OFFSET(ptr)			\
  (FIRST_STRING_P (ptr)				\
   ? ((regoff_t) ((ptr) - string1))		\
   : ((regoff_t) ((ptr) - string2 + size1)))

/* Macros for dealing with the split strings in re_match_2.  */

#define MATCHING_IN_FIRST_STRING  (dend == end_match_1)

/* Call before fetching a character with *d.  This switches over to
   string2 if necessary.  */
#define PREFETCH()							\
  while (d == dend)						    	\
    {									\
      /* End of string2 => fail.  */					\
      if (dend == end_match_2) 						\
        goto fail;							\
      /* End of string1 => advance to string2.  */ 			\
      d = string2;						        \
      dend = end_match_2;						\
    }


/* Test if at very beginning or at very end of the virtual concatenation
   of `string1' and `string2'.  If only one string, it's `string2'.  */
#define AT_STRINGS_BEG(d) ((d) == (size1 ? string1 : string2) || !size2)
#define AT_STRINGS_END(d) ((d) == end2)


/* Test if D points to a character which is word-constituent.  We have
   two special cases to check for: if past the end of string1, look at
   the first character in string2; and if before the beginning of
   string2, look at the last character in string1.  */
#define WORDCHAR_P(d)							\
  (SYNTAX ((d) == end1 ? *string2					\
           : (d) == string2 - 1 ? *(end1 - 1) : *(d))			\
   == Sword)

/* Disabled due to a compiler bug -- see comment at case wordbound */
#if 0
/* Test if the character before D and the one at D differ with respect
   to being word-constituent.  */
#define AT_WORD_BOUNDARY(d)						\
  (AT_STRINGS_BEG (d) || AT_STRINGS_END (d)				\
   || WORDCHAR_P (d - 1) != WORDCHAR_P (d))
#endif

/* Free everything we malloc.  */
#ifdef MATCH_MAY_ALLOCATE
# define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL
# define FREE_VARIABLES()						\
  do {									\
    REGEX_FREE_STACK (fail_stack.stack);				\
    FREE_VAR (regstart);						\
    FREE_VAR (regend);							\
    FREE_VAR (old_regstart);						\
    FREE_VAR (old_regend);						\
    FREE_VAR (best_regstart);						\
    FREE_VAR (best_regend);						\
    FREE_VAR (reg_info);						\
    FREE_VAR (reg_dummy);						\
    FREE_VAR (reg_info_dummy);						\
  } while (0)
#else
# define FREE_VARIABLES() ((void)0) /* Do nothing!  But inhibit gcc warning. */
#endif /* not MATCH_MAY_ALLOCATE */

/* These values must meet several constraints.  They must not be valid
   register values; since we have a limit of 255 registers (because
   we use only one byte in the pattern for the register number), we can
   use numbers larger than 255.  They must differ by 1, because of
   NUM_FAILURE_ITEMS above.  And the value for the lowest register must
   be larger than the value for the highest register, so we do not try
   to actually save any registers when none are active.  */
#define NO_HIGHEST_ACTIVE_REG (1 << BYTEWIDTH)
#define NO_LOWEST_ACTIVE_REG (NO_HIGHEST_ACTIVE_REG + 1)

/* Matching routines.  */

#ifndef emacs   /* Emacs never uses this.  */
/* re_match is like re_match_2 except it takes only a single string.  */

int
re_match (bufp, string, size, pos, regs)
     struct re_pattern_buffer *bufp;
     const char *string;
     int size, pos;
     struct re_registers *regs;
{
  int result = re_match_2_internal (bufp, NULL, 0, string, size,
				    pos, regs, size);
# ifndef REGEX_MALLOC
#  ifdef C_ALLOCA
  alloca (0);
#  endif
# endif
  return result;
}
# ifdef _LIBC
weak_alias (__re_match, re_match)
# endif
#endif /* not emacs */

static boolean group_match_null_string_p _RE_ARGS ((unsigned char **p,
						    unsigned char *end,
						register_info_type *reg_info));
static boolean alt_match_null_string_p _RE_ARGS ((unsigned char *p,
						  unsigned char *end,
						register_info_type *reg_info));
static boolean common_op_match_null_string_p _RE_ARGS ((unsigned char **p,
							unsigned char *end,
						register_info_type *reg_info));
static int bcmp_translate _RE_ARGS ((const char *s1, const char *s2,
				     int len, char *translate));

/* re_match_2 matches the compiled pattern in BUFP against the
   the (virtual) concatenation of STRING1 and STRING2 (of length SIZE1
   and SIZE2, respectively).  We start matching at POS, and stop
   matching at STOP.

   If REGS is non-null and the `no_sub' field of BUFP is nonzero, we
   store offsets for the substring each group matched in REGS.  See the
   documentation for exactly how many groups we fill.

   We return -1 if no match, -2 if an internal error (such as the
   failure stack overflowing).  Otherwise, we return the length of the
   matched substring.  */

int
re_match_2 (bufp, string1, size1, string2, size2, pos, regs, stop)
     struct re_pattern_buffer *bufp;
     const char *string1, *string2;
     int size1, size2;
     int pos;
     struct re_registers *regs;
     int stop;
{
  int result = re_match_2_internal (bufp, string1, size1, string2, size2,
				    pos, regs, stop);
#ifndef REGEX_MALLOC
# ifdef C_ALLOCA
  alloca (0);
# endif
#endif
  return result;
}
#ifdef _LIBC
weak_alias (__re_match_2, re_match_2)
#endif

/* This is a separate function so that we can force an alloca cleanup
   afterwards.  */
static int
re_match_2_internal (bufp, string1, size1, string2, size2, pos, regs, stop)
     struct re_pattern_buffer *bufp;
     const char *string1, *string2;
     int size1, size2;
     int pos;
     struct re_registers *regs;
     int stop;
{
  /* General temporaries.  */
  int mcnt;
  unsigned char *p1;

  /* Just past the end of the corresponding string.  */
  const char *end1, *end2;

  /* Pointers into string1 and string2, just past the last characters in
     each to consider matching.  */
  const char *end_match_1, *end_match_2;

  /* Where we are in the data, and the end of the current string.  */
  const char *d, *dend;

  /* Where we are in the pattern, and the end of the pattern.  */
  unsigned char *p = bufp->buffer;
  register unsigned char *pend = p + bufp->used;

  /* Mark the opcode just after a start_memory, so we can test for an
     empty subpattern when we get to the stop_memory.  */
  unsigned char *just_past_start_mem = 0;

  /* We use this to map every character in the string.  */
  RE_TRANSLATE_TYPE translate = bufp->translate;

  /* Failure point stack.  Each place that can handle a failure further
     down the line pushes a failure point on this stack.  It consists of
     restart, regend, and reg_info for all registers corresponding to
     the subexpressions we're currently inside, plus the number of such
     registers, and, finally, two char *'s.  The first char * is where
     to resume scanning the pattern; the second one is where to resume
     scanning the strings.  If the latter is zero, the failure point is
     a ``dummy''; if a failure happens and the failure point is a dummy,
     it gets discarded and the next next one is tried.  */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
  fail_stack_type fail_stack;
#endif
#ifdef DEBUG
  static unsigned failure_id = 0;
  unsigned nfailure_points_pushed = 0, nfailure_points_popped = 0;
#endif

#ifdef REL_ALLOC
  /* This holds the pointer to the failure stack, when
     it is allocated relocatably.  */
  fail_stack_elt_t *failure_stack_ptr;
#endif

  /* We fill all the registers internally, independent of what we
     return, for use in backreferences.  The number here includes
     an element for register zero.  */
  size_t num_regs = bufp->re_nsub + 1;

  /* The currently active registers.  */
  active_reg_t lowest_active_reg = NO_LOWEST_ACTIVE_REG;
  active_reg_t highest_active_reg = NO_HIGHEST_ACTIVE_REG;

  /* Information on the contents of registers. These are pointers into
     the input strings; they record just what was matched (on this
     attempt) by a subexpression part of the pattern, that is, the
     regnum-th regstart pointer points to where in the pattern we began
     matching and the regnum-th regend points to right after where we
     stopped matching the regnum-th subexpression.  (The zeroth register
     keeps track of what the whole pattern matches.)  */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
  const char **regstart, **regend;
#endif

  /* If a group that's operated upon by a repetition operator fails to
     match anything, then the register for its start will need to be
     restored because it will have been set to wherever in the string we
     are when we last see its open-group operator.  Similarly for a
     register's end.  */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
  const char **old_regstart, **old_regend;
#endif

  /* The is_active field of reg_info helps us keep track of which (possibly
     nested) subexpressions we are currently in. The matched_something
     field of reg_info[reg_num] helps us tell whether or not we have
     matched any of the pattern so far this time through the reg_num-th
     subexpression.  These two fields get reset each time through any
     loop their register is in.  */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, this is global.  */
  register_info_type *reg_info;
#endif

  /* The following record the register info as found in the above
     variables when we find a match better than any we've seen before.
     This happens as we backtrack through the failure points, which in
     turn happens only if we have not yet matched the entire string. */
  unsigned best_regs_set = false;
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
  const char **best_regstart, **best_regend;
#endif

  /* Logically, this is `best_regend[0]'.  But we don't want to have to
     allocate space for that if we're not allocating space for anything
     else (see below).  Also, we never need info about register 0 for
     any of the other register vectors, and it seems rather a kludge to
     treat `best_regend' differently than the rest.  So we keep track of
     the end of the best match so far in a separate variable.  We
     initialize this to NULL so that when we backtrack the first time
     and need to test it, it's not garbage.  */
  const char *match_end = NULL;

  /* This helps SET_REGS_MATCHED avoid doing redundant work.  */
  int set_regs_matched_done = 0;

  /* Used when we pop values we don't care about.  */
#ifdef MATCH_MAY_ALLOCATE /* otherwise, these are global.  */
  const char **reg_dummy;
  register_info_type *reg_info_dummy;
#endif

#ifdef DEBUG
  /* Counts the total number of registers pushed.  */
  unsigned num_regs_pushed = 0;
#endif

  DEBUG_PRINT1 ("\n\nEntering re_match_2.\n");

  INIT_FAIL_STACK ();

#ifdef MATCH_MAY_ALLOCATE
  /* Do not bother to initialize all the register variables if there are
     no groups in the pattern, as it takes a fair amount of time.  If
     there are groups, we include space for register 0 (the whole
     pattern), even though we never use it, since it simplifies the
     array indexing.  We should fix this.  */
  if (bufp->re_nsub)
    {
      regstart = REGEX_TALLOC (num_regs, const char *);
      regend = REGEX_TALLOC (num_regs, const char *);
      old_regstart = REGEX_TALLOC (num_regs, const char *);
      old_regend = REGEX_TALLOC (num_regs, const char *);
      best_regstart = REGEX_TALLOC (num_regs, const char *);
      best_regend = REGEX_TALLOC (num_regs, const char *);
      reg_info = REGEX_TALLOC (num_regs, register_info_type);
      reg_dummy = REGEX_TALLOC (num_regs, const char *);
      reg_info_dummy = REGEX_TALLOC (num_regs, register_info_type);

      if (!(regstart && regend && old_regstart && old_regend && reg_info
            && best_regstart && best_regend && reg_dummy && reg_info_dummy))
        {
          FREE_VARIABLES ();
          return -2;
        }
    }
  else
    {
      /* We must initialize all our variables to NULL, so that
         `FREE_VARIABLES' doesn't try to free them.  */
      regstart = regend = old_regstart = old_regend = best_regstart
        = best_regend = reg_dummy = NULL;
      reg_info = reg_info_dummy = (register_info_type *) NULL;
    }
#endif /* MATCH_MAY_ALLOCATE */

  /* The starting position is bogus.  */
  if (pos < 0 || pos > size1 + size2)
    {
      FREE_VARIABLES ();
      return -1;
    }

  /* Initialize subexpression text positions to -1 to mark ones that no
     start_memory/stop_memory has been seen for. Also initialize the
     register information struct.  */
  for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
    {
      regstart[mcnt] = regend[mcnt]
        = old_regstart[mcnt] = old_regend[mcnt] = REG_UNSET_VALUE;

      REG_MATCH_NULL_STRING_P (reg_info[mcnt]) = MATCH_NULL_UNSET_VALUE;
      IS_ACTIVE (reg_info[mcnt]) = 0;
      MATCHED_SOMETHING (reg_info[mcnt]) = 0;
      EVER_MATCHED_SOMETHING (reg_info[mcnt]) = 0;
    }

  /* We move `string1' into `string2' if the latter's empty -- but not if
     `string1' is null.  */
  if (size2 == 0 && string1 != NULL)
    {
      string2 = string1;
      size2 = size1;
      string1 = 0;
      size1 = 0;
    }
  end1 = string1 + size1;
  end2 = string2 + size2;

  /* Compute where to stop matching, within the two strings.  */
  if (stop <= size1)
    {
      end_match_1 = string1 + stop;
      end_match_2 = string2;
    }
  else
    {
      end_match_1 = end1;
      end_match_2 = string2 + stop - size1;
    }

  /* `p' scans through the pattern as `d' scans through the data.
     `dend' is the end of the input string that `d' points within.  `d'
     is advanced into the following input string whenever necessary, but
     this happens before fetching; therefore, at the beginning of the
     loop, `d' can be pointing at the end of a string, but it cannot
     equal `string2'.  */
  if (size1 > 0 && pos <= size1)
    {
      d = string1 + pos;
      dend = end_match_1;
    }
  else
    {
      d = string2 + pos - size1;
      dend = end_match_2;
    }

  DEBUG_PRINT1 ("The compiled pattern is:\n");
  DEBUG_PRINT_COMPILED_PATTERN (bufp, p, pend);
  DEBUG_PRINT1 ("The string to match is: `");
  DEBUG_PRINT_DOUBLE_STRING (d, string1, size1, string2, size2);
  DEBUG_PRINT1 ("'\n");

  /* This loops over pattern commands.  It exits by returning from the
     function if the match is complete, or it drops through if the match
     fails at this starting point in the input data.  */
  for (;;)
    {
#ifdef _LIBC
      DEBUG_PRINT2 ("\n%p: ", p);
#else
      DEBUG_PRINT2 ("\n0x%x: ", p);
#endif

      if (p == pend)
	{ /* End of pattern means we might have succeeded.  */
          DEBUG_PRINT1 ("end of pattern ... ");

	  /* If we haven't matched the entire string, and we want the
             longest match, try backtracking.  */
          if (d != end_match_2)
	    {
	      /* 1 if this match ends in the same string (string1 or string2)
		 as the best previous match.  */
	      boolean same_str_p = (FIRST_STRING_P (match_end)
				    == MATCHING_IN_FIRST_STRING);
	      /* 1 if this match is the best seen so far.  */
	      boolean best_match_p;

	      /* AIX compiler got confused when this was combined
		 with the previous declaration.  */
	      if (same_str_p)
		best_match_p = d > match_end;
	      else
		best_match_p = !MATCHING_IN_FIRST_STRING;

              DEBUG_PRINT1 ("backtracking.\n");

              if (!FAIL_STACK_EMPTY ())
                { /* More failure points to try.  */

                  /* If exceeds best match so far, save it.  */
                  if (!best_regs_set || best_match_p)
                    {
                      best_regs_set = true;
                      match_end = d;

                      DEBUG_PRINT1 ("\nSAVING match as best so far.\n");

                      for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
                        {
                          best_regstart[mcnt] = regstart[mcnt];
                          best_regend[mcnt] = regend[mcnt];
                        }
                    }
                  goto fail;
                }

              /* If no failure points, don't restore garbage.  And if
                 last match is real best match, don't restore second
                 best one. */
              else if (best_regs_set && !best_match_p)
                {
  	        restore_best_regs:
                  /* Restore best match.  It may happen that `dend ==
                     end_match_1' while the restored d is in string2.
                     For example, the pattern `x.*y.*z' against the
                     strings `x-' and `y-z-', if the two strings are
                     not consecutive in memory.  */
                  DEBUG_PRINT1 ("Restoring best registers.\n");

                  d = match_end;
                  dend = ((d >= string1 && d <= end1)
		           ? end_match_1 : end_match_2);

		  for (mcnt = 1; (unsigned) mcnt < num_regs; mcnt++)
		    {
		      regstart[mcnt] = best_regstart[mcnt];
		      regend[mcnt] = best_regend[mcnt];
		    }
                }
            } /* d != end_match_2 */

	succeed_label:
          DEBUG_PRINT1 ("Accepting match.\n");

          /* If caller wants register contents data back, do it.  */
          if (regs && !bufp->no_sub)
	    {
              /* Have the register data arrays been allocated?  */
              if (bufp->regs_allocated == REGS_UNALLOCATED)
                { /* No.  So allocate them with malloc.  We need one
                     extra element beyond `num_regs' for the `-1' marker
                     GNU code uses.  */
                  regs->num_regs = MAX (RE_NREGS, num_regs + 1);
                  regs->start = TALLOC (regs->num_regs, regoff_t);
                  regs->end = TALLOC (regs->num_regs, regoff_t);
                  if (regs->start == NULL || regs->end == NULL)
		    {
		      FREE_VARIABLES ();
		      return -2;
		    }
                  bufp->regs_allocated = REGS_REALLOCATE;
                }
              else if (bufp->regs_allocated == REGS_REALLOCATE)
                { /* Yes.  If we need more elements than were already
                     allocated, reallocate them.  If we need fewer, just
                     leave it alone.  */
                  if (regs->num_regs < num_regs + 1)
                    {
                      regs->num_regs = num_regs + 1;
                      RETALLOC (regs->start, regs->num_regs, regoff_t);
                      RETALLOC (regs->end, regs->num_regs, regoff_t);
                      if (regs->start == NULL || regs->end == NULL)
			{
			  FREE_VARIABLES ();
			  return -2;
			}
                    }
                }
              else
		{
		  /* These braces fend off a "empty body in an else-statement"
		     warning under GCC when assert expands to nothing.  */
		  assert (bufp->regs_allocated == REGS_FIXED);
		}

              /* Convert the pointer data in `regstart' and `regend' to
                 indices.  Register zero has to be set differently,
                 since we haven't kept track of any info for it.  */
              if (regs->num_regs > 0)
                {
                  regs->start[0] = pos;
                  regs->end[0] = (MATCHING_IN_FIRST_STRING
				  ? ((regoff_t) (d - string1))
			          : ((regoff_t) (d - string2 + size1)));
                }

              /* Go through the first `min (num_regs, regs->num_regs)'
                 registers, since that is all we initialized.  */
	      for (mcnt = 1; (unsigned) mcnt < MIN (num_regs, regs->num_regs);
		   mcnt++)
		{
                  if (REG_UNSET (regstart[mcnt]) || REG_UNSET (regend[mcnt]))
                    regs->start[mcnt] = regs->end[mcnt] = -1;
                  else
                    {
		      regs->start[mcnt]
			= (regoff_t) POINTER_TO_OFFSET (regstart[mcnt]);
                      regs->end[mcnt]
			= (regoff_t) POINTER_TO_OFFSET (regend[mcnt]);
                    }
		}

              /* If the regs structure we return has more elements than
                 were in the pattern, set the extra elements to -1.  If
                 we (re)allocated the registers, this is the case,
                 because we always allocate enough to have at least one
                 -1 at the end.  */
              for (mcnt = num_regs; (unsigned) mcnt < regs->num_regs; mcnt++)
                regs->start[mcnt] = regs->end[mcnt] = -1;
	    } /* regs && !bufp->no_sub */

          DEBUG_PRINT4 ("%u failure points pushed, %u popped (%u remain).\n",
                        nfailure_points_pushed, nfailure_points_popped,
                        nfailure_points_pushed - nfailure_points_popped);
          DEBUG_PRINT2 ("%u registers pushed.\n", num_regs_pushed);

          mcnt = d - pos - (MATCHING_IN_FIRST_STRING
			    ? string1
			    : string2 - size1);

          DEBUG_PRINT2 ("Returning %d from re_match_2.\n", mcnt);

          FREE_VARIABLES ();
          return mcnt;
        }

      /* Otherwise match next pattern command.  */
      switch (SWITCH_ENUM_CAST ((re_opcode_t) *p++))
	{
        /* Ignore these.  Used to ignore the n of succeed_n's which
           currently have n == 0.  */
        case no_op:
          DEBUG_PRINT1 ("EXECUTING no_op.\n");
          break;

	case succeed:
          DEBUG_PRINT1 ("EXECUTING succeed.\n");
	  goto succeed_label;

        /* Match the next n pattern characters exactly.  The following
           byte in the pattern defines n, and the n bytes after that
           are the characters to match.  */
	case exactn:
	  mcnt = *p++;
          DEBUG_PRINT2 ("EXECUTING exactn %d.\n", mcnt);

          /* This is written out as an if-else so we don't waste time
             testing `translate' inside the loop.  */
          if (translate)
	    {
	      do
		{
		  PREFETCH ();
		  if ((unsigned char) translate[(unsigned char) *d++]
		      != (unsigned char) *p++)
                    goto fail;
		}
	      while (--mcnt);
	    }
	  else
	    {
	      do
		{
		  PREFETCH ();
		  if (*d++ != (char) *p++) goto fail;
		}
	      while (--mcnt);
	    }
	  SET_REGS_MATCHED ();
          break;


        /* Match any character except possibly a newline or a null.  */
	case anychar:
          DEBUG_PRINT1 ("EXECUTING anychar.\n");

          PREFETCH ();

          if ((!(bufp->syntax & RE_DOT_NEWLINE) && TRANSLATE (*d) == '\n')
              || (bufp->syntax & RE_DOT_NOT_NULL && TRANSLATE (*d) == '\000'))
	    goto fail;

          SET_REGS_MATCHED ();
          DEBUG_PRINT2 ("  Matched `%d'.\n", *d);
          d++;
	  break;


	case charset:
	case charset_not:
	  {
	    register unsigned char c;
	    boolean not = (re_opcode_t) *(p - 1) == charset_not;

            DEBUG_PRINT2 ("EXECUTING charset%s.\n", not ? "_not" : "");

	    PREFETCH ();
	    c = TRANSLATE (*d); /* The character to match.  */

            /* Cast to `unsigned' instead of `unsigned char' in case the
               bit list is a full 32 bytes long.  */
	    if (c < (unsigned) (*p * BYTEWIDTH)
		&& p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
	      not = !not;

	    p += 1 + *p;

	    if (!not) goto fail;

	    SET_REGS_MATCHED ();
            d++;
	    break;
	  }


        /* The beginning of a group is represented by start_memory.
           The arguments are the register number in the next byte, and the
           number of groups inner to this one in the next.  The text
           matched within the group is recorded (in the internal
           registers data structure) under the register number.  */
        case start_memory:
	  DEBUG_PRINT3 ("EXECUTING start_memory %d (%d):\n", *p, p[1]);

          /* Find out if this group can match the empty string.  */
	  p1 = p;		/* To send to group_match_null_string_p.  */

          if (REG_MATCH_NULL_STRING_P (reg_info[*p]) == MATCH_NULL_UNSET_VALUE)
            REG_MATCH_NULL_STRING_P (reg_info[*p])
              = group_match_null_string_p (&p1, pend, reg_info);

          /* Save the position in the string where we were the last time
             we were at this open-group operator in case the group is
             operated upon by a repetition operator, e.g., with `(a*)*b'
             against `ab'; then we want to ignore where we are now in
             the string in case this attempt to match fails.  */
          old_regstart[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
                             ? REG_UNSET (regstart[*p]) ? d : regstart[*p]
                             : regstart[*p];
	  DEBUG_PRINT2 ("  old_regstart: %d\n",
			 POINTER_TO_OFFSET (old_regstart[*p]));

          regstart[*p] = d;
	  DEBUG_PRINT2 ("  regstart: %d\n", POINTER_TO_OFFSET (regstart[*p]));

          IS_ACTIVE (reg_info[*p]) = 1;
          MATCHED_SOMETHING (reg_info[*p]) = 0;

	  /* Clear this whenever we change the register activity status.  */
	  set_regs_matched_done = 0;

          /* This is the new highest active register.  */
          highest_active_reg = *p;

          /* If nothing was active before, this is the new lowest active
             register.  */
          if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
            lowest_active_reg = *p;

          /* Move past the register number and inner group count.  */
          p += 2;
	  just_past_start_mem = p;

          break;


        /* The stop_memory opcode represents the end of a group.  Its
           arguments are the same as start_memory's: the register
           number, and the number of inner groups.  */
	case stop_memory:
	  DEBUG_PRINT3 ("EXECUTING stop_memory %d (%d):\n", *p, p[1]);

          /* We need to save the string position the last time we were at
             this close-group operator in case the group is operated
             upon by a repetition operator, e.g., with `((a*)*(b*)*)*'
             against `aba'; then we want to ignore where we are now in
             the string in case this attempt to match fails.  */
          old_regend[*p] = REG_MATCH_NULL_STRING_P (reg_info[*p])
                           ? REG_UNSET (regend[*p]) ? d : regend[*p]
			   : regend[*p];
	  DEBUG_PRINT2 ("      old_regend: %d\n",
			 POINTER_TO_OFFSET (old_regend[*p]));

          regend[*p] = d;
	  DEBUG_PRINT2 ("      regend: %d\n", POINTER_TO_OFFSET (regend[*p]));

          /* This register isn't active anymore.  */
          IS_ACTIVE (reg_info[*p]) = 0;

	  /* Clear this whenever we change the register activity status.  */
	  set_regs_matched_done = 0;

          /* If this was the only register active, nothing is active
             anymore.  */
          if (lowest_active_reg == highest_active_reg)
            {
              lowest_active_reg = NO_LOWEST_ACTIVE_REG;
              highest_active_reg = NO_HIGHEST_ACTIVE_REG;
            }
          else
            { /* We must scan for the new highest active register, since
                 it isn't necessarily one less than now: consider
                 (a(b)c(d(e)f)g).  When group 3 ends, after the f), the
                 new highest active register is 1.  */
              unsigned char r = *p - 1;
              while (r > 0 && !IS_ACTIVE (reg_info[r]))
                r--;

              /* If we end up at register zero, that means that we saved
                 the registers as the result of an `on_failure_jump', not
                 a `start_memory', and we jumped to past the innermost
                 `stop_memory'.  For example, in ((.)*) we save
                 registers 1 and 2 as a result of the *, but when we pop
                 back to the second ), we are at the stop_memory 1.
                 Thus, nothing is active.  */
	      if (r == 0)
                {
                  lowest_active_reg = NO_LOWEST_ACTIVE_REG;
                  highest_active_reg = NO_HIGHEST_ACTIVE_REG;
                }
              else
                highest_active_reg = r;
            }

          /* If just failed to match something this time around with a
             group that's operated on by a repetition operator, try to
             force exit from the ``loop'', and restore the register
             information for this group that we had before trying this
             last match.  */
          if ((!MATCHED_SOMETHING (reg_info[*p])
               || just_past_start_mem == p - 1)
	      && (p + 2) < pend)
            {
              boolean is_a_jump_n = false;

              p1 = p + 2;
              mcnt = 0;
              switch ((re_opcode_t) *p1++)
                {
                  case jump_n:
		    is_a_jump_n = true;
                  case pop_failure_jump:
		  case maybe_pop_jump:
		  case jump:
		  case dummy_failure_jump:
                    EXTRACT_NUMBER_AND_INCR (mcnt, p1);
		    if (is_a_jump_n)
		      p1 += 2;
                    break;

                  default:
                    /* do nothing */ ;
                }
	      p1 += mcnt;

              /* If the next operation is a jump backwards in the pattern
	         to an on_failure_jump right before the start_memory
                 corresponding to this stop_memory, exit from the loop
                 by forcing a failure after pushing on the stack the
                 on_failure_jump's jump in the pattern, and d.  */
              if (mcnt < 0 && (re_opcode_t) *p1 == on_failure_jump
                  && (re_opcode_t) p1[3] == start_memory && p1[4] == *p)
		{
                  /* If this group ever matched anything, then restore
                     what its registers were before trying this last
                     failed match, e.g., with `(a*)*b' against `ab' for
                     regstart[1], and, e.g., with `((a*)*(b*)*)*'
                     against `aba' for regend[3].

                     Also restore the registers for inner groups for,
                     e.g., `((a*)(b*))*' against `aba' (register 3 would
                     otherwise get trashed).  */

                  if (EVER_MATCHED_SOMETHING (reg_info[*p]))
		    {
		      unsigned r;

                      EVER_MATCHED_SOMETHING (reg_info[*p]) = 0;

		      /* Restore this and inner groups' (if any) registers.  */
                      for (r = *p; r < (unsigned) *p + (unsigned) *(p + 1);
			   r++)
                        {
                          regstart[r] = old_regstart[r];

                          /* xx why this test?  */
                          if (old_regend[r] >= regstart[r])
                            regend[r] = old_regend[r];
                        }
                    }
		  p1++;
                  EXTRACT_NUMBER_AND_INCR (mcnt, p1);
                  PUSH_FAILURE_POINT (p1 + mcnt, d, -2);

                  goto fail;
                }
            }

          /* Move past the register number and the inner group count.  */
          p += 2;
          break;


	/* \<digit> has been turned into a `duplicate' command which is
           followed by the numeric value of <digit> as the register number.  */
        case duplicate:
	  {
	    register const char *d2, *dend2;
	    int regno = *p++;   /* Get which register to match against.  */
	    DEBUG_PRINT2 ("EXECUTING duplicate %d.\n", regno);

	    /* Can't back reference a group which we've never matched.  */
            if (REG_UNSET (regstart[regno]) || REG_UNSET (regend[regno]))
              goto fail;

            /* Where in input to try to start matching.  */
            d2 = regstart[regno];

            /* Where to stop matching; if both the place to start and
               the place to stop matching are in the same string, then
               set to the place to stop, otherwise, for now have to use
               the end of the first string.  */

            dend2 = ((FIRST_STRING_P (regstart[regno])
		      == FIRST_STRING_P (regend[regno]))
		     ? regend[regno] : end_match_1);
	    for (;;)
	      {
		/* If necessary, advance to next segment in register
                   contents.  */
		while (d2 == dend2)
		  {
		    if (dend2 == end_match_2) break;
		    if (dend2 == regend[regno]) break;

                    /* End of string1 => advance to string2. */
                    d2 = string2;
                    dend2 = regend[regno];
		  }
		/* At end of register contents => success */
		if (d2 == dend2) break;

		/* If necessary, advance to next segment in data.  */
		PREFETCH ();

		/* How many characters left in this segment to match.  */
		mcnt = dend - d;

		/* Want how many consecutive characters we can match in
                   one shot, so, if necessary, adjust the count.  */
                if (mcnt > dend2 - d2)
		  mcnt = dend2 - d2;

		/* Compare that many; failure if mismatch, else move
                   past them.  */
		if (translate
                    ? bcmp_translate (d, d2, mcnt, translate)
                    : memcmp (d, d2, mcnt))
		  goto fail;
		d += mcnt, d2 += mcnt;

		/* Do this because we've match some characters.  */
		SET_REGS_MATCHED ();
	      }
	  }
	  break;


        /* begline matches the empty string at the beginning of the string
           (unless `not_bol' is set in `bufp'), and, if
           `newline_anchor' is set, after newlines.  */
	case begline:
          DEBUG_PRINT1 ("EXECUTING begline.\n");

          if (AT_STRINGS_BEG (d))
            {
              if (!bufp->not_bol) break;
            }
          else if (d[-1] == '\n' && bufp->newline_anchor)
            {
              break;
            }
          /* In all other cases, we fail.  */
          goto fail;


        /* endline is the dual of begline.  */
	case endline:
          DEBUG_PRINT1 ("EXECUTING endline.\n");

          if (AT_STRINGS_END (d))
            {
              if (!bufp->not_eol) break;
            }

          /* We have to ``prefetch'' the next character.  */
          else if ((d == end1 ? *string2 : *d) == '\n'
                   && bufp->newline_anchor)
            {
              break;
            }
          goto fail;


	/* Match at the very beginning of the data.  */
        case begbuf:
          DEBUG_PRINT1 ("EXECUTING begbuf.\n");
          if (AT_STRINGS_BEG (d))
            break;
          goto fail;


	/* Match at the very end of the data.  */
        case endbuf:
          DEBUG_PRINT1 ("EXECUTING endbuf.\n");
	  if (AT_STRINGS_END (d))
	    break;
          goto fail;


        /* on_failure_keep_string_jump is used to optimize `.*\n'.  It
           pushes NULL as the value for the string on the stack.  Then
           `pop_failure_point' will keep the current value for the
           string, instead of restoring it.  To see why, consider
           matching `foo\nbar' against `.*\n'.  The .* matches the foo;
           then the . fails against the \n.  But the next thing we want
           to do is match the \n against the \n; if we restored the
           string value, we would be back at the foo.

           Because this is used only in specific cases, we don't need to
           check all the things that `on_failure_jump' does, to make
           sure the right things get saved on the stack.  Hence we don't
           share its code.  The only reason to push anything on the
           stack at all is that otherwise we would have to change
           `anychar's code to do something besides goto fail in this
           case; that seems worse than this.  */
        case on_failure_keep_string_jump:
          DEBUG_PRINT1 ("EXECUTING on_failure_keep_string_jump");

          EXTRACT_NUMBER_AND_INCR (mcnt, p);
#ifdef _LIBC
          DEBUG_PRINT3 (" %d (to %p):\n", mcnt, p + mcnt);
#else
          DEBUG_PRINT3 (" %d (to 0x%x):\n", mcnt, p + mcnt);
#endif

          PUSH_FAILURE_POINT (p + mcnt, NULL, -2);
          break;


	/* Uses of on_failure_jump:

           Each alternative starts with an on_failure_jump that points
           to the beginning of the next alternative.  Each alternative
           except the last ends with a jump that in effect jumps past
           the rest of the alternatives.  (They really jump to the
           ending jump of the following alternative, because tensioning
           these jumps is a hassle.)

           Repeats start with an on_failure_jump that points past both
           the repetition text and either the following jump or
           pop_failure_jump back to this on_failure_jump.  */
	case on_failure_jump:
        on_failure:
          DEBUG_PRINT1 ("EXECUTING on_failure_jump");

          EXTRACT_NUMBER_AND_INCR (mcnt, p);
#ifdef _LIBC
          DEBUG_PRINT3 (" %d (to %p)", mcnt, p + mcnt);
#else
          DEBUG_PRINT3 (" %d (to 0x%x)", mcnt, p + mcnt);
#endif

          /* If this on_failure_jump comes right before a group (i.e.,
             the original * applied to a group), save the information
             for that group and all inner ones, so that if we fail back
             to this point, the group's information will be correct.
             For example, in \(a*\)*\1, we need the preceding group,
             and in \(zz\(a*\)b*\)\2, we need the inner group.  */

          /* We can't use `p' to check ahead because we push
             a failure point to `p + mcnt' after we do this.  */
          p1 = p;

          /* We need to skip no_op's before we look for the
             start_memory in case this on_failure_jump is happening as
             the result of a completed succeed_n, as in \(a\)\{1,3\}b\1
             against aba.  */
          while (p1 < pend && (re_opcode_t) *p1 == no_op)
            p1++;

          if (p1 < pend && (re_opcode_t) *p1 == start_memory)
            {
              /* We have a new highest active register now.  This will
                 get reset at the start_memory we are about to get to,
                 but we will have saved all the registers relevant to
                 this repetition op, as described above.  */
              highest_active_reg = *(p1 + 1) + *(p1 + 2);
              if (lowest_active_reg == NO_LOWEST_ACTIVE_REG)
                lowest_active_reg = *(p1 + 1);
            }

          DEBUG_PRINT1 (":\n");
          PUSH_FAILURE_POINT (p + mcnt, d, -2);
          break;


        /* A smart repeat ends with `maybe_pop_jump'.
	   We change it to either `pop_failure_jump' or `jump'.  */
        case maybe_pop_jump:
          EXTRACT_NUMBER_AND_INCR (mcnt, p);
          DEBUG_PRINT2 ("EXECUTING maybe_pop_jump %d.\n", mcnt);
          {
	    register unsigned char *p2 = p;

            /* Compare the beginning of the repeat with what in the
               pattern follows its end. If we can establish that there
               is nothing that they would both match, i.e., that we
               would have to backtrack because of (as in, e.g., `a*a')
               then we can change to pop_failure_jump, because we'll
               never have to backtrack.

               This is not true in the case of alternatives: in
               `(a|ab)*' we do need to backtrack to the `ab' alternative
               (e.g., if the string was `ab').  But instead of trying to
               detect that here, the alternative has put on a dummy
               failure point which is what we will end up popping.  */

	    /* Skip over open/close-group commands.
	       If what follows this loop is a ...+ construct,
	       look at what begins its body, since we will have to
	       match at least one of that.  */
	    while (1)
	      {
		if (p2 + 2 < pend
		    && ((re_opcode_t) *p2 == stop_memory
			|| (re_opcode_t) *p2 == start_memory))
		  p2 += 3;
		else if (p2 + 6 < pend
			 && (re_opcode_t) *p2 == dummy_failure_jump)
		  p2 += 6;
		else
		  break;
	      }

	    p1 = p + mcnt;
	    /* p1[0] ... p1[2] are the `on_failure_jump' corresponding
	       to the `maybe_finalize_jump' of this case.  Examine what
	       follows.  */

            /* If we're at the end of the pattern, we can change.  */
            if (p2 == pend)
	      {
		/* Consider what happens when matching ":\(.*\)"
		   against ":/".  I don't really understand this code
		   yet.  */
  	        p[-3] = (unsigned char) pop_failure_jump;
                DEBUG_PRINT1
                  ("  End of pattern: change to `pop_failure_jump'.\n");
              }

            else if ((re_opcode_t) *p2 == exactn
		     || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
	      {
		register unsigned char c
                  = *p2 == (unsigned char) endline ? '\n' : p2[2];

                if ((re_opcode_t) p1[3] == exactn && p1[5] != c)
                  {
  		    p[-3] = (unsigned char) pop_failure_jump;
                    DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
                                  c, p1[5]);
                  }

		else if ((re_opcode_t) p1[3] == charset
			 || (re_opcode_t) p1[3] == charset_not)
		  {
		    int not = (re_opcode_t) p1[3] == charset_not;

		    if (c < (unsigned char) (p1[4] * BYTEWIDTH)
			&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
		      not = !not;

                    /* `not' is equal to 1 if c would match, which means
                        that we can't change to pop_failure_jump.  */
		    if (!not)
                      {
  		        p[-3] = (unsigned char) pop_failure_jump;
                        DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
                      }
		  }
	      }
            else if ((re_opcode_t) *p2 == charset)
	      {
#ifdef DEBUG
		register unsigned char c
                  = *p2 == (unsigned char) endline ? '\n' : p2[2];
#endif

#if 0
                if ((re_opcode_t) p1[3] == exactn
		    && ! ((int) p2[1] * BYTEWIDTH > (int) p1[5]
			  && (p2[2 + p1[5] / BYTEWIDTH]
			      & (1 << (p1[5] % BYTEWIDTH)))))
#else
                if ((re_opcode_t) p1[3] == exactn
		    && ! ((int) p2[1] * BYTEWIDTH > (int) p1[4]
			  && (p2[2 + p1[4] / BYTEWIDTH]
			      & (1 << (p1[4] % BYTEWIDTH)))))
#endif
                  {
  		    p[-3] = (unsigned char) pop_failure_jump;
                    DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
                                  c, p1[5]);
                  }

		else if ((re_opcode_t) p1[3] == charset_not)
		  {
		    int idx;
		    /* We win if the charset_not inside the loop
		       lists every character listed in the charset after.  */
		    for (idx = 0; idx < (int) p2[1]; idx++)
		      if (! (p2[2 + idx] == 0
			     || (idx < (int) p1[4]
				 && ((p2[2 + idx] & ~ p1[5 + idx]) == 0))))
			break;

		    if (idx == p2[1])
                      {
  		        p[-3] = (unsigned char) pop_failure_jump;
                        DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
                      }
		  }
		else if ((re_opcode_t) p1[3] == charset)
		  {
		    int idx;
		    /* We win if the charset inside the loop
		       has no overlap with the one after the loop.  */
		    for (idx = 0;
			 idx < (int) p2[1] && idx < (int) p1[4];
			 idx++)
		      if ((p2[2 + idx] & p1[5 + idx]) != 0)
			break;

		    if (idx == p2[1] || idx == p1[4])
                      {
  		        p[-3] = (unsigned char) pop_failure_jump;
                        DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
                      }
		  }
	      }
	  }
	  p -= 2;		/* Point at relative address again.  */
	  if ((re_opcode_t) p[-1] != pop_failure_jump)
	    {
	      p[-1] = (unsigned char) jump;
              DEBUG_PRINT1 ("  Match => jump.\n");
	      goto unconditional_jump;
	    }
        /* Note fall through.  */


	/* The end of a simple repeat has a pop_failure_jump back to
           its matching on_failure_jump, where the latter will push a
           failure point.  The pop_failure_jump takes off failure
           points put on by this pop_failure_jump's matching
           on_failure_jump; we got through the pattern to here from the
           matching on_failure_jump, so didn't fail.  */
        case pop_failure_jump:
          {
            /* We need to pass separate storage for the lowest and
               highest registers, even though we don't care about the
               actual values.  Otherwise, we will restore only one
               register from the stack, since lowest will == highest in
               `pop_failure_point'.  */
            active_reg_t dummy_low_reg, dummy_high_reg;
            unsigned char *pdummy;
            const char *sdummy;

            DEBUG_PRINT1 ("EXECUTING pop_failure_jump.\n");
            POP_FAILURE_POINT (sdummy, pdummy,
                               dummy_low_reg, dummy_high_reg,
                               reg_dummy, reg_dummy, reg_info_dummy);
          }
	  /* Note fall through.  */

	unconditional_jump:
#ifdef _LIBC
	  DEBUG_PRINT2 ("\n%p: ", p);
#else
	  DEBUG_PRINT2 ("\n0x%x: ", p);
#endif
          /* Note fall through.  */

        /* Unconditionally jump (without popping any failure points).  */
        case jump:
	  EXTRACT_NUMBER_AND_INCR (mcnt, p);	/* Get the amount to jump.  */
          DEBUG_PRINT2 ("EXECUTING jump %d ", mcnt);
	  p += mcnt;				/* Do the jump.  */
#ifdef _LIBC
          DEBUG_PRINT2 ("(to %p).\n", p);
#else
          DEBUG_PRINT2 ("(to 0x%x).\n", p);
#endif
	  break;


        /* We need this opcode so we can detect where alternatives end
           in `group_match_null_string_p' et al.  */
        case jump_past_alt:
          DEBUG_PRINT1 ("EXECUTING jump_past_alt.\n");
          goto unconditional_jump;


        /* Normally, the on_failure_jump pushes a failure point, which
           then gets popped at pop_failure_jump.  We will end up at
           pop_failure_jump, also, and with a pattern of, say, `a+', we
           are skipping over the on_failure_jump, so we have to push
           something meaningless for pop_failure_jump to pop.  */
        case dummy_failure_jump:
          DEBUG_PRINT1 ("EXECUTING dummy_failure_jump.\n");
          /* It doesn't matter what we push for the string here.  What
             the code at `fail' tests is the value for the pattern.  */
          PUSH_FAILURE_POINT (NULL, NULL, -2);
          goto unconditional_jump;


        /* At the end of an alternative, we need to push a dummy failure
           point in case we are followed by a `pop_failure_jump', because
           we don't want the failure point for the alternative to be
           popped.  For example, matching `(a|ab)*' against `aab'
           requires that we match the `ab' alternative.  */
        case push_dummy_failure:
          DEBUG_PRINT1 ("EXECUTING push_dummy_failure.\n");
          /* See comments just above at `dummy_failure_jump' about the
             two zeroes.  */
          PUSH_FAILURE_POINT (NULL, NULL, -2);
          break;

        /* Have to succeed matching what follows at least n times.
           After that, handle like `on_failure_jump'.  */
        case succeed_n:
          EXTRACT_NUMBER (mcnt, p + 2);
          DEBUG_PRINT2 ("EXECUTING succeed_n %d.\n", mcnt);

          assert (mcnt >= 0);
          /* Originally, this is how many times we HAVE to succeed.  */
          if (mcnt > 0)
            {
               mcnt--;
	       p += 2;
               STORE_NUMBER_AND_INCR (p, mcnt);
#ifdef _LIBC
               DEBUG_PRINT3 ("  Setting %p to %d.\n", p - 2, mcnt);
#else
               DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p - 2, mcnt);
#endif
            }
	  else if (mcnt == 0)
            {
#ifdef _LIBC
              DEBUG_PRINT2 ("  Setting two bytes from %p to no_op.\n", p+2);
#else
              DEBUG_PRINT2 ("  Setting two bytes from 0x%x to no_op.\n", p+2);
#endif
	      p[2] = (unsigned char) no_op;
              p[3] = (unsigned char) no_op;
              goto on_failure;
            }
          break;

        case jump_n:
          EXTRACT_NUMBER (mcnt, p + 2);
          DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);

          /* Originally, this is how many times we CAN jump.  */
          if (mcnt)
            {
               mcnt--;
               STORE_NUMBER (p + 2, mcnt);
#ifdef _LIBC
               DEBUG_PRINT3 ("  Setting %p to %d.\n", p + 2, mcnt);
#else
               DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p + 2, mcnt);
#endif
	       goto unconditional_jump;
            }
          /* If don't have to jump any more, skip over the rest of command.  */
	  else
	    p += 4;
          break;

	case set_number_at:
	  {
            DEBUG_PRINT1 ("EXECUTING set_number_at.\n");

            EXTRACT_NUMBER_AND_INCR (mcnt, p);
            p1 = p + mcnt;
            EXTRACT_NUMBER_AND_INCR (mcnt, p);
#ifdef _LIBC
            DEBUG_PRINT3 ("  Setting %p to %d.\n", p1, mcnt);
#else
            DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p1, mcnt);
#endif
	    STORE_NUMBER (p1, mcnt);
            break;
          }

#if 0
	/* The DEC Alpha C compiler 3.x generates incorrect code for the
	   test  WORDCHAR_P (d - 1) != WORDCHAR_P (d)  in the expansion of
	   AT_WORD_BOUNDARY, so this code is disabled.  Expanding the
	   macro and introducing temporary variables works around the bug.  */

	case wordbound:
	  DEBUG_PRINT1 ("EXECUTING wordbound.\n");
	  if (AT_WORD_BOUNDARY (d))
	    break;
	  goto fail;

	case notwordbound:
	  DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
	  if (AT_WORD_BOUNDARY (d))
	    goto fail;
	  break;
#else
	case wordbound:
	{
	  boolean prevchar, thischar;

	  DEBUG_PRINT1 ("EXECUTING wordbound.\n");
	  if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
	    break;

	  prevchar = WORDCHAR_P (d - 1);
	  thischar = WORDCHAR_P (d);
	  if (prevchar != thischar)
	    break;
	  goto fail;
	}

      case notwordbound:
	{
	  boolean prevchar, thischar;

	  DEBUG_PRINT1 ("EXECUTING notwordbound.\n");
	  if (AT_STRINGS_BEG (d) || AT_STRINGS_END (d))
	    goto fail;

	  prevchar = WORDCHAR_P (d - 1);
	  thischar = WORDCHAR_P (d);
	  if (prevchar != thischar)
	    goto fail;
	  break;
	}
#endif

	case wordbeg:
          DEBUG_PRINT1 ("EXECUTING wordbeg.\n");
	  if (WORDCHAR_P (d) && (AT_STRINGS_BEG (d) || !WORDCHAR_P (d - 1)))
	    break;
          goto fail;

	case wordend:
          DEBUG_PRINT1 ("EXECUTING wordend.\n");
	  if (!AT_STRINGS_BEG (d) && WORDCHAR_P (d - 1)
              && (!WORDCHAR_P (d) || AT_STRINGS_END (d)))
	    break;
          goto fail;

#ifdef emacs
  	case before_dot:
          DEBUG_PRINT1 ("EXECUTING before_dot.\n");
 	  if (PTR_CHAR_POS ((unsigned char *) d) >= point)
  	    goto fail;
  	  break;

  	case at_dot:
          DEBUG_PRINT1 ("EXECUTING at_dot.\n");
 	  if (PTR_CHAR_POS ((unsigned char *) d) != point)
  	    goto fail;
  	  break;

  	case after_dot:
          DEBUG_PRINT1 ("EXECUTING after_dot.\n");
          if (PTR_CHAR_POS ((unsigned char *) d) <= point)
  	    goto fail;
  	  break;

	case syntaxspec:
          DEBUG_PRINT2 ("EXECUTING syntaxspec %d.\n", mcnt);
	  mcnt = *p++;
	  goto matchsyntax;

        case wordchar:
          DEBUG_PRINT1 ("EXECUTING Emacs wordchar.\n");
	  mcnt = (int) Sword;
        matchsyntax:
	  PREFETCH ();
	  /* Can't use *d++ here; SYNTAX may be an unsafe macro.  */
	  d++;
	  if (SYNTAX (d[-1]) != (enum syntaxcode) mcnt)
	    goto fail;
          SET_REGS_MATCHED ();
	  break;

	case notsyntaxspec:
          DEBUG_PRINT2 ("EXECUTING notsyntaxspec %d.\n", mcnt);
	  mcnt = *p++;
	  goto matchnotsyntax;

        case notwordchar:
          DEBUG_PRINT1 ("EXECUTING Emacs notwordchar.\n");
	  mcnt = (int) Sword;
        matchnotsyntax:
	  PREFETCH ();
	  /* Can't use *d++ here; SYNTAX may be an unsafe macro.  */
	  d++;
	  if (SYNTAX (d[-1]) == (enum syntaxcode) mcnt)
	    goto fail;
	  SET_REGS_MATCHED ();
          break;

#else /* not emacs */
	case wordchar:
          DEBUG_PRINT1 ("EXECUTING non-Emacs wordchar.\n");
	  PREFETCH ();
          if (!WORDCHAR_P (d))
            goto fail;
	  SET_REGS_MATCHED ();
          d++;
	  break;

	case notwordchar:
          DEBUG_PRINT1 ("EXECUTING non-Emacs notwordchar.\n");
	  PREFETCH ();
	  if (WORDCHAR_P (d))
            goto fail;
          SET_REGS_MATCHED ();
          d++;
	  break;
#endif /* not emacs */

        default:
          abort ();
	}
      continue;  /* Successfully executed one pattern command; keep going.  */


    /* We goto here if a matching operation fails. */
    fail:
      if (!FAIL_STACK_EMPTY ())
	{ /* A restart point is known.  Restore to that state.  */
          DEBUG_PRINT1 ("\nFAIL:\n");
          POP_FAILURE_POINT (d, p,
                             lowest_active_reg, highest_active_reg,
                             regstart, regend, reg_info);

          /* If this failure point is a dummy, try the next one.  */
          if (!p)
	    goto fail;

          /* If we failed to the end of the pattern, don't examine *p.  */
	  assert (p <= pend);
          if (p < pend)
            {
              boolean is_a_jump_n = false;

              /* If failed to a backwards jump that's part of a repetition
                 loop, need to pop this failure point and use the next one.  */
              switch ((re_opcode_t) *p)
                {
                case jump_n:
                  is_a_jump_n = true;
                case maybe_pop_jump:
                case pop_failure_jump:
                case jump:
                  p1 = p + 1;
                  EXTRACT_NUMBER_AND_INCR (mcnt, p1);
                  p1 += mcnt;

                  if ((is_a_jump_n && (re_opcode_t) *p1 == succeed_n)
                      || (!is_a_jump_n
                          && (re_opcode_t) *p1 == on_failure_jump))
                    goto fail;
                  break;
                default:
                  /* do nothing */ ;
                }
            }

          if (d >= string1 && d <= end1)
	    dend = end_match_1;
        }
      else
        break;   /* Matching at this starting point really fails.  */
    } /* for (;;) */

  if (best_regs_set)
    goto restore_best_regs;

  FREE_VARIABLES ();

  return -1;         			/* Failure to match.  */
} /* re_match_2 */

/* Subroutine definitions for re_match_2.  */


/* We are passed P pointing to a register number after a start_memory.

   Return true if the pattern up to the corresponding stop_memory can
   match the empty string, and false otherwise.

   If we find the matching stop_memory, sets P to point to one past its number.
   Otherwise, sets P to an undefined byte less than or equal to END.

   We don't handle duplicates properly (yet).  */

static boolean
group_match_null_string_p (p, end, reg_info)
    unsigned char **p, *end;
    register_info_type *reg_info;
{
  int mcnt;
  /* Point to after the args to the start_memory.  */
  unsigned char *p1 = *p + 2;

  while (p1 < end)
    {
      /* Skip over opcodes that can match nothing, and return true or
	 false, as appropriate, when we get to one that can't, or to the
         matching stop_memory.  */

      switch ((re_opcode_t) *p1)
        {
        /* Could be either a loop or a series of alternatives.  */
        case on_failure_jump:
          p1++;
          EXTRACT_NUMBER_AND_INCR (mcnt, p1);

          /* If the next operation is not a jump backwards in the
	     pattern.  */

	  if (mcnt >= 0)
	    {
              /* Go through the on_failure_jumps of the alternatives,
                 seeing if any of the alternatives cannot match nothing.
                 The last alternative starts with only a jump,
                 whereas the rest start with on_failure_jump and end
                 with a jump, e.g., here is the pattern for `a|b|c':

                 /on_failure_jump/0/6/exactn/1/a/jump_past_alt/0/6
                 /on_failure_jump/0/6/exactn/1/b/jump_past_alt/0/3
                 /exactn/1/c

                 So, we have to first go through the first (n-1)
                 alternatives and then deal with the last one separately.  */


              /* Deal with the first (n-1) alternatives, which start
                 with an on_failure_jump (see above) that jumps to right
                 past a jump_past_alt.  */

              while ((re_opcode_t) p1[mcnt-3] == jump_past_alt)
                {
                  /* `mcnt' holds how many bytes long the alternative
                     is, including the ending `jump_past_alt' and
                     its number.  */

                  if (!alt_match_null_string_p (p1, p1 + mcnt - 3,
				                      reg_info))
                    return false;

                  /* Move to right after this alternative, including the
		     jump_past_alt.  */
                  p1 += mcnt;

                  /* Break if it's the beginning of an n-th alternative
                     that doesn't begin with an on_failure_jump.  */
                  if ((re_opcode_t) *p1 != on_failure_jump)
                    break;

		  /* Still have to check that it's not an n-th
		     alternative that starts with an on_failure_jump.  */
		  p1++;
                  EXTRACT_NUMBER_AND_INCR (mcnt, p1);
                  if ((re_opcode_t) p1[mcnt-3] != jump_past_alt)
                    {
		      /* Get to the beginning of the n-th alternative.  */
                      p1 -= 3;
                      break;
                    }
                }

              /* Deal with the last alternative: go back and get number
                 of the `jump_past_alt' just before it.  `mcnt' contains
                 the length of the alternative.  */
              EXTRACT_NUMBER (mcnt, p1 - 2);

              if (!alt_match_null_string_p (p1, p1 + mcnt, reg_info))
                return false;

              p1 += mcnt;	/* Get past the n-th alternative.  */
            } /* if mcnt > 0 */
          break;


        case stop_memory:
	  assert (p1[1] == **p);
          *p = p1 + 2;
          return true;


        default:
          if (!common_op_match_null_string_p (&p1, end, reg_info))
            return false;
        }
    } /* while p1 < end */

  return false;
} /* group_match_null_string_p */


/* Similar to group_match_null_string_p, but doesn't deal with alternatives:
   It expects P to be the first byte of a single alternative and END one
   byte past the last. The alternative can contain groups.  */

static boolean
alt_match_null_string_p (p, end, reg_info)
    unsigned char *p, *end;
    register_info_type *reg_info;
{
  int mcnt;
  unsigned char *p1 = p;

  while (p1 < end)
    {
      /* Skip over opcodes that can match nothing, and break when we get
         to one that can't.  */

      switch ((re_opcode_t) *p1)
        {
	/* It's a loop.  */
        case on_failure_jump:
          p1++;
          EXTRACT_NUMBER_AND_INCR (mcnt, p1);
          p1 += mcnt;
          break;

	default:
          if (!common_op_match_null_string_p (&p1, end, reg_info))
            return false;
        }
    }  /* while p1 < end */

  return true;
} /* alt_match_null_string_p */


/* Deals with the ops common to group_match_null_string_p and
   alt_match_null_string_p.

   Sets P to one after the op and its arguments, if any.  */

static boolean
common_op_match_null_string_p (p, end, reg_info)
    unsigned char **p, *end;
    register_info_type *reg_info;
{
  int mcnt;
  boolean ret;
  int reg_no;
  unsigned char *p1 = *p;

  switch ((re_opcode_t) *p1++)
    {
    case no_op:
    case begline:
    case endline:
    case begbuf:
    case endbuf:
    case wordbeg:
    case wordend:
    case wordbound:
    case notwordbound:
#ifdef emacs
    case before_dot:
    case at_dot:
    case after_dot:
#endif
      break;

    case start_memory:
      reg_no = *p1;
      assert (reg_no > 0 && reg_no <= MAX_REGNUM);
      ret = group_match_null_string_p (&p1, end, reg_info);

      /* Have to set this here in case we're checking a group which
         contains a group and a back reference to it.  */

      if (REG_MATCH_NULL_STRING_P (reg_info[reg_no]) == MATCH_NULL_UNSET_VALUE)
        REG_MATCH_NULL_STRING_P (reg_info[reg_no]) = ret;

      if (!ret)
        return false;
      break;

    /* If this is an optimized succeed_n for zero times, make the jump.  */
    case jump:
      EXTRACT_NUMBER_AND_INCR (mcnt, p1);
      if (mcnt >= 0)
        p1 += mcnt;
      else
        return false;
      break;

    case succeed_n:
      /* Get to the number of times to succeed.  */
      p1 += 2;
      EXTRACT_NUMBER_AND_INCR (mcnt, p1);

      if (mcnt == 0)
        {
          p1 -= 4;
          EXTRACT_NUMBER_AND_INCR (mcnt, p1);
          p1 += mcnt;
        }
      else
        return false;
      break;

    case duplicate:
      if (!REG_MATCH_NULL_STRING_P (reg_info[*p1]))
        return false;
      break;

    case set_number_at:
      p1 += 4;

    default:
      /* All other opcodes mean we cannot match the empty string.  */
      return false;
  }

  *p = p1;
  return true;
} /* common_op_match_null_string_p */


/* Return zero if TRANSLATE[S1] and TRANSLATE[S2] are identical for LEN
   bytes; nonzero otherwise.  */

static int
bcmp_translate (s1, s2, len, translate)
     const char *s1, *s2;
     register int len;
     RE_TRANSLATE_TYPE translate;
{
  register const unsigned char *p1 = (const unsigned char *) s1;
  register const unsigned char *p2 = (const unsigned char *) s2;
  while (len)
    {
      if (translate[*p1++] != translate[*p2++]) return 1;
      len--;
    }
  return 0;
}

/* Entry points for GNU code.  */

/* re_compile_pattern is the GNU regular expression compiler: it
   compiles PATTERN (of length SIZE) and puts the result in BUFP.
   Returns 0 if the pattern was valid, otherwise an error string.

   Assumes the `allocated' (and perhaps `buffer') and `translate' fields
   are set in BUFP on entry.

   We call regex_compile to do the actual compilation.  */

const char *
re_compile_pattern (pattern, length, bufp)
     const char *pattern;
     size_t length;
     struct re_pattern_buffer *bufp;
{
  reg_errcode_t ret;

  /* GNU code is written to assume at least RE_NREGS registers will be set
     (and at least one extra will be -1).  */
  bufp->regs_allocated = REGS_UNALLOCATED;

  /* And GNU code determines whether or not to get register information
     by passing null for the REGS argument to re_match, etc., not by
     setting no_sub.  */
  bufp->no_sub = 0;

  /* Match anchors at newline.  */
  bufp->newline_anchor = 1;

  ret = regex_compile (pattern, length, re_syntax_options, bufp);

  if (!ret)
    return NULL;
  return gettext (re_error_msgid[(int) ret]);
}
#ifdef _LIBC
weak_alias (__re_compile_pattern, re_compile_pattern)
#endif

/* Entry points compatible with 4.2 BSD regex library.  We don't define
   them unless specifically requested.  */

#if defined _REGEX_RE_COMP || defined _LIBC

/* BSD has one and only one pattern buffer.  */
static struct re_pattern_buffer re_comp_buf;

char *
#ifdef _LIBC
/* Make these definitions weak in libc, so POSIX programs can redefine
   these names if they don't use our functions, and still use
   regcomp/regexec below without link errors.  */
weak_function
#endif
re_comp (s)
    const char *s;
{
  reg_errcode_t ret;

  if (!s)
    {
      if (!re_comp_buf.buffer)
	return gettext ("No previous regular expression");
      return 0;
    }

  if (!re_comp_buf.buffer)
    {
      re_comp_buf.buffer = (unsigned char *) malloc (200);
      if (re_comp_buf.buffer == NULL)
        return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
      re_comp_buf.allocated = 200;

      re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH);
      if (re_comp_buf.fastmap == NULL)
	return (char *) gettext (re_error_msgid[(int) REG_ESPACE]);
    }

  /* Since `re_exec' always passes NULL for the `regs' argument, we
     don't need to initialize the pattern buffer fields which affect it.  */

  /* Match anchors at newlines.  */
  re_comp_buf.newline_anchor = 1;

  ret = regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);

  if (!ret)
    return NULL;

  /* Yes, we're discarding `const' here if !HAVE_LIBINTL.  */
  return (char *) gettext (re_error_msgid[(int) ret]);
}


int
#ifdef _LIBC
weak_function
#endif
re_exec (s)
    const char *s;
{
  const int len = strlen (s);
  return
    0 <= re_search (&re_comp_buf, s, len, 0, len, (struct re_registers *) 0);
}

#endif /* _REGEX_RE_COMP */

/* POSIX.2 functions.  Don't define these for Emacs.  */

#ifndef emacs

/* regcomp takes a regular expression as a string and compiles it.

   PREG is a regex_t *.  We do not expect any fields to be initialized,
   since POSIX says we shouldn't.  Thus, we set

     `buffer' to the compiled pattern;
     `used' to the length of the compiled pattern;
     `syntax' to RE_SYNTAX_POSIX_EXTENDED if the
       REG_EXTENDED bit in CFLAGS is set; otherwise, to
       RE_SYNTAX_POSIX_BASIC;
     `newline_anchor' to REG_NEWLINE being set in CFLAGS;
     `fastmap' to an allocated space for the fastmap;
     `fastmap_accurate' to zero;
     `re_nsub' to the number of subexpressions in PATTERN.

   PATTERN is the address of the pattern string.

   CFLAGS is a series of bits which affect compilation.

     If REG_EXTENDED is set, we use POSIX extended syntax; otherwise, we
     use POSIX basic syntax.

     If REG_NEWLINE is set, then . and [^...] don't match newline.
     Also, regexec will try a match beginning after every newline.

     If REG_ICASE is set, then we considers upper- and lowercase
     versions of letters to be equivalent when matching.

     If REG_NOSUB is set, then when PREG is passed to regexec, that
     routine will report only success or failure, and nothing about the
     registers.

   It returns 0 if it succeeds, nonzero if it doesn't.  (See regex.h for
   the return codes and their meanings.)  */

int
regcomp (preg, pattern, cflags)
    regex_t *preg;
    const char *pattern;
    int cflags;
{
  reg_errcode_t ret;
  reg_syntax_t syntax
    = (cflags & REG_EXTENDED) ?
      RE_SYNTAX_POSIX_EXTENDED : RE_SYNTAX_POSIX_BASIC;

  /* regex_compile will allocate the space for the compiled pattern.  */
  preg->buffer = 0;
  preg->allocated = 0;
  preg->used = 0;

  /* Try to allocate space for the fastmap.  */
  preg->fastmap = (char *) malloc (1 << BYTEWIDTH);

  if (cflags & REG_ICASE)
    {
      unsigned i;

      preg->translate
	= (RE_TRANSLATE_TYPE) malloc (CHAR_SET_SIZE
				      * sizeof (*(RE_TRANSLATE_TYPE)0));
      if (preg->translate == NULL)
        return (int) REG_ESPACE;

      /* Map uppercase characters to corresponding lowercase ones.  */
      for (i = 0; i < CHAR_SET_SIZE; i++)
        preg->translate[i] = ISUPPER (i) ? tolower (i) : i;
    }
  else
    preg->translate = NULL;

  /* If REG_NEWLINE is set, newlines are treated differently.  */
  if (cflags & REG_NEWLINE)
    { /* REG_NEWLINE implies neither . nor [^...] match newline.  */
      syntax &= ~RE_DOT_NEWLINE;
      syntax |= RE_HAT_LISTS_NOT_NEWLINE;
      /* It also changes the matching behavior.  */
      preg->newline_anchor = 1;
    }
  else
    preg->newline_anchor = 0;

  preg->no_sub = !!(cflags & REG_NOSUB);

  /* POSIX says a null character in the pattern terminates it, so we
     can use strlen here in compiling the pattern.  */
  ret = regex_compile (pattern, strlen (pattern), syntax, preg);

  /* POSIX doesn't distinguish between an unmatched open-group and an
     unmatched close-group: both are REG_EPAREN.  */
  if (ret == REG_ERPAREN) ret = REG_EPAREN;

  if (ret == REG_NOERROR && preg->fastmap)
    {
      /* Compute the fastmap now, since regexec cannot modify the pattern
	 buffer.  */
      if (re_compile_fastmap (preg) == -2)
	{
	  /* Some error occured while computing the fastmap, just forget
	     about it.  */
	  free (preg->fastmap);
	  preg->fastmap = NULL;
	}
    }

  return (int) ret;
}
#ifdef _LIBC
weak_alias (__regcomp, regcomp)
#endif


/* regexec searches for a given pattern, specified by PREG, in the
   string STRING.

   If NMATCH is zero or REG_NOSUB was set in the cflags argument to
   `regcomp', we ignore PMATCH.  Otherwise, we assume PMATCH has at
   least NMATCH elements, and we set them to the offsets of the
   corresponding matched substrings.

   EFLAGS specifies `execution flags' which affect matching: if
   REG_NOTBOL is set, then ^ does not match at the beginning of the
   string; if REG_NOTEOL is set, then $ does not match at the end.

   We return 0 if we find a match and REG_NOMATCH if not.  */

int
regexec (preg, string, nmatch, pmatch, eflags)
    const regex_t *preg;
    const char *string;
    size_t nmatch;
    regmatch_t pmatch[];
    int eflags;
{
  int ret;
  struct re_registers regs;
  regex_t private_preg;
  int len = strlen (string);
  boolean want_reg_info = !preg->no_sub && nmatch > 0;

  private_preg = *preg;

  private_preg.not_bol = !!(eflags & REG_NOTBOL);
  private_preg.not_eol = !!(eflags & REG_NOTEOL);

  /* The user has told us exactly how many registers to return
     information about, via `nmatch'.  We have to pass that on to the
     matching routines.  */
  private_preg.regs_allocated = REGS_FIXED;

  if (want_reg_info)
    {
      regs.num_regs = nmatch;
      regs.start = TALLOC (nmatch * 2, regoff_t);
      if (regs.start == NULL)
        return (int) REG_NOMATCH;
      regs.end = regs.start + nmatch;
    }

  /* Perform the searching operation.  */
  ret = re_search (&private_preg, string, len,
                   /* start: */ 0, /* range: */ len,
                   want_reg_info ? &regs : (struct re_registers *) 0);

  /* Copy the register information to the POSIX structure.  */
  if (want_reg_info)
    {
      if (ret >= 0)
        {
          unsigned r;

          for (r = 0; r < nmatch; r++)
            {
              pmatch[r].rm_so = regs.start[r];
              pmatch[r].rm_eo = regs.end[r];
            }
        }

      /* If we needed the temporary register info, free the space now.  */
      free (regs.start);
    }

  /* We want zero return to mean success, unlike `re_search'.  */
  return ret >= 0 ? (int) REG_NOERROR : (int) REG_NOMATCH;
}
#ifdef _LIBC
weak_alias (__regexec, regexec)
#endif


/* Returns a message corresponding to an error code, ERRCODE, returned
   from either regcomp or regexec.   We don't use PREG here.  */

size_t
regerror (errcode, preg, errbuf, errbuf_size)
    int errcode;
    const regex_t *preg;
    char *errbuf;
    size_t errbuf_size;
{
  const char *msg;
  size_t msg_size;

  if (errcode < 0
      || errcode >= (int) (sizeof (re_error_msgid)
			   / sizeof (re_error_msgid[0])))
    /* Only error codes returned by the rest of the code should be passed
       to this routine.  If we are given anything else, or if other regex
       code generates an invalid error code, then the program has a bug.
       Dump core so we can fix it.  */
    abort ();

  msg = gettext (re_error_msgid[errcode]);

  msg_size = strlen (msg) + 1; /* Includes the null.  */

  if (errbuf_size != 0)
    {
      if (msg_size > errbuf_size)
        {
#if defined HAVE_MEMPCPY || defined _LIBC
	  *((char *) __mempcpy (errbuf, msg, errbuf_size - 1)) = '\0';
#else
          memcpy (errbuf, msg, errbuf_size - 1);
          errbuf[errbuf_size - 1] = 0;
#endif
        }
      else
        memcpy (errbuf, msg, msg_size);
    }

  return msg_size;
}
#ifdef _LIBC
weak_alias (__regerror, regerror)
#endif


/* Free dynamically allocated space used by PREG.  */

void
regfree (preg)
    regex_t *preg;
{
  if (preg->buffer != NULL)
    free (preg->buffer);
  preg->buffer = NULL;

  preg->allocated = 0;
  preg->used = 0;

  if (preg->fastmap != NULL)
    free (preg->fastmap);
  preg->fastmap = NULL;
  preg->fastmap_accurate = 0;

  if (preg->translate != NULL)
    free (preg->translate);
  preg->translate = NULL;
}
#ifdef _LIBC
weak_alias (__regfree, regfree)
#endif

#endif /* not emacs  */




/* Definitions for data structures and routines for the regular
   expression library, version 0.12.
   Copyright (C) 1985,89,90,91,92,93,95,96,97,98 Free Software Foundation, Inc.

   This file is part of the GNU C Library.  Its master source is NOT part of
   the C library, however.  The master source lives in /gd/gnu/lib.

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

   The GNU C Library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#ifndef _REGEX_H
#define _REGEX_H 1

/* Allow the use in C++ code.  */
#ifdef __cplusplus
extern "C" {
#endif

/* POSIX says that <sys/types.h> must be included (by the caller) before
   <regex.h>.  */

#if !defined _POSIX_C_SOURCE && !defined _POSIX_SOURCE && defined VMS
/* VMS doesn't have `size_t' in <sys/types.h>, even though POSIX says it
   should be there.  */
# include <stddef.h>
#endif

/* The following two types have to be signed and unsigned integer type
   wide enough to hold a value of a pointer.  For most ANSI compilers
   ptrdiff_t and size_t should be likely OK.  Still size of these two
   types is 2 for Microsoft C.  Ugh... */
typedef long int s_reg_t;
typedef unsigned long int active_reg_t;

/* The following bits are used to determine the regexp syntax we
   recognize.  The set/not-set meanings are chosen so that Emacs syntax
   remains the value 0.  The bits are given in alphabetical order, and
   the definitions shifted by one from the previous bit; thus, when we
   add or remove a bit, only one other definition need change.  */
typedef unsigned long int reg_syntax_t;

/* If this bit is not set, then \ inside a bracket expression is literal.
   If set, then such a \ quotes the following character.  */
#define RE_BACKSLASH_ESCAPE_IN_LISTS ((unsigned long int) 1)

/* If this bit is not set, then + and ? are operators, and \+ and \? are
     literals.
   If set, then \+ and \? are operators and + and ? are literals.  */
#define RE_BK_PLUS_QM (RE_BACKSLASH_ESCAPE_IN_LISTS << 1)

/* If this bit is set, then character classes are supported.  They are:
     [:alpha:], [:upper:], [:lower:],  [:digit:], [:alnum:], [:xdigit:],
     [:space:], [:print:], [:punct:], [:graph:], and [:cntrl:].
   If not set, then character classes are not supported.  */
#define RE_CHAR_CLASSES (RE_BK_PLUS_QM << 1)

/* If this bit is set, then ^ and $ are always anchors (outside bracket
     expressions, of course).
   If this bit is not set, then it depends:
        ^  is an anchor if it is at the beginning of a regular
           expression or after an open-group or an alternation operator;
        $  is an anchor if it is at the end of a regular expression, or
           before a close-group or an alternation operator.

   This bit could be (re)combined with RE_CONTEXT_INDEP_OPS, because
   POSIX draft 11.2 says that * etc. in leading positions is undefined.
   We already implemented a previous draft which made those constructs
   invalid, though, so we haven't changed the code back.  */
#define RE_CONTEXT_INDEP_ANCHORS (RE_CHAR_CLASSES << 1)

/* If this bit is set, then special characters are always special
     regardless of where they are in the pattern.
   If this bit is not set, then special characters are special only in
     some contexts; otherwise they are ordinary.  Specifically,
     * + ? and intervals are only special when not after the beginning,
     open-group, or alternation operator.  */
#define RE_CONTEXT_INDEP_OPS (RE_CONTEXT_INDEP_ANCHORS << 1)

/* If this bit is set, then *, +, ?, and { cannot be first in an re or
     immediately after an alternation or begin-group operator.  */
#define RE_CONTEXT_INVALID_OPS (RE_CONTEXT_INDEP_OPS << 1)

/* If this bit is set, then . matches newline.
   If not set, then it doesn't.  */
#define RE_DOT_NEWLINE (RE_CONTEXT_INVALID_OPS << 1)

/* If this bit is set, then . doesn't match NUL.
   If not set, then it does.  */
#define RE_DOT_NOT_NULL (RE_DOT_NEWLINE << 1)

/* If this bit is set, nonmatching lists [^...] do not match newline.
   If not set, they do.  */
#define RE_HAT_LISTS_NOT_NEWLINE (RE_DOT_NOT_NULL << 1)

/* If this bit is set, either \{...\} or {...} defines an
     interval, depending on RE_NO_BK_BRACES.
   If not set, \{, \}, {, and } are literals.  */
#define RE_INTERVALS (RE_HAT_LISTS_NOT_NEWLINE << 1)

/* If this bit is set, +, ? and | aren't recognized as operators.
   If not set, they are.  */
#define RE_LIMITED_OPS (RE_INTERVALS << 1)

/* If this bit is set, newline is an alternation operator.
   If not set, newline is literal.  */
#define RE_NEWLINE_ALT (RE_LIMITED_OPS << 1)

/* If this bit is set, then `{...}' defines an interval, and \{ and \}
     are literals.
  If not set, then `\{...\}' defines an interval.  */
#define RE_NO_BK_BRACES (RE_NEWLINE_ALT << 1)

/* If this bit is set, (...) defines a group, and \( and \) are literals.
   If not set, \(...\) defines a group, and ( and ) are literals.  */
#define RE_NO_BK_PARENS (RE_NO_BK_BRACES << 1)

/* If this bit is set, then \<digit> matches <digit>.
   If not set, then \<digit> is a back-reference.  */
#define RE_NO_BK_REFS (RE_NO_BK_PARENS << 1)

/* If this bit is set, then | is an alternation operator, and \| is literal.
   If not set, then \| is an alternation operator, and | is literal.  */
#define RE_NO_BK_VBAR (RE_NO_BK_REFS << 1)

/* If this bit is set, then an ending range point collating higher
     than the starting range point, as in [z-a], is invalid.
   If not set, then when ending range point collates higher than the
     starting range point, the range is ignored.  */
#define RE_NO_EMPTY_RANGES (RE_NO_BK_VBAR << 1)

/* If this bit is set, then an unmatched ) is ordinary.
   If not set, then an unmatched ) is invalid.  */
#define RE_UNMATCHED_RIGHT_PAREN_ORD (RE_NO_EMPTY_RANGES << 1)

/* If this bit is set, succeed as soon as we match the whole pattern,
   without further backtracking.  */
#define RE_NO_POSIX_BACKTRACKING (RE_UNMATCHED_RIGHT_PAREN_ORD << 1)

/* If this bit is set, do not process the GNU regex operators.
   If not set, then the GNU regex operators are recognized. */
#define RE_NO_GNU_OPS (RE_NO_POSIX_BACKTRACKING << 1)

/* If this bit is set, turn on internal regex debugging.
   If not set, and debugging was on, turn it off.
   This only works if regex.c is compiled -DDEBUG.
   We define this bit always, so that all that's needed to turn on
   debugging is to recompile regex.c; the calling code can always have
   this bit set, and it won't affect anything in the normal case. */
#define RE_DEBUG (RE_NO_GNU_OPS << 1)

/* This global variable defines the particular regexp syntax to use (for
   some interfaces).  When a regexp is compiled, the syntax used is
   stored in the pattern buffer, so changing this does not affect
   already-compiled regexps.  */
extern reg_syntax_t re_syntax_options;

/* Define combinations of the above bits for the standard possibilities.
   (The [[[ comments delimit what gets put into the Texinfo file, so
   don't delete them!)  */
/* [[[begin syntaxes]]] */
#define RE_SYNTAX_EMACS 0

#define RE_SYNTAX_AWK							\
  (RE_BACKSLASH_ESCAPE_IN_LISTS   | RE_DOT_NOT_NULL			\
   | RE_NO_BK_PARENS              | RE_NO_BK_REFS			\
   | RE_NO_BK_VBAR                | RE_NO_EMPTY_RANGES			\
   | RE_DOT_NEWLINE		  | RE_CONTEXT_INDEP_ANCHORS		\
   | RE_UNMATCHED_RIGHT_PAREN_ORD | RE_NO_GNU_OPS)

#define RE_SYNTAX_GNU_AWK						\
  ((RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS | RE_DEBUG)	\
   & ~(RE_DOT_NOT_NULL | RE_INTERVALS | RE_CONTEXT_INDEP_OPS))

#define RE_SYNTAX_POSIX_AWK 						\
  (RE_SYNTAX_POSIX_EXTENDED | RE_BACKSLASH_ESCAPE_IN_LISTS		\
   | RE_INTERVALS	    | RE_NO_GNU_OPS)

#define RE_SYNTAX_GREP							\
  (RE_BK_PLUS_QM              | RE_CHAR_CLASSES				\
   | RE_HAT_LISTS_NOT_NEWLINE | RE_INTERVALS				\
   | RE_NEWLINE_ALT)

#define RE_SYNTAX_EGREP							\
  (RE_CHAR_CLASSES        | RE_CONTEXT_INDEP_ANCHORS			\
   | RE_CONTEXT_INDEP_OPS | RE_HAT_LISTS_NOT_NEWLINE			\
   | RE_NEWLINE_ALT       | RE_NO_BK_PARENS				\
   | RE_NO_BK_VBAR)

#define RE_SYNTAX_POSIX_EGREP						\
  (RE_SYNTAX_EGREP | RE_INTERVALS | RE_NO_BK_BRACES)

/* P1003.2/D11.2, section 4.20.7.1, lines 5078ff.  */
#define RE_SYNTAX_ED RE_SYNTAX_POSIX_BASIC

#define RE_SYNTAX_SED RE_SYNTAX_POSIX_BASIC

/* Syntax bits common to both basic and extended POSIX regex syntax.  */
#define _RE_SYNTAX_POSIX_COMMON						\
  (RE_CHAR_CLASSES | RE_DOT_NEWLINE      | RE_DOT_NOT_NULL		\
   | RE_INTERVALS  | RE_NO_EMPTY_RANGES)

#define RE_SYNTAX_POSIX_BASIC						\
  (_RE_SYNTAX_POSIX_COMMON | RE_BK_PLUS_QM)

/* Differs from ..._POSIX_BASIC only in that RE_BK_PLUS_QM becomes
   RE_LIMITED_OPS, i.e., \? \+ \| are not recognized.  Actually, this
   isn't minimal, since other operators, such as \`, aren't disabled.  */
#define RE_SYNTAX_POSIX_MINIMAL_BASIC					\
  (_RE_SYNTAX_POSIX_COMMON | RE_LIMITED_OPS)

#define RE_SYNTAX_POSIX_EXTENDED					\
  (_RE_SYNTAX_POSIX_COMMON | RE_CONTEXT_INDEP_ANCHORS			\
   | RE_CONTEXT_INDEP_OPS  | RE_NO_BK_BRACES				\
   | RE_NO_BK_PARENS       | RE_NO_BK_VBAR				\
   | RE_UNMATCHED_RIGHT_PAREN_ORD)

/* Differs from ..._POSIX_EXTENDED in that RE_CONTEXT_INVALID_OPS
   replaces RE_CONTEXT_INDEP_OPS and RE_NO_BK_REFS is added.  */
#define RE_SYNTAX_POSIX_MINIMAL_EXTENDED				\
  (_RE_SYNTAX_POSIX_COMMON  | RE_CONTEXT_INDEP_ANCHORS			\
   | RE_CONTEXT_INVALID_OPS | RE_NO_BK_BRACES				\
   | RE_NO_BK_PARENS        | RE_NO_BK_REFS				\
   | RE_NO_BK_VBAR	    | RE_UNMATCHED_RIGHT_PAREN_ORD)
/* [[[end syntaxes]]] */

/* Maximum number of duplicates an interval can allow.  Some systems
   (erroneously) define this in other header files, but we want our
   value, so remove any previous define.  */
#ifdef RE_DUP_MAX
# undef RE_DUP_MAX
#endif
/* If sizeof(int) == 2, then ((1 << 15) - 1) overflows.  */
#define RE_DUP_MAX (0x7fff)


/* POSIX `cflags' bits (i.e., information for `regcomp').  */

/* If this bit is set, then use extended regular expression syntax.
   If not set, then use basic regular expression syntax.  */
#define REG_EXTENDED 1

/* If this bit is set, then ignore case when matching.
   If not set, then case is significant.  */
#define REG_ICASE (REG_EXTENDED << 1)

/* If this bit is set, then anchors do not match at newline
     characters in the string.
   If not set, then anchors do match at newlines.  */
#define REG_NEWLINE (REG_ICASE << 1)

/* If this bit is set, then report only success or fail in regexec.
   If not set, then returns differ between not matching and errors.  */
#define REG_NOSUB (REG_NEWLINE << 1)


/* POSIX `eflags' bits (i.e., information for regexec).  */

/* If this bit is set, then the beginning-of-line operator doesn't match
     the beginning of the string (presumably because it's not the
     beginning of a line).
   If not set, then the beginning-of-line operator does match the
     beginning of the string.  */
#define REG_NOTBOL 1

/* Like REG_NOTBOL, except for the end-of-line.  */
#define REG_NOTEOL (1 << 1)


/* If any error codes are removed, changed, or added, update the
   `re_error_msg' table in regex.c.  */
typedef enum
{
#ifdef _XOPEN_SOURCE
  REG_ENOSYS = -1,	/* This will never happen for this implementation.  */
#endif

  REG_NOERROR = 0,	/* Success.  */
  REG_NOMATCH,		/* Didn't find a match (for regexec).  */

  /* POSIX regcomp return error codes.  (In the order listed in the
     standard.)  */
  REG_BADPAT,		/* Invalid pattern.  */
  REG_ECOLLATE,		/* Not implemented.  */
  REG_ECTYPE,		/* Invalid character class name.  */
  REG_EESCAPE,		/* Trailing backslash.  */
  REG_ESUBREG,		/* Invalid back reference.  */
  REG_EBRACK,		/* Unmatched left bracket.  */
  REG_EPAREN,		/* Parenthesis imbalance.  */
  REG_EBRACE,		/* Unmatched \{.  */
  REG_BADBR,		/* Invalid contents of \{\}.  */
  REG_ERANGE,		/* Invalid range end.  */
  REG_ESPACE,		/* Ran out of memory.  */
  REG_BADRPT,		/* No preceding re for repetition op.  */

  /* Error codes we've added.  */
  REG_EEND,		/* Premature end.  */
  REG_ESIZE,		/* Compiled pattern bigger than 2^16 bytes.  */
  REG_ERPAREN		/* Unmatched ) or \); not returned from regcomp.  */
} reg_errcode_t;

/* This data structure represents a compiled pattern.  Before calling
   the pattern compiler, the fields `buffer', `allocated', `fastmap',
   `translate', and `no_sub' can be set.  After the pattern has been
   compiled, the `re_nsub' field is available.  All other fields are
   private to the regex routines.  */

#ifndef RE_TRANSLATE_TYPE
# define RE_TRANSLATE_TYPE char *
#endif

struct re_pattern_buffer
{
/* [[[begin pattern_buffer]]] */
	/* Space that holds the compiled pattern.  It is declared as
          `unsigned char *' because its elements are
           sometimes used as array indexes.  */
  unsigned char *buffer;

	/* Number of bytes to which `buffer' points.  */
  unsigned long int allocated;

	/* Number of bytes actually used in `buffer'.  */
  unsigned long int used;

        /* Syntax setting with which the pattern was compiled.  */
  reg_syntax_t syntax;

        /* Pointer to a fastmap, if any, otherwise zero.  re_search uses
           the fastmap, if there is one, to skip over impossible
           starting points for matches.  */
  char *fastmap;

        /* Either a translate table to apply to all characters before
           comparing them, or zero for no translation.  The translation
           is applied to a pattern when it is compiled and to a string
           when it is matched.  */
  RE_TRANSLATE_TYPE translate;

	/* Number of subexpressions found by the compiler.  */
  size_t re_nsub;

        /* Zero if this pattern cannot match the empty string, one else.
           Well, in truth it's used only in `re_search_2', to see
           whether or not we should use the fastmap, so we don't set
           this absolutely perfectly; see `re_compile_fastmap' (the
           `duplicate' case).  */
  unsigned can_be_null : 1;

        /* If REGS_UNALLOCATED, allocate space in the `regs' structure
             for `max (RE_NREGS, re_nsub + 1)' groups.
           If REGS_REALLOCATE, reallocate space if necessary.
           If REGS_FIXED, use what's there.  */
#define REGS_UNALLOCATED 0
#define REGS_REALLOCATE 1
#define REGS_FIXED 2
  unsigned regs_allocated : 2;

        /* Set to zero when `regex_compile' compiles a pattern; set to one
           by `re_compile_fastmap' if it updates the fastmap.  */
  unsigned fastmap_accurate : 1;

        /* If set, `re_match_2' does not return information about
           subexpressions.  */
  unsigned no_sub : 1;

        /* If set, a beginning-of-line anchor doesn't match at the
           beginning of the string.  */
  unsigned not_bol : 1;

        /* Similarly for an end-of-line anchor.  */
  unsigned not_eol : 1;

        /* If true, an anchor at a newline matches.  */
  unsigned newline_anchor : 1;

/* [[[end pattern_buffer]]] */
};

typedef struct re_pattern_buffer regex_t;

/* Type for byte offsets within the string.  POSIX mandates this.  */
typedef int regoff_t;


/* This is the structure we store register match data in.  See
   regex.texinfo for a full description of what registers match.  */
struct re_registers
{
  unsigned num_regs;
  regoff_t *start;
  regoff_t *end;
};


/* If `regs_allocated' is REGS_UNALLOCATED in the pattern buffer,
   `re_match_2' returns information about at least this many registers
   the first time a `regs' structure is passed.  */
#ifndef RE_NREGS
# define RE_NREGS 30
#endif


/* POSIX specification for registers.  Aside from the different names than
   `re_registers', POSIX uses an array of structures, instead of a
   structure of arrays.  */
typedef struct
{
  regoff_t rm_so;  /* Byte offset from string's start to substring's start.  */
  regoff_t rm_eo;  /* Byte offset from string's start to substring's end.  */
} regmatch_t;

/* Declarations for routines.  */

/* To avoid duplicating every routine declaration -- once with a
   prototype (if we are ANSI), and once without (if we aren't) -- we
   use the following macro to declare argument types.  This
   unfortunately clutters up the declarations a bit, but I think it's
   worth it.  */

#if __STDC__

# define _RE_ARGS(args) args

#else /* not __STDC__ */

# define _RE_ARGS(args) ()

#endif /* not __STDC__ */

/* Sets the current default syntax to SYNTAX, and return the old syntax.
   You can also simply assign to the `re_syntax_options' variable.  */
extern reg_syntax_t __re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));

/* Compile the regular expression PATTERN, with length LENGTH
   and syntax given by the global `re_syntax_options', into the buffer
   BUFFER.  Return NULL if successful, and an error string if not.  */
extern const char *__re_compile_pattern
  _RE_ARGS ((const char *pattern, size_t length,
             struct re_pattern_buffer *buffer));
extern const char *re_compile_pattern
  _RE_ARGS ((const char *pattern, size_t length,
             struct re_pattern_buffer *buffer));


/* Compile a fastmap for the compiled pattern in BUFFER; used to
   accelerate searches.  Return 0 if successful and -2 if was an
   internal error.  */
extern int __re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));


/* Search in the string STRING (with length LENGTH) for the pattern
   compiled into BUFFER.  Start searching at position START, for RANGE
   characters.  Return the starting position of the match, -1 for no
   match, or -2 for an internal error.  Also return register
   information in REGS (if REGS and BUFFER->no_sub are nonzero).  */
extern int __re_search
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
            int length, int start, int range, struct re_registers *regs));
extern int re_search
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
            int length, int start, int range, struct re_registers *regs));


/* Like `re_search', but search in the concatenation of STRING1 and
   STRING2.  Also, stop searching at index START + STOP.  */
extern int __re_search_2
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
             int length1, const char *string2, int length2,
             int start, int range, struct re_registers *regs, int stop));
extern int re_search_2
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
             int length1, const char *string2, int length2,
             int start, int range, struct re_registers *regs, int stop));


/* Like `re_search', but return how many characters in STRING the regexp
   in BUFFER matched, starting at position START.  */
extern int __re_match
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
             int length, int start, struct re_registers *regs));
extern int re_match
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
             int length, int start, struct re_registers *regs));


/* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
extern int __re_match_2
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
             int length1, const char *string2, int length2,
             int start, struct re_registers *regs, int stop));
extern int re_match_2
  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
             int length1, const char *string2, int length2,
             int start, struct re_registers *regs, int stop));


/* Set REGS to hold NUM_REGS registers, storing them in STARTS and
   ENDS.  Subsequent matches using BUFFER and REGS will use this memory
   for recording register information.  STARTS and ENDS must be
   allocated with malloc, and must each be at least `NUM_REGS * sizeof
   (regoff_t)' bytes long.

   If NUM_REGS == 0, then subsequent matches should allocate their own
   register data.

   Unless this function is called, the first search or match using
   PATTERN_BUFFER will allocate its own register data, without
   freeing the old data.  */
extern void __re_set_registers
  _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
             unsigned num_regs, regoff_t *starts, regoff_t *ends));
extern void re_set_registers
  _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
             unsigned num_regs, regoff_t *starts, regoff_t *ends));

#ifdef _REGEX_RE_COMP
# ifndef _CRAY
/* 4.2 bsd compatibility.  */
extern char *re_comp _RE_ARGS ((const char *));
extern int re_exec _RE_ARGS ((const char *));
# endif
#endif

/* POSIX compatibility.  */
extern int __regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern,
				int __cflags));
extern int regcomp _RE_ARGS ((regex_t *__preg, const char *__pattern,
			      int __cflags));

extern int __regexec _RE_ARGS ((const regex_t *__preg,
				const char *__string, size_t __nmatch,
				regmatch_t __pmatch[], int __eflags));
extern int regexec _RE_ARGS ((const regex_t *__preg,
			      const char *__string, size_t __nmatch,
			      regmatch_t __pmatch[], int __eflags));

extern size_t __regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
				    char *__errbuf, size_t __errbuf_size));
extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
				  char *__errbuf, size_t __errbuf_size));

extern void __regfree _RE_ARGS ((regex_t *__preg));
extern void regfree _RE_ARGS ((regex_t *__preg));


#ifdef __cplusplus
}
#endif	/* C++ */

#endif /* regex.h */

/*
Local variables:
make-backup-files: t
version-control: t
trim-versions-without-asking: nil
End:
*/




/* savedir.c -- save the list of files in a directory in a string
   Copyright (C) 1990, 1997, 1998 Free Software Foundation, Inc.

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/* Written by David MacKenzie <djm@gnu.ai.mit.edu>. */

#if HAVE_CONFIG_H
# include <config.h>
#endif

#include <sys/types.h>

#if HAVE_UNISTD_H
# include <unistd.h>
#endif

#if HAVE_DIRENT_H
# include <dirent.h>
# define NAMLEN(dirent) strlen((dirent)->d_name)
#else
# define dirent direct
# define NAMLEN(dirent) (dirent)->d_namlen
# if HAVE_SYS_NDIR_H
#  include <sys/ndir.h>
# endif
# if HAVE_SYS_DIR_H
#  include <sys/dir.h>
# endif
# if HAVE_NDIR_H
#  include <ndir.h>
# endif
#endif

#ifdef CLOSEDIR_VOID
/* Fake a return value. */
# define CLOSEDIR(d) (closedir (d), 0)
#else
# define CLOSEDIR(d) closedir (d)
#endif

#ifdef STDC_HEADERS
# include <stdlib.h>
# include <string.h>
#else
char *malloc ();
char *realloc ();
#endif
#ifndef NULL
# define NULL 0
#endif

#ifndef stpcpy
char *stpcpy ();
#endif

#include "savedir.h"

/* Return a freshly allocated string containing the filenames
   in directory DIR, separated by '\0' characters;
   the end is marked by two '\0' characters in a row.
   NAME_SIZE is the number of bytes to initially allocate
   for the string; it will be enlarged as needed.
   Return NULL if DIR cannot be opened or if out of memory. */

char *
savedir (dir, name_size)
     const char *dir;
     unsigned int name_size;
{
  DIR *dirp;
  struct dirent *dp;
  char *name_space;
  char *namep;

  dirp = opendir (dir);
  if (dirp == NULL)
    return NULL;

  name_space = (char *) malloc (name_size);
  if (name_space == NULL)
    {
      closedir (dirp);
      return NULL;
    }
  namep = name_space;

  while ((dp = readdir (dirp)) != NULL)
    {
      /* Skip "." and ".." (some NFS filesystems' directories lack them). */
      if (dp->d_name[0] != '.'
	  || (dp->d_name[1] != '\0'
	      && (dp->d_name[1] != '.' || dp->d_name[2] != '\0')))
	{
	  unsigned size_needed = (namep - name_space) + NAMLEN (dp) + 2;

	  if (size_needed > name_size)
	    {
	      char *new_name_space;

	      while (size_needed > name_size)
		name_size += 1024;

	      new_name_space = realloc (name_space, name_size);
	      if (new_name_space == NULL)
		{
		  closedir (dirp);
		  return NULL;
		}
	      namep += new_name_space - name_space;
	      name_space = new_name_space;
	    }
	  namep = stpcpy (namep, dp->d_name) + 1;
	}
    }
  *namep = '\0';
  if (CLOSEDIR (dirp))
    {
      free (name_space);
      return NULL;
    }
  return name_space;
}




#if !defined SAVEDIR_H_
# define SAVEDIR_H_

# ifndef PARAMS
#  if defined PROTOTYPES || (defined __STDC__ && __STDC__)
#   define PARAMS(Args) Args
#  else
#   define PARAMS(Args) ()
#  endif
# endif

char *
savedir PARAMS ((const char *dir, unsigned int name_size));

#endif




/* search.c - searching subroutines using dfa, kwset and regex for grep.
   Copyright (C) 1992, 1998 Free Software Foundation, Inc.

   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


   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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

/* Written August 1992 by Mike Haertel. */

#ifdef HAVE_CONFIG_H
# include <config.h>
#ifdef STDC_HEADERS
#include <limits.h>
#include <stdlib.h>
#else
#define UCHAR_MAX 255
#include <sys/types.h>
extern char *malloc();
#endif

#ifdef HAVE_MEMCHR
#include <string.h>
#ifdef NEED_MEMORY_H
#include <memory.h>
#endif
#else
#ifdef __STDC__
extern void *memchr();
#else
extern char *memchr();
#endif
#endif
#include <sys/types.h>
#include "system.h"
#undef bcopy
#define bcopy(s, d, n) memcpy((d), (s), (n))
#endif

#if defined(isascii) && !defined(__FreeBSD__)
#define ISALNUM(C) (isascii(C) && isalnum(C))
#define ISUPPER(C) (isascii(C) && isupper(C))
#else
#define ISALNUM(C) isalnum((unsigned char)C)
#define ISUPPER(C) isupper((unsigned char)C)
#endif

#define TOLOWER(C) (ISUPPER(C) ? tolower((unsigned char)C) : (C))

#include "grep.h"
#include "regex.h"
#include "dfa.h"
#include "kwset.h"
#include "gnuregex.h"

#define NCHAR (UCHAR_MAX + 1)

static void Gcompile PARAMS((char *, size_t));
static void Ecompile PARAMS((char *, size_t));
static char *EGexecute PARAMS((char *, size_t, char **));
static void Fcompile PARAMS((char *, size_t));
static char *Fexecute PARAMS((char *, size_t, char **));
static void kwsinit PARAMS((void));
#else
static void Gcompile();
static void Ecompile();
static char *EGexecute();
static void Fcompile();
static char *Fexecute();
#endif

/* Here is the matchers vector for the main program. */
struct matcher matchers[] = {
  { "default", Gcompile, EGexecute },
  { "grep", Gcompile, EGexecute },
  { "ggrep", Gcompile, EGexecute },
  { "egrep", Ecompile, EGexecute },
  { "posix-egrep", Ecompile, EGexecute },
  { "awk", Ecompile, EGexecute },
  { "fgrep", Fcompile, Fexecute },
  { "gfgrep", Fcompile, Fexecute },
  { 0, 0, 0 },
};



void
dfaerror(mesg)
  const char *mesg;
{
  fatal(mesg, 0);
}

     char *pattern;
     size_t size;
{
  const char *err;
  const
#endif
  char *err;

  re_set_syntax(RE_SYNTAX_GREP | RE_HAT_LISTS_NOT_NEWLINE);
  dfasyntax(RE_SYNTAX_GREP | RE_HAT_LISTS_NOT_NEWLINE, match_icase);

  if ((err = re_compile_pattern(pattern, size, &regex)) != 0)
    fatal(err, 0);

  dfainit(&dfa);

  /* In the match_words and match_lines cases, we use a different pattern
     for the DFA matcher that will quickly throw out cases that won't work.
     Then if DFA succeeds we do some hairy stuff using the regex matcher

	strcpy(n, "\\(^\\|[^0-9A-Za-z_]\\)\\(");

      i = strlen(n);
      memcpy(n + i, pattern, size);
      i += size;

      if (match_words)

     char *pattern;
     size_t size;
{
  const char *err;
  const
#endif
  char *err;

  if (strcmp(matcher, "posix-egrep") == 0)
    {
      re_set_syntax(RE_SYNTAX_POSIX_EGREP);
      dfasyntax(RE_SYNTAX_POSIX_EGREP, match_icase);
    }
  else if (strcmp(matcher, "awk") == 0)
    {
      re_set_syntax(RE_SYNTAX_AWK);
      dfasyntax(RE_SYNTAX_AWK, match_icase);
    }
  else
    {
      re_set_syntax(RE_SYNTAX_EGREP);

  if ((err = re_compile_pattern(pattern, size, &regex)) != 0)
    fatal(err, 0);

  dfainit(&dfa);

  /* In the match_words and match_lines cases, we use a different pattern
     for the DFA matcher that will quickly throw out cases that won't work.
     Then if DFA succeeds we do some hairy stuff using the regex matcher

	strcpy(n, "(^|[^0-9A-Za-z_])(");

      i = strlen(n);
      memcpy(n + i, pattern, size);
      i += size;

      if (match_words)

      if ((start = re_search(&regex, beg, end - beg, 0, end - beg, &regs)) >= 0)
	{
	  len = regs.end[0] - start;
	  if ((!match_lines && !match_words)
	      || (match_lines && len == end - beg))
	    goto success;
	  /* If -w, check if the match aligns with word boundaries.
	     We do this iteratively because:

	  if (match_words)
	    while (start >= 0)
	      {
		if ((start == 0 || !WCHAR ((unsigned char) beg[start - 1]))
		    && (len == end - beg
			|| !WCHAR ((unsigned char) beg[start + len])))
		  goto success;
		if (len > 0)
		  {




/* stpcpy.c -- copy a string and return pointer to end of new string
   Copyright (C) 1992, 1995, 1997, 1998 Free Software Foundation, Inc.

   NOTE: The canonical source of this file is maintained with the GNU C Library.
   Bugs can be reported to bug-glibc@prep.ai.mit.edu.

   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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
   USA.  */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <string.h>

#undef __stpcpy
#undef stpcpy

#ifndef weak_alias
# define __stpcpy stpcpy
#endif

/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST.  */
char *
__stpcpy (dest, src)
     char *dest;
     const char *src;
{
  register char *d = dest;
  register const char *s = src;

  do
    *d++ = *s;
  while (*s++ != '\0');

  return d - 1;
}
#ifdef weak_alias
weak_alias (__stpcpy, stpcpy)
#endif




/* Portability cruft.  Include after config.h and sys/types.h.
   Copyright (C) 1996, 1998 Free Software Foundation, Inc.

   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., 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA.  */

#undef PARAMS
#if defined (__STDC__) && __STDC__
# ifndef _PTR_T
# define _PTR_T
  typedef void * ptr_t;
# endif
# define PARAMS(x) x
#else
# ifndef _PTR_T
# define _PTR_T
  typedef char * ptr_t;
# endif
# define PARAMS(x) ()
#endif

#ifdef HAVE_UNISTD_H
# include <fcntl.h>
# include <unistd.h>
#else
# define O_RDONLY 0
int open(), read(), close();
#endif

#include <errno.h>
#ifndef errno
extern int errno;
#endif

#ifndef HAVE_STRERROR
extern int sys_nerr;
extern char *sys_errlist[];
# define strerror(E) (0 <= (E) && (E) < sys_nerr ? _(sys_errlist[E]) : _("Unknown system error"))
#endif

/* Some operating systems treat text and binary files differently.  */
#if O_BINARY
# include <io.h>
# ifdef HAVE_SETMODE
#  define SET_BINARY(fd)  setmode (fd, O_BINARY)
# else
#  define SET_BINARY(fd)  _setmode (fd, O_BINARY)
# endif
#else
# ifndef O_BINARY
#  define O_BINARY 0
#  define SET_BINARY(fd)   (void)0
# endif
#endif

#ifdef HAVE_DOS_FILE_NAMES
# define IS_SLASH(c) ((c) == '/' || (c) == '\\')
# define FILESYSTEM_PREFIX_LEN(f) ((f)[0] && (f)[1] == ':' ? 2 : 0)
#endif

#ifndef IS_SLASH
# define IS_SLASH(c) ((c) == '/')
#endif

#ifndef FILESYSTEM_PREFIX_LEN
# define FILESYSTEM_PREFIX_LEN(f) 0
#endif

/* This assumes _WIN32, like DJGPP, has D_OK.  Does it?  In what header?  */
#ifdef D_OK
# ifdef EISDIR
#  define is_EISDIR(e, f) \
     ((e) == EISDIR \
      || ((e) == EACCES && access (f, D_OK) == 0 && ((e) = EISDIR, 1)))
# else
#  define is_EISDIR(e, f) ((e) == EACCES && access (f, D_OK) == 0)
# endif
#endif

#ifndef is_EISDIR
# ifdef EISDIR
#  define is_EISDIR(e, f) ((e) == EISDIR)
# else
#  define is_EISDIR(e, f) 0
# endif
#endif

#if STAT_MACROS_BROKEN
# undef S_ISDIR
#endif
#if !defined(S_ISDIR) && defined(S_IFDIR)
# define S_ISDIR(Mode) (((Mode) & S_IFMT) == S_IFDIR)
#endif

#ifdef STDC_HEADERS
# include <stdlib.h>
#else
ptr_t malloc(), realloc(), calloc();
void free();
#endif

#if __STDC__
# include <stddef.h>
#endif
#ifdef STDC_HEADERS
# include <limits.h>
#endif
#ifndef CHAR_BIT
# define CHAR_BIT 8
#endif
#ifndef INT_MAX
# define INT_MAX 2147483647
#endif
#ifndef UCHAR_MAX
# define UCHAR_MAX 255
#endif

#if !defined(STDC_HEADERS) && defined(HAVE_STRING_H) && defined(HAVE_MEMORY_H)
# include <memory.h>
#endif
#if defined(STDC_HEADERS) || defined(HAVE_STRING_H)
# include <string.h>
#else
# include <strings.h>
# undef strchr
# define strchr index
# undef strrchr
# define strrchr rindex
# undef memcpy
# define memcpy(d, s, n) bcopy((s), (d), (n))
#endif
#ifndef HAVE_MEMCHR
ptr_t memchr();
#endif

#include <ctype.h>

#ifndef isgraph
# define isgraph(C) (isprint(C) && !isspace(C))
#endif

#if defined (STDC_HEADERS) || (!defined (isascii) && !defined (HAVE_ISASCII))
# define IN_CTYPE_DOMAIN(c) 1
#else
# define IN_CTYPE_DOMAIN(c) isascii(c)
#endif

#define ISALPHA(C)	(IN_CTYPE_DOMAIN (C) && isalpha (C))
#define ISUPPER(C)	(IN_CTYPE_DOMAIN (C) && isupper (C))
#define ISLOWER(C)	(IN_CTYPE_DOMAIN (C) && islower (C))
#define ISDIGIT(C)	(IN_CTYPE_DOMAIN (C) && isdigit (C))
#define ISXDIGIT(C)	(IN_CTYPE_DOMAIN (C) && isxdigit (C))
#define ISSPACE(C)	(IN_CTYPE_DOMAIN (C) && isspace (C))
#define ISPUNCT(C)	(IN_CTYPE_DOMAIN (C) && ispunct (C))
#define ISALNUM(C)	(IN_CTYPE_DOMAIN (C) && isalnum (C))
#define ISPRINT(C)	(IN_CTYPE_DOMAIN (C) && isprint (C))
#define ISGRAPH(C)	(IN_CTYPE_DOMAIN (C) && isgraph (C))
#define ISCNTRL(C)	(IN_CTYPE_DOMAIN (C) && iscntrl (C))

#define TOLOWER(C) (ISUPPER(C) ? tolower(C) : (C))

#if ENABLE_NLS
# include <libintl.h>
# define _(String) gettext (String)
#else
# define _(String) String
#endif
#define N_(String) String

#if HAVE_SETLOCALE
# include <locale.h>
#endif

#ifndef initialize_main
#define initialize_main(argcp, argvp)
#endif




     /*
        <vms_fab>

        This macro sets up the file access block and name block for VMS.
        It also does the initial parsing of the input string (resolving 
        wildcards,
        if any) and finds all files matching the input pattern.
        The address of the first matching pattern is returned.

        Written by Phillip C. Brisco 8/98.
      */
#include "vms_fab.h"

void
vms_fab (argp, argvp)
	int * argp;
	char **argvp[];
{
  extern int optind;
  int optout;

  fab = cc$rms_fab;
  nam = cc$rms_nam;

  optout = 0;
  strcpy (fna_buffer, *argvp[optind]);
  length_of_fna_buffer = NAM$C_MAXRSS;

  fab.fab$b_bid = FAB$C_BID;
  fab.fab$b_bln = FAB$C_BLN;
  fab.fab$l_fop = FAB$M_NAM;
  fab.fab$l_nam = &nam;
  fab.fab$l_fna = &fna_buffer;
  fab.fab$b_fns = length_of_fna_buffer;

  nam.nam$b_bid = NAM$C_BID;
  nam.nam$b_bln = NAM$C_BLN;
  nam.nam$l_esa = &expanded_name;
  nam.nam$b_ess = NAM$C_MAXRSS;
  nam.nam$l_rsa = &result_name;
  nam.nam$b_rss = NAM$C_MAXRSS;

  fab_stat = sys$parse (&fab);
  fab_stat = sys$search (&fab);

  if (fab_stat != 65537)
    {
      fprintf (stderr, "No Matches found.\n");
      exit (0);
    }

  /*
     While we find matching patterns, continue searching for more.
   */
  while (fab_stat == 65537)
    {
      /*
         Allocate memory for the filename
       */
      arr_ptr[optout] = alloca (max_file_path_size + 1);

      strcpy (arr_ptr[optout], result_name);

      /*
         If we don't tack on a null character at the end of the 
         filename,
         we can get partial data which is still there from the last
         sys$search command.
       */
      arr_ptr[optout][nam.nam$b_dev +
		      nam.nam$b_dir +
		      nam.nam$b_name +
		      nam.nam$b_type +
		      nam.nam$b_ver] = '\0';

      fab_stat = sys$search (&fab);
      optout++;
    }

  optout--;

  /* Return a pointer to the beginning of memory that has the expanded
     filenames.
   */
  *argcp = optout;
  *argvp = arr_ptr;

}




/*
   This file includes the setup for the file access block for VMS.
   Written by Phillip C. Brisco 8/98.
 */

#include <rms.h>
#include <ssdef.h>
#include <stddef.h>

struct FAB fab;
struct NAM nam;

int length_of_fna_buffer;
int fab_stat;
char expanded_name[NAM$C_MAXRSS];
char fna_buffer[NAM$C_MAXRSS];
char result_name[NAM$C_MAXRSS];
char final_name[NAM$C_MAXRSS];
int max_file_path_size = NAM$C_MAXRSS;
char *arr_ptr[32767]:

Return to bug 13935

Lines 20-29 Link Here

(-)grep/AUTHORS (-1 / +13 lines)
20	to James Woods. He also contributed some code to early versions of	20	to James Woods. He also contributed some code to early versions of
21	GNU grep.	21	GNU grep.
22		22
23	Finally, I would like to thank Andrew Hume for many fascinating discussions	23	Mike Haertel would like to thank Andrew Hume for many fascinating discussions
24	of string searching issues over the years. Hume & Sunday's excellent	24	of string searching issues over the years. Hume & Sunday's excellent
25	paper on fast string searching (AT&T Bell Laboratories CSTR #156)	25	paper on fast string searching (AT&T Bell Laboratories CSTR #156)
26	describes some of the history of the subject, as well as providing	26	describes some of the history of the subject, as well as providing
27	exhaustive performance analysis of various implementation alternatives.	27	exhaustive performance analysis of various implementation alternatives.
28	The inner loop of GNU grep is similar to Hume & Sunday's recommended	28	The inner loop of GNU grep is similar to Hume & Sunday's recommended
29	"Tuned Boyer Moore" inner loop.	29	"Tuned Boyer Moore" inner loop.
		30
		31	More work was done on regex.[ch] by Ulrich Drepper and Arnold
		32	Robbins. Regex is now part of GNU C library, see this package
		33	for complete details and credits.
		34
		35	Arnold Robbins contributed to improve dfa.[ch]. In fact
		36	it came straight from gawk-3.0.3 with small editing and fixes.
		37
		38	Many folks contributed see THANKS, if I omited someone please
		39	send me email.
		40
		41	Alain Magloire is the current maintainer.

Lines 2-8 Link Here

(-)grep/COPYING (-5 / +6 lines)
2	Version 2, June 1991	2	Version 2, June 1991
3		3
4	Copyright (C) 1989, 1991 Free Software Foundation, Inc.	4	Copyright (C) 1989, 1991 Free Software Foundation, Inc.
5	675 Mass Ave, Cambridge, MA 02139, USA	5	59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
6	Everyone is permitted to copy and distribute verbatim copies	6	Everyone is permitted to copy and distribute verbatim copies
7	of this license document, but changing it is not allowed.	7	of this license document, but changing it is not allowed.
8		8
Lines 279-285 Link Here
279		279
280	END OF TERMS AND CONDITIONS	280	END OF TERMS AND CONDITIONS
281		281
282	Appendix: How to Apply These Terms to Your New Programs	282	How to Apply These Terms to Your New Programs
283		283
284	If you develop a new program, and you want it to be of the greatest	284	If you develop a new program, and you want it to be of the greatest
285	possible use to the public, the best way to achieve this is to make it	285	possible use to the public, the best way to achieve this is to make it
Lines 291-297 Link Here
291	the "copyright" line and a pointer to where the full notice is found.	291	the "copyright" line and a pointer to where the full notice is found.
292		292
293	<one line to give the program's name and a brief idea of what it does.>	293	<one line to give the program's name and a brief idea of what it does.>
294	Copyright (C) 19yy <name of author>	294	Copyright (C) <year> <name of author>
295		295
296	This program is free software; you can redistribute it and/or modify	296	This program is free software; you can redistribute it and/or modify
297	it under the terms of the GNU General Public License as published by	297	it under the terms of the GNU General Public License as published by
Lines 305-318 Link Here
305		305
306	You should have received a copy of the GNU General Public License	306	You should have received a copy of the GNU General Public License
307	along with this program; if not, write to the Free Software	307	along with this program; if not, write to the Free Software
308	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	308	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
		309
309		310
310	Also add information on how to contact you by electronic and paper mail.	311	Also add information on how to contact you by electronic and paper mail.
311		312
312	If the program is interactive, make it output a short notice like this	313	If the program is interactive, make it output a short notice like this
313	when it starts in an interactive mode:	314	when it starts in an interactive mode:
314		315
315	Gnomovision version 69, Copyright (C) 19yy name of author	316	Gnomovision version 69, Copyright (C) year name of author
316	Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.	317	Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
317	This is free software, and you are welcome to redistribute it	318	This is free software, and you are welcome to redistribute it
318	under certain conditions; type `show c' for details.	319	under certain conditions; type `show c' for details.

Lines 1-3 Link Here

(-)grep/NEWS (+64 lines)
		1	Version 2.3:
		2
		3	- When searching a binary file FOO, grep now just reports
		4	`Binary file FOO matches' instead of outputting binary data.
		5	This is typically more useful than the old behavior,
		6	and it is also more consistent with other utilities like `diff'.
		7	A file is considered to be binary if it contains a NUL (i.e. zero) byte.
		8
		9	The new -a or --text option causes `grep' to assume that all
		10	input is text. (This option has the same meaning as with `diff'.)
		11	Use it if you want binary data in your output.
		12
		13	- `grep' now searches directories just like ordinary files; it no longer
		14	silently skips directories. This is the traditional behavior of
		15	Unix text utilities (in particular, of traditional `grep').
		16	Hence `grep PATTERN DIRECTORY' should report
		17	`grep: DIRECTORY: Is a directory' on hosts where the operating system
		18	does not permit programs to read directories directly, and
		19	`grep: DIRECTORY: Binary file matches' (or nothing) otherwise.
		20
		21	The new -d ACTION or --directories=ACTION option affects directory handling.
		22	`-d skip' causes `grep' to silently skip directories, as in grep 2.2;
		23	`-d read' (the default) causes `grep' to read directories if possible,
		24	as in earlier versions of grep.
		25
		26	- The MS-DOS and Microsoft Windows ports now behave identically to the
		27	GNU and Unix ports with respect to binary files and directories.
		28
		29	Version 2.2:
		30
		31	Bug fix release.
		32
		33	- Status error number fix.
		34	- Skipping directories removed.
		35	- Many typos fix.
		36	- -f /dev/null fix(not to consider as an empty pattern).
		37	- Checks for wctype/wchar.
		38	- -E was using the wrong matcher fix.
		39	- bug in regex char class fix
		40	- Fixes for DJGPP
		41
		42	Version 2.1:
		43
		44	This is a bug fix release(see Changelog) i.e. no new features.
		45
		46	- More compliance to GNU standard.
		47	- Long options.
		48	- Internationalisation.
		49	- Use automake/autoconf.
		50	- Directory hierarchy change.
		51	- Sigvec with -e on Linux corrected.
		52	- Sigvec with -f on Linux corrected.
		53	- Sigvec with the mmap() corrected.
		54	- Bug in kwset corrected.
		55	- -q, -L and -l stop on first match.
		56	- New and improve regex.[ch] from Ulrich Drepper.
		57	- New and improve dfa.[ch] from Arnold Robbins.
		58	- Prototypes for over zealous C compiler.
		59	- Not scanning a file, if it's a directory
		60	(cause problems on Sun).
		61	- Ported to MS-DOS/MS-Windows with DJGPP tools.
		62
		63	See Changelog for the full story and proper credits.
		64
1	Version 2.0:	65	Version 2.0:
2		66
3	The most important user visible change is that egrep and fgrep have	67	The most important user visible change is that egrep and fgrep have

Lines 1-15 Link Here

(-)grep/PROJECTS (-15 lines)
1	Write Texinfo documentation for grep. The manual page would be a good
2	place to start, but Info documents are also supposed to contain a
3	tutorial and examples.
4
5	Fix the DFA matcher to never use exponential space. (Fortunately, these
6	cases are rare.)
7
8	Improve the performance of the regex backtracking matcher. This matcher
9	is agonizingly slow, and is responsible for grep sometimes being slower
10	than Unix grep when backreferences are used.
11
12	Provide support for the Posix [= =] and [. .] constructs. This is
13	difficult because it requires locale-dependent details of the character
14	set and collating sequence, but Posix does not standardize any method
15	for accessing this information!

Line 0 Link Here

(-)grep/alloca.c (+504 lines)
		1	/* alloca.c -- allocate automatically reclaimed memory
		2	(Mostly) portable public-domain implementation -- D A Gwyn
		3
		4	This implementation of the PWB library alloca function,
		5	which is used to allocate space off the run-time stack so
		6	that it is automatically reclaimed upon procedure exit,
		7	was inspired by discussions with J. Q. Johnson of Cornell.
		8	J.Otto Tennant <jot@cray.com> contributed the Cray support.
		9
		10	There are some preprocessor constants that can
		11	be defined when compiling for your specific system, for
		12	improved efficiency; however, the defaults should be okay.
		13
		14	The general concept of this implementation is to keep
		15	track of all alloca-allocated blocks, and reclaim any
		16	that are found to be deeper in the stack than the current
		17	invocation. This heuristic does not reclaim storage as
		18	soon as it becomes invalid, but it will do so eventually.
		19
		20	As a special case, alloca(0) reclaims storage without
		21	allocating any. It is a good idea to use alloca(0) in
		22	your main control loop, etc. to force garbage collection. */
		23
		24	#ifdef HAVE_CONFIG_H
		25	#include <config.h>
		26	#endif
		27
		28	#ifdef HAVE_STRING_H
		29	#include <string.h>
		30	#endif
		31	#ifdef HAVE_STDLIB_H
		32	#include <stdlib.h>
		33	#endif
		34
		35	#ifdef emacs
		36	#include "blockinput.h"
		37	#endif
		38
		39	/* If compiling with GCC 2, this file's not needed. */
		40	#if !defined (__GNUC__) \|\| __GNUC__ < 2
		41
		42	/* If someone has defined alloca as a macro,
		43	there must be some other way alloca is supposed to work. */
		44	#ifndef alloca
		45
		46	#ifdef emacs
		47	#ifdef static
		48	/* actually, only want this if static is defined as ""
		49	-- this is for usg, in which emacs must undefine static
		50	in order to make unexec workable
		51	*/
		52	#ifndef STACK_DIRECTION
		53	you
		54	lose
		55	-- must know STACK_DIRECTION at compile-time
		56	#endif /* STACK_DIRECTION undefined */
		57	#endif /* static */
		58	#endif /* emacs */
		59
		60	/* If your stack is a linked list of frames, you have to
		61	provide an "address metric" ADDRESS_FUNCTION macro. */
		62
		63	#if defined (CRAY) && defined (CRAY_STACKSEG_END)
		64	long i00afunc ();
65	#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
66	#else
67	#define ADDRESS_FUNCTION(arg) &(arg)
68	#endif
69
70	#if __STDC__
71	typedef void *pointer;
72	#else
73	typedef char *pointer;
74	#endif
75
76	#ifndef NULL
77	#define NULL 0
78	#endif
79
80	/* Different portions of Emacs need to call different versions of
81	malloc. The Emacs executable needs alloca to call xmalloc, because
82	ordinary malloc isn't protected from input signals. On the other
83	hand, the utilities in lib-src need alloca to call malloc; some of
84	them are very simple, and don't have an xmalloc routine.
85
86	Non-Emacs programs expect this to call use xmalloc.
87
88	Callers below should use malloc. */
89
90	#ifndef emacs
91	#define malloc xmalloc
92	#endif
93	extern pointer malloc ();
94
95	/* Define STACK_DIRECTION if you know the direction of stack
96	growth for your system; otherwise it will be automatically
97	deduced at run-time.
98
99	STACK_DIRECTION > 0 => grows toward higher addresses
100	STACK_DIRECTION < 0 => grows toward lower addresses
101	STACK_DIRECTION = 0 => direction of growth unknown */
102
103	#ifndef STACK_DIRECTION
104	#define STACK_DIRECTION 0 /* Direction unknown. */
105	#endif
106
107	#if STACK_DIRECTION != 0
108
109	#define STACK_DIR STACK_DIRECTION /* Known at compile-time. */
110
111	#else /* STACK_DIRECTION == 0; need run-time code. */
112
113	static int stack_dir; /* 1 or -1 once known. */
114	#define STACK_DIR stack_dir
115
116	static void
117	find_stack_direction ()
118	{
119	static char addr = NULL; / Address of first `dummy', once known. */
120	auto char dummy; /* To get stack address. */
121
122	if (addr == NULL)
123	{ /* Initial entry. */
124	addr = ADDRESS_FUNCTION (dummy);
125
126	find_stack_direction (); /* Recurse once. */
127	}
128	else
129	{
130	/* Second entry. */
131	if (ADDRESS_FUNCTION (dummy) > addr)
132	stack_dir = 1; /* Stack grew upward. */
133	else
134	stack_dir = -1; /* Stack grew downward. */
135	}
136	}
137
138	#endif /* STACK_DIRECTION == 0 */
139
140	/* An "alloca header" is used to:
141	(a) chain together all alloca'ed blocks;
142	(b) keep track of stack depth.
143
144	It is very important that sizeof(header) agree with malloc
145	alignment chunk size. The following default should work okay. */
146
147	#ifndef ALIGN_SIZE
148	#define ALIGN_SIZE sizeof(double)
149	#endif
150
151	typedef union hdr
152	{
153	char align[ALIGN_SIZE]; /* To force sizeof(header). */
154	struct
155	{
156	union hdr next; / For chaining headers. */
157	char deep; / For stack depth measure. */
158	} h;
159	} header;
160
161	static header last_alloca_header = NULL; / -> last alloca header. */
162
163	/* Return a pointer to at least SIZE bytes of storage,
164	which will be automatically reclaimed upon exit from
165	the procedure that called alloca. Originally, this space
166	was supposed to be taken from the current stack frame of the
167	caller, but that method cannot be made to work for some
168	implementations of C, for example under Gould's UTX/32. */
169
170	pointer
171	alloca (size)
172	unsigned size;
173	{
174	auto char probe; /* Probes stack depth: */
175	register char *depth = ADDRESS_FUNCTION (probe);
176
177	#if STACK_DIRECTION == 0
178	if (STACK_DIR == 0) /* Unknown growth direction. */
179	find_stack_direction ();
180	#endif
181
182	/* Reclaim garbage, defined as all alloca'd storage that
183	was allocated from deeper in the stack than currently. */
184
185	{
186	register header hp; / Traverses linked list. */
187
188	#ifdef emacs
189	BLOCK_INPUT;
190	#endif
191
192	for (hp = last_alloca_header; hp != NULL;)
193	if ((STACK_DIR > 0 && hp->h.deep > depth)
194	\|\| (STACK_DIR < 0 && hp->h.deep < depth))
195	{
196	register header *np = hp->h.next;
197
198	free ((pointer) hp); /* Collect garbage. */
199
200	hp = np; /* -> next header. */
201	}
202	else
203	break; /* Rest are not deeper. */
204
205	last_alloca_header = hp; /* -> last valid storage. */
206
207	#ifdef emacs
208	UNBLOCK_INPUT;
209	#endif
210	}
211
212	if (size == 0)
213	return NULL; /* No allocation required. */
214
215	/* Allocate combined header + user data storage. */
216
217	{
218	register pointer new = malloc (sizeof (header) + size);
219	/* Address of header. */
220
221	if (new == 0)
222	abort();
223
224	((header *) new)->h.next = last_alloca_header;
225	((header *) new)->h.deep = depth;
226
227	last_alloca_header = (header *) new;
228
229	/* User storage begins just after header. */
230
231	return (pointer) ((char *) new + sizeof (header));
232	}
233	}
234
235	#if defined (CRAY) && defined (CRAY_STACKSEG_END)
236
237	#ifdef DEBUG_I00AFUNC
238	#include <stdio.h>
239	#endif
240
241	#ifndef CRAY_STACK
242	#define CRAY_STACK
243	#ifndef CRAY2
244	/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
245	struct stack_control_header
246	{
247	long shgrow:32; /* Number of times stack has grown. */
248	long shaseg:32; /* Size of increments to stack. */
249	long shhwm:32; /* High water mark of stack. */
250	long shsize:32; /* Current size of stack (all segments). */
251	};
252
253	/* The stack segment linkage control information occurs at
254	the high-address end of a stack segment. (The stack
255	grows from low addresses to high addresses.) The initial
256	part of the stack segment linkage control information is
257	0200 (octal) words. This provides for register storage
258	for the routine which overflows the stack. */
259
260	struct stack_segment_linkage
261	{
262	long ss[0200]; /* 0200 overflow words. */
263	long sssize:32; /* Number of words in this segment. */
264	long ssbase:32; /* Offset to stack base. */
265	long:32;
266	long sspseg:32; /* Offset to linkage control of previous
267	segment of stack. */
268	long:32;
269	long sstcpt:32; /* Pointer to task common address block. */
270	long sscsnm; /* Private control structure number for
271	microtasking. */
272	long ssusr1; /* Reserved for user. */
273	long ssusr2; /* Reserved for user. */
274	long sstpid; /* Process ID for pid based multi-tasking. */
275	long ssgvup; /* Pointer to multitasking thread giveup. */
276	long sscray[7]; /* Reserved for Cray Research. */
277	long ssa0;
278	long ssa1;
279	long ssa2;
280	long ssa3;
281	long ssa4;
282	long ssa5;
283	long ssa6;
284	long ssa7;
285	long sss0;
286	long sss1;
287	long sss2;
288	long sss3;
289	long sss4;
290	long sss5;
291	long sss6;
292	long sss7;
293	};
294
295	#else /* CRAY2 */
296	/* The following structure defines the vector of words
297	returned by the STKSTAT library routine. */
298	struct stk_stat
299	{
300	long now; /* Current total stack size. */
301	long maxc; /* Amount of contiguous space which would
302	be required to satisfy the maximum
303	stack demand to date. */
304	long high_water; /* Stack high-water mark. */
305	long overflows; /* Number of stack overflow ($STKOFEN) calls. */
306	long hits; /* Number of internal buffer hits. */
307	long extends; /* Number of block extensions. */
308	long stko_mallocs; /* Block allocations by $STKOFEN. */
309	long underflows; /* Number of stack underflow calls ($STKRETN). */
310	long stko_free; /* Number of deallocations by $STKRETN. */
311	long stkm_free; /* Number of deallocations by $STKMRET. */
312	long segments; /* Current number of stack segments. */
313	long maxs; /* Maximum number of stack segments so far. */
314	long pad_size; /* Stack pad size. */
315	long current_address; /* Current stack segment address. */
316	long current_size; /* Current stack segment size. This
317	number is actually corrupted by STKSTAT to
318	include the fifteen word trailer area. */
319	long initial_address; /* Address of initial segment. */
320	long initial_size; /* Size of initial segment. */
321	};
322
323	/* The following structure describes the data structure which trails
324	any stack segment. I think that the description in 'asdef' is
325	out of date. I only describe the parts that I am sure about. */
326
327	struct stk_trailer
328	{
329	long this_address; /* Address of this block. */
330	long this_size; /* Size of this block (does not include
331	this trailer). */
332	long unknown2;
333	long unknown3;
334	long link; /* Address of trailer block of previous
335	segment. */
336	long unknown5;
337	long unknown6;
338	long unknown7;
339	long unknown8;
340	long unknown9;
341	long unknown10;
342	long unknown11;
343	long unknown12;
344	long unknown13;
345	long unknown14;
346	};
347
348	#endif /* CRAY2 */
349	#endif /* not CRAY_STACK */
350
351	#ifdef CRAY2
352	/* Determine a "stack measure" for an arbitrary ADDRESS.
353	I doubt that "lint" will like this much. */
354
355	static long
356	i00afunc (long *address)
357	{
358	struct stk_stat status;
359	struct stk_trailer *trailer;
360	long *block, size;
361	long result = 0;
362
363	/* We want to iterate through all of the segments. The first
364	step is to get the stack status structure. We could do this
365	more quickly and more directly, perhaps, by referencing the
366	$LM00 common block, but I know that this works. */
367
368	STKSTAT (&status);
369
370	/* Set up the iteration. */
371
372	trailer = (struct stk_trailer *) (status.current_address
373	+ status.current_size
374	- 15);
375
376	/* There must be at least one stack segment. Therefore it is
377	a fatal error if "trailer" is null. */
378
379	if (trailer == 0)
380	abort ();
381
382	/* Discard segments that do not contain our argument address. */
383
384	while (trailer != 0)
385	{
386	block = (long *) trailer->this_address;
387	size = trailer->this_size;
388	if (block == 0 \|\| size == 0)
389	abort ();
390	trailer = (struct stk_trailer *) trailer->link;
391	if ((block <= address) && (address < (block + size)))
392	break;
393	}
394
395	/* Set the result to the offset in this segment and add the sizes
396	of all predecessor segments. */
397
398	result = address - block;
399
400	if (trailer == 0)
401	{
402	return result;
403	}
404
405	do
406	{
407	if (trailer->this_size <= 0)
408	abort ();
409	result += trailer->this_size;
410	trailer = (struct stk_trailer *) trailer->link;
411	}
412	while (trailer != 0);
413
414	/* We are done. Note that if you present a bogus address (one
415	not in any segment), you will get a different number back, formed
416	from subtracting the address of the first block. This is probably
417	not what you want. */
418
419	return (result);
420	}
421
422	#else /* not CRAY2 */
423	/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP.
424	Determine the number of the cell within the stack,
425	given the address of the cell. The purpose of this
426	routine is to linearize, in some sense, stack addresses
427	for alloca. */
428
429	static long
430	i00afunc (long address)
431	{
432	long stkl = 0;
433
434	long size, pseg, this_segment, stack;
435	long result = 0;
436
437	struct stack_segment_linkage *ssptr;
438
439	/* Register B67 contains the address of the end of the
440	current stack segment. If you (as a subprogram) store
441	your registers on the stack and find that you are past
442	the contents of B67, you have overflowed the segment.
443
444	B67 also points to the stack segment linkage control
445	area, which is what we are really interested in. */
446
447	stkl = CRAY_STACKSEG_END ();
448	ssptr = (struct stack_segment_linkage *) stkl;
449
450	/* If one subtracts 'size' from the end of the segment,
451	one has the address of the first word of the segment.
452
453	If this is not the first segment, 'pseg' will be
454	nonzero. */
455
456	pseg = ssptr->sspseg;
457	size = ssptr->sssize;
458
459	this_segment = stkl - size;
460
461	/* It is possible that calling this routine itself caused
462	a stack overflow. Discard stack segments which do not
463	contain the target address. */
464
465	while (!(this_segment <= address && address <= stkl))
466	{
467	#ifdef DEBUG_I00AFUNC
468	fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
469	#endif
470	if (pseg == 0)
471	break;
472	stkl = stkl - pseg;
473	ssptr = (struct stack_segment_linkage *) stkl;
474	size = ssptr->sssize;
475	pseg = ssptr->sspseg;
476	this_segment = stkl - size;
477	}
478
479	result = address - this_segment;
480
481	/* If you subtract pseg from the current end of the stack,
482	you get the address of the previous stack segment's end.
483	This seems a little convoluted to me, but I'll bet you save
484	a cycle somewhere. */
485
486	while (pseg != 0)
487	{
488	#ifdef DEBUG_I00AFUNC
489	fprintf (stderr, "%011o %011o\n", pseg, size);
490	#endif
491	stkl = stkl - pseg;
492	ssptr = (struct stack_segment_linkage *) stkl;
493	size = ssptr->sssize;
494	pseg = ssptr->sspseg;
495	result += size;
496	}
497	return (result);
498	}
499
500	#endif /* not CRAY2 */
501	#endif /* CRAY */
502
503	#endif /* no alloca */
504	#endif /* not GCC version 2 */

Line 0 Link Here

(-)grep/btowc.c (+52 lines)
	1	/* Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
	2	This file is part of the GNU C Library.
	3	Contributed by Ulrich Drepper, <drepper@gnu.ai.mit.edu>
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Library General Public License as
	7	published by the Free Software Foundation; either version 2 of the
	8	License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Library General Public License for more details.
	14
	15	You should have received a copy of the GNU Library General Public
	16	License along with the GNU C Library; see the file COPYING.LIB. If not,
	17	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	18	Boston, MA 02111-1307, USA. */
	19
	20	#ifdef HAVE_CONFIG_H
	21	#include <config.h>
	22	#endif
	23
	24	#include <stdio.h>
	25
	26	#if ! defined(HAVE_WCHAR_H) \|\| defined(__CYGWIN__)
	27	typedef unsigned int wint_t;
	28	# undef WEOF
	29	# define WEOF ((wint_t)-1)
	30	#else
	31	#include <wchar.h>
	32	#endif
	33
	34	#ifndef weak_alias
	35	# define __btowc btowc
	36	#endif
	37
	38	/* We use UTF8 encoding for multibyte strings and therefore a valid
	39	one byte multibyte string only can have a value from 0 to 0x7f. */
	40	wint_t
	41	__btowc (c)
	42	int c;
	43	{
	44	if (WEOF != (wint_t) EOF \|\| c < 0 \|\| c > 0x7f)
	45	return WEOF;
	46	else
	47	return (wint_t) c;
	48	}
	49
	50	#ifdef weak_alias
	51	weak_alias (__btowc, btowc)
	52	#endif

Lines 1-5 Link Here

(-)grep/dfa.h (-19 / +30 lines)
1	/* dfa.h - declarations for GNU deterministic regexp compiler	1	/* dfa.h - declarations for GNU deterministic regexp compiler
2	Copyright (C) 1988 Free Software Foundation, Inc.	2	Copyright (C) 1988, 1998 Free Software Foundation, Inc.
3		3
4	This program is free software; you can redistribute it and/or modify	4	This program is free software; you can redistribute it and/or modify
5	it under the terms of the GNU General Public License as published by	5	it under the terms of the GNU General Public License as published by
Lines 13-19 Link Here
13		13
14	You should have received a copy of the GNU General Public License	14	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software	15	along with this program; if not, write to the Free Software
16	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */
17		17
18	/* Written June, 1988 by Mike Haertel */	18	/* Written June, 1988 by Mike Haertel */
19		19
Lines 22-35 Link Here
22	In addition to clobbering modularity, we eat up valuable	22	In addition to clobbering modularity, we eat up valuable
23	name space. */	23	name space. */
24		24
		25	# undef PARAMS
		26	#if __STDC__
		27	# ifndef _PTR_T
		28	# define _PTR_T
		29	typedef void * ptr_t;
		30	# endif
		31	# define PARAMS(x) x
		32	#else
		33	# ifndef _PTR_T
		34	# define _PTR_T
		35	typedef char * ptr_t;
		36	# endif
		37	# define PARAMS(x) ()
		38	#endif
		39
25	/* Number of bits in an unsigned char. */	40	/* Number of bits in an unsigned char. */
		41	#ifndef CHARBITS
26	#define CHARBITS 8	42	#define CHARBITS 8
		43	#endif
27		44
28	/* First integer value that is greater than any character code. */	45	/* First integer value that is greater than any character code. */
29	#define NOTCHAR (1 << CHARBITS)	46	#define NOTCHAR (1 << CHARBITS)
30		47
31	/* INTBITS need not be exact, just a lower bound. */	48	/* INTBITS need not be exact, just a lower bound. */
		49	#ifndef INTBITS
32	#define INTBITS (CHARBITS * sizeof (int))	50	#define INTBITS (CHARBITS * sizeof (int))
		51	#endif
33		52
34	/* Number of ints required to hold a bit for every character. */	53	/* Number of ints required to hold a bit for every character. */
35	#define CHARCLASS_INTS ((NOTCHAR + INTBITS - 1) / INTBITS)	54	#define CHARCLASS_INTS ((NOTCHAR + INTBITS - 1) / INTBITS)
Lines 301-316 Link Here
301		320
302	/* Entry points. */	321	/* Entry points. */
303		322
304	#if __STDC__
305
306	/* dfasyntax() takes two arguments; the first sets the syntax bits described	323	/* dfasyntax() takes two arguments; the first sets the syntax bits described
307	earlier in this file, and the second sets the case-folding flag. */	324	earlier in this file, and the second sets the case-folding flag. */
308	extern void dfasyntax(int, int);	325	extern void dfasyntax PARAMS ((reg_syntax_t, int));
309		326
310	/* Compile the given string of the given length into the given struct dfa.	327	/* Compile the given string of the given length into the given struct dfa.
311	Final argument is a flag specifying whether to build a searching or an	328	Final argument is a flag specifying whether to build a searching or an
312	exact matcher. */	329	exact matcher. */
313	extern void dfacomp(char , size_t, struct dfa , int);	330	extern void dfacomp PARAMS ((char , size_t, struct dfa , int));
314		331
315	/* Execute the given struct dfa on the buffer of characters. The	332	/* Execute the given struct dfa on the buffer of characters. The
316	first char * points to the beginning, and the second points to the	333	first char * points to the beginning, and the second points to the
Lines 324-349 Link Here
324	order to verify backreferencing; otherwise the flag will be cleared.	341	order to verify backreferencing; otherwise the flag will be cleared.
325	Returns NULL if no match is found, or a pointer to the first	342	Returns NULL if no match is found, or a pointer to the first
326	character after the first & shortest matching string in the buffer. */	343	character after the first & shortest matching string in the buffer. */
327	extern char dfaexec(struct dfa , char , char , int, int , int );	344	extern char dfaexec PARAMS ((struct dfa , char , char , int, int , int ));
328		345
329	/* Free the storage held by the components of a struct dfa. */	346	/* Free the storage held by the components of a struct dfa. */
330	extern void dfafree(struct dfa *);	347	extern void dfafree PARAMS ((struct dfa *));
331		348
332	/* Entry points for people who know what they're doing. */	349	/* Entry points for people who know what they're doing. */
333		350
334	/* Initialize the components of a struct dfa. */	351	/* Initialize the components of a struct dfa. */
335	extern void dfainit(struct dfa *);	352	extern void dfainit PARAMS ((struct dfa *));
336		353
337	/* Incrementally parse a string of given length into a struct dfa. */	354	/* Incrementally parse a string of given length into a struct dfa. */
338	extern void dfaparse(char , size_t, struct dfa );	355	extern void dfaparse PARAMS ((char , size_t, struct dfa ));
339		356
340	/* Analyze a parsed regexp; second argument tells whether to build a searching	357	/* Analyze a parsed regexp; second argument tells whether to build a searching
341	or an exact matcher. */	358	or an exact matcher. */
342	extern void dfaanalyze(struct dfa *, int);	359	extern void dfaanalyze PARAMS ((struct dfa *, int));
343		360
344	/* Compute, for each possible character, the transitions out of a given	361	/* Compute, for each possible character, the transitions out of a given
345	state, storing them in an array of integers. */	362	state, storing them in an array of integers. */
346	extern void dfastate(int, struct dfa *, int []);	363	extern void dfastate PARAMS ((int, struct dfa *, int []));
347		364
348	/* Error handling. */	365	/* Error handling. */
349		366
Lines 351-360 Link Here
351	takes a single argument, a NUL-terminated string describing the error.	368	takes a single argument, a NUL-terminated string describing the error.
352	The default dfaerror() prints the error message to stderr and exits.	369	The default dfaerror() prints the error message to stderr and exits.
353	The user can provide a different dfafree() if so desired. */	370	The user can provide a different dfafree() if so desired. */
354	extern void dfaerror(char *);	371	extern void dfaerror PARAMS ((const char *));
355
356	#else /* ! __STDC__ */
357	extern void dfasyntax(), dfacomp(), dfafree(), dfainit(), dfaparse();
358	extern void dfaanalyze(), dfastate(), dfaerror();
359	extern char *dfaexec();
360	#endif /* ! __STDC__ */

Line 0 Link Here

(-)grep/dosbuf.c (+186 lines)
		1	/* Messy DOS-specific code for correctly treating binary, Unix text
		2	and DOS text files.
		3
		4	This has several aspects:
		5
		6	* Guessing the file type (unless the user tells us);
		7	* Stripping CR characters from DOS text files (otherwise regex
		8	functions won't work correctly);
		9	* Reporting correct byte count with -b for any kind of file.
		10
		11	*/
		12
		13	typedef enum {
		14	UNKNOWN, DOS_BINARY, DOS_TEXT, UNIX_TEXT
		15	} File_type;
		16
		17	struct dos_map {
		18	off_t pos; /* position in buffer passed to matcher */
		19	off_t add; /* how much to add when reporting char position */
		20	};
		21
		22	static int dos_report_unix_offset = 0;
		23
		24	static File_type dos_file_type = UNKNOWN;
		25	static File_type dos_use_file_type = UNKNOWN;
		26	static off_t dos_stripped_crs = 0;
		27	static struct dos_map *dos_pos_map;
		28	static int dos_pos_map_size = 0;
		29	static int dos_pos_map_used = 0;
		30	static int inp_map_idx = 0, out_map_idx = 1;
		31
		32	/* Guess DOS file type by looking at its contents. */
		33	static inline File_type
		34	guess_type(buf, buflen)
		35	char *buf;
		36	register size_t buflen;
		37	{
		38	int crlf_seen = 0;
		39	register char *bp = buf;
		40
		41	while (buflen--)
		42	{
		43	/* Treat a file as binary if it has a NUL character. */
		44	if (!*bp)
		45	return DOS_BINARY;
		46
		47	/* CR before LF means DOS text file (unless we later see
		48	binary characters). */
		49	else if (*bp == '\r' && buflen && bp[1] == '\n')
		50	crlf_seen = 1;
		51
		52	bp++;
		53	}
		54
		55	return crlf_seen ? DOS_TEXT : UNIX_TEXT;
		56	}
		57
		58	/* Convert external DOS file representation to internal.
		59	Return the count of characters left in the buffer.
		60	Build table to map character positions when reporting byte counts. */
		61	static inline int
		62	undossify_input(buf, buflen)
		63	register char *buf;
		64	size_t buflen;
65	{
66	int chars_left = 0;
67
68	if (totalcc == 0)
69	{
70	/* New file: forget everything we knew about character
71	position mapping table and file type. */
72	inp_map_idx = 0;
73	out_map_idx = 1;
74	dos_pos_map_used = 0;
75	dos_stripped_crs = 0;
76	dos_file_type = dos_use_file_type;
77	}
78
79	/* Guess if this file is binary, unless we already know that. */
80	if (dos_file_type == UNKNOWN)
81	dos_file_type = guess_type(buf, buflen);
82
83	/* If this file is to be treated as DOS Text, strip the CR characters
84	and maybe build the table for character position mapping on output. */
85	if (dos_file_type == DOS_TEXT)
86	{
87	char *destp = buf;
88
89	while (buflen--)
90	{
91	if (*buf != '\r')
92	{
93	destp++ = buf++;
94	chars_left++;
95	}
96	else
97	{
98	buf++;
99	if (out_byte && !dos_report_unix_offset)
100	{
101	dos_stripped_crs++;
102	while (buflen && *buf == '\r')
103	{
104	dos_stripped_crs++;
105	buflen--;
106	buf++;
107	}
108	if (inp_map_idx >= dos_pos_map_size - 1)
109	{
110	dos_pos_map_size = inp_map_idx ? inp_map_idx * 2 : 1000;
111	dos_pos_map =
112	(struct dos_map )xrealloc((char )dos_pos_map,
113	dos_pos_map_size *
114	sizeof(struct dos_map));
115	}
116
117	if (!inp_map_idx)
118	{
119	/* Add sentinel entry. */
120	dos_pos_map[inp_map_idx].pos = 0;
121	dos_pos_map[inp_map_idx++].add = 0;
122
123	/* Initialize first real entry. */
124	dos_pos_map[inp_map_idx].add = 0;
125	}
126
127	/* Put the new entry. If the stripped CR characters
128	precede a Newline (the usual case), pretend that
129	they were found after the Newline. This makes
130	displayed byte offsets more reasonable in some
131	cases, and fits better the intuitive notion that
132	the line ends before the CR, not after it. */
133	inp_map_idx++;
134	dos_pos_map[inp_map_idx-1].pos =
135	(*buf == '\n' ? destp + 1 : destp ) - bufbeg + totalcc;
136	dos_pos_map[inp_map_idx].add = dos_stripped_crs;
137	dos_pos_map_used = inp_map_idx;
138
139	/* The following will be updated on the next pass. */
140	dos_pos_map[inp_map_idx].pos = destp - bufbeg + totalcc + 1;
141	}
142	}
143	}
144
145	return chars_left;
146	}
147
148	return buflen;
149	}
150
151	/* Convert internal byte count into external. */
152	static inline off_t
153	dossified_pos (byteno)
154	off_t byteno;
155	{
156	off_t pos_lo;
157	off_t pos_hi;
158
159	if (dos_file_type != DOS_TEXT \|\| dos_report_unix_offset)
160	return byteno;
161
162	/* Optimization: usually the file will be scanned sequentially.
163	So in most cases, this byte position will be found in the
164	table near the previous one, as recorded in `out_map_idx'. */
165	pos_lo = dos_pos_map[out_map_idx-1].pos;
166	pos_hi = dos_pos_map[out_map_idx].pos;
167
168	/* If the initial guess failed, search up or down, as
169	appropriate, beginning with the previous place. */
170	if (byteno >= pos_hi)
171	{
172	out_map_idx++;
173	while (out_map_idx < dos_pos_map_used &&
174	byteno >= dos_pos_map[out_map_idx].pos)
175	out_map_idx++;
176	}
177
178	else if (byteno < pos_lo)
179	{
180	out_map_idx--;
181	while (out_map_idx > 1 && byteno < dos_pos_map[out_map_idx-1].pos)
182	out_map_idx--;
183	}
184
185	return byteno + dos_pos_map[out_map_idx].add;
186	}

Lines 1-19 Link Here

(-)grep/getopt.h (-17 / +21 lines)
1	/* Declarations for getopt.	1	/* Declarations for getopt.
2	Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.	2	Copyright (C) 1989,90,91,92,93,94,96,97, 98 Free Software Foundation, Inc.
3		3
4	This program is free software; you can redistribute it and/or modify it	4	This file is part of the GNU C Library. Its master source is NOT part of
5	under the terms of the GNU General Public License as published by the	5	the C library, however. The master source lives in /gd/gnu/lib.
6	Free Software Foundation; either version 2, or (at your option) any
7	later version.
8		6
9	This program is distributed in the hope that it will be useful,	7	The GNU C Library is free software; you can redistribute it and/or
		8	modify it under the terms of the GNU Library General Public License as
		9	published by the Free Software Foundation; either version 2 of the
		10	License, or (at your option) any later version.
		11
		12	The GNU C Library is distributed in the hope that it will be useful,
10	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12	GNU General Public License for more details.	15	Library General Public License for more details.
13		16
14	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU Library General Public
15	along with this program; if not, write to the Free Software	18	License along with the GNU C Library; see the file COPYING.LIB. If not,
16	Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */	19	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
		20	Boston, MA 02111-1307, USA. */
17		21
18	#ifndef _GETOPT_H	22	#ifndef _GETOPT_H
19	#define _GETOPT_H 1	23	#define _GETOPT_H 1
Lines 36-42 Link Here
36		40
37	On entry to `getopt', zero means this is the first call; initialize.	41	On entry to `getopt', zero means this is the first call; initialize.
38		42
39	When `getopt' returns EOF, this is the index of the first of the	43	When `getopt' returns -1, this is the index of the first of the
40	non-option elements that the caller should itself scan.	44	non-option elements that the caller should itself scan.
41		45
42	Otherwise, `optind' communicates from one call to the next	46	Otherwise, `optind' communicates from one call to the next
Lines 76-82 Link Here
76		80
77	struct option	81	struct option
78	{	82	{
79	#if __STDC__	83	#if defined (__STDC__) && __STDC__
80	const char *name;	84	const char *name;
81	#else	85	#else
82	char *name;	86	char *name;
Lines 94-108 Link Here
94	#define required_argument 1	98	#define required_argument 1
95	#define optional_argument 2	99	#define optional_argument 2
96		100
97	#if __STDC__	101	#if defined (__STDC__) && __STDC__
98	#if defined(__GNU_LIBRARY__)	102	#ifdef __GNU_LIBRARY__
99	/* Many other libraries have conflicting prototypes for getopt, with	103	/* Many other libraries have conflicting prototypes for getopt, with
100	differences in the consts, in stdlib.h. To avoid compilation	104	differences in the consts, in stdlib.h. To avoid compilation
101	errors, only prototype getopt for the GNU C library. */	105	errors, only prototype getopt for the GNU C library. */
102	extern int getopt (int argc, char const argv, const char *shortopts);	106	extern int getopt (int argc, char const argv, const char *shortopts);
103	#else /* not __GNU_LIBRARY__ */	107	#else /* not __GNU_LIBRARY__ */
104	extern int getopt ();	108	extern int getopt ();
105	#endif /* not __GNU_LIBRARY__ */	109	#endif /* __GNU_LIBRARY__ */
106	extern int getopt_long (int argc, char const argv, const char *shortopts,	110	extern int getopt_long (int argc, char const argv, const char *shortopts,
107	const struct option longopts, int longind);	111	const struct option longopts, int longind);
108	extern int getopt_long_only (int argc, char const argv,	112	extern int getopt_long_only (int argc, char const argv,
Lines 120-126 Link Here
120	extern int getopt_long_only ();	124	extern int getopt_long_only ();
121		125
122	extern int _getopt_internal ();	126	extern int _getopt_internal ();
123	#endif /* not __STDC__ */	127	#endif /* __STDC__ */
124		128
125	#ifdef __cplusplus	129	#ifdef __cplusplus
126	}	130	}

Line 0 Link Here

(-)grep/getopt1.c (+189 lines)
		1	/* getopt_long and getopt_long_only entry points for GNU getopt.
		2	Copyright (C) 1987,88,89,90,91,92,93,94,96,97, 98 Free Software Foundation, Inc.
		3
		4	This file is part of the GNU C Library. Its master source is NOT part of
		5	the C library, however. The master source lives in /gd/gnu/lib.
		6
		7	The GNU C Library is free software; you can redistribute it and/or
		8	modify it under the terms of the GNU Library General Public License as
		9	published by the Free Software Foundation; either version 2 of the
		10	License, or (at your option) any later version.
		11
		12	The GNU C Library is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
		15	Library General Public License for more details.
		16
		17	You should have received a copy of the GNU Library General Public
		18	License along with the GNU C Library; see the file COPYING.LIB. If not,
		19	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
		20	Boston, MA 02111-1307, USA. */
		21
		22	#ifdef HAVE_CONFIG_H
		23	#include <config.h>
		24	#endif
		25
		26	#include "getopt.h"
		27
		28	#if !defined (__STDC__) \|\| !__STDC__
		29	/* This is a separate conditional since some stdc systems
		30	reject `defined (const)'. */
		31	#ifndef const
		32	#define const
		33	#endif
		34	#endif
		35
		36	#include <stdio.h>
		37
		38	/* Comment out all this code if we are using the GNU C Library, and are not
		39	actually compiling the library itself. This code is part of the GNU C
		40	Library, but also included in many other GNU distributions. Compiling
		41	and linking in this code is a waste when using the GNU C library
		42	(especially if it is a shared library). Rather than having every GNU
		43	program understand `configure --with-gnu-libc' and omit the object files,
		44	it is simpler to just do this in the source for each such file. */
		45
		46	#define GETOPT_INTERFACE_VERSION 2
		47	#if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
		48	#include <gnu-versions.h>
		49	#if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
		50	#define ELIDE_CODE
		51	#endif
		52	#endif
		53
		54	#ifndef ELIDE_CODE
		55
		56
		57	/* This needs to come after some library #include
		58	to get __GNU_LIBRARY__ defined. */
		59	#ifdef __GNU_LIBRARY__
		60	#include <stdlib.h>
		61	#endif
		62
		63	#ifndef NULL
		64	#define NULL 0
65	#endif
66
67	int
68	getopt_long (argc, argv, options, long_options, opt_index)
69	int argc;
70	char const argv;
71	const char *options;
72	const struct option *long_options;
73	int *opt_index;
74	{
75	return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
76	}
77
78	/* Like getopt_long, but '-' as well as '--' can indicate a long option.
79	If an option that starts with '-' (not '--') doesn't match a long option,
80	but does match a short option, it is parsed as a short option
81	instead. */
82
83	int
84	getopt_long_only (argc, argv, options, long_options, opt_index)
85	int argc;
86	char const argv;
87	const char *options;
88	const struct option *long_options;
89	int *opt_index;
90	{
91	return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
92	}
93
94
95	#endif /* Not ELIDE_CODE. */
96
97	#ifdef TEST
98
99	#include <stdio.h>
100
101	int
102	main (argc, argv)
103	int argc;
104	char **argv;
105	{
106	int c;
107	int digit_optind = 0;
108
109	while (1)
110	{
111	int this_option_optind = optind ? optind : 1;
112	int option_index = 0;
113	static struct option long_options[] =
114	{
115	{"add", 1, 0, 0},
116	{"append", 0, 0, 0},
117	{"delete", 1, 0, 0},
118	{"verbose", 0, 0, 0},
119	{"create", 0, 0, 0},
120	{"file", 1, 0, 0},
121	{0, 0, 0, 0}
122	};
123
124	c = getopt_long (argc, argv, "abc:d:0123456789",
125	long_options, &option_index);
126	if (c == -1)
127	break;
128
129	switch (c)
130	{
131	case 0:
132	printf (_("option %s"), long_options[option_index].name);
133	if (optarg)
134	printf (_(" with arg %s"), optarg);
135	printf ("\n");
136	break;
137
138	case '0':
139	case '1':
140	case '2':
141	case '3':
142	case '4':
143	case '5':
144	case '6':
145	case '7':
146	case '8':
147	case '9':
148	if (digit_optind != 0 && digit_optind != this_option_optind)
149	printf (_("digits occur in two different argv-elements.\n"));
150	digit_optind = this_option_optind;
151	printf (_("option %c\n"), c);
152	break;
153
154	case 'a':
155	printf (_("option a\n"));
156	break;
157
158	case 'b':
159	printf (_("option b\n"));
160	break;
161
162	case 'c':
163	printf (_("option c with value `%s'\n"), optarg);
164	break;
165
166	case 'd':
167	printf (_("option d with value `%s'\n"), optarg);
168	break;
169
170	case '?':
171	break;
172
173	default:
174	printf (_("?? getopt returned character code 0%o ??\n"), c);
175	}
176	}
177
178	if (optind < argc)
179	{
180	printf (_("non-option ARGV-elements: "));
181	while (optind < argc)
182	printf ("%s ", argv[optind++]);
183	printf ("\n");
184	}
185
186	exit (0);
187	}
188
189	#endif /* TEST */

Lines 1-42 Link Here

(-)grep/getpagesize.h (-38 / +37 lines)
1	#ifdef BSD	1	/* Emulate getpagesize on systems that lack it. */
2	#ifndef BSD4_1
3	#define HAVE_GETPAGESIZE
4	#endif
5	#endif
6		2
7	#ifndef HAVE_GETPAGESIZE	3	#ifndef HAVE_GETPAGESIZE
8		4
9	#ifdef VMS	5	# ifdef VMS
10	#define getpagesize() 512	6	# define getpagesize() 512
11	#endif	7	# endif
12		8
13	#ifdef HAVE_UNISTD_H	9	# ifdef HAVE_UNISTD_H
14	#include <unistd.h>	10	# include <unistd.h>
15	#endif	11	# endif
16		12
17	#ifdef _SC_PAGESIZE	13	# ifdef _SC_PAGESIZE
18	#define getpagesize() sysconf(_SC_PAGESIZE)	14	# define getpagesize() sysconf(_SC_PAGESIZE)
19	#else	15	# else /* no _SC_PAGESIZE */
20		16	# ifdef HAVE_SYS_PARAM_H
21	#ifdef HAVE_SYS_PARAM_H	17	# include <sys/param.h>
22	#include <sys/param.h>	18	# ifdef EXEC_PAGESIZE
23		19	# define getpagesize() EXEC_PAGESIZE
24	#ifdef EXEC_PAGESIZE	20	# else /* no EXEC_PAGESIZE */
25	#define getpagesize() EXEC_PAGESIZE	21	# ifdef NBPG
26	#else	22	# define getpagesize() NBPG * CLSIZE
27	#ifdef NBPG	23	# ifndef CLSIZE
28	#define getpagesize() NBPG * CLSIZE	24	# define CLSIZE 1
29	#ifndef CLSIZE	25	# endif /* no CLSIZE */
30	#define CLSIZE 1	26	# else /* no NBPG */
31	#endif /* no CLSIZE */	27	# ifdef NBPC
32	#else /* no NBPG */	28	# define getpagesize() NBPC
33	#define getpagesize() NBPC	29	# else /* no NBPC */
34	#endif /* no NBPG */	30	# ifdef PAGESIZE
35	#endif /* no EXEC_PAGESIZE */	31	# define getpagesize() PAGESIZE
36	#else /* !HAVE_SYS_PARAM_H */	32	# endif /* PAGESIZE */
37	#define getpagesize() 8192 /* punt totally */	33	# endif /* no NBPC */
38	#endif /* !HAVE_SYS_PARAM_H */	34	# endif /* no NBPG */
39	#endif /* no _SC_PAGESIZE */	35	# endif /* no EXEC_PAGESIZE */
40		36	# else /* no HAVE_SYS_PARAM_H */
41	#endif /* not HAVE_GETPAGESIZE */	37	# define getpagesize() 8192 /* punt totally */
		38	# endif /* no HAVE_SYS_PARAM_H */
		39	# endif /* no _SC_PAGESIZE */
42		40
		41	#endif /* no HAVE_GETPAGESIZE */

Lines 1-10 Link Here

(-)grep/kwset.c (-38 / +35 lines)
1	/* kwset.c - search for any of a set of keywords.	1	/* kwset.c - search for any of a set of keywords.
2	Copyright 1989 Free Software Foundation	2	Copyright (C) 1989, 1998 Free Software Foundation, Inc.
3	Written August 1989 by Mike Haertel.
4		3
5	This program is free software; you can redistribute it and/or modify	4	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by	5	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 1, or (at your option)	6	the Free Software Foundation; either version 2, or (at your option)
8	any later version.	7	any later version.
9		8
10	This program is distributed in the hope that it will be useful,	9	This program is distributed in the hope that it will be useful,
Lines 14-21 Link Here
14		13
15	You should have received a copy of the GNU General Public License	14	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software	15	along with this program; if not, write to the Free Software
17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
		17	02111-1307, USA. */
18		18
		19	/* Written August 1989 by Mike Haertel.
19	The author may be reached (Email) at the address mike@ai.mit.edu,	20	The author may be reached (Email) at the address mike@ai.mit.edu,
20	or (US mail) as Mike Haertel c/o Free Software Foundation. */	21	or (US mail) as Mike Haertel c/o Free Software Foundation. */
21		22
Lines 27-69 Link Here
27	String Matching: An Aid to Bibliographic Search," CACM June 1975,	28	String Matching: An Aid to Bibliographic Search," CACM June 1975,
28	Vol. 18, No. 6, which describes the failure function used below. */	29	Vol. 18, No. 6, which describes the failure function used below. */
29		30
30		31	#ifdef HAVE_CONFIG_H
31	#ifdef STDC_HEADERS	32	# include <config.h>
32	#include <limits.h>
33	#include <stdlib.h>
34	#else
35	#define INT_MAX 2147483647
36	#define UCHAR_MAX 255
37	#ifdef __STDC__
38	#include <stddef.h>
39	#else
40	#include <sys/types.h>
41	#endif
42	extern char *malloc();
43	extern void free();
44	#endif
45
46	#ifdef HAVE_MEMCHR
47	#include <string.h>
48	#ifdef NEED_MEMORY_H
49	#include <memory.h>
50	#endif
51	#else
52	#ifdef __STDC__
53	extern void *memchr();
54	#else
55	extern char *memchr();
56	#endif
57	#endif	33	#endif
		34	#include <sys/types.h>
		35	#include "system.h"
		36	#include "kwset.h"
		37	#include "obstack.h"
58		38
59	#ifdef GREP	39	#ifdef GREP
60	extern char *xmalloc();	40	extern char *xmalloc();
61	#define malloc xmalloc	41	# undef malloc
		42	# define malloc xmalloc
62	#endif	43	#endif
63		44
64	#include "kwset.h"
65	#include "obstack.h"
66
67	#define NCHAR (UCHAR_MAX + 1)	45	#define NCHAR (UCHAR_MAX + 1)
68	#define obstack_chunk_alloc malloc	46	#define obstack_chunk_alloc malloc
69	#define obstack_chunk_free free	47	#define obstack_chunk_free free
Lines 106-111 Link Here
106	char trans; / Character translation table. */	84	char trans; / Character translation table. */
107	};	85	};
108		86
		87	/* prototypes */
		88	static void enqueue PARAMS((struct tree , struct trie *));
		89	static void treefails PARAMS((register struct tree , struct trie , struct trie *));
		90	static void treedelta PARAMS((register struct tree ,register unsigned int, unsigned char ));
		91	static int hasevery PARAMS((register struct tree , register struct tree ));
		92	static void treenext PARAMS((struct tree , struct trie *));
		93	static char * bmexec PARAMS((kwset_t, char *, size_t));
		94	static char * cwexec PARAMS((kwset_t, char , size_t, struct kwsmatch ));
		95
109	/* Allocate and initialize a keyword set object, returning an opaque	96	/* Allocate and initialize a keyword set object, returning an opaque
110	pointer to it. Return NULL if memory is not available. */	97	pointer to it. Return NULL if memory is not available. */
111	kwset_t	98	kwset_t
Lines 194-206 Link Here
194	link = (struct tree *) obstack_alloc(&kwset->obstack,	181	link = (struct tree *) obstack_alloc(&kwset->obstack,
195	sizeof (struct tree));	182	sizeof (struct tree));
196	if (!link)	183	if (!link)
197	return "memory exhausted";	184	return _("memory exhausted");
198	link->llink = 0;	185	link->llink = 0;
199	link->rlink = 0;	186	link->rlink = 0;
200	link->trie = (struct trie *) obstack_alloc(&kwset->obstack,	187	link->trie = (struct trie *) obstack_alloc(&kwset->obstack,
201	sizeof (struct trie));	188	sizeof (struct trie));
202	if (!link->trie)	189	if (!link->trie)
203	return "memory exhausted";	190	return _("memory exhausted");
204	link->trie->accepting = 0;	191	link->trie->accepting = 0;
205	link->trie->links = 0;	192	link->trie->links = 0;
206	link->trie->parent = trie;	193	link->trie->parent = trie;
Lines 249-254 Link Here
249	r->balance = t->balance != (char) -1 ? 0 : 1;	236	r->balance = t->balance != (char) -1 ? 0 : 1;
250	t->balance = 0;	237	t->balance = 0;
251	break;	238	break;
		239	default:
		240	abort ();
252	}	241	}
253	break;	242	break;
254	case 2:	243	case 2:
Lines 267-274 Link Here
267	r->balance = t->balance != (char) -1 ? 0 : 1;	256	r->balance = t->balance != (char) -1 ? 0 : 1;
268	t->balance = 0;	257	t->balance = 0;
269	break;	258	break;
		259	default:
		260	abort ();
270	}	261	}
271	break;	262	break;
		263	default:
		264	abort ();
272	}	265	}
273		266
274	if (dirs[depth - 1] == L)	267	if (dirs[depth - 1] == L)
Lines 591-597 Link Here
591	d = d1[U((tp += d)[-1])];	584	d = d1[U((tp += d)[-1])];
592	if (d != 0)	585	if (d != 0)
593	continue;	586	continue;
594	if (tp[-2] == gc)	587	if (U(tp[-2]) == gc)
595	{	588	{
596	for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)	589	for (i = 3; i <= len && U(tp[-i]) == U(sp[-i]); ++i)
597	;	590	;
Lines 620-625 Link Here
620	register char end, qlim;	613	register char end, qlim;
621	register struct tree *tree;	614	register struct tree *tree;
622	register char *trans;	615	register char *trans;
		616
		617	#ifdef lint
		618	accept = NULL;
		619	#endif
623		620
624	/* Initialize register copies and look for easy ways out. */	621	/* Initialize register copies and look for easy ways out. */
625	kwset = (struct kwset *) kws;	622	kwset = (struct kwset *) kws;

Lines 1-10 Link Here

(-)grep/kwset.h (-23 / +11 lines)
1	/* kwset.h - header declaring the keyword set library.	1	/* kwset.h - header declaring the keyword set library.
2	Copyright 1989 Free Software Foundation	2	Copyright (C) 1989, 1998 Free Software Foundation, Inc.
3	Written August 1989 by Mike Haertel.
4		3
5	This program is free software; you can redistribute it and/or modify	4	This program is free software; you can redistribute it and/or modify
6	it under the terms of the GNU General Public License as published by	5	it under the terms of the GNU General Public License as published by
7	the Free Software Foundation; either version 1, or (at your option)	6	the Free Software Foundation; either version 2, or (at your option)
8	any later version.	7	any later version.
9		8
10	This program is distributed in the hope that it will be useful,	9	This program is distributed in the hope that it will be useful,
Lines 14-21 Link Here
14		13
15	You should have received a copy of the GNU General Public License	14	You should have received a copy of the GNU General Public License
16	along with this program; if not, write to the Free Software	15	along with this program; if not, write to the Free Software
17	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
		17	02111-1307, USA. */
18		18
		19	/* Written August 1989 by Mike Haertel.
19	The author may be reached (Email) at the address mike@ai.mit.edu,	20	The author may be reached (Email) at the address mike@ai.mit.edu,
20	or (US mail) as Mike Haertel c/o Free Software Foundation. */	21	or (US mail) as Mike Haertel c/o Free Software Foundation. */
21		22
Lines 26-49 Link Here
26	size_t size[1]; /* Length of each submatch. */	27	size_t size[1]; /* Length of each submatch. */
27	};	28	};
28		29
29	#if __STDC__	30	typedef ptr_t kwset_t;
30
31	typedef void *kwset_t;
32		31
33	/* Return an opaque pointer to a newly allocated keyword set, or NULL	32	/* Return an opaque pointer to a newly allocated keyword set, or NULL
34	if enough memory cannot be obtained. The argument if non-NULL	33	if enough memory cannot be obtained. The argument if non-NULL
35	specifies a table of character translations to be applied to all	34	specifies a table of character translations to be applied to all
36	pattern and search text. */	35	pattern and search text. */
37	extern kwset_t kwsalloc(char *);	36	extern kwset_t kwsalloc PARAMS((char *));
38		37
39	/* Incrementally extend the keyword set to include the given string.	38	/* Incrementally extend the keyword set to include the given string.
40	Return NULL for success, or an error message. Remember an index	39	Return NULL for success, or an error message. Remember an index
41	number for each keyword included in the set. */	40	number for each keyword included in the set. */
42	extern char kwsincr(kwset_t, char , size_t);	41	extern char kwsincr PARAMS((kwset_t, char , size_t));
43		42
44	/* When the keyword set has been completely built, prepare it for	43	/* When the keyword set has been completely built, prepare it for
45	use. Return NULL for success, or an error message. */	44	use. Return NULL for success, or an error message. */
46	extern char *kwsprep(kwset_t);	45	extern char *kwsprep PARAMS((kwset_t));
47		46
48	/* Search through the given buffer for a member of the keyword set.	47	/* Search through the given buffer for a member of the keyword set.
49	Return a pointer to the leftmost longest match found, or NULL if	48	Return a pointer to the leftmost longest match found, or NULL if
Lines 51-69 Link Here
51	the matching substring in the integer it points to. Similarly,	50	the matching substring in the integer it points to. Similarly,
52	if foundindex is non-NULL, store the index of the particular	51	if foundindex is non-NULL, store the index of the particular
53	keyword found therein. */	52	keyword found therein. */
54	extern char kwsexec(kwset_t, char , size_t, struct kwsmatch *);	53	extern char kwsexec PARAMS((kwset_t, char , size_t, struct kwsmatch *));
55		54
56	/* Deallocate the given keyword set and all its associated storage. */	55	/* Deallocate the given keyword set and all its associated storage. */
57	extern void kwsfree(kwset_t);	56	extern void kwsfree PARAMS((kwset_t));
58
59	#else
60
61	typedef char *kwset_t;
62
63	extern kwset_t kwsalloc();
64	extern char *kwsincr();
65	extern char *kwsprep();
66	extern char *kwsexec();
67	extern void kwsfree();
68		57
69	#endif

Line 0 Link Here

(-)grep/memchr.c (+198 lines)
		1	/* Copyright (C) 1991, 1993, 1998 Free Software Foundation, Inc.
		2	Based on strlen implemention by Torbjorn Granlund (tege@sics.se),
		3	with help from Dan Sahlin (dan@sics.se) and
		4	commentary by Jim Blandy (jimb@ai.mit.edu);
		5	adaptation to memchr suggested by Dick Karpinski (dick@cca.ucsf.edu),
		6	and implemented by Roland McGrath (roland@ai.mit.edu).
		7
		8	NOTE: The canonical source of this file is maintained with the GNU C Library.
		9	Bugs can be reported to bug-glibc@prep.ai.mit.edu.
		10
		11	This program is free software; you can redistribute it and/or modify it
		12	under the terms of the GNU General Public License as published by the
		13	Free Software Foundation; either version 2, or (at your option) any
		14	later version.
		15
		16	This program is distributed in the hope that it will be useful,
		17	but WITHOUT ANY WARRANTY; without even the implied warranty of
		18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		19	GNU General Public License for more details.
		20
		21	You should have received a copy of the GNU General Public License
		22	along with this program; if not, write to the Free Software
		23	Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
		24
		25	#ifdef HAVE_CONFIG_H
		26	#include <config.h>
		27	#endif
		28
		29	#undef __ptr_t
		30	#if defined (__cplusplus) \|\| (defined (__STDC__) && __STDC__)
		31	# define __ptr_t void *
		32	#else /* Not C++ or ANSI C. */
		33	# define __ptr_t char *
		34	#endif /* C++ or ANSI C. */
		35
		36	#if defined (_LIBC)
		37	# include <string.h>
		38	#endif
		39
		40	#if defined (HAVE_LIMITS_H) \|\| defined (_LIBC)
		41	# include <limits.h>
		42	#endif
		43
		44	#define LONG_MAX_32_BITS 2147483647
		45
		46	#ifndef LONG_MAX
		47	#define LONG_MAX LONG_MAX_32_BITS
		48	#endif
		49
		50	#include <sys/types.h>
		51
		52
		53	/* Search no more than N bytes of S for C. */
		54
		55	__ptr_t
		56	memchr (s, c, n)
		57	const __ptr_t s;
		58	int c;
		59	size_t n;
		60	{
		61	const unsigned char *char_ptr;
		62	const unsigned long int *longword_ptr;
		63	unsigned long int longword, magic_bits, charmask;
		64
65	c = (unsigned char) c;
66
67	/* Handle the first few characters by reading one character at a time.
68	Do this until CHAR_PTR is aligned on a longword boundary. */
69	for (char_ptr = (const unsigned char *) s;
70	n > 0 && ((unsigned long int) char_ptr
71	& (sizeof (longword) - 1)) != 0;
72	--n, ++char_ptr)
73	if (*char_ptr == c)
74	return (__ptr_t) char_ptr;
75
76	/* All these elucidatory comments refer to 4-byte longwords,
77	but the theory applies equally well to 8-byte longwords. */
78
79	longword_ptr = (unsigned long int *) char_ptr;
80
81	/* Bits 31, 24, 16, and 8 of this number are zero. Call these bits
82	the "holes." Note that there is a hole just to the left of
83	each byte, with an extra at the end:
84
85	bits: 01111110 11111110 11111110 11111111
86	bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD
87
88	The 1-bits make sure that carries propagate to the next 0-bit.
89	The 0-bits provide holes for carries to fall into. */
90
91	if (sizeof (longword) != 4 && sizeof (longword) != 8)
92	abort ();
93
94	#if LONG_MAX <= LONG_MAX_32_BITS
95	magic_bits = 0x7efefeff;
96	#else
97	magic_bits = ((unsigned long int) 0x7efefefe << 32) \| 0xfefefeff;
98	#endif
99
100	/* Set up a longword, each of whose bytes is C. */
101	charmask = c \| (c << 8);
102	charmask \|= charmask << 16;
103	#if LONG_MAX > LONG_MAX_32_BITS
104	charmask \|= charmask << 32;
105	#endif
106
107	/* Instead of the traditional loop which tests each character,
108	we will test a longword at a time. The tricky part is testing
109	if any of the four bytes in the longword in question are zero. */
110	while (n >= sizeof (longword))
111	{
112	/* We tentatively exit the loop if adding MAGIC_BITS to
113	LONGWORD fails to change any of the hole bits of LONGWORD.
114
115	1) Is this safe? Will it catch all the zero bytes?
116	Suppose there is a byte with all zeros. Any carry bits
117	propagating from its left will fall into the hole at its
118	least significant bit and stop. Since there will be no
119	carry from its most significant bit, the LSB of the
120	byte to the left will be unchanged, and the zero will be
121	detected.
122
123	2) Is this worthwhile? Will it ignore everything except
124	zero bytes? Suppose every byte of LONGWORD has a bit set
125	somewhere. There will be a carry into bit 8. If bit 8
126	is set, this will carry into bit 16. If bit 8 is clear,
127	one of bits 9-15 must be set, so there will be a carry
128	into bit 16. Similarly, there will be a carry into bit
129	24. If one of bits 24-30 is set, there will be a carry
130	into bit 31, so all of the hole bits will be changed.
131
132	The one misfire occurs when bits 24-30 are clear and bit
133	31 is set; in this case, the hole at bit 31 is not
134	changed. If we had access to the processor carry flag,
135	we could close this loophole by putting the fourth hole
136	at bit 32!
137
138	So it ignores everything except 128's, when they're aligned
139	properly.
140
141	3) But wait! Aren't we looking for C, not zero?
142	Good point. So what we do is XOR LONGWORD with a longword,
143	each of whose bytes is C. This turns each byte that is C
144	into a zero. */
145
146	longword = *longword_ptr++ ^ charmask;
147
148	/* Add MAGIC_BITS to LONGWORD. */
149	if ((((longword + magic_bits)
150
151	/* Set those bits that were unchanged by the addition. */
152	^ ~longword)
153
154	/* Look at only the hole bits. If any of the hole bits
155	are unchanged, most likely one of the bytes was a
156	zero. */
157	& ~magic_bits) != 0)
158	{
159	/* Which of the bytes was C? If none of them were, it was
160	a misfire; continue the search. */
161
162	const unsigned char cp = (const unsigned char ) (longword_ptr - 1);
163
164	if (cp[0] == c)
165	return (__ptr_t) cp;
166	if (cp[1] == c)
167	return (__ptr_t) &cp[1];
168	if (cp[2] == c)
169	return (__ptr_t) &cp[2];
170	if (cp[3] == c)
171	return (__ptr_t) &cp[3];
172	#if LONG_MAX > 2147483647
173	if (cp[4] == c)
174	return (__ptr_t) &cp[4];
175	if (cp[5] == c)
176	return (__ptr_t) &cp[5];
177	if (cp[6] == c)
178	return (__ptr_t) &cp[6];
179	if (cp[7] == c)
180	return (__ptr_t) &cp[7];
181	#endif
182	}
183
184	n -= sizeof (longword);
185	}
186
187	char_ptr = (const unsigned char *) longword_ptr;
188
189	while (n-- > 0)
190	{
191	if (*char_ptr == c)
192	return (__ptr_t) char_ptr;
193	else
194	++char_ptr;
195	}
196
197	return 0;
198	}

Line 0 Link Here

(-)grep/savedir.c (+135 lines)
		1	/* savedir.c -- save the list of files in a directory in a string
		2	Copyright (C) 1990, 1997, 1998 Free Software Foundation, Inc.
		3
		4	This program is free software; you can redistribute it and/or modify
		5	it under the terms of the GNU General Public License as published by
		6	the Free Software Foundation; either version 2, or (at your option)
		7	any later version.
		8
		9	This program is distributed in the hope that it will be useful,
		10	but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12	GNU General Public License for more details.
		13
		14	You should have received a copy of the GNU General Public License
		15	along with this program; if not, write to the Free Software Foundation,
		16	Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
		17
		18	/* Written by David MacKenzie <djm@gnu.ai.mit.edu>. */
		19
		20	#if HAVE_CONFIG_H
		21	# include <config.h>
		22	#endif
		23
		24	#include <sys/types.h>
		25
		26	#if HAVE_UNISTD_H
		27	# include <unistd.h>
		28	#endif
		29
		30	#if HAVE_DIRENT_H
		31	# include <dirent.h>
		32	# define NAMLEN(dirent) strlen((dirent)->d_name)
		33	#else
		34	# define dirent direct
		35	# define NAMLEN(dirent) (dirent)->d_namlen
		36	# if HAVE_SYS_NDIR_H
		37	# include <sys/ndir.h>
		38	# endif
		39	# if HAVE_SYS_DIR_H
		40	# include <sys/dir.h>
		41	# endif
		42	# if HAVE_NDIR_H
		43	# include <ndir.h>
		44	# endif
		45	#endif
		46
		47	#ifdef CLOSEDIR_VOID
		48	/* Fake a return value. */
		49	# define CLOSEDIR(d) (closedir (d), 0)
		50	#else
		51	# define CLOSEDIR(d) closedir (d)
		52	#endif
		53
		54	#ifdef STDC_HEADERS
		55	# include <stdlib.h>
		56	# include <string.h>
		57	#else
		58	char *malloc ();
		59	char *realloc ();
		60	#endif
		61	#ifndef NULL
		62	# define NULL 0
		63	#endif
		64
65	#ifndef stpcpy
66	char *stpcpy ();
67	#endif
68
69	#include "savedir.h"
70
71	/* Return a freshly allocated string containing the filenames
72	in directory DIR, separated by '\0' characters;
73	the end is marked by two '\0' characters in a row.
74	NAME_SIZE is the number of bytes to initially allocate
75	for the string; it will be enlarged as needed.
76	Return NULL if DIR cannot be opened or if out of memory. */
77
78	char *
79	savedir (dir, name_size)
80	const char *dir;
81	unsigned int name_size;
82	{
83	DIR *dirp;
84	struct dirent *dp;
85	char *name_space;
86	char *namep;
87
88	dirp = opendir (dir);
89	if (dirp == NULL)
90	return NULL;
91
92	name_space = (char *) malloc (name_size);
93	if (name_space == NULL)
94	{
95	closedir (dirp);
96	return NULL;
97	}
98	namep = name_space;
99
100	while ((dp = readdir (dirp)) != NULL)
101	{
102	/* Skip "." and ".." (some NFS filesystems' directories lack them). */
103	if (dp->d_name[0] != '.'
104	\|\| (dp->d_name[1] != '\0'
105	&& (dp->d_name[1] != '.' \|\| dp->d_name[2] != '\0')))
106	{
107	unsigned size_needed = (namep - name_space) + NAMLEN (dp) + 2;
108
109	if (size_needed > name_size)
110	{
111	char *new_name_space;
112
113	while (size_needed > name_size)
114	name_size += 1024;
115
116	new_name_space = realloc (name_space, name_size);
117	if (new_name_space == NULL)
118	{
119	closedir (dirp);
120	return NULL;
121	}
122	namep += new_name_space - name_space;
123	name_space = new_name_space;
124	}
125	namep = stpcpy (namep, dp->d_name) + 1;
126	}
127	}
128	*namep = '\0';
129	if (CLOSEDIR (dirp))
130	{
131	free (name_space);
132	return NULL;
133	}
134	return name_space;
135	}

Line 0 Link Here

(-)grep/savedir.h (+15 lines)
	1	#if !defined SAVEDIR_H_
	2	# define SAVEDIR_H_
	3
	4	# ifndef PARAMS
	5	# if defined PROTOTYPES \|\| (defined __STDC__ && __STDC__)
	6	# define PARAMS(Args) Args
	7	# else
	8	# define PARAMS(Args) ()
	9	# endif
	10	# endif
	11
	12	char *
	13	savedir PARAMS ((const char *dir, unsigned int name_size));
	14
	15	#endif

Lines 1-5 Link Here

(-)grep/search.c (-76 / +31 lines)
1	/* search.c - searching subroutines using dfa, kwset and regex for grep.	1	/* search.c - searching subroutines using dfa, kwset and regex for grep.
2	Copyright (C) 1992 Free Software Foundation, Inc.	2	Copyright (C) 1992, 1998 Free Software Foundation, Inc.
3		3
4	This program is free software; you can redistribute it and/or modify	4	This program is free software; you can redistribute it and/or modify
5	it under the terms of the GNU General Public License as published by	5	it under the terms of the GNU General Public License as published by
Lines 13-92 Link Here
13		13
14	You should have received a copy of the GNU General Public License	14	You should have received a copy of the GNU General Public License
15	along with this program; if not, write to the Free Software	15	along with this program; if not, write to the Free Software
16	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
		17	02111-1307, USA. */
17		18
18	Written August 1992 by Mike Haertel. */	19	/* Written August 1992 by Mike Haertel. */
19		20
20	#include <ctype.h>	21	#ifdef HAVE_CONFIG_H
21		22	# include <config.h>
22	#ifdef STDC_HEADERS
23	#include <limits.h>
24	#include <stdlib.h>
25	#else
26	#define UCHAR_MAX 255
27	#include <sys/types.h>
28	extern char *malloc();
29	#endif
30
31	#ifdef HAVE_MEMCHR
32	#include <string.h>
33	#ifdef NEED_MEMORY_H
34	#include <memory.h>
35	#endif
36	#else
37	#ifdef __STDC__
38	extern void *memchr();
39	#else
40	extern char *memchr();
41	#endif
42	#endif	23	#endif
43		24	#include <sys/types.h>
44	#if defined(HAVE_STRING_H) \|\| defined(STDC_HEADERS)	25	#include "system.h"
45	#undef bcopy
46	#define bcopy(s, d, n) memcpy((d), (s), (n))
47	#endif
48
49	#if defined(isascii) && !defined(__FreeBSD__)
50	#define ISALNUM(C) (isascii(C) && isalnum(C))
51	#define ISUPPER(C) (isascii(C) && isupper(C))
52	#else
53	#define ISALNUM(C) isalnum((unsigned char)C)
54	#define ISUPPER(C) isupper((unsigned char)C)
55	#endif
56
57	#define TOLOWER(C) (ISUPPER(C) ? tolower((unsigned char)C) : (C))
58
59	#include "grep.h"	26	#include "grep.h"
		27	#include "regex.h"
60	#include "dfa.h"	28	#include "dfa.h"
61	#include "kwset.h"	29	#include "kwset.h"
62	#include "gnuregex.h"
63		30
64	#define NCHAR (UCHAR_MAX + 1)	31	#define NCHAR (UCHAR_MAX + 1)
65		32
66	#if __STDC__	33	static void Gcompile PARAMS((char *, size_t));
67	static void Gcompile(char *, size_t);	34	static void Ecompile PARAMS((char *, size_t));
68	static void Ecompile(char *, size_t);	35	static char EGexecute PARAMS((char , size_t, char **));
69	static char EGexecute(char , size_t, char **);	36	static void Fcompile PARAMS((char *, size_t));
70	static void Fcompile(char *, size_t);	37	static char Fexecute PARAMS((char , size_t, char **));
71	static char Fexecute(char , size_t, char **);	38	static void kwsinit PARAMS((void));
72	#else
73	static void Gcompile();
74	static void Ecompile();
75	static char *EGexecute();
76	static void Fcompile();
77	static char *Fexecute();
78	#endif
79		39
80	/* Here is the matchers vector for the main program. */	40	/* Here is the matchers vector for the main program. */
81	struct matcher matchers[] = {	41	struct matcher matchers[] = {
82	{ "default", Gcompile, EGexecute },	42	{ "default", Gcompile, EGexecute },
83	{ "grep", Gcompile, EGexecute },	43	{ "grep", Gcompile, EGexecute },
84	{ "ggrep", Gcompile, EGexecute },
85	{ "egrep", Ecompile, EGexecute },	44	{ "egrep", Ecompile, EGexecute },
86	{ "posix-egrep", Ecompile, EGexecute },	45	{ "posix-egrep", Ecompile, EGexecute },
87	{ "gegrep", Ecompile, EGexecute },	46	{ "awk", Ecompile, EGexecute },
88	{ "fgrep", Fcompile, Fexecute },	47	{ "fgrep", Fcompile, Fexecute },
89	{ "gfgrep", Fcompile, Fexecute },
90	{ 0, 0, 0 },	48	{ 0, 0, 0 },
91	};	49	};
92		50
Lines 111-117 Link Here
111		69
112	void	70	void
113	dfaerror(mesg)	71	dfaerror(mesg)
114	char *mesg;	72	const char *mesg;
115	{	73	{
116	fatal(mesg, 0);	74	fatal(mesg, 0);
117	}	75	}
Lines 173-182 Link Here
173	char *pattern;	131	char *pattern;
174	size_t size;	132	size_t size;
175	{	133	{
176	#ifdef __STDC__	134	const char *err;
177	const
178	#endif
179	char *err;
180		135
181	re_set_syntax(RE_SYNTAX_GREP \| RE_HAT_LISTS_NOT_NEWLINE);	136	re_set_syntax(RE_SYNTAX_GREP \| RE_HAT_LISTS_NOT_NEWLINE);
182	dfasyntax(RE_SYNTAX_GREP \| RE_HAT_LISTS_NOT_NEWLINE, match_icase);	137	dfasyntax(RE_SYNTAX_GREP \| RE_HAT_LISTS_NOT_NEWLINE, match_icase);
Lines 184-191 Link Here
184	if ((err = re_compile_pattern(pattern, size, &regex)) != 0)	139	if ((err = re_compile_pattern(pattern, size, &regex)) != 0)
185	fatal(err, 0);	140	fatal(err, 0);
186		141
187	dfainit(&dfa);
188
189	/* In the match_words and match_lines cases, we use a different pattern	142	/* In the match_words and match_lines cases, we use a different pattern
190	for the DFA matcher that will quickly throw out cases that won't work.	143	for the DFA matcher that will quickly throw out cases that won't work.
191	Then if DFA succeeds we do some hairy stuff using the regex matcher	144	Then if DFA succeeds we do some hairy stuff using the regex matcher
Lines 209-215 Link Here
209	strcpy(n, "\\(^\\\|[^0-9A-Za-z_]\\)\\(");	162	strcpy(n, "\\(^\\\|[^0-9A-Za-z_]\\)\\(");
210		163
211	i = strlen(n);	164	i = strlen(n);
212	bcopy(pattern, n + i, size);	165	memcpy(n + i, pattern, size);
213	i += size;	166	i += size;
214		167
215	if (match_words)	168	if (match_words)
Lines 231-246 Link Here
231	char *pattern;	184	char *pattern;
232	size_t size;	185	size_t size;
233	{	186	{
234	#ifdef __STDC__	187	const char *err;
235	const
236	#endif
237	char *err;
238		188
239	if (strcmp(matcher, "posix-egrep") == 0)	189	if (strcmp(matcher, "posix-egrep") == 0)
240	{	190	{
241	re_set_syntax(RE_SYNTAX_POSIX_EGREP);	191	re_set_syntax(RE_SYNTAX_POSIX_EGREP);
242	dfasyntax(RE_SYNTAX_POSIX_EGREP, match_icase);	192	dfasyntax(RE_SYNTAX_POSIX_EGREP, match_icase);
243	}	193	}
		194	else if (strcmp(matcher, "awk") == 0)
		195	{
		196	re_set_syntax(RE_SYNTAX_AWK);
		197	dfasyntax(RE_SYNTAX_AWK, match_icase);
		198	}
244	else	199	else
245	{	200	{
246	re_set_syntax(RE_SYNTAX_EGREP);	201	re_set_syntax(RE_SYNTAX_EGREP);
Lines 250-257 Link Here
250	if ((err = re_compile_pattern(pattern, size, &regex)) != 0)	205	if ((err = re_compile_pattern(pattern, size, &regex)) != 0)
251	fatal(err, 0);	206	fatal(err, 0);
252		207
253	dfainit(&dfa);
254
255	/* In the match_words and match_lines cases, we use a different pattern	208	/* In the match_words and match_lines cases, we use a different pattern
256	for the DFA matcher that will quickly throw out cases that won't work.	209	for the DFA matcher that will quickly throw out cases that won't work.
257	Then if DFA succeeds we do some hairy stuff using the regex matcher	210	Then if DFA succeeds we do some hairy stuff using the regex matcher
Lines 275-281 Link Here
275	strcpy(n, "(^\|[^0-9A-Za-z_])(");	228	strcpy(n, "(^\|[^0-9A-Za-z_])(");
276		229
277	i = strlen(n);	230	i = strlen(n);
278	bcopy(pattern, n + i, size);	231	memcpy(n + i, pattern, size);
279	i += size;	232	i += size;
280		233
281	if (match_words)	234	if (match_words)
Lines 358-364 Link Here
358	if ((start = re_search(&regex, beg, end - beg, 0, end - beg, &regs)) >= 0)	311	if ((start = re_search(&regex, beg, end - beg, 0, end - beg, &regs)) >= 0)
359	{	312	{
360	len = regs.end[0] - start;	313	len = regs.end[0] - start;
361	if (!match_lines && !match_words \|\| match_lines && len == end - beg)	314	if ((!match_lines && !match_words)
		315	\|\| (match_lines && len == end - beg))
362	goto success;	316	goto success;
363	/* If -w, check if the match aligns with word boundaries.	317	/* If -w, check if the match aligns with word boundaries.
364	We do this iteratively because:	318	We do this iteratively because:
Lines 369-376 Link Here
369	if (match_words)	323	if (match_words)
370	while (start >= 0)	324	while (start >= 0)
371	{	325	{
372	if ((start == 0 \|\| !WCHAR(beg[start - 1]))	326	if ((start == 0 \|\| !WCHAR ((unsigned char) beg[start - 1]))
373	&& (len == end - beg \|\| !WCHAR(beg[start + len])))	327	&& (len == end - beg
		328	\|\| !WCHAR ((unsigned char) beg[start + len])))
374	goto success;	329	goto success;
375	if (len > 0)	330	if (len > 0)
376	{	331	{

Line 0 Link Here

(-)grep/stpcpy.c (+52 lines)
	1	/* stpcpy.c -- copy a string and return pointer to end of new string
	2	Copyright (C) 1992, 1995, 1997, 1998 Free Software Foundation, Inc.
	3
	4	NOTE: The canonical source of this file is maintained with the GNU C Library.
	5	Bugs can be reported to bug-glibc@prep.ai.mit.edu.
	6
	7	This program is free software; you can redistribute it and/or modify it
	8	under the terms of the GNU General Public License as published by the
	9	Free Software Foundation; either version 2, or (at your option) any
	10	later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
	20	USA. */
	21
	22	#ifdef HAVE_CONFIG_H
	23	# include <config.h>
	24	#endif
	25
	26	#include <string.h>
	27
	28	#undef __stpcpy
	29	#undef stpcpy
	30
	31	#ifndef weak_alias
	32	# define __stpcpy stpcpy
	33	#endif
	34
	35	/* Copy SRC to DEST, returning the address of the terminating '\0' in DEST. */
	36	char *
	37	__stpcpy (dest, src)
	38	char *dest;
	39	const char *src;
	40	{
	41	register char *d = dest;
	42	register const char *s = src;
	43
	44	do
	45	d++ = s;
	46	while (*s++ != '\0');
	47
	48	return d - 1;
	49	}
	50	#ifdef weak_alias
	51	weak_alias (__stpcpy, stpcpy)
	52	#endif

Line 0 Link Here

(-)grep/system.h (+188 lines)
		1	/* Portability cruft. Include after config.h and sys/types.h.
		2	Copyright (C) 1996, 1998 Free Software Foundation, Inc.
		3
		4	This program is free software; you can redistribute it and/or modify
		5	it under the terms of the GNU General Public License as published by
		6	the Free Software Foundation; either version 2, or (at your option)
		7	any later version.
		8
		9	This program is distributed in the hope that it will be useful,
		10	but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12	GNU General Public License for more details.
		13
		14	You should have received a copy of the GNU General Public License
		15	along with this program; if not, write to the Free Software
		16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
		17	02111-1307, USA. */
		18
		19	#undef PARAMS
		20	#if defined (__STDC__) && __STDC__
		21	# ifndef _PTR_T
		22	# define _PTR_T
		23	typedef void * ptr_t;
		24	# endif
		25	# define PARAMS(x) x
		26	#else
		27	# ifndef _PTR_T
		28	# define _PTR_T
		29	typedef char * ptr_t;
		30	# endif
		31	# define PARAMS(x) ()
		32	#endif
		33
		34	#ifdef HAVE_UNISTD_H
		35	# include <fcntl.h>
		36	# include <unistd.h>
		37	#else
		38	# define O_RDONLY 0
		39	int open(), read(), close();
		40	#endif
		41
		42	#include <errno.h>
		43	#ifndef errno
		44	extern int errno;
		45	#endif
		46
		47	#ifndef HAVE_STRERROR
		48	extern int sys_nerr;
		49	extern char *sys_errlist[];
		50	# define strerror(E) (0 <= (E) && (E) < sys_nerr ? _(sys_errlist[E]) : _("Unknown system error"))
		51	#endif
		52
		53	/* Some operating systems treat text and binary files differently. */
		54	#if O_BINARY
		55	# include <io.h>
		56	# ifdef HAVE_SETMODE
		57	# define SET_BINARY(fd) setmode (fd, O_BINARY)
		58	# else
		59	# define SET_BINARY(fd) _setmode (fd, O_BINARY)
		60	# endif
		61	#else
		62	# ifndef O_BINARY
		63	# define O_BINARY 0
		64	# define SET_BINARY(fd) (void)0
65	# endif
66	#endif
67
68	#ifdef HAVE_DOS_FILE_NAMES
69	# define IS_SLASH(c) ((c) == '/' \|\| (c) == '\\')
70	# define FILESYSTEM_PREFIX_LEN(f) ((f)[0] && (f)[1] == ':' ? 2 : 0)
71	#endif
72
73	#ifndef IS_SLASH
74	# define IS_SLASH(c) ((c) == '/')
75	#endif
76
77	#ifndef FILESYSTEM_PREFIX_LEN
78	# define FILESYSTEM_PREFIX_LEN(f) 0
79	#endif
80
81	/* This assumes _WIN32, like DJGPP, has D_OK. Does it? In what header? */
82	#ifdef D_OK
83	# ifdef EISDIR
84	# define is_EISDIR(e, f) \
85	((e) == EISDIR \
86	\|\| ((e) == EACCES && access (f, D_OK) == 0 && ((e) = EISDIR, 1)))
87	# else
88	# define is_EISDIR(e, f) ((e) == EACCES && access (f, D_OK) == 0)
89	# endif
90	#endif
91
92	#ifndef is_EISDIR
93	# ifdef EISDIR
94	# define is_EISDIR(e, f) ((e) == EISDIR)
95	# else
96	# define is_EISDIR(e, f) 0
97	# endif
98	#endif
99
100	#if STAT_MACROS_BROKEN
101	# undef S_ISDIR
102	#endif
103	#if !defined(S_ISDIR) && defined(S_IFDIR)
104	# define S_ISDIR(Mode) (((Mode) & S_IFMT) == S_IFDIR)
105	#endif
106
107	#ifdef STDC_HEADERS
108	# include <stdlib.h>
109	#else
110	ptr_t malloc(), realloc(), calloc();
111	void free();
112	#endif
113
114	#if __STDC__
115	# include <stddef.h>
116	#endif
117	#ifdef STDC_HEADERS
118	# include <limits.h>
119	#endif
120	#ifndef CHAR_BIT
121	# define CHAR_BIT 8
122	#endif
123	#ifndef INT_MAX
124	# define INT_MAX 2147483647
125	#endif
126	#ifndef UCHAR_MAX
127	# define UCHAR_MAX 255
128	#endif
129
130	#if !defined(STDC_HEADERS) && defined(HAVE_STRING_H) && defined(HAVE_MEMORY_H)
131	# include <memory.h>
132	#endif
133	#if defined(STDC_HEADERS) \|\| defined(HAVE_STRING_H)
134	# include <string.h>
135	#else
136	# include <strings.h>
137	# undef strchr
138	# define strchr index
139	# undef strrchr
140	# define strrchr rindex
141	# undef memcpy
142	# define memcpy(d, s, n) bcopy((s), (d), (n))
143	#endif
144	#ifndef HAVE_MEMCHR
145	ptr_t memchr();
146	#endif
147
148	#include <ctype.h>
149
150	#ifndef isgraph
151	# define isgraph(C) (isprint(C) && !isspace(C))
152	#endif
153
154	#if defined (STDC_HEADERS) \|\| (!defined (isascii) && !defined (HAVE_ISASCII))
155	# define IN_CTYPE_DOMAIN(c) 1
156	#else
157	# define IN_CTYPE_DOMAIN(c) isascii(c)
158	#endif
159
160	#define ISALPHA(C) (IN_CTYPE_DOMAIN (C) && isalpha (C))
161	#define ISUPPER(C) (IN_CTYPE_DOMAIN (C) && isupper (C))
162	#define ISLOWER(C) (IN_CTYPE_DOMAIN (C) && islower (C))
163	#define ISDIGIT(C) (IN_CTYPE_DOMAIN (C) && isdigit (C))
164	#define ISXDIGIT(C) (IN_CTYPE_DOMAIN (C) && isxdigit (C))
165	#define ISSPACE(C) (IN_CTYPE_DOMAIN (C) && isspace (C))
166	#define ISPUNCT(C) (IN_CTYPE_DOMAIN (C) && ispunct (C))
167	#define ISALNUM(C) (IN_CTYPE_DOMAIN (C) && isalnum (C))
168	#define ISPRINT(C) (IN_CTYPE_DOMAIN (C) && isprint (C))
169	#define ISGRAPH(C) (IN_CTYPE_DOMAIN (C) && isgraph (C))
170	#define ISCNTRL(C) (IN_CTYPE_DOMAIN (C) && iscntrl (C))
171
172	#define TOLOWER(C) (ISUPPER(C) ? tolower(C) : (C))
173
174	#if ENABLE_NLS
175	# include <libintl.h>
176	# define _(String) gettext (String)
177	#else
178	# define _(String) String
179	#endif
180	#define N_(String) String
181
182	#if HAVE_SETLOCALE
183	# include <locale.h>
184	#endif
185
186	#ifndef initialize_main
187	#define initialize_main(argcp, argvp)
188	#endif

Line 0 Link Here

(-)grep/vms_fab.c (+88 lines)
		1	/*
		2	<vms_fab>
		3
		4	This macro sets up the file access block and name block for VMS.
		5	It also does the initial parsing of the input string (resolving
		6	wildcards,
		7	if any) and finds all files matching the input pattern.
		8	The address of the first matching pattern is returned.
		9
		10	Written by Phillip C. Brisco 8/98.
		11	*/
		12	#include "vms_fab.h"
		13
		14	void
		15	vms_fab (argp, argvp)
		16	int * argp;
		17	char **argvp[];
		18	{
		19	extern int optind;
		20	int optout;
		21
		22	fab = cc$rms_fab;
		23	nam = cc$rms_nam;
		24
		25	optout = 0;
		26	strcpy (fna_buffer, *argvp[optind]);
		27	length_of_fna_buffer = NAM$C_MAXRSS;
		28
		29	fab.fab$b_bid = FAB$C_BID;
		30	fab.fab$b_bln = FAB$C_BLN;
		31	fab.fab$l_fop = FAB$M_NAM;
		32	fab.fab$l_nam = &nam;
		33	fab.fab$l_fna = &fna_buffer;
		34	fab.fab$b_fns = length_of_fna_buffer;
		35
		36	nam.nam$b_bid = NAM$C_BID;
		37	nam.nam$b_bln = NAM$C_BLN;
		38	nam.nam$l_esa = &expanded_name;
		39	nam.nam$b_ess = NAM$C_MAXRSS;
		40	nam.nam$l_rsa = &result_name;
		41	nam.nam$b_rss = NAM$C_MAXRSS;
		42
		43	fab_stat = sys$parse (&fab);
		44	fab_stat = sys$search (&fab);
		45
		46	if (fab_stat != 65537)
		47	{
		48	fprintf (stderr, "No Matches found.\n");
		49	exit (0);
		50	}
		51
		52	/*
		53	While we find matching patterns, continue searching for more.
		54	*/
		55	while (fab_stat == 65537)
		56	{
		57	/*
		58	Allocate memory for the filename
		59	*/
		60	arr_ptr[optout] = alloca (max_file_path_size + 1);
		61
		62	strcpy (arr_ptr[optout], result_name);
		63
		64	/*
65	If we don't tack on a null character at the end of the
66	filename,
67	we can get partial data which is still there from the last
68	sys$search command.
69	*/
70	arr_ptr[optout][nam.nam$b_dev +
71	nam.nam$b_dir +
72	nam.nam$b_name +
73	nam.nam$b_type +
74	nam.nam$b_ver] = '\0';
75
76	fab_stat = sys$search (&fab);
77	optout++;
78	}
79
80	optout--;
81
82	/* Return a pointer to the beginning of memory that has the expanded
83	filenames.
84	*/
85	*argcp = optout;
86	*argvp = arr_ptr;
87
88	}

Line 0 Link Here

(-)grep/vms_fab.h (+20 lines)
	1	/*
	2	This file includes the setup for the file access block for VMS.
	3	Written by Phillip C. Brisco 8/98.
	4	*/
	5
	6	#include <rms.h>
	7	#include <ssdef.h>
	8	#include <stddef.h>
	9
	10	struct FAB fab;
	11	struct NAM nam;
	12
	13	int length_of_fna_buffer;
	14	int fab_stat;
	15	char expanded_name[NAM$C_MAXRSS];
	16	char fna_buffer[NAM$C_MAXRSS];
	17	char result_name[NAM$C_MAXRSS];
	18	char final_name[NAM$C_MAXRSS];
	19	int max_file_path_size = NAM$C_MAXRSS;
	20	char *arr_ptr[32767]: