[glibc.git] / misc / regexp.h

/* Copyright (C) 1996-2013 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.

   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, see
   <http://www.gnu.org/licenses/>.  */

#ifndef _REGEXP_H
#define _REGEXP_H	1

/* The contents of this header file was first standardized in X/Open
   System Interface and Headers Issue 2, originally coming from SysV.
   In issue 4, version 2, it is marked as TO BE WITDRAWN, and it has
   been withdrawn in SUSv3.

   This code shouldn't be used in any newly written code.  It is
   included only for compatibility reasons.  Use the POSIX definition
   in <regex.h> for portable applications and a reasonable interface.  */

#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.  */
	RETURN (36);
      case REG_ESUBREG:
	RETURN (25);
      case REG_EBRACK:
	RETURN (49);
      case REG_EPAREN:
	RETURN (42);
      case REG_EBRACE:
	RETURN (44);
      case REG_BADBR:
	RETURN (46);
      case REG_ERANGE:
	RETURN (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

#endif /* regexp.h */
Commit	Line	Data
568035b7	1	/* Copyright (C) 1996-2013 Free Software Foundation, Inc.
84384f5b UD	2	This file is part of the GNU C Library.
	3	Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
84384f5b UD	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	13	Lesser General Public License for more details.
84384f5b	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
84384f5b UD	18
	19	#ifndef _REGEXP_H
	20	#define _REGEXP_H 1
	21
	22	/* The contents of this header file was first standardized in X/Open
	23	System Interface and Headers Issue 2, originally coming from SysV.
d4b60383 UD	24	In issue 4, version 2, it is marked as TO BE WITDRAWN, and it has
d4b60383 UD	25	been withdrawn in SUSv3.
84384f5b UD	26
	27	This code shouldn't be used in any newly written code. It is
	28	included only for compatibility reasons. Use the POSIX definition
	29	in <regex.h> for portable applications and a reasonable interface. */
	30
dfd2257a	31	#include <features.h>
84384f5b UD	32	#include <alloca.h>
	33	#include <regex.h>
	34	#include <stdlib.h>
	35	#include <string.h>
	36
	37	/* The implementation provided here emulates the needed functionality
	38	by mapping to the POSIX regular expression matcher. The interface
	39	for the here included function is weird (this really is a harmless
	40	word).
	41
714a562f	42	The user has to provide six macros before this header file can be
84384f5b UD	43	included:
84384f5b UD	44
714a562f UD	45	INIT Declarations vor variables which can be used by the
	46	other macros.
	47
84384f5b UD	48	GETC() Return the value of the next character in the regular
	49	expression pattern. Successive calls should return
	50	successive characters.
	51
	52	PEEKC() Return the value of the next character in the regular
	53	expression pattern. Immediately successive calls to
	54	PEEKC() should return the same character which should
	55	also be the next character returned by GETC().
	56
	57	UNGETC(c) Cause `c' to be returned by the next call to GETC() and
	58	PEEKC().
	59
	60	RETURN(ptr) Used for normal exit of the `compile' function. `ptr'
	61	is a pointer to the character after the last character of
	62	the compiled regular expression.
	63
	64	ERROR(val) Used for abnormal return from `compile'. `val' is the
	65	error number. The error codes are:
	66	11 Range endpoint too large.
	67	16 Bad number.
	68	25 \digit out of range.
	69	36 Illegal or missing delimiter.
	70	41 No remembered search string.
	71	42 \( \) imbalance.
	72	43 Too many \(.
	73	44 More tan two numbers given in \{ \}.
	74	45 } expected after \.
	75	46 First number exceeds second in \{ \}.
	76	49 [ ] imbalance.
	77	50 Regular expression overflow.
	78
	79	*/
	80
	81	__BEGIN_DECLS
	82
	83	/* Interface variables. They contain the results of the successful
	84	calls to `setp' and `advance'. */
	85	extern char *loc1;
	86	extern char *loc2;
	87
	88	/* The use of this variable in the `advance' function is not
	89	supported. */
	90	extern char *locs;
	91
	92
	93	#ifndef __DO_NOT_DEFINE_COMPILE
	94	/* Get and compile the user supplied pattern up to end of line or
	95	string or until EOF is seen, whatever happens first. The result is
9963a779	96	placed in the buffer starting at EXPBUF and delimited by ENDBUF.
84384f5b UD	97
	98	This function cannot be defined in the libc itself since it depends
	99	on the macros. */
	100	char *
9963a779	101	compile (char __restrict instring, char __restrict expbuf,
a784e502	102	const char *__restrict endbuf, int eof)
84384f5b UD	103	{
	104	char *__input_buffer = NULL;
	105	size_t __input_size = 0;
714a562f	106	size_t __current_size = 0;
84384f5b	107	int __ch;
8d57beea	108	int __error;
714a562f	109	INIT
84384f5b UD	110
	111	/* Align the expression buffer according to the needs for an object
	112	of type `regex_t'. Then check for minimum size of the buffer for
	113	the compiled regular expression. */
	114	regex_t *__expr_ptr;
dfd2257a	115	# if defined __GNUC__ && __GNUC__ >= 2
84384f5b	116	const size_t __req = __alignof__ (regex_t *);
dfd2257a	117	# else
84384f5b UD	118	/* How shall we find out? We simply guess it and can change it is
	119	this really proofs to be wrong. */
	120	const size_t __req = 8;
dfd2257a	121	# endif
9756dfe1 UD	122	expbuf += __req;
	123	expbuf -= (expbuf - ((char *) 0)) % __req;
	124	if (endbuf < expbuf + sizeof (regex_t))
84384f5b UD	125	{
	126	ERROR (50);
	127	}
9756dfe1	128	__expr_ptr = (regex_t *) expbuf;
84384f5b UD	129	/* The remaining space in the buffer can be used for the compiled
84384f5b UD	130	pattern. */
eef8a803 JJ	131	__expr_ptr->__REPB_PREFIX (buffer) = expbuf + sizeof (regex_t);
	132	__expr_ptr->__REPB_PREFIX (allocated)
	133	= endbuf - (char *) __expr_ptr->__REPB_PREFIX (buffer);
84384f5b	134
9756dfe1	135	while ((__ch = (GETC ())) != eof)
84384f5b	136	{
9963a779	137	if (__ch == '\0' \|\| __ch == '\n')
84384f5b UD	138	{
	139	UNGETC (__ch);
	140	break;
	141	}
	142
	143	if (__current_size + 1 >= __input_size)
	144	{
	145	size_t __new_size = __input_size ? 2 * __input_size : 128;
b4751608	146	char __new_room = (char ) alloca (__new_size);
84384f5b UD	147	/* See whether we can use the old buffer. */
	148	if (__new_room + __new_size == __input_buffer)
	149	{
	150	__input_size += __new_size;
b4751608 AS	151	__input_buffer = (char *) memcpy (__new_room, __input_buffer,
b4751608 AS	152	__current_size);
84384f5b UD	153	}
	154	else if (__input_buffer + __input_size == __new_room)
	155	__input_size += __new_size;
	156	else
	157	{
	158	__input_size = __new_size;
b4751608 AS	159	__input_buffer = (char *) memcpy (__new_room, __input_buffer,
b4751608 AS	160	__current_size);
84384f5b UD	161	}
	162	}
	163	__input_buffer[__current_size++] = __ch;
	164	}
eef8a803 JJ	165	if (__current_size)
	166	__input_buffer[__current_size++] = '\0';
	167	else
	168	__input_buffer = "";
84384f5b UD	169
	170	/* Now compile the pattern. */
	171	__error = regcomp (__expr_ptr, __input_buffer, REG_NEWLINE);
	172	if (__error != 0)
	173	/* Oh well, we have to translate POSIX error codes. */
	174	switch (__error)
	175	{
	176	case REG_BADPAT:
	177	case REG_ECOLLATE:
	178	case REG_ECTYPE:
	179	case REG_EESCAPE:
	180	case REG_BADRPT:
	181	case REG_EEND:
8d57beea	182	case REG_ERPAREN:
84384f5b UD	183	default:
	184	/* There is no matching error code. */
	185	RETURN (36);
	186	case REG_ESUBREG:
	187	RETURN (25);
	188	case REG_EBRACK:
	189	RETURN (49);
	190	case REG_EPAREN:
	191	RETURN (42);
	192	case REG_EBRACE:
	193	RETURN (44);
	194	case REG_BADBR:
	195	RETURN (46);
	196	case REG_ERANGE:
	197	RETURN (11);
	198	case REG_ESPACE:
	199	case REG_ESIZE:
	200	ERROR (50);
	201	}
	202
	203	/* Everything is ok. */
eef8a803 JJ	204	RETURN ((char *) (__expr_ptr->__REPB_PREFIX (buffer)
eef8a803 JJ	205	+ __expr_ptr->__REPB_PREFIX (used)));
84384f5b UD	206	}
	207	#endif
	208
	209
	210	/* Find the next match in STRING. The compiled regular expression is
	211	found in the buffer starting at EXPBUF. `loc1' will return the
	212	first character matched and `loc2' points to the next unmatched
	213	character. */
a784e502 UD	214	extern int step (const char *__restrict __string,
a784e502 UD	215	const char *__restrict __expbuf) __THROW;
84384f5b UD	216
	217	/* Match the beginning of STRING with the compiled regular expression
	218	in EXPBUF. If the match is successful `loc2' will contain the
	219	position of the first unmatched character. */
a784e502 UD	220	extern int advance (const char *__restrict __string,
a784e502 UD	221	const char *__restrict __expbuf) __THROW;
84384f5b UD	222
	223
	224	__END_DECLS
	225
	226	#endif /* regexp.h */