Desupport regexp.h (bug 18681)
This commit is contained in:
Zack Weinberg
Andreas Schwab
parent
d5dff793af
commit
1c70b6f155
|
|
@ -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]
|
||||
|
|
|
|||
6
NEWS
6
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
|
||||
|
||||
|
|
|
|||
|
|
@ -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) */
|
||||
|
|
|
|||
203
misc/regexp.h
203
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 */
|
||||
|
|
|
|||
Loading…
Reference in New Issue