/[pcre]/code/tags/pcre-4.5/internal.h

Diff of /code/tags/pcre-4.5/internal.h

Parent Directory | Revision Log | View Patch Patch

-revision 41 by nigel,
Sat Feb 24 21:39:17 2007 UTC
+revision 69 by nigel,
Sat Feb 24 21:40:18 2007 UTC
 Line 9 
 the file Tech.Notes for some information
  Written by: Philip Hazel <ph10@cam.ac.uk>
-            Copyright (c) 1997-1999 University of Cambridge
+            Copyright (c) 1997-2003 University of Cambridge
  -----------------------------------------------------------------------------
  Permission is granted to anyone to use this software for any purpose on any
 Line 39 
 modules, but which are not relevant to t
  #include "config.h"
+ /* When compiling for use with the Virtual Pascal compiler, these functions
+ need to have their names changed. PCRE must be compiled with the -DVPCOMPAT
+ option on the command line. */
+ #ifdef VPCOMPAT
+ #define strncmp(s1,s2,m) _strncmp(s1,s2,m)
+ #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)
+ #else  /* VPCOMPAT */
  /* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),
- define a macro for memmove() if HAVE_MEMMOVE is not defined. */
+ 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
+ that all calls to memmove are moving strings upwards in store, which is the
+ case in PCRE. */
- #ifndef HAVE_MEMMOVE
+ #if ! HAVE_MEMMOVE
  #undef  memmove        /* some systems may have a macro */
+ #if HAVE_BCOPY
  #define memmove(a, b, c) bcopy(b, a, c)
+ #else  /* HAVE_BCOPY */
+ void *
+ pcre_memmove(unsigned char *dest, const unsigned char *src, size_t n)
+ {
+ int i;
+ dest += n;
+ src += n;
+ for (i = 0; i < n; ++i) *(--dest) =  *(--src);
+ }
+ #define memmove(a, b, c) pcre_memmove(a, b, c)
+ #endif   /* not HAVE_BCOPY */
+ #endif   /* not HAVE_MEMMOVE */
+ #endif   /* not VPCOMPAT */
+ /* PCRE keeps offsets in its compiled code as 2-byte quantities by default.
+ These are used, for example, to link from the start of a subpattern to its
+ alternatives and its end. The use of 2 bytes per offset limits the size of the
+ compiled regex to around 64K, which is big enough for almost everybody.
+ However, I received a request for an even bigger limit. For this reason, and
+ also to make the code easier to maintain, the storing and loading of offsets
+ from the byte string is now handled by the macros that are defined here.
+ The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
+ the config.h file, but can be overridden by using -D on the command line. This
+ is automated on Unix systems via the "configure" command. */
+ #if LINK_SIZE == 2
+ #define PUT(a,n,d)   \
+   (a[n] = (d) >> 8), \
+   (a[(n)+1] = (d) & 255)
+ #define GET(a,n) \
+   (((a)[n] << 8) | (a)[(n)+1])
+ #define MAX_PATTERN_SIZE (1 << 16)
+ #elif LINK_SIZE == 3
+ #define PUT(a,n,d)       \
+   (a[n] = (d) >> 16),    \
+   (a[(n)+1] = (d) >> 8), \
+   (a[(n)+2] = (d) & 255)
+ #define GET(a,n) \
+   (((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])
+ #define MAX_PATTERN_SIZE (1 << 24)
+ #elif LINK_SIZE == 4
+ #define PUT(a,n,d)        \
+   (a[n] = (d) >> 24),     \
+   (a[(n)+1] = (d) >> 16), \
+   (a[(n)+2] = (d) >> 8),  \
+   (a[(n)+3] = (d) & 255)
+ #define GET(a,n) \
+   (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
+ #define MAX_PATTERN_SIZE (1 << 30)   /* Keep it positive */
+ #else
+ #error LINK_SIZE must be either 2, 3, or 4
  #endif
+ /* Convenience macro defined in terms of the others */
+ #define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE
+ /* PCRE uses some other 2-byte quantities that do not change when the size of
+ offsets changes. There are used for repeat counts and for other things such as
+ capturing parenthesis numbers in back references. */
+ #define PUT2(a,n,d)   \
+   a[n] = (d) >> 8; \
+   a[(n)+1] = (d) & 255
+ #define GET2(a,n) \
+   (((a)[n] << 8) | (a)[(n)+1])
+ #define PUT2INC(a,n,d)  PUT2(a,n,d), a += 2
  /* Standard C headers plus the external interface definition */
  #include <ctype.h>
-Line 55 
 define a macro for memmove() if HAVE_MEM
+Line 159 
 define a macro for memmove() if HAVE_MEM
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
+ #ifndef PCRE_SPY
+ #define PCRE_DEFINITION       /* Win32 __declspec(export) trigger for .dll */
+ #endif
  #include "pcre.h"
  /* In case there is no definition of offsetof() provided - though any proper
-Line 74 
 with negative values. The public options
+Line 183 
 with negative values. The public options
  significant end. Make sure they don't overlap, though now that we have expanded
  to four bytes there is plenty of space. */
- #define PCRE_FIRSTSET      0x40000000  /* first_char is set */
+ #define PCRE_FIRSTSET      0x40000000  /* first_byte is set */
- #define PCRE_REQCHSET      0x20000000  /* req_char is set */
+ #define PCRE_REQCHSET      0x20000000  /* req_byte is set */
  #define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */
- #define PCRE_INGROUP       0x08000000  /* compiling inside a group */
+ #define PCRE_ICHANGED      0x08000000  /* i option changes within regex */
- #define PCRE_ICHANGED      0x04000000  /* i option changes within regex */
  /* Options for the "extra" block produced by pcre_study(). */
-Line 89 
 time, run time or study time, respective
+Line 197 
 time, run time or study time, respective
  #define PUBLIC_OPTIONS \
    (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
-    PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY)
+    PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
+    PCRE_NO_AUTO_CAPTURE)
  #define PUBLIC_EXEC_OPTIONS \
    (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY)
-Line 100 
 time, run time or study time, respective
+Line 209 
 time, run time or study time, respective
  #define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */
+ /* Negative values for the firstchar and reqchar variables */
+ #define REQ_UNSET (-2)
+ #define REQ_NONE  (-1)
+ /* Flags added to firstbyte or reqbyte; a "non-literal" item is either a
+ variable-length repeat, or a anything other than literal characters. */
+ #define REQ_CASELESS 0x0100    /* indicates caselessness */
+ #define REQ_VARY     0x0200    /* reqbyte followed non-literal item */
  /* Miscellaneous definitions */
  typedef int BOOL;
-Line 107 
 typedef int BOOL;
+Line 227 
 typedef int BOOL;
  #define FALSE   0
  #define TRUE    1
+ /* Escape items that are just an encoding of a particular data value. Note that
+ 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
+ #endif
+ #ifndef ESC_f
+ #define ESC_f '\f'
+ #endif
+ #ifndef ESC_n
+ #define ESC_n NEWLINE
+ #endif
+ #ifndef ESC_r
+ #define ESC_r '\r'
+ #endif
+ /* We can't officially use ESC_t because it is a POSIX reserved identifier
+ (presumably because of all the others like size_t). */
+ #ifndef ESC_tee
+ #define ESC_tee '\t'
+ #endif
  /* These are escaped items that aren't just an encoding of a particular data
  value such as \n. They must have non-zero values, as check_escape() returns
  their negation. Also, they must appear in the same order as in the opcode
- definitions below, up to ESC_z. The final one must be ESC_REF as subsequent
+ definitions below, up to ESC_z. There's a dummy for OP_ANY because it
- values are used for \1, \2, \3, etc. There is a test in the code for an escape
+ corresponds to "." rather than an escape sequence. The final one must be
- greater than ESC_b and less than ESC_X to detect the types that may be
+ ESC_REF as subsequent values are used for \1, \2, \3, etc. There is are two
- repeated. If any new escapes are put in-between that don't consume a character,
+ tests in the code for an escape greater than ESC_b and less than ESC_Z to
- that code will have to change. */
+ detect the types that may be repeated. These are the types that consume a
+ character. 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_Z, ESC_z, ESC_E, ESC_Q, ESC_REF };
+ /* Flag bits and data types for the extended class (OP_XCLASS) for classes that
+ contain UTF-8 characters with values greater than 255. */
+ #define XCL_NOT    0x01    /* Flag: this is a negative class */
+ #define XCL_MAP    0x02    /* Flag: a 32-byte map is present */
+ #define XCL_END       0    /* Marks end of individual items */
+ #define XCL_SINGLE    1    /* Single item (one multibyte char) follows */
+ #define XCL_RANGE     2    /* A range (two multibyte chars) follows */
- enum { ESC_A = 1, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W, ESC_w,
-        ESC_Z, ESC_z, 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. */
+ 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. */
  enum {
-   OP_END,            /* End of pattern */
+   OP_END,            /* 0 End of pattern */
    /* Values corresponding to backslashed metacharacters */
-   OP_SOD,            /* Start of data: \A */
+   OP_SOD,            /* 1 Start of data: \A */
-   OP_NOT_WORD_BOUNDARY,  /* \B */
+   OP_SOM,            /* 2 Start of match (subject + offset): \G */
-   OP_WORD_BOUNDARY,      /* \b */
+   OP_NOT_WORD_BOUNDARY,  /*  3 \B */
-   OP_NOT_DIGIT,          /* \D */
+   OP_WORD_BOUNDARY,      /*  4 \b */
-   OP_DIGIT,              /* \d */
+   OP_NOT_DIGIT,          /*  5 \D */
-   OP_NOT_WHITESPACE,     /* \S */
+   OP_DIGIT,              /*  6 \d */
-   OP_WHITESPACE,         /* \s */
+   OP_NOT_WHITESPACE,     /*  7 \S */
-   OP_NOT_WORDCHAR,       /* \W */
+   OP_WHITESPACE,         /*  8 \s */
-   OP_WORDCHAR,           /* \w */
+   OP_NOT_WORDCHAR,       /*  9 \W */
-   OP_EODN,           /* End of data or \n at end of data: \Z. */
+   OP_WORDCHAR,           /* 10 \w */
-   OP_EOD,            /* End of data: \z */
+   OP_ANY,            /* 11 Match any character */
+   OP_ANYBYTE,        /* 12 Match any byte (\C); different to OP_ANY for UTF-8 */
-   OP_OPT,            /* Set runtime options */
+   OP_EODN,           /* 13 End of data or \n at end of data: \Z. */
-   OP_CIRC,           /* Start of line - varies with multiline switch */
+   OP_EOD,            /* 14 End of data: \z */
-   OP_DOLL,           /* End of line - varies with multiline switch */
-   OP_ANY,            /* Match any character */
+   OP_OPT,            /* 15 Set runtime options */
-   OP_CHARS,          /* Match string of characters */
+   OP_CIRC,           /* 16 Start of line - varies with multiline switch */
-   OP_NOT,            /* Match anything but the following char */
+   OP_DOLL,           /* 17 End of line - varies with multiline switch */
+   OP_CHARS,          /* 18 Match string of characters */
-   OP_STAR,           /* The maximizing and minimizing versions of */
+   OP_NOT,            /* 19 Match anything but the following char */
-   OP_MINSTAR,        /* all these opcodes must come in pairs, with */
-   OP_PLUS,           /* the minimizing one second. */
+   OP_STAR,           /* 20 The maximizing and minimizing versions of */
-   OP_MINPLUS,        /* This first set applies to single characters */
+   OP_MINSTAR,        /* 21 all these opcodes must come in pairs, with */
-   OP_QUERY,
+   OP_PLUS,           /* 22 the minimizing one second. */
-   OP_MINQUERY,
+   OP_MINPLUS,        /* 23 This first set applies to single characters */
-   OP_UPTO,           /* From 0 to n matches */
+   OP_QUERY,          /* 24 */
-   OP_MINUPTO,
+   OP_MINQUERY,       /* 25 */
-   OP_EXACT,          /* Exactly n matches */
+   OP_UPTO,           /* 26 From 0 to n matches */
+   OP_MINUPTO,        /* 27 */
-   OP_NOTSTAR,        /* The maximizing and minimizing versions of */
+   OP_EXACT,          /* 28 Exactly n matches */
-   OP_NOTMINSTAR,     /* all these opcodes must come in pairs, with */
-   OP_NOTPLUS,        /* the minimizing one second. */
+   OP_NOTSTAR,        /* 29 The maximizing and minimizing versions of */
-   OP_NOTMINPLUS,     /* This first set applies to "not" single characters */
+   OP_NOTMINSTAR,     /* 30 all these opcodes must come in pairs, with */
-   OP_NOTQUERY,
+   OP_NOTPLUS,        /* 31 the minimizing one second. */
-   OP_NOTMINQUERY,
+   OP_NOTMINPLUS,     /* 32 This set applies to "not" single characters */
-   OP_NOTUPTO,        /* From 0 to n matches */
+   OP_NOTQUERY,       /* 33 */
-   OP_NOTMINUPTO,
+   OP_NOTMINQUERY,    /* 34 */
-   OP_NOTEXACT,       /* Exactly n matches */
+   OP_NOTUPTO,        /* 35 From 0 to n matches */
+   OP_NOTMINUPTO,     /* 36 */
-   OP_TYPESTAR,       /* The maximizing and minimizing versions of */
+   OP_NOTEXACT,       /* 37 Exactly n matches */
-   OP_TYPEMINSTAR,    /* all these opcodes must come in pairs, with */
-   OP_TYPEPLUS,       /* the minimizing one second. These codes must */
+   OP_TYPESTAR,       /* 38 The maximizing and minimizing versions of */
-   OP_TYPEMINPLUS,    /* be in exactly the same order as those above. */
+   OP_TYPEMINSTAR,    /* 39 all these opcodes must come in pairs, with */
-   OP_TYPEQUERY,      /* This set applies to character types such as \d */
+   OP_TYPEPLUS,       /* 40 the minimizing one second. These codes must */
-   OP_TYPEMINQUERY,
+   OP_TYPEMINPLUS,    /* 41 be in exactly the same order as those above. */
-   OP_TYPEUPTO,       /* From 0 to n matches */
+   OP_TYPEQUERY,      /* 42 This set applies to character types such as \d */
-   OP_TYPEMINUPTO,
+   OP_TYPEMINQUERY,   /* 43 */
-   OP_TYPEEXACT,      /* Exactly n matches */
+   OP_TYPEUPTO,       /* 44 From 0 to n matches */
+   OP_TYPEMINUPTO,    /* 45 */
-   OP_CRSTAR,         /* The maximizing and minimizing versions of */
+   OP_TYPEEXACT,      /* 46 Exactly n matches */
-   OP_CRMINSTAR,      /* all these opcodes must come in pairs, with */
-   OP_CRPLUS,         /* the minimizing one second. These codes must */
+   OP_CRSTAR,         /* 47 The maximizing and minimizing versions of */
-   OP_CRMINPLUS,      /* be in exactly the same order as those above. */
+   OP_CRMINSTAR,      /* 48 all these opcodes must come in pairs, with */
-   OP_CRQUERY,        /* These are for character classes and back refs */
+   OP_CRPLUS,         /* 49 the minimizing one second. These codes must */
-   OP_CRMINQUERY,
+   OP_CRMINPLUS,      /* 50 be in exactly the same order as those above. */
-   OP_CRRANGE,        /* These are different to the three seta above. */
+   OP_CRQUERY,        /* 51 These are for character classes and back refs */
-   OP_CRMINRANGE,
+   OP_CRMINQUERY,     /* 52 */
+   OP_CRRANGE,        /* 53 These are different to the three seta above. */
-   OP_CLASS,          /* Match a character class */
+   OP_CRMINRANGE,     /* 54 */
-   OP_REF,            /* Match a back reference */
+   OP_CLASS,          /* 55 Match a character class, chars < 256 only */
-   OP_ALT,            /* Start of alternation */
+   OP_NCLASS,         /* 56 Same, but the bitmap was created from a negative
-   OP_KET,            /* End of group that doesn't have an unbounded repeat */
+                            class - the difference is relevant only when a UTF-8
-   OP_KETRMAX,        /* These two must remain together and in this */
+                            character > 255 is encountered. */
-   OP_KETRMIN,        /* order. They are for groups the repeat for ever. */
+   OP_XCLASS,         /* 56 Extended class for handling UTF-8 chars within the
+                            class. This does both positive and negative. */
+   OP_REF,            /* 57 Match a back reference */
+   OP_RECURSE,        /* 58 Match a numbered subpattern (possibly recursive) */
+   OP_CALLOUT,        /* 59 Call out to external function if provided */
+   OP_ALT,            /* 60 Start of alternation */
+   OP_KET,            /* 61 End of group that doesn't have an unbounded repeat */
+   OP_KETRMAX,        /* 62 These two must remain together and in this */
+   OP_KETRMIN,        /* 63 order. They are for groups the repeat for ever. */
    /* The assertions must come before ONCE and COND */
-   OP_ASSERT,         /* Positive lookahead */
+   OP_ASSERT,         /* 64 Positive lookahead */
-   OP_ASSERT_NOT,     /* Negative lookahead */
+   OP_ASSERT_NOT,     /* 65 Negative lookahead */
-   OP_ASSERTBACK,     /* Positive lookbehind */
+   OP_ASSERTBACK,     /* 66 Positive lookbehind */
-   OP_ASSERTBACK_NOT, /* Negative lookbehind */
+   OP_ASSERTBACK_NOT, /* 67 Negative lookbehind */
-   OP_REVERSE,        /* Move pointer back - used in lookbehind assertions */
+   OP_REVERSE,        /* 68 Move pointer back - used in lookbehind assertions */
    /* ONCE and COND must come after the assertions, with ONCE first, as there's
    a test for >= ONCE for a subpattern that isn't an assertion. */
-   OP_ONCE,           /* Once matched, don't back up into the subpattern */
+   OP_ONCE,           /* 69 Once matched, don't back up into the subpattern */
-   OP_COND,           /* Conditional group */
+   OP_COND,           /* 70 Conditional group */
-   OP_CREF,           /* Used to hold an extraction string number */
+   OP_CREF,           /* 71 Used to hold an extraction string number (cond ref) */
+   OP_BRAZERO,        /* 72 These two must remain together and in this */
+   OP_BRAMINZERO,     /* 73 order. */
+   OP_BRANUMBER,      /* 74 Used for extracting brackets whose number is greater
+                            than can fit into an opcode. */
+   OP_BRA             /* 75 This and greater values are used for brackets that
+                            extract substrings up to a basic limit. After that,
+                            use is made of OP_BRANUMBER. */
+ };
+ /* WARNING: There is an implicit assumption in study.c that all opcodes are
+ less than 128 in value. This makes handling UTF-8 character sequences easier.
+ */
-   OP_BRAZERO,        /* These two must remain together and in this */
+ /* This macro defines textual names for all the opcodes. There are used only
-   OP_BRAMINZERO,     /* order. */
+ for debugging, in pcre.c when DEBUG is defined, and also in pcretest.c. The
+ macro is referenced only in printint.c. */
+ #define OP_NAME_LIST \
+   "End", "\\A", "\\G", "\\B", "\\b", "\\D", "\\d",                \
+   "\\S", "\\s", "\\W", "\\w", "Any", "Anybyte", "\\Z", "\\z",     \
+   "Opt", "^", "$", "chars", "not",                                \
+   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+   "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
+   "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \
+   "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
+   "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cond ref",\
+   "Brazero", "Braminzero", "Branumber", "Bra"
+ /* This macro defines the length of fixed length operations in the compiled
+ regex. The lengths are used when searching for specific things, and also in the
+ debugging printing of a compiled regex. We use a macro so that it can be
+ incorporated both into pcre.c and pcretest.c without being publicly exposed.
+ As things have been extended, some of these are no longer fixed lenths, but are
+ minima instead. For example, the length of a single-character repeat may vary
+ in UTF-8 mode. The code that uses this table must know about such things. */
+ #define OP_LENGTHS \
+,                             /* End                                    */ \
+, 1, 1, 1, 1, 1, 1, 1, 1, 1,  /* \A, \G, \B, \B, \D, \d, \S, \s, \W, \w */ \
+, 1, 1, 1, 2, 1, 1,           /* Any, Anybyte, \Z, \z, Opt, ^, $        */ \
+,                             /* Chars - the minimum length             */ \
+,                             /* not                                    */ \
+   /* Positive single-char repeats                                          */ \
+, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** These are  */ \
+, 4, 4,                       /* upto, minupto, exact     ** minima     */ \
+   /* Negative single-char repeats                                          */ \
+, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
+, 4, 4,                       /* NOT upto, minupto, exact               */ \
+   /* Positive type repeats                                                 */ \
+, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
+, 4, 4,                       /* Type upto, minupto, exact              */ \
+   /* Character class & ref repeats                                         */ \
+, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
+, 5,                          /* CRRANGE, CRMINRANGE                    */ \
+,                             /* CLASS                                  */ \
+,                             /* NCLASS                                 */ \
+,                             /* XCLASS - variable length               */ \
+,                             /* REF                                    */ \
++LINK_SIZE,                   /* RECURSE                                */ \
+,                             /* CALLOUT                                */ \
++LINK_SIZE,                   /* Alt                                    */ \
++LINK_SIZE,                   /* Ket                                    */ \
++LINK_SIZE,                   /* KetRmax                                */ \
++LINK_SIZE,                   /* KetRmin                                */ \
++LINK_SIZE,                   /* Assert                                 */ \
++LINK_SIZE,                   /* Assert not                             */ \
++LINK_SIZE,                   /* Assert behind                          */ \
++LINK_SIZE,                   /* Assert behind not                      */ \
++LINK_SIZE,                   /* Reverse                                */ \
++LINK_SIZE,                   /* Once                                   */ \
++LINK_SIZE,                   /* COND                                   */ \
+,                             /* CREF                                   */ \
+, 1,                          /* BRAZERO, BRAMINZERO                    */ \
+,                             /* BRANUMBER                              */ \
++LINK_SIZE                    /* BRA                                    */ \
+ /* 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. */
-   OP_BRA             /* This and greater values are used for brackets that
+ #define EXTRACT_BASIC_MAX  150
-                         extract substrings. */
- };
- /* The highest extraction number. This is limited by the number of opcodes
+ /* A magic value for OP_CREF to indicate the "in recursion" condition. */
- left after OP_BRA, i.e. 255 - OP_BRA. We actually set it somewhat lower. */
- #define EXTRACT_MAX  99
+ #define CREF_RECURSE  0xffff
  /* The texts of compile-time error messages are defined as macros here so that
  they can be accessed by the POSIX wrapper and converted into error codes.  Yes,
-Line 238 
 just to accommodate the POSIX wrapper. *
+Line 495 
 just to accommodate the POSIX wrapper. *
  #define ERR10 "operand of unlimited repeat could match the empty string"
  #define ERR11 "internal error: unexpected repeat"
  #define ERR12 "unrecognized character after (?"
- #define ERR13 "too many capturing parenthesized sub-patterns"
+ #define ERR13 "POSIX named classes are supported only within a class"
  #define ERR14 "missing )"
- #define ERR15 "back reference to non-existent subpattern"
+ #define ERR15 "reference to non-existent subpattern"
  #define ERR16 "erroffset passed as NULL"
  #define ERR17 "unknown option bit(s) set"
  #define ERR18 "missing ) after comment"
- #define ERR19 "too many sets of parentheses"
+ #define ERR19 "parentheses nested too deeply"
  #define ERR20 "regular expression too large"
  #define ERR21 "failed to get memory"
  #define ERR22 "unmatched parentheses"
-Line 254 
 just to accommodate the POSIX wrapper. *
+Line 511 
 just to accommodate the POSIX wrapper. *
  #define ERR26 "malformed number after (?("
  #define ERR27 "conditional group contains more than two branches"
  #define ERR28 "assertion expected after (?("
+ #define ERR29 "(?R or (?digits must be followed by )"
+ #define ERR30 "unknown POSIX class name"
+ #define ERR31 "POSIX collating elements are not supported"
+ #define ERR32 "this version of PCRE is not compiled with PCRE_UTF8 support"
+ #define ERR33 "spare error"
+ #define ERR34 "character value in \\x{...} sequence is too large"
+ #define ERR35 "invalid condition (?(0)"
+ #define ERR36 "\\C not allowed in lookbehind assertion"
+ #define ERR37 "PCRE does not support \\L, \\l, \\N, \\P, \\p, \\U, \\u, or \\X"
+ #define ERR38 "number after (?C is > 255"
+ #define ERR39 "closing ) for (?C expected"
+ #define ERR40 "recursive call could loop indefinitely"
+ #define ERR41 "unrecognized character after (?P"
+ #define ERR42 "syntax error after (?P"
+ #define ERR43 "two named groups have the same name"
  /* All character handling must be done as unsigned characters. Otherwise there
  are problems with top-bit-set characters and functions such as isspace().
-Line 264 
 Unix, where it is defined in sys/types,
+Line 536 
 Unix, where it is defined in sys/types,
  typedef unsigned char uschar;
- /* The real format of the start of the pcre block; the actual code vector
+ /* The real format of the start of the pcre block; the index of names and the
- runs on as long as necessary after the end. */
+ code vector run on as long as necessary after the end. */
  typedef struct real_pcre {
    unsigned long int magic_number;
-   const unsigned char *tables;
+   size_t size;                        /* Total that was malloced */
+   const unsigned char *tables;        /* Pointer to tables */
    unsigned long int options;
-   uschar top_bracket;
+   unsigned short int top_bracket;
-   uschar top_backref;
+   unsigned short int top_backref;
-   uschar first_char;
+   unsigned short int first_byte;
-   uschar req_char;
+   unsigned short int req_byte;
-   uschar code[1];
+   unsigned short int name_entry_size; /* Size of any name items; 0 => none */
+   unsigned short int name_count;      /* Number of name items */
  } real_pcre;
- /* The real format of the extra block returned by pcre_study(). */
+ /* The format of the block used to store data from pcre_study(). */
- typedef struct real_pcre_extra {
+ typedef struct pcre_study_data {
+   size_t size;                        /* Total that was malloced */
    uschar options;
    uschar start_bits[32];
- } real_pcre_extra;
+ } pcre_study_data;
  /* Structure for passing "static" information around between the functions
  doing the compiling, so that they are thread-safe. */
-Line 294 
 typedef struct compile_data {
+Line 568 
 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_code;     /* The start of the compiled code */
+   uschar *name_table;           /* The name/number table */
+   int  names_found;             /* Number of entries so far */
+   int  name_entry_size;         /* Size of each entry */
+   int  top_backref;             /* Maximum back reference */
+   unsigned int backref_map;     /* Bitmap of low back refs */
+   int  req_varyopt;             /* "After variable item" flag for reqbyte */
  } compile_data;
+ /* Structure for maintaining a chain of pointers to the currently incomplete
+ branches, for testing for left recursion. */
+ typedef struct branch_chain {
+   struct branch_chain *outer;
+   uschar *current;
+ } branch_chain;
+ /* Structure for items in a linked list that represents an explicit recursive
+ call within the pattern. */
+ typedef struct recursion_info {
+   struct recursion_info *prev;  /* Previous recursion record (or NULL) */
+   int group_num;                /* Number of group that was called */
+   const uschar *after_call;     /* "Return value": points after the call in the expr */
+   const uschar *save_start;     /* Old value of md->start_match */
+   int *offset_save;             /* Pointer to start of saved offsets */
+   int saved_max;                /* Number of saved offsets */
+ } recursion_info;
  /* Structure for passing "static" information around between the functions
  doing the matching, so that they are thread-safe. */
  typedef struct match_data {
-   int    errorcode;             /* As it says */
+   unsigned long int match_call_count; /* As it says */
+   unsigned long int match_limit;/* As it says */
    int   *offset_vector;         /* Offset vector */
    int    offset_end;            /* One past the end */
    int    offset_max;            /* The maximum usable for return data */
-Line 309 
 typedef struct match_data {
+Line 611 
 typedef struct match_data {
    BOOL   offset_overflow;       /* Set if too many extractions */
    BOOL   notbol;                /* NOTBOL flag */
    BOOL   noteol;                /* NOTEOL flag */
+   BOOL   utf8;                  /* UTF8 flag */
    BOOL   endonly;               /* Dollar not before final \n */
    BOOL   notempty;              /* Empty string match not wanted */
+   const uschar *start_code;     /* For use when recursing */
    const uschar *start_subject;  /* Start of the subject string */
    const uschar *end_subject;    /* End of the subject string */
    const uschar *start_match;    /* Start of this match attempt */
    const uschar *end_match_ptr;  /* Subject position at end match */
-   int     end_offset_top;       /* Highwater mark at end of match */
+   int    end_offset_top;        /* Highwater mark at end of match */
+   int    capture_last;          /* Most recent capture number */
+   int    start_offset;          /* The start offset value */
+   recursion_info *recursive;    /* Linked list of recursion data */
+   void  *callout_data;          /* To pass back to callouts */
  } match_data;
  /* Bit definitions for entries in the pcre_ctypes table. */
-Line 328 
 typedef struct match_data {
+Line 636 
 typedef struct match_data {
  #define ctype_meta    0x80   /* regexp meta char or zero (end pattern) */
  /* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
- of bits for a class map. */
+ of bits for a class map. Some classes are built by combining these tables. */
- #define cbit_digit    0      /* for \d */
+ #define cbit_space     0      /* [:space:] or \s */
- #define cbit_word    32      /* for \w */
+ #define cbit_xdigit   32      /* [:xdigit:] */
- #define cbit_space   64      /* for \s */
+ #define cbit_digit    64      /* [:digit:] or \d */
- #define cbit_length  96      /* Length of the cbits table */
+ #define cbit_upper    96      /* [:upper:] */
+ #define cbit_lower   128      /* [:lower:] */
+ #define cbit_word    160      /* [:word:] or \w */
+ #define cbit_graph   192      /* [:graph:] */
+ #define cbit_print   224      /* [:print:] */
+ #define cbit_punct   256      /* [:punct:] */
+ #define cbit_cntrl   288      /* [:cntrl:] */
+ #define cbit_length  320      /* Length of the cbits table */
  /* Offsets of the various tables from the base tables pointer, and
  total length. */

 Legend:



Removed from v.41
 


changed lines


 
Added in v.69
 Legend:



Removed from v.41
 


changed lines


 
Added in v.69
-Removed from v.41
+Added in v.69

	ViewVC Help
Powered by ViewVC 1.1.5