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

Diff of /code/trunk/pcre_compile.c

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

revision 640 by ph10, Mon Jul 25 10:50:28 2011 UTC revision 643 by ph10, Fri Jul 29 15:56:39 2011 UTC
# Line 546  static const unsigned char ebcdic_charta Line 546  static const unsigned char ebcdic_charta
546  /* Definition to allow mutual recursion */  /* Definition to allow mutual recursion */
547    
548  static BOOL  static BOOL
549    compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int *,    compile_regex(int, uschar **, const uschar **, int *, BOOL, BOOL, int, int,
550      int *, branch_chain *, compile_data *, int *);      int *, int *, branch_chain *, compile_data *, int *);
551    
552    
553    
# Line 3035  Arguments: Line 3035  Arguments:
3035    firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)    firstbyteptr   set to initial literal character, or < 0 (REQ_UNSET, REQ_NONE)
3036    reqbyteptr     set to the last literal character required, else < 0    reqbyteptr     set to the last literal character required, else < 0
3037    bcptr          points to current branch chain    bcptr          points to current branch chain
3038      cond_depth     conditional nesting depth
3039    cd             contains pointers to tables etc.    cd             contains pointers to tables etc.
3040    lengthptr      NULL during the real compile phase    lengthptr      NULL during the real compile phase
3041                   points to length accumulator during pre-compile phase                   points to length accumulator during pre-compile phase
# Line 3046  Returns:         TRUE on success Line 3047  Returns:         TRUE on success
3047  static BOOL  static BOOL
3048  compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,  compile_branch(int *optionsptr, uschar **codeptr, const uschar **ptrptr,
3049    int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,    int *errorcodeptr, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
3050    compile_data *cd, int *lengthptr)    int cond_depth, compile_data *cd, int *lengthptr)
3051  {  {
3052  int repeat_type, op_type;  int repeat_type, op_type;
3053  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */  int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
# Line 4996  for (;; ptr++) Line 4997  for (;; ptr++)
4997        previous = NULL;        previous = NULL;
4998        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};        while ((cd->ctypes[*++ptr] & ctype_letter) != 0) {};
4999        namelen = (int)(ptr - name);        namelen = (int)(ptr - name);
5000    
5001          /* It appears that Perl allows any characters whatsoever, other than
5002          a closing parenthesis, to appear in arguments, so we no longer insist on
5003          letters, digits, and underscores. */
5004    
5005        if (*ptr == CHAR_COLON)        if (*ptr == CHAR_COLON)
5006          {          {
5007          arg = ++ptr;          arg = ++ptr;
5008          while ((cd->ctypes[*ptr] & (ctype_letter|ctype_digit)) != 0          while (*ptr != 0 && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
           || *ptr == '_') ptr++;  
5009          arglen = (int)(ptr - arg);          arglen = (int)(ptr - arg);
5010          }          }
5011    
5012        if (*ptr != CHAR_RIGHT_PARENTHESIS)        if (*ptr != CHAR_RIGHT_PARENTHESIS)
5013          {          {
5014          *errorcodeptr = ERR60;          *errorcodeptr = ERR60;
# Line 5759  for (;; ptr++) Line 5763  for (;; ptr++)
5763    
5764              /* If not a forward reference, and the subpattern is still open,              /* If not a forward reference, and the subpattern is still open,
5765              this is a recursive call. We check to see if this is a left              this is a recursive call. We check to see if this is a left
5766              recursion that could loop for ever, and diagnose that case. */              recursion that could loop for ever, and diagnose that case. We
5767                must not, however, do this check if we are in a conditional
5768                subpattern because the condition might be testing for recursion in
5769                a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.
5770                Forever loops are also detected at runtime, so those that occur in
5771                conditional subpatterns will be picked up then. */
5772    
5773              else if (GET(called, 1) == 0 &&              else if (GET(called, 1) == 0 && cond_depth <= 0 &&
5774                       could_be_empty(called, code, bcptr, utf8, cd))                       could_be_empty(called, code, bcptr, utf8, cd))
5775                {                {
5776                *errorcodeptr = ERR40;                *errorcodeptr = ERR40;
# Line 5893  for (;; ptr++) Line 5902  for (;; ptr++)
5902      repeated. We copy code into a non-register variable (tempcode) in order to      repeated. We copy code into a non-register variable (tempcode) in order to
5903      be able to pass its address because some compilers complain otherwise. */      be able to pass its address because some compilers complain otherwise. */
5904    
5905      previous = code;                   /* For handling repetition */      previous = code;                      /* For handling repetition */
5906      *code = bravalue;      *code = bravalue;
5907      tempcode = code;      tempcode = code;
5908      tempreqvary = cd->req_varyopt;     /* Save value before bracket */      tempreqvary = cd->req_varyopt;        /* Save value before bracket */
5909      length_prevgroup = 0;              /* Initialize for pre-compile phase */      length_prevgroup = 0;                 /* Initialize for pre-compile phase */
5910    
5911      if (!compile_regex(      if (!compile_regex(
5912           newoptions,                   /* The complete new option state */           newoptions,                      /* The complete new option state */
5913           &tempcode,                    /* Where to put code (updated) */           &tempcode,                       /* Where to put code (updated) */
5914           &ptr,                         /* Input pointer (updated) */           &ptr,                            /* Input pointer (updated) */
5915           errorcodeptr,                 /* Where to put an error message */           errorcodeptr,                    /* Where to put an error message */
5916           (bravalue == OP_ASSERTBACK ||           (bravalue == OP_ASSERTBACK ||
5917            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */            bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
5918           reset_bracount,               /* True if (?| group */           reset_bracount,                  /* True if (?| group */
5919           skipbytes,                    /* Skip over bracket number */           skipbytes,                       /* Skip over bracket number */
5920           &subfirstbyte,                /* For possible first char */           cond_depth +
5921           &subreqbyte,                  /* For possible last char */             ((bravalue == OP_COND)?1:0),   /* Depth of condition subpatterns */
5922           bcptr,                        /* Current branch chain */           &subfirstbyte,                   /* For possible first char */
5923           cd,                           /* Tables block */           &subreqbyte,                     /* For possible last char */
5924           (lengthptr == NULL)? NULL :   /* Actual compile phase */           bcptr,                           /* Current branch chain */
5925             &length_prevgroup           /* Pre-compile phase */           cd,                              /* Tables block */
5926             (lengthptr == NULL)? NULL :      /* Actual compile phase */
5927               &length_prevgroup              /* Pre-compile phase */
5928           ))           ))
5929        goto FAILED;        goto FAILED;
5930    
# Line 6371  Arguments: Line 6382  Arguments:
6382    lookbehind     TRUE if this is a lookbehind assertion    lookbehind     TRUE if this is a lookbehind assertion
6383    reset_bracount TRUE to reset the count for each branch    reset_bracount TRUE to reset the count for each branch
6384    skipbytes      skip this many bytes at start (for brackets and OP_COND)    skipbytes      skip this many bytes at start (for brackets and OP_COND)
6385      cond_depth     depth of nesting for conditional subpatterns
6386    firstbyteptr   place to put the first required character, or a negative number    firstbyteptr   place to put the first required character, or a negative number
6387    reqbyteptr     place to put the last required character, or a negative number    reqbyteptr     place to put the last required character, or a negative number
6388    bcptr          pointer to the chain of currently open branches    bcptr          pointer to the chain of currently open branches
# Line 6384  Returns:         TRUE on success Line 6396  Returns:         TRUE on success
6396  static BOOL  static BOOL
6397  compile_regex(int options, uschar **codeptr, const uschar **ptrptr,  compile_regex(int options, uschar **codeptr, const uschar **ptrptr,
6398    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,    int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
6399    int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr, compile_data *cd,    int cond_depth, int *firstbyteptr, int *reqbyteptr, branch_chain *bcptr,
6400    int *lengthptr)    compile_data *cd, int *lengthptr)
6401  {  {
6402  const uschar *ptr = *ptrptr;  const uschar *ptr = *ptrptr;
6403  uschar *code = *codeptr;  uschar *code = *codeptr;
# Line 6464  for (;;) Line 6476  for (;;)
6476    into the length. */    into the length. */
6477    
6478    if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,    if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstbyte,
6479          &branchreqbyte, &bc, cd, (lengthptr == NULL)? NULL : &length))          &branchreqbyte, &bc, cond_depth, cd,
6480            (lengthptr == NULL)? NULL : &length))
6481      {      {
6482      *ptrptr = ptr;      *ptrptr = ptr;
6483      return FALSE;      return FALSE;
# Line 7190  ptr += skipatstart; Line 7203  ptr += skipatstart;
7203  code = cworkspace;  code = cworkspace;
7204  *code = OP_BRA;  *code = OP_BRA;
7205  (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,  (void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
7206    FALSE, 0, &firstbyte, &reqbyte, NULL, cd, &length);    FALSE, 0, 0, &firstbyte, &reqbyte, NULL, cd, &length);
7207  if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;  if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
7208    
7209  DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,  DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
# Line 7263  of the function here. */ Line 7276  of the function here. */
7276  ptr = (const uschar *)pattern + skipatstart;  ptr = (const uschar *)pattern + skipatstart;
7277  code = (uschar *)codestart;  code = (uschar *)codestart;
7278  *code = OP_BRA;  *code = OP_BRA;
7279  (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0,  (void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
7280    &firstbyte, &reqbyte, NULL, cd, NULL);    &firstbyte, &reqbyte, NULL, cd, NULL);
7281  re->top_bracket = cd->bracount;  re->top_bracket = cd->bracount;
7282  re->top_backref = cd->top_backref;  re->top_backref = cd->top_backref;

Legend:
Removed from v.640  
changed lines
  Added in v.643

  ViewVC Help
Powered by ViewVC 1.1.5