/[pcre]/code/trunk/pcreposix.c
ViewVC logotype

Diff of /code/trunk/pcreposix.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3 by nigel, Sat Feb 24 21:38:01 2007 UTC revision 43 by nigel, Sat Feb 24 21:39:21 2007 UTC
# Line 12  functions. Line 12  functions.
12    
13  Written by: Philip Hazel <ph10@cam.ac.uk>  Written by: Philip Hazel <ph10@cam.ac.uk>
14    
15             Copyright (c) 1997 University of Cambridge             Copyright (c) 1997-2000 University of Cambridge
16    
17  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
18  Permission is granted to anyone to use this software for any purpose on any  Permission is granted to anyone to use this software for any purpose on any
# Line 28  restrictions: Line 28  restrictions:
28    
29  3. Altered versions must be plainly marked as such, and must not be  3. Altered versions must be plainly marked as such, and must not be
30     misrepresented as being the original software.     misrepresented as being the original software.
31    
32    4. If PCRE is embedded in any software that is released under the GNU
33       General Purpose Licence (GPL), then the terms of that licence shall
34       supersede any condition above with which it is incompatible.
35  -----------------------------------------------------------------------------  -----------------------------------------------------------------------------
36  */  */
37    
# Line 39  restrictions: Line 43  restrictions:
43    
44  /* Corresponding tables of PCRE error messages and POSIX error codes. */  /* Corresponding tables of PCRE error messages and POSIX error codes. */
45    
46  static char *estring[] = {  static const char *estring[] = {
47    ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,  ERR10,    ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,  ERR10,
48    ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19, ERR20,    ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19, ERR20,
49    ERR21, ERR22, ERR23 };    ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR29, ERR29, ERR30,
50      ERR31 };
51    
52  static int eint[] = {  static int eint[] = {
53    REG_EESCAPE, /* "\\ at end of pattern" */    REG_EESCAPE, /* "\\ at end of pattern" */
# Line 67  static int eint[] = { Line 72  static int eint[] = {
72    REG_ESIZE,   /* "regular expression too large" */    REG_ESIZE,   /* "regular expression too large" */
73    REG_ESPACE,  /* "failed to get memory" */    REG_ESPACE,  /* "failed to get memory" */
74    REG_EPAREN,  /* "unmatched brackets" */    REG_EPAREN,  /* "unmatched brackets" */
75    REG_ASSERT   /* "internal error: code overflow" */    REG_ASSERT,  /* "internal error: code overflow" */
76      REG_BADPAT,  /* "unrecognized character after (?<" */
77      REG_BADPAT,  /* "lookbehind assertion is not fixed length" */
78      REG_BADPAT,  /* "malformed number after (?(" */
79      REG_BADPAT,  /* "conditional group containe more than two branches" */
80      REG_BADPAT,  /* "assertion expected after (?(" */
81      REG_BADPAT,  /* "(?p must be followed by )" */
82      REG_ECTYPE,  /* "unknown POSIX class name" */
83      REG_BADPAT   /* "POSIX collating elements are not supported" */
84  };  };
85    
86  /* Table of texts corresponding to POSIX error codes */  /* Table of texts corresponding to POSIX error codes */
87    
88  static char *pstring[] = {  static const char *pstring[] = {
89    "",                                /* Dummy for value 0 */    "",                                /* Dummy for value 0 */
90    "internal error",                  /* REG_ASSERT */    "internal error",                  /* REG_ASSERT */
91    "invalid repeat counts in {}",     /* BADBR      */    "invalid repeat counts in {}",     /* BADBR      */
# Line 106  look them up in a table to turn them int Line 119  look them up in a table to turn them int
119  static int  static int
120  pcre_posix_error_code(const char *s)  pcre_posix_error_code(const char *s)
121  {  {
122  int i;  size_t i;
123  for (i = 0; i < sizeof(estring)/sizeof(char *); i++)  for (i = 0; i < sizeof(estring)/sizeof(char *); i++)
124    if (strcmp(s, estring[i]) == 0) return eint[i];    if (strcmp(s, estring[i]) == 0) return eint[i];
125  return REG_ASSERT;  return REG_ASSERT;
# Line 121  return REG_ASSERT; Line 134  return REG_ASSERT;
134  size_t  size_t
135  regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)  regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
136  {  {
137  char *message, *addmessage;  const char *message, *addmessage;
138  int length, adlength;  size_t length, addlength;
139    
140  message = (errcode >= sizeof(pstring)/sizeof(char *))?  message = (errcode >= (int)(sizeof(pstring)/sizeof(char *)))?
141    "unknown error code" : pstring[errcode];    "unknown error code" : pstring[errcode];
142    length = strlen(message) + 1;
143    
144  length = (int)strlen(message) + 1;  addmessage = " at offset ";
145    addlength = (preg != NULL && (int)preg->re_erroffset != -1)?
146  if (preg != NULL && (int)preg->re_erroffset != -1)    strlen(addmessage) + 6 : 0;
   {  
   addmessage = " at offset ";  
   adlength = (int)strlen(addmessage) + 6;  
   }  
 else adlength = 0;  
147    
148  if (errbuf_size > 0)  if (errbuf_size > 0)
149    {    {
150    if (adlength > 0 && errbuf_size >= length + adlength)    if (addlength > 0 && errbuf_size >= length + addlength)
151      sprintf(errbuf, "%s%s%-6d", message, addmessage, preg->re_erroffset);      sprintf(errbuf, "%s%s%-6d", message, addmessage, (int)preg->re_erroffset);
152    else    else
153      {      {
154      strncpy(errbuf, message, errbuf_size - 1);      strncpy(errbuf, message, errbuf_size - 1);
# Line 147  if (errbuf_size > 0) Line 156  if (errbuf_size > 0)
156      }      }
157    }    }
158    
159  return length + adlength;  return length + addlength;
160  }  }
161    
162    
# Line 183  Returns:      0 on success Line 192  Returns:      0 on success
192  int  int
193  regcomp(regex_t *preg, const char *pattern, int cflags)  regcomp(regex_t *preg, const char *pattern, int cflags)
194  {  {
195  char *errorptr;  const char *errorptr;
196  int erroffset;  int erroffset;
197  int options = 0;  int options = 0;
198    
199  if ((cflags & REG_ICASE) != 0) options |= PCRE_CASELESS;  if ((cflags & REG_ICASE) != 0) options |= PCRE_CASELESS;
200  if ((cflags & REG_NEWLINE) != 0) options |= PCRE_MULTILINE;  if ((cflags & REG_NEWLINE) != 0) options |= PCRE_MULTILINE;
201    
202  preg->re_pcre = pcre_compile(pattern, options, &errorptr, &erroffset);  preg->re_pcre = pcre_compile(pattern, options, &errorptr, &erroffset, NULL);
203  preg->re_erroffset = erroffset;  preg->re_erroffset = erroffset;
204    
205  if (preg->re_pcre == NULL) return pcre_posix_error_code(errorptr);  if (preg->re_pcre == NULL) return pcre_posix_error_code(errorptr);
# Line 206  return 0; Line 215  return 0;
215  *              Match a regular expression        *  *              Match a regular expression        *
216  *************************************************/  *************************************************/
217    
218    /* Unfortunately, PCRE requires 3 ints of working space for each captured
219    substring, so we have to get and release working store instead of just using
220    the POSIX structures as was done in earlier releases when PCRE needed only 2
221    ints. */
222    
223  int  int
224  regexec(regex_t *preg, const char *string, size_t nmatch,  regexec(regex_t *preg, const char *string, size_t nmatch,
225    regmatch_t pmatch[], int eflags)    regmatch_t pmatch[], int eflags)
226  {  {
227  int rc;  int rc;
228  int options = 0;  int options = 0;
229    int *ovector = NULL;
230    
231  if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;  if ((eflags & REG_NOTBOL) != 0) options |= PCRE_NOTBOL;
232  if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;  if ((eflags & REG_NOTEOL) != 0) options |= PCRE_NOTEOL;
233    
234  preg->re_erroffset = -1;   /* Only has meaning after compile */  preg->re_erroffset = (size_t)(-1);   /* Only has meaning after compile */
235    
236    if (nmatch > 0)
237      {
238      ovector = (int *)malloc(sizeof(int) * nmatch * 3);
239      if (ovector == NULL) return REG_ESPACE;
240      }
241    
242  rc = pcre_exec(preg->re_pcre, NULL, string, (int)strlen(string), options,  rc = pcre_exec(preg->re_pcre, NULL, string, (int)strlen(string), 0, options,
243    (int *)pmatch, nmatch * 2);    ovector, nmatch * 3);
244    
245  if (rc == 0) return 0;    /* All pmatch were filled in */  if (rc == 0) rc = nmatch;    /* All captured slots were filled in */
246    
247  if (rc > 0)  if (rc >= 0)
248    {    {
249    int i;    size_t i;
250    for (i = rc; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;    for (i = 0; i < rc; i++)
251        {
252        pmatch[i].rm_so = ovector[i*2];
253        pmatch[i].rm_eo = ovector[i*2+1];
254        }
255      if (ovector != NULL) free(ovector);
256      for (; i < nmatch; i++) pmatch[i].rm_so = pmatch[i].rm_eo = -1;
257    return 0;    return 0;
258    }    }
259    
260  else switch(rc)  else
261    {    {
262    case PCRE_ERROR_NOMATCH: return REG_NOMATCH;    if (ovector != NULL) free(ovector);
263    case PCRE_ERROR_BADREF: return REG_ESUBREG;    switch(rc)
264    case PCRE_ERROR_NULL: return REG_INVARG;      {
265    case PCRE_ERROR_BADOPTION: return REG_INVARG;      case PCRE_ERROR_NOMATCH: return REG_NOMATCH;
266    case PCRE_ERROR_BADMAGIC: return REG_INVARG;      case PCRE_ERROR_NULL: return REG_INVARG;
267    case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;      case PCRE_ERROR_BADOPTION: return REG_INVARG;
268    case PCRE_ERROR_NOMEMORY: return REG_ESPACE;      case PCRE_ERROR_BADMAGIC: return REG_INVARG;
269    default: return REG_ASSERT;      case PCRE_ERROR_UNKNOWN_NODE: return REG_ASSERT;
270        case PCRE_ERROR_NOMEMORY: return REG_ESPACE;
271        default: return REG_ASSERT;
272        }
273    }    }
274  }  }
275    

Legend:
Removed from v.3  
changed lines
  Added in v.43

  ViewVC Help
Powered by ViewVC 1.1.5