misc/regexp.h

   1 /* Copyright (C) 1996, 1997 Free Software Foundation, Inc.
   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
   6    modify it under the terms of the GNU Library General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   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
  13    Library General Public License for more details.
  14
  15    You should have received a copy of the GNU Library General Public
  16    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18    Boston, MA 02111-1307, USA.  */
  19
  20 #ifndef _REGEXP_H
  21 #define _REGEXP_H       1
  22
  23 /* The contents of this header file was first standardized in X/Open
  24    System Interface and Headers Issue 2, originally coming from SysV.
  25    In issue 4, version 2, it is marked as TO BE WITDRAWN.
  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
  31 #include <features.h>
  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
  42    The user has to provide six macros before this header file can be
  43    included:
  44
  45    INIT         Declarations vor variables which can be used by the
  46                 other macros.
  47
  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
  96    placed in the buffer starting at EXPBUG and delimited by ENDBUF.
  97
  98    This function cannot be defined in the libc itself since it depends
  99    on the macros.  */
 100 char *
 101 compile (char *instring, char *expbuf, __const char *endbuf, int eof)
 102 {
 103   char *__input_buffer = NULL;
 104   size_t __input_size = 0;
 105   size_t __current_size = 0;
 106   int __ch;
 107   int __error;
 108   INIT
 109
 110   /* Align the expression buffer according to the needs for an object
 111      of type `regex_t'.  Then check for minimum size of the buffer for
 112      the compiled regular expression.  */
 113   regex_t *__expr_ptr;
 114 # if defined __GNUC__ && __GNUC__ >= 2
 115   const size_t __req = __alignof__ (regex_t *);
 116 # else
 117   /* How shall we find out?  We simply guess it and can change it is
 118      this really proofs to be wrong.  */
 119   const size_t __req = 8;
 120 # endif
 121   expbuf += __req;
 122   expbuf -= (expbuf - ((char *) 0)) % __req;
 123   if (endbuf < expbuf + sizeof (regex_t))
 124     {
 125       ERROR (50);
 126     }
 127   __expr_ptr = (regex_t *) expbuf;
 128   /* The remaining space in the buffer can be used for the compiled
 129      pattern.  */
 130   __expr_ptr->buffer = expbuf + sizeof (regex_t);
 131   __expr_ptr->allocated = endbuf -  (char *) __expr_ptr->buffer;
 132
 133   while ((__ch = (GETC ())) != eof)
 134     {
 135       if (__ch == '\0' || __ch == 'n')
 136         {
 137           UNGETC (__ch);
 138           break;
 139         }
 140
 141       if (__current_size + 1 >= __input_size)
 142         {
 143           size_t __new_size = __input_size ? 2 * __input_size : 128;
 144           char *__new_room = __alloca (__new_size);
 145           /* See whether we can use the old buffer.  */
 146           if (__new_room + __new_size == __input_buffer)
 147             {
 148               __input_size += __new_size;
 149               __input_buffer = memcpy (__new_room, __input_buffer,
 150                                        __current_size);
 151             }
 152           else if (__input_buffer + __input_size == __new_room)
 153             __input_size += __new_size;
 154           else
 155             {
 156               __input_size = __new_size;
 157               __input_buffer = memcpy (__new_room, __input_buffer,
 158                                        __current_size);
 159             }
 160         }
 161       __input_buffer[__current_size++] = __ch;
 162     }
 163   __input_buffer[__current_size++] = '\0';
 164
 165   /* Now compile the pattern.  */
 166   __error = regcomp (__expr_ptr, __input_buffer, REG_NEWLINE);
 167   if (__error != 0)
 168     /* Oh well, we have to translate POSIX error codes.  */
 169     switch (__error)
 170       {
 171       case REG_BADPAT:
 172       case REG_ECOLLATE:
 173       case REG_ECTYPE:
 174       case REG_EESCAPE:
 175       case REG_BADRPT:
 176       case REG_EEND:
 177       case REG_ERPAREN:
 178       default:
 179         /* There is no matching error code.  */
 180         RETURN (36);
 181       case REG_ESUBREG:
 182         RETURN (25);
 183       case REG_EBRACK:
 184         RETURN (49);
 185       case REG_EPAREN:
 186         RETURN (42);
 187       case REG_EBRACE:
 188         RETURN (44);
 189       case REG_BADBR:
 190         RETURN (46);
 191       case REG_ERANGE:
 192         RETURN (11);
 193       case REG_ESPACE:
 194       case REG_ESIZE:
 195         ERROR (50);
 196       }
 197
 198   /* Everything is ok.  */
 199   RETURN ((char *) (__expr_ptr->buffer + __expr_ptr->used));
 200 }
 201 #endif
 202
 203
 204 /* Find the next match in STRING.  The compiled regular expression is
 205    found in the buffer starting at EXPBUF.  `loc1' will return the
 206    first character matched and `loc2' points to the next unmatched
 207    character.  */
 208 extern int step __P ((__const char *__string, __const char *__expbuf));
 209
 210 /* Match the beginning of STRING with the compiled regular expression
 211    in EXPBUF.  If the match is successful `loc2' will contain the
 212    position of the first unmatched character.  */
 213 extern int advance __P ((__const char *__string, __const char *__expbuf));
 214
 215
 216 __END_DECLS
 217
 218 #endif /* regexp.h */