/[pcre]/code/trunk/pcre_internal.h

Diff of /code/trunk/pcre_internal.h

Parent Directory | Revision Log | View Patch Patch

-revision 87 by nigel,
Sat Feb 24 21:41:21 2007 UTC
+revision 150 by ph10,
Tue Apr 17 08:22:40 2007 UTC
 Line 7
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2006 University of Cambridge
+            Copyright (c) 1997-2007 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 54 
 functions whose names all begin with "_p
  /* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
  inline, and there are *still* stupid compilers about that don't like indented
  pre-processor statements, or at least there were when I first wrote this. After
- all, it had only been about 10 years then... */
+ all, it had only been about 10 years then...
+ It turns out that the Mac Debugging.h header also defines the macro DPRINTF, so
+ be absolutely sure we get our version. */
+ #undef DPRINTF
  #ifdef DEBUG
  #define DPRINTF(p) printf p
  #else
- #define DPRINTF(p) /*nothing*/
+ #define DPRINTF(p) /* Nothing */
  #endif
-Line 79 
 setjmp and stdarg are used is when NO_RE
+Line 83 
 setjmp and stdarg are used is when NO_RE
  #include <stdlib.h>
  #include <string.h>
- #ifndef PCRE_SPY
+ /* When compiling a DLL for Windows, the exported symbols have to be declared
- #define PCRE_DEFINITION       /* Win32 __declspec(export) trigger for .dll */
+ using some MS magic. I found some useful information on this web page:
+ http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the
+ information there, using __declspec(dllesport) without "extern" we have a
+ definition; with "extern" we have a declaration. The settings here override the
+ setting in pcre.h (which is included below); it defines only PCRE_EXP_DECL,
+ which is all that is needed for applications, which import the symbols. We use:
+   PCRE_EXP_DECL       for declarations
+   PCRE_EXP_DEFN       for definitions of exported functions
+   PCRE_EXP_DATA_DEFN  for definitions of exported variables
+ The reason for the two DEFN macros is that in non-Windows environments, one
+ does not want to have "extern" before variable definitions because it leads to
+ compiler warnings. So we distinguish between functions and variables. In
+ Windows, the two should always be the same.
+ The reason for wrapping this in #ifndef PCRE_EXP_DECL is so that pcretest,
+ which is an application, but needs to import this file in order to "peek" at
+ internals, can #include pcre.h first, can get an application's-eye view.
+ In principle, people compiling for non-Windows, non-Unix-like (i.e. uncommon,
+ special-purpose environments) might want to stick other stuff in front of
+ exported symbols. That's why, in the non-Windows case, we set PCRE_EXP_DEFN and
+ PCRE_EXP_DATA_DEFN only if they are not already set. */
+ #ifndef PCRE_EXP_DECL
+ #  ifdef _WIN32
+ #    ifdef DLL_EXPORT
+ #      define PCRE_EXP_DECL       extern __declspec(dllexport)
+ #      define PCRE_EXP_DEFN       __declspec(dllexport)
+ #      define PCRE_EXP_DATA_DEFN  __declspec(dllexport)
+ #    else
+ #      define PCRE_EXP_DECL       extern
+ #      define PCRE_EXP_DEFN
+ #      define PCRE_EXP_DATA_DEFN
+ #    endif
+ #
+ #  else
+ #    ifdef __cplusplus
+ #      define PCRE_EXP_DECL       extern "C"
+ #    else
+ #      define PCRE_EXP_DECL       extern
+ #    endif
+ #    ifndef PCRE_EXP_DEFN
+ #      define PCRE_EXP_DEFN       PCRE_EXP_DECL
+ #    endif
+ #    ifndef PCRE_EXP_DATA_DEFN
+ #      define PCRE_EXP_DATA_DEFN
+ #    endif
+ #  endif
  #endif
  /* We need to have types that specify unsigned 16-bit and 32-bit integers. We
-Line 114 
 Unix, where it is defined in sys/types,
+Line 167 
 Unix, where it is defined in sys/types,
  typedef unsigned char uschar;
+ /* This is an unsigned int value that no character can ever have. UTF-8
+ characters only go up to 0x7fffffff (though Unicode doesn't go beyond
+x0010ffff). */
+ #define NOTACHAR 0xffffffff
+ /* PCRE is able to support several different kinds of newline (CR, LF, CRLF,
+ "any" and "anycrlf" at present). The following macros are used to package up
+ testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various
+ modules to indicate in which datablock the parameters exist, and what the
+ start/end of string field names are. */
+ #define NLTYPE_FIXED    0     /* Newline is a fixed length string */
+ #define NLTYPE_ANY      1     /* Newline is any Unicode line ending */
+ #define NLTYPE_ANYCRLF  2     /* Newline is CR, LF, or CRLF */
+ /* This macro checks for a newline at the given position */
+ #define IS_NEWLINE(p) \
+   ((NLBLOCK->nltype != NLTYPE_FIXED)? \
+     ((p) < NLBLOCK->PSEND && \
+      _pcre_is_newline((p), NLBLOCK->nltype, NLBLOCK->PSEND, &(NLBLOCK->nllen),\
+        utf8)) \
+     : \
+     ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
+      (p)[0] == NLBLOCK->nl[0] && \
+      (NLBLOCK->nllen == 1 || (p)[1] == NLBLOCK->nl[1]) \
+     ) \
+   )
+ /* This macro checks for a newline immediately preceding the given position */
+ #define WAS_NEWLINE(p) \
+   ((NLBLOCK->nltype != NLTYPE_FIXED)? \
+     ((p) > NLBLOCK->PSSTART && \
+      _pcre_was_newline((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
+        &(NLBLOCK->nllen), utf8)) \
+     : \
+     ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
+      (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \
+      (NLBLOCK->nllen == 1 || (p)[-NLBLOCK->nllen+1] == NLBLOCK->nl[1]) \
+     ) \
+   )
  /* When PCRE is compiled as a C++ library, the subject pointer can be replaced
  with a custom type. This makes it possible, for example, to allow pcre_exec()
  to process subject strings that are discontinuous by using a smart pointer
-Line 131 
 must begin with PCRE_. */
+Line 228 
 must begin with PCRE_. */
  #define USPTR const unsigned char *
  #endif
  /* Include the public PCRE header and the definitions of UCP character property
  values. */
- #include "pcre.h"
+ #include <pcre.h>
  #include "ucp.h"
  /* When compiling for use with the Virtual Pascal compiler, these functions
-Line 142 
 need to have their names changed. PCRE m
+Line 241 
 need to have their names changed. PCRE m
  option on the command line. */
  #ifdef VPCOMPAT
+ #define strlen(s)        _strlen(s)
  #define strncmp(s1,s2,m) _strncmp(s1,s2,m)
+ #define memcmp(s,c,n)    _memcmp(s,c,n)
  #define memcpy(d,s,n)    _memcpy(d,s,n)
  #define memmove(d,s,n)   _memmove(d,s,n)
  #define memset(s,c,n)    _memset(s,c,n)
-Line 151 
 option on the command line. */
+Line 252 
 option on the command line. */
  /* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),
  define a macro for memmove() if HAVE_MEMMOVE is false, provided that HAVE_BCOPY
  is set. Otherwise, include an emulating function for those systems that have
- neither (there some non-Unix environments where this is the case). This assumes
+ neither (there some non-Unix environments where this is the case). */
- that all calls to memmove are moving strings upwards in store, which is the
- case in PCRE. */
- #if ! HAVE_MEMMOVE
+ #ifndef HAVE_MEMMOVE
  #undef  memmove        /* some systems may have a macro */
- #if HAVE_BCOPY
+ #ifdef HAVE_BCOPY
  #define memmove(a, b, c) bcopy(b, a, c)
  #else  /* HAVE_BCOPY */
- void *
+ static void *
- pcre_memmove(unsigned char *dest, const unsigned char *src, size_t n)
+ pcre_memmove(void *d, const void *s, size_t n)
  {
  size_t i;
- dest += n;
+ unsigned char *dest = (unsigned char *)d;
- src += n;
+ const unsigned char *src = (const unsigned char *)s;
- for (i = 0; i < n; ++i) *(--dest) =  *(--src);
+ if (dest > src)
- return dest;
+   {
+   dest += n;
+   src += n;
+   for (i = 0; i < n; ++i) *(--dest) = *(--src);
+   return (void *)dest;
+   }
+ else
+   {
+   for (i = 0; i < n; ++i) *dest++ = *src++;
+   return (void *)(dest - n);
+   }
  }
  #define memmove(a, b, c) pcre_memmove(a, b, c)
  #endif   /* not HAVE_BCOPY */
-Line 270 
 we know we are in UTF-8 mode. */
+Line 379 
 we know we are in UTF-8 mode. */
  #define GETCHAR(c, eptr) \
    c = *eptr; \
-   if ((c & 0xc0) == 0xc0) \
+   if (c >= 0xc0) \
      { \
      int gcii; \
      int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
-Line 288 
 pointer. */
+Line 397 
 pointer. */
  #define GETCHARTEST(c, eptr) \
    c = *eptr; \
-   if (utf8 && (c & 0xc0) == 0xc0) \
+   if (utf8 && c >= 0xc0) \
      { \
      int gcii; \
      int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
-Line 306 
 know we are in UTF-8 mode. */
+Line 415 
 know we are in UTF-8 mode. */
  #define GETCHARINC(c, eptr) \
    c = *eptr++; \
-   if ((c & 0xc0) == 0xc0) \
+   if (c >= 0xc0) \
      { \
      int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
      int gcss = 6*gcaa; \
-Line 322 
 know we are in UTF-8 mode. */
+Line 431 
 know we are in UTF-8 mode. */
  #define GETCHARINCTEST(c, eptr) \
    c = *eptr++; \
-   if (utf8 && (c & 0xc0) == 0xc0) \
+   if (utf8 && c >= 0xc0) \
      { \
      int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
      int gcss = 6*gcaa; \
-Line 339 
 if there are extra bytes. This is called
+Line 448 
 if there are extra bytes. This is called
  #define GETCHARLEN(c, eptr, len) \
    c = *eptr; \
-   if ((c & 0xc0) == 0xc0) \
+   if (c >= 0xc0) \
      { \
      int gcii; \
      int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
-Line 373 
 Standard C system should have one. */
+Line 482 
 Standard C system should have one. */
  #define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)
- /* Private options flags start at the most significant end of the four bytes,
+ /* Private options flags start at the most significant end of the four bytes.
- but skip the top bit so we can use ints for convenience without getting tangled
+ The public options defined in pcre.h start at the least significant end. Make
- with negative values. The public options defined in pcre.h start at the least
+ sure they don't overlap! The bits are getting a bit scarce now -- when we run
- significant end. Make sure they don't overlap! */
+ out, there is a dummy word in the structure that could be used for the private
+ bits. */
+ #define PCRE_NOPARTIAL     0x80000000  /* can't use partial with this regex */
  #define PCRE_FIRSTSET      0x40000000  /* first_byte is set */
  #define PCRE_REQCHSET      0x20000000  /* req_byte is set */
  #define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */
- #define PCRE_ICHANGED      0x08000000  /* i option changes within regex */
+ #define PCRE_JCHANGED      0x08000000  /* j option changes within regex */
- #define PCRE_NOPARTIAL     0x04000000  /* can't use partial with this regex */
  /* Options for the "extra" block produced by pcre_study(). */
-Line 391 
 significant end. Make sure they don't ov
+Line 501 
 significant end. Make sure they don't ov
  /* Masks for identifying the public options that are permitted at compile
  time, run time, or study time, respectively. */
+ #define PCRE_NEWLINE_BITS (PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_ANY| \
+                            PCRE_NEWLINE_ANYCRLF)
  #define PUBLIC_OPTIONS \
    (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
     PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
-    PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE)
+    PCRE_NO_AUTO_CAPTURE|PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE| \
+    PCRE_DUPNAMES|PCRE_NEWLINE_BITS)
  #define PUBLIC_EXEC_OPTIONS \
    (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
-    PCRE_PARTIAL)
+    PCRE_PARTIAL|PCRE_NEWLINE_BITS)
  #define PUBLIC_DFA_EXEC_OPTIONS \
    (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
-    PCRE_PARTIAL|PCRE_DFA_SHORTEST|PCRE_DFA_RESTART)
+    PCRE_PARTIAL|PCRE_DFA_SHORTEST|PCRE_DFA_RESTART|PCRE_NEWLINE_BITS)
  #define PUBLIC_STUDY_OPTIONS 0   /* None defined */
-Line 434 
 typedef int BOOL;
+Line 548 
 typedef int BOOL;
  #define FALSE   0
  #define TRUE    1
- /* Escape items that are just an encoding of a particular data value. Note that
+ /* Escape items that are just an encoding of a particular data value. */
- ESC_n is defined as yet another macro, which is set in config.h to either \n
- (the default) or \r (which some people want). */
  #ifndef ESC_e
  #define ESC_e 27
-Line 447 
 ESC_n is defined as yet another macro, w
+Line 559 
 ESC_n is defined as yet another macro, w
  #endif
  #ifndef ESC_n
- #define ESC_n NEWLINE
+ #define ESC_n '\n'
  #endif
  #ifndef ESC_r
-Line 486 
 value such as \n. They must have non-zer
+Line 598 
 value such as \n. They must have non-zer
  their negation. Also, they must appear in the same order as in the opcode
  definitions below, up to ESC_z. There's a dummy for OP_ANY because it
  corresponds to "." rather than an escape sequence. The final one must be
- ESC_REF as subsequent values are used for \1, \2, \3, etc. There is are two
+ ESC_REF as subsequent values are used for backreferences (\1, \2, \3, etc).
- tests in the code for an escape greater than ESC_b and less than ESC_Z to
+ There are two tests in the code for an escape greater than ESC_b and less than
- detect the types that may be repeated. These are the types that consume
+ ESC_Z to detect the types that may be repeated. These are the types that
- characters. If any new escapes are put in between that don't consume a
+ consume characters. If any new escapes are put in between that don't consume a
  character, that code will have to change. */
  enum { ESC_A = 1, ESC_G, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W,
-        ESC_w, ESC_dum1, ESC_C, ESC_P, ESC_p, ESC_X, ESC_Z, ESC_z, ESC_E,
+        ESC_w, ESC_dum1, ESC_C, ESC_P, ESC_p, ESC_R, ESC_X, ESC_Z, ESC_z,
-        ESC_Q, ESC_REF };
+        ESC_E, ESC_Q, ESC_k, ESC_REF };
  /* Opcode table: OP_BRA must be last, as all values >= it are used for brackets
  that extract substrings. Starting from 1 (i.e. after OP_END), the values up to
  OP_EOD must correspond in order to the list of escapes immediately above.
- Note that whenever this list is updated, the two macro definitions that follow
- must also be updated to match. */
+ To keep stored, compiled patterns compatible, new opcodes should be added
+ immediately before OP_BRA, where (since release 7.0) a gap is left for this
+ purpose.
+ *** NOTE NOTE NOTE *** Whenever this list is updated, the two macro definitions
+ that follow must also be updated to match. There is also a table called
+ "coptable" in pcre_dfa_exec.c that must be updated. */
  enum {
    OP_END,            /* 0 End of pattern */
-Line 521 
 enum {
+Line 640 
 enum {
    OP_ANYBYTE,        /* 12 Match any byte (\C); different to OP_ANY for UTF-8 */
    OP_NOTPROP,        /* 13 \P (not Unicode property) */
    OP_PROP,           /* 14 \p (Unicode property) */
-   OP_EXTUNI,         /* 15 \X (extended Unicode sequence */
+   OP_ANYNL,          /* 15 \R (any newline sequence) */
-   OP_EODN,           /* 16 End of data or \n at end of data: \Z. */
+   OP_EXTUNI,         /* 16 \X (extended Unicode sequence */
-   OP_EOD,            /* 17 End of data: \z */
+   OP_EODN,           /* 17 End of data or \n at end of data: \Z. */
+   OP_EOD,            /* 18 End of data: \z */
-   OP_OPT,            /* 18 Set runtime options */
-   OP_CIRC,           /* 19 Start of line - varies with multiline switch */
+   OP_OPT,            /* 19 Set runtime options */
-   OP_DOLL,           /* 20 End of line - varies with multiline switch */
+   OP_CIRC,           /* 20 Start of line - varies with multiline switch */
-   OP_CHAR,           /* 21 Match one character, casefully */
+   OP_DOLL,           /* 21 End of line - varies with multiline switch */
-   OP_CHARNC,         /* 22 Match one character, caselessly */
+   OP_CHAR,           /* 22 Match one character, casefully */
-   OP_NOT,            /* 23 Match anything but the following char */
+   OP_CHARNC,         /* 23 Match one character, caselessly */
+   OP_NOT,            /* 24 Match one character, not the following one */
-   OP_STAR,           /* 24 The maximizing and minimizing versions of */
-   OP_MINSTAR,        /* 25 all these opcodes must come in pairs, with */
+   OP_STAR,           /* 25 The maximizing and minimizing versions of */
-   OP_PLUS,           /* 26 the minimizing one second. */
+   OP_MINSTAR,        /* 26 these six opcodes must come in pairs, with */
-   OP_MINPLUS,        /* 27 This first set applies to single characters */
+   OP_PLUS,           /* 27 the minimizing one second. */
-   OP_QUERY,          /* 28 */
+   OP_MINPLUS,        /* 28 This first set applies to single characters.*/
-   OP_MINQUERY,       /* 29 */
+   OP_QUERY,          /* 29 */
-   OP_UPTO,           /* 30 From 0 to n matches */
+   OP_MINQUERY,       /* 30 */
-   OP_MINUPTO,        /* 31 */
-   OP_EXACT,          /* 32 Exactly n matches */
+   OP_UPTO,           /* 31 From 0 to n matches */
+   OP_MINUPTO,        /* 32 */
-   OP_NOTSTAR,        /* 33 The maximizing and minimizing versions of */
+   OP_EXACT,          /* 33 Exactly n matches */
-   OP_NOTMINSTAR,     /* 34 all these opcodes must come in pairs, with */
-   OP_NOTPLUS,        /* 35 the minimizing one second. */
+   OP_POSSTAR,        /* 34 Possessified star */
-   OP_NOTMINPLUS,     /* 36 This set applies to "not" single characters */
+   OP_POSPLUS,        /* 35 Possessified plus */
-   OP_NOTQUERY,       /* 37 */
+   OP_POSQUERY,       /* 36 Posesssified query */
-   OP_NOTMINQUERY,    /* 38 */
+   OP_POSUPTO,        /* 37 Possessified upto */
-   OP_NOTUPTO,        /* 39 From 0 to n matches */
-   OP_NOTMINUPTO,     /* 40 */
+   OP_NOTSTAR,        /* 38 The maximizing and minimizing versions of */
-   OP_NOTEXACT,       /* 41 Exactly n matches */
+   OP_NOTMINSTAR,     /* 39 these six opcodes must come in pairs, with */
+   OP_NOTPLUS,        /* 40 the minimizing one second. They must be in */
-   OP_TYPESTAR,       /* 42 The maximizing and minimizing versions of */
+   OP_NOTMINPLUS,     /* 41 exactly the same order as those above. */
-   OP_TYPEMINSTAR,    /* 43 all these opcodes must come in pairs, with */
+   OP_NOTQUERY,       /* 42 This set applies to "not" single characters. */
-   OP_TYPEPLUS,       /* 44 the minimizing one second. These codes must */
+   OP_NOTMINQUERY,    /* 43 */
-   OP_TYPEMINPLUS,    /* 45 be in exactly the same order as those above. */
-   OP_TYPEQUERY,      /* 46 This set applies to character types such as \d */
+   OP_NOTUPTO,        /* 44 From 0 to n matches */
-   OP_TYPEMINQUERY,   /* 47 */
+   OP_NOTMINUPTO,     /* 45 */
-   OP_TYPEUPTO,       /* 48 From 0 to n matches */
+   OP_NOTEXACT,       /* 46 Exactly n matches */
-   OP_TYPEMINUPTO,    /* 49 */
-   OP_TYPEEXACT,      /* 50 Exactly n matches */
+   OP_NOTPOSSTAR,     /* 47 Possessified versions */
+   OP_NOTPOSPLUS,     /* 48 */
-   OP_CRSTAR,         /* 51 The maximizing and minimizing versions of */
+   OP_NOTPOSQUERY,    /* 49 */
-   OP_CRMINSTAR,      /* 52 all these opcodes must come in pairs, with */
+   OP_NOTPOSUPTO,     /* 50 */
-   OP_CRPLUS,         /* 53 the minimizing one second. These codes must */
-   OP_CRMINPLUS,      /* 54 be in exactly the same order as those above. */
+   OP_TYPESTAR,       /* 51 The maximizing and minimizing versions of */
-   OP_CRQUERY,        /* 55 These are for character classes and back refs */
+   OP_TYPEMINSTAR,    /* 52 these six opcodes must come in pairs, with */
-   OP_CRMINQUERY,     /* 56 */
+   OP_TYPEPLUS,       /* 53 the minimizing one second. These codes must */
-   OP_CRRANGE,        /* 57 These are different to the three sets above. */
+   OP_TYPEMINPLUS,    /* 54 be in exactly the same order as those above. */
-   OP_CRMINRANGE,     /* 58 */
+   OP_TYPEQUERY,      /* 55 This set applies to character types such as \d */
+   OP_TYPEMINQUERY,   /* 56 */
+   OP_TYPEUPTO,       /* 57 From 0 to n matches */
+   OP_TYPEMINUPTO,    /* 58 */
+   OP_TYPEEXACT,      /* 59 Exactly n matches */
+   OP_TYPEPOSSTAR,    /* 60 Possessified versions */
+   OP_TYPEPOSPLUS,    /* 61 */
+   OP_TYPEPOSQUERY,   /* 62 */
+   OP_TYPEPOSUPTO,    /* 63 */
+   OP_CRSTAR,         /* 64 The maximizing and minimizing versions of */
+   OP_CRMINSTAR,      /* 65 all these opcodes must come in pairs, with */
+   OP_CRPLUS,         /* 66 the minimizing one second. These codes must */
+   OP_CRMINPLUS,      /* 67 be in exactly the same order as those above. */
+   OP_CRQUERY,        /* 68 These are for character classes and back refs */
+   OP_CRMINQUERY,     /* 69 */
+   OP_CRRANGE,        /* 70 These are different to the three sets above. */
+   OP_CRMINRANGE,     /* 71 */
-   OP_CLASS,          /* 59 Match a character class, chars < 256 only */
+   OP_CLASS,          /* 72 Match a character class, chars < 256 only */
-   OP_NCLASS,         /* 60 Same, but the bitmap was created from a negative
+   OP_NCLASS,         /* 73 Same, but the bitmap was created from a negative
                             class - the difference is relevant only when a UTF-8
                             character > 255 is encountered. */
-   OP_XCLASS,         /* 61 Extended class for handling UTF-8 chars within the
+   OP_XCLASS,         /* 74 Extended class for handling UTF-8 chars within the
                             class. This does both positive and negative. */
-   OP_REF,            /* 62 Match a back reference */
+   OP_REF,            /* 75 Match a back reference */
-   OP_RECURSE,        /* 63 Match a numbered subpattern (possibly recursive) */
+   OP_RECURSE,        /* 76 Match a numbered subpattern (possibly recursive) */
-   OP_CALLOUT,        /* 64 Call out to external function if provided */
+   OP_CALLOUT,        /* 77 Call out to external function if provided */
-   OP_ALT,            /* 65 Start of alternation */
+   OP_ALT,            /* 78 Start of alternation */
-   OP_KET,            /* 66 End of group that doesn't have an unbounded repeat */
+   OP_KET,            /* 79 End of group that doesn't have an unbounded repeat */
-   OP_KETRMAX,        /* 67 These two must remain together and in this */
+   OP_KETRMAX,        /* 80 These two must remain together and in this */
-   OP_KETRMIN,        /* 68 order. They are for groups the repeat for ever. */
+   OP_KETRMIN,        /* 81 order. They are for groups the repeat for ever. */
-   /* The assertions must come before ONCE and COND */
+   /* The assertions must come before BRA, CBRA, ONCE, and COND.*/
-   OP_ASSERT,         /* 69 Positive lookahead */
+   OP_ASSERT,         /* 82 Positive lookahead */
-   OP_ASSERT_NOT,     /* 70 Negative lookahead */
+   OP_ASSERT_NOT,     /* 83 Negative lookahead */
-   OP_ASSERTBACK,     /* 71 Positive lookbehind */
+   OP_ASSERTBACK,     /* 84 Positive lookbehind */
-   OP_ASSERTBACK_NOT, /* 72 Negative lookbehind */
+   OP_ASSERTBACK_NOT, /* 85 Negative lookbehind */
-   OP_REVERSE,        /* 73 Move pointer back - used in lookbehind assertions */
+   OP_REVERSE,        /* 86 Move pointer back - used in lookbehind assertions */
-   /* ONCE and COND must come after the assertions, with ONCE first, as there's
+   /* ONCE, BRA, CBRA, and COND must come after the assertions, with ONCE first,
-   a test for >= ONCE for a subpattern that isn't an assertion. */
+   as there's a test for >= ONCE for a subpattern that isn't an assertion. */
-   OP_ONCE,           /* 74 Once matched, don't back up into the subpattern */
+   OP_ONCE,           /* 87 Atomic group */
-   OP_COND,           /* 75 Conditional group */
+   OP_BRA,            /* 88 Start of non-capturing bracket */
-   OP_CREF,           /* 76 Used to hold an extraction string number (cond ref) */
+   OP_CBRA,           /* 89 Start of capturing bracket */
+   OP_COND,           /* 90 Conditional group */
-   OP_BRAZERO,        /* 77 These two must remain together and in this */
-   OP_BRAMINZERO,     /* 78 order. */
+   /* These three must follow the previous three, in the same order. There's a
+   check for >= SBRA to distinguish the two sets. */
-   OP_BRANUMBER,      /* 79 Used for extracting brackets whose number is greater
-                            than can fit into an opcode. */
+   OP_SBRA,           /* 91 Start of non-capturing bracket, check empty  */
+   OP_SCBRA,          /* 92 Start of capturing bracket, check empty */
-   OP_BRA             /* 80 This and greater values are used for brackets that
+   OP_SCOND,          /* 93 Conditional group, check empty */
-                            extract substrings up to EXTRACT_BASIC_MAX. After
-                            that, use is made of OP_BRANUMBER. */
+   OP_CREF,           /* 94 Used to hold a capture number as condition */
- };
+   OP_RREF,           /* 95 Used to hold a recursion number as condition */
+   OP_DEF,            /* 96 The DEFINE condition */
- /* WARNING WARNING WARNING: There is an implicit assumption in pcre.c and
- study.c that all opcodes are less than 128 in value. This makes handling UTF-8
- character sequences easier. */
- /* The highest extraction number before we have to start using additional
- bytes. (Originally PCRE didn't have support for extraction counts highter than
- this number.) The value is limited by the number of opcodes left after OP_BRA,
- i.e. 255 - OP_BRA. We actually set it a bit lower to leave room for additional
- opcodes. */
- #define EXTRACT_BASIC_MAX  100
+   OP_BRAZERO,        /* 97 These two must remain together and in this */
+   OP_BRAMINZERO      /* 98 order. */
+ };
  /* This macro defines textual names for all the opcodes. These are used only
-Line 633 
 for debugging. The macro is referenced o
+Line 764 
 for debugging. The macro is referenced o
  #define OP_NAME_LIST \
    "End", "\\A", "\\G", "\\B", "\\b", "\\D", "\\d",                \
    "\\S", "\\s", "\\W", "\\w", "Any", "Anybyte",                   \
-   "notprop", "prop", "extuni",                                    \
+   "notprop", "prop", "anynl", "extuni",                           \
    "\\Z", "\\z",                                                   \
    "Opt", "^", "$", "char", "charnc", "not",                       \
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*+","++", "?+", "{",                                           \
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*+","++", "?+", "{",                                           \
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*+","++", "?+", "{",                                           \
    "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
    "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \
    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
-   "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cond ref",\
+   "AssertB", "AssertB not", "Reverse",                            \
-   "Brazero", "Braminzero", "Branumber", "Bra"
+   "Once", "Bra 0", "Bra", "Cond", "SBra 0", "SBra", "SCond",      \
+   "Cond ref", "Cond rec", "Cond def", "Brazero", "Braminzero"
  /* This macro defines the length of fixed length operations in the compiled
-Line 659 
 in UTF-8 mode. The code that uses this t
+Line 794 
 in UTF-8 mode. The code that uses this t
 ,                             /* End                                    */ \
 , 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* \A, \G, \B, \B, \D, \d, \S, \s, \W, \w */ \
 , 1,                          /* Any, Anybyte                           */ \
-, 3, 1,                       /* NOTPROP, PROP, EXTUNI                  */ \
+, 3, 1, 1,                    /* NOTPROP, PROP, EXTUNI, ANYNL           */ \
 , 1, 2, 1, 1,                 /* \Z, \z, Opt, ^, $                      */ \
 ,                             /* Char  - the minimum length             */ \
 ,                             /* Charnc  - the minimum length           */ \
-Line 667 
 in UTF-8 mode. The code that uses this t
+Line 802 
 in UTF-8 mode. The code that uses this t
    /* Positive single-char repeats                            ** These are  */ \
 , 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \
 , 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \
+, 2, 2, 4,                    /* *+, ++, ?+, upto+                      */ \
    /* Negative single-char repeats - only for chars < 256                   */ \
 , 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
 , 4, 4,                       /* NOT upto, minupto, exact               */ \
+, 2, 2, 4,                    /* Possessive *, +, ?, upto               */ \
    /* Positive type repeats                                                 */ \
 , 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
 , 4, 4,                       /* Type upto, minupto, exact              */ \
+, 2, 2, 4,                    /* Possessive *+, ++, ?+, upto+           */ \
    /* Character class & ref repeats                                         */ \
 , 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
 , 5,                          /* CRRANGE, CRMINRANGE                    */ \
-Line 691 
 in UTF-8 mode. The code that uses this t
+Line 829 
 in UTF-8 mode. The code that uses this t
 +LINK_SIZE,                   /* Assert behind                          */ \
 +LINK_SIZE,                   /* Assert behind not                      */ \
 +LINK_SIZE,                   /* Reverse                                */ \
-+LINK_SIZE,                   /* Once                                   */ \
++LINK_SIZE,                   /* ONCE                                   */ \
++LINK_SIZE,                   /* BRA                                    */ \
++LINK_SIZE,                   /* CBRA                                   */ \
 +LINK_SIZE,                   /* COND                                   */ \
++LINK_SIZE,                   /* SBRA                                   */ \
++LINK_SIZE,                   /* SCBRA                                  */ \
++LINK_SIZE,                   /* SCOND                                  */ \
 ,                             /* CREF                                   */ \
+,                             /* RREF                                   */ \
+,                             /* DEF                                    */ \
 , 1,                          /* BRAZERO, BRAMINZERO                    */ \
-,                             /* BRANUMBER                              */ \
-+LINK_SIZE                    /* BRA                                    */ \
- /* A magic value for OP_CREF to indicate the "in recursion" condition. */
+ /* A magic value for OP_RREF to indicate the "any recursion" condition. */
- #define CREF_RECURSE  0xffff
+ #define RREF_ANY  0xffff
  /* Error code numbers. They are given names so that they can more easily be
  tracked. */
-Line 710 
 enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,
+Line 853 
 enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,
         ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19,
         ERR20, ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29,
         ERR30, ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39,
-        ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47 };
+        ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49,
+        ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57 };
  /* The real format of the start of the pcre block; the index of names and the
  code vector run on as long as necessary after the end. We store an explicit
-Line 765 
 typedef struct compile_data {
+Line 909 
 typedef struct compile_data {
    const uschar *fcc;            /* Points to case-flipping table */
    const uschar *cbits;          /* Points to character type table */
    const uschar *ctypes;         /* Points to table of type maps */
+   const uschar *start_workspace;/* The start of working space */
    const uschar *start_code;     /* The start of the compiled code */
    const uschar *start_pattern;  /* The start of the pattern */
+   const uschar *end_pattern;    /* The end of the pattern */
+   uschar *hwm;                  /* High watermark of workspace */
    uschar *name_table;           /* The name/number table */
    int  names_found;             /* Number of entries so far */
    int  name_entry_size;         /* Size of each entry */
+   int  bracount;                /* Count of capturing parens */
    int  top_backref;             /* Maximum back reference */
    unsigned int backref_map;     /* Bitmap of low back refs */
+   int  external_options;        /* External (initial) options */
    int  req_varyopt;             /* "After variable item" flag for reqbyte */
    BOOL nopartial;               /* Set TRUE if partial won't work */
+   int  nltype;                  /* Newline type */
+   int  nllen;                   /* Newline string length */
+   uschar nl[4];                 /* Newline string when fixed length */
  } compile_data;
  /* Structure for maintaining a chain of pointers to the currently incomplete
-Line 798 
 typedef struct recursion_info {
+Line 950 
 typedef struct recursion_info {
  /* When compiling in a mode that doesn't use recursive calls to match(),
  a structure is used to remember local variables on the heap. It is defined in
- pcre.c, close to the match() function, so that it is easy to keep it in step
+ pcre_exec.c, close to the match() function, so that it is easy to keep it in
- with any changes of local variable. However, the pointer to the current frame
+ step with any changes of local variable. However, the pointer to the current
- must be saved in some "static" place over a longjmp(). We declare the
+ frame must be saved in some "static" place over a longjmp(). We declare the
- structure here so that we can put a pointer in the match_data structure.
+ structure here so that we can put a pointer in the match_data structure. NOTE:
- NOTE: This isn't used for a "normal" compilation of pcre. */
+ This isn't used for a "normal" compilation of pcre. */
  struct heapframe;
+ /* Structure for building a chain of data for holding the values of the subject
+ pointer at the start of each subpattern, so as to detect when an empty string
+ has been matched by a subpattern - to break infinite loops. */
+ typedef struct eptrblock {
+   struct eptrblock *epb_prev;
+   USPTR epb_saved_eptr;
+ } eptrblock;
  /* Structure for passing "static" information around between the functions
  doing traditional NFA matching, so that they are thread-safe. */
-Line 816 
 typedef struct match_data {
+Line 978 
 typedef struct match_data {
    int   *offset_vector;         /* Offset vector */
    int    offset_end;            /* One past the end */
    int    offset_max;            /* The maximum usable for return data */
+   int    nltype;                /* Newline type */
+   int    nllen;                 /* Newline string length */
+   uschar nl[4];                 /* Newline string when fixed */
    const uschar *lcc;            /* Points to lower casing table */
    const uschar *ctypes;         /* Points to table of type maps */
    BOOL   offset_overflow;       /* Set if too many extractions */
-Line 834 
 typedef struct match_data {
+Line 999 
 typedef struct match_data {
    int    end_offset_top;        /* Highwater mark at end of match */
    int    capture_last;          /* Most recent capture number */
    int    start_offset;          /* The start offset value */
+   eptrblock *eptrchain;         /* Chain of eptrblocks for tail recursions */
+   int    eptrn;                 /* Next free eptrblock */
    recursion_info *recursive;    /* Linked list of recursion data */
    void  *callout_data;          /* To pass back to callouts */
    struct heapframe *thisframe;  /* Used only when compiling for no recursion */
-Line 849 
 typedef struct dfa_match_data {
+Line 1016 
 typedef struct dfa_match_data {
    const uschar *tables;         /* Character tables */
    int   moptions;               /* Match options */
    int   poptions;               /* Pattern options */
+   int    nltype;                /* Newline type */
+   int    nllen;                 /* Newline string length */
+   uschar nl[4];                 /* Newline string when fixed */
    void  *callout_data;          /* To pass back to callouts */
  } dfa_match_data;
-Line 919 
 extern const uschar _pcre_OP_lengths[];
+Line 1089 
 extern const uschar _pcre_OP_lengths[];
  one of the exported public functions. They have to be "external" in the C
  sense, but are not part of the PCRE public API. */
- extern int         _pcre_ord2utf8(int, uschar *);
+ extern BOOL         _pcre_is_newline(const uschar *, int, const uschar *,
- extern real_pcre * _pcre_try_flipped(const real_pcre *, real_pcre *,
+                       int *, BOOL);
-                      const pcre_study_data *, pcre_study_data *);
+ extern int          _pcre_ord2utf8(int, uschar *);
- extern int         _pcre_ucp_findprop(const int, int *, int *);
+ extern real_pcre   *_pcre_try_flipped(const real_pcre *, real_pcre *,
- extern int         _pcre_ucp_othercase(const int);
+                       const pcre_study_data *, pcre_study_data *);
- extern int         _pcre_valid_utf8(const uschar *, int);
+ extern int          _pcre_ucp_findprop(const unsigned int, int *, int *);
- extern BOOL        _pcre_xclass(int, const uschar *);
+ extern unsigned int _pcre_ucp_othercase(const unsigned int);
+ extern int          _pcre_valid_utf8(const uschar *, int);
+ extern BOOL         _pcre_was_newline(const uschar *, int, const uschar *,
+                       int *, BOOL);
+ extern BOOL         _pcre_xclass(int, const uschar *);
  #endif

 Legend:



Removed from v.87
 


changed lines


 
Added in v.150
 Legend:



Removed from v.87
 


changed lines


 
Added in v.150
-Removed from v.87
+Added in v.150

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12