mirror of
https://sourceware.org/git/glibc.git
synced 2025-07-29 11:41:21 +03:00
Desupport regexp.h (bug 18681)
This commit is contained in:
Zack Weinberg
committed by
Andreas Schwab
Andreas Schwab
parent
d5dff793af
commit
1c70b6f155
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 */
|
||||
|
||||
Reference in New Issue
Block a user