libiberty: remove source files that either duplicate functionality

already present in all modern libc implementations, or are
incompatible with modern development environments, or both.

61 files changed, 0 insertions, 15176 deletions

diff --git a/libiberty/asprintf.c b/libiberty/asprintf.c
deleted file mode 100644
index 3cf505266..000000000
--- a/libiberty/asprintf.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Like sprintf but provides a pointer to malloc'd storage, which must
-   be freed by the caller.
-   Copyright (C) 1997, 2003 Free Software Foundation, Inc.
-   Contributed by Cygnus Solutions.
-
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-
-#include <stdarg.h>
-
-/*
-
-@deftypefn Extension int asprintf (char **@var{resptr}, const char *@var{format}, ...)
-
-Like @code{sprintf}, but instead of passing a pointer to a buffer, you
-pass a pointer to a pointer.  This function will compute the size of
-the buffer needed, allocate memory with @code{malloc}, and store a
-pointer to the allocated memory in @code{*@var{resptr}}.  The value
-returned is the same as @code{sprintf} would return.  If memory could
-not be allocated, minus one is returned and @code{NULL} is stored in
-@code{*@var{resptr}}.
-
-@end deftypefn
-
-*/
-
-int
-asprintf (char **buf, const char *fmt, ...)
-{
-  int status;
-  VA_OPEN (ap, fmt);
-  VA_FIXEDARG (ap, char **, buf);
-  VA_FIXEDARG (ap, const char *, fmt);
-  status = vasprintf (buf, fmt, ap);
-  VA_CLOSE (ap);
-  return status;
-}
diff --git a/libiberty/atexit.c b/libiberty/atexit.c
deleted file mode 100644
index e091f0139..000000000
--- a/libiberty/atexit.c
+++ /dev/null
@@ -1,27 +0,0 @@
-/* Wrapper to implement ANSI C's atexit using SunOS's on_exit. */
-/* This function is in the public domain.  --Mike Stump. */
-
-/*
-
-@deftypefn Supplemental int atexit (void (*@var{f})())
-
-Causes function @var{f} to be called at exit.  Returns 0.
-
-@end deftypefn
-
-*/
-
-#include "config.h"
-
-#ifdef HAVE_ON_EXIT
-
-int
-atexit(void (*f)(void))
-{
-  /* If the system doesn't provide a definition for atexit, use on_exit
-     if the system provides that.  */
-  on_exit (f, 0);
-  return 0;
-}
-
-#endif
diff --git a/libiberty/basename.c b/libiberty/basename.c
deleted file mode 100644
index 0f2c069f0..000000000
--- a/libiberty/basename.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/* Return the basename of a pathname.
-   This file is in the public domain. */
-
-/*
-
-@deftypefn Supplemental char* basename (const char *@var{name})
-
-Returns a pointer to the last component of pathname @var{name}.
-Behavior is undefined if the pathname ends in a directory separator.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-#include "safe-ctype.h"
-
-#ifndef DIR_SEPARATOR
-#define DIR_SEPARATOR '/'
-#endif
-
-#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
-  defined (__OS2__)
-#define HAVE_DOS_BASED_FILE_SYSTEM
-#ifndef DIR_SEPARATOR_2 
-#define DIR_SEPARATOR_2 '\\'
-#endif
-#endif
-
-/* Define IS_DIR_SEPARATOR.  */
-#ifndef DIR_SEPARATOR_2
-# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
-#else /* DIR_SEPARATOR_2 */
-# define IS_DIR_SEPARATOR(ch) \
-	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
-#endif /* DIR_SEPARATOR_2 */
-
-char *
-basename (const char *name)
-{
-  const char *base;
-
-#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
-  /* Skip over the disk name in MSDOS pathnames. */
-  if (ISALPHA (name[0]) && name[1] == ':') 
-    name += 2;
-#endif
-
-  for (base = name; *name; name++)
-    {
-      if (IS_DIR_SEPARATOR (*name))
-	{
-	  base = name + 1;
-	}
-    }
-  return (char *) base;
-}
-
diff --git a/libiberty/bcmp.c b/libiberty/bcmp.c
deleted file mode 100644
index c639f9895..000000000
--- a/libiberty/bcmp.c
+++ /dev/null
@@ -1,27 +0,0 @@
-/* bcmp
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental int bcmp (char *@var{x}, char *@var{y}, int @var{count})
-
-Compares the first @var{count} bytes of two areas of memory.  Returns
-zero if they are the same, nonzero otherwise.  Returns zero if
-@var{count} is zero.  A nonzero result only indicates a difference,
-it does not indicate any sorting order (say, by having a positive
-result mean @var{x} sorts before @var{y}).
-
-@end deftypefn
-
-*/
-
-#include <stddef.h>
-
-extern int memcmp(const void *, const void *, size_t);
-
-int
-bcmp (const void *s1, const void *s2, size_t count)
-{
-  return memcmp (s1, s2, count);
-}
-
diff --git a/libiberty/bcopy.c b/libiberty/bcopy.c
deleted file mode 100644
index f9b7a8acd..000000000
--- a/libiberty/bcopy.c
+++ /dev/null
@@ -1,31 +0,0 @@
-/* bcopy -- copy memory regions of arbitary length
-
-@deftypefn Supplemental void bcopy (char *@var{in}, char *@var{out}, int @var{length})
-
-Copies @var{length} bytes from memory region @var{in} to region
-@var{out}.  The use of @code{bcopy} is deprecated in new programs.
-
-@end deftypefn
-
-*/
-
-#include <stddef.h>
-
-void
-bcopy (const void *src, void *dest, size_t len)
-{
-  if (dest < src)
-    {
-      const char *firsts = (const char *) src;
-      char *firstd = (char *) dest;
-      while (len--)
-	*firstd++ = *firsts++;
-    }
-  else
-    {
-      const char *lasts = (const char *)src + (len-1);
-      char *lastd = (char *)dest + (len-1);
-      while (len--)
-        *lastd-- = *lasts--;
-    }
-}
diff --git a/libiberty/bsearch.c b/libiberty/bsearch.c
deleted file mode 100644
index 35fad1997..000000000
--- a/libiberty/bsearch.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 1990 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. [rescinded 22 July 1999]
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
-
-@deftypefn Supplemental void* bsearch (const void *@var{key}, @
-  const void *@var{base}, size_t @var{nmemb}, size_t @var{size}, @
-  int (*@var{compar})(const void *, const void *))
-
-Performs a search over an array of @var{nmemb} elements pointed to by
-@var{base} for a member that matches the object pointed to by @var{key}.
-The size of each member is specified by @var{size}.  The array contents
-should be sorted in ascending order according to the @var{compar}
-comparison function.  This routine should take two arguments pointing to
-the @var{key} and to an array member, in that order, and should return an
-integer less than, equal to, or greater than zero if the @var{key} object
-is respectively less than, matching, or greater than the array member.
-
-@end deftypefn
-
-*/
-
-#include "config.h"
-#include "ansidecl.h"
-#include <sys/types.h>		/* size_t */
-#include <stdio.h>
-
-/*
- * Perform a binary search.
- *
- * The code below is a bit sneaky.  After a comparison fails, we
- * divide the work in half by moving either left or right. If lim
- * is odd, moving left simply involves halving lim: e.g., when lim
- * is 5 we look at item 2, so we change lim to 2 so that we will
- * look at items 0 & 1.  If lim is even, the same applies.  If lim
- * is odd, moving right again involes halving lim, this time moving
- * the base up one item past p: e.g., when lim is 5 we change base
- * to item 3 and make lim 2 so that we will look at items 3 and 4.
- * If lim is even, however, we have to shrink it by one before
- * halving: e.g., when lim is 4, we still looked at item 2, so we
- * have to make lim 3, then halve, obtaining 1, so that we will only
- * look at item 3.
- */
-void *
-bsearch (register const void *key, const void *base0,
-         size_t nmemb, register size_t size,
-         register int (*compar)(const void *, const void *))
-{
-	register const char *base = (const char *) base0;
-	register int lim, cmp;
-	register const void *p;
-
-	for (lim = nmemb; lim != 0; lim >>= 1) {
-		p = base + (lim >> 1) * size;
-		cmp = (*compar)(key, p);
-		if (cmp == 0)
-			return (void *)p;
-		if (cmp > 0) {	/* key > p: move right */
-			base = (const char *)p + size;
-			lim--;
-		} /* else move left */
-	}
-	return (NULL);
-}
diff --git a/libiberty/bzero.c b/libiberty/bzero.c
deleted file mode 100644
index 44ad73da4..000000000
--- a/libiberty/bzero.c
+++ /dev/null
@@ -1,23 +0,0 @@
-/* Portable version of bzero for systems without it.
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental void bzero (char *@var{mem}, int @var{count})
-
-Zeros @var{count} bytes starting at @var{mem}.  Use of this function
-is deprecated in favor of @code{memset}.
-
-@end deftypefn
-
-*/
-
-#include <stddef.h>
-
-extern void *memset(void *, int, size_t);
-
-void
-bzero (void *to, size_t count)
-{
-  memset (to, 0, count);
-}
diff --git a/libiberty/calloc.c b/libiberty/calloc.c
deleted file mode 100644
index f4bd27b1c..000000000
--- a/libiberty/calloc.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/* calloc -- allocate memory which has been initialized to zero.
-   This function is in the public domain. */
-
-/*
-
-@deftypefn Supplemental void* calloc (size_t @var{nelem}, size_t @var{elsize})
-
-Uses @code{malloc} to allocate storage for @var{nelem} objects of
-@var{elsize} bytes each, then zeros the memory.
-
-@end deftypefn
-
-*/
- 
-#include "ansidecl.h"
-#include <stddef.h>
-
-/* For systems with larger pointers than ints, this must be declared.  */
-PTR malloc (size_t);
-void bzero (PTR, size_t);
-
-PTR
-calloc (size_t nelem, size_t elsize)
-{
-  register PTR ptr;  
-
-  if (nelem == 0 || elsize == 0)
-    nelem = elsize = 1;
-  
-  ptr = malloc (nelem * elsize);
-  if (ptr) bzero (ptr, nelem * elsize);
-  
-  return ptr;
-}
diff --git a/libiberty/clock.c b/libiberty/clock.c
deleted file mode 100644
index 07d902e8a..000000000
--- a/libiberty/clock.c
+++ /dev/null
@@ -1,103 +0,0 @@
-/* ANSI-compatible clock function.
-   Copyright (C) 1994, 1995, 1999 Free Software Foundation, Inc.
-
-This file is part of the libiberty library.  This library 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 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 General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
-
-As a special exception, if you link this library with files
-compiled with a GNU compiler to produce an executable, this does not cause
-the resulting executable to be covered by the GNU General Public License.
-This exception does not however invalidate any other reasons why
-the executable file might be covered by the GNU General Public License. */
-
-/*
-
-@deftypefn Supplemental long clock (void)
-
-Returns an approximation of the CPU time used by the process as a
-@code{clock_t}; divide this number by @samp{CLOCKS_PER_SEC} to get the
-number of seconds used.
-
-@end deftypefn
-
-*/
-
-#include "config.h"
-
-#ifdef HAVE_GETRUSAGE
-#include <sys/time.h>
-#include <sys/resource.h>
-#endif
-
-#ifdef HAVE_TIMES
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-#include <sys/times.h>
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#ifdef _SC_CLK_TCK
-#define GNU_HZ  sysconf(_SC_CLK_TCK)
-#else
-#ifdef HZ
-#define GNU_HZ  HZ
-#else
-#ifdef CLOCKS_PER_SEC
-#define GNU_HZ  CLOCKS_PER_SEC
-#endif
-#endif
-#endif
-
-/* FIXME: should be able to declare as clock_t. */
-
-long
-clock (void)
-{
-#ifdef HAVE_GETRUSAGE
-  struct rusage rusage;
-
-  getrusage (0, &rusage);
-  return (rusage.ru_utime.tv_sec * 1000000 + rusage.ru_utime.tv_usec
-	  + rusage.ru_stime.tv_sec * 1000000 + rusage.ru_stime.tv_usec);
-#else
-#ifdef HAVE_TIMES
-  struct tms tms;
-
-  times (&tms);
-  return (tms.tms_utime + tms.tms_stime) * (1000000 / GNU_HZ);
-#else
-#ifdef VMS
-  struct
-    {
-      int proc_user_time;
-      int proc_system_time;
-      int child_user_time;
-      int child_system_time;
-    } vms_times;
-
-  times (&vms_times);
-  return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
-#else
-  /* A fallback, if nothing else available. */
-  return 0;
-#endif /* VMS */
-#endif /* HAVE_TIMES */
-#endif /* HAVE_GETRUSAGE */
-}
-
diff --git a/libiberty/copysign.c b/libiberty/copysign.c
deleted file mode 100644
index 6793f22e8..000000000
--- a/libiberty/copysign.c
+++ /dev/null
@@ -1,154 +0,0 @@
-#include <ansidecl.h>
-
-#ifdef __IEEE_BIG_ENDIAN
-
-typedef union 
-{
-  double value;
-  struct 
-  {
-    unsigned int sign : 1;
-    unsigned int exponent: 11;
-    unsigned int fraction0:4;
-    unsigned int fraction1:16;
-    unsigned int fraction2:16;
-    unsigned int fraction3:16;
-    
-  } number;
-  struct 
-  {
-    unsigned int sign : 1;
-    unsigned int exponent: 11;
-    unsigned int quiet:1;
-    unsigned int function0:3;
-    unsigned int function1:16;
-    unsigned int function2:16;
-    unsigned int function3:16;
-  } nan;
-  struct 
-  {
-    unsigned long msw;
-    unsigned long lsw;
-  } parts;
-    long aslong[2];
-} __ieee_double_shape_type;
-
-#endif
-
-#ifdef __IEEE_LITTLE_ENDIAN
-
-typedef union 
-{
-  double value;
-  struct 
-  {
-#ifdef __SMALL_BITFIELDS
-    unsigned int fraction3:16;
-    unsigned int fraction2:16;
-    unsigned int fraction1:16;
-    unsigned int fraction0: 4;
-#else
-    unsigned int fraction1:32;
-    unsigned int fraction0:20;
-#endif
-    unsigned int exponent :11;
-    unsigned int sign     : 1;
-  } number;
-  struct 
-  {
-#ifdef __SMALL_BITFIELDS
-    unsigned int function3:16;
-    unsigned int function2:16;
-    unsigned int function1:16;
-    unsigned int function0:3;
-#else
-    unsigned int function1:32;
-    unsigned int function0:19;
-#endif
-    unsigned int quiet:1;
-    unsigned int exponent: 11;
-    unsigned int sign : 1;
-  } nan;
-  struct 
-  {
-    unsigned long lsw;
-    unsigned long msw;
-  } parts;
-
-  long aslong[2];
-
-} __ieee_double_shape_type;
-
-#endif
-
-#ifdef __IEEE_BIG_ENDIAN
-typedef union
-{
-  float value;
-  struct 
-  {
-    unsigned int sign : 1;
-    unsigned int exponent: 8;
-    unsigned int fraction0: 7;
-    unsigned int fraction1: 16;
-  } number;
-  struct 
-  {
-    unsigned int sign:1;
-    unsigned int exponent:8;
-    unsigned int quiet:1;
-    unsigned int function0:6;
-    unsigned int function1:16;
-  } nan;
-  long p1;
-  
-} __ieee_float_shape_type;
-#endif
-
-#ifdef __IEEE_LITTLE_ENDIAN
-typedef union
-{
-  float value;
-  struct 
-  {
-    unsigned int fraction0: 7;
-    unsigned int fraction1: 16;
-    unsigned int exponent: 8;
-    unsigned int sign : 1;
-  } number;
-  struct 
-  {
-    unsigned int function1:16;
-    unsigned int function0:6;
-    unsigned int quiet:1;
-    unsigned int exponent:8;
-    unsigned int sign:1;
-  } nan;
-  long p1;
-  
-} __ieee_float_shape_type;
-#endif
-
-#if defined(__IEEE_BIG_ENDIAN) || defined(__IEEE_LITTLE_ENDIAN)
-
-double
-copysign (double x, double y)
-{
-  __ieee_double_shape_type a,b;
-  b.value = y;  
-  a.value = x;
-  a.number.sign =b.number.sign;
-  return a.value;
-}
-
-#else
-
-double
-copysign (double x, double y)
-{
-  if ((x < 0 && y > 0) || (x > 0 && y < 0))
-    return -x;
-  return x;
-}
-
-#endif
diff --git a/libiberty/ffs.c b/libiberty/ffs.c
deleted file mode 100644
index 603cbe8ed..000000000
--- a/libiberty/ffs.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/* ffs -- Find the first bit set in the parameter
-
-@deftypefn Supplemental int ffs (int @var{valu})
-
-Find the first (least significant) bit set in @var{valu}.  Bits are
-numbered from right to left, starting with bit 1 (corresponding to the
-value 1).  If @var{valu} is zero, zero is returned.
-
-@end deftypefn
-
-*/
-
-int
-ffs (register int valu)
-{
-  register int bit;
-
-  if (valu == 0)
-    return 0;
-
-  for (bit = 1; !(valu & 1); bit++)
-  	valu >>= 1;
-
-  return bit;
-}
-
diff --git a/libiberty/fnmatch.c b/libiberty/fnmatch.c
deleted file mode 100644
index fc897be2c..000000000
--- a/libiberty/fnmatch.c
+++ /dev/null
@@ -1,220 +0,0 @@
-/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
-
-NOTE: This source is derived from an old version taken from the GNU C
-Library (glibc).
-
-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, 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-#ifdef HAVE_CONFIG_H
-#if defined (CONFIG_BROKETS)
-/* We use <config.h> instead of "config.h" so that a compilation
-   using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h
-   (which it would do because it found this file in $srcdir).  */
-#include <config.h>
-#else
-#include "config.h"
-#endif
-#endif
-
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-/* This code to undef const added in libiberty.  */
-#ifndef __STDC__
-/* This is a separate conditional since some stdc systems
-   reject `defined (const)'.  */
-#ifndef const
-#define const
-#endif
-#endif
-
-#include <errno.h>
-#include <fnmatch.h>
-#include <safe-ctype.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.  */
-
-#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
-
-
-#if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
-extern int errno;
-#endif
-
-/* Match STRING against the filename pattern PATTERN, returning zero if
-   it matches, nonzero if not.  */
-int
-fnmatch (const char *pattern, const char *string, int flags)
-{
-  register const char *p = pattern, *n = string;
-  register unsigned char c;
-
-#define FOLD(c)	((flags & FNM_CASEFOLD) ? TOLOWER (c) : (c))
-
-  while ((c = *p++) != '\0')
-    {
-      c = FOLD (c);
-
-      switch (c)
-	{
-	case '?':
-	  if (*n == '\0')
-	    return FNM_NOMATCH;
-	  else if ((flags & FNM_FILE_NAME) && *n == '/')
-	    return FNM_NOMATCH;
-	  else if ((flags & FNM_PERIOD) && *n == '.' &&
-		   (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
-	    return FNM_NOMATCH;
-	  break;
-
-	case '\\':
-	  if (!(flags & FNM_NOESCAPE))
-	    {
-	      c = *p++;
-	      c = FOLD (c);
-	    }
-	  if (FOLD ((unsigned char)*n) != c)
-	    return FNM_NOMATCH;
-	  break;
-
-	case '*':
-	  if ((flags & FNM_PERIOD) && *n == '.' &&
-	      (n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
-	    return FNM_NOMATCH;
-
-	  for (c = *p++; c == '?' || c == '*'; c = *p++, ++n)
-	    if (((flags & FNM_FILE_NAME) && *n == '/') ||
-		(c == '?' && *n == '\0'))
-	      return FNM_NOMATCH;
-
-	  if (c == '\0')
-	    return 0;
-
-	  {
-	    unsigned char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c;
-	    c1 = FOLD (c1);
-	    for (--p; *n != '\0'; ++n)
-	      if ((c == '[' || FOLD ((unsigned char)*n) == c1) &&
-		  fnmatch (p, n, flags & ~FNM_PERIOD) == 0)
-		return 0;
-	    return FNM_NOMATCH;
-	  }
-
-	case '[':
-	  {
-	    /* Nonzero if the sense of the character class is inverted.  */
-	    register int negate;
-
-	    if (*n == '\0')
-	      return FNM_NOMATCH;
-
-	    if ((flags & FNM_PERIOD) && *n == '.' &&
-		(n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
-	      return FNM_NOMATCH;
-
-	    negate = (*p == '!' || *p == '^');
-	    if (negate)
-	      ++p;
-
-	    c = *p++;
-	    for (;;)
-	      {
-		register unsigned char cstart = c, cend = c;
-
-		if (!(flags & FNM_NOESCAPE) && c == '\\')
-		  cstart = cend = *p++;
-
-		cstart = cend = FOLD (cstart);
-
-		if (c == '\0')
-		  /* [ (unterminated) loses.  */
-		  return FNM_NOMATCH;
-
-		c = *p++;
-		c = FOLD (c);
-
-		if ((flags & FNM_FILE_NAME) && c == '/')
-		  /* [/] can never match.  */
-		  return FNM_NOMATCH;
-
-		if (c == '-' && *p != ']')
-		  {
-		    cend = *p++;
-		    if (!(flags & FNM_NOESCAPE) && cend == '\\')
-		      cend = *p++;
-		    if (cend == '\0')
-		      return FNM_NOMATCH;
-		    cend = FOLD (cend);
-
-		    c = *p++;
-		  }
-
-		if (FOLD ((unsigned char)*n) >= cstart
-		    && FOLD ((unsigned char)*n) <= cend)
-		  goto matched;
-
-		if (c == ']')
-		  break;
-	      }
-	    if (!negate)
-	      return FNM_NOMATCH;
-	    break;
-
-	  matched:;
-	    /* Skip the rest of the [...] that already matched.  */
-	    while (c != ']')
-	      {
-		if (c == '\0')
-		  /* [... (unterminated) loses.  */
-		  return FNM_NOMATCH;
-
-		c = *p++;
-		if (!(flags & FNM_NOESCAPE) && c == '\\')
-		  /* XXX 1003.2d11 is unclear if this is right.  */
-		  ++p;
-	      }
-	    if (negate)
-	      return FNM_NOMATCH;
-	  }
-	  break;
-
-	default:
-	  if (c != FOLD ((unsigned char)*n))
-	    return FNM_NOMATCH;
-	}
-
-      ++n;
-    }
-
-  if (*n == '\0')
-    return 0;
-
-  if ((flags & FNM_LEADING_DIR) && *n == '/')
-    /* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz".  */
-    return 0;
-
-  return FNM_NOMATCH;
-}
-
-#endif	/* _LIBC or not __GNU_LIBRARY__.  */
diff --git a/libiberty/getcwd.c b/libiberty/getcwd.c
deleted file mode 100644
index 28f26eb17..000000000
--- a/libiberty/getcwd.c
+++ /dev/null
@@ -1,62 +0,0 @@
-/* Emulate getcwd using getwd.
-   This function is in the public domain. */
-
-/*
-
-@deftypefn Supplemental char* getcwd (char *@var{pathname}, int @var{len})
-
-Copy the absolute pathname for the current working directory into
-@var{pathname}, which is assumed to point to a buffer of at least
-@var{len} bytes, and return a pointer to the buffer.  If the current
-directory's path doesn't fit in @var{len} characters, the result is
-@code{NULL} and @code{errno} is set.  If @var{pathname} is a null pointer,
-@code{getcwd} will obtain @var{len} bytes of space using
-@code{malloc}.
-
-@end deftypefn
-
-*/
-
-#include "config.h"
-
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-#include <errno.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
-extern char *getwd ();
-extern int errno;
-
-#ifndef MAXPATHLEN
-#define MAXPATHLEN 1024
-#endif
-
-char *
-getcwd (char *buf, size_t len)
-{
-  char ourbuf[MAXPATHLEN];
-  char *result;
-
-  result = getwd (ourbuf);
-  if (result) {
-    if (strlen (ourbuf) >= len) {
-      errno = ERANGE;
-      return 0;
-    }
-    if (!buf) {
-       buf = (char*)malloc(len);
-       if (!buf) {
-           errno = ENOMEM;
-	   return 0;
-       }
-    }
-    strcpy (buf, ourbuf);
-  }
-  return buf;
-}
diff --git a/libiberty/getopt.c b/libiberty/getopt.c
deleted file mode 100644
index d9c3532ce..000000000
--- a/libiberty/getopt.c
+++ /dev/null
@@ -1,1052 +0,0 @@
-/* Getopt for GNU.
-   NOTE: getopt is now part of the C library, so if you don't know what
-   "Keep this file name-space clean" means, talk to drepper@gnu.org
-   before changing it!
-
-   Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1997, 1998, 2005 Free Software Foundation, Inc.
-
-   NOTE: This source is derived from an old version taken from the GNU C
-   Library (glibc).
-
-   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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
-   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
-
-#if !defined __STDC__ || !__STDC__
-/* This is a separate conditional since some stdc systems
-   reject `defined (const)'.  */
-# ifndef const
-#  define const
-# endif
-#endif
-
-#include "ansidecl.h"
-#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__
-/* 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>
-#endif	/* GNU C library.  */
-
-#ifdef VMS
-# include <unixlib.h>
-# if HAVE_STRING_H - 0
-#  include <string.h>
-# endif
-#endif
-
-#ifndef _
-/* This is for other GNU distributions with internationalized messages.
-   When compiling libc, the _ macro is predefined.  */
-# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
-#  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
-   to intersperse the options with the other arguments.
-
-   As `getopt' works, it permutes the elements of ARGV so that,
-   when it is done, all the options precede everything else.  Thus
-   all application programs are extended to handle flexible argument order.
-
-   Setting the environment variable POSIXLY_CORRECT disables permutation.
-   Then the behavior is completely standard.
-
-   GNU application programs can use a third alternative mode in which
-   they can distinguish the relative order of options and other arguments.  */
-
-#include "getopt.h"
-
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   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
-   and for communication between successive calls to `getopt'.
-
-   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.
-   This allows us to pick up the scan where we left off.
-
-   If this is zero, or a null string, it means resume the scan
-   by advancing to the next ARGV-element.  */
-
-static char *nextchar;
-
-/* Callers store zero here to inhibit the error message
-   for unrecognized options.  */
-
-int opterr = 1;
-
-/* Set to an option character which was unrecognized.
-   This must be initialized on some systems to avoid linking in the
-   system's own getopt implementation.  */
-
-int optopt = '?';
-
-/* Describe how to deal with options that follow non-option ARGV-elements.
-
-   If the caller did not specify anything,
-   the default is REQUIRE_ORDER if the environment variable
-   POSIXLY_CORRECT is defined, PERMUTE otherwise.
-
-   REQUIRE_ORDER means don't recognize them as options;
-   stop option processing when the first non-option is seen.
-   This is what Unix does.
-   This mode of operation is selected by either setting the environment
-   variable POSIXLY_CORRECT, or using `+' as the first character
-   of the list of option characters.
-
-   PERMUTE is the default.  We permute the contents of ARGV as we scan,
-   so that eventually all the non-options are at the end.  This allows options
-   to be given in any order, even with programs that were not written to
-   expect this.
-
-   RETURN_IN_ORDER is an option available to programs that were written
-   to expect options and other ARGV-elements in any order and that care about
-   the ordering of the two.  We describe each non-option ARGV-element
-   as if it were the argument of an option with character code 1.
-   Using `-' as the first character of the list of option characters
-   selects this mode of operation.
-
-   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
-   because there are many ways it can cause trouble.
-   On some systems, it contains special magic macros that don't work
-   in GCC.  */
-# include <string.h>
-# define my_index	strchr
-#else
-
-# if HAVE_STRING_H
-#  include <string.h>
-# else
-#  if HAVE_STRINGS_H
-#   include <strings.h>
-#  endif
-# endif
-
-/* Avoid depending on library functions or files
-   whose names are inconsistent.  */
-
-#if HAVE_STDLIB_H && HAVE_DECL_GETENV
-#  include <stdlib.h>
-#elif !defined(getenv)
-#  ifdef __cplusplus
-extern "C" {
-#  endif /* __cplusplus */
-extern char *getenv (const char *);
-#  ifdef __cplusplus
-}
-#  endif /* __cplusplus */
-#endif
-
-static char *
-my_index (const char *str, int chr)
-{
-  while (*str)
-    {
-      if (*str == chr)
-	return (char *) str;
-      str++;
-    }
-  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__) && !defined strlen
-/* 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.  */
-
-/* Describe the part of ARGV that contains non-options that have
-   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
-   `last_nonopt' is the index after the last of them.  */
-
-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.  */
-
-/* Defined in getopt_init.c  */
-extern char *__getopt_nonoption_flags;
-
-static int nonoption_flags_max_len;
-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
-__attribute__ ((unused))
-store_args_and_env (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;
-}
-# ifdef text_set_element
-text_set_element (__libc_subinit, store_args_and_env);
-# endif /* text_set_element */
-
-# define SWAP_FLAGS(ch1, ch2) \
-  if (nonoption_flags_len > 0)						      \
-    {									      \
-      char __tmp = __getopt_nonoption_flags[ch1];			      \
-      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
-      __getopt_nonoption_flags[ch2] = __tmp;				      \
-    }
-#else	/* !_LIBC */
-# define SWAP_FLAGS(ch1, ch2)
-#endif	/* _LIBC */
-
-/* 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.
-   The other is elements [last_nonopt,optind), which contains all
-   the options processed since those non-options were skipped.
-
-   `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 (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.  */
-
-#ifdef _LIBC
-  /* First make sure the handling of the `__getopt_nonoption_flags'
-     string can work normally.  Our top argument must be in the range
-     of the string.  */
-  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
-    {
-      /* We must extend the array.  The user plays games with us and
-	 presents new arguments.  */
-      char *new_str = (char *) malloc (top + 1);
-      if (new_str == NULL)
-	nonoption_flags_len = nonoption_flags_max_len = 0;
-      else
-	{
-	  memset (mempcpy (new_str, __getopt_nonoption_flags,
-			   nonoption_flags_max_len),
-		  '\0', top + 1 - nonoption_flags_max_len);
-	  nonoption_flags_max_len = top + 1;
-	  __getopt_nonoption_flags = new_str;
-	}
-    }
-#endif
-
-  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;
-	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
-	    }
-	  /* 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;
-	      SWAP_FLAGS (bottom + i, middle + i);
-	    }
-	  /* 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 (int argc ATTRIBUTE_UNUSED,
-		    char *const *argv ATTRIBUTE_UNUSED,
-		    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;
-
-  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)
-    {
-      if (nonoption_flags_max_len == 0)
-	{
-	  if (__getopt_nonoption_flags == NULL
-	      || __getopt_nonoption_flags[0] == '\0')
-	    nonoption_flags_max_len = -1;
-	  else
-	    {
-	      const char *orig_str = __getopt_nonoption_flags;
-	      int len = nonoption_flags_max_len = strlen (orig_str);
-	      if (nonoption_flags_max_len < argc)
-		nonoption_flags_max_len = argc;
-	      __getopt_nonoption_flags =
-		(char *) malloc (nonoption_flags_max_len);
-	      if (__getopt_nonoption_flags == NULL)
-		nonoption_flags_max_len = -1;
-	      else
-		memset (mempcpy (__getopt_nonoption_flags, orig_str, len),
-			'\0', nonoption_flags_max_len - len);
-	    }
-	}
-      nonoption_flags_len = nonoption_flags_max_len;
-    }
-  else
-    nonoption_flags_len = 0;
-#endif
-
-  return optstring;
-}
-
-/* Scan elements of ARGV (whose length is ARGC) for option characters
-   given in OPTSTRING.
-
-   If an element of ARGV starts with '-', and is not exactly "-" or "--",
-   then it is an option element.  The characters of this element
-   (aside from the initial '-') are option characters.  If `getopt'
-   is called repeatedly, it returns successively each of the option characters
-   from each of the option elements.
-
-   If `getopt' finds another option character, it returns that character,
-   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.)
-
-   OPTSTRING is a string containing the legitimate option characters.
-   If an option character is seen that is not listed in OPTSTRING,
-   return '?' after printing an error message.  If you set `opterr' to
-   zero, the error message is suppressed but we still return '?'.
-
-   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
-   so the following text in the same ARGV-element, or the text of the following
-   ARGV-element, is returned in `optarg'.  Two colons mean an option that
-   wants an optional arg; if there is text in the current ARGV-element,
-   it is returned in `optarg', otherwise `optarg' is set to zero.
-
-   If OPTSTRING starts with `-' or `+', it requests different methods of
-   handling the non-option ARGV-elements.
-   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
-
-   Long-named options begin with `--' instead of `-'.
-   Their names may be abbreviated as long as the abbreviation is unique
-   or is an exact match for some defined option.  If they have an
-   argument, it follows the option name in the same ARGV-element, separated
-   from the option name by a `=', or else the in next ARGV-element.
-   When `getopt' finds a long-named option, it returns 0 if that option's
-   `flag' field is nonzero, the value of the option's `val' field
-   if the `flag' field is zero.
-
-   The elements of ARGV aren't really const, because we permute them.
-   But we pretend they're const in the prototype to be compatible
-   with other systems.
-
-   LONGOPTS is a vector of `struct option' terminated by an
-   element containing a name which is zero.
-
-   LONGIND returns the index in LONGOPT of the long-named option found.
-   It is only valid when a long-named option has been found by the most
-   recent call.
-
-   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
-   long-named options.  */
-
-int
-_getopt_internal (int argc, char *const *argv, const char *optstring,
-                  const struct option *longopts,
-                  int *longind, int long_only)
-{
-  optarg = NULL;
-
-  if (optind == 0 || !__getopt_initialized)
-    {
-      if (optind == 0)
-	optind = 1;	/* Don't scan ARGV[0], the program name.  */
-      optstring = _getopt_initialize (argc, argv, optstring);
-      __getopt_initialized = 1;
-    }
-
-  /* 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			      \
-			  && __getopt_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,
-	     exchange them so that the options come first.  */
-
-	  if (first_nonopt != last_nonopt && last_nonopt != optind)
-	    exchange ((char **) argv);
-	  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)
-	    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.  */
-
-      if (optind != argc && !strcmp (argv[optind], "--"))
-	{
-	  optind++;
-
-	  if (first_nonopt != last_nonopt && last_nonopt != optind)
-	    exchange ((char **) argv);
-	  else if (first_nonopt == last_nonopt)
-	    first_nonopt = optind;
-	  last_nonopt = argc;
-
-	  optind = argc;
-	}
-
-      /* If we have done all the ARGV-elements, stop the scan
-	 and back over any non-options that we skipped and permuted.  */
-
-      if (optind == argc)
-	{
-	  /* Set the next-arg-index to point at the non-options
-	     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)
-	{
-	  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])))))
-    {
-      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;
-		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 `%s' is ambiguous\n"),
-		     argv[0], argv[optind]);
-	  nextchar += strlen (nextchar);
-	  optind++;
-	  optopt = 0;
-	  return '?';
-	}
-
-      if (pfound != NULL)
-	{
-	  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 (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);
-		  optopt = pfound->val;
-		  return optstring[0] == ':' ? ':' : '?';
-		}
-	    }
-	  nextchar += strlen (nextchar);
-	  if (longind != NULL)
-	    *longind = option_index;
-	  if (pfound->flag)
-	    {
-	      *(pfound->flag) = pfound->val;
-	      return 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] == '-'
-	  || 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++;
-    char *temp = my_index (optstring, c);
-
-    /* Increment `optind' when we start to process its last character.  */
-    if (*nextchar == '\0')
-      ++optind;
-
-    if (temp == NULL || c == ':')
-      {
-	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);
-	  }
-	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] == ':')
-	  {
-	    /* This is an option that accepts an argument optionally.  */
-	    if (*nextchar != '\0')
-	      {
-		optarg = nextchar;
-		optind++;
-	      }
-	    else
-	      optarg = NULL;
-	    nextchar = NULL;
-	  }
-	else
-	  {
-	    /* 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 = '?';
-	      }
-	    else
-	      /* We already incremented `optind' once;
-		 increment it again when taking next ARGV-elt as argument.  */
-	      optarg = argv[optind++];
-	    nextchar = NULL;
-	  }
-      }
-    return c;
-  }
-}
-
-int
-getopt (int argc, char *const *argv, const char *optstring)
-{
-  return _getopt_internal (argc, argv, optstring,
-			   (const struct option *) 0,
-			   (int *) 0,
-			   0);
-}
-
-#endif	/* Not ELIDE_CODE.  */
-
-#ifdef TEST
-
-/* Compile with -DTEST to make an executable for use in testing
-   the above definition of `getopt'.  */
-
-int
-main (int argc, char **argv)
-{
-  int c;
-  int digit_optind = 0;
-
-  while (1)
-    {
-      int this_option_optind = optind ? optind : 1;
-
-      c = getopt (argc, argv, "abc:d:0123456789");
-      if (c == -1)
-	break;
-
-      switch (c)
-	{
-	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 '?':
-	  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 */
diff --git a/libiberty/getopt1.c b/libiberty/getopt1.c
deleted file mode 100644
index 255b14456..000000000
--- a/libiberty/getopt1.c
+++ /dev/null
@@ -1,180 +0,0 @@
-/* getopt_long and getopt_long_only entry points for GNU getopt.
-   Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98,2005
-     Free Software Foundation, Inc.
-
-   NOTE: This source is derived from an old version taken from the GNU C
-   Library (glibc).
-
-   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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
-   USA.  */
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#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>
-
-#include "getopt.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 (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 (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 (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 */
diff --git a/libiberty/getpagesize.c b/libiberty/getpagesize.c
deleted file mode 100644
index 1c3a26304..000000000
--- a/libiberty/getpagesize.c
+++ /dev/null
@@ -1,90 +0,0 @@
-/* Emulation of getpagesize() for systems that need it. */
-
-/*
-
-@deftypefn Supplemental int getpagesize (void)
-
-Returns the number of bytes in a page of memory.  This is the
-granularity of many of the system memory management routines.  No
-guarantee is made as to whether or not it is the same as the basic
-memory management hardware page size.
-
-@end deftypefn
-
-BUGS
-
-	Is intended as a reasonable replacement for systems where this
-	is not provided as a system call.  The value of 4096 may or may
-	not be correct for the systems where it is returned as the default
-	value.
-
-*/
-
-#ifndef VMS
-
-#include "config.h"
-
-#include <sys/types.h>
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-
-#undef GNU_OUR_PAGESIZE
-#if defined (HAVE_SYSCONF) && defined (HAVE_UNISTD_H)
-#include <unistd.h>
-#ifdef _SC_PAGESIZE
-#define GNU_OUR_PAGESIZE sysconf(_SC_PAGESIZE)
-#endif
-#endif
-
-#ifndef GNU_OUR_PAGESIZE
-# ifdef	PAGESIZE
-#  define	GNU_OUR_PAGESIZE PAGESIZE
-# else	/* no PAGESIZE */
-#  ifdef	EXEC_PAGESIZE
-#   define	GNU_OUR_PAGESIZE EXEC_PAGESIZE
-#  else	/* no EXEC_PAGESIZE */
-#   ifdef	NBPG
-#    define	GNU_OUR_PAGESIZE (NBPG * CLSIZE)
-#    ifndef	CLSIZE
-#     define	CLSIZE 1
-#    endif	/* CLSIZE */
-#   else	/* no NBPG */
-#    ifdef	NBPC
-#     define	GNU_OUR_PAGESIZE NBPC
-#    else	/* no NBPC */
-#     define	GNU_OUR_PAGESIZE 4096	/* Just punt and use reasonable value */
-#    endif /* NBPC */
-#   endif /* NBPG */
-#  endif /* EXEC_PAGESIZE */
-# endif /* PAGESIZE */
-#endif /* GNU_OUR_PAGESIZE */
-
-int
-getpagesize (void)
-{
-  return (GNU_OUR_PAGESIZE);
-}
-
-#else /* VMS */
-
-#if 0	/* older distributions of gcc-vms are missing <syidef.h> */
-#include <syidef.h>
-#endif
-#ifndef SYI$_PAGE_SIZE	/* VMS V5.4 and earlier didn't have this yet */
-#define SYI$_PAGE_SIZE 4452
-#endif
-extern unsigned long lib$getsyi(const unsigned short *,...);
-
-int getpagesize (void)
-{
-  long pagsiz = 0L;
-  unsigned short itmcod = SYI$_PAGE_SIZE;
-
-  (void) lib$getsyi (&itmcod, (void *) &pagsiz);
-  if (pagsiz == 0L)
-    pagsiz = 512L;	/* VAX default */
-  return (int) pagsiz;
-}
-
-#endif /* VMS */
diff --git a/libiberty/gettimeofday.c b/libiberty/gettimeofday.c
deleted file mode 100644
index fca167940..000000000
--- a/libiberty/gettimeofday.c
+++ /dev/null
@@ -1,30 +0,0 @@
-#include "config.h"
-#include "libiberty.h"
-#ifdef HAVE_TIME_H
-#include <time.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-
-/* 
-
-@deftypefn Supplemental int gettimeofday (struct timeval *@var{tp}, void *@var{tz})
-
-Writes the current time to @var{tp}.  This implementation requires
-that @var{tz} be NULL.  Returns 0 on success, -1 on failure.
-
-@end deftypefn
-
-*/ 
-
-int
-gettimeofday (struct timeval *tp, void *tz)
-{
-  if (tz)
-    abort ();
-  tp->tv_usec = 0;
-  if (time (&tp->tv_sec) == (time_t) -1)
-    return -1;
-  return 0;
-}
diff --git a/libiberty/index.c b/libiberty/index.c
deleted file mode 100644
index acd0a45fc..000000000
--- a/libiberty/index.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Stub implementation of (obsolete) index(). */
-
-/*
-
-@deftypefn Supplemental char* index (char *@var{s}, int @var{c})
-
-Returns a pointer to the first occurrence of the character @var{c} in
-the string @var{s}, or @code{NULL} if not found.  The use of @code{index} is
-deprecated in new programs in favor of @code{strchr}.
-
-@end deftypefn
-
-*/
-
-extern char * strchr(const char *, int);
-
-char *
-index (const char *s, int c)
-{
-  return strchr (s, c);
-}
diff --git a/libiberty/insque.c b/libiberty/insque.c
deleted file mode 100644
index fd02357bb..000000000
--- a/libiberty/insque.c
+++ /dev/null
@@ -1,51 +0,0 @@
-/* insque(3C) routines
-   This file is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental void insque (struct qelem *@var{elem}, @
-  struct qelem *@var{pred})
-@deftypefnx Supplemental void remque (struct qelem *@var{elem})
-
-Routines to manipulate queues built from doubly linked lists.  The
-@code{insque} routine inserts @var{elem} in the queue immediately
-after @var{pred}.  The @code{remque} routine removes @var{elem} from
-its containing queue.  These routines expect to be passed pointers to
-structures which have as their first members a forward pointer and a
-back pointer, like this prototype (although no prototype is provided):
-
-@example
-struct qelem @{
-  struct qelem *q_forw;
-  struct qelem *q_back;
-  char q_data[];
-@};
-@end example
-
-@end deftypefn
-
-*/
-
-
-struct qelem {
-  struct qelem *q_forw;
-  struct qelem *q_back;
-};
-
-
-void
-insque (struct qelem *elem, struct qelem *pred)
-{
-  elem -> q_forw = pred -> q_forw;
-  pred -> q_forw -> q_back = elem;
-  elem -> q_back = pred;
-  pred -> q_forw = elem;
-}
-
-
-void
-remque (struct qelem *elem)
-{
-  elem -> q_forw -> q_back = elem -> q_back;
-  elem -> q_back -> q_forw = elem -> q_forw;
-}
diff --git a/libiberty/memchr.c b/libiberty/memchr.c
deleted file mode 100644
index 7448ab9e7..000000000
--- a/libiberty/memchr.c
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
-
-@deftypefn Supplemental void* memchr (const void *@var{s}, int @var{c}, @
-  size_t @var{n})
-
-This function searches memory starting at @code{*@var{s}} for the
-character @var{c}.  The search only ends with the first occurrence of
-@var{c}, or after @var{length} characters; in particular, a null
-character does not terminate the search.  If the character @var{c} is
-found within @var{length} characters of @code{*@var{s}}, a pointer
-to the character is returned.  If @var{c} is not found, then @code{NULL} is
-returned.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-PTR
-memchr (register const PTR src_void, int c, size_t length)
-{
-  const unsigned char *src = (const unsigned char *)src_void;
-  
-  while (length-- > 0)
-  {
-    if (*src == c)
-     return (PTR)src;
-    src++;
-  }
-  return NULL;
-}
diff --git a/libiberty/memcmp.c b/libiberty/memcmp.c
deleted file mode 100644
index 37db60f38..000000000
--- a/libiberty/memcmp.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/* memcmp -- compare two memory regions.
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental int memcmp (const void *@var{x}, const void *@var{y}, @
-  size_t @var{count})
-
-Compares the first @var{count} bytes of two areas of memory.  Returns
-zero if they are the same, a value less than zero if @var{x} is
-lexically less than @var{y}, or a value greater than zero if @var{x}
-is lexically greater than @var{y}.  Note that lexical order is determined
-as if comparing unsigned char arrays.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-int
-memcmp (const PTR str1, const PTR str2, size_t count)
-{
-  register const unsigned char *s1 = (const unsigned char*)str1;
-  register const unsigned char *s2 = (const unsigned char*)str2;
-
-  while (count-- > 0)
-    {
-      if (*s1++ != *s2++)
-	  return s1[-1] < s2[-1] ? -1 : 1;
-    }
-  return 0;
-}
-
diff --git a/libiberty/memcpy.c b/libiberty/memcpy.c
deleted file mode 100644
index 7f67d0bd1..000000000
--- a/libiberty/memcpy.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/* memcpy (the standard C function)
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental void* memcpy (void *@var{out}, const void *@var{in}, @
-  size_t @var{length})
-
-Copies @var{length} bytes from memory region @var{in} to region
-@var{out}.  Returns a pointer to @var{out}.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-void bcopy (const void*, void*, size_t);
-
-PTR
-memcpy (PTR out, const PTR in, size_t length)
-{
-    bcopy(in, out, length);
-    return out;
-}
diff --git a/libiberty/memmem.c b/libiberty/memmem.c
deleted file mode 100644
index 147253f5b..000000000
--- a/libiberty/memmem.c
+++ /dev/null
@@ -1,71 +0,0 @@
-/* Copyright (C) 1991,92,93,94,96,97,98,2000,2004,2007,2011 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Supplemental void* memmem (const void *@var{haystack}, @
-  size_t @var{haystack_len} const void *@var{needle}, size_t @var{needle_len})
-
-Returns a pointer to the first occurrence of @var{needle} (length
-@var{needle_len}) in @var{haystack} (length @var{haystack_len}).
-Returns @code{NULL} if not found.
-
-@end deftypefn
-
-*/
-
-#ifndef _LIBC
-# include <config.h>
-#endif
-
-#include <stddef.h>
-#include <string.h>
-
-#ifndef _LIBC
-# define __builtin_expect(expr, val)   (expr)
-#endif
-
-#undef memmem
-
-/* Return the first occurrence of NEEDLE in HAYSTACK.  */
-void *
-memmem (const void *haystack, size_t haystack_len, const void *needle,
-	size_t needle_len)
-{
-  const char *begin;
-  const char *const last_possible
-    = (const char *) haystack + haystack_len - needle_len;
-
-  if (needle_len == 0)
-    /* The first occurrence of the empty string is deemed to occur at
-       the beginning of the string.  */
-    return (void *) haystack;
-
-  /* Sanity check, otherwise the loop might search through the whole
-     memory.  */
-  if (__builtin_expect (haystack_len < needle_len, 0))
-    return NULL;
-
-  for (begin = (const char *) haystack; begin <= last_possible; ++begin)
-    if (begin[0] == ((const char *) needle)[0] &&
-	!memcmp ((const void *) &begin[1],
-		 (const void *) ((const char *) needle + 1),
-		 needle_len - 1))
-      return (void *) begin;
-
-  return NULL;
-}
diff --git a/libiberty/memmove.c b/libiberty/memmove.c
deleted file mode 100644
index ebda7cbb4..000000000
--- a/libiberty/memmove.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Wrapper to implement ANSI C's memmove using BSD's bcopy. */
-/* This function is in the public domain.  --Per Bothner. */
-
-/*
-
-@deftypefn Supplemental void* memmove (void *@var{from}, const void *@var{to}, @
-  size_t @var{count})
-
-Copies @var{count} bytes from memory area @var{from} to memory area
-@var{to}, returning a pointer to @var{to}.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-void bcopy (const void*, void*, size_t);
-
-PTR
-memmove (PTR s1, const PTR s2, size_t n)
-{
-  bcopy (s2, s1, n);
-  return s1;
-}
diff --git a/libiberty/mempcpy.c b/libiberty/mempcpy.c
deleted file mode 100644
index f85a07f29..000000000
--- a/libiberty/mempcpy.c
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Implement the mempcpy function.
-   Copyright (C) 2003, 2004, 2005, 2011 Free Software Foundation, Inc.
-   Written by Kaveh R. Ghazi <ghazi@caip.rutgers.edu>.
-
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Supplemental void* mempcpy (void *@var{out}, const void *@var{in}, @
-  size_t @var{length})
-
-Copies @var{length} bytes from memory region @var{in} to region
-@var{out}.  Returns a pointer to @var{out} + @var{length}.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-extern PTR memcpy (PTR, const PTR, size_t);
-
-PTR
-mempcpy (PTR dst, const PTR src, size_t len)
-{
-  return (char *) memcpy (dst, src, len) + len;
-}
diff --git a/libiberty/memset.c b/libiberty/memset.c
deleted file mode 100644
index 476668961..000000000
--- a/libiberty/memset.c
+++ /dev/null
@@ -1,26 +0,0 @@
-/* memset
-   This implementation is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental void* memset (void *@var{s}, int @var{c}, @
-  size_t @var{count})
-
-Sets the first @var{count} bytes of @var{s} to the constant byte
-@var{c}, returning a pointer to @var{s}.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-PTR
-memset (PTR dest, register int val, register size_t len)
-{
-  register unsigned char *ptr = (unsigned char*)dest;
-  while (len-- > 0)
-    *ptr++ = val;
-  return dest;
-}
diff --git a/libiberty/mkstemps.c b/libiberty/mkstemps.c
deleted file mode 100644
index a0e68a73b..000000000
--- a/libiberty/mkstemps.c
+++ /dev/null
@@ -1,147 +0,0 @@
-/* Copyright (C) 1991, 1992, 1996, 1998, 2004 Free Software Foundation, Inc.
-   This file is derived from mkstemp.c from the GNU C Library.
-
-   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., 51 Franklin Street - Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <sys/types.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#include <errno.h>
-#include <stdio.h>
-#include <fcntl.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-#ifdef HAVE_SYS_TIME_H
-#include <sys/time.h>
-#endif
-#include "ansidecl.h"
-
-/* We need to provide a type for gcc_uint64_t.  */
-#ifdef __GNUC__
-__extension__ typedef unsigned long long gcc_uint64_t;
-#else
-typedef unsigned long gcc_uint64_t;
-#endif
-
-#ifndef TMP_MAX
-#define TMP_MAX 16384
-#endif
-
-#ifndef O_BINARY
-# define O_BINARY 0
-#endif
-
-/*
-
-@deftypefn Replacement int mkstemps (char *@var{pattern}, int @var{suffix_len})
-
-Generate a unique temporary file name from @var{pattern}.
-@var{pattern} has the form:
-
-@example
-   @var{path}/ccXXXXXX@var{suffix}
-@end example
-
-@var{suffix_len} tells us how long @var{suffix} is (it can be zero
-length).  The last six characters of @var{pattern} before @var{suffix}
-must be @samp{XXXXXX}; they are replaced with a string that makes the
-filename unique.  Returns a file descriptor open on the file for
-reading and writing.
-
-@end deftypefn
-
-*/
-
-int
-mkstemps (char *pattern, int suffix_len)
-{
-  static const char letters[]
-    = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  static gcc_uint64_t value;
-#ifdef HAVE_GETTIMEOFDAY
-  struct timeval tv;
-#endif
-  char *XXXXXX;
-  size_t len;
-  int count;
-
-  len = strlen (pattern);
-
-  if ((int) len < 6 + suffix_len
-      || strncmp (&pattern[len - 6 - suffix_len], "XXXXXX", 6))
-    {
-      return -1;
-    }
-
-  XXXXXX = &pattern[len - 6 - suffix_len];
-
-#ifdef HAVE_GETTIMEOFDAY
-  /* Get some more or less random data.  */
-  gettimeofday (&tv, NULL);
-  value += ((gcc_uint64_t) tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
-#else
-  value += getpid ();
-#endif
-
-  for (count = 0; count < TMP_MAX; ++count)
-    {
-      gcc_uint64_t v = value;
-      int fd;
-
-      /* Fill in the random bits.  */
-      XXXXXX[0] = letters[v % 62];
-      v /= 62;
-      XXXXXX[1] = letters[v % 62];
-      v /= 62;
-      XXXXXX[2] = letters[v % 62];
-      v /= 62;
-      XXXXXX[3] = letters[v % 62];
-      v /= 62;
-      XXXXXX[4] = letters[v % 62];
-      v /= 62;
-      XXXXXX[5] = letters[v % 62];
-
-      fd = open (pattern, O_BINARY|O_RDWR|O_CREAT|O_EXCL, 0600);
-      if (fd >= 0)
-	/* The file does not exist.  */
-	return fd;
-      if (errno != EEXIST
-#ifdef EISDIR
-	  && errno != EISDIR
-#endif
-	 )
-	/* Fatal error (EPERM, ENOSPC etc).  Doesn't make sense to loop.  */
-	break;
-
-      /* This is a random value.  It is only necessary that the next
-	 TMP_MAX values generated by adding 7777 to VALUE are different
-	 with (module 2^32).  */
-      value += 7777;
-    }
-
-  /* We return the null string if we can't find a unique file name.  */
-  pattern[0] = '\0';
-  return -1;
-}
diff --git a/libiberty/putenv.c b/libiberty/putenv.c
deleted file mode 100644
index 248f50e92..000000000
--- a/libiberty/putenv.c
+++ /dev/null
@@ -1,84 +0,0 @@
-/* Copyright (C) 1991, 1994, 1995, 1996, 2002 Free Software Foundation, Inc.
-   This file based on putenv.c in the GNU C Library.
-
-   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., 51 Franklin Street - Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Supplemental int putenv (const char *@var{string})
-
-Uses @code{setenv} or @code{unsetenv} to put @var{string} into
-the environment or remove it.  If @var{string} is of the form
-@samp{name=value} the string is added; if no @samp{=} is present the
-name is unset/removed.
-
-@end deftypefn
-
-*/
-
-#if defined (_AIX) && !defined (__GNUC__)
- #pragma alloca
-#endif
-
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#include "ansidecl.h"
-
-#define putenv libiberty_putenv
-
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#if HAVE_STRING_H
-# include <string.h>
-#endif
-
-#ifdef HAVE_ALLOCA_H
-# include <alloca.h>
-#else
-# ifndef alloca
-#  ifdef __GNUC__
-#   define alloca __builtin_alloca
-#  else
-extern char *alloca ();
-#  endif /* __GNUC__ */
-# endif /* alloca */
-#endif /* HAVE_ALLOCA_H */
-
-#undef putenv
-
-/* Below this point, it's verbatim code from the glibc-2.0 implementation */
-
-
-/* Put STRING, which is of the form "NAME=VALUE", in the environment.  */
-int
-putenv (const char *string)
-{
-  const char *const name_end = strchr (string, '=');
-
-  if (name_end)
-    {
-      char *name = (char *) alloca (name_end - string + 1);
-      memcpy (name, string, name_end - string);
-      name[name_end - string] = '\0';
-      return setenv (name, name_end + 1, 1);
-    }
-
-  unsetenv (string);
-  return 0;
-}
diff --git a/libiberty/random.c b/libiberty/random.c
deleted file mode 100644
index b1d3c6c6a..000000000
--- a/libiberty/random.c
+++ /dev/null
@@ -1,404 +0,0 @@
-/*
- * Copyright (c) 1983 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. [rescinded 22 July 1999]
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
- * This is derived from the Berkeley source:
- *	@(#)random.c	5.5 (Berkeley) 7/6/88
- * It was reworked for the GNU C Library by Roland McGrath.
- */
-
-/*
-
-@deftypefn Supplement {long int} random (void)
-@deftypefnx Supplement void srandom (unsigned int @var{seed})
-@deftypefnx Supplement void* initstate (unsigned int @var{seed}, @
-  void *@var{arg_state}, unsigned long @var{n})
-@deftypefnx Supplement void* setstate (void *@var{arg_state})
-
-Random number functions.  @code{random} returns a random number in the
-range 0 to @code{LONG_MAX}.  @code{srandom} initializes the random
-number generator to some starting point determined by @var{seed}
-(else, the values returned by @code{random} are always the same for each
-run of the program).  @code{initstate} and @code{setstate} allow fine-grained
-control over the state of the random number generator.
-
-@end deftypefn
-
-*/
-
-#include <errno.h>
-
-#if 0
-
-#include <ansidecl.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdlib.h>
-
-#else
-
-#define	ULONG_MAX  ((unsigned long)(~0L))     /* 0xFFFFFFFF for 32-bits */
-#define	LONG_MAX   ((long)(ULONG_MAX >> 1))   /* 0x7FFFFFFF for 32-bits*/
-
-#ifdef __STDC__
-#  define PTR void *
-#  ifndef NULL
-#    define NULL (void *) 0
-#  endif
-#else
-#  define PTR char *
-#  ifndef NULL
-#    define NULL (void *) 0
-#  endif
-#endif
-
-#endif
-
-long int random (void);
-
-/* An improved random number generation package.  In addition to the standard
-   rand()/srand() like interface, this package also has a special state info
-   interface.  The initstate() routine is called with a seed, an array of
-   bytes, and a count of how many bytes are being passed in; this array is
-   then initialized to contain information for random number generation with
-   that much state information.  Good sizes for the amount of state
-   information are 32, 64, 128, and 256 bytes.  The state can be switched by
-   calling the setstate() function with the same array as was initiallized
-   with initstate().  By default, the package runs with 128 bytes of state
-   information and generates far better random numbers than a linear
-   congruential generator.  If the amount of state information is less than
-   32 bytes, a simple linear congruential R.N.G. is used.  Internally, the
-   state information is treated as an array of longs; the zeroeth element of
-   the array is the type of R.N.G. being used (small integer); the remainder
-   of the array is the state information for the R.N.G.  Thus, 32 bytes of
-   state information will give 7 longs worth of state information, which will
-   allow a degree seven polynomial.  (Note: The zeroeth word of state
-   information also has some other information stored in it; see setstate
-   for details).  The random number generation technique is a linear feedback
-   shift register approach, employing trinomials (since there are fewer terms
-   to sum up that way).  In this approach, the least significant bit of all
-   the numbers in the state table will act as a linear feedback shift register,
-   and will have period 2^deg - 1 (where deg is the degree of the polynomial
-   being used, assuming that the polynomial is irreducible and primitive).
-   The higher order bits will have longer periods, since their values are
-   also influenced by pseudo-random carries out of the lower bits.  The
-   total period of the generator is approximately deg*(2**deg - 1); thus
-   doubling the amount of state information has a vast influence on the
-   period of the generator.  Note: The deg*(2**deg - 1) is an approximation
-   only good for large deg, when the period of the shift register is the
-   dominant factor.  With deg equal to seven, the period is actually much
-   longer than the 7*(2**7 - 1) predicted by this formula.  */
-
-
-
-/* For each of the currently supported random number generators, we have a
-   break value on the amount of state information (you need at least thi
-   bytes of state info to support this random number generator), a degree for
-   the polynomial (actually a trinomial) that the R.N.G. is based on, and
-   separation between the two lower order coefficients of the trinomial.  */
-
-/* Linear congruential.  */
-#define	TYPE_0		0
-#define	BREAK_0		8
-#define	DEG_0		0
-#define	SEP_0		0
-
-/* x**7 + x**3 + 1.  */
-#define	TYPE_1		1
-#define	BREAK_1		32
-#define	DEG_1		7
-#define	SEP_1		3
-
-/* x**15 + x + 1.  */
-#define	TYPE_2		2
-#define	BREAK_2		64
-#define	DEG_2		15
-#define	SEP_2		1
-
-/* x**31 + x**3 + 1.  */
-#define	TYPE_3		3
-#define	BREAK_3		128
-#define	DEG_3		31
-#define	SEP_3		3
-
-/* x**63 + x + 1.  */
-#define	TYPE_4		4
-#define	BREAK_4		256
-#define	DEG_4		63
-#define	SEP_4		1
-
-
-/* Array versions of the above information to make code run faster.
-   Relies on fact that TYPE_i == i.  */
-
-#define	MAX_TYPES	5	/* Max number of types above.  */
-
-static int degrees[MAX_TYPES] = { DEG_0, DEG_1, DEG_2, DEG_3, DEG_4 };
-static int seps[MAX_TYPES] = { SEP_0, SEP_1, SEP_2, SEP_3, SEP_4 };
-
-
-
-/* Initially, everything is set up as if from:
-	initstate(1, randtbl, 128);
-   Note that this initialization takes advantage of the fact that srandom
-   advances the front and rear pointers 10*rand_deg times, and hence the
-   rear pointer which starts at 0 will also end up at zero; thus the zeroeth
-   element of the state information, which contains info about the current
-   position of the rear pointer is just
-	(MAX_TYPES * (rptr - state)) + TYPE_3 == TYPE_3.  */
-
-static long int randtbl[DEG_3 + 1] =
-  { TYPE_3,
-      0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342, 
-      0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb, 
-      0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd, 
-      0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86, 
-      0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7, 
-      0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc, 
-      0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b, 
-      0xf5ad9d0e, 0x8999220b, 0x27fb47b9
-    };
-
-/* FPTR and RPTR are two pointers into the state info, a front and a rear
-   pointer.  These two pointers are always rand_sep places aparts, as they
-   cycle through the state information.  (Yes, this does mean we could get
-   away with just one pointer, but the code for random is more efficient
-   this way).  The pointers are left positioned as they would be from the call:
-	initstate(1, randtbl, 128);
-   (The position of the rear pointer, rptr, is really 0 (as explained above
-   in the initialization of randtbl) because the state table pointer is set
-   to point to randtbl[1] (as explained below).)  */
-
-static long int *fptr = &randtbl[SEP_3 + 1];
-static long int *rptr = &randtbl[1];
-
-
-
-/* The following things are the pointer to the state information table,
-   the type of the current generator, the degree of the current polynomial
-   being used, and the separation between the two pointers.
-   Note that for efficiency of random, we remember the first location of
-   the state information, not the zeroeth.  Hence it is valid to access
-   state[-1], which is used to store the type of the R.N.G.
-   Also, we remember the last location, since this is more efficient than
-   indexing every time to find the address of the last element to see if
-   the front and rear pointers have wrapped.  */
-
-static long int *state = &randtbl[1];
-
-static int rand_type = TYPE_3;
-static int rand_deg = DEG_3;
-static int rand_sep = SEP_3;
-
-static long int *end_ptr = &randtbl[sizeof(randtbl) / sizeof(randtbl[0])];
-
-/* Initialize the random number generator based on the given seed.  If the
-   type is the trivial no-state-information type, just remember the seed.
-   Otherwise, initializes state[] based on the given "seed" via a linear
-   congruential generator.  Then, the pointers are set to known locations
-   that are exactly rand_sep places apart.  Lastly, it cycles the state
-   information a given number of times to get rid of any initial dependencies
-   introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
-   for default usage relies on values produced by this routine.  */
-void
-srandom (unsigned int x)
-{
-  state[0] = x;
-  if (rand_type != TYPE_0)
-    {
-      register long int i;
-      for (i = 1; i < rand_deg; ++i)
-	state[i] = (1103515145 * state[i - 1]) + 12345;
-      fptr = &state[rand_sep];
-      rptr = &state[0];
-      for (i = 0; i < 10 * rand_deg; ++i)
-	random();
-    }
-}
-
-/* Initialize the state information in the given array of N bytes for
-   future random number generation.  Based on the number of bytes we
-   are given, and the break values for the different R.N.G.'s, we choose
-   the best (largest) one we can and set things up for it.  srandom is
-   then called to initialize the state information.  Note that on return
-   from srandom, we set state[-1] to be the type multiplexed with the current
-   value of the rear pointer; this is so successive calls to initstate won't
-   lose this information and will be able to restart with setstate.
-   Note: The first thing we do is save the current state, if any, just like
-   setstate so that it doesn't matter when initstate is called.
-   Returns a pointer to the old state.  */
-PTR
-initstate (unsigned int seed, PTR arg_state, unsigned long n)
-{
-  PTR ostate = (PTR) &state[-1];
-
-  if (rand_type == TYPE_0)
-    state[-1] = rand_type;
-  else
-    state[-1] = (MAX_TYPES * (rptr - state)) + rand_type;
-  if (n < BREAK_1)
-    {
-      if (n < BREAK_0)
-	{
-	  errno = EINVAL;
-	  return NULL;
-	}
-      rand_type = TYPE_0;
-      rand_deg = DEG_0;
-      rand_sep = SEP_0;
-    }
-  else if (n < BREAK_2)
-    {
-      rand_type = TYPE_1;
-      rand_deg = DEG_1;
-      rand_sep = SEP_1;
-    }
-  else if (n < BREAK_3)
-    {
-      rand_type = TYPE_2;
-      rand_deg = DEG_2;
-      rand_sep = SEP_2;
-    }
-  else if (n < BREAK_4)
-    {
-      rand_type = TYPE_3;
-      rand_deg = DEG_3;
-      rand_sep = SEP_3;
-    }
-  else
-    {
-      rand_type = TYPE_4;
-      rand_deg = DEG_4;
-      rand_sep = SEP_4;
-    }
-
-  state = &((long int *) arg_state)[1];	/* First location.  */
-  /* Must set END_PTR before srandom.  */
-  end_ptr = &state[rand_deg];
-  srandom(seed);
-  if (rand_type == TYPE_0)
-    state[-1] = rand_type;
-  else
-    state[-1] = (MAX_TYPES * (rptr - state)) + rand_type;
-
-  return ostate;
-}
-
-/* Restore the state from the given state array.
-   Note: It is important that we also remember the locations of the pointers
-   in the current state information, and restore the locations of the pointers
-   from the old state information.  This is done by multiplexing the pointer
-   location into the zeroeth word of the state information. Note that due
-   to the order in which things are done, it is OK to call setstate with the
-   same state as the current state
-   Returns a pointer to the old state information.  */
-
-PTR
-setstate (PTR arg_state)
-{
-  register long int *new_state = (long int *) arg_state;
-  register int type = new_state[0] % MAX_TYPES;
-  register int rear = new_state[0] / MAX_TYPES;
-  PTR ostate = (PTR) &state[-1];
-
-  if (rand_type == TYPE_0)
-    state[-1] = rand_type;
-  else
-    state[-1] = (MAX_TYPES * (rptr - state)) + rand_type;
-
-  switch (type)
-    {
-    case TYPE_0:
-    case TYPE_1:
-    case TYPE_2:
-    case TYPE_3:
-    case TYPE_4:
-      rand_type = type;
-      rand_deg = degrees[type];
-      rand_sep = seps[type];
-      break;
-    default:
-      /* State info munged.  */
-      errno = EINVAL;
-      return NULL;
-    }
-
-  state = &new_state[1];
-  if (rand_type != TYPE_0)
-    {
-      rptr = &state[rear];
-      fptr = &state[(rear + rand_sep) % rand_deg];
-    }
-  /* Set end_ptr too.  */
-  end_ptr = &state[rand_deg];
-
-  return ostate;
-}
-
-/* If we are using the trivial TYPE_0 R.N.G., just do the old linear
-   congruential bit.  Otherwise, we do our fancy trinomial stuff, which is the
-   same in all ther other cases due to all the global variables that have been
-   set up.  The basic operation is to add the number at the rear pointer into
-   the one at the front pointer.  Then both pointers are advanced to the next
-   location cyclically in the table.  The value returned is the sum generated,
-   reduced to 31 bits by throwing away the "least random" low bit.
-   Note: The code takes advantage of the fact that both the front and
-   rear pointers can't wrap on the same call by not testing the rear
-   pointer if the front one has wrapped.  Returns a 31-bit random number.  */
-
-long int
-random (void)
-{
-  if (rand_type == TYPE_0)
-    {
-      state[0] = ((state[0] * 1103515245) + 12345) & LONG_MAX;
-      return state[0];
-    }
-  else
-    {
-      long int i;
-      *fptr += *rptr;
-      /* Chucking least random bit.  */
-      i = (*fptr >> 1) & LONG_MAX;
-      ++fptr;
-      if (fptr >= end_ptr)
-	{
-	  fptr = state;
-	  ++rptr;
-	}
-      else
-	{
-	  ++rptr;
-	  if (rptr >= end_ptr)
-	    rptr = state;
-	}
-      return i;
-    }
-}
diff --git a/libiberty/regex.c b/libiberty/regex.c
deleted file mode 100644
index 420c7f4a4..000000000
--- a/libiberty/regex.c
+++ /dev/null
@@ -1,8205 +0,0 @@
-/* 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, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
-   2002, 2005, 2010 Free Software Foundation, Inc.
-   This file is part of the GNU C Library.
-
-   The GNU C Library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 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
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, write to the Free
-   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301 USA.  */
-
-/* This file has been modified for usage in libiberty.  It includes "xregex.h"
-   instead of <regex.h>.  The "xregex.h" header file renames all external
-   routines with an "x" prefix so they do not collide with the native regex
-   routines or with other components regex routines. */
-/* AIX requires this to be the first thing in the file. */
-#if defined _AIX && !defined __GNUC__ && !defined REGEX_MALLOC
-  #pragma alloca
-#endif
-
-#undef	_GNU_SOURCE
-#define _GNU_SOURCE
-
-#ifndef INSIDE_RECURSION
-# ifdef HAVE_CONFIG_H
-#  include <config.h>
-# endif
-#endif
-
-#include <ansidecl.h>
-
-#ifndef INSIDE_RECURSION
-
-# 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
-
-/* We are also using some library internals.  */
-#  include <locale/localeinfo.h>
-#  include <locale/elem-hash.h>
-#  include <langinfo.h>
-#  include <locale/coll-lookup.h>
-# endif
-
-/* This is for other GNU distributions with internationalized messages.  */
-# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
-#  include <libintl.h>
-#  ifdef _LIBC
-#   undef gettext
-#   define gettext(msgid) __dcgettext ("libc", msgid, LC_MESSAGES)
-#  endif
-# 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
-
-# endif /* not emacs */
-
-# if defined _LIBC || HAVE_LIMITS_H
-#  include <limits.h>
-# endif
-
-# ifndef MB_LEN_MAX
-#  define MB_LEN_MAX 1
-# endif
-
-/* Get the interface, including the syntax bits.  */
-# include "xregex.h"  /* change for libiberty */
-
-/* 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))
-
-# ifdef _tolower
-#  define TOLOWER(c) _tolower(c)
-# else
-#  define TOLOWER(c) tolower(c)
-# endif
-
-# 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
-
-# ifndef emacs
-/* 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 (void);
-
-static void
-init_syntax_once (void)
-{
-   register int c;
-   static int done = 0;
-
-   if (done)
-     return;
-   bzero (re_syntax_table, sizeof re_syntax_table);
-
-   for (c = 0; c < CHAR_SET_SIZE; ++c)
-     if (ISALNUM (c))
-	re_syntax_table[c] = Sword;
-
-   re_syntax_table['_'] = Sword;
-
-   done = 1;
-}
-
-#  endif /* not SYNTAX_TABLE */
-
-#  define SYNTAX(c) re_syntax_table[(unsigned char) (c)]
-
-# endif /* emacs */
-
-/* Integer type for pointers.  */
-# if !defined _LIBC && !defined HAVE_UINTPTR_T
-typedef unsigned long int uintptr_t;
-# 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 reg_errcode_t byte_regex_compile (const char *pattern, size_t size,
-                                         reg_syntax_t syntax,
-                                         struct re_pattern_buffer *bufp);
-
-static int byte_re_match_2_internal (struct re_pattern_buffer *bufp,
-                                     const char *string1, int size1,
-                                     const char *string2, int size2,
-                                     int pos,
-                                     struct re_registers *regs,
-                                     int stop);
-static int byte_re_search_2 (struct re_pattern_buffer *bufp,
-                             const char *string1, int size1,
-                             const char *string2, int size2,
-                             int startpos, int range,
-                             struct re_registers *regs, int stop);
-static int byte_re_compile_fastmap (struct re_pattern_buffer *bufp);
-
-#ifdef MBS_SUPPORT
-static reg_errcode_t wcs_regex_compile (const char *pattern, size_t size,
-                                        reg_syntax_t syntax,
-                                        struct re_pattern_buffer *bufp);
-
-
-static int wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
-                                    const char *cstring1, int csize1,
-                                    const char *cstring2, int csize2,
-                                    int pos,
-                                    struct re_registers *regs,
-                                    int stop,
-                                    wchar_t *string1, int size1,
-                                    wchar_t *string2, int size2,
-                                    int *mbs_offset1, int *mbs_offset2);
-static int wcs_re_search_2 (struct re_pattern_buffer *bufp,
-                            const char *string1, int size1,
-                            const char *string2, int size2,
-                            int startpos, int range,
-                            struct re_registers *regs, int stop);
-static int wcs_re_compile_fastmap (struct re_pattern_buffer *bufp);
-#endif
-
-/* 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,
-
-# ifdef MBS_SUPPORT
-	/* Same as exactn, but contains binary data.  */
-  exactn_bin,
-# endif
-
-        /* 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.  */
-        /* ifdef MBS_SUPPORT, following element is length of character
-	   classes, length of collating symbols, length of equivalence
-	   classes, length of character ranges, and length of characters.
-	   Next, character class element, collating symbols elements,
-	   equivalence class elements, range elements, and character
-	   elements follow.
-	   See regex_compile function.  */
-  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.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  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.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  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.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  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.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  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.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  succeed_n,
-
-        /* Followed by two-byte relative address, and two-byte number n.
-           Jump to the address N times, then fail.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  jump_n,
-
-        /* Set the following two-byte relative address to the
-           subsequent two-byte number.  The address *includes* the two
-           bytes of number.  */
-        /* ifdef MBS_SUPPORT, the size of address is 1.  */
-  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;
-#endif /* not INSIDE_RECURSION */
-
-
-#ifdef BYTE
-# define CHAR_T char
-# define UCHAR_T unsigned char
-# define COMPILED_BUFFER_VAR bufp->buffer
-# define OFFSET_ADDRESS_SIZE 2
-# define PREFIX(name) byte_##name
-# define ARG_PREFIX(name) name
-# define PUT_CHAR(c) putchar (c)
-#else
-# ifdef WCHAR
-#  define CHAR_T wchar_t
-#  define UCHAR_T wchar_t
-#  define COMPILED_BUFFER_VAR wc_buffer
-#  define OFFSET_ADDRESS_SIZE 1 /* the size which STORE_NUMBER macro use */
-#  define CHAR_CLASS_SIZE ((__alignof__(wctype_t)+sizeof(wctype_t))/sizeof(CHAR_T)+1)
-#  define PREFIX(name) wcs_##name
-#  define ARG_PREFIX(name) c##name
-/* Should we use wide stream??  */
-#  define PUT_CHAR(c) printf ("%C", c);
-#  define TRUE 1
-#  define FALSE 0
-# else
-#  ifdef MBS_SUPPORT
-#   define WCHAR
-#   define INSIDE_RECURSION
-#   include "regex.c"
-#   undef INSIDE_RECURSION
-#  endif
-#  define BYTE
-#  define INSIDE_RECURSION
-#  include "regex.c"
-#  undef INSIDE_RECURSION
-# endif
-#endif
-
-#ifdef INSIDE_RECURSION
-/* Common operations on the compiled pattern.  */
-
-/* Store NUMBER in two contiguous bytes starting at DESTINATION.  */
-/* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
-
-# ifdef WCHAR
-#  define STORE_NUMBER(destination, number)				\
-  do {									\
-    *(destination) = (UCHAR_T)(number);				\
-  } while (0)
-# else /* BYTE */
-#  define STORE_NUMBER(destination, number)				\
-  do {									\
-    (destination)[0] = (number) & 0377;					\
-    (destination)[1] = (number) >> 8;					\
-  } while (0)
-# endif /* WCHAR */
-
-/* Same as STORE_NUMBER, except increment DESTINATION to
-   the byte after where the number is stored.  Therefore, DESTINATION
-   must be an lvalue.  */
-/* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
-
-# define STORE_NUMBER_AND_INCR(destination, number)			\
-  do {									\
-    STORE_NUMBER (destination, number);					\
-    (destination) += OFFSET_ADDRESS_SIZE;				\
-  } while (0)
-
-/* Put into DESTINATION a number stored in two contiguous bytes starting
-   at SOURCE.  */
-/* ifdef MBS_SUPPORT, we store NUMBER in 1 element.  */
-
-# ifdef WCHAR
-#  define EXTRACT_NUMBER(destination, source)				\
-  do {									\
-    (destination) = *(source);						\
-  } while (0)
-# else /* BYTE */
-#  define EXTRACT_NUMBER(destination, source)				\
-  do {									\
-    (destination) = *(source) & 0377;					\
-    (destination) += SIGN_EXTEND_CHAR (*((source) + 1)) << 8;		\
-  } while (0)
-# endif
-
-# ifdef DEBUG
-static void PREFIX(extract_number) (int *dest, UCHAR_T *source);
-static void
-PREFIX(extract_number) (int *dest, UCHAR_T *source)
-{
-#  ifdef WCHAR
-  *dest = *source;
-#  else /* BYTE */
-  int temp = SIGN_EXTEND_CHAR (*(source + 1));
-  *dest = *source & 0377;
-  *dest += temp << 8;
-#  endif
-}
-
-#  ifndef EXTRACT_MACROS /* To debug the macros.  */
-#   undef EXTRACT_NUMBER
-#   define EXTRACT_NUMBER(dest, src) PREFIX(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) += OFFSET_ADDRESS_SIZE; 					\
-  } while (0)
-
-# ifdef DEBUG
-static void PREFIX(extract_number_and_incr) (int *destination,
-                                             UCHAR_T **source);
-static void
-PREFIX(extract_number_and_incr) (int *destination, UCHAR_T **source)
-{
-  PREFIX(extract_number) (destination, *source);
-  *source += OFFSET_ADDRESS_SIZE;
-}
-
-#  ifndef EXTRACT_MACROS
-#   undef EXTRACT_NUMBER_AND_INCR
-#   define EXTRACT_NUMBER_AND_INCR(dest, src) \
-  PREFIX(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
-
-#  ifndef DEFINED_ONCE
-
-/* 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;
-
-#   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)
-#  endif /* not DEFINED_ONCE */
-
-#  define DEBUG_PRINT_COMPILED_PATTERN(p, s, e) 			\
-  if (debug) PREFIX(print_partial_compiled_pattern) (s, e)
-#  define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)		\
-  if (debug) PREFIX(print_double_string) (w, s1, sz1, s2, sz2)
-
-
-/* Print the fastmap in human-readable form.  */
-
-#  ifndef DEFINED_ONCE
-void
-print_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');
-}
-#  endif /* not DEFINED_ONCE */
-
-
-/* Print a compiled pattern string in human-readable form, starting at
-   the START pointer into it and ending just before the pointer END.  */
-
-void
-PREFIX(print_partial_compiled_pattern) (UCHAR_T *start, UCHAR_T *end)
-{
-  int mcnt, mcnt2;
-  UCHAR_T *p1;
-  UCHAR_T *p = start;
-  UCHAR_T *pend = end;
-
-  if (start == NULL)
-    {
-      printf ("(null)\n");
-      return;
-    }
-
-  /* Loop over pattern commands.  */
-  while (p < pend)
-    {
-#  ifdef _LIBC
-      printf ("%td:\t", p - start);
-#  else
-      printf ("%ld:\t", (long int) (p - start));
-#  endif
-
-      switch ((re_opcode_t) *p++)
-	{
-        case no_op:
-          printf ("/no_op");
-          break;
-
-	case exactn:
-	  mcnt = *p++;
-          printf ("/exactn/%d", mcnt);
-          do
-	    {
-              putchar ('/');
-	      PUT_CHAR (*p++);
-            }
-          while (--mcnt);
-          break;
-
-#  ifdef MBS_SUPPORT
-	case exactn_bin:
-	  mcnt = *p++;
-	  printf ("/exactn_bin/%d", mcnt);
-          do
-	    {
-	      printf("/%lx", (long int) *p++);
-            }
-          while (--mcnt);
-          break;
-#  endif /* MBS_SUPPORT */
-
-	case start_memory:
-          mcnt = *p++;
-          printf ("/start_memory/%d/%ld", mcnt, (long int) *p++);
-          break;
-
-	case stop_memory:
-          mcnt = *p++;
-	  printf ("/stop_memory/%d/%ld", mcnt, (long int) *p++);
-          break;
-
-	case duplicate:
-	  printf ("/duplicate/%ld", (long int) *p++);
-	  break;
-
-	case anychar:
-	  printf ("/anychar");
-	  break;
-
-	case charset:
-        case charset_not:
-          {
-#  ifdef WCHAR
-	    int i, length;
-	    wchar_t *workp = p;
-	    printf ("/charset [%s",
-	            (re_opcode_t) *(workp - 1) == charset_not ? "^" : "");
-	    p += 5;
-	    length = *workp++; /* the length of char_classes */
-	    for (i=0 ; i<length ; i++)
-	      printf("[:%lx:]", (long int) *p++);
-	    length = *workp++; /* the length of collating_symbol */
-	    for (i=0 ; i<length ;)
-	      {
-		printf("[.");
-		while(*p != 0)
-		  PUT_CHAR((i++,*p++));
-		i++,p++;
-		printf(".]");
-	      }
-	    length = *workp++; /* the length of equivalence_class */
-	    for (i=0 ; i<length ;)
-	      {
-		printf("[=");
-		while(*p != 0)
-		  PUT_CHAR((i++,*p++));
-		i++,p++;
-		printf("=]");
-	      }
-	    length = *workp++; /* the length of char_range */
-	    for (i=0 ; i<length ; i++)
-	      {
-		wchar_t range_start = *p++;
-		wchar_t range_end = *p++;
-		printf("%C-%C", range_start, range_end);
-	      }
-	    length = *workp++; /* the length of char */
-	    for (i=0 ; i<length ; i++)
-	      printf("%C", *p++);
-	    putchar (']');
-#  else
-            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;
-#  endif /* WCHAR */
-	  }
-	  break;
-
-	case begline:
-	  printf ("/begline");
-          break;
-
-	case endline:
-          printf ("/endline");
-          break;
-
-	case on_failure_jump:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/on_failure_jump to %td", p + mcnt - start);
-#  else
-  	  printf ("/on_failure_jump to %ld", (long int) (p + mcnt - start));
-#  endif
-          break;
-
-	case on_failure_keep_string_jump:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/on_failure_keep_string_jump to %td", p + mcnt - start);
-#  else
-  	  printf ("/on_failure_keep_string_jump to %ld",
-		  (long int) (p + mcnt - start));
-#  endif
-          break;
-
-	case dummy_failure_jump:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/dummy_failure_jump to %td", p + mcnt - start);
-#  else
-  	  printf ("/dummy_failure_jump to %ld", (long int) (p + mcnt - start));
-#  endif
-          break;
-
-	case push_dummy_failure:
-          printf ("/push_dummy_failure");
-          break;
-
-        case maybe_pop_jump:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/maybe_pop_jump to %td", p + mcnt - start);
-#  else
-  	  printf ("/maybe_pop_jump to %ld", (long int) (p + mcnt - start));
-#  endif
-	  break;
-
-        case pop_failure_jump:
-	  PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/pop_failure_jump to %td", p + mcnt - start);
-#  else
-  	  printf ("/pop_failure_jump to %ld", (long int) (p + mcnt - start));
-#  endif
-	  break;
-
-        case jump_past_alt:
-	  PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/jump_past_alt to %td", p + mcnt - start);
-#  else
-  	  printf ("/jump_past_alt to %ld", (long int) (p + mcnt - start));
-#  endif
-	  break;
-
-        case jump:
-	  PREFIX(extract_number_and_incr) (&mcnt, &p);
-#  ifdef _LIBC
-  	  printf ("/jump to %td", p + mcnt - start);
-#  else
-  	  printf ("/jump to %ld", (long int) (p + mcnt - start));
-#  endif
-	  break;
-
-        case succeed_n:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-	  p1 = p + mcnt;
-          PREFIX(extract_number_and_incr) (&mcnt2, &p);
-#  ifdef _LIBC
-	  printf ("/succeed_n to %td, %d times", p1 - start, mcnt2);
-#  else
-	  printf ("/succeed_n to %ld, %d times",
-		  (long int) (p1 - start), mcnt2);
-#  endif
-          break;
-
-        case jump_n:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-	  p1 = p + mcnt;
-          PREFIX(extract_number_and_incr) (&mcnt2, &p);
-	  printf ("/jump_n to %d, %d times", p1 - start, mcnt2);
-          break;
-
-        case set_number_at:
-          PREFIX(extract_number_and_incr) (&mcnt, &p);
-	  p1 = p + mcnt;
-          PREFIX(extract_number_and_incr) (&mcnt2, &p);
-#  ifdef _LIBC
-	  printf ("/set_number_at location %td to %d", p1 - start, mcnt2);
-#  else
-	  printf ("/set_number_at location %ld to %d",
-		  (long int) (p1 - start), mcnt2);
-#  endif
-          break;
-
-        case wordbound:
-	  printf ("/wordbound");
-	  break;
-
-	case notwordbound:
-	  printf ("/notwordbound");
-          break;
-
-	case wordbeg:
-	  printf ("/wordbeg");
-	  break;
-
-	case wordend:
-	  printf ("/wordend");
-	  break;
-
-#  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 ("?%ld", (long int) *(p-1));
-	}
-
-      putchar ('\n');
-    }
-
-#  ifdef _LIBC
-  printf ("%td:\tend of pattern.\n", p - start);
-#  else
-  printf ("%ld:\tend of pattern.\n", (long int) (p - start));
-#  endif
-}
-
-
-void
-PREFIX(print_compiled_pattern) (struct re_pattern_buffer *bufp)
-{
-  UCHAR_T *buffer = (UCHAR_T*) bufp->buffer;
-
-  PREFIX(print_partial_compiled_pattern) (buffer, buffer
-				  + bufp->used / sizeof(UCHAR_T));
-  printf ("%ld bytes used/%ld bytes allocated.\n",
-	  bufp->used, bufp->allocated);
-
-  if (bufp->fastmap_accurate && bufp->fastmap)
-    {
-      printf ("fastmap: ");
-      print_fastmap (bufp->fastmap);
-    }
-
-#  ifdef _LIBC
-  printf ("re_nsub: %Zd\t", bufp->re_nsub);
-#  else
-  printf ("re_nsub: %ld\t", (long int) bufp->re_nsub);
-#  endif
-  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
-PREFIX(print_double_string) (const CHAR_T *where, const CHAR_T *string1,
-                             int size1, const CHAR_T *string2, int size2)
-{
-  int this_char;
-
-  if (where == NULL)
-    printf ("(null)");
-  else
-    {
-      int cnt;
-
-      if (FIRST_STRING_P (where))
-        {
-          for (this_char = where - string1; this_char < size1; this_char++)
-	    PUT_CHAR (string1[this_char]);
-
-          where = string2;
-        }
-
-      cnt = 0;
-      for (this_char = where - string2; this_char < size2; this_char++)
-	{
-	  PUT_CHAR (string2[this_char]);
-	  if (++cnt > 100)
-	    {
-	      fputs ("...", stdout);
-	      break;
-	    }
-	}
-    }
-}
-
-#  ifndef DEFINED_ONCE
-void
-printchar (int c)
-{
-  putc (c, stderr);
-}
-#  endif
-
-# else /* not DEBUG */
-
-#  ifndef DEFINED_ONCE
-#   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)
-#  endif /* not DEFINED_ONCE */
-#  define DEBUG_PRINT_COMPILED_PATTERN(p, s, e)
-#  define DEBUG_PRINT_DOUBLE_STRING(w, s1, sz1, s2, sz2)
-
-# endif /* not DEBUG */
-
-
-
-# ifdef WCHAR
-/* This  convert a multibyte string to a wide character string.
-   And write their correspondances to offset_buffer(see below)
-   and write whether each wchar_t is binary data to is_binary.
-   This assume invalid multibyte sequences as binary data.
-   We assume offset_buffer and is_binary is already allocated
-   enough space.  */
-
-static size_t convert_mbs_to_wcs (CHAR_T *dest, const unsigned char* src,
-				  size_t len, int *offset_buffer,
-				  char *is_binary);
-static size_t
-convert_mbs_to_wcs (CHAR_T *dest, const unsigned char*src, size_t len,
-                    int *offset_buffer, char *is_binary)
-     /* It hold correspondances between src(char string) and
-	dest(wchar_t string) for optimization.
-	e.g. src  = "xxxyzz"
-             dest = {'X', 'Y', 'Z'}
-	      (each "xxx", "y" and "zz" represent one multibyte character
-	       corresponding to 'X', 'Y' and 'Z'.)
-	  offset_buffer = {0, 0+3("xxx"), 0+3+1("y"), 0+3+1+2("zz")}
-	  	        = {0, 3, 4, 6}
-     */
-{
-  wchar_t *pdest = dest;
-  const unsigned char *psrc = src;
-  size_t wc_count = 0;
-
-  mbstate_t mbs;
-  int i, consumed;
-  size_t mb_remain = len;
-  size_t mb_count = 0;
-
-  /* Initialize the conversion state.  */
-  memset (&mbs, 0, sizeof (mbstate_t));
-
-  offset_buffer[0] = 0;
-  for( ; mb_remain > 0 ; ++wc_count, ++pdest, mb_remain -= consumed,
-	 psrc += consumed)
-    {
-#ifdef _LIBC
-      consumed = __mbrtowc (pdest, psrc, mb_remain, &mbs);
-#else
-      consumed = mbrtowc (pdest, psrc, mb_remain, &mbs);
-#endif
-
-      if (consumed <= 0)
-	/* failed to convert. maybe src contains binary data.
-	   So we consume 1 byte manualy.  */
-	{
-	  *pdest = *psrc;
-	  consumed = 1;
-	  is_binary[wc_count] = TRUE;
-	}
-      else
-	is_binary[wc_count] = FALSE;
-      /* In sjis encoding, we use yen sign as escape character in
-	 place of reverse solidus. So we convert 0x5c(yen sign in
-	 sjis) to not 0xa5(yen sign in UCS2) but 0x5c(reverse
-	 solidus in UCS2).  */
-      if (consumed == 1 && (int) *psrc == 0x5c && (int) *pdest == 0xa5)
-	*pdest = (wchar_t) *psrc;
-
-      offset_buffer[wc_count + 1] = mb_count += consumed;
-    }
-
-  /* Fill remain of the buffer with sentinel.  */
-  for (i = wc_count + 1 ; i <= len ; i++)
-    offset_buffer[i] = mb_count + 1;
-
-  return wc_count;
-}
-
-# endif /* WCHAR */
-
-#else /* not INSIDE_RECURSION */
-
-/* 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 (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 */
-  };
-
-#endif /* INSIDE_RECURSION */
-
-#ifndef DEFINED_ONCE
-/* 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
-#endif /* not DEFINED_ONCE */
-
-#ifdef INSIDE_RECURSION
-/* 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
-
-#  ifndef DEFINED_ONCE
-#   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
-#  endif
-
-union PREFIX(fail_stack_elt)
-{
-  UCHAR_T *pointer;
-  long int integer;
-};
-
-typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
-
-typedef struct
-{
-  PREFIX(fail_stack_elt_t) *stack;
-  unsigned long int size;
-  unsigned long int avail;		/* Offset of next open position.  */
-} PREFIX(fail_stack_type);
-
-# else /* not INT_IS_16BIT */
-
-#  ifndef DEFINED_ONCE
-#   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 = 4000;
-#   else
-int re_max_failures = 2000;
-#   endif
-#  endif
-
-union PREFIX(fail_stack_elt)
-{
-  UCHAR_T *pointer;
-  int integer;
-};
-
-typedef union PREFIX(fail_stack_elt) PREFIX(fail_stack_elt_t);
-
-typedef struct
-{
-  PREFIX(fail_stack_elt_t) *stack;
-  unsigned size;
-  unsigned avail;			/* Offset of next open position.  */
-} PREFIX(fail_stack_type);
-
-# endif /* INT_IS_16BIT */
-
-# ifndef DEFINED_ONCE
-#  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)
-# endif
-
-
-/* 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 = (PREFIX(fail_stack_elt_t) *)		\
-      REGEX_ALLOCATE_STACK (INIT_FAILURE_ALLOC * sizeof (PREFIX(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 = (PREFIX(fail_stack_elt_t) *)			\
-        REGEX_REALLOCATE_STACK ((fail_stack).stack, 			\
-          (fail_stack).size * sizeof (PREFIX(fail_stack_elt_t)),	\
-          ((fail_stack).size << 1) * sizeof (PREFIX(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 = (UCHAR_T *) (item)
-
-/* This pushes an integer-valued item onto the failure stack.
-   Assumes the variable `fail_stack'.  Probably should only
-   be called from within `PUSH_FAILURE_POINT'.  */
-# define PUSH_FAILURE_INT(item)					\
-  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)
-
-# ifndef DEFINED_ONCE
-/* 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)
-# endif /* not DEFINED_ONCE */
-
-
-/* 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 UCHAR_T *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_T *) string_temp;					\
-									\
-  DEBUG_PRINT2 ("  Popping string %p: `", str);				\
-  DEBUG_PRINT_DOUBLE_STRING (str, string1, size1, string2, size2);	\
-  DEBUG_PRINT1 ("'\n");							\
-									\
-  pat = (UCHAR_T *) 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_T *) POP_FAILURE_POINTER ();	\
-	DEBUG_PRINT2 ("      end: %p\n", regend[this_reg]);		\
-									\
-	regstart[this_reg] = (const CHAR_T *) 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
-{
-  PREFIX(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;
-} PREFIX(register_info_type);
-
-# ifndef DEFINED_ONCE
-#  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)
-# endif /* not DEFINED_ONCE */
-
-/* Registers are set to a sentinel when they haven't yet matched.  */
-static CHAR_T PREFIX(reg_unset_dummy);
-# define REG_UNSET_VALUE (&PREFIX(reg_unset_dummy))
-# define REG_UNSET(e) ((e) == REG_UNSET_VALUE)
-
-/* Subroutine declarations and macros for regex_compile.  */
-static void PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg);
-static void PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc,
-                               int arg1, int arg2);
-static void PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc,
-                                int arg, UCHAR_T *end);
-static void PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc,
-                                int arg1, int arg2, UCHAR_T *end);
-static boolean PREFIX(at_begline_loc_p) (const CHAR_T *pattern,
-                                         const CHAR_T *p,
-                                         reg_syntax_t syntax);
-static boolean PREFIX(at_endline_loc_p) (const CHAR_T *p,
-                                         const CHAR_T *pend,
-                                         reg_syntax_t syntax);
-# ifdef WCHAR
-static reg_errcode_t wcs_compile_range (CHAR_T range_start,
-                                        const CHAR_T **p_ptr,
-                                        const CHAR_T *pend,
-                                        char *translate,
-                                        reg_syntax_t syntax,
-                                        UCHAR_T *b,
-                                        CHAR_T *char_set);
-static void insert_space (int num, CHAR_T *loc, CHAR_T *end);
-# else /* BYTE */
-static reg_errcode_t byte_compile_range (unsigned int range_start,
-                                         const char **p_ptr,
-                                         const char *pend,
-                                         char *translate,
-                                         reg_syntax_t syntax,
-                                         unsigned char *b);
-# endif /* WCHAR */
-
-/* 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').  */
-/* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
-   because it is impossible to allocate 4GB array for some encodings
-   which have 4 byte character_set like UCS4.  */
-# ifndef PATFETCH
-#  ifdef WCHAR
-#   define PATFETCH(c)							\
-  do {if (p == pend) return REG_EEND;					\
-    c = (UCHAR_T) *p++;							\
-    if (translate && (c <= 0xff)) c = (UCHAR_T) translate[c];		\
-  } while (0)
-#  else /* BYTE */
-#   define PATFETCH(c)							\
-  do {if (p == pend) return REG_EEND;					\
-    c = (unsigned char) *p++;						\
-    if (translate) c = (unsigned char) translate[c];			\
-  } while (0)
-#  endif /* WCHAR */
-# endif
-
-/* Fetch the next character in the uncompiled pattern, with no
-   translation.  */
-# define PATFETCH_RAW(c)						\
-  do {if (p == pend) return REG_EEND;					\
-    c = (UCHAR_T) *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.  */
-/* ifdef MBS_SUPPORT, we translate only if character <= 0xff,
-   because it is impossible to allocate 4GB array for some encodings
-   which have 4 byte character_set like UCS4.  */
-
-# ifndef TRANSLATE
-#  ifdef WCHAR
-#   define TRANSLATE(d) \
-  ((translate && ((UCHAR_T) (d)) <= 0xff) \
-   ? (char) translate[(unsigned char) (d)] : (d))
-# else /* BYTE */
-#   define TRANSLATE(d) \
-  (translate ? (char) translate[(unsigned char) (d)] : (char) (d))
-#  endif /* WCHAR */
-# 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 * sizeof(UCHAR_T))
-
-/* Make sure we have at least N more bytes of space in buffer.  */
-# ifdef WCHAR
-#  define GET_BUFFER_SPACE(n)						\
-    while (((unsigned long)b - (unsigned long)COMPILED_BUFFER_VAR	\
-            + (n)*sizeof(CHAR_T)) > bufp->allocated)			\
-      EXTEND_BUFFER ()
-# else /* BYTE */
-#  define GET_BUFFER_SPACE(n)						\
-    while ((unsigned long) (b - bufp->buffer + (n)) > bufp->allocated)	\
-      EXTEND_BUFFER ()
-# endif /* WCHAR */
-
-/* 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++ = (UCHAR_T) (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++ = (UCHAR_T) (c1);						\
-    *b++ = (UCHAR_T) (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++ = (UCHAR_T) (c1);						\
-    *b++ = (UCHAR_T) (c2);						\
-    *b++ = (UCHAR_T) (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) \
- PREFIX(store_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)))
-
-/* Likewise, for a two-argument jump.  */
-# define STORE_JUMP2(op, loc, to, arg) \
-  PREFIX(store_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), arg)
-
-/* Like `STORE_JUMP', but for inserting.  Assume `b' is the buffer end.  */
-# define INSERT_JUMP(op, loc, to) \
-  PREFIX(insert_op1) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)), b)
-
-/* Like `STORE_JUMP2', but for inserting.  Assume `b' is the buffer end.  */
-# define INSERT_JUMP2(op, loc, to, arg) \
-  PREFIX(insert_op2) (op, loc, (int) ((to) - (loc) - (1 + OFFSET_ADDRESS_SIZE)),\
-	      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!!  */
-# ifndef DEFINED_ONCE
-#  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.  */
-#  if __BOUNDED_POINTERS__
-#   define SET_HIGH_BOUND(P) (__ptrhigh (P) = __ptrlow (P) + bufp->allocated)
-#   define MOVE_BUFFER_POINTER(P) \
-  (__ptrlow (P) += incr, SET_HIGH_BOUND (P), __ptrvalue (P) += incr)
-#   define ELSE_EXTEND_BUFFER_HIGH_BOUND	\
-  else						\
-    {						\
-      SET_HIGH_BOUND (b);			\
-      SET_HIGH_BOUND (begalt);			\
-      if (fixup_alt_jump)			\
-	SET_HIGH_BOUND (fixup_alt_jump);	\
-      if (laststart)				\
-	SET_HIGH_BOUND (laststart);		\
-      if (pending_exact)			\
-	SET_HIGH_BOUND (pending_exact);		\
-    }
-#  else
-#   define MOVE_BUFFER_POINTER(P) (P) += incr
-#   define ELSE_EXTEND_BUFFER_HIGH_BOUND
-#  endif
-# endif /* not DEFINED_ONCE */
-
-# ifdef WCHAR
-#  define EXTEND_BUFFER()						\
-  do {									\
-    UCHAR_T *old_buffer = COMPILED_BUFFER_VAR;				\
-    int wchar_count;							\
-    if (bufp->allocated + sizeof(UCHAR_T) > MAX_BUF_SIZE)		\
-      return REG_ESIZE;							\
-    bufp->allocated <<= 1;						\
-    if (bufp->allocated > MAX_BUF_SIZE)					\
-      bufp->allocated = MAX_BUF_SIZE;					\
-    /* How many characters the new buffer can have?  */			\
-    wchar_count = bufp->allocated / sizeof(UCHAR_T);			\
-    if (wchar_count == 0) wchar_count = 1;				\
-    /* Truncate the buffer to CHAR_T align.  */			\
-    bufp->allocated = wchar_count * sizeof(UCHAR_T);			\
-    RETALLOC (COMPILED_BUFFER_VAR, wchar_count, UCHAR_T);		\
-    bufp->buffer = (char*)COMPILED_BUFFER_VAR;				\
-    if (COMPILED_BUFFER_VAR == NULL)					\
-      return REG_ESPACE;						\
-    /* If the buffer moved, move all the pointers into it.  */		\
-    if (old_buffer != COMPILED_BUFFER_VAR)				\
-      {									\
-	int incr = COMPILED_BUFFER_VAR - old_buffer;			\
-	MOVE_BUFFER_POINTER (b);					\
-	MOVE_BUFFER_POINTER (begalt);					\
-	if (fixup_alt_jump)						\
-	  MOVE_BUFFER_POINTER (fixup_alt_jump);				\
-	if (laststart)							\
-	  MOVE_BUFFER_POINTER (laststart);				\
-	if (pending_exact)						\
-	  MOVE_BUFFER_POINTER (pending_exact);				\
-      }									\
-    ELSE_EXTEND_BUFFER_HIGH_BOUND					\
-  } while (0)
-# else /* BYTE */
-#  define EXTEND_BUFFER()						\
-  do {									\
-    UCHAR_T *old_buffer = COMPILED_BUFFER_VAR;				\
-    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 = (UCHAR_T *) REALLOC (COMPILED_BUFFER_VAR,		\
-						bufp->allocated);	\
-    if (COMPILED_BUFFER_VAR == NULL)					\
-      return REG_ESPACE;						\
-    /* If the buffer moved, move all the pointers into it.  */		\
-    if (old_buffer != COMPILED_BUFFER_VAR)				\
-      {									\
-	int incr = COMPILED_BUFFER_VAR - old_buffer;			\
-	MOVE_BUFFER_POINTER (b);					\
-	MOVE_BUFFER_POINTER (begalt);					\
-	if (fixup_alt_jump)						\
-	  MOVE_BUFFER_POINTER (fixup_alt_jump);				\
-	if (laststart)							\
-	  MOVE_BUFFER_POINTER (laststart);				\
-	if (pending_exact)						\
-	  MOVE_BUFFER_POINTER (pending_exact);				\
-      }									\
-    ELSE_EXTEND_BUFFER_HIGH_BOUND					\
-  } while (0)
-# endif /* WCHAR */
-
-# ifndef DEFINED_ONCE
-/* 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])
-
-# endif /* not DEFINED_ONCE */
-
-/* Set the bit for character C in a list.  */
-# ifndef DEFINED_ONCE
-#  define SET_LIST_BIT(c)                               \
-  (b[((unsigned char) (c)) / BYTEWIDTH]               \
-   |= 1 << (((unsigned char) c) % BYTEWIDTH))
-# endif /* DEFINED_ONCE */
-
-/* Get the next unsigned number in the uncompiled pattern.  */
-# define GET_UNSIGNED_NUMBER(num) \
-  {									\
-    while (p != pend)							\
-      {									\
-	PATFETCH (c);							\
-	if (c < '0' || c > '9')						\
-	  break;							\
-	if (num <= RE_DUP_MAX)						\
-	  {								\
-	    if (num < 0)						\
-	      num = 0;							\
-	    num = num * 10 + c - '0';					\
-	  }								\
-      }									\
-  }
-
-# ifndef DEFINED_ONCE
-#  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
-# endif /* DEFINED_ONCE */
-
-# 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 PREFIX(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.  */
-#  ifdef DEFINED_ONCE
-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 const char **reg_dummy;
-#  endif /* DEFINED_ONCE */
-
-static PREFIX(register_info_type) *PREFIX(reg_info);
-static PREFIX(register_info_type) *PREFIX(reg_info_dummy);
-
-/* Make the register vectors big enough for NUM_REGS registers,
-   but don't make them smaller.  */
-
-static void
-PREFIX(regex_grow_registers) (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 (PREFIX(reg_info), num_regs, PREFIX(register_info_type));
-      RETALLOC_IF (reg_dummy,	 num_regs, const char *);
-      RETALLOC_IF (PREFIX(reg_info_dummy), num_regs, PREFIX(register_info_type));
-
-      regs_allocated_size = num_regs;
-    }
-}
-
-# endif /* not MATCH_MAY_ALLOCATE */
-
-# ifndef DEFINED_ONCE
-static boolean group_in_compile_stack (compile_stack_type compile_stack,
-                                       regnum_t regnum);
-# endif /* not DEFINED_ONCE */
-
-/* `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.  */
-# ifdef WCHAR
-#  define FREE_STACK_RETURN(value)		\
-  return (free(pattern), free(mbs_offset), free(is_binary), free (compile_stack.stack), value)
-# else
-#  define FREE_STACK_RETURN(value)		\
-  return (free (compile_stack.stack), value)
-# endif /* WCHAR */
-
-static reg_errcode_t
-PREFIX(regex_compile) (const char *ARG_PREFIX(pattern),
-                       size_t ARG_PREFIX(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 UCHAR_T c, c1;
-
-#ifdef WCHAR
-  /* A temporary space to keep wchar_t pattern and compiled pattern.  */
-  CHAR_T *pattern, *COMPILED_BUFFER_VAR;
-  size_t size;
-  /* offset buffer for optimization. See convert_mbs_to_wc.  */
-  int *mbs_offset = NULL;
-  /* It hold whether each wchar_t is binary data or not.  */
-  char *is_binary = NULL;
-  /* A flag whether exactn is handling binary data or not.  */
-  char is_exactn_bin = FALSE;
-#endif /* WCHAR */
-
-  /* A random temporary spot in PATTERN.  */
-  const CHAR_T *p1;
-
-  /* Points to the end of the buffer, where we should append.  */
-  register UCHAR_T *b;
-
-  /* Keeps track of unclosed groups.  */
-  compile_stack_type compile_stack;
-
-  /* Points to the current (ending) position in the pattern.  */
-#ifdef WCHAR
-  const CHAR_T *p;
-  const CHAR_T *pend;
-#else /* BYTE */
-  const CHAR_T *p = pattern;
-  const CHAR_T *pend = pattern + size;
-#endif /* WCHAR */
-
-  /* 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.  */
-  UCHAR_T *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.  */
-  UCHAR_T *laststart = 0;
-
-  /* Address of beginning of regexp, or inside of last group.  */
-  UCHAR_T *begalt;
-
-  /* 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.  */
-  UCHAR_T *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 WCHAR
-  /* Initialize the wchar_t PATTERN and offset_buffer.  */
-  p = pend = pattern = TALLOC(csize + 1, CHAR_T);
-  mbs_offset = TALLOC(csize + 1, int);
-  is_binary = TALLOC(csize + 1, char);
-  if (pattern == NULL || mbs_offset == NULL || is_binary == NULL)
-    {
-      free(pattern);
-      free(mbs_offset);
-      free(is_binary);
-      return REG_ESPACE;
-    }
-  pattern[csize] = L'\0';	/* sentinel */
-  size = convert_mbs_to_wcs(pattern, cpattern, csize, mbs_offset, is_binary);
-  pend = p + size;
-  if (size < 0)
-    {
-      free(pattern);
-      free(mbs_offset);
-      free(is_binary);
-      return REG_BADPAT;
-    }
-#endif
-
-#ifdef DEBUG
-  DEBUG_PRINT1 ("\nCompiling pattern: ");
-  if (debug)
-    {
-      unsigned debug_count;
-
-      for (debug_count = 0; debug_count < size; debug_count++)
-        PUT_CHAR (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)
-    {
-#ifdef WCHAR
-      free(pattern);
-      free(mbs_offset);
-      free(is_binary);
-#endif
-      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.  */
-#ifdef WCHAR
-	  /* Free bufp->buffer and allocate an array for wchar_t pattern
-	     buffer.  */
-          free(bufp->buffer);
-          COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE/sizeof(UCHAR_T),
-					UCHAR_T);
-#else
-          RETALLOC (COMPILED_BUFFER_VAR, INIT_BUF_SIZE, UCHAR_T);
-#endif /* WCHAR */
-        }
-      else
-        { /* Caller did not allocate a buffer.  Do it for them.  */
-          COMPILED_BUFFER_VAR = TALLOC (INIT_BUF_SIZE / sizeof(UCHAR_T),
-					UCHAR_T);
-        }
-
-      if (!COMPILED_BUFFER_VAR) FREE_STACK_RETURN (REG_ESPACE);
-#ifdef WCHAR
-      bufp->buffer = (char*)COMPILED_BUFFER_VAR;
-#endif /* WCHAR */
-      bufp->allocated = INIT_BUF_SIZE;
-    }
-#ifdef WCHAR
-  else
-    COMPILED_BUFFER_VAR = (UCHAR_T*) bufp->buffer;
-#endif
-
-  begalt = b = COMPILED_BUFFER_VAR;
-
-  /* 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.  */
-                || PREFIX(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.  */
-                || PREFIX(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 (1 + OFFSET_ADDRESS_SIZE);
-
-                /* 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 -
-			      (1 + OFFSET_ADDRESS_SIZE));
-
-                /* We've added more stuff to the buffer.  */
-                b += 1 + OFFSET_ADDRESS_SIZE;
-              }
-
-            /* On failure, jump from laststart to b + 3, which will be the
-               end of the buffer after this jump is inserted.  */
-	    /* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE' instead of
-	       'b + 3'.  */
-            GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
-            INSERT_JUMP (keep_string_p ? on_failure_keep_string_jump
-                                       : on_failure_jump,
-                         laststart, b + 1 + OFFSET_ADDRESS_SIZE);
-            pending_exact = 0;
-            b += 1 + OFFSET_ADDRESS_SIZE;
-
-            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 (1 + OFFSET_ADDRESS_SIZE);
-                INSERT_JUMP (dummy_failure_jump, laststart, laststart +
-			     2 + 2 * OFFSET_ADDRESS_SIZE);
-                b += 1 + OFFSET_ADDRESS_SIZE;
-              }
-            }
-	  break;
-
-
-	case '.':
-          laststart = b;
-          BUF_PUSH (anychar);
-          break;
-
-
-        case '[':
-          {
-            boolean had_char_class = false;
-#ifdef WCHAR
-	    CHAR_T range_start = 0xffffffff;
-#else
-	    unsigned int range_start = 0xffffffff;
-#endif
-            if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
-
-#ifdef WCHAR
-	    /* We assume a charset(_not) structure as a wchar_t array.
-	       charset[0] = (re_opcode_t) charset(_not)
-               charset[1] = l (= length of char_classes)
-               charset[2] = m (= length of collating_symbols)
-               charset[3] = n (= length of equivalence_classes)
-	       charset[4] = o (= length of char_ranges)
-	       charset[5] = p (= length of chars)
-
-               charset[6] = char_class (wctype_t)
-               charset[6+CHAR_CLASS_SIZE] = char_class (wctype_t)
-                         ...
-               charset[l+5]  = char_class (wctype_t)
-
-               charset[l+6]  = collating_symbol (wchar_t)
-                            ...
-               charset[l+m+5]  = collating_symbol (wchar_t)
-					ifdef _LIBC we use the index if
-					_NL_COLLATE_SYMB_EXTRAMB instead of
-					wchar_t string.
-
-               charset[l+m+6]  = equivalence_classes (wchar_t)
-                              ...
-               charset[l+m+n+5]  = equivalence_classes (wchar_t)
-					ifdef _LIBC we use the index in
-					_NL_COLLATE_WEIGHT instead of
-					wchar_t string.
-
-	       charset[l+m+n+6] = range_start
-	       charset[l+m+n+7] = range_end
-	                       ...
-	       charset[l+m+n+2o+4] = range_start
-	       charset[l+m+n+2o+5] = range_end
-					ifdef _LIBC we use the value looked up
-					in _NL_COLLATE_COLLSEQ instead of
-					wchar_t character.
-
-	       charset[l+m+n+2o+6] = char
-	                          ...
-	       charset[l+m+n+2o+p+5] = char
-
-	     */
-
-	    /* We need at least 6 spaces: the opcode, the length of
-               char_classes, the length of collating_symbols, the length of
-               equivalence_classes, the length of char_ranges, the length of
-               chars.  */
-	    GET_BUFFER_SPACE (6);
-
-	    /* Save b as laststart. And We use laststart as the pointer
-	       to the first element of the charset here.
-	       In other words, laststart[i] indicates charset[i].  */
-            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++;
-
-            /* Push the length of char_classes, the length of
-               collating_symbols, the length of equivalence_classes, the
-               length of char_ranges and the length of chars.  */
-            BUF_PUSH_3 (0, 0, 0);
-            BUF_PUSH_2 (0, 0);
-
-            /* Remember the first position in the bracket expression.  */
-            p1 = p;
-
-            /* charset_not matches newline according to a syntax bit.  */
-            if ((re_opcode_t) b[-6] == charset_not
-                && (syntax & RE_HAT_LISTS_NOT_NEWLINE))
-	      {
-		BUF_PUSH('\n');
-		laststart[5]++; /* Update the length of characters  */
-	      }
-
-            /* 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);
-		    BUF_PUSH(c1);
-		    laststart[5]++; /* Update the length of chars  */
-		    range_start = 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;
-		    /* Allocate the space for range_start and range_end.  */
-		    GET_BUFFER_SPACE (2);
-		    /* Update the pointer to indicate end of buffer.  */
-                    b += 2;
-                    ret = wcs_compile_range (range_start, &p, pend, translate,
-                                         syntax, b, laststart);
-                    if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
-                    range_start = 0xffffffff;
-                  }
-                else if (p[0] == '-' && p[1] != ']')
-                  { /* This handles ranges made up of characters only.  */
-                    reg_errcode_t ret;
-
-		    /* Move past the `-'.  */
-                    PATFETCH (c1);
-		    /* Allocate the space for range_start and range_end.  */
-		    GET_BUFFER_SPACE (2);
-		    /* Update the pointer to indicate end of buffer.  */
-                    b += 2;
-                    ret = wcs_compile_range (c, &p, pend, translate, syntax, b,
-                                         laststart);
-                    if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
-		    range_start = 0xffffffff;
-                  }
-
-                /* 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 store them as character).  */
-                    if (c == ':' && *p == ']')
-                      {
-			wctype_t wt;
-			uintptr_t alignedp;
-
-			/* Query the character class as wctype_t.  */
-			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);
-
-			/* Allocate the space for character class.  */
-                        GET_BUFFER_SPACE(CHAR_CLASS_SIZE);
-			/* Update the pointer to indicate end of buffer.  */
-                        b += CHAR_CLASS_SIZE;
-			/* Move data which follow character classes
-			    not to violate the data.  */
-                        insert_space(CHAR_CLASS_SIZE,
-				     laststart + 6 + laststart[1],
-				     b - 1);
-			alignedp = ((uintptr_t)(laststart + 6 + laststart[1])
-				    + __alignof__(wctype_t) - 1)
-			  	    & ~(uintptr_t)(__alignof__(wctype_t) - 1);
-			/* Store the character class.  */
-                        *((wctype_t*)alignedp) = wt;
-                        /* Update length of char_classes */
-                        laststart[1] += CHAR_CLASS_SIZE;
-
-                        had_char_class = true;
-                      }
-                    else
-                      {
-                        c1++;
-                        while (c1--)
-                          PATUNFETCH;
-                        BUF_PUSH ('[');
-                        BUF_PUSH (':');
-                        laststart[5] += 2; /* Update the length of characters  */
-			range_start = ':';
-                        had_char_class = false;
-                      }
-                  }
-                else if (syntax & RE_CHAR_CLASSES && c == '[' && (*p == '='
-							  || *p == '.'))
-		  {
-		    CHAR_T str[128];	/* Should be large enough.  */
-		    CHAR_T delim = *p; /* '=' or '.'  */
-# ifdef _LIBC
-		    uint32_t nrules =
-		      _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-# endif
-		    PATFETCH (c);
-		    c1 = 0;
-
-		    /* If pattern is `[[=' or '[[.'.  */
-		    if (p == pend) FREE_STACK_RETURN (REG_EBRACK);
-
-		    for (;;)
-		      {
-			PATFETCH (c);
-			if ((c == delim && *p == ']') || p == pend)
-			  break;
-			if (c1 < sizeof (str) - 1)
-			  str[c1++] = c;
-			else
-			  /* This is in any case an invalid class name.  */
-			  str[0] = '\0';
-                      }
-		    str[c1] = '\0';
-
-		    if (c == delim && *p == ']' && str[0] != '\0')
-		      {
-                        unsigned int i, offset;
-			/* If we have no collation data we use the default
-			   collation in which each character is in a class
-			   by itself.  It also means that ASCII is the
-			   character set and therefore we cannot have character
-			   with more than one byte in the multibyte
-			   representation.  */
-
-                        /* If not defined _LIBC, we push the name and
-			   `\0' for the sake of matching performance.  */
-			int datasize = c1 + 1;
-
-# ifdef _LIBC
-			int32_t idx = 0;
-			if (nrules == 0)
-# endif
-			  {
-			    if (c1 != 1)
-			      FREE_STACK_RETURN (REG_ECOLLATE);
-			  }
-# ifdef _LIBC
-			else
-			  {
-			    const int32_t *table;
-			    const int32_t *weights;
-			    const int32_t *extra;
-			    const int32_t *indirect;
-			    wint_t *cp;
-
-			    /* This #include defines a local function!  */
-#  include <locale/weightwc.h>
-
-			    if(delim == '=')
-			      {
-				/* We push the index for equivalence class.  */
-				cp = (wint_t*)str;
-
-				table = (const int32_t *)
-				  _NL_CURRENT (LC_COLLATE,
-					       _NL_COLLATE_TABLEWC);
-				weights = (const int32_t *)
-				  _NL_CURRENT (LC_COLLATE,
-					       _NL_COLLATE_WEIGHTWC);
-				extra = (const int32_t *)
-				  _NL_CURRENT (LC_COLLATE,
-					       _NL_COLLATE_EXTRAWC);
-				indirect = (const int32_t *)
-				  _NL_CURRENT (LC_COLLATE,
-					       _NL_COLLATE_INDIRECTWC);
-
-				idx = findidx ((const wint_t**)&cp);
-				if (idx == 0 || cp < (wint_t*) str + c1)
-				  /* This is no valid character.  */
-				  FREE_STACK_RETURN (REG_ECOLLATE);
-
-				str[0] = (wchar_t)idx;
-			      }
-			    else /* delim == '.' */
-			      {
-				/* We push collation sequence value
-				   for collating symbol.  */
-				int32_t table_size;
-				const int32_t *symb_table;
-				const unsigned char *extra;
-				int32_t idx;
-				int32_t elem;
-				int32_t second;
-				int32_t hash;
-				char char_str[c1];
-
-				/* We have to convert the name to a single-byte
-				   string.  This is possible since the names
-				   consist of ASCII characters and the internal
-				   representation is UCS4.  */
-				for (i = 0; i < c1; ++i)
-				  char_str[i] = str[i];
-
-				table_size =
-				  _NL_CURRENT_WORD (LC_COLLATE,
-						    _NL_COLLATE_SYMB_HASH_SIZEMB);
-				symb_table = (const int32_t *)
-				  _NL_CURRENT (LC_COLLATE,
-					       _NL_COLLATE_SYMB_TABLEMB);
-				extra = (const unsigned char *)
-				  _NL_CURRENT (LC_COLLATE,
-					       _NL_COLLATE_SYMB_EXTRAMB);
-
-				/* Locate the character in the hashing table.  */
-				hash = elem_hash (char_str, c1);
-
-				idx = 0;
-				elem = hash % table_size;
-				second = hash % (table_size - 2);
-				while (symb_table[2 * elem] != 0)
-				  {
-				    /* First compare the hashing value.  */
-				    if (symb_table[2 * elem] == hash
-					&& c1 == extra[symb_table[2 * elem + 1]]
-					&& memcmp (char_str,
-						   &extra[symb_table[2 * elem + 1]
-							 + 1], c1) == 0)
-				      {
-					/* Yep, this is the entry.  */
-					idx = symb_table[2 * elem + 1];
-					idx += 1 + extra[idx];
-					break;
-				      }
-
-				    /* Next entry.  */
-				    elem += second;
-				  }
-
-				if (symb_table[2 * elem] != 0)
-				  {
-				    /* Compute the index of the byte sequence
-				       in the table.  */
-				    idx += 1 + extra[idx];
-				    /* Adjust for the alignment.  */
-				    idx = (idx + 3) & ~3;
-
-				    str[0] = (wchar_t) idx + 4;
-				  }
-				else if (symb_table[2 * elem] == 0 && c1 == 1)
-				  {
-				    /* No valid character.  Match it as a
-				       single byte character.  */
-				    had_char_class = false;
-				    BUF_PUSH(str[0]);
-				    /* Update the length of characters  */
-				    laststart[5]++;
-				    range_start = str[0];
-
-				    /* Throw away the ] at the end of the
-				       collating symbol.  */
-				    PATFETCH (c);
-				    /* exit from the switch block.  */
-				    continue;
-				  }
-				else
-				  FREE_STACK_RETURN (REG_ECOLLATE);
-			      }
-			    datasize = 1;
-			  }
-# endif
-                        /* Throw away the ] at the end of the equivalence
-                           class (or collating symbol).  */
-                        PATFETCH (c);
-
-			/* Allocate the space for the equivalence class
-			   (or collating symbol) (and '\0' if needed).  */
-                        GET_BUFFER_SPACE(datasize);
-			/* Update the pointer to indicate end of buffer.  */
-                        b += datasize;
-
-			if (delim == '=')
-			  { /* equivalence class  */
-			    /* Calculate the offset of char_ranges,
-			       which is next to equivalence_classes.  */
-			    offset = laststart[1] + laststart[2]
-			      + laststart[3] +6;
-			    /* Insert space.  */
-			    insert_space(datasize, laststart + offset, b - 1);
-
-			    /* Write the equivalence_class and \0.  */
-			    for (i = 0 ; i < datasize ; i++)
-			      laststart[offset + i] = str[i];
-
-			    /* Update the length of equivalence_classes.  */
-			    laststart[3] += datasize;
-			    had_char_class = true;
-			  }
-			else /* delim == '.' */
-			  { /* collating symbol  */
-			    /* Calculate the offset of the equivalence_classes,
-			       which is next to collating_symbols.  */
-			    offset = laststart[1] + laststart[2] + 6;
-			    /* Insert space and write the collationg_symbol
-			       and \0.  */
-			    insert_space(datasize, laststart + offset, b-1);
-			    for (i = 0 ; i < datasize ; i++)
-			      laststart[offset + i] = str[i];
-
-			    /* In re_match_2_internal if range_start < -1, we
-			       assume -range_start is the offset of the
-			       collating symbol which is specified as
-			       the character of the range start.  So we assign
-			       -(laststart[1] + laststart[2] + 6) to
-			       range_start.  */
-			    range_start = -(laststart[1] + laststart[2] + 6);
-			    /* Update the length of collating_symbol.  */
-			    laststart[2] += datasize;
-			    had_char_class = false;
-			  }
-		      }
-                    else
-                      {
-                        c1++;
-                        while (c1--)
-                          PATUNFETCH;
-                        BUF_PUSH ('[');
-                        BUF_PUSH (delim);
-                        laststart[5] += 2; /* Update the length of characters  */
-			range_start = delim;
-                        had_char_class = false;
-                      }
-		  }
-                else
-                  {
-                    had_char_class = false;
-		    BUF_PUSH(c);
-		    laststart[5]++;  /* Update the length of characters  */
-		    range_start = c;
-                  }
-	      }
-
-#else /* BYTE */
-            /* 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);
-		    range_start = 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
-                      = byte_compile_range (range_start, &p, pend, translate,
-					    syntax, b);
-                    if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
-		    range_start = 0xffffffff;
-                  }
-
-                else if (p[0] == '-' && p[1] != ']')
-                  { /* This handles ranges made up of characters only.  */
-                    reg_errcode_t ret;
-
-		    /* Move past the `-'.  */
-                    PATFETCH (c1);
-
-                    ret = byte_compile_range (c, &p, pend, translate, syntax, b);
-                    if (ret != REG_NOERROR) FREE_STACK_RETURN (ret);
-		    range_start = 0xffffffff;
-                  }
-
-                /* 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 (':');
-			range_start = ':';
-                        had_char_class = false;
-                      }
-                  }
-                else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '=')
-		  {
-		    unsigned char str[MB_LEN_MAX + 1];
-# ifdef _LIBC
-		    uint32_t nrules =
-		      _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-# endif
-
-		    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 < MB_LEN_MAX)
-			  str[c1++] = c;
-			else
-			  /* This is in any case an invalid class name.  */
-			  str[0] = '\0';
-                      }
-		    str[c1] = '\0';
-
-		    if (c == '=' && *p == ']' && str[0] != '\0')
-		      {
-			/* If we have no collation data we use the default
-			   collation in which each character is in a class
-			   by itself.  It also means that ASCII is the
-			   character set and therefore we cannot have character
-			   with more than one byte in the multibyte
-			   representation.  */
-# ifdef _LIBC
-			if (nrules == 0)
-# endif
-			  {
-			    if (c1 != 1)
-			      FREE_STACK_RETURN (REG_ECOLLATE);
-
-			    /* Throw away the ] at the end of the equivalence
-			       class.  */
-			    PATFETCH (c);
-
-			    /* Set the bit for the character.  */
-			    SET_LIST_BIT (str[0]);
-			  }
-# ifdef _LIBC
-			else
-			  {
-			    /* Try to match the byte sequence in `str' against
-			       those known to the collate implementation.
-			       First find out whether the bytes in `str' are
-			       actually from exactly one character.  */
-			    const int32_t *table;
-			    const unsigned char *weights;
-			    const unsigned char *extra;
-			    const int32_t *indirect;
-			    int32_t idx;
-			    const unsigned char *cp = str;
-			    int ch;
-
-			    /* This #include defines a local function!  */
-#  include <locale/weight.h>
-
-			    table = (const int32_t *)
-			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEMB);
-			    weights = (const unsigned char *)
-			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTMB);
-			    extra = (const unsigned char *)
-			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAMB);
-			    indirect = (const int32_t *)
-			      _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTMB);
-
-			    idx = findidx (&cp);
-			    if (idx == 0 || cp < str + c1)
-			      /* This is no valid character.  */
-			      FREE_STACK_RETURN (REG_ECOLLATE);
-
-			    /* Throw away the ] at the end of the equivalence
-			       class.  */
-			    PATFETCH (c);
-
-			    /* Now we have to go throught the whole table
-			       and find all characters which have the same
-			       first level weight.
-
-			       XXX Note that this is not entirely correct.
-			       we would have to match multibyte sequences
-			       but this is not possible with the current
-			       implementation.  */
-			    for (ch = 1; ch < 256; ++ch)
-			      /* XXX This test would have to be changed if we
-				 would allow matching multibyte sequences.  */
-			      if (table[ch] > 0)
-				{
-				  int32_t idx2 = table[ch];
-				  size_t len = weights[idx2];
-
-				  /* Test whether the lenghts match.  */
-				  if (weights[idx] == len)
-				    {
-				      /* They do.  New compare the bytes of
-					 the weight.  */
-				      size_t cnt = 0;
-
-				      while (cnt < len
-					     && (weights[idx + 1 + cnt]
-						 == weights[idx2 + 1 + cnt]))
-					++cnt;
-
-				      if (cnt == len)
-					/* They match.  Mark the character as
-					   acceptable.  */
-					SET_LIST_BIT (ch);
-				    }
-				}
-			  }
-# endif
-			had_char_class = true;
-		      }
-                    else
-                      {
-                        c1++;
-                        while (c1--)
-                          PATUNFETCH;
-                        SET_LIST_BIT ('[');
-                        SET_LIST_BIT ('=');
-			range_start = '=';
-                        had_char_class = false;
-                      }
-		  }
-                else if (syntax & RE_CHAR_CLASSES && c == '[' && *p == '.')
-		  {
-		    unsigned char str[128];	/* Should be large enough.  */
-# ifdef _LIBC
-		    uint32_t nrules =
-		      _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-# endif
-
-		    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 < sizeof (str))
-			  str[c1++] = c;
-			else
-			  /* This is in any case an invalid class name.  */
-			  str[0] = '\0';
-                      }
-		    str[c1] = '\0';
-
-		    if (c == '.' && *p == ']' && str[0] != '\0')
-		      {
-			/* If we have no collation data we use the default
-			   collation in which each character is the name
-			   for its own class which contains only the one
-			   character.  It also means that ASCII is the
-			   character set and therefore we cannot have character
-			   with more than one byte in the multibyte
-			   representation.  */
-# ifdef _LIBC
-			if (nrules == 0)
-# endif
-			  {
-			    if (c1 != 1)
-			      FREE_STACK_RETURN (REG_ECOLLATE);
-
-			    /* Throw away the ] at the end of the equivalence
-			       class.  */
-			    PATFETCH (c);
-
-			    /* Set the bit for the character.  */
-			    SET_LIST_BIT (str[0]);
-			    range_start = ((const unsigned char *) str)[0];
-			  }
-# ifdef _LIBC
-			else
-			  {
-			    /* Try to match the byte sequence in `str' against
-			       those known to the collate implementation.
-			       First find out whether the bytes in `str' are
-			       actually from exactly one character.  */
-			    int32_t table_size;
-			    const int32_t *symb_table;
-			    const unsigned char *extra;
-			    int32_t idx;
-			    int32_t elem;
-			    int32_t second;
-			    int32_t hash;
-
-			    table_size =
-			      _NL_CURRENT_WORD (LC_COLLATE,
-						_NL_COLLATE_SYMB_HASH_SIZEMB);
-			    symb_table = (const int32_t *)
-			      _NL_CURRENT (LC_COLLATE,
-					   _NL_COLLATE_SYMB_TABLEMB);
-			    extra = (const unsigned char *)
-			      _NL_CURRENT (LC_COLLATE,
-					   _NL_COLLATE_SYMB_EXTRAMB);
-
-			    /* Locate the character in the hashing table.  */
-			    hash = elem_hash (str, c1);
-
-			    idx = 0;
-			    elem = hash % table_size;
-			    second = hash % (table_size - 2);
-			    while (symb_table[2 * elem] != 0)
-			      {
-				/* First compare the hashing value.  */
-				if (symb_table[2 * elem] == hash
-				    && c1 == extra[symb_table[2 * elem + 1]]
-				    && memcmp (str,
-					       &extra[symb_table[2 * elem + 1]
-						     + 1],
-					       c1) == 0)
-				  {
-				    /* Yep, this is the entry.  */
-				    idx = symb_table[2 * elem + 1];
-				    idx += 1 + extra[idx];
-				    break;
-				  }
-
-				/* Next entry.  */
-				elem += second;
-			      }
-
-			    if (symb_table[2 * elem] == 0)
-			      /* This is no valid character.  */
-			      FREE_STACK_RETURN (REG_ECOLLATE);
-
-			    /* Throw away the ] at the end of the equivalence
-			       class.  */
-			    PATFETCH (c);
-
-			    /* Now add the multibyte character(s) we found
-			       to the accept list.
-
-			       XXX Note that this is not entirely correct.
-			       we would have to match multibyte sequences
-			       but this is not possible with the current
-			       implementation.  Also, we have to match
-			       collating symbols, which expand to more than
-			       one file, as a whole and not allow the
-			       individual bytes.  */
-			    c1 = extra[idx++];
-			    if (c1 == 1)
-			      range_start = extra[idx];
-			    while (c1-- > 0)
-			      {
-				SET_LIST_BIT (extra[idx]);
-				++idx;
-			      }
-			  }
-# endif
-			had_char_class = false;
-		      }
-                    else
-                      {
-                        c1++;
-                        while (c1--)
-                          PATUNFETCH;
-                        SET_LIST_BIT ('[');
-                        SET_LIST_BIT ('.');
-			range_start = '.';
-                        had_char_class = false;
-                      }
-		  }
-                else
-                  {
-                    had_char_class = false;
-                    SET_LIST_BIT (c);
-		    range_start = 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];
-#endif /* WCHAR */
-          }
-          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 - COMPILED_BUFFER_VAR;
-              COMPILE_STACK_TOP.fixup_alt_jump
-                = fixup_alt_jump ? fixup_alt_jump - COMPILED_BUFFER_VAR + 1 : 0;
-              COMPILE_STACK_TOP.laststart_offset = b - COMPILED_BUFFER_VAR;
-              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
-		    - COMPILED_BUFFER_VAR + 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 = COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.begalt_offset;
-                fixup_alt_jump
-                  = COMPILE_STACK_TOP.fixup_alt_jump
-                    ? COMPILED_BUFFER_VAR + COMPILE_STACK_TOP.fixup_alt_jump - 1
-                    : 0;
-                laststart = COMPILED_BUFFER_VAR + 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)
-                  {
-		    UCHAR_T *inner_group_loc
-                      = COMPILED_BUFFER_VAR + 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 (1 + OFFSET_ADDRESS_SIZE);
-              INSERT_JUMP (on_failure_jump, begalt,
-			   b + 2 + 2 * OFFSET_ADDRESS_SIZE);
-              pending_exact = 0;
-              b += 1 + OFFSET_ADDRESS_SIZE;
-
-              /* 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 (1 + OFFSET_ADDRESS_SIZE);
-              b += 1 + OFFSET_ADDRESS_SIZE;
-
-              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_NO_BK_BRACES))
-                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;
-
-		/* Place in the uncompiled pattern (i.e., just after
-		   the '{') to go back to if the interval is invalid.  */
-		const CHAR_T *beg_interval = p;
-
-                if (p == pend)
-		  goto invalid_interval;
-
-                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 (! (0 <= lower_bound && lower_bound <= upper_bound))
-		  goto invalid_interval;
-
-                if (!(syntax & RE_NO_BK_BRACES))
-                  {
-		    if (c != '\\' || p == pend)
-		      goto invalid_interval;
-                    PATFETCH (c);
-                  }
-
-                if (c != '}')
-		  goto invalid_interval;
-
-                /* If it's invalid to have no preceding re.  */
-                if (!laststart)
-                  {
-		    if (syntax & RE_CONTEXT_INVALID_OPS
-			&& !(syntax & RE_INVALID_INTERVAL_ORD))
-                      FREE_STACK_RETURN (REG_BADRPT);
-                    else if (syntax & RE_CONTEXT_INDEP_OPS)
-                      laststart = b;
-                    else
-                      goto unfetch_interval;
-                  }
-
-                /* We just parsed a valid interval.  */
-
-                if (RE_DUP_MAX < upper_bound)
-		  FREE_STACK_RETURN (REG_BADBR);
-
-                /* 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.  */
-		/* ifdef WCHAR, 'b + 1 + OFFSET_ADDRESS_SIZE'
-		   instead of 'b + 3'.  */
-                 if (upper_bound == 0)
-                   {
-                     GET_BUFFER_SPACE (1 + OFFSET_ADDRESS_SIZE);
-                     INSERT_JUMP (jump, laststart, b + 1
-				  + OFFSET_ADDRESS_SIZE);
-                     b += 1 + OFFSET_ADDRESS_SIZE;
-                   }
-
-                 /* 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 = 2 + 4 * OFFSET_ADDRESS_SIZE +
-		       (upper_bound > 1) * (2 + 4 * OFFSET_ADDRESS_SIZE);
-
-                     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 + 1 + 2 * OFFSET_ADDRESS_SIZE
-				   + (upper_bound > 1) * (1 + 2 * OFFSET_ADDRESS_SIZE)
-				   , lower_bound);
-                     b += 1 + 2 * OFFSET_ADDRESS_SIZE;
-
-                     /* 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'.  */
-		     /* ifdef WCHAR, The '1+2*OFFSET_ADDRESS_SIZE'
-			is the 'set_number_at', plus '1+OFFSET_ADDRESS_SIZE'
-			of the following `succeed_n'.  */
-                     PREFIX(insert_op2) (set_number_at, laststart, 1
-				 + 2 * OFFSET_ADDRESS_SIZE, lower_bound, b);
-                     b += 1 + 2 * OFFSET_ADDRESS_SIZE;
-
-                     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
-				      + 2 * OFFSET_ADDRESS_SIZE + 1,
-                                      upper_bound - 1);
-                         b += 1 + 2 * OFFSET_ADDRESS_SIZE;
-
-                         /* 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.  */
-                         PREFIX(insert_op2) (set_number_at, laststart,
-					     b - laststart,
-					     upper_bound - 1, b);
-                         b += 1 + 2 * OFFSET_ADDRESS_SIZE;
-                       }
-                   }
-                pending_exact = 0;
-		break;
-
-	      invalid_interval:
-		if (!(syntax & RE_INVALID_INTERVAL_ORD))
-		  FREE_STACK_RETURN (p == pend ? REG_EBRACE : REG_BADBR);
-	      unfetch_interval:
-		/* Match the characters as literals.  */
-		p = beg_interval;
-		c = '{';
-		if (syntax & RE_NO_BK_BRACES)
-		  goto normal_char;
-		else
-		  goto normal_backslash;
-	      }
-
-#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
-#ifdef WCHAR
-	      /* If last exactn handle binary(or character) and
-		 new exactn handle character(or binary).  */
-	      || is_exactn_bin != is_binary[p - 1 - pattern]
-#endif /* WCHAR */
-
-              /* 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;
-
-#ifdef WCHAR
-	      /* Is this exactn binary data or character? */
-	      is_exactn_bin = is_binary[p - 1 - pattern];
-	      if (is_exactn_bin)
-		  BUF_PUSH_2 (exactn_bin, 0);
-	      else
-		  BUF_PUSH_2 (exactn, 0);
-#else
-	      BUF_PUSH_2 (exactn, 0);
-#endif /* WCHAR */
-	      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);
-
-#ifdef WCHAR
-  free (pattern);
-  free (mbs_offset);
-  free (is_binary);
-#endif
-  free (compile_stack.stack);
-
-  /* We have succeeded; set the length of the buffer.  */
-#ifdef WCHAR
-  bufp->used = (uintptr_t) b - (uintptr_t) COMPILED_BUFFER_VAR;
-#else
-  bufp->used = b - bufp->buffer;
-#endif
-
-#ifdef DEBUG
-  if (debug)
-    {
-      DEBUG_PRINT1 ("\nCompiled pattern: \n");
-      PREFIX(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
-	    = (PREFIX(fail_stack_elt_t) *) xmalloc (fail_stack.size
-				    * sizeof (PREFIX(fail_stack_elt_t)));
-	else
-	  fail_stack.stack
-	    = (PREFIX(fail_stack_elt_t) *) xrealloc (fail_stack.stack,
-				     (fail_stack.size
-				      * sizeof (PREFIX(fail_stack_elt_t))));
-# else /* not emacs */
-	if (! fail_stack.stack)
-	  fail_stack.stack
-	    = (PREFIX(fail_stack_elt_t) *) malloc (fail_stack.size
-				   * sizeof (PREFIX(fail_stack_elt_t)));
-	else
-	  fail_stack.stack
-	    = (PREFIX(fail_stack_elt_t) *) realloc (fail_stack.stack,
-					    (fail_stack.size
-				     * sizeof (PREFIX(fail_stack_elt_t))));
-# endif /* not emacs */
-      }
-
-   PREFIX(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.  */
-/* ifdef WCHAR, integer parameter is 1 wchar_t.  */
-
-static void
-PREFIX(store_op1) (re_opcode_t op, UCHAR_T *loc, int arg)
-{
-  *loc = (UCHAR_T) op;
-  STORE_NUMBER (loc + 1, arg);
-}
-
-
-/* Like `store_op1', but for two two-byte parameters ARG1 and ARG2.  */
-/* ifdef WCHAR, integer parameter is 1 wchar_t.  */
-
-static void
-PREFIX(store_op2) (re_opcode_t op, UCHAR_T *loc, int arg1, int arg2)
-{
-  *loc = (UCHAR_T) op;
-  STORE_NUMBER (loc + 1, arg1);
-  STORE_NUMBER (loc + 1 + OFFSET_ADDRESS_SIZE, 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.  */
-/* ifdef WCHAR, integer parameter is 1 wchar_t.  */
-
-static void
-PREFIX(insert_op1) (re_opcode_t op, UCHAR_T *loc, int arg, UCHAR_T *end)
-{
-  register UCHAR_T *pfrom = end;
-  register UCHAR_T *pto = end + 1 + OFFSET_ADDRESS_SIZE;
-
-  while (pfrom != loc)
-    *--pto = *--pfrom;
-
-  PREFIX(store_op1) (op, loc, arg);
-}
-
-
-/* Like `insert_op1', but for two two-byte parameters ARG1 and ARG2.  */
-/* ifdef WCHAR, integer parameter is 1 wchar_t.  */
-
-static void
-PREFIX(insert_op2) (re_opcode_t op, UCHAR_T *loc, int arg1,
-                    int arg2, UCHAR_T *end)
-{
-  register UCHAR_T *pfrom = end;
-  register UCHAR_T *pto = end + 1 + 2 * OFFSET_ADDRESS_SIZE;
-
-  while (pfrom != loc)
-    *--pto = *--pfrom;
-
-  PREFIX(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
-PREFIX(at_begline_loc_p) (const CHAR_T *pattern, const CHAR_T *p,
-                          reg_syntax_t syntax)
-{
-  const CHAR_T *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
-PREFIX(at_endline_loc_p) (const CHAR_T *p, const CHAR_T *pend,
-                          reg_syntax_t syntax)
-{
-  const CHAR_T *next = p;
-  boolean next_backslash = *next == '\\';
-  const CHAR_T *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 == '|');
-}
-
-#else /* not INSIDE_RECURSION */
-
-/* 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_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;
-}
-#endif /* not INSIDE_RECURSION */
-
-#ifdef INSIDE_RECURSION
-
-#ifdef WCHAR
-/* This insert space, which size is "num", into the pattern at "loc".
-   "end" must point the end of the allocated buffer.  */
-static void
-insert_space (int num, CHAR_T *loc, CHAR_T *end)
-{
-  register CHAR_T *pto = end;
-  register CHAR_T *pfrom = end - num;
-
-  while (pfrom >= loc)
-    *pto-- = *pfrom--;
-}
-#endif /* WCHAR */
-
-#ifdef WCHAR
-static reg_errcode_t
-wcs_compile_range (CHAR_T range_start_char, const CHAR_T **p_ptr,
-                   const CHAR_T *pend, RE_TRANSLATE_TYPE translate,
-                   reg_syntax_t syntax, CHAR_T *b, CHAR_T *char_set)
-{
-  const CHAR_T *p = *p_ptr;
-  CHAR_T range_start, range_end;
-  reg_errcode_t ret;
-# ifdef _LIBC
-  uint32_t nrules;
-  uint32_t start_val, end_val;
-# endif
-  if (p == pend)
-    return REG_ERANGE;
-
-# ifdef _LIBC
-  nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-  if (nrules != 0)
-    {
-      const char *collseq = (const char *) _NL_CURRENT(LC_COLLATE,
-						       _NL_COLLATE_COLLSEQWC);
-      const unsigned char *extra = (const unsigned char *)
-	_NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
-
-      if (range_start_char < -1)
-	{
-	  /* range_start is a collating symbol.  */
-	  int32_t *wextra;
-	  /* Retreive the index and get collation sequence value.  */
-	  wextra = (int32_t*)(extra + char_set[-range_start_char]);
-	  start_val = wextra[1 + *wextra];
-	}
-      else
-	start_val = collseq_table_lookup(collseq, TRANSLATE(range_start_char));
-
-      end_val = collseq_table_lookup (collseq, TRANSLATE (p[0]));
-
-      /* Report an error if the range is empty and the syntax prohibits
-	 this.  */
-      ret = ((syntax & RE_NO_EMPTY_RANGES)
-	     && (start_val > end_val))? REG_ERANGE : REG_NOERROR;
-
-      /* Insert space to the end of the char_ranges.  */
-      insert_space(2, b - char_set[5] - 2, b - 1);
-      *(b - char_set[5] - 2) = (wchar_t)start_val;
-      *(b - char_set[5] - 1) = (wchar_t)end_val;
-      char_set[4]++; /* ranges_index */
-    }
-  else
-# endif
-    {
-      range_start = (range_start_char >= 0)? TRANSLATE (range_start_char):
-	range_start_char;
-      range_end = TRANSLATE (p[0]);
-      /* Report an error if the range is empty and the syntax prohibits
-	 this.  */
-      ret = ((syntax & RE_NO_EMPTY_RANGES)
-	     && (range_start > range_end))? REG_ERANGE : REG_NOERROR;
-
-      /* Insert space to the end of the char_ranges.  */
-      insert_space(2, b - char_set[5] - 2, b - 1);
-      *(b - char_set[5] - 2) = range_start;
-      *(b - char_set[5] - 1) = range_end;
-      char_set[4]++; /* ranges_index */
-    }
-  /* Have to increment the pointer into the pattern string, so the
-     caller isn't still at the ending character.  */
-  (*p_ptr)++;
-
-  return ret;
-}
-#else /* BYTE */
-/* 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
-byte_compile_range (unsigned int range_start_char, const char **p_ptr,
-                    const char *pend, RE_TRANSLATE_TYPE translate,
-                    reg_syntax_t syntax, unsigned char *b)
-{
-  unsigned this_char;
-  const char *p = *p_ptr;
-  reg_errcode_t ret;
-# if _LIBC
-  const unsigned char *collseq;
-  unsigned int start_colseq;
-  unsigned int end_colseq;
-# else
-  unsigned end_char;
-# endif
-
-  if (p == pend)
-    return REG_ERANGE;
-
-  /* Have to increment the pointer into the pattern string, so the
-     caller isn't still at the ending character.  */
-  (*p_ptr)++;
-
-  /* Report an error if the range is empty and the syntax prohibits this.  */
-  ret = syntax & RE_NO_EMPTY_RANGES ? REG_ERANGE : REG_NOERROR;
-
-# if _LIBC
-  collseq = (const unsigned char *) _NL_CURRENT (LC_COLLATE,
-						 _NL_COLLATE_COLLSEQMB);
-
-  start_colseq = collseq[(unsigned char) TRANSLATE (range_start_char)];
-  end_colseq = collseq[(unsigned char) TRANSLATE (p[0])];
-  for (this_char = 0; this_char <= (unsigned char) -1; ++this_char)
-    {
-      unsigned int this_colseq = collseq[(unsigned char) TRANSLATE (this_char)];
-
-      if (start_colseq <= this_colseq && this_colseq <= end_colseq)
-	{
-	  SET_LIST_BIT (TRANSLATE (this_char));
-	  ret = REG_NOERROR;
-	}
-    }
-# else
-  /* Here we see why `this_char' has to be larger than an `unsigned
-     char' -- we would otherwise go into an infinite loop, since all
-     characters <= 0xff.  */
-  range_start_char = TRANSLATE (range_start_char);
-  /* TRANSLATE(p[0]) is casted to char (not unsigned char) in TRANSLATE,
-     and some compilers cast it to int implicitly, so following for_loop
-     may fall to (almost) infinite loop.
-     e.g. If translate[p[0]] = 0xff, end_char may equals to 0xffffffff.
-     To avoid this, we cast p[0] to unsigned int and truncate it.  */
-  end_char = ((unsigned)TRANSLATE(p[0]) & ((1 << BYTEWIDTH) - 1));
-
-  for (this_char = range_start_char; this_char <= end_char; ++this_char)
-    {
-      SET_LIST_BIT (TRANSLATE (this_char));
-      ret = REG_NOERROR;
-    }
-# endif
-
-  return ret;
-}
-#endif /* WCHAR */
-
-/* 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.   */
-
-#ifdef WCHAR
-/* local function for re_compile_fastmap.
-   truncate wchar_t character to char.  */
-static unsigned char truncate_wchar (CHAR_T c);
-
-static unsigned char
-truncate_wchar (CHAR_T c)
-{
-  unsigned char buf[MB_CUR_MAX];
-  mbstate_t state;
-  int retval;
-  memset (&state, '\0', sizeof (state));
-# ifdef _LIBC
-  retval = __wcrtomb (buf, c, &state);
-# else
-  retval = wcrtomb (buf, c, &state);
-# endif
-  return retval > 0 ? buf[0] : (unsigned char) c;
-}
-#endif /* WCHAR */
-
-static int
-PREFIX(re_compile_fastmap) (struct re_pattern_buffer *bufp)
-{
-  int j, k;
-#ifdef MATCH_MAY_ALLOCATE
-  PREFIX(fail_stack_type) fail_stack;
-#endif
-#ifndef REGEX_MALLOC
-  char *destination;
-#endif
-
-  register char *fastmap = bufp->fastmap;
-
-#ifdef WCHAR
-  /* We need to cast pattern to (wchar_t*), because we casted this compiled
-     pattern to (char*) in regex_compile.  */
-  UCHAR_T *pattern = (UCHAR_T*)bufp->buffer;
-  register UCHAR_T *pend = (UCHAR_T*) (bufp->buffer + bufp->used);
-#else /* BYTE */
-  UCHAR_T *pattern = bufp->buffer;
-  register UCHAR_T *pend = pattern + bufp->used;
-#endif /* WCHAR */
-  UCHAR_T *p = pattern;
-
-#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 == (UCHAR_T) 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'.  */
-
-#ifdef WCHAR
-	case exactn:
-          fastmap[truncate_wchar(p[1])] = 1;
-	  break;
-#else /* BYTE */
-	case exactn:
-          fastmap[p[1]] = 1;
-	  break;
-#endif /* WCHAR */
-#ifdef MBS_SUPPORT
-	case exactn_bin:
-	  fastmap[p[1]] = 1;
-	  break;
-#endif
-
-#ifdef WCHAR
-        /* It is hard to distinguish fastmap from (multi byte) characters
-           which depends on current locale.  */
-        case charset:
-	case charset_not:
-	case wordchar:
-	case notwordchar:
-          bufp->can_be_null = 1;
-          goto done;
-#else /* BYTE */
-        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;
-#endif /* WCHAR */
-
-        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 += OFFSET_ADDRESS_SIZE;
-
-          /* Increment p past the n for when k != 0.  */
-          EXTRACT_NUMBER_AND_INCR (k, p);
-          if (k == 0)
-	    {
-              p -= 2 * OFFSET_ADDRESS_SIZE;
-  	      succeed_n_p = true;  /* Spaghetti code alert.  */
-              goto handle_on_failure_jump;
-            }
-          continue;
-
-
-	case set_number_at:
-          p += 2 * OFFSET_ADDRESS_SIZE;
-          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;
-}
-
-#else /* not INSIDE_RECURSION */
-
-int
-re_compile_fastmap (struct re_pattern_buffer *bufp)
-{
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    return wcs_re_compile_fastmap(bufp);
-  else
-# endif
-    return byte_re_compile_fastmap(bufp);
-} /* 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 (struct re_pattern_buffer *bufp,
-                  struct re_registers *regs, unsigned num_regs,
-                  regoff_t *starts, regoff_t *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 (struct re_pattern_buffer *bufp, const char *string, int size,
-           int startpos, int 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 (struct re_pattern_buffer *bufp, const char *string1, int size1,
-             const char *string2, int size2, int startpos, int range,
-             struct re_registers *regs, int stop)
-{
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    return wcs_re_search_2 (bufp, string1, size1, string2, size2, startpos,
-			    range, regs, stop);
-  else
-# endif
-    return byte_re_search_2 (bufp, string1, size1, string2, size2, startpos,
-			     range, regs, stop);
-} /* re_search_2 */
-#ifdef _LIBC
-weak_alias (__re_search_2, re_search_2)
-#endif
-
-#endif /* not INSIDE_RECURSION */
-
-#ifdef INSIDE_RECURSION
-
-#ifdef MATCH_MAY_ALLOCATE
-# define FREE_VAR(var) if (var) REGEX_FREE (var); var = NULL
-#else
-# define FREE_VAR(var) if (var) free (var); var = NULL
-#endif
-
-#ifdef WCHAR
-# define MAX_ALLOCA_SIZE	2000
-
-# define FREE_WCS_BUFFERS() \
-  do {									      \
-    if (size1 > MAX_ALLOCA_SIZE)					      \
-      {									      \
-	free (wcs_string1);						      \
-	free (mbs_offset1);						      \
-      }									      \
-    else								      \
-      {									      \
-	FREE_VAR (wcs_string1);						      \
-	FREE_VAR (mbs_offset1);						      \
-      }									      \
-    if (size2 > MAX_ALLOCA_SIZE) 					      \
-      {									      \
-	free (wcs_string2);						      \
-	free (mbs_offset2);						      \
-      }									      \
-    else								      \
-      {									      \
-	FREE_VAR (wcs_string2);						      \
-	FREE_VAR (mbs_offset2);						      \
-      }									      \
-  } while (0)
-
-#endif
-
-
-static int
-PREFIX(re_search_2) (struct re_pattern_buffer *bufp, const char *string1,
-                     int size1, const char *string2, int 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;
-#ifdef WCHAR
-  /* We need wchar_t* buffers correspond to cstring1, cstring2.  */
-  wchar_t *wcs_string1 = NULL, *wcs_string2 = NULL;
-  /* We need the size of wchar_t buffers correspond to csize1, csize2.  */
-  int wcs_size1 = 0, wcs_size2 = 0;
-  /* offset buffer for optimizatoin. See convert_mbs_to_wc.  */
-  int *mbs_offset1 = NULL, *mbs_offset2 = NULL;
-  /* They hold whether each wchar_t is binary data or not.  */
-  char *is_binary = NULL;
-#endif /* WCHAR */
-
-  /* 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;
-
-#ifdef WCHAR
-  /* Allocate wchar_t array for wcs_string1 and wcs_string2 and
-     fill them with converted string.  */
-  if (size1 != 0)
-    {
-      if (size1 > MAX_ALLOCA_SIZE)
-	{
-	  wcs_string1 = TALLOC (size1 + 1, CHAR_T);
-	  mbs_offset1 = TALLOC (size1 + 1, int);
-	  is_binary = TALLOC (size1 + 1, char);
-	}
-      else
-	{
-	  wcs_string1 = REGEX_TALLOC (size1 + 1, CHAR_T);
-	  mbs_offset1 = REGEX_TALLOC (size1 + 1, int);
-	  is_binary = REGEX_TALLOC (size1 + 1, char);
-	}
-      if (!wcs_string1 || !mbs_offset1 || !is_binary)
-	{
-	  if (size1 > MAX_ALLOCA_SIZE)
-	    {
-	      free (wcs_string1);
-	      free (mbs_offset1);
-	      free (is_binary);
-	    }
-	  else
-	    {
-	      FREE_VAR (wcs_string1);
-	      FREE_VAR (mbs_offset1);
-	      FREE_VAR (is_binary);
-	    }
-	  return -2;
-	}
-      wcs_size1 = convert_mbs_to_wcs(wcs_string1, string1, size1,
-				     mbs_offset1, is_binary);
-      wcs_string1[wcs_size1] = L'\0'; /* for a sentinel  */
-      if (size1 > MAX_ALLOCA_SIZE)
-	free (is_binary);
-      else
-	FREE_VAR (is_binary);
-    }
-  if (size2 != 0)
-    {
-      if (size2 > MAX_ALLOCA_SIZE)
-	{
-	  wcs_string2 = TALLOC (size2 + 1, CHAR_T);
-	  mbs_offset2 = TALLOC (size2 + 1, int);
-	  is_binary = TALLOC (size2 + 1, char);
-	}
-      else
-	{
-	  wcs_string2 = REGEX_TALLOC (size2 + 1, CHAR_T);
-	  mbs_offset2 = REGEX_TALLOC (size2 + 1, int);
-	  is_binary = REGEX_TALLOC (size2 + 1, char);
-	}
-      if (!wcs_string2 || !mbs_offset2 || !is_binary)
-	{
-	  FREE_WCS_BUFFERS ();
-	  if (size2 > MAX_ALLOCA_SIZE)
-	    free (is_binary);
-	  else
-	    FREE_VAR (is_binary);
-	  return -2;
-	}
-      wcs_size2 = convert_mbs_to_wcs(wcs_string2, string2, size2,
-				     mbs_offset2, is_binary);
-      wcs_string2[wcs_size2] = L'\0'; /* for a sentinel  */
-      if (size2 > MAX_ALLOCA_SIZE)
-	free (is_binary);
-      else
-	FREE_VAR (is_binary);
-    }
-#endif /* WCHAR */
-
-
-  /* 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_T 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)
-       {
-#ifdef WCHAR
-         FREE_WCS_BUFFERS ();
-#endif
-         return -1;
-       }
-
-#ifdef WCHAR
-      val = wcs_re_match_2_internal (bufp, string1, size1, string2,
-				     size2, startpos, regs, stop,
-				     wcs_string1, wcs_size1,
-				     wcs_string2, wcs_size2,
-				     mbs_offset1, mbs_offset2);
-#else /* BYTE */
-      val = byte_re_match_2_internal (bufp, string1, size1, string2,
-				      size2, startpos, regs, stop);
-#endif /* BYTE */
-
-#ifndef REGEX_MALLOC
-# ifdef C_ALLOCA
-      alloca (0);
-# endif
-#endif
-
-      if (val >= 0)
-	{
-#ifdef WCHAR
-	  FREE_WCS_BUFFERS ();
-#endif
-	  return startpos;
-	}
-
-      if (val == -2)
-	{
-#ifdef WCHAR
-	  FREE_WCS_BUFFERS ();
-#endif
-	  return -2;
-	}
-
-    advance:
-      if (!range)
-        break;
-      else if (range > 0)
-        {
-          range--;
-          startpos++;
-        }
-      else
-        {
-          range++;
-          startpos--;
-        }
-    }
-#ifdef WCHAR
-  FREE_WCS_BUFFERS ();
-#endif
-  return -1;
-}
-
-#ifdef WCHAR
-/* This converts PTR, a pointer into one of the search wchar_t strings
-   `string1' and `string2' into an multibyte string offset from the
-   beginning of that string. We use mbs_offset to optimize.
-   See convert_mbs_to_wcs.  */
-# define POINTER_TO_OFFSET(ptr)						\
-  (FIRST_STRING_P (ptr)							\
-   ? ((regoff_t)(mbs_offset1 != NULL? mbs_offset1[(ptr)-string1] : 0))	\
-   : ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0)	\
-		 + csize1)))
-#else /* BYTE */
-/* 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)))
-#endif /* WCHAR */
-
-/* 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.  */
-#ifdef WCHAR
-/* Use internationalized API instead of SYNTAX.  */
-# define WORDCHAR_P(d)							\
-  (iswalnum ((wint_t)((d) == end1 ? *string2				\
-           : (d) == string2 - 1 ? *(end1 - 1) : *(d))) != 0		\
-   || ((d) == end1 ? *string2						\
-       : (d) == string2 - 1 ? *(end1 - 1) : *(d)) == L'_')
-#else /* BYTE */
-# define WORDCHAR_P(d)							\
-  (SYNTAX ((d) == end1 ? *string2					\
-           : (d) == string2 - 1 ? *(end1 - 1) : *(d))			\
-   == Sword)
-#endif /* WCHAR */
-
-/* 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
-# ifdef WCHAR
-#  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);						\
-    if (!cant_free_wcs_buf)						\
-      {									\
-        FREE_VAR (string1);						\
-        FREE_VAR (string2);						\
-        FREE_VAR (mbs_offset1);						\
-        FREE_VAR (mbs_offset2);						\
-      }									\
-  } while (0)
-# else /* BYTE */
-#  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)
-# endif /* WCHAR */
-#else
-# ifdef WCHAR
-#  define FREE_VARIABLES()						\
-  do {									\
-    if (!cant_free_wcs_buf)						\
-      {									\
-        FREE_VAR (string1);						\
-        FREE_VAR (string2);						\
-        FREE_VAR (mbs_offset1);						\
-        FREE_VAR (mbs_offset2);						\
-      }									\
-  } while (0)
-# else /* BYTE */
-#  define FREE_VARIABLES() ((void)0) /* Do nothing!  But inhibit gcc warning. */
-# endif /* WCHAR */
-#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)
-
-#else /* not INSIDE_RECURSION */
-/* 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 (struct re_pattern_buffer *bufp, const char *string,
-          int size, int pos, struct re_registers *regs)
-{
-  int result;
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    result = wcs_re_match_2_internal (bufp, NULL, 0, string, size,
-				      pos, regs, size,
-				      NULL, 0, NULL, 0, NULL, NULL);
-  else
-# endif
-    result = byte_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 */
-
-#endif /* not INSIDE_RECURSION */
-
-#ifdef INSIDE_RECURSION
-static boolean PREFIX(group_match_null_string_p) (UCHAR_T **p,
-                                                  UCHAR_T *end,
-					PREFIX(register_info_type) *reg_info);
-static boolean PREFIX(alt_match_null_string_p) (UCHAR_T *p,
-                                                UCHAR_T *end,
-					PREFIX(register_info_type) *reg_info);
-static boolean PREFIX(common_op_match_null_string_p) (UCHAR_T **p,
-                                                      UCHAR_T *end,
-					PREFIX(register_info_type) *reg_info);
-static int PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2,
-                                   int len, char *translate);
-#else /* not INSIDE_RECURSION */
-
-/* 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 (struct re_pattern_buffer *bufp, const char *string1, int size1,
-            const char *string2, int size2, int pos,
-            struct re_registers *regs, int stop)
-{
-  int result;
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    result = wcs_re_match_2_internal (bufp, string1, size1, string2, size2,
-				      pos, regs, stop,
-				      NULL, 0, NULL, 0, NULL, NULL);
-  else
-# endif
-    result = byte_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
-
-#endif /* not INSIDE_RECURSION */
-
-#ifdef INSIDE_RECURSION
-
-#ifdef WCHAR
-static int count_mbs_length (int *, int);
-
-/* This check the substring (from 0, to length) of the multibyte string,
-   to which offset_buffer correspond. And count how many wchar_t_characters
-   the substring occupy. We use offset_buffer to optimization.
-   See convert_mbs_to_wcs.  */
-
-static int
-count_mbs_length(int *offset_buffer, int length)
-{
-  int upper, lower;
-
-  /* Check whether the size is valid.  */
-  if (length < 0)
-    return -1;
-
-  if (offset_buffer == NULL)
-    return 0;
-
-  /* If there are no multibyte character, offset_buffer[i] == i.
-   Optmize for this case.  */
-  if (offset_buffer[length] == length)
-    return length;
-
-  /* Set up upper with length. (because for all i, offset_buffer[i] >= i)  */
-  upper = length;
-  lower = 0;
-
-  while (true)
-    {
-      int middle = (lower + upper) / 2;
-      if (middle == lower || middle == upper)
-	break;
-      if (offset_buffer[middle] > length)
-	upper = middle;
-      else if (offset_buffer[middle] < length)
-	lower = middle;
-      else
-	return middle;
-    }
-
-  return -1;
-}
-#endif /* WCHAR */
-
-/* This is a separate function so that we can force an alloca cleanup
-   afterwards.  */
-#ifdef WCHAR
-static int
-wcs_re_match_2_internal (struct re_pattern_buffer *bufp,
-                         const char *cstring1, int csize1,
-                         const char *cstring2, int csize2,
-                         int pos,
-			 struct re_registers *regs,
-                         int stop,
-     /* string1 == string2 == NULL means string1/2, size1/2 and
-	mbs_offset1/2 need seting up in this function.  */
-     /* We need wchar_t* buffers correspond to cstring1, cstring2.  */
-                         wchar_t *string1, int size1,
-                         wchar_t *string2, int size2,
-     /* offset buffer for optimizatoin. See convert_mbs_to_wc.  */
-			 int *mbs_offset1, int *mbs_offset2)
-#else /* BYTE */
-static int
-byte_re_match_2_internal (struct re_pattern_buffer *bufp,
-                          const char *string1, int size1,
-                          const char *string2, int size2,
-                          int pos,
-			  struct re_registers *regs, int stop)
-#endif /* BYTE */
-{
-  /* General temporaries.  */
-  int mcnt;
-  UCHAR_T *p1;
-#ifdef WCHAR
-  /* They hold whether each wchar_t is binary data or not.  */
-  char *is_binary = NULL;
-  /* If true, we can't free string1/2, mbs_offset1/2.  */
-  int cant_free_wcs_buf = 1;
-#endif /* WCHAR */
-
-  /* Just past the end of the corresponding string.  */
-  const CHAR_T *end1, *end2;
-
-  /* Pointers into string1 and string2, just past the last characters in
-     each to consider matching.  */
-  const CHAR_T *end_match_1, *end_match_2;
-
-  /* Where we are in the data, and the end of the current string.  */
-  const CHAR_T *d, *dend;
-
-  /* Where we are in the pattern, and the end of the pattern.  */
-#ifdef WCHAR
-  UCHAR_T *pattern, *p;
-  register UCHAR_T *pend;
-#else /* BYTE */
-  UCHAR_T *p = bufp->buffer;
-  register UCHAR_T *pend = p + bufp->used;
-#endif /* WCHAR */
-
-  /* Mark the opcode just after a start_memory, so we can test for an
-     empty subpattern when we get to the stop_memory.  */
-  UCHAR_T *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.  */
-  PREFIX(fail_stack_type) fail_stack;
-#endif
-#ifdef DEBUG
-  static unsigned failure_id;
-  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_T **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_T **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.  */
-  PREFIX(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_T **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_T *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_T **reg_dummy;
-  PREFIX(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_T *);
-      regend = REGEX_TALLOC (num_regs, const CHAR_T *);
-      old_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
-      old_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
-      best_regstart = REGEX_TALLOC (num_regs, const CHAR_T *);
-      best_regend = REGEX_TALLOC (num_regs, const CHAR_T *);
-      reg_info = REGEX_TALLOC (num_regs, PREFIX(register_info_type));
-      reg_dummy = REGEX_TALLOC (num_regs, const CHAR_T *);
-      reg_info_dummy = REGEX_TALLOC (num_regs, PREFIX(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 = (PREFIX(register_info_type) *) NULL;
-    }
-#endif /* MATCH_MAY_ALLOCATE */
-
-  /* The starting position is bogus.  */
-#ifdef WCHAR
-  if (pos < 0 || pos > csize1 + csize2)
-#else /* BYTE */
-  if (pos < 0 || pos > size1 + size2)
-#endif
-    {
-      FREE_VARIABLES ();
-      return -1;
-    }
-
-#ifdef WCHAR
-  /* Allocate wchar_t array for string1 and string2 and
-     fill them with converted string.  */
-  if (string1 == NULL && string2 == NULL)
-    {
-      /* We need seting up buffers here.  */
-
-      /* We must free wcs buffers in this function.  */
-      cant_free_wcs_buf = 0;
-
-      if (csize1 != 0)
-	{
-	  string1 = REGEX_TALLOC (csize1 + 1, CHAR_T);
-	  mbs_offset1 = REGEX_TALLOC (csize1 + 1, int);
-	  is_binary = REGEX_TALLOC (csize1 + 1, char);
-	  if (!string1 || !mbs_offset1 || !is_binary)
-	    {
-	      FREE_VAR (string1);
-	      FREE_VAR (mbs_offset1);
-	      FREE_VAR (is_binary);
-	      return -2;
-	    }
-	}
-      if (csize2 != 0)
-	{
-	  string2 = REGEX_TALLOC (csize2 + 1, CHAR_T);
-	  mbs_offset2 = REGEX_TALLOC (csize2 + 1, int);
-	  is_binary = REGEX_TALLOC (csize2 + 1, char);
-	  if (!string2 || !mbs_offset2 || !is_binary)
-	    {
-	      FREE_VAR (string1);
-	      FREE_VAR (mbs_offset1);
-	      FREE_VAR (string2);
-	      FREE_VAR (mbs_offset2);
-	      FREE_VAR (is_binary);
-	      return -2;
-	    }
-	  size2 = convert_mbs_to_wcs(string2, cstring2, csize2,
-				     mbs_offset2, is_binary);
-	  string2[size2] = L'\0'; /* for a sentinel  */
-	  FREE_VAR (is_binary);
-	}
-    }
-
-  /* We need to cast pattern to (wchar_t*), because we casted this compiled
-     pattern to (char*) in regex_compile.  */
-  p = pattern = (CHAR_T*)bufp->buffer;
-  pend = (CHAR_T*)(bufp->buffer + bufp->used);
-
-#endif /* WCHAR */
-
-  /* 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;
-#ifdef WCHAR
-      mbs_offset2 = mbs_offset1;
-      csize2 = csize1;
-      mbs_offset1 = NULL;
-      csize1 = 0;
-#endif
-    }
-  end1 = string1 + size1;
-  end2 = string2 + size2;
-
-  /* Compute where to stop matching, within the two strings.  */
-#ifdef WCHAR
-  if (stop <= csize1)
-    {
-      mcnt = count_mbs_length(mbs_offset1, stop);
-      end_match_1 = string1 + mcnt;
-      end_match_2 = string2;
-    }
-  else
-    {
-      if (stop > csize1 + csize2)
-	stop = csize1 + csize2;
-      end_match_1 = end1;
-      mcnt = count_mbs_length(mbs_offset2, stop-csize1);
-      end_match_2 = string2 + mcnt;
-    }
-  if (mcnt < 0)
-    { /* count_mbs_length return error.  */
-      FREE_VARIABLES ();
-      return -1;
-    }
-#else
-  if (stop <= size1)
-    {
-      end_match_1 = string1 + stop;
-      end_match_2 = string2;
-    }
-  else
-    {
-      end_match_1 = end1;
-      end_match_2 = string2 + stop - size1;
-    }
-#endif /* WCHAR */
-
-  /* `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'.  */
-#ifdef WCHAR
-  if (size1 > 0 && pos <= csize1)
-    {
-      mcnt = count_mbs_length(mbs_offset1, pos);
-      d = string1 + mcnt;
-      dend = end_match_1;
-    }
-  else
-    {
-      mcnt = count_mbs_length(mbs_offset2, pos-csize1);
-      d = string2 + mcnt;
-      dend = end_match_2;
-    }
-
-  if (mcnt < 0)
-    { /* count_mbs_length return error.  */
-      FREE_VARIABLES ();
-      return -1;
-    }
-#else
-  if (size1 > 0 && pos <= size1)
-    {
-      d = string1 + pos;
-      dend = end_match_1;
-    }
-  else
-    {
-      d = string2 + pos - size1;
-      dend = end_match_2;
-    }
-#endif /* WCHAR */
-
-  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;
-
-	      /* 1 if this match is the best seen so far.  */
-	      boolean best_match_p;
-
-              same_str_p = (FIRST_STRING_P (match_end)
-                            == MATCHING_IN_FIRST_STRING);
-
-	      /* 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;
-#ifdef WCHAR
-		  if (MATCHING_IN_FIRST_STRING)
-		    regs->end[0] = mbs_offset1 != NULL ?
-					mbs_offset1[d-string1] : 0;
-		  else
-		    regs->end[0] = csize1 + (mbs_offset2 != NULL ?
-					     mbs_offset2[d-string2] : 0);
-#else
-                  regs->end[0] = (MATCHING_IN_FIRST_STRING
-				  ? ((regoff_t) (d - string1))
-			          : ((regoff_t) (d - string2 + size1)));
-#endif /* WCHAR */
-                }
-
-              /* 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);
-
-#ifdef WCHAR
-	  if (MATCHING_IN_FIRST_STRING)
-	    mcnt = mbs_offset1 != NULL ? mbs_offset1[d-string1] : 0;
-	  else
-	    mcnt = (mbs_offset2 != NULL ? mbs_offset2[d-string2] : 0) +
-			csize1;
-          mcnt -= pos;
-#else
-          mcnt = d - pos - (MATCHING_IN_FIRST_STRING
-			    ? string1
-			    : string2 - size1);
-#endif /* WCHAR */
-
-          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:
-#ifdef MBS_SUPPORT
-	case exactn_bin:
-#endif
-	  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 ();
-#ifdef WCHAR
-		  if (*d <= 0xff)
-		    {
-		      if ((UCHAR_T) translate[(unsigned char) *d++]
-			  != (UCHAR_T) *p++)
-			goto fail;
-		    }
-		  else
-		    {
-		      if (*d++ != (CHAR_T) *p++)
-			goto fail;
-		    }
-#else
-		  if ((UCHAR_T) translate[(unsigned char) *d++]
-		      != (UCHAR_T) *p++)
-                    goto fail;
-#endif /* WCHAR */
-		}
-	      while (--mcnt);
-	    }
-	  else
-	    {
-	      do
-		{
-		  PREFETCH ();
-		  if (*d++ != (CHAR_T) *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 `%ld'.\n", (long int) *d);
-          d++;
-	  break;
-
-
-	case charset:
-	case charset_not:
-	  {
-	    register UCHAR_T c;
-#ifdef WCHAR
-	    unsigned int i, char_class_length, coll_symbol_length,
-              equiv_class_length, ranges_length, chars_length, length;
-	    CHAR_T *workp, *workp2, *charset_top;
-#define WORK_BUFFER_SIZE 128
-            CHAR_T str_buf[WORK_BUFFER_SIZE];
-# ifdef _LIBC
-	    uint32_t nrules;
-# endif /* _LIBC */
-#endif /* WCHAR */
-	    boolean negate = (re_opcode_t) *(p - 1) == charset_not;
-
-            DEBUG_PRINT2 ("EXECUTING charset%s.\n", negate ? "_not" : "");
-	    PREFETCH ();
-	    c = TRANSLATE (*d); /* The character to match.  */
-#ifdef WCHAR
-# ifdef _LIBC
-	    nrules = _NL_CURRENT_WORD (LC_COLLATE, _NL_COLLATE_NRULES);
-# endif /* _LIBC */
-	    charset_top = p - 1;
-	    char_class_length = *p++;
-	    coll_symbol_length = *p++;
-	    equiv_class_length = *p++;
-	    ranges_length = *p++;
-	    chars_length = *p++;
-	    /* p points charset[6], so the address of the next instruction
-	       (charset[l+m+n+2o+k+p']) equals p[l+m+n+2*o+p'],
-	       where l=length of char_classes, m=length of collating_symbol,
-	       n=equivalence_class, o=length of char_range,
-	       p'=length of character.  */
-	    workp = p;
-	    /* Update p to indicate the next instruction.  */
-	    p += char_class_length + coll_symbol_length+ equiv_class_length +
-              2*ranges_length + chars_length;
-
-            /* match with char_class?  */
-	    for (i = 0; i < char_class_length ; i += CHAR_CLASS_SIZE)
-	      {
-		wctype_t wctype;
-		uintptr_t alignedp = ((uintptr_t)workp
-				      + __alignof__(wctype_t) - 1)
-		  		      & ~(uintptr_t)(__alignof__(wctype_t) - 1);
-		wctype = *((wctype_t*)alignedp);
-		workp += CHAR_CLASS_SIZE;
-# ifdef _LIBC
-		if (__iswctype((wint_t)c, wctype))
-		  goto char_set_matched;
-# else
-		if (iswctype((wint_t)c, wctype))
-		  goto char_set_matched;
-# endif
-	      }
-
-            /* match with collating_symbol?  */
-# ifdef _LIBC
-	    if (nrules != 0)
-	      {
-		const unsigned char *extra = (const unsigned char *)
-		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_SYMB_EXTRAMB);
-
-		for (workp2 = workp + coll_symbol_length ; workp < workp2 ;
-		     workp++)
-		  {
-		    int32_t *wextra;
-		    wextra = (int32_t*)(extra + *workp++);
-		    for (i = 0; i < *wextra; ++i)
-		      if (TRANSLATE(d[i]) != wextra[1 + i])
-			break;
-
-		    if (i == *wextra)
-		      {
-			/* Update d, however d will be incremented at
-			   char_set_matched:, we decrement d here.  */
-			d += i - 1;
-			goto char_set_matched;
-		      }
-		  }
-	      }
-	    else /* (nrules == 0) */
-# endif
-	      /* If we can't look up collation data, we use wcscoll
-		 instead.  */
-	      {
-		for (workp2 = workp + coll_symbol_length ; workp < workp2 ;)
-		  {
-		    const CHAR_T *backup_d = d, *backup_dend = dend;
-# ifdef _LIBC
-		    length = __wcslen (workp);
-# else
-		    length = wcslen (workp);
-# endif
-
-		    /* If wcscoll(the collating symbol, whole string) > 0,
-		       any substring of the string never match with the
-		       collating symbol.  */
-# ifdef _LIBC
-		    if (__wcscoll (workp, d) > 0)
-# else
-		    if (wcscoll (workp, d) > 0)
-# endif
-		      {
-			workp += length + 1;
-			continue;
-		      }
-
-		    /* First, we compare the collating symbol with
-		       the first character of the string.
-		       If it don't match, we add the next character to
-		       the compare buffer in turn.  */
-		    for (i = 0 ; i < WORK_BUFFER_SIZE-1 ; i++, d++)
-		      {
-			int match;
-			if (d == dend)
-			  {
-			    if (dend == end_match_2)
-			      break;
-			    d = string2;
-			    dend = end_match_2;
-			  }
-
-			/* add next character to the compare buffer.  */
-			str_buf[i] = TRANSLATE(*d);
-			str_buf[i+1] = '\0';
-
-# ifdef _LIBC
-			match = __wcscoll (workp, str_buf);
-# else
-			match = wcscoll (workp, str_buf);
-# endif
-			if (match == 0)
-			  goto char_set_matched;
-
-			if (match < 0)
-			  /* (str_buf > workp) indicate (str_buf + X > workp),
-			     because for all X (str_buf + X > str_buf).
-			     So we don't need continue this loop.  */
-			  break;
-
-			/* Otherwise(str_buf < workp),
-			   (str_buf+next_character) may equals (workp).
-			   So we continue this loop.  */
-		      }
-		    /* not matched */
-		    d = backup_d;
-		    dend = backup_dend;
-		    workp += length + 1;
-		  }
-              }
-            /* match with equivalence_class?  */
-# ifdef _LIBC
-	    if (nrules != 0)
-	      {
-                const CHAR_T *backup_d = d, *backup_dend = dend;
-		/* Try to match the equivalence class against
-		   those known to the collate implementation.  */
-		const int32_t *table;
-		const int32_t *weights;
-		const int32_t *extra;
-		const int32_t *indirect;
-		int32_t idx, idx2;
-		wint_t *cp;
-		size_t len;
-
-		/* This #include defines a local function!  */
-#  include <locale/weightwc.h>
-
-		table = (const int32_t *)
-		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_TABLEWC);
-		weights = (const wint_t *)
-		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_WEIGHTWC);
-		extra = (const wint_t *)
-		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_EXTRAWC);
-		indirect = (const int32_t *)
-		  _NL_CURRENT (LC_COLLATE, _NL_COLLATE_INDIRECTWC);
-
-		/* Write 1 collating element to str_buf, and
-		   get its index.  */
-		idx2 = 0;
-
-		for (i = 0 ; idx2 == 0 && i < WORK_BUFFER_SIZE - 1; i++)
-		  {
-		    cp = (wint_t*)str_buf;
-		    if (d == dend)
-		      {
-			if (dend == end_match_2)
-			  break;
-			d = string2;
-			dend = end_match_2;
-		      }
-		    str_buf[i] = TRANSLATE(*(d+i));
-		    str_buf[i+1] = '\0'; /* sentinel */
-		    idx2 = findidx ((const wint_t**)&cp);
-		  }
-
-		/* Update d, however d will be incremented at
-		   char_set_matched:, we decrement d here.  */
-		d = backup_d + ((wchar_t*)cp - (wchar_t*)str_buf - 1);
-		if (d >= dend)
-		  {
-		    if (dend == end_match_2)
-			d = dend;
-		    else
-		      {
-			d = string2;
-			dend = end_match_2;
-		      }
-		  }
-
-		len = weights[idx2];
-
-		for (workp2 = workp + equiv_class_length ; workp < workp2 ;
-		     workp++)
-		  {
-		    idx = (int32_t)*workp;
-		    /* We already checked idx != 0 in regex_compile. */
-
-		    if (idx2 != 0 && len == weights[idx])
-		      {
-			int cnt = 0;
-			while (cnt < len && (weights[idx + 1 + cnt]
-					     == weights[idx2 + 1 + cnt]))
-			  ++cnt;
-
-			if (cnt == len)
-			  goto char_set_matched;
-		      }
-		  }
-		/* not matched */
-                d = backup_d;
-                dend = backup_dend;
-	      }
-	    else /* (nrules == 0) */
-# endif
-	      /* If we can't look up collation data, we use wcscoll
-		 instead.  */
-	      {
-		for (workp2 = workp + equiv_class_length ; workp < workp2 ;)
-		  {
-		    const CHAR_T *backup_d = d, *backup_dend = dend;
-# ifdef _LIBC
-		    length = __wcslen (workp);
-# else
-		    length = wcslen (workp);
-# endif
-
-		    /* If wcscoll(the collating symbol, whole string) > 0,
-		       any substring of the string never match with the
-		       collating symbol.  */
-# ifdef _LIBC
-		    if (__wcscoll (workp, d) > 0)
-# else
-		    if (wcscoll (workp, d) > 0)
-# endif
-		      {
-			workp += length + 1;
-			break;
-		      }
-
-		    /* First, we compare the equivalence class with
-		       the first character of the string.
-		       If it don't match, we add the next character to
-		       the compare buffer in turn.  */
-		    for (i = 0 ; i < WORK_BUFFER_SIZE - 1 ; i++, d++)
-		      {
-			int match;
-			if (d == dend)
-			  {
-			    if (dend == end_match_2)
-			      break;
-			    d = string2;
-			    dend = end_match_2;
-			  }
-
-			/* add next character to the compare buffer.  */
-			str_buf[i] = TRANSLATE(*d);
-			str_buf[i+1] = '\0';
-
-# ifdef _LIBC
-			match = __wcscoll (workp, str_buf);
-# else
-			match = wcscoll (workp, str_buf);
-# endif
-
-			if (match == 0)
-			  goto char_set_matched;
-
-			if (match < 0)
-			/* (str_buf > workp) indicate (str_buf + X > workp),
-			   because for all X (str_buf + X > str_buf).
-			   So we don't need continue this loop.  */
-			  break;
-
-			/* Otherwise(str_buf < workp),
-			   (str_buf+next_character) may equals (workp).
-			   So we continue this loop.  */
-		      }
-		    /* not matched */
-		    d = backup_d;
-		    dend = backup_dend;
-		    workp += length + 1;
-		  }
-	      }
-
-            /* match with char_range?  */
-# ifdef _LIBC
-	    if (nrules != 0)
-	      {
-		uint32_t collseqval;
-		const char *collseq = (const char *)
-		  _NL_CURRENT(LC_COLLATE, _NL_COLLATE_COLLSEQWC);
-
-		collseqval = collseq_table_lookup (collseq, c);
-
-		for (; workp < p - chars_length ;)
-		  {
-		    uint32_t start_val, end_val;
-
-		    /* We already compute the collation sequence value
-		       of the characters (or collating symbols).  */
-		    start_val = (uint32_t) *workp++; /* range_start */
-		    end_val = (uint32_t) *workp++; /* range_end */
-
-		    if (start_val <= collseqval && collseqval <= end_val)
-		      goto char_set_matched;
-		  }
-	      }
-	    else
-# endif
-	      {
-		/* We set range_start_char at str_buf[0], range_end_char
-		   at str_buf[4], and compared char at str_buf[2].  */
-		str_buf[1] = 0;
-		str_buf[2] = c;
-		str_buf[3] = 0;
-		str_buf[5] = 0;
-		for (; workp < p - chars_length ;)
-		  {
-		    wchar_t *range_start_char, *range_end_char;
-
-		    /* match if (range_start_char <= c <= range_end_char).  */
-
-		    /* If range_start(or end) < 0, we assume -range_start(end)
-		       is the offset of the collating symbol which is specified
-		       as the character of the range start(end).  */
-
-		    /* range_start */
-		    if (*workp < 0)
-		      range_start_char = charset_top - (*workp++);
-		    else
-		      {
-			str_buf[0] = *workp++;
-			range_start_char = str_buf;
-		      }
-
-		    /* range_end */
-		    if (*workp < 0)
-		      range_end_char = charset_top - (*workp++);
-		    else
-		      {
-			str_buf[4] = *workp++;
-			range_end_char = str_buf + 4;
-		      }
-
-# ifdef _LIBC
-		    if (__wcscoll (range_start_char, str_buf+2) <= 0
-			&& __wcscoll (str_buf+2, range_end_char) <= 0)
-# else
-		    if (wcscoll (range_start_char, str_buf+2) <= 0
-			&& wcscoll (str_buf+2, range_end_char) <= 0)
-# endif
-		      goto char_set_matched;
-		  }
-	      }
-
-            /* match with char?  */
-	    for (; workp < p ; workp++)
-	      if (c == *workp)
-		goto char_set_matched;
-
-	    negate = !negate;
-
-	  char_set_matched:
-	    if (negate) goto fail;
-#else
-            /* 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)))
-	      negate = !negate;
-
-	    p += 1 + *p;
-
-	    if (!negate) goto fail;
-#undef WORK_BUFFER_SIZE
-#endif /* WCHAR */
-	    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 %ld (%ld):\n",
-			(long int) *p, (long int) 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])
-              = PREFIX(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 %ld (%ld):\n",
-			(long int) *p, (long int) 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.  */
-              UCHAR_T 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 += OFFSET_ADDRESS_SIZE;
-                    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[1+OFFSET_ADDRESS_SIZE] == start_memory
-		  && p1[2+OFFSET_ADDRESS_SIZE] == *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_T *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
-                    ? PREFIX(bcmp_translate) (d, d2, mcnt, translate)
-                    : memcmp (d, d2, mcnt*sizeof(UCHAR_T)))
-		  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 UCHAR_T *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 + 2 + 2 * OFFSET_ADDRESS_SIZE < pend
-			 && (re_opcode_t) *p2 == dummy_failure_jump)
-		  p2 += 2 + 2 * OFFSET_ADDRESS_SIZE;
-		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[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
-		  pop_failure_jump;
-                DEBUG_PRINT1
-                  ("  End of pattern: change to `pop_failure_jump'.\n");
-              }
-
-            else if ((re_opcode_t) *p2 == exactn
-#ifdef MBS_SUPPORT
-		     || (re_opcode_t) *p2 == exactn_bin
-#endif
-		     || (bufp->newline_anchor && (re_opcode_t) *p2 == endline))
-	      {
-		register UCHAR_T c
-                  = *p2 == (UCHAR_T) endline ? '\n' : p2[2];
-
-                if (((re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn
-#ifdef MBS_SUPPORT
-		     || (re_opcode_t) p1[1+OFFSET_ADDRESS_SIZE] == exactn_bin
-#endif
-		    ) && p1[3+OFFSET_ADDRESS_SIZE] != c)
-                  {
-  		    p[-(1+OFFSET_ADDRESS_SIZE)] = (UCHAR_T)
-		      pop_failure_jump;
-#ifdef WCHAR
-		      DEBUG_PRINT3 ("  %C != %C => pop_failure_jump.\n",
-				    (wint_t) c,
-				    (wint_t) p1[3+OFFSET_ADDRESS_SIZE]);
-#else
-		      DEBUG_PRINT3 ("  %c != %c => pop_failure_jump.\n",
-				    (char) c,
-				    (char) p1[3+OFFSET_ADDRESS_SIZE]);
-#endif
-                  }
-
-#ifndef WCHAR
-		else if ((re_opcode_t) p1[3] == charset
-			 || (re_opcode_t) p1[3] == charset_not)
-		  {
-		    int negate = (re_opcode_t) p1[3] == charset_not;
-
-		    if (c < (unsigned) (p1[4] * BYTEWIDTH)
-			&& p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH)))
-		      negate = !negate;
-
-                    /* `negate' is equal to 1 if c would match, which means
-                        that we can't change to pop_failure_jump.  */
-		    if (!negate)
-                      {
-  		        p[-3] = (unsigned char) pop_failure_jump;
-                        DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
-                      }
-		  }
-#endif /* not WCHAR */
-	      }
-#ifndef WCHAR
-            else if ((re_opcode_t) *p2 == charset)
-	      {
-		/* We win if the first character of the loop is not part
-                   of the charset.  */
-                if ((re_opcode_t) p1[3] == exactn
- 		    && ! ((int) p2[1] * BYTEWIDTH > (int) p1[5]
- 			  && (p2[2 + p1[5] / BYTEWIDTH]
- 			      & (1 << (p1[5] % BYTEWIDTH)))))
-		  {
-		    p[-3] = (unsigned char) pop_failure_jump;
-		    DEBUG_PRINT1 ("  No match => pop_failure_jump.\n");
-                  }
-
-		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");
-                      }
-		  }
-	      }
-#endif /* not WCHAR */
-	  }
-	  p -= OFFSET_ADDRESS_SIZE;	/* Point at relative address again.  */
-	  if ((re_opcode_t) p[-1] != pop_failure_jump)
-	    {
-	      p[-1] = (UCHAR_T) 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;
-            UCHAR_T *pdummy ATTRIBUTE_UNUSED = NULL;
-            const CHAR_T *sdummy ATTRIBUTE_UNUSED = NULL;
-
-            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 + OFFSET_ADDRESS_SIZE);
-          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 += OFFSET_ADDRESS_SIZE;
-               STORE_NUMBER_AND_INCR (p, mcnt);
-#ifdef _LIBC
-               DEBUG_PRINT3 ("  Setting %p to %d.\n", p - OFFSET_ADDRESS_SIZE
-			     , mcnt);
-#else
-               DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p - OFFSET_ADDRESS_SIZE
-			     , mcnt);
-#endif
-            }
-	  else if (mcnt == 0)
-            {
-#ifdef _LIBC
-              DEBUG_PRINT2 ("  Setting two bytes from %p to no_op.\n",
-			    p + OFFSET_ADDRESS_SIZE);
-#else
-              DEBUG_PRINT2 ("  Setting two bytes from 0x%x to no_op.\n",
-			    p + OFFSET_ADDRESS_SIZE);
-#endif /* _LIBC */
-
-#ifdef WCHAR
-	      p[1] = (UCHAR_T) no_op;
-#else
-	      p[2] = (UCHAR_T) no_op;
-              p[3] = (UCHAR_T) no_op;
-#endif /* WCHAR */
-              goto on_failure;
-            }
-          break;
-
-        case jump_n:
-          EXTRACT_NUMBER (mcnt, p + OFFSET_ADDRESS_SIZE);
-          DEBUG_PRINT2 ("EXECUTING jump_n %d.\n", mcnt);
-
-          /* Originally, this is how many times we CAN jump.  */
-          if (mcnt)
-            {
-               mcnt--;
-               STORE_NUMBER (p + OFFSET_ADDRESS_SIZE, mcnt);
-
-#ifdef _LIBC
-               DEBUG_PRINT3 ("  Setting %p to %d.\n", p + OFFSET_ADDRESS_SIZE,
-			     mcnt);
-#else
-               DEBUG_PRINT3 ("  Setting 0x%x to %d.\n", p + OFFSET_ADDRESS_SIZE,
-			     mcnt);
-#endif /* _LIBC */
-	       goto unconditional_jump;
-            }
-          /* If don't have to jump any more, skip over the rest of command.  */
-	  else
-	    p += 2 * OFFSET_ADDRESS_SIZE;
-          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 (!AT_STRINGS_END (d) && 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)
-              && (AT_STRINGS_END (d) || !WORDCHAR_P (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
-PREFIX(group_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
-                                   PREFIX(register_info_type) *reg_info)
-{
-  int mcnt;
-  /* Point to after the args to the start_memory.  */
-  UCHAR_T *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-(1+OFFSET_ADDRESS_SIZE)] ==
-		     jump_past_alt)
-                {
-                  /* `mcnt' holds how many bytes long the alternative
-                     is, including the ending `jump_past_alt' and
-                     its number.  */
-
-                  if (!PREFIX(alt_match_null_string_p) (p1, p1 + mcnt -
-						(1 + OFFSET_ADDRESS_SIZE),
-						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-(1+OFFSET_ADDRESS_SIZE)] !=
-		      jump_past_alt)
-                    {
-		      /* Get to the beginning of the n-th alternative.  */
-                      p1 -= 1 + OFFSET_ADDRESS_SIZE;
-                      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 - OFFSET_ADDRESS_SIZE);
-
-              if (!PREFIX(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 (!PREFIX(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
-PREFIX(alt_match_null_string_p) (UCHAR_T *p, UCHAR_T *end,
-                                 PREFIX(register_info_type) *reg_info)
-{
-  int mcnt;
-  UCHAR_T *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 (!PREFIX(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
-PREFIX(common_op_match_null_string_p) (UCHAR_T **p, UCHAR_T *end,
-                                       PREFIX(register_info_type) *reg_info)
-{
-  int mcnt;
-  boolean ret;
-  int reg_no;
-  UCHAR_T *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 = PREFIX(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 += OFFSET_ADDRESS_SIZE;
-      EXTRACT_NUMBER_AND_INCR (mcnt, p1);
-
-      if (mcnt == 0)
-        {
-          p1 -= 2 * OFFSET_ADDRESS_SIZE;
-          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 += 2 * OFFSET_ADDRESS_SIZE;
-
-    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
-PREFIX(bcmp_translate) (const CHAR_T *s1, const CHAR_T *s2, register int len,
-                        RE_TRANSLATE_TYPE translate)
-{
-  register const UCHAR_T *p1 = (const UCHAR_T *) s1;
-  register const UCHAR_T *p2 = (const UCHAR_T *) s2;
-  while (len)
-    {
-#ifdef WCHAR
-      if (((*p1<=0xff)?translate[*p1++]:*p1++)
-	  != ((*p2<=0xff)?translate[*p2++]:*p2++))
-	return 1;
-#else /* BYTE */
-      if (translate[*p1++] != translate[*p2++]) return 1;
-#endif /* WCHAR */
-      len--;
-    }
-  return 0;
-}
-
-
-#else /* not INSIDE_RECURSION */
-
-/* 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 (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;
-
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    ret = wcs_regex_compile (pattern, length, re_syntax_options, bufp);
-  else
-# endif
-    ret = byte_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 (const char *s)
-{
-  reg_errcode_t ret;
-
-  if (!s)
-    {
-      if (!re_comp_buf.buffer)
-	return (char *) 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;
-
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    ret = wcs_regex_compile (s, strlen (s), re_syntax_options, &re_comp_buf);
-  else
-# endif
-    ret = byte_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 (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 (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)
-    {
-      int 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.  */
-# ifdef MBS_SUPPORT
-  if (MB_CUR_MAX != 1)
-    ret = wcs_regex_compile (pattern, strlen (pattern), syntax, preg);
-  else
-# endif
-    ret = byte_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 occurred 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 (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 (int errcode, const regex_t *preg ATTRIBUTE_UNUSED,
-          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 (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  */
-
-#endif /* not INSIDE_RECURSION */
-
-
-#undef STORE_NUMBER
-#undef STORE_NUMBER_AND_INCR
-#undef EXTRACT_NUMBER
-#undef EXTRACT_NUMBER_AND_INCR
-
-#undef DEBUG_PRINT_COMPILED_PATTERN
-#undef DEBUG_PRINT_DOUBLE_STRING
-
-#undef INIT_FAIL_STACK
-#undef RESET_FAIL_STACK
-#undef DOUBLE_FAIL_STACK
-#undef PUSH_PATTERN_OP
-#undef PUSH_FAILURE_POINTER
-#undef PUSH_FAILURE_INT
-#undef PUSH_FAILURE_ELT
-#undef POP_FAILURE_POINTER
-#undef POP_FAILURE_INT
-#undef POP_FAILURE_ELT
-#undef DEBUG_PUSH
-#undef DEBUG_POP
-#undef PUSH_FAILURE_POINT
-#undef POP_FAILURE_POINT
-
-#undef REG_UNSET_VALUE
-#undef REG_UNSET
-
-#undef PATFETCH
-#undef PATFETCH_RAW
-#undef PATUNFETCH
-#undef TRANSLATE
-
-#undef INIT_BUF_SIZE
-#undef GET_BUFFER_SPACE
-#undef BUF_PUSH
-#undef BUF_PUSH_2
-#undef BUF_PUSH_3
-#undef STORE_JUMP
-#undef STORE_JUMP2
-#undef INSERT_JUMP
-#undef INSERT_JUMP2
-#undef EXTEND_BUFFER
-#undef GET_UNSIGNED_NUMBER
-#undef FREE_STACK_RETURN
-
-# undef POINTER_TO_OFFSET
-# undef MATCHING_IN_FRST_STRING
-# undef PREFETCH
-# undef AT_STRINGS_BEG
-# undef AT_STRINGS_END
-# undef WORDCHAR_P
-# undef FREE_VAR
-# undef FREE_VARIABLES
-# undef NO_HIGHEST_ACTIVE_REG
-# undef NO_LOWEST_ACTIVE_REG
-
-# undef CHAR_T
-# undef UCHAR_T
-# undef COMPILED_BUFFER_VAR
-# undef OFFSET_ADDRESS_SIZE
-# undef CHAR_CLASS_SIZE
-# undef PREFIX
-# undef ARG_PREFIX
-# undef PUT_CHAR
-# undef BYTE
-# undef WCHAR
-
-# define DEFINED_ONCE
diff --git a/libiberty/rename.c b/libiberty/rename.c
deleted file mode 100644
index ad342ffca..000000000
--- a/libiberty/rename.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/* rename -- rename a file
-   This function is in the public domain. */
-
-/*
-
-@deftypefn Supplemental int rename (const char *@var{old}, const char *@var{new})
-
-Renames a file from @var{old} to @var{new}.  If @var{new} already
-exists, it is removed.
-
-@end deftypefn
-
-*/
-
-#include "ansidecl.h"
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include <errno.h>
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-int
-rename (const char *zfrom, const char *zto)
-{
-  if (link (zfrom, zto) < 0)
-    {
-      if (errno != EEXIST)
-	return -1;
-      if (unlink (zto) < 0
-	  || link (zfrom, zto) < 0)
-	return -1;
-    }
-  return unlink (zfrom);
-}
diff --git a/libiberty/rindex.c b/libiberty/rindex.c
deleted file mode 100644
index 194ef9fad..000000000
--- a/libiberty/rindex.c
+++ /dev/null
@@ -1,21 +0,0 @@
-/* Stub implementation of (obsolete) rindex(). */
-
-/*
-
-@deftypefn Supplemental char* rindex (const char *@var{s}, int @var{c})
-
-Returns a pointer to the last occurrence of the character @var{c} in
-the string @var{s}, or @code{NULL} if not found.  The use of @code{rindex} is
-deprecated in new programs in favor of @code{strrchr}.
-
-@end deftypefn
-
-*/
-
-extern char *strrchr (const char *, int);
-
-char *
-rindex (const char *s, int c)
-{
-  return strrchr (s, c);
-}
diff --git a/libiberty/setenv.c b/libiberty/setenv.c
deleted file mode 100644
index 96917d576..000000000
--- a/libiberty/setenv.c
+++ /dev/null
@@ -1,185 +0,0 @@
-/* Copyright (C) 1992, 1995, 1996, 1997, 2002, 2011 Free Software Foundation,
-   Inc.
-   This file based on setenv.c in the GNU C Library.
-
-   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., 51 Franklin Street - Fifth Floor,
-   Boston, MA 02110-1301, USA.  */
-
-
-/*
-
-@deftypefn Supplemental int setenv (const char *@var{name}, @
-  const char *@var{value}, int @var{overwrite})
-@deftypefnx Supplemental void unsetenv (const char *@var{name})
-
-@code{setenv} adds @var{name} to the environment with value
-@var{value}.  If the name was already present in the environment,
-the new value will be stored only if @var{overwrite} is nonzero.
-The companion @code{unsetenv} function removes @var{name} from the
-environment.  This implementation is not safe for multithreaded code.
-
-@end deftypefn
-
-*/
-
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-
-#define setenv libiberty_setenv
-#define unsetenv libiberty_unsetenv
-
-#include "ansidecl.h"
-#include <sys/types.h> /* For `size_t' */
-#include <stdio.h>     /* For `NULL' */
-
-#include <errno.h>
-#if !defined(errno) && !defined(HAVE_ERRNO_DECL)
-extern int errno;
-#endif
-#define __set_errno(ev) ((errno) = (ev))
-
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#if HAVE_STRING_H
-# include <string.h>
-#endif
-#if HAVE_UNISTD_H
-# include <unistd.h>
-#endif
-
-#define __environ	environ
-#ifndef HAVE_ENVIRON_DECL
-extern char **environ;
-#endif
-
-#undef setenv
-#undef unsetenv
-
-/* LOCK and UNLOCK are defined as no-ops.  This makes the libiberty
- * implementation MT-Unsafe. */
-#define LOCK
-#define UNLOCK
-
-/* Below this point, it's verbatim code from the glibc-2.0 implementation */
-
-/* If this variable is not a null pointer we allocated the current
-   environment.  */
-static char **last_environ;
-
-
-int
-setenv (const char *name, const char *value, int replace)
-{
-  register char **ep = 0;
-  register size_t size;
-  const size_t namelen = strlen (name);
-  const size_t vallen = strlen (value) + 1;
-
-  LOCK;
-
-  size = 0;
-  if (__environ != NULL)
-    {
-      for (ep = __environ; *ep != NULL; ++ep)
-	if (!strncmp (*ep, name, namelen) && (*ep)[namelen] == '=')
-	  break;
-	else
-	  ++size;
-    }
-
-  if (__environ == NULL || *ep == NULL)
-    {
-      char **new_environ;
-      if (__environ == last_environ && __environ != NULL)
-	/* We allocated this space; we can extend it.  */
-	new_environ = (char **) realloc (last_environ,
-					 (size + 2) * sizeof (char *));
-      else
-	new_environ = (char **) malloc ((size + 2) * sizeof (char *));
-
-      if (new_environ == NULL)
-	{
-	  UNLOCK;
-	  return -1;
-	}
-
-      new_environ[size] = (char *) malloc (namelen + 1 + vallen);
-      if (new_environ[size] == NULL)
-	{
-	  free ((char *) new_environ);
-	  __set_errno (ENOMEM);
-	  UNLOCK;
-	  return -1;
-	}
-
-      if (__environ != last_environ)
-	memcpy ((char *) new_environ, (char *) __environ,
-		size * sizeof (char *));
-
-      memcpy (new_environ[size], name, namelen);
-      new_environ[size][namelen] = '=';
-      memcpy (&new_environ[size][namelen + 1], value, vallen);
-
-      new_environ[size + 1] = NULL;
-
-      last_environ = __environ = new_environ;
-    }
-  else if (replace)
-    {
-      size_t len = strlen (*ep);
-      if (len + 1 < namelen + 1 + vallen)
-	{
-	  /* The existing string is too short; malloc a new one.  */
-	  char *new_string = (char *) malloc (namelen + 1 + vallen);
-	  if (new_string == NULL)
-	    {
-	      UNLOCK;
-	      return -1;
-	    }
-	  *ep = new_string;
-	}
-      memcpy (*ep, name, namelen);
-      (*ep)[namelen] = '=';
-      memcpy (&(*ep)[namelen + 1], value, vallen);
-    }
-
-  UNLOCK;
-
-  return 0;
-}
-
-void
-unsetenv (const char *name)
-{
-  const size_t len = strlen (name);
-  char **ep;
-
-  LOCK;
-
-  for (ep = __environ; *ep; ++ep)
-    if (!strncmp (*ep, name, len) && (*ep)[len] == '=')
-      {
-	/* Found it.  Remove this pointer by moving later ones back.  */
-	char **dp = ep;
-	do
-	  dp[0] = dp[1];
-	while (*dp++);
-	/* Continue the loop in case NAME appears again.  */
-      }
-
-  UNLOCK;
-}
diff --git a/libiberty/snprintf.c b/libiberty/snprintf.c
deleted file mode 100644
index 1e3b03888..000000000
--- a/libiberty/snprintf.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/* Implement the snprintf function.
-   Copyright (C) 2003, 2011 Free Software Foundation, Inc.
-   Written by Kaveh R. Ghazi <ghazi@caip.rutgers.edu>.
-
-This file is part of the libiberty library.  This library 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 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 General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
-
-As a special exception, if you link this library with files
-compiled with a GNU compiler to produce an executable, this does not cause
-the resulting executable to be covered by the GNU General Public License.
-This exception does not however invalidate any other reasons why
-the executable file might be covered by the GNU General Public License. */
-
-/*
-
-@deftypefn Supplemental int snprintf (char *@var{buf}, size_t @var{n}, @
-  const char *@var{format}, ...)
-
-This function is similar to @code{sprintf}, but it will write to
-@var{buf} at most @code{@var{n}-1} bytes of text, followed by a
-terminating null byte, for a total of @var{n} bytes.
-On error the return value is -1, otherwise it returns the number of
-bytes, not including the terminating null byte, that would have been
-written had @var{n} been sufficiently large, regardless of the actual
-value of @var{n}.  Note some pre-C99 system libraries do not implement
-this correctly so users cannot generally rely on the return value if
-the system version of this function is used.
-
-@end deftypefn
-
-*/
-
-#include "ansidecl.h"
-
-#include <stdarg.h>
-#include <stddef.h>
-
-int vsnprintf (char *, size_t, const char *, va_list);
-
-int
-snprintf (char *s, size_t n, const char *format, ...)
-{
-  int result;
-  VA_OPEN (ap, format);
-  VA_FIXEDARG (ap, char *, s);
-  VA_FIXEDARG (ap, size_t, n);
-  VA_FIXEDARG (ap, const char *, format);
-  result = vsnprintf (s, n, format, ap);
-  VA_CLOSE (ap);
-  return result;
-}
diff --git a/libiberty/strcasecmp.c b/libiberty/strcasecmp.c
deleted file mode 100644
index 131d81c2c..000000000
--- a/libiberty/strcasecmp.c
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (c) 1987 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms are permitted
- * provided that this notice is preserved and that due credit is given
- * to the University of California at Berkeley. The name of the University
- * may not be used to endorse or promote products derived from this
- * software without specific written prior permission. This software
- * is provided ``as is'' without express or implied warranty.
- */
-
-/*
-  
-@deftypefn Supplemental int strcasecmp (const char *@var{s1}, const char *@var{s2})
-
-A case-insensitive @code{strcmp}.
-
-@end deftypefn
-
-*/
-
-#if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)strcasecmp.c	5.5 (Berkeley) 11/24/87";
-#endif /* LIBC_SCCS and not lint */
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-/*
- * This array is designed for mapping upper and lower case letter
- * together for a case independent comparison.  The mappings are
- * based upon ascii character sequences.
- */
-typedef unsigned char uc;
-static const unsigned char charmap[] = {
-	(uc)'\000',(uc)'\001',(uc)'\002',(uc)'\003',(uc)'\004',(uc)'\005',(uc)'\006',(uc)'\007',
-	(uc)'\010',(uc)'\011',(uc)'\012',(uc)'\013',(uc)'\014',(uc)'\015',(uc)'\016',(uc)'\017',
-	(uc)'\020',(uc)'\021',(uc)'\022',(uc)'\023',(uc)'\024',(uc)'\025',(uc)'\026',(uc)'\027',
-	(uc)'\030',(uc)'\031',(uc)'\032',(uc)'\033',(uc)'\034',(uc)'\035',(uc)'\036',(uc)'\037',
-	(uc)'\040',(uc)'\041',(uc)'\042',(uc)'\043',(uc)'\044',(uc)'\045',(uc)'\046',(uc)'\047',
-	(uc)'\050',(uc)'\051',(uc)'\052',(uc)'\053',(uc)'\054',(uc)'\055',(uc)'\056',(uc)'\057',
-	(uc)'\060',(uc)'\061',(uc)'\062',(uc)'\063',(uc)'\064',(uc)'\065',(uc)'\066',(uc)'\067',
-	(uc)'\070',(uc)'\071',(uc)'\072',(uc)'\073',(uc)'\074',(uc)'\075',(uc)'\076',(uc)'\077',
-	(uc)'\100',(uc)'\141',(uc)'\142',(uc)'\143',(uc)'\144',(uc)'\145',(uc)'\146',(uc)'\147',
-	(uc)'\150',(uc)'\151',(uc)'\152',(uc)'\153',(uc)'\154',(uc)'\155',(uc)'\156',(uc)'\157',
-	(uc)'\160',(uc)'\161',(uc)'\162',(uc)'\163',(uc)'\164',(uc)'\165',(uc)'\166',(uc)'\167',
-	(uc)'\170',(uc)'\171',(uc)'\172',(uc)'\133',(uc)'\134',(uc)'\135',(uc)'\136',(uc)'\137',
-	(uc)'\140',(uc)'\141',(uc)'\142',(uc)'\143',(uc)'\144',(uc)'\145',(uc)'\146',(uc)'\147',
-	(uc)'\150',(uc)'\151',(uc)'\152',(uc)'\153',(uc)'\154',(uc)'\155',(uc)'\156',(uc)'\157',
-	(uc)'\160',(uc)'\161',(uc)'\162',(uc)'\163',(uc)'\164',(uc)'\165',(uc)'\166',(uc)'\167',
-	(uc)'\170',(uc)'\171',(uc)'\172',(uc)'\173',(uc)'\174',(uc)'\175',(uc)'\176',(uc)'\177',
-	(uc)'\200',(uc)'\201',(uc)'\202',(uc)'\203',(uc)'\204',(uc)'\205',(uc)'\206',(uc)'\207',
-	(uc)'\210',(uc)'\211',(uc)'\212',(uc)'\213',(uc)'\214',(uc)'\215',(uc)'\216',(uc)'\217',
-	(uc)'\220',(uc)'\221',(uc)'\222',(uc)'\223',(uc)'\224',(uc)'\225',(uc)'\226',(uc)'\227',
-	(uc)'\230',(uc)'\231',(uc)'\232',(uc)'\233',(uc)'\234',(uc)'\235',(uc)'\236',(uc)'\237',
-	(uc)'\240',(uc)'\241',(uc)'\242',(uc)'\243',(uc)'\244',(uc)'\245',(uc)'\246',(uc)'\247',
-	(uc)'\250',(uc)'\251',(uc)'\252',(uc)'\253',(uc)'\254',(uc)'\255',(uc)'\256',(uc)'\257',
-	(uc)'\260',(uc)'\261',(uc)'\262',(uc)'\263',(uc)'\264',(uc)'\265',(uc)'\266',(uc)'\267',
-	(uc)'\270',(uc)'\271',(uc)'\272',(uc)'\273',(uc)'\274',(uc)'\275',(uc)'\276',(uc)'\277',
-	(uc)'\300',(uc)'\341',(uc)'\342',(uc)'\343',(uc)'\344',(uc)'\345',(uc)'\346',(uc)'\347',
-	(uc)'\350',(uc)'\351',(uc)'\352',(uc)'\353',(uc)'\354',(uc)'\355',(uc)'\356',(uc)'\357',
-	(uc)'\360',(uc)'\361',(uc)'\362',(uc)'\363',(uc)'\364',(uc)'\365',(uc)'\366',(uc)'\367',
-	(uc)'\370',(uc)'\371',(uc)'\372',(uc)'\333',(uc)'\334',(uc)'\335',(uc)'\336',(uc)'\337',
-	(uc)'\340',(uc)'\341',(uc)'\342',(uc)'\343',(uc)'\344',(uc)'\345',(uc)'\346',(uc)'\347',
-	(uc)'\350',(uc)'\351',(uc)'\352',(uc)'\353',(uc)'\354',(uc)'\355',(uc)'\356',(uc)'\357',
-	(uc)'\360',(uc)'\361',(uc)'\362',(uc)'\363',(uc)'\364',(uc)'\365',(uc)'\366',(uc)'\367',
-	(uc)'\370',(uc)'\371',(uc)'\372',(uc)'\373',(uc)'\374',(uc)'\375',(uc)'\376',(uc)'\377',
-};
-
-int
-strcasecmp(const char *s1, const char *s2)
-{
-    register unsigned char u1, u2;
-
-    for (;;) {
-	u1 = (unsigned char) *s1++;
-	u2 = (unsigned char) *s2++;
-	if (charmap[u1] != charmap[u2]) {
-	    return charmap[u1] - charmap[u2];
-	}
-	if (u1 == '\0') {
-	    return 0;
-	}
-    }
-}
-
diff --git a/libiberty/strchr.c b/libiberty/strchr.c
deleted file mode 100644
index 935805ef4..000000000
--- a/libiberty/strchr.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/* Portable version of strchr()
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental char* strchr (const char *@var{s}, int @var{c})
-
-Returns a pointer to the first occurrence of the character @var{c} in
-the string @var{s}, or @code{NULL} if not found.  If @var{c} is itself the
-null character, the results are undefined.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-
-char *
-strchr (register const char *s, int c)
-{
-  do {
-    if (*s == c)
-      {
-	return (char*)s;
-      }
-  } while (*s++);
-  return (0);
-}
diff --git a/libiberty/strerror.c b/libiberty/strerror.c
deleted file mode 100644
index 0efadc3d6..000000000
--- a/libiberty/strerror.c
+++ /dev/null
@@ -1,809 +0,0 @@
-/* Extended support for using errno values.
-   Written by Fred Fish.  fnf@cygnus.com
-   This file is in the public domain.  --Per Bothner.  */
-
-#include "config.h"
-
-#ifdef HAVE_SYS_ERRLIST
-/* Note that errno.h (not sure what OS) or stdio.h (BSD 4.4, at least)
-   might declare sys_errlist in a way that the compiler might consider
-   incompatible with our later declaration, perhaps by using const
-   attributes.  So we hide the declaration in errno.h (if any) using a
-   macro. */
-#define sys_nerr sys_nerr__
-#define sys_errlist sys_errlist__
-#endif
-
-#include "ansidecl.h"
-#include "libiberty.h"
-
-#include <stdio.h>
-#include <errno.h>
-
-#ifdef HAVE_SYS_ERRLIST
-#undef sys_nerr
-#undef sys_errlist
-#endif
-
-/*  Routines imported from standard C runtime libraries. */
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#else
-extern PTR malloc ();
-#endif
-
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-extern PTR memset ();
-#endif
-
-#ifndef MAX
-#  define MAX(a,b) ((a) > (b) ? (a) : (b))
-#endif
-
-static void init_error_tables (void);
-
-/* Translation table for errno values.  See intro(2) in most UNIX systems
-   Programmers Reference Manuals.
-
-   Note that this table is generally only accessed when it is used at runtime
-   to initialize errno name and message tables that are indexed by errno
-   value.
-
-   Not all of these errnos will exist on all systems.  This table is the only
-   thing that should have to be updated as new error numbers are introduced.
-   It's sort of ugly, but at least its portable. */
-
-struct error_info
-{
-  const int value;		/* The numeric value from <errno.h> */
-  const char *const name;	/* The equivalent symbolic value */
-#ifndef HAVE_SYS_ERRLIST
-  const char *const msg;	/* Short message about this value */
-#endif
-};
-
-#ifndef HAVE_SYS_ERRLIST
-#   define ENTRY(value, name, msg)	{value, name, msg}
-#else
-#   define ENTRY(value, name, msg)	{value, name}
-#endif
-
-static const struct error_info error_table[] =
-{
-#if defined (EPERM)
-  ENTRY(EPERM, "EPERM", "Not owner"),
-#endif
-#if defined (ENOENT)
-  ENTRY(ENOENT, "ENOENT", "No such file or directory"),
-#endif
-#if defined (ESRCH)
-  ENTRY(ESRCH, "ESRCH", "No such process"),
-#endif
-#if defined (EINTR)
-  ENTRY(EINTR, "EINTR", "Interrupted system call"),
-#endif
-#if defined (EIO)
-  ENTRY(EIO, "EIO", "I/O error"),
-#endif
-#if defined (ENXIO)
-  ENTRY(ENXIO, "ENXIO", "No such device or address"),
-#endif
-#if defined (E2BIG)
-  ENTRY(E2BIG, "E2BIG", "Arg list too long"),
-#endif
-#if defined (ENOEXEC)
-  ENTRY(ENOEXEC, "ENOEXEC", "Exec format error"),
-#endif
-#if defined (EBADF)
-  ENTRY(EBADF, "EBADF", "Bad file number"),
-#endif
-#if defined (ECHILD)
-  ENTRY(ECHILD, "ECHILD", "No child processes"),
-#endif
-#if defined (EWOULDBLOCK)	/* Put before EAGAIN, sometimes aliased */
-  ENTRY(EWOULDBLOCK, "EWOULDBLOCK", "Operation would block"),
-#endif
-#if defined (EAGAIN)
-  ENTRY(EAGAIN, "EAGAIN", "No more processes"),
-#endif
-#if defined (ENOMEM)
-  ENTRY(ENOMEM, "ENOMEM", "Not enough space"),
-#endif
-#if defined (EACCES)
-  ENTRY(EACCES, "EACCES", "Permission denied"),
-#endif
-#if defined (EFAULT)
-  ENTRY(EFAULT, "EFAULT", "Bad address"),
-#endif
-#if defined (ENOTBLK)
-  ENTRY(ENOTBLK, "ENOTBLK", "Block device required"),
-#endif
-#if defined (EBUSY)
-  ENTRY(EBUSY, "EBUSY", "Device busy"),
-#endif
-#if defined (EEXIST)
-  ENTRY(EEXIST, "EEXIST", "File exists"),
-#endif
-#if defined (EXDEV)
-  ENTRY(EXDEV, "EXDEV", "Cross-device link"),
-#endif
-#if defined (ENODEV)
-  ENTRY(ENODEV, "ENODEV", "No such device"),
-#endif
-#if defined (ENOTDIR)
-  ENTRY(ENOTDIR, "ENOTDIR", "Not a directory"),
-#endif
-#if defined (EISDIR)
-  ENTRY(EISDIR, "EISDIR", "Is a directory"),
-#endif
-#if defined (EINVAL)
-  ENTRY(EINVAL, "EINVAL", "Invalid argument"),
-#endif
-#if defined (ENFILE)
-  ENTRY(ENFILE, "ENFILE", "File table overflow"),
-#endif
-#if defined (EMFILE)
-  ENTRY(EMFILE, "EMFILE", "Too many open files"),
-#endif
-#if defined (ENOTTY)
-  ENTRY(ENOTTY, "ENOTTY", "Not a typewriter"),
-#endif
-#if defined (ETXTBSY)
-  ENTRY(ETXTBSY, "ETXTBSY", "Text file busy"),
-#endif
-#if defined (EFBIG)
-  ENTRY(EFBIG, "EFBIG", "File too large"),
-#endif
-#if defined (ENOSPC)
-  ENTRY(ENOSPC, "ENOSPC", "No space left on device"),
-#endif
-#if defined (ESPIPE)
-  ENTRY(ESPIPE, "ESPIPE", "Illegal seek"),
-#endif
-#if defined (EROFS)
-  ENTRY(EROFS, "EROFS", "Read-only file system"),
-#endif
-#if defined (EMLINK)
-  ENTRY(EMLINK, "EMLINK", "Too many links"),
-#endif
-#if defined (EPIPE)
-  ENTRY(EPIPE, "EPIPE", "Broken pipe"),
-#endif
-#if defined (EDOM)
-  ENTRY(EDOM, "EDOM", "Math argument out of domain of func"),
-#endif
-#if defined (ERANGE)
-  ENTRY(ERANGE, "ERANGE", "Math result not representable"),
-#endif
-#if defined (ENOMSG)
-  ENTRY(ENOMSG, "ENOMSG", "No message of desired type"),
-#endif
-#if defined (EIDRM)
-  ENTRY(EIDRM, "EIDRM", "Identifier removed"),
-#endif
-#if defined (ECHRNG)
-  ENTRY(ECHRNG, "ECHRNG", "Channel number out of range"),
-#endif
-#if defined (EL2NSYNC)
-  ENTRY(EL2NSYNC, "EL2NSYNC", "Level 2 not synchronized"),
-#endif
-#if defined (EL3HLT)
-  ENTRY(EL3HLT, "EL3HLT", "Level 3 halted"),
-#endif
-#if defined (EL3RST)
-  ENTRY(EL3RST, "EL3RST", "Level 3 reset"),
-#endif
-#if defined (ELNRNG)
-  ENTRY(ELNRNG, "ELNRNG", "Link number out of range"),
-#endif
-#if defined (EUNATCH)
-  ENTRY(EUNATCH, "EUNATCH", "Protocol driver not attached"),
-#endif
-#if defined (ENOCSI)
-  ENTRY(ENOCSI, "ENOCSI", "No CSI structure available"),
-#endif
-#if defined (EL2HLT)
-  ENTRY(EL2HLT, "EL2HLT", "Level 2 halted"),
-#endif
-#if defined (EDEADLK)
-  ENTRY(EDEADLK, "EDEADLK", "Deadlock condition"),
-#endif
-#if defined (ENOLCK)
-  ENTRY(ENOLCK, "ENOLCK", "No record locks available"),
-#endif
-#if defined (EBADE)
-  ENTRY(EBADE, "EBADE", "Invalid exchange"),
-#endif
-#if defined (EBADR)
-  ENTRY(EBADR, "EBADR", "Invalid request descriptor"),
-#endif
-#if defined (EXFULL)
-  ENTRY(EXFULL, "EXFULL", "Exchange full"),
-#endif
-#if defined (ENOANO)
-  ENTRY(ENOANO, "ENOANO", "No anode"),
-#endif
-#if defined (EBADRQC)
-  ENTRY(EBADRQC, "EBADRQC", "Invalid request code"),
-#endif
-#if defined (EBADSLT)
-  ENTRY(EBADSLT, "EBADSLT", "Invalid slot"),
-#endif
-#if defined (EDEADLOCK)
-  ENTRY(EDEADLOCK, "EDEADLOCK", "File locking deadlock error"),
-#endif
-#if defined (EBFONT)
-  ENTRY(EBFONT, "EBFONT", "Bad font file format"),
-#endif
-#if defined (ENOSTR)
-  ENTRY(ENOSTR, "ENOSTR", "Device not a stream"),
-#endif
-#if defined (ENODATA)
-  ENTRY(ENODATA, "ENODATA", "No data available"),
-#endif
-#if defined (ETIME)
-  ENTRY(ETIME, "ETIME", "Timer expired"),
-#endif
-#if defined (ENOSR)
-  ENTRY(ENOSR, "ENOSR", "Out of streams resources"),
-#endif
-#if defined (ENONET)
-  ENTRY(ENONET, "ENONET", "Machine is not on the network"),
-#endif
-#if defined (ENOPKG)
-  ENTRY(ENOPKG, "ENOPKG", "Package not installed"),
-#endif
-#if defined (EREMOTE)
-  ENTRY(EREMOTE, "EREMOTE", "Object is remote"),
-#endif
-#if defined (ENOLINK)
-  ENTRY(ENOLINK, "ENOLINK", "Link has been severed"),
-#endif
-#if defined (EADV)
-  ENTRY(EADV, "EADV", "Advertise error"),
-#endif
-#if defined (ESRMNT)
-  ENTRY(ESRMNT, "ESRMNT", "Srmount error"),
-#endif
-#if defined (ECOMM)
-  ENTRY(ECOMM, "ECOMM", "Communication error on send"),
-#endif
-#if defined (EPROTO)
-  ENTRY(EPROTO, "EPROTO", "Protocol error"),
-#endif
-#if defined (EMULTIHOP)
-  ENTRY(EMULTIHOP, "EMULTIHOP", "Multihop attempted"),
-#endif
-#if defined (EDOTDOT)
-  ENTRY(EDOTDOT, "EDOTDOT", "RFS specific error"),
-#endif
-#if defined (EBADMSG)
-  ENTRY(EBADMSG, "EBADMSG", "Not a data message"),
-#endif
-#if defined (ENAMETOOLONG)
-  ENTRY(ENAMETOOLONG, "ENAMETOOLONG", "File name too long"),
-#endif
-#if defined (EOVERFLOW)
-  ENTRY(EOVERFLOW, "EOVERFLOW", "Value too large for defined data type"),
-#endif
-#if defined (ENOTUNIQ)
-  ENTRY(ENOTUNIQ, "ENOTUNIQ", "Name not unique on network"),
-#endif
-#if defined (EBADFD)
-  ENTRY(EBADFD, "EBADFD", "File descriptor in bad state"),
-#endif
-#if defined (EREMCHG)
-  ENTRY(EREMCHG, "EREMCHG", "Remote address changed"),
-#endif
-#if defined (ELIBACC)
-  ENTRY(ELIBACC, "ELIBACC", "Can not access a needed shared library"),
-#endif
-#if defined (ELIBBAD)
-  ENTRY(ELIBBAD, "ELIBBAD", "Accessing a corrupted shared library"),
-#endif
-#if defined (ELIBSCN)
-  ENTRY(ELIBSCN, "ELIBSCN", ".lib section in a.out corrupted"),
-#endif
-#if defined (ELIBMAX)
-  ENTRY(ELIBMAX, "ELIBMAX", "Attempting to link in too many shared libraries"),
-#endif
-#if defined (ELIBEXEC)
-  ENTRY(ELIBEXEC, "ELIBEXEC", "Cannot exec a shared library directly"),
-#endif
-#if defined (EILSEQ)
-  ENTRY(EILSEQ, "EILSEQ", "Illegal byte sequence"),
-#endif
-#if defined (ENOSYS)
-  ENTRY(ENOSYS, "ENOSYS", "Operation not applicable"),
-#endif
-#if defined (ELOOP)
-  ENTRY(ELOOP, "ELOOP", "Too many symbolic links encountered"),
-#endif
-#if defined (ERESTART)
-  ENTRY(ERESTART, "ERESTART", "Interrupted system call should be restarted"),
-#endif
-#if defined (ESTRPIPE)
-  ENTRY(ESTRPIPE, "ESTRPIPE", "Streams pipe error"),
-#endif
-#if defined (ENOTEMPTY)
-  ENTRY(ENOTEMPTY, "ENOTEMPTY", "Directory not empty"),
-#endif
-#if defined (EUSERS)
-  ENTRY(EUSERS, "EUSERS", "Too many users"),
-#endif
-#if defined (ENOTSOCK)
-  ENTRY(ENOTSOCK, "ENOTSOCK", "Socket operation on non-socket"),
-#endif
-#if defined (EDESTADDRREQ)
-  ENTRY(EDESTADDRREQ, "EDESTADDRREQ", "Destination address required"),
-#endif
-#if defined (EMSGSIZE)
-  ENTRY(EMSGSIZE, "EMSGSIZE", "Message too long"),
-#endif
-#if defined (EPROTOTYPE)
-  ENTRY(EPROTOTYPE, "EPROTOTYPE", "Protocol wrong type for socket"),
-#endif
-#if defined (ENOPROTOOPT)
-  ENTRY(ENOPROTOOPT, "ENOPROTOOPT", "Protocol not available"),
-#endif
-#if defined (EPROTONOSUPPORT)
-  ENTRY(EPROTONOSUPPORT, "EPROTONOSUPPORT", "Protocol not supported"),
-#endif
-#if defined (ESOCKTNOSUPPORT)
-  ENTRY(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT", "Socket type not supported"),
-#endif
-#if defined (EOPNOTSUPP)
-  ENTRY(EOPNOTSUPP, "EOPNOTSUPP", "Operation not supported on transport endpoint"),
-#endif
-#if defined (EPFNOSUPPORT)
-  ENTRY(EPFNOSUPPORT, "EPFNOSUPPORT", "Protocol family not supported"),
-#endif
-#if defined (EAFNOSUPPORT)
-  ENTRY(EAFNOSUPPORT, "EAFNOSUPPORT", "Address family not supported by protocol"),
-#endif
-#if defined (EADDRINUSE)
-  ENTRY(EADDRINUSE, "EADDRINUSE", "Address already in use"),
-#endif
-#if defined (EADDRNOTAVAIL)
-  ENTRY(EADDRNOTAVAIL, "EADDRNOTAVAIL","Cannot assign requested address"),
-#endif
-#if defined (ENETDOWN)
-  ENTRY(ENETDOWN, "ENETDOWN", "Network is down"),
-#endif
-#if defined (ENETUNREACH)
-  ENTRY(ENETUNREACH, "ENETUNREACH", "Network is unreachable"),
-#endif
-#if defined (ENETRESET)
-  ENTRY(ENETRESET, "ENETRESET", "Network dropped connection because of reset"),
-#endif
-#if defined (ECONNABORTED)
-  ENTRY(ECONNABORTED, "ECONNABORTED", "Software caused connection abort"),
-#endif
-#if defined (ECONNRESET)
-  ENTRY(ECONNRESET, "ECONNRESET", "Connection reset by peer"),
-#endif
-#if defined (ENOBUFS)
-  ENTRY(ENOBUFS, "ENOBUFS", "No buffer space available"),
-#endif
-#if defined (EISCONN)
-  ENTRY(EISCONN, "EISCONN", "Transport endpoint is already connected"),
-#endif
-#if defined (ENOTCONN)
-  ENTRY(ENOTCONN, "ENOTCONN", "Transport endpoint is not connected"),
-#endif
-#if defined (ESHUTDOWN)
-  ENTRY(ESHUTDOWN, "ESHUTDOWN", "Cannot send after transport endpoint shutdown"),
-#endif
-#if defined (ETOOMANYREFS)
-  ENTRY(ETOOMANYREFS, "ETOOMANYREFS", "Too many references: cannot splice"),
-#endif
-#if defined (ETIMEDOUT)
-  ENTRY(ETIMEDOUT, "ETIMEDOUT", "Connection timed out"),
-#endif
-#if defined (ECONNREFUSED)
-  ENTRY(ECONNREFUSED, "ECONNREFUSED", "Connection refused"),
-#endif
-#if defined (EHOSTDOWN)
-  ENTRY(EHOSTDOWN, "EHOSTDOWN", "Host is down"),
-#endif
-#if defined (EHOSTUNREACH)
-  ENTRY(EHOSTUNREACH, "EHOSTUNREACH", "No route to host"),
-#endif
-#if defined (EALREADY)
-  ENTRY(EALREADY, "EALREADY", "Operation already in progress"),
-#endif
-#if defined (EINPROGRESS)
-  ENTRY(EINPROGRESS, "EINPROGRESS", "Operation now in progress"),
-#endif
-#if defined (ESTALE)
-  ENTRY(ESTALE, "ESTALE", "Stale NFS file handle"),
-#endif
-#if defined (EUCLEAN)
-  ENTRY(EUCLEAN, "EUCLEAN", "Structure needs cleaning"),
-#endif
-#if defined (ENOTNAM)
-  ENTRY(ENOTNAM, "ENOTNAM", "Not a XENIX named type file"),
-#endif
-#if defined (ENAVAIL)
-  ENTRY(ENAVAIL, "ENAVAIL", "No XENIX semaphores available"),
-#endif
-#if defined (EISNAM)
-  ENTRY(EISNAM, "EISNAM", "Is a named type file"),
-#endif
-#if defined (EREMOTEIO)
-  ENTRY(EREMOTEIO, "EREMOTEIO", "Remote I/O error"),
-#endif
-  ENTRY(0, NULL, NULL)
-};
-
-#ifdef EVMSERR
-/* This is not in the table, because the numeric value of EVMSERR (32767)
-   lies outside the range of sys_errlist[].  */
-static struct { int value; const char *name, *msg; }
-  evmserr = { EVMSERR, "EVMSERR", "VMS-specific error" };
-#endif
-
-/* Translation table allocated and initialized at runtime.  Indexed by the
-   errno value to find the equivalent symbolic value. */
-
-static const char **error_names;
-static int num_error_names = 0;
-
-/* Translation table allocated and initialized at runtime, if it does not
-   already exist in the host environment.  Indexed by the errno value to find
-   the descriptive string.
-
-   We don't export it for use in other modules because even though it has the
-   same name, it differs from other implementations in that it is dynamically
-   initialized rather than statically initialized. */
-
-#ifndef HAVE_SYS_ERRLIST
-
-#define sys_nerr sys_nerr__
-#define sys_errlist sys_errlist__
-static int sys_nerr;
-static const char **sys_errlist;
-
-#else
-
-extern int sys_nerr;
-extern char *sys_errlist[];
-
-#endif
-
-/*
-
-NAME
-
-	init_error_tables -- initialize the name and message tables
-
-SYNOPSIS
-
-	static void init_error_tables ();
-
-DESCRIPTION
-
-	Using the error_table, which is initialized at compile time, generate
-	the error_names and the sys_errlist (if needed) tables, which are
-	indexed at runtime by a specific errno value.
-
-BUGS
-
-	The initialization of the tables may fail under low memory conditions,
-	in which case we don't do anything particularly useful, but we don't
-	bomb either.  Who knows, it might succeed at a later point if we free
-	some memory in the meantime.  In any case, the other routines know
-	how to deal with lack of a table after trying to initialize it.  This
-	may or may not be considered to be a bug, that we don't specifically
-	warn about this particular failure mode.
-
-*/
-
-static void
-init_error_tables (void)
-{
-  const struct error_info *eip;
-  int nbytes;
-
-  /* If we haven't already scanned the error_table once to find the maximum
-     errno value, then go find it now. */
-
-  if (num_error_names == 0)
-    {
-      for (eip = error_table; eip -> name != NULL; eip++)
-	{
-	  if (eip -> value >= num_error_names)
-	    {
-	      num_error_names = eip -> value + 1;
-	    }
-	}
-    }
-
-  /* Now attempt to allocate the error_names table, zero it out, and then
-     initialize it from the statically initialized error_table. */
-
-  if (error_names == NULL)
-    {
-      nbytes = num_error_names * sizeof (char *);
-      if ((error_names = (const char **) malloc (nbytes)) != NULL)
-	{
-	  memset (error_names, 0, nbytes);
-	  for (eip = error_table; eip -> name != NULL; eip++)
-	    {
-	      error_names[eip -> value] = eip -> name;
-	    }
-	}
-    }
-
-#ifndef HAVE_SYS_ERRLIST
-
-  /* Now attempt to allocate the sys_errlist table, zero it out, and then
-     initialize it from the statically initialized error_table. */
-
-  if (sys_errlist == NULL)
-    {
-      nbytes = num_error_names * sizeof (char *);
-      if ((sys_errlist = (const char **) malloc (nbytes)) != NULL)
-	{
-	  memset (sys_errlist, 0, nbytes);
-	  sys_nerr = num_error_names;
-	  for (eip = error_table; eip -> name != NULL; eip++)
-	    {
-	      sys_errlist[eip -> value] = eip -> msg;
-	    }
-	}
-    }
-
-#endif
-
-}
-
-/*
-
-
-@deftypefn Extension int errno_max (void)
-
-Returns the maximum @code{errno} value for which a corresponding
-symbolic name or message is available.  Note that in the case where we
-use the @code{sys_errlist} supplied by the system, it is possible for
-there to be more symbolic names than messages, or vice versa.  In
-fact, the manual page for @code{perror(3C)} explicitly warns that one
-should check the size of the table (@code{sys_nerr}) before indexing
-it, since new error codes may be added to the system before they are
-added to the table.  Thus @code{sys_nerr} might be smaller than value
-implied by the largest @code{errno} value defined in @code{<errno.h>}.
-
-We return the maximum value that can be used to obtain a meaningful
-symbolic name or message.
-
-@end deftypefn
-
-*/
-
-int
-errno_max (void)
-{
-  int maxsize;
-
-  if (error_names == NULL)
-    {
-      init_error_tables ();
-    }
-  maxsize = MAX (sys_nerr, num_error_names);
-  return (maxsize - 1);
-}
-
-#ifndef HAVE_STRERROR
-
-/*
-
-@deftypefn Supplemental char* strerror (int @var{errnoval})
-
-Maps an @code{errno} number to an error message string, the contents
-of which are implementation defined.  On systems which have the
-external variables @code{sys_nerr} and @code{sys_errlist}, these
-strings will be the same as the ones used by @code{perror}.
-
-If the supplied error number is within the valid range of indices for
-the @code{sys_errlist}, but no message is available for the particular
-error number, then returns the string @samp{Error @var{num}}, where
-@var{num} is the error number.
-
-If the supplied error number is not a valid index into
-@code{sys_errlist}, returns @code{NULL}.
-
-The returned string is only guaranteed to be valid only until the
-next call to @code{strerror}.
-
-@end deftypefn
-
-*/
-
-char *
-strerror (int errnoval)
-{
-  const char *msg;
-  static char buf[32];
-
-#ifndef HAVE_SYS_ERRLIST
-
-  if (error_names == NULL)
-    {
-      init_error_tables ();
-    }
-
-#endif
-
-  if ((errnoval < 0) || (errnoval >= sys_nerr))
-    {
-#ifdef EVMSERR
-      if (errnoval == evmserr.value)
-	msg = evmserr.msg;
-      else
-#endif
-      /* Out of range, just return NULL */
-      msg = NULL;
-    }
-  else if ((sys_errlist == NULL) || (sys_errlist[errnoval] == NULL))
-    {
-      /* In range, but no sys_errlist or no entry at this index. */
-      sprintf (buf, "Error %d", errnoval);
-      msg = buf;
-    }
-  else
-    {
-      /* In range, and a valid message.  Just return the message. */
-      msg = (char *) sys_errlist[errnoval];
-    }
-  
-  return (msg);
-}
-
-#endif	/* ! HAVE_STRERROR */
-
-
-/*
-
-@deftypefn Replacement {const char*} strerrno (int @var{errnum})
-
-Given an error number returned from a system call (typically returned
-in @code{errno}), returns a pointer to a string containing the
-symbolic name of that error number, as found in @code{<errno.h>}.
-
-If the supplied error number is within the valid range of indices for
-symbolic names, but no name is available for the particular error
-number, then returns the string @samp{Error @var{num}}, where @var{num}
-is the error number.
-
-If the supplied error number is not within the range of valid
-indices, then returns @code{NULL}.
-
-The contents of the location pointed to are only guaranteed to be
-valid until the next call to @code{strerrno}.
-
-@end deftypefn
-
-*/
-
-const char *
-strerrno (int errnoval)
-{
-  const char *name;
-  static char buf[32];
-
-  if (error_names == NULL)
-    {
-      init_error_tables ();
-    }
-
-  if ((errnoval < 0) || (errnoval >= num_error_names))
-    {
-#ifdef EVMSERR
-      if (errnoval == evmserr.value)
-	name = evmserr.name;
-      else
-#endif
-      /* Out of range, just return NULL */
-      name = NULL;
-    }
-  else if ((error_names == NULL) || (error_names[errnoval] == NULL))
-    {
-      /* In range, but no error_names or no entry at this index. */
-      sprintf (buf, "Error %d", errnoval);
-      name = (const char *) buf;
-    }
-  else
-    {
-      /* In range, and a valid name.  Just return the name. */
-      name = error_names[errnoval];
-    }
-
-  return (name);
-}
-
-/*
-
-@deftypefn Extension int strtoerrno (const char *@var{name})
-
-Given the symbolic name of a error number (e.g., @code{EACCES}), map it
-to an errno value.  If no translation is found, returns 0.
-
-@end deftypefn
-
-*/
-
-int
-strtoerrno (const char *name)
-{
-  int errnoval = 0;
-
-  if (name != NULL)
-    {
-      if (error_names == NULL)
-	{
-	  init_error_tables ();
-	}
-      for (errnoval = 0; errnoval < num_error_names; errnoval++)
-	{
-	  if ((error_names[errnoval] != NULL) &&
-	      (strcmp (name, error_names[errnoval]) == 0))
-	    {
-	      break;
-	    }
-	}
-      if (errnoval == num_error_names)
-	{
-#ifdef EVMSERR
-	  if (strcmp (name, evmserr.name) == 0)
-	    errnoval = evmserr.value;
-	  else
-#endif
-	  errnoval = 0;
-	}
-    }
-  return (errnoval);
-}
-
-
-/* A simple little main that does nothing but print all the errno translations
-   if MAIN is defined and this file is compiled and linked. */
-
-#ifdef MAIN
-
-#include <stdio.h>
-
-int
-main (void)
-{
-  int errn;
-  int errnmax;
-  const char *name;
-  const char *msg;
-  char *strerror ();
-
-  errnmax = errno_max ();
-  printf ("%d entries in names table.\n", num_error_names);
-  printf ("%d entries in messages table.\n", sys_nerr);
-  printf ("%d is max useful index.\n", errnmax);
-
-  /* Keep printing values until we get to the end of *both* tables, not
-     *either* table.  Note that knowing the maximum useful index does *not*
-     relieve us of the responsibility of testing the return pointer for
-     NULL. */
-
-  for (errn = 0; errn <= errnmax; errn++)
-    {
-      name = strerrno (errn);
-      name = (name == NULL) ? "<NULL>" : name;
-      msg = strerror (errn);
-      msg = (msg == NULL) ? "<NULL>" : msg;
-      printf ("%-4d%-18s%s\n", errn, name, msg);
-    }
-
-  return 0;
-}
-
-#endif
diff --git a/libiberty/strncasecmp.c b/libiberty/strncasecmp.c
deleted file mode 100644
index 47700dde5..000000000
--- a/libiberty/strncasecmp.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * Copyright (c) 1987 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms are permitted
- * provided that this notice is preserved and that due credit is given
- * to the University of California at Berkeley. The name of the University
- * may not be used to endorse or promote products derived from this
- * software without specific written prior permission. This software
- * is provided ``as is'' without express or implied warranty.
- */
-
-/*
-  
-@deftypefn Supplemental int strncasecmp (const char *@var{s1}, const char *@var{s2})
-
-A case-insensitive @code{strncmp}.
-
-@end deftypefn
-
-*/
-
-#if defined(LIBC_SCCS) && !defined(lint)
-static char sccsid[] = "@(#)strcasecmp.c	5.5 (Berkeley) 11/24/87";
-#endif /* LIBC_SCCS and not lint */
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-/*
- * This array is designed for mapping upper and lower case letter
- * together for a case independent comparison.  The mappings are
- * based upon ascii character sequences.
- */
-static const unsigned char charmap[] = {
-	'\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
-	'\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
-	'\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
-	'\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
-	'\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
-	'\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
-	'\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
-	'\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
-	'\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
-	'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
-	'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
-	'\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
-	'\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
-	'\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
-	'\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
-	'\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
-	'\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
-	'\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
-	'\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
-	'\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
-	'\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
-	'\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
-	'\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
-	'\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
-	'\300', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
-	'\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
-	'\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
-	'\370', '\371', '\372', '\333', '\334', '\335', '\336', '\337',
-	'\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
-	'\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
-	'\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
-	'\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
-};
-
-int
-strncasecmp(const char *s1, const char *s2, register size_t n)
-{
-    register unsigned char u1, u2;
-
-    for (; n != 0; --n) {
-	u1 = (unsigned char) *s1++;
-	u2 = (unsigned char) *s2++;
-	if (charmap[u1] != charmap[u2]) {
-	    return charmap[u1] - charmap[u2];
-	}
-	if (u1 == '\0') {
-	    return 0;
-	}
-    }
-    return 0;
-}
diff --git a/libiberty/strncmp.c b/libiberty/strncmp.c
deleted file mode 100644
index 23f6df617..000000000
--- a/libiberty/strncmp.c
+++ /dev/null
@@ -1,34 +0,0 @@
-/* strncmp -- compare two strings, stop after n bytes.
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental int strncmp (const char *@var{s1}, @
-  const char *@var{s2}, size_t @var{n})
-
-Compares the first @var{n} bytes of two strings, returning a value as
-@code{strcmp}.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stddef.h>
-
-int
-strncmp(const char *s1, const char *s2, register size_t n)
-{
-  register unsigned char u1, u2;
-
-  while (n-- > 0)
-    {
-      u1 = (unsigned char) *s1++;
-      u2 = (unsigned char) *s2++;
-      if (u1 != u2)
-	return u1 - u2;
-      if (u1 == '\0')
-	return 0;
-    }
-  return 0;
-}
diff --git a/libiberty/strndup.c b/libiberty/strndup.c
deleted file mode 100644
index 9e9b4e299..000000000
--- a/libiberty/strndup.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/* Implement the strndup function.
-   Copyright (C) 2005 Free Software Foundation, Inc.
-   Written by Kaveh R. Ghazi <ghazi@caip.rutgers.edu>.
-
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Extension char* strndup (const char *@var{s}, size_t @var{n})
-
-Returns a pointer to a copy of @var{s} with at most @var{n} characters
-in memory obtained from @code{malloc}, or @code{NULL} if insufficient
-memory was available.  The result is always NUL terminated.
-
-@end deftypefn
-
-*/
-
-#include "ansidecl.h"
-#include <stddef.h>
-
-extern size_t	strlen (const char*);
-extern PTR	malloc (size_t);
-extern PTR	memcpy (PTR, const PTR, size_t);
-
-char *
-strndup (const char *s, size_t n)
-{
-  char *result;
-  size_t len = strlen (s);
-
-  if (n < len)
-    len = n;
-
-  result = (char *) malloc (len + 1);
-  if (!result)
-    return 0;
-
-  result[len] = '\0';
-  return (char *) memcpy (result, s, len);
-}
diff --git a/libiberty/strrchr.c b/libiberty/strrchr.c
deleted file mode 100644
index 5cf7c14d8..000000000
--- a/libiberty/strrchr.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/* Portable version of strrchr().
-   This function is in the public domain. */
-
-/*
-
-@deftypefn Supplemental char* strrchr (const char *@var{s}, int @var{c})
-
-Returns a pointer to the last occurrence of the character @var{c} in
-the string @var{s}, or @code{NULL} if not found.  If @var{c} is itself the
-null character, the results are undefined.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-
-char *
-strrchr (register const char *s, int c)
-{
-  char *rtnval = 0;
-
-  do {
-    if (*s == c)
-      rtnval = (char*) s;
-  } while (*s++);
-  return (rtnval);
-}
diff --git a/libiberty/strsignal.c b/libiberty/strsignal.c
deleted file mode 100644
index 666b1b4f1..000000000
--- a/libiberty/strsignal.c
+++ /dev/null
@@ -1,610 +0,0 @@
-/* Extended support for using signal values.
-   Written by Fred Fish.  fnf@cygnus.com
-   This file is in the public domain.  */
-
-#include "config.h"
-#include "ansidecl.h"
-#include "libiberty.h"
-
-/* We need to declare sys_siglist, because even if the system provides
-   it we can't assume that it is declared in <signal.h> (for example,
-   SunOS provides sys_siglist, but it does not declare it in any
-   header file).  However, we can't declare sys_siglist portably,
-   because on some systems it is declared with const and on some
-   systems it is declared without const.  If we were using autoconf,
-   we could work out the right declaration.  Until, then we just
-   ignore any declaration in the system header files, and always
-   declare it ourselves.  With luck, this will always work.  */
-#define sys_siglist no_such_symbol
-#define sys_nsig sys_nsig__no_such_symbol
-
-#include <stdio.h>
-#include <signal.h>
-
-/*  Routines imported from standard C runtime libraries. */
-
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#else
-extern PTR malloc ();
-#endif
-
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-extern PTR memset ();
-#endif
-
-/* Undefine the macro we used to hide the definition of sys_siglist
-   found in the system header files.  */
-#undef sys_siglist
-#undef sys_nsig
-
-#ifndef NULL
-#  define NULL (void *) 0
-#endif
-
-#ifndef MAX
-#  define MAX(a,b) ((a) > (b) ? (a) : (b))
-#endif
-
-static void init_signal_tables (void);
-
-/* Translation table for signal values.
-
-   Note that this table is generally only accessed when it is used at runtime
-   to initialize signal name and message tables that are indexed by signal
-   value.
-
-   Not all of these signals will exist on all systems.  This table is the only
-   thing that should have to be updated as new signal numbers are introduced.
-   It's sort of ugly, but at least its portable. */
-
-struct signal_info
-{
-  const int value;		/* The numeric value from <signal.h> */
-  const char *const name;	/* The equivalent symbolic value */
-#ifndef HAVE_SYS_SIGLIST
-  const char *const msg;	/* Short message about this value */
-#endif
-};
-
-#ifndef HAVE_SYS_SIGLIST
-#   define ENTRY(value, name, msg)	{value, name, msg}
-#else
-#   define ENTRY(value, name, msg)	{value, name}
-#endif
-
-static const struct signal_info signal_table[] =
-{
-#if defined (SIGHUP)
-  ENTRY(SIGHUP, "SIGHUP", "Hangup"),
-#endif
-#if defined (SIGINT)
-  ENTRY(SIGINT, "SIGINT", "Interrupt"),
-#endif
-#if defined (SIGQUIT)
-  ENTRY(SIGQUIT, "SIGQUIT", "Quit"),
-#endif
-#if defined (SIGILL)
-  ENTRY(SIGILL, "SIGILL", "Illegal instruction"),
-#endif
-#if defined (SIGTRAP)
-  ENTRY(SIGTRAP, "SIGTRAP", "Trace/breakpoint trap"),
-#endif
-/* Put SIGIOT before SIGABRT, so that if SIGIOT==SIGABRT then SIGABRT
-   overrides SIGIOT.  SIGABRT is in ANSI and POSIX.1, and SIGIOT isn't. */
-#if defined (SIGIOT)
-  ENTRY(SIGIOT, "SIGIOT", "IOT trap"),
-#endif
-#if defined (SIGABRT)
-  ENTRY(SIGABRT, "SIGABRT", "Aborted"),
-#endif
-#if defined (SIGEMT)
-  ENTRY(SIGEMT, "SIGEMT", "Emulation trap"),
-#endif
-#if defined (SIGFPE)
-  ENTRY(SIGFPE, "SIGFPE", "Arithmetic exception"),
-#endif
-#if defined (SIGKILL)
-  ENTRY(SIGKILL, "SIGKILL", "Killed"),
-#endif
-#if defined (SIGBUS)
-  ENTRY(SIGBUS, "SIGBUS", "Bus error"),
-#endif
-#if defined (SIGSEGV)
-  ENTRY(SIGSEGV, "SIGSEGV", "Segmentation fault"),
-#endif
-#if defined (SIGSYS)
-  ENTRY(SIGSYS, "SIGSYS", "Bad system call"),
-#endif
-#if defined (SIGPIPE)
-  ENTRY(SIGPIPE, "SIGPIPE", "Broken pipe"),
-#endif
-#if defined (SIGALRM)
-  ENTRY(SIGALRM, "SIGALRM", "Alarm clock"),
-#endif
-#if defined (SIGTERM)
-  ENTRY(SIGTERM, "SIGTERM", "Terminated"),
-#endif
-#if defined (SIGUSR1)
-  ENTRY(SIGUSR1, "SIGUSR1", "User defined signal 1"),
-#endif
-#if defined (SIGUSR2)
-  ENTRY(SIGUSR2, "SIGUSR2", "User defined signal 2"),
-#endif
-/* Put SIGCLD before SIGCHLD, so that if SIGCLD==SIGCHLD then SIGCHLD
-   overrides SIGCLD.  SIGCHLD is in POXIX.1 */
-#if defined (SIGCLD)
-  ENTRY(SIGCLD, "SIGCLD", "Child status changed"),
-#endif
-#if defined (SIGCHLD)
-  ENTRY(SIGCHLD, "SIGCHLD", "Child status changed"),
-#endif
-#if defined (SIGPWR)
-  ENTRY(SIGPWR, "SIGPWR", "Power fail/restart"),
-#endif
-#if defined (SIGWINCH)
-  ENTRY(SIGWINCH, "SIGWINCH", "Window size changed"),
-#endif
-#if defined (SIGURG)
-  ENTRY(SIGURG, "SIGURG", "Urgent I/O condition"),
-#endif
-#if defined (SIGIO)
-  /* "I/O pending" has also been suggested, but is misleading since the
-     signal only happens when the process has asked for it, not everytime
-     I/O is pending. */
-  ENTRY(SIGIO, "SIGIO", "I/O possible"),
-#endif
-#if defined (SIGPOLL)
-  ENTRY(SIGPOLL, "SIGPOLL", "Pollable event occurred"),
-#endif
-#if defined (SIGSTOP)
-  ENTRY(SIGSTOP, "SIGSTOP", "Stopped (signal)"),
-#endif
-#if defined (SIGTSTP)
-  ENTRY(SIGTSTP, "SIGTSTP", "Stopped (user)"),
-#endif
-#if defined (SIGCONT)
-  ENTRY(SIGCONT, "SIGCONT", "Continued"),
-#endif
-#if defined (SIGTTIN)
-  ENTRY(SIGTTIN, "SIGTTIN", "Stopped (tty input)"),
-#endif
-#if defined (SIGTTOU)
-  ENTRY(SIGTTOU, "SIGTTOU", "Stopped (tty output)"),
-#endif
-#if defined (SIGVTALRM)
-  ENTRY(SIGVTALRM, "SIGVTALRM", "Virtual timer expired"),
-#endif
-#if defined (SIGPROF)
-  ENTRY(SIGPROF, "SIGPROF", "Profiling timer expired"),
-#endif
-#if defined (SIGXCPU)
-  ENTRY(SIGXCPU, "SIGXCPU", "CPU time limit exceeded"),
-#endif
-#if defined (SIGXFSZ)
-  ENTRY(SIGXFSZ, "SIGXFSZ", "File size limit exceeded"),
-#endif
-#if defined (SIGWIND)
-  ENTRY(SIGWIND, "SIGWIND", "SIGWIND"),
-#endif
-#if defined (SIGPHONE)
-  ENTRY(SIGPHONE, "SIGPHONE", "SIGPHONE"),
-#endif
-#if defined (SIGLOST)
-  ENTRY(SIGLOST, "SIGLOST", "Resource lost"),
-#endif
-#if defined (SIGWAITING)
-  ENTRY(SIGWAITING, "SIGWAITING", "Process's LWPs are blocked"),
-#endif
-#if defined (SIGLWP)
-  ENTRY(SIGLWP, "SIGLWP", "Signal LWP"),
-#endif
-#if defined (SIGDANGER)
-  ENTRY(SIGDANGER, "SIGDANGER", "Swap space dangerously low"),
-#endif
-#if defined (SIGGRANT)
-  ENTRY(SIGGRANT, "SIGGRANT", "Monitor mode granted"),
-#endif
-#if defined (SIGRETRACT)
-  ENTRY(SIGRETRACT, "SIGRETRACT", "Need to relinguish monitor mode"),
-#endif
-#if defined (SIGMSG)
-  ENTRY(SIGMSG, "SIGMSG", "Monitor mode data available"),
-#endif
-#if defined (SIGSOUND)
-  ENTRY(SIGSOUND, "SIGSOUND", "Sound completed"),
-#endif
-#if defined (SIGSAK)
-  ENTRY(SIGSAK, "SIGSAK", "Secure attention"),
-#endif
-  ENTRY(0, NULL, NULL)
-};
-
-/* Translation table allocated and initialized at runtime.  Indexed by the
-   signal value to find the equivalent symbolic value. */
-
-static const char **signal_names;
-static int num_signal_names = 0;
-
-/* Translation table allocated and initialized at runtime, if it does not
-   already exist in the host environment.  Indexed by the signal value to find
-   the descriptive string.
-
-   We don't export it for use in other modules because even though it has the
-   same name, it differs from other implementations in that it is dynamically
-   initialized rather than statically initialized. */
-
-#ifndef HAVE_SYS_SIGLIST
-
-static int sys_nsig;
-static const char **sys_siglist;
-
-#else
-
-#ifdef NSIG
-static int sys_nsig = NSIG;
-#else
-#ifdef _NSIG
-static int sys_nsig = _NSIG;
-#endif
-#endif
-extern const char * const sys_siglist[];
-
-#endif
-
-
-/*
-
-NAME
-
-	init_signal_tables -- initialize the name and message tables
-
-SYNOPSIS
-
-	static void init_signal_tables ();
-
-DESCRIPTION
-
-	Using the signal_table, which is initialized at compile time, generate
-	the signal_names and the sys_siglist (if needed) tables, which are
-	indexed at runtime by a specific signal value.
-
-BUGS
-
-	The initialization of the tables may fail under low memory conditions,
-	in which case we don't do anything particularly useful, but we don't
-	bomb either.  Who knows, it might succeed at a later point if we free
-	some memory in the meantime.  In any case, the other routines know
-	how to deal with lack of a table after trying to initialize it.  This
-	may or may not be considered to be a bug, that we don't specifically
-	warn about this particular failure mode.
-
-*/
-
-static void
-init_signal_tables (void)
-{
-  const struct signal_info *eip;
-  int nbytes;
-
-  /* If we haven't already scanned the signal_table once to find the maximum
-     signal value, then go find it now. */
-
-  if (num_signal_names == 0)
-    {
-      for (eip = signal_table; eip -> name != NULL; eip++)
-	{
-	  if (eip -> value >= num_signal_names)
-	    {
-	      num_signal_names = eip -> value + 1;
-	    }
-	}
-    }
-
-  /* Now attempt to allocate the signal_names table, zero it out, and then
-     initialize it from the statically initialized signal_table. */
-
-  if (signal_names == NULL)
-    {
-      nbytes = num_signal_names * sizeof (char *);
-      if ((signal_names = (const char **) malloc (nbytes)) != NULL)
-	{
-	  memset (signal_names, 0, nbytes);
-	  for (eip = signal_table; eip -> name != NULL; eip++)
-	    {
-	      signal_names[eip -> value] = eip -> name;
-	    }
-	}
-    }
-
-#ifndef HAVE_SYS_SIGLIST
-
-  /* Now attempt to allocate the sys_siglist table, zero it out, and then
-     initialize it from the statically initialized signal_table. */
-
-  if (sys_siglist == NULL)
-    {
-      nbytes = num_signal_names * sizeof (char *);
-      if ((sys_siglist = (const char **) malloc (nbytes)) != NULL)
-	{
-	  memset (sys_siglist, 0, nbytes);
-	  sys_nsig = num_signal_names;
-	  for (eip = signal_table; eip -> name != NULL; eip++)
-	    {
-	      sys_siglist[eip -> value] = eip -> msg;
-	    }
-	}
-    }
-
-#endif
-
-}
-
-
-/*
-
-@deftypefn Extension int signo_max (void)
-
-Returns the maximum signal value for which a corresponding symbolic
-name or message is available.  Note that in the case where we use the
-@code{sys_siglist} supplied by the system, it is possible for there to
-be more symbolic names than messages, or vice versa.  In fact, the
-manual page for @code{psignal(3b)} explicitly warns that one should
-check the size of the table (@code{NSIG}) before indexing it, since
-new signal codes may be added to the system before they are added to
-the table.  Thus @code{NSIG} might be smaller than value implied by
-the largest signo value defined in @code{<signal.h>}.
-
-We return the maximum value that can be used to obtain a meaningful
-symbolic name or message.
-
-@end deftypefn
-
-*/
-
-int
-signo_max (void)
-{
-  int maxsize;
-
-  if (signal_names == NULL)
-    {
-      init_signal_tables ();
-    }
-  maxsize = MAX (sys_nsig, num_signal_names);
-  return (maxsize - 1);
-}
-
-
-/*
-
-@deftypefn Supplemental {const char *} strsignal (int @var{signo})
-
-Maps an signal number to an signal message string, the contents of
-which are implementation defined.  On systems which have the external
-variable @code{sys_siglist}, these strings will be the same as the
-ones used by @code{psignal()}.
-
-If the supplied signal number is within the valid range of indices for
-the @code{sys_siglist}, but no message is available for the particular
-signal number, then returns the string @samp{Signal @var{num}}, where
-@var{num} is the signal number.
-
-If the supplied signal number is not a valid index into
-@code{sys_siglist}, returns @code{NULL}.
-
-The returned string is only guaranteed to be valid only until the next
-call to @code{strsignal}.
-
-@end deftypefn
-
-*/
-
-#ifndef HAVE_STRSIGNAL
-
-char *
-strsignal (int signo)
-{
-  char *msg;
-  static char buf[32];
-
-#ifndef HAVE_SYS_SIGLIST
-
-  if (signal_names == NULL)
-    {
-      init_signal_tables ();
-    }
-
-#endif
-
-  if ((signo < 0) || (signo >= sys_nsig))
-    {
-      /* Out of range, just return NULL */
-      msg = NULL;
-    }
-  else if ((sys_siglist == NULL) || (sys_siglist[signo] == NULL))
-    {
-      /* In range, but no sys_siglist or no entry at this index. */
-      sprintf (buf, "Signal %d", signo);
-      msg = buf;
-    }
-  else
-    {
-      /* In range, and a valid message.  Just return the message.  We
-	 can safely cast away const, since POSIX says the user must
-	 not modify the result.	 */
-      msg = (char *) sys_siglist[signo];
-    }
-
-  return (msg);
-}
-
-#endif /* ! HAVE_STRSIGNAL */
-
-/*
-
-@deftypefn Extension {const char*} strsigno (int @var{signo})
-
-Given an signal number, returns a pointer to a string containing the
-symbolic name of that signal number, as found in @code{<signal.h>}.
-
-If the supplied signal number is within the valid range of indices for
-symbolic names, but no name is available for the particular signal
-number, then returns the string @samp{Signal @var{num}}, where
-@var{num} is the signal number.
-
-If the supplied signal number is not within the range of valid
-indices, then returns @code{NULL}.
-
-The contents of the location pointed to are only guaranteed to be
-valid until the next call to @code{strsigno}.
-
-@end deftypefn
-
-*/
-
-const char *
-strsigno (int signo)
-{
-  const char *name;
-  static char buf[32];
-
-  if (signal_names == NULL)
-    {
-      init_signal_tables ();
-    }
-
-  if ((signo < 0) || (signo >= num_signal_names))
-    {
-      /* Out of range, just return NULL */
-      name = NULL;
-    }
-  else if ((signal_names == NULL) || (signal_names[signo] == NULL))
-    {
-      /* In range, but no signal_names or no entry at this index. */
-      sprintf (buf, "Signal %d", signo);
-      name = (const char *) buf;
-    }
-  else
-    {
-      /* In range, and a valid name.  Just return the name. */
-      name = signal_names[signo];
-    }
-
-  return (name);
-}
-
-
-/*
-
-@deftypefn Extension int strtosigno (const char *@var{name})
-
-Given the symbolic name of a signal, map it to a signal number.  If no
-translation is found, returns 0.
-
-@end deftypefn
-
-*/
-
-int
-strtosigno (const char *name)
-{
-  int signo = 0;
-
-  if (name != NULL)
-    {
-      if (signal_names == NULL)
-	{
-	  init_signal_tables ();
-	}
-      for (signo = 0; signo < num_signal_names; signo++)
-	{
-	  if ((signal_names[signo] != NULL) &&
-	      (strcmp (name, signal_names[signo]) == 0))
-	    {
-	      break;
-	    }
-	}
-      if (signo == num_signal_names)
-	{
-	  signo = 0;
-	}
-    }
-  return (signo);
-}
-
-
-/*
-
-@deftypefn Supplemental void psignal (int @var{signo}, char *@var{message})
-
-Print @var{message} to the standard error, followed by a colon,
-followed by the description of the signal specified by @var{signo},
-followed by a newline.
-
-@end deftypefn
-
-*/
-
-#ifndef HAVE_PSIGNAL
-
-void
-psignal (int signo, char *message)
-{
-  if (signal_names == NULL)
-    {
-      init_signal_tables ();
-    }
-  if ((signo <= 0) || (signo >= sys_nsig))
-    {
-      fprintf (stderr, "%s: unknown signal\n", message);
-    }
-  else
-    {
-      fprintf (stderr, "%s: %s\n", message, sys_siglist[signo]);
-    }
-}
-
-#endif	/* ! HAVE_PSIGNAL */
-
-
-/* A simple little main that does nothing but print all the signal translations
-   if MAIN is defined and this file is compiled and linked. */
-
-#ifdef MAIN
-
-#include <stdio.h>
-
-int
-main (void)
-{
-  int signo;
-  int maxsigno;
-  const char *name;
-  const char *msg;
-
-  maxsigno = signo_max ();
-  printf ("%d entries in names table.\n", num_signal_names);
-  printf ("%d entries in messages table.\n", sys_nsig);
-  printf ("%d is max useful index.\n", maxsigno);
-
-  /* Keep printing values until we get to the end of *both* tables, not
-     *either* table.  Note that knowing the maximum useful index does *not*
-     relieve us of the responsibility of testing the return pointer for
-     NULL. */
-
-  for (signo = 0; signo <= maxsigno; signo++)
-    {
-      name = strsigno (signo);
-      name = (name == NULL) ? "<NULL>" : name;
-      msg = strsignal (signo);
-      msg = (msg == NULL) ? "<NULL>" : msg;
-      printf ("%-4d%-18s%s\n", signo, name, msg);
-    }
-
-  return 0;
-}
-
-#endif
diff --git a/libiberty/strstr.c b/libiberty/strstr.c
deleted file mode 100644
index 60902ea40..000000000
--- a/libiberty/strstr.c
+++ /dev/null
@@ -1,41 +0,0 @@
-/* Simple implementation of strstr for systems without it.
-   This function is in the public domain.  */
-
-/*
-
-@deftypefn Supplemental char* strstr (const char *@var{string}, const char *@var{sub})
-
-This function searches for the substring @var{sub} in the string
-@var{string}, not including the terminating null characters.  A pointer
-to the first occurrence of @var{sub} is returned, or @code{NULL} if the
-substring is absent.  If @var{sub} points to a string with zero
-length, the function returns @var{string}.
-
-@end deftypefn
-
-
-*/
-
-
-/* FIXME:  The above description is ANSI compiliant.  This routine has not
-   been validated to comply with it.  -fnf */
-
-#include <stddef.h>
-
-extern char *strchr (const char *, int);
-extern int strncmp (const void *, const void *, size_t);
-extern size_t strlen (const char *);
-
-char *
-strstr (const char *s1, const char *s2)
-{
-  const char *p = s1;
-  const size_t len = strlen (s2);
-
-  for (; (p = strchr (p, *s2)) != 0; p++)
-    {
-      if (strncmp (p, s2, len) == 0)
-	return (char *)p;
-    }
-  return (0);
-}
diff --git a/libiberty/strtod.c b/libiberty/strtod.c
deleted file mode 100644
index e4da2113f..000000000
--- a/libiberty/strtod.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/* Implementation of strtod for systems with atof.
-   Copyright (C) 1991, 1995, 2002, 2011 Free Software Foundation, Inc.
-
-This file is part of the libiberty library.  This library 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 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 General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
-
-As a special exception, if you link this library with files
-compiled with a GNU compiler to produce an executable, this does not cause
-the resulting executable to be covered by the GNU General Public License.
-This exception does not however invalidate any other reasons why
-the executable file might be covered by the GNU General Public License. */
-
-/*
-
-@deftypefn Supplemental double strtod (const char *@var{string}, @
-  char **@var{endptr})
-
-This ISO C function converts the initial portion of @var{string} to a
-@code{double}.  If @var{endptr} is not @code{NULL}, a pointer to the
-character after the last character used in the conversion is stored in
-the location referenced by @var{endptr}.  If no conversion is
-performed, zero is returned and the value of @var{string} is stored in
-the location referenced by @var{endptr}.
-
-@end deftypefn
-
-*/
-
-#include "ansidecl.h"
-#include "safe-ctype.h"
-
-extern double atof (const char *);
-
-/* Disclaimer: this is currently just used by CHILL in GDB and therefore
-   has not been tested well.  It may have been tested for nothing except
-   that it compiles.  */
-
-double
-strtod (char *str, char **ptr)
-{
-  char *p;
-
-  if (ptr == (char **)0)
-    return atof (str);
-  
-  p = str;
-  
-  while (ISSPACE (*p))
-    ++p;
-  
-  if (*p == '+' || *p == '-')
-    ++p;
-
-  /* INF or INFINITY.  */
-  if ((p[0] == 'i' || p[0] == 'I')
-      && (p[1] == 'n' || p[1] == 'N')
-      && (p[2] == 'f' || p[2] == 'F'))
-    {
-      if ((p[3] == 'i' || p[3] == 'I')
-	  && (p[4] == 'n' || p[4] == 'N')
-	  && (p[5] == 'i' || p[5] == 'I')
-	  && (p[6] == 't' || p[6] == 'T')
-	  && (p[7] == 'y' || p[7] == 'Y'))
-	{
-	  *ptr = p + 8;
-	  return atof (str);
-	}
-      else
-	{
-	  *ptr = p + 3;
-	  return atof (str);
-	}
-    }
-
-  /* NAN or NAN(foo).  */
-  if ((p[0] == 'n' || p[0] == 'N')
-      && (p[1] == 'a' || p[1] == 'A')
-      && (p[2] == 'n' || p[2] == 'N'))
-    {
-      p += 3;
-      if (*p == '(')
-	{
-	  ++p;
-	  while (*p != '\0' && *p != ')')
-	    ++p;
-	  if (*p == ')')
-	    ++p;
-	}
-      *ptr = p;
-      return atof (str);
-    }
-
-  /* digits, with 0 or 1 periods in it.  */
-  if (ISDIGIT (*p) || *p == '.')
-    {
-      int got_dot = 0;
-      while (ISDIGIT (*p) || (!got_dot && *p == '.'))
-	{
-	  if (*p == '.')
-	    got_dot = 1;
-	  ++p;
-	}
-
-      /* Exponent.  */
-      if (*p == 'e' || *p == 'E')
-	{
-	  int i;
-	  i = 1;
-	  if (p[i] == '+' || p[i] == '-')
-	    ++i;
-	  if (ISDIGIT (p[i]))
-	    {
-	      while (ISDIGIT (p[i]))
-		++i;
-	      *ptr = p + i;
-	      return atof (str);
-	    }
-	}
-      *ptr = p;
-      return atof (str);
-    }
-  /* Didn't find any digits.  Doesn't look like a number.  */
-  *ptr = str;
-  return 0.0;
-}
diff --git a/libiberty/strtol.c b/libiberty/strtol.c
deleted file mode 100644
index bde5647c9..000000000
--- a/libiberty/strtol.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*-
- * Copyright (c) 1990 The Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. [rescinded 22 July 1999]
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-/*
-
-@deftypefn Supplemental {long int} strtol (const char *@var{string}, @
-  char **@var{endptr}, int @var{base})
-@deftypefnx Supplemental {unsigned long int} strtoul (const char *@var{string}, @
-  char **@var{endptr}, int @var{base})
-
-The @code{strtol} function converts the string in @var{string} to a
-long integer value according to the given @var{base}, which must be
-between 2 and 36 inclusive, or be the special value 0.  If @var{base}
-is 0, @code{strtol} will look for the prefixes @code{0} and @code{0x}
-to indicate bases 8 and 16, respectively, else default to base 10.
-When the base is 16 (either explicitly or implicitly), a prefix of
-@code{0x} is allowed.  The handling of @var{endptr} is as that of
-@code{strtod} above.  The @code{strtoul} function is the same, except
-that the converted value is unsigned.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-#include <errno.h>
-#ifdef NEED_DECLARATION_ERRNO
-extern int errno;
-#endif
-#include "safe-ctype.h"
-
-/* FIXME: It'd be nice to configure around these, but the include files are too
-   painful.  These macros should at least be more portable than hardwired hex
-   constants. */
-
-#ifndef ULONG_MAX
-#define	ULONG_MAX	((unsigned long)(~0L))		/* 0xFFFFFFFF */
-#endif
-
-#ifndef LONG_MAX
-#define	LONG_MAX	((long)(ULONG_MAX >> 1))	/* 0x7FFFFFFF */
-#endif
-
-#ifndef LONG_MIN
-#define	LONG_MIN	((long)(~LONG_MAX))		/* 0x80000000 */
-#endif
-
-/*
- * Convert a string to a long integer.
- *
- * Ignores `locale' stuff.  Assumes that the upper and lower case
- * alphabets and digits are each contiguous.
- */
-long
-strtol(const char *nptr, char **endptr, register int base)
-{
-	register const char *s = nptr;
-	register unsigned long acc;
-	register int c;
-	register unsigned long cutoff;
-	register int neg = 0, any, cutlim;
-
-	/*
-	 * Skip white space and pick up leading +/- sign if any.
-	 * If base is 0, allow 0x for hex and 0 for octal, else
-	 * assume decimal; if base is already 16, allow 0x.
-	 */
-	do {
-		c = *s++;
-	} while (ISSPACE(c));
-	if (c == '-') {
-		neg = 1;
-		c = *s++;
-	} else if (c == '+')
-		c = *s++;
-	if ((base == 0 || base == 16) &&
-	    c == '0' && (*s == 'x' || *s == 'X')) {
-		c = s[1];
-		s += 2;
-		base = 16;
-	}
-	if (base == 0)
-		base = c == '0' ? 8 : 10;
-
-	/*
-	 * Compute the cutoff value between legal numbers and illegal
-	 * numbers.  That is the largest legal value, divided by the
-	 * base.  An input number that is greater than this value, if
-	 * followed by a legal input character, is too big.  One that
-	 * is equal to this value may be valid or not; the limit
-	 * between valid and invalid numbers is then based on the last
-	 * digit.  For instance, if the range for longs is
-	 * [-2147483648..2147483647] and the input base is 10,
-	 * cutoff will be set to 214748364 and cutlim to either
-	 * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
-	 * a value > 214748364, or equal but the next digit is > 7 (or 8),
-	 * the number is too big, and we will return a range error.
-	 *
-	 * Set any if any `digits' consumed; make it negative to indicate
-	 * overflow.
-	 */
-	cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
-	cutlim = cutoff % (unsigned long)base;
-	cutoff /= (unsigned long)base;
-	for (acc = 0, any = 0;; c = *s++) {
-		if (ISDIGIT(c))
-			c -= '0';
-		else if (ISALPHA(c))
-			c -= ISUPPER(c) ? 'A' - 10 : 'a' - 10;
-		else
-			break;
-		if (c >= base)
-			break;
-		if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
-			any = -1;
-		else {
-			any = 1;
-			acc *= base;
-			acc += c;
-		}
-	}
-	if (any < 0) {
-		acc = neg ? LONG_MIN : LONG_MAX;
-		errno = ERANGE;
-	} else if (neg)
-		acc = -acc;
-	if (endptr != 0)
-		*endptr = (char *) (any ? s - 1 : nptr);
-	return (acc);
-}
diff --git a/libiberty/strtoul.c b/libiberty/strtoul.c
deleted file mode 100644
index ba8006353..000000000
--- a/libiberty/strtoul.c
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
- * Copyright (c) 1990 Regents of the University of California.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. [rescinded 22 July 1999]
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif
-#ifdef HAVE_SYS_PARAM_H
-#include <sys/param.h>
-#endif
-#include <errno.h>
-#ifdef NEED_DECLARATION_ERRNO
-extern int errno;
-#endif
-#if 0
-#include <stdlib.h>
-#endif
-#include "ansidecl.h"
-#include "safe-ctype.h"
-
-#ifndef ULONG_MAX
-#define	ULONG_MAX	((unsigned long)(~0L))		/* 0xFFFFFFFF */
-#endif
-
-/*
- * Convert a string to an unsigned long integer.
- *
- * Ignores `locale' stuff.  Assumes that the upper and lower case
- * alphabets and digits are each contiguous.
- */
-unsigned long
-strtoul(const char *nptr, char **endptr, register int base)
-{
-	register const char *s = nptr;
-	register unsigned long acc;
-	register int c;
-	register unsigned long cutoff;
-	register int neg = 0, any, cutlim;
-
-	/*
-	 * See strtol for comments as to the logic used.
-	 */
-	do {
-		c = *s++;
-	} while (ISSPACE(c));
-	if (c == '-') {
-		neg = 1;
-		c = *s++;
-	} else if (c == '+')
-		c = *s++;
-	if ((base == 0 || base == 16) &&
-	    c == '0' && (*s == 'x' || *s == 'X')) {
-		c = s[1];
-		s += 2;
-		base = 16;
-	}
-	if (base == 0)
-		base = c == '0' ? 8 : 10;
-	cutoff = (unsigned long)ULONG_MAX / (unsigned long)base;
-	cutlim = (unsigned long)ULONG_MAX % (unsigned long)base;
-	for (acc = 0, any = 0;; c = *s++) {
-		if (ISDIGIT(c))
-			c -= '0';
-		else if (ISALPHA(c))
-			c -= ISUPPER(c) ? 'A' - 10 : 'a' - 10;
-		else
-			break;
-		if (c >= base)
-			break;
-		if (any < 0 || acc > cutoff || (acc == cutoff && c > cutlim))
-			any = -1;
-		else {
-			any = 1;
-			acc *= base;
-			acc += c;
-		}
-	}
-	if (any < 0) {
-		acc = ULONG_MAX;
-		errno = ERANGE;
-	} else if (neg)
-		acc = -acc;
-	if (endptr != 0)
-		*endptr = (char *) (any ? s - 1 : nptr);
-	return (acc);
-}
diff --git a/libiberty/strverscmp.c b/libiberty/strverscmp.c
deleted file mode 100644
index 04e1e4ae9..000000000
--- a/libiberty/strverscmp.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/* Compare strings while treating digits characters numerically.
-   Copyright (C) 1997, 2002, 2005 Free Software Foundation, Inc.
-   This file is part of the libiberty library.
-   Contributed by Jean-François Bignolles <bignolle@ecoledoc.ibp.fr>, 1997.
-
-   Libiberty is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Lesser General Public
-   License as published by the Free Software Foundation; either
-   version 2.1 of the License, or (at your option) any later version.
-
-   Libiberty 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
-   Lesser General Public License for more details.
-
-   You should have received a copy of the GNU Lesser General Public
-   License along with the GNU C Library; if not, write to the Free
-   Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-   02110-1301 USA.  */
-
-#include "libiberty.h"
-#include "safe-ctype.h"
-
-/* 
-@deftypefun int strverscmp (const char *@var{s1}, const char *@var{s2})
-The @code{strverscmp} function compares the string @var{s1} against
-@var{s2}, considering them as holding indices/version numbers.  Return
-value follows the same conventions as found in the @code{strverscmp}
-function.  In fact, if @var{s1} and @var{s2} contain no digits,
-@code{strverscmp} behaves like @code{strcmp}.
-
-Basically, we compare strings normally (character by character), until
-we find a digit in each string - then we enter a special comparison
-mode, where each sequence of digits is taken as a whole.  If we reach the
-end of these two parts without noticing a difference, we return to the
-standard comparison mode.  There are two types of numeric parts:
-"integral" and "fractional" (those  begin with a '0'). The types
-of the numeric parts affect the way we sort them:
-
-@itemize @bullet
-@item
-integral/integral: we compare values as you would expect.
-
-@item
-fractional/integral: the fractional part is less than the integral one.
-Again, no surprise.
-
-@item
-fractional/fractional: the things become a bit more complex.
-If the common prefix contains only leading zeroes, the longest part is less
-than the other one; else the comparison behaves normally.
-@end itemize
-
-@smallexample
-strverscmp ("no digit", "no digit")
-    @result{} 0    // @r{same behavior as strcmp.}
-strverscmp ("item#99", "item#100")
-    @result{} <0   // @r{same prefix, but 99 < 100.}
-strverscmp ("alpha1", "alpha001")
-    @result{} >0   // @r{fractional part inferior to integral one.}
-strverscmp ("part1_f012", "part1_f01")
-    @result{} >0   // @r{two fractional parts.}
-strverscmp ("foo.009", "foo.0")
-    @result{} <0   // @r{idem, but with leading zeroes only.}
-@end smallexample
-
-This function is especially useful when dealing with filename sorting,
-because filenames frequently hold indices/version numbers.
-@end deftypefun
-
-*/
-
-/* states: S_N: normal, S_I: comparing integral part, S_F: comparing
-           fractional parts, S_Z: idem but with leading Zeroes only */
-#define  S_N    0x0
-#define  S_I    0x4
-#define  S_F    0x8
-#define  S_Z    0xC
-
-/* result_type: CMP: return diff; LEN: compare using len_diff/diff */
-#define  CMP    2
-#define  LEN    3
-
-
-/* Compare S1 and S2 as strings holding indices/version numbers,
-   returning less than, equal to or greater than zero if S1 is less than,
-   equal to or greater than S2 (for more info, see the Glibc texinfo doc).  */
-
-int
-strverscmp (const char *s1, const char *s2)
-{
-  const unsigned char *p1 = (const unsigned char *) s1;
-  const unsigned char *p2 = (const unsigned char *) s2;
-  unsigned char c1, c2;
-  int state;
-  int diff;
-
-  /* Symbol(s)    0       [1-9]   others  (padding)
-     Transition   (10) 0  (01) d  (00) x  (11) -   */
-  static const unsigned int next_state[] =
-    {
-      /* state    x    d    0    - */
-      /* S_N */  S_N, S_I, S_Z, S_N,
-      /* S_I */  S_N, S_I, S_I, S_I,
-      /* S_F */  S_N, S_F, S_F, S_F,
-      /* S_Z */  S_N, S_F, S_Z, S_Z
-    };
-
-  static const int result_type[] =
-    {
-      /* state   x/x  x/d  x/0  x/-  d/x  d/d  d/0  d/-
-                 0/x  0/d  0/0  0/-  -/x  -/d  -/0  -/- */
-
-      /* S_N */  CMP, CMP, CMP, CMP, CMP, LEN, CMP, CMP,
-                 CMP, CMP, CMP, CMP, CMP, CMP, CMP, CMP,
-      /* S_I */  CMP, -1,  -1,  CMP, +1,  LEN, LEN, CMP,
-                 +1,  LEN, LEN, CMP, CMP, CMP, CMP, CMP,
-      /* S_F */  CMP, CMP, CMP, CMP, CMP, LEN, CMP, CMP,
-                 CMP, CMP, CMP, CMP, CMP, CMP, CMP, CMP,
-      /* S_Z */  CMP, +1,  +1,  CMP, -1,  CMP, CMP, CMP,
-                 -1,  CMP, CMP, CMP
-    };
-
-  if (p1 == p2)
-    return 0;
-
-  c1 = *p1++;
-  c2 = *p2++;
-  /* Hint: '0' is a digit too.  */
-  state = S_N | ((c1 == '0') + (ISDIGIT (c1) != 0));
-
-  while ((diff = c1 - c2) == 0 && c1 != '\0')
-    {
-      state = next_state[state];
-      c1 = *p1++;
-      c2 = *p2++;
-      state |= (c1 == '0') + (ISDIGIT (c1) != 0);
-    }
-
-  state = result_type[state << 2 | (((c2 == '0') + (ISDIGIT (c2) != 0)))];
-
-  switch (state)
-    {
-    case CMP:
-      return diff;
-      
-    case LEN:
-      while (ISDIGIT (*p1++))
-	if (!ISDIGIT (*p2++))
-	  return 1;
-      
-      return ISDIGIT (*p2) ? -1 : diff;
-      
-    default:
-      return state;
-    }
-}
diff --git a/libiberty/tmpnam.c b/libiberty/tmpnam.c
deleted file mode 100644
index cc3433366..000000000
--- a/libiberty/tmpnam.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-
-@deftypefn Supplemental char* tmpnam (char *@var{s})
-
-This function attempts to create a name for a temporary file, which
-will be a valid file name yet not exist when @code{tmpnam} checks for
-it.  @var{s} must point to a buffer of at least @code{L_tmpnam} bytes,
-or be @code{NULL}.  Use of this function creates a security risk, and it must
-not be used in new projects.  Use @code{mkstemp} instead.
-
-@end deftypefn
-
-*/
-
-#include <stdio.h>
-
-#ifndef L_tmpnam
-#define L_tmpnam 100
-#endif
-#ifndef P_tmpdir
-#define P_tmpdir "/usr/tmp"
-#endif
-
-static char tmpnam_buffer[L_tmpnam];
-static int tmpnam_counter;
-
-extern int getpid (void);
-
-char *
-tmpnam (char *s)
-{
-  int pid = getpid ();
-
-  if (s == NULL)
-    s = tmpnam_buffer;
-
-  /*  Generate the filename and make sure that there isn't one called
-      it already.  */
-
-  while (1)
-    {
-      FILE *f;
-      sprintf (s, "%s/%s%x.%x", P_tmpdir, "t", pid, tmpnam_counter);
-      f = fopen (s, "r");
-      if (f == NULL)
-	break;
-      tmpnam_counter++;
-      fclose (f);
-    }
-
-  return s;
-}
diff --git a/libiberty/vasprintf.c b/libiberty/vasprintf.c
deleted file mode 100644
index 85de5429f..000000000
--- a/libiberty/vasprintf.c
+++ /dev/null
@@ -1,197 +0,0 @@
-/* Like vsprintf but provides a pointer to malloc'd storage, which must
-   be freed by the caller.
-   Copyright (C) 1994, 2003, 2011 Free Software Foundation, Inc.
-
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include <ansidecl.h>
-#include <stdarg.h>
-#if !defined (va_copy) && defined (__va_copy)
-# define va_copy(d,s)  __va_copy((d),(s))
-#endif
-#include <stdio.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#else
-extern unsigned long strtoul ();
-extern PTR malloc ();
-#endif
-#include "libiberty.h"
-
-#ifdef TEST
-int global_total_width;
-#endif
-
-/*
-
-@deftypefn Extension int vasprintf (char **@var{resptr}, @
-  const char *@var{format}, va_list @var{args})
-
-Like @code{vsprintf}, but instead of passing a pointer to a buffer,
-you pass a pointer to a pointer.  This function will compute the size
-of the buffer needed, allocate memory with @code{malloc}, and store a
-pointer to the allocated memory in @code{*@var{resptr}}.  The value
-returned is the same as @code{vsprintf} would return.  If memory could
-not be allocated, minus one is returned and @code{NULL} is stored in
-@code{*@var{resptr}}.
-
-@end deftypefn
-
-*/
-
-static int int_vasprintf (char **, const char *, va_list);
-
-static int
-int_vasprintf (char **result, const char *format, va_list args)
-{
-  const char *p = format;
-  /* Add one to make sure that it is never zero, which might cause malloc
-     to return NULL.  */
-  int total_width = strlen (format) + 1;
-  va_list ap;
-
-#ifdef va_copy
-  va_copy (ap, args);
-#else
-  memcpy ((PTR) &ap, (PTR) &args, sizeof (va_list));
-#endif
-
-  while (*p != '\0')
-    {
-      if (*p++ == '%')
-	{
-	  while (strchr ("-+ #0", *p))
-	    ++p;
-	  if (*p == '*')
-	    {
-	      ++p;
-	      total_width += abs (va_arg (ap, int));
-	    }
-	  else
-	    total_width += strtoul (p, (char **) &p, 10);
-	  if (*p == '.')
-	    {
-	      ++p;
-	      if (*p == '*')
-		{
-		  ++p;
-		  total_width += abs (va_arg (ap, int));
-		}
-	      else
-	      total_width += strtoul (p, (char **) &p, 10);
-	    }
-	  while (strchr ("hlL", *p))
-	    ++p;
-	  /* Should be big enough for any format specifier except %s and floats.  */
-	  total_width += 30;
-	  switch (*p)
-	    {
-	    case 'd':
-	    case 'i':
-	    case 'o':
-	    case 'u':
-	    case 'x':
-	    case 'X':
-	    case 'c':
-	      (void) va_arg (ap, int);
-	      break;
-	    case 'f':
-	    case 'e':
-	    case 'E':
-	    case 'g':
-	    case 'G':
-	      (void) va_arg (ap, double);
-	      /* Since an ieee double can have an exponent of 307, we'll
-		 make the buffer wide enough to cover the gross case. */
-	      total_width += 307;
-	      break;
-	    case 's':
-	      total_width += strlen (va_arg (ap, char *));
-	      break;
-	    case 'p':
-	    case 'n':
-	      (void) va_arg (ap, char *);
-	      break;
-	    }
-	  p++;
-	}
-    }
-#ifdef va_copy
-  va_end (ap);
-#endif
-#ifdef TEST
-  global_total_width = total_width;
-#endif
-  *result = (char *) malloc (total_width);
-  if (*result != NULL)
-    return vsprintf (*result, format, args);
-  else
-    return -1;
-}
-
-int
-vasprintf (char **result, const char *format,
-#if defined (_BSD_VA_LIST_) && defined (__FreeBSD__)
-           _BSD_VA_LIST_ args)
-#else
-           va_list args)
-#endif
-{
-  return int_vasprintf (result, format, args);
-}
-
-#ifdef TEST
-static void ATTRIBUTE_PRINTF_1
-checkit (const char *format, ...)
-{
-  char *result;
-  VA_OPEN (args, format);
-  VA_FIXEDARG (args, const char *, format);
-  vasprintf (&result, format, args);
-  VA_CLOSE (args);
-
-  if (strlen (result) < (size_t) global_total_width)
-    printf ("PASS: ");
-  else
-    printf ("FAIL: ");
-  printf ("%d %s\n", global_total_width, result);
-
-  free (result);
-}
-
-extern int main (void);
-
-int
-main (void)
-{
-  checkit ("%d", 0x12345678);
-  checkit ("%200d", 5);
-  checkit ("%.300d", 6);
-  checkit ("%100.150d", 7);
-  checkit ("%s", "jjjjjjjjjiiiiiiiiiiiiiiioooooooooooooooooppppppppppppaa\n\
-777777777777777777333333333333366666666666622222222222777777777777733333");
-  checkit ("%f%s%d%s", 1.0, "foo", 77, "asdjffffffffffffffiiiiiiiiiiixxxxx");
-
-  return 0;
-}
-#endif /* TEST */
diff --git a/libiberty/vfprintf.c b/libiberty/vfprintf.c
deleted file mode 100644
index 9bd3ed555..000000000
--- a/libiberty/vfprintf.c
+++ /dev/null
@@ -1,15 +0,0 @@
-/* Provide a version vfprintf in terms of _doprnt.
-   By Kaveh Ghazi  (ghazi@caip.rutgers.edu)  3/29/98
-   Copyright (C) 1998 Free Software Foundation, Inc.
- */
-
-#include "ansidecl.h"
-#include <stdarg.h>
-#include <stdio.h>
-#undef vfprintf
-
-int
-vfprintf (FILE *stream, const char *format, va_list ap)
-{
-  return _doprnt (format, ap, stream);
-}
diff --git a/libiberty/vprintf.c b/libiberty/vprintf.c
deleted file mode 100644
index c3193ac81..000000000
--- a/libiberty/vprintf.c
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
-
-@deftypefn Supplemental int vprintf (const char *@var{format}, va_list @var{ap})
-@deftypefnx Supplemental int vfprintf (FILE *@var{stream}, @
-  const char *@var{format}, va_list @var{ap})
-@deftypefnx Supplemental int vsprintf (char *@var{str}, @
-  const char *@var{format}, va_list @var{ap})
-
-These functions are the same as @code{printf}, @code{fprintf}, and
-@code{sprintf}, respectively, except that they are called with a
-@code{va_list} instead of a variable number of arguments.  Note that
-they do not call @code{va_end}; this is the application's
-responsibility.  In @libib{} they are implemented in terms of the
-nonstandard but common function @code{_doprnt}.
-
-@end deftypefn
-
-*/
-
-#include <ansidecl.h>
-#include <stdarg.h>
-#include <stdio.h>
-#undef vprintf
-int
-vprintf (const char *format, va_list ap)
-{
-  return vfprintf (stdout, format, ap);
-}
diff --git a/libiberty/vsnprintf.c b/libiberty/vsnprintf.c
deleted file mode 100644
index 6c0afa672..000000000
--- a/libiberty/vsnprintf.c
+++ /dev/null
@@ -1,148 +0,0 @@
-/* Implement the vsnprintf function.
-   Copyright (C) 2003, 2004, 2005, 2011 Free Software Foundation, Inc.
-   Written by Kaveh R. Ghazi <ghazi@caip.rutgers.edu>.
-
-This file is part of the libiberty library.  This library 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 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 General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
-
-As a special exception, if you link this library with files
-compiled with a GNU compiler to produce an executable, this does not cause
-the resulting executable to be covered by the GNU General Public License.
-This exception does not however invalidate any other reasons why
-the executable file might be covered by the GNU General Public License. */
-
-/*
-
-@deftypefn Supplemental int vsnprintf (char *@var{buf}, size_t @var{n}, @
-  const char *@var{format}, va_list @var{ap})
-
-This function is similar to @code{vsprintf}, but it will write to
-@var{buf} at most @code{@var{n}-1} bytes of text, followed by a
-terminating null byte, for a total of @var{n} bytes.  On error the
-return value is -1, otherwise it returns the number of characters that
-would have been printed had @var{n} been sufficiently large,
-regardless of the actual value of @var{n}.  Note some pre-C99 system
-libraries do not implement this correctly so users cannot generally
-rely on the return value if the system version of this function is
-used.
-
-@end deftypefn
-
-*/
-
-#include "config.h"
-#include "ansidecl.h"
-
-#include <stdarg.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#endif
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-
-#include "libiberty.h"
-
-/* This implementation relies on a working vasprintf.  */
-int
-vsnprintf (char *s, size_t n, const char *format, va_list ap)
-{
-  char *buf = 0;
-  int result = vasprintf (&buf, format, ap);
-
-  if (!buf)
-    return -1;
-  if (result < 0)
-    {
-      free (buf);
-      return -1;
-    }
-
-  result = strlen (buf);
-  if (n > 0)
-    {
-      if ((long) n > result)
-	memcpy (s, buf, result+1);
-      else
-        {
-	  memcpy (s, buf, n-1);
-	  s[n - 1] = 0;
-	}
-    }
-  free (buf);
-  return result;
-}
-
-#ifdef TEST
-/* Set the buffer to a known state.  */
-#define CLEAR(BUF) do { memset ((BUF), 'X', sizeof (BUF)); (BUF)[14] = '\0'; } while (0)
-/* For assertions.  */
-#define VERIFY(P) do { if (!(P)) abort(); } while (0)
-
-static int ATTRIBUTE_PRINTF_3
-checkit (char *s, size_t n, const char *format, ...)
-{
-  int result;
-  VA_OPEN (ap, format);
-  VA_FIXEDARG (ap, char *, s);
-  VA_FIXEDARG (ap, size_t, n);
-  VA_FIXEDARG (ap, const char *, format);
-  result = vsnprintf (s, n, format, ap);
-  VA_CLOSE (ap);
-  return result;
-}
-
-extern int main (void);
-int
-main (void)
-{
-  char buf[128];
-  int status;
-  
-  CLEAR (buf);
-  status = checkit (buf, 10, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "foobar:9\0XXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 9, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "foobar:9\0XXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 8, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "foobar:\0XXXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 7, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "foobar\0XXXXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 6, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "fooba\0XXXXXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 2, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "f\0XXXXXXXXXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 1, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "\0XXXXXXXXXXXXX\0", 15) == 0);
-
-  CLEAR (buf);
-  status = checkit (buf, 0, "%s:%d", "foobar", 9);
-  VERIFY (status==8 && memcmp (buf, "XXXXXXXXXXXXXX\0", 15) == 0);
-
-  return 0;
-}
-#endif /* TEST */
diff --git a/libiberty/vsprintf.c b/libiberty/vsprintf.c
deleted file mode 100644
index 99e704493..000000000
--- a/libiberty/vsprintf.c
+++ /dev/null
@@ -1,56 +0,0 @@
-/* Simple implementation of vsprintf for systems without it.
-   Highly system-dependent, but should work on most "traditional"
-   implementations of stdio; newer ones should already have vsprintf.
-   Written by Per Bothner of Cygnus Support.
-   Based on libg++'s "form" (written by Doug Lea; dl@rocky.oswego.edu).
-   Copyright (C) 1991, 1995, 2002 Free Software Foundation, Inc.
-
-This file is part of the libiberty library.  This library 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 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 General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
-
-As a special exception, if you link this library with files
-compiled with a GNU compiler to produce an executable, this does not cause
-the resulting executable to be covered by the GNU General Public License.
-This exception does not however invalidate any other reasons why
-the executable file might be covered by the GNU General Public License. */
-
-#include <ansidecl.h>
-#include <stdarg.h>
-#include <stdio.h>
-#undef vsprintf
-
-#if defined _IOSTRG && defined _IOWRT
-
-int
-vsprintf (char *buf, const char *format, va_list ap)
-{
-  FILE b;
-  int ret;
-#ifdef VMS
-  b->_flag = _IOWRT|_IOSTRG;
-  b->_ptr = buf;
-  b->_cnt = 12000;
-#else
-  b._flag = _IOWRT|_IOSTRG;
-  b._ptr = buf;
-  b._cnt = 12000;
-#endif
-  ret = _doprnt(format, ap, &b);
-  putc('\0', &b);
-  return ret;
-
-}
-
-#endif
diff --git a/libiberty/waitpid.c b/libiberty/waitpid.c
deleted file mode 100644
index fd519d769..000000000
--- a/libiberty/waitpid.c
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-
-@deftypefn Supplemental int waitpid (int @var{pid}, int *@var{status}, int)
-
-This is a wrapper around the @code{wait} function.  Any ``special''
-values of @var{pid} depend on your implementation of @code{wait}, as
-does the return value.  The third argument is unused in @libib{}.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include "ansidecl.h"
-
-/* On some systems (such as WindISS), you must include <sys/types.h>
-   to get the definition of "pid_t" before you include <sys/wait.h>.  */
-#include <sys/types.h>
-
-#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h>
-#endif
-
-pid_t
-waitpid (pid_t pid, int *stat_loc, int options ATTRIBUTE_UNUSED)
-{
-  for (;;)
-    {
-      int wpid = wait(stat_loc);
-      if (wpid == pid || wpid == -1)
-	return wpid;
-    }
-}
diff --git a/libiberty/xatexit.c b/libiberty/xatexit.c
deleted file mode 100644
index 6fdad9ed8..000000000
--- a/libiberty/xatexit.c
+++ /dev/null
@@ -1,99 +0,0 @@
-/*
- * Copyright (c) 1990 Regents of the University of California.
- * All rights reserved.
- *
- * %sccs.include.redist.c%
- */
-
-
-/*
-
-@deftypefun int xatexit (void (*@var{fn}) (void))
-
-Behaves as the standard @code{atexit} function, but with no limit on
-the number of registered functions.  Returns 0 on success, or @minus{}1 on
-failure.  If you use @code{xatexit} to register functions, you must use
-@code{xexit} to terminate your program.
-
-@end deftypefun
-
-*/
-
-/* Adapted from newlib/libc/stdlib/{,at}exit.[ch].
-   If you use xatexit, you must call xexit instead of exit.  */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-
-#include <stdio.h>
-
-#include <stddef.h>
-
-#if VMS
-#include <stdlib.h>
-#include <unixlib.h>
-#else
-/* For systems with larger pointers than ints, this must be declared.  */
-PTR malloc (size_t);
-#endif
-
-static void xatexit_cleanup (void);
-
-/* Pointer to function run by xexit.  */
-extern void (*_xexit_cleanup) (void);
-
-#define	XATEXIT_SIZE 32
-
-struct xatexit {
-	struct	xatexit *next;		/* next in list */
-	int	ind;			/* next index in this table */
-	void	(*fns[XATEXIT_SIZE]) (void);	/* the table itself */
-};
-
-/* Allocate one struct statically to guarantee that we can register
-   at least a few handlers.  */
-static struct xatexit xatexit_first;
-
-/* Points to head of LIFO stack.  */
-static struct xatexit *xatexit_head = &xatexit_first;
-
-/* Register function FN to be run by xexit.
-   Return 0 if successful, -1 if not.  */
-
-int
-xatexit (void (*fn) (void))
-{
-  register struct xatexit *p;
-
-  /* Tell xexit to call xatexit_cleanup.  */
-  if (!_xexit_cleanup)
-    _xexit_cleanup = xatexit_cleanup;
-
-  p = xatexit_head;
-  if (p->ind >= XATEXIT_SIZE)
-    {
-      if ((p = (struct xatexit *) malloc (sizeof *p)) == NULL)
-	return -1;
-      p->ind = 0;
-      p->next = xatexit_head;
-      xatexit_head = p;
-    }
-  p->fns[p->ind++] = fn;
-  return 0;
-}
-
-/* Call any cleanup functions.  */
-
-static void
-xatexit_cleanup (void)
-{
-  register struct xatexit *p;
-  register int n;
-
-  for (p = xatexit_head; p; p = p->next)
-    for (n = p->ind; --n >= 0;)
-      (*p->fns[n]) ();
-}
diff --git a/libiberty/xexit.c b/libiberty/xexit.c
deleted file mode 100644
index 421e5e238..000000000
--- a/libiberty/xexit.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/* xexit.c -- Run any exit handlers, then exit.
-   Copyright (C) 1994, 95, 1997 Free Software Foundation, Inc.
-
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If not, write
-to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Replacement void xexit (int @var{code})
-
-Terminates the program.  If any functions have been registered with
-the @code{xatexit} replacement function, they will be called first.
-Termination is handled via the system's normal @code{exit} call.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include <stdio.h>
-#ifdef HAVE_STDLIB_H
-#include <stdlib.h>
-#endif
-#include "libiberty.h"
-
-
-/* This variable is set by xatexit if it is called.  This way, xmalloc
-   doesn't drag xatexit into the link.  */
-void (*_xexit_cleanup) (void);
-
-void
-xexit (int code)
-{
-  if (_xexit_cleanup != NULL)
-    (*_xexit_cleanup) ();
-  exit (code);
-}
diff --git a/libiberty/xmalloc.c b/libiberty/xmalloc.c
deleted file mode 100644
index 3e97aab56..000000000
--- a/libiberty/xmalloc.c
+++ /dev/null
@@ -1,184 +0,0 @@
-/* memory allocation routines with error checking.
-   Copyright 1989, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
-   
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Replacement void* xmalloc (size_t)
-
-Allocate memory without fail.  If @code{malloc} fails, this will print
-a message to @code{stderr} (using the name set by
-@code{xmalloc_set_program_name},
-if any) and then call @code{xexit}.  Note that it is therefore safe for
-a program to contain @code{#define malloc xmalloc} in its source.
-
-@end deftypefn
-
-@deftypefn Replacement void* xrealloc (void *@var{ptr}, size_t @var{size})
-Reallocate memory without fail.  This routine functions like @code{realloc},
-but will behave the same as @code{xmalloc} if memory cannot be found.
-
-@end deftypefn
-
-@deftypefn Replacement void* xcalloc (size_t @var{nelem}, size_t @var{elsize})
-
-Allocate memory without fail, and set it to zero.  This routine functions
-like @code{calloc}, but will behave the same as @code{xmalloc} if memory
-cannot be found.
-
-@end deftypefn
-
-@deftypefn Replacement void xmalloc_set_program_name (const char *@var{name})
-
-You can use this to set the name of the program used by
-@code{xmalloc_failed} when printing a failure message.
-
-@end deftypefn
-
-@deftypefn Replacement void xmalloc_failed (size_t)
-
-This function is not meant to be called by client code, and is listed
-here for completeness only.  If any of the allocation routines fail, this
-function will be called to print an error message and terminate execution.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-
-#include <stdio.h>
-
-#include <stddef.h>
-
-#if VMS
-#include <stdlib.h>
-#include <unixlib.h>
-#else
-/* For systems with larger pointers than ints, these must be declared.  */
-#  if HAVE_STDLIB_H && HAVE_UNISTD_H && HAVE_DECL_MALLOC \
-      && HAVE_DECL_REALLOC && HAVE_DECL_CALLOC && HAVE_DECL_SBRK
-#    include <stdlib.h>
-#    include <unistd.h>
-#  else
-#    ifdef __cplusplus
-extern "C" {
-#    endif /* __cplusplus */
-void *malloc (size_t);
-void *realloc (void *, size_t);
-void *calloc (size_t, size_t);
-void *sbrk (ptrdiff_t);
-#    ifdef __cplusplus
-}
-#    endif /* __cplusplus */
-#  endif /* HAVE_STDLIB_H ...  */
-#endif /* VMS */
-
-/* The program name if set.  */
-static const char *name = "";
-
-#ifdef HAVE_SBRK
-/* The initial sbrk, set when the program name is set. Not used for win32
-   ports other than cygwin32.  */
-static char *first_break = NULL;
-#endif /* HAVE_SBRK */
-
-void
-xmalloc_set_program_name (const char *s)
-{
-  name = s;
-#ifdef HAVE_SBRK
-  /* Win32 ports other than cygwin32 don't have brk() */
-  if (first_break == NULL)
-    first_break = (char *) sbrk (0);
-#endif /* HAVE_SBRK */
-}
-
-void
-xmalloc_failed (size_t size)
-{
-#ifdef HAVE_SBRK
-  extern char **environ;
-  size_t allocated;
-
-  if (first_break != NULL)
-    allocated = (char *) sbrk (0) - first_break;
-  else
-    allocated = (char *) sbrk (0) - (char *) &environ;
-  fprintf (stderr,
-	   "\n%s%sout of memory allocating %lu bytes after a total of %lu bytes\n",
-	   name, *name ? ": " : "",
-	   (unsigned long) size, (unsigned long) allocated);
-#else /* HAVE_SBRK */
-  fprintf (stderr,
-	   "\n%s%sout of memory allocating %lu bytes\n",
-	   name, *name ? ": " : "",
-	   (unsigned long) size);
-#endif /* HAVE_SBRK */
-  xexit (1);
-}  
-
-PTR
-xmalloc (size_t size)
-{
-  PTR newmem;
-
-  if (size == 0)
-    size = 1;
-  newmem = malloc (size);
-  if (!newmem)
-    xmalloc_failed (size);
-
-  return (newmem);
-}
-
-PTR
-xcalloc (size_t nelem, size_t elsize)
-{
-  PTR newmem;
-
-  if (nelem == 0 || elsize == 0)
-    nelem = elsize = 1;
-
-  newmem = calloc (nelem, elsize);
-  if (!newmem)
-    xmalloc_failed (nelem * elsize);
-
-  return (newmem);
-}
-
-PTR
-xrealloc (PTR oldmem, size_t size)
-{
-  PTR newmem;
-
-  if (size == 0)
-    size = 1;
-  if (!oldmem)
-    newmem = malloc (size);
-  else
-    newmem = realloc (oldmem, size);
-  if (!newmem)
-    xmalloc_failed (size);
-
-  return (newmem);
-}
diff --git a/libiberty/xmemdup.c b/libiberty/xmemdup.c
deleted file mode 100644
index aa56f0bf5..000000000
--- a/libiberty/xmemdup.c
+++ /dev/null
@@ -1,39 +0,0 @@
-/* xmemdup.c -- Duplicate a memory buffer, using xcalloc.
-   This trivial function is in the public domain.
-   Jeff Garzik, September 1999.  */
-
-/*
-
-@deftypefn Replacement void* xmemdup (void *@var{input}, @
-  size_t @var{copy_size}, size_t @var{alloc_size})
-
-Duplicates a region of memory without fail.  First, @var{alloc_size} bytes
-are allocated, then @var{copy_size} bytes from @var{input} are copied into
-it, and the new memory is returned.  If fewer bytes are copied than were
-allocated, the remaining memory is zeroed.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-
-#include <sys/types.h> /* For size_t. */
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-# ifdef HAVE_STRINGS_H
-#  include <strings.h>
-# endif
-#endif
-
-PTR
-xmemdup (const PTR input, size_t copy_size, size_t alloc_size)
-{
-  PTR output = xcalloc (1, alloc_size);
-  return (PTR) memcpy (output, input, copy_size);
-}
diff --git a/libiberty/xstrdup.c b/libiberty/xstrdup.c
deleted file mode 100644
index fa12c96a3..000000000
--- a/libiberty/xstrdup.c
+++ /dev/null
@@ -1,36 +0,0 @@
-/* xstrdup.c -- Duplicate a string in memory, using xmalloc.
-   This trivial function is in the public domain.
-   Ian Lance Taylor, Cygnus Support, December 1995.  */
-
-/*
-
-@deftypefn Replacement char* xstrdup (const char *@var{s})
-
-Duplicates a character string without fail, using @code{xmalloc} to
-obtain memory.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include <sys/types.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-# ifdef HAVE_STRINGS_H
-#  include <strings.h>
-# endif
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-
-char *
-xstrdup (const char *s)
-{
-  register size_t len = strlen (s) + 1;
-  register char *ret = XNEWVEC (char, len);
-  return (char *) memcpy (ret, s, len);
-}
diff --git a/libiberty/xstrerror.c b/libiberty/xstrerror.c
deleted file mode 100644
index 2ea2200e9..000000000
--- a/libiberty/xstrerror.c
+++ /dev/null
@@ -1,79 +0,0 @@
-/* xstrerror.c -- jacket routine for more robust strerror() usage.
-   Fri Jun 16 18:30:00 1995  Pat Rankin  <rankin@eql.caltech.edu>
-   This code is in the public domain.  */
-
-/*
-
-@deftypefn Replacement char* xstrerror (int @var{errnum})
-
-Behaves exactly like the standard @code{strerror} function, but
-will never return a @code{NULL} pointer.
-
-@end deftypefn
-
-*/
-
-#include <stdio.h>
-
-#include "config.h"
-#include "libiberty.h"
-
-#ifdef VMS
-#  include <errno.h>
-#  if !defined (__STRICT_ANSI__) && !defined (__HIDE_FORBIDDEN_NAMES)
-#    ifdef __cplusplus
-extern "C" {
-#    endif /* __cplusplus */
-extern char *strerror (int,...);
-#    define DONT_DECLARE_STRERROR
-#    ifdef __cplusplus
-}
-#    endif /* __cplusplus */
-#  endif
-#endif  /* VMS */
-
-
-#ifndef DONT_DECLARE_STRERROR
-#  ifdef __cplusplus
-extern "C" {
-#  endif /* __cplusplus */
-extern char *strerror (int);
-#  ifdef __cplusplus
-}
-#  endif /* __cplusplus */
-#endif
-
-/* If strerror returns NULL, we'll format the number into a static buffer.  */
-
-#define ERRSTR_FMT "undocumented error #%d"
-static char xstrerror_buf[sizeof ERRSTR_FMT + 20];
-
-/* Like strerror, but result is never a null pointer.  */
-
-char *
-xstrerror (int errnum)
-{
-  char *errstr;
-#ifdef VMS
-  char *(*vmslib_strerror) (int,...);
-
-  /* Override any possibly-conflicting declaration from system header.  */
-  vmslib_strerror = (char *(*) (int,...)) strerror;
-  /* Second argument matters iff first is EVMSERR, but it's simpler to
-     pass it unconditionally.  `vaxc$errno' is declared in <errno.h>
-     and maintained by the run-time library in parallel to `errno'.
-     We assume that `errnum' corresponds to the last value assigned to
-     errno by the run-time library, hence vaxc$errno will be relevant.  */
-  errstr = (*vmslib_strerror) (errnum, vaxc$errno);
-#else
-  errstr = strerror (errnum);
-#endif
-
-  /* If `errnum' is out of range, result might be NULL.  We'll fix that.  */
-  if (!errstr)
-    {
-      sprintf (xstrerror_buf, ERRSTR_FMT, errnum);
-      errstr = xstrerror_buf;
-    }
-  return errstr;
-}
diff --git a/libiberty/xstrndup.c b/libiberty/xstrndup.c
deleted file mode 100644
index 0a41f608e..000000000
--- a/libiberty/xstrndup.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/* Implement the xstrndup function.
-   Copyright (C) 2005 Free Software Foundation, Inc.
-   Written by Kaveh R. Ghazi <ghazi@caip.rutgers.edu>.
-
-This file is part of the libiberty library.
-Libiberty 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.
-
-Libiberty 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 libiberty; see the file COPYING.LIB.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
-Boston, MA 02110-1301, USA.  */
-
-/*
-
-@deftypefn Replacement char* xstrndup (const char *@var{s}, size_t @var{n})
-
-Returns a pointer to a copy of @var{s} with at most @var{n} characters
-without fail, using @code{xmalloc} to obtain memory.  The result is
-always NUL terminated.
-
-@end deftypefn
-
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include <sys/types.h>
-#ifdef HAVE_STRING_H
-#include <string.h>
-#else
-# ifdef HAVE_STRINGS_H
-#  include <strings.h>
-# endif
-#endif
-#include "ansidecl.h"
-#include "libiberty.h"
-
-char *
-xstrndup (const char *s, size_t n)
-{
-  char *result;
-  size_t len = strlen (s);
-
-  if (n < len)
-    len = n;
-
-  result = XNEWVEC (char, len + 1);
-
-  result[len] = '\0';
-  return (char *) memcpy (result, s, len);
-}