Desupport regexp.h (bug 18681)

1 files changed, 3 insertions, 200 deletions

diff --git a/misc/regexp.h b/misc/regexp.h
index 42394f78cf..9f5c413d28 100644
--- a/misc/regexp.h
+++ b/misc/regexp.h
@@ -25,206 +25,9 @@
    were encouraged to use <regex.h> instead.  It was officially
    withdrawn from the standard in Issue 6 (aka POSIX.1-2001).
 
-   This header is provided only for backward compatibility.
-   It will be removed in the next release of the GNU C Library.
-   New code should use <regex.h> instead.  */
+   The GNU C Library provided this header through version 2.22. */
 
-#warning "<regexp.h> will be removed in the next release of the GNU C Library."
-#warning "Please update your code to use <regex.h> instead (no trailing 'p')."
-
-#include <features.h>
-#include <alloca.h>
-#include <regex.h>
-#include <stdlib.h>
-#include <string.h>
-
-/* The implementation provided here emulates the needed functionality
-   by mapping to the POSIX regular expression matcher.  The interface
-   for the here included function is weird (this really is a harmless
-   word).
-
-   The user has to provide six macros before this header file can be
-   included:
-
-   INIT		Declarations vor variables which can be used by the
-		other macros.
-
-   GETC()	Return the value of the next character in the regular
-		expression pattern.  Successive calls should return
-		successive characters.
-
-   PEEKC()	Return the value of the next character in the regular
-		expression pattern.  Immediately successive calls to
-		PEEKC() should return the same character which should
-		also be the next character returned by GETC().
-
-   UNGETC(c)	Cause `c' to be returned by the next call to GETC() and
-		PEEKC().
-
-   RETURN(ptr)	Used for normal exit of the `compile' function.  `ptr'
-		is a pointer to the character after the last character of
-		the compiled regular expression.
-
-   ERROR(val)	Used for abnormal return from `compile'.  `val' is the
-		error number.  The error codes are:
-		11	Range endpoint too large.
-		16	Bad number.
-		25	\digit out of range.
-		36	Illegal or missing delimiter.
-		41	No remembered search string.
-		42	\( \) imbalance.
-		43	Too many \(.
-		44	More tan two numbers given in \{ \}.
-		45	} expected after \.
-		46	First number exceeds second in \{ \}.
-		49	[ ] imbalance.
-		50	Regular expression overflow.
-
-  */
-
-__BEGIN_DECLS
-
-/* Interface variables.  They contain the results of the successful
-   calls to `setp' and `advance'.  */
-extern char *loc1;
-extern char *loc2;
-
-/* The use of this variable in the `advance' function is not
-   supported.  */
-extern char *locs;
-
-
-#ifndef __DO_NOT_DEFINE_COMPILE
-/* Get and compile the user supplied pattern up to end of line or
-   string or until EOF is seen, whatever happens first.  The result is
-   placed in the buffer starting at EXPBUF and delimited by ENDBUF.
-
-   This function cannot be defined in the libc itself since it depends
-   on the macros.  */
-char *
-compile (char *__restrict instring, char *__restrict expbuf,
-	 const char *__restrict endbuf, int eof)
-{
-  char *__input_buffer = NULL;
-  size_t __input_size = 0;
-  size_t __current_size = 0;
-  int __ch;
-  int __error;
-  INIT
-
-  /* Align the expression buffer according to the needs for an object
-     of type `regex_t'.  Then check for minimum size of the buffer for
-     the compiled regular expression.  */
-  regex_t *__expr_ptr;
-# if defined __GNUC__ && __GNUC__ >= 2
-  const size_t __req = __alignof__ (regex_t *);
-# else
-  /* How shall we find out?  We simply guess it and can change it is
-     this really proofs to be wrong.  */
-  const size_t __req = 8;
-# endif
-  expbuf += __req;
-  expbuf -= (expbuf - ((char *) 0)) % __req;
-  if (endbuf < expbuf + sizeof (regex_t))
-    {
-      ERROR (50);
-    }
-  __expr_ptr = (regex_t *) expbuf;
-  /* The remaining space in the buffer can be used for the compiled
-     pattern.  */
-  __expr_ptr->__REPB_PREFIX (buffer) = expbuf + sizeof (regex_t);
-  __expr_ptr->__REPB_PREFIX (allocated)
-    = endbuf - (char *) __expr_ptr->__REPB_PREFIX (buffer);
-
-  while ((__ch = (GETC ())) != eof)
-    {
-      if (__ch == '\0' || __ch == '\n')
-	{
-	  UNGETC (__ch);
-	  break;
-	}
-
-      if (__current_size + 1 >= __input_size)
-	{
-	  size_t __new_size = __input_size ? 2 * __input_size : 128;
-	  char *__new_room = (char *) alloca (__new_size);
-	  /* See whether we can use the old buffer.  */
-	  if (__new_room + __new_size == __input_buffer)
-	    {
-	      __input_size += __new_size;
-	      __input_buffer = (char *) memcpy (__new_room, __input_buffer,
-					       __current_size);
-	    }
-	  else if (__input_buffer + __input_size == __new_room)
-	    __input_size += __new_size;
-	  else
-	    {
-	      __input_size = __new_size;
-	      __input_buffer = (char *) memcpy (__new_room, __input_buffer,
-						__current_size);
-	    }
-	}
-      __input_buffer[__current_size++] = __ch;
-    }
-  if (__current_size)
-    __input_buffer[__current_size++] = '\0';
-  else
-    __input_buffer = "";
-
-  /* Now compile the pattern.  */
-  __error = regcomp (__expr_ptr, __input_buffer, REG_NEWLINE);
-  if (__error != 0)
-    /* Oh well, we have to translate POSIX error codes.  */
-    switch (__error)
-      {
-      case REG_BADPAT:
-      case REG_ECOLLATE:
-      case REG_ECTYPE:
-      case REG_EESCAPE:
-      case REG_BADRPT:
-      case REG_EEND:
-      case REG_ERPAREN:
-      default:
-	/* There is no matching error code.  */
-	ERROR (36);
-      case REG_ESUBREG:
-	ERROR (25);
-      case REG_EBRACK:
-	ERROR (49);
-      case REG_EPAREN:
-	ERROR (42);
-      case REG_EBRACE:
-	ERROR (44);
-      case REG_BADBR:
-	ERROR (46);
-      case REG_ERANGE:
-	ERROR (11);
-      case REG_ESPACE:
-      case REG_ESIZE:
-	ERROR (50);
-      }
-
-  /* Everything is ok.  */
-  RETURN ((char *) (__expr_ptr->__REPB_PREFIX (buffer)
-		    + __expr_ptr->__REPB_PREFIX (used)));
-}
-#endif
-
-
-/* Find the next match in STRING.  The compiled regular expression is
-   found in the buffer starting at EXPBUF.  `loc1' will return the
-   first character matched and `loc2' points to the next unmatched
-   character.  */
-extern int step (const char *__restrict __string,
-		 const char *__restrict __expbuf) __THROW;
-
-/* Match the beginning of STRING with the compiled regular expression
-   in EXPBUF.  If the match is successful `loc2' will contain the
-   position of the first unmatched character.  */
-extern int advance (const char *__restrict __string,
-		    const char *__restrict __expbuf) __THROW;
-
-
-__END_DECLS
+#error "The GNU C Library no longer implements <regexp.h>."
+#error "Please update your code to use <regex.h> instead (no trailing 'p')."
 
 #endif /* regexp.h */