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