about summary refs log tree commit diff
diff options
context:
space:
mode:
-rw-r--r--ChangeLog8
-rw-r--r--NEWS6
-rw-r--r--misc/regexp.c29
-rw-r--r--misc/regexp.h203
4 files changed, 37 insertions, 209 deletions
diff --git a/ChangeLog b/ChangeLog
index a00482ddf2..3b62365511 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2015-08-16  Zack Weinberg  <zackw@panix.com>
+
+	[BZ #18681]
+	* misc/regexp.h: This interface is no longer supported.
+	Remove all contents, leaving only an #error directive.
+	* misc/regexp.c (loc1, loc2, locs, step, advance):
+	Demote to compatibility symbols.
+
 2015-08-15  Paul Pluzhnikov  <ppluzhnikov@google.com>
 
 	[BZ #18084]
diff --git a/NEWS b/NEWS
index 12b258a517..64230e2819 100644
--- a/NEWS
+++ b/NEWS
@@ -10,9 +10,11 @@ Version 2.23
 * The following bugs are resolved with this release:
 
   16517, 16519, 16520, 16734, 17905, 18084, 18086, 18265, 18480, 18525,
-  18618, 18647, 18661, 18674, 18778, 18781, 18787, 18789, 18790, 18795,
-  18820, 18824.
+  18618, 18647, 18661, 18681, 18674, 18778, 18781, 18787, 18789, 18790,
+  18795, 18820, 18824.
 
+* The obsolete header <regexp.h> has been removed.  Programs that require
+  this header must be updated to use <regex.h> instead.
 
 Version 2.22
 
diff --git a/misc/regexp.c b/misc/regexp.c
index ee7d572111..ef5e18bd28 100644
--- a/misc/regexp.c
+++ b/misc/regexp.c
@@ -1,4 +1,4 @@
-/* Define function and variables for the obsolete <regexp.h> interface.
+/* Compatibility symbols for the obsolete <regexp.h> interface.
    Copyright (C) 1996-2015 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
@@ -17,17 +17,27 @@
    License along with the GNU C Library; if not, see
    <http://www.gnu.org/licenses/>.  */
 
-/* We don't include regexp.h here because of the macros it requires, and
-   because it now contains an unconditional #warning.  */
+/* regexp.h now contains only an #error directive, so it cannot be
+   used in this file.
+
+   The function that would produce an 'expbuf' to use as the second
+   argument to 'step' and 'advance' was defined only in regexp.h,
+   as its definition depended on macros defined by the user.  */
 
 #include <regex.h>
+#include <shlib-compat.h>
+
+#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_23)
 
 /* Define the variables used for the interface.  */
 char *loc1;
 char *loc2;
+compat_symbol (libc, loc1, loc1, GLIBC_2_0);
+compat_symbol (libc, loc2, loc2, GLIBC_2_0);
 
 /* Although we do not support the use we define this variable as well.  */
 char *locs;
+compat_symbol (libc, locs, locs, GLIBC_2_0);
 
 
 /* Find the next match in STRING.  The compiled regular expression is
@@ -35,7 +45,8 @@ char *locs;
    first character matched and `loc2' points to the next unmatched
    character.  */
 int
-__step (const char *string, const char *expbuf)
+weak_function attribute_compat_text_section
+step (const char *string, const char *expbuf)
 {
   regmatch_t match;	/* We only need info about the full match.  */
 
@@ -50,14 +61,15 @@ __step (const char *string, const char *expbuf)
   loc2 = (char *) string + match.rm_eo;
   return 1;
 }
-weak_alias (__step, step)
+compat_symbol (libc, step, step, GLIBC_2_0);
 
 
 /* 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.  */
 int
-__advance (const char *string, const char *expbuf)
+weak_function attribute_compat_text_section
+advance (const char *string, const char *expbuf)
 {
   regmatch_t match;	/* We only need info about the full match.  */
 
@@ -74,4 +86,7 @@ __advance (const char *string, const char *expbuf)
   loc2 = (char *) string + match.rm_eo;
   return 1;
 }
-weak_alias (__advance, advance)
+compat_symbol (libc, advance, advance, GLIBC_2_0);
+
+
+#endif /* SHLIB_COMPAT (2.0, 2.23) */
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 */