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

Diff of /code/trunk/pcre_internal.h

Parent Directory | Revision Log | View Patch Patch

-revision 118 by ph10,
Fri Mar  9 16:17:46 2007 UTC
+revision 384 by ph10,
Sun Mar  8 16:27:43 2009 UTC
 Line 7
  and semantics are as close as possible to those of the Perl 5 language.
                         Written by Philip Hazel
-            Copyright (c) 1997-2007 University of Cambridge
+            Copyright (c) 1997-2009 University of Cambridge
  -----------------------------------------------------------------------------
  Redistribution and use in source and binary forms, with or without
 Line 67 
 be absolutely sure we get our version. *
  #endif
- /* Get the definitions provided by running "configure" */
- #include "config.h"
  /* Standard C headers plus the external interface definition. The only time
  setjmp and stdarg are used is when NO_RECURSE is set. */
-Line 83 
 setjmp and stdarg are used is when NO_RE
+Line 79 
 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(dllexport) 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 (they just 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 to 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
+ #    ifndef PCRE_STATIC
+ #      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
+ /* When compiling with the MSVC compiler, it is sometimes necessary to include
+ a "calling convention" before exported function names. (This is secondhand
+ information; I know nothing about MSVC myself). For example, something like
+   void __cdecl function(....)
+ might be needed. In order so make this easy, all the exported functions have
+ PCRE_CALL_CONVENTION just before their names. It is rarely needed; if not
+ set, we ensure here that it has no effect. */
+ #ifndef PCRE_CALL_CONVENTION
+ #define PCRE_CALL_CONVENTION
  #endif
  /* We need to have types that specify unsigned 16-bit and 32-bit integers. We
-Line 95 
 preprocessor time in standard C environm
+Line 154 
 preprocessor time in standard C environm
  #if USHRT_MAX == 65535
    typedef unsigned short pcre_uint16;
+   typedef short pcre_int16;
  #elif UINT_MAX == 65535
    typedef unsigned int pcre_uint16;
+   typedef int pcre_int16;
  #else
    #error Cannot determine a type for 16-bit unsigned integers
  #endif
  #if UINT_MAX == 4294967295
    typedef unsigned int pcre_uint32;
+   typedef int pcre_int32;
  #elif ULONG_MAX == 4294967295
    typedef unsigned long int pcre_uint32;
+   typedef long int pcre_int32;
  #else
    #error Cannot determine a type for 32-bit unsigned integers
  #endif
-Line 125 
 characters only go up to 0x7fffffff (tho
+Line 188 
 characters only go up to 0x7fffffff (tho
  #define NOTACHAR 0xffffffff
  /* PCRE is able to support several different kinds of newline (CR, LF, CRLF,
- and "all" at present). The following macros are used to package up testing for
+ "any" and "anycrlf" at present). The following macros are used to package up
- newlines. NLBLOCK, PSSTART, and PSEND are defined in the various modules to
+ testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various
- indicate in which datablock the parameters exist, and what the start/end of
+ modules to indicate in which datablock the parameters exist, and what the
- string field names are. */
+ start/end of string field names are. */
- #define NLTYPE_FIXED   0     /* Newline is a fixed length string */
+ #define NLTYPE_FIXED    0     /* Newline is a fixed length string */
- #define NLTYPE_ANY     1     /* Newline is any Unicode line ending */
+ #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->PSEND, &(NLBLOCK->nllen), utf8) \
+      _pcre_is_newline((p), NLBLOCK->nltype, NLBLOCK->PSEND, &(NLBLOCK->nllen),\
-     ) \
+        utf8)) \
      : \
      ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
       (p)[0] == NLBLOCK->nl[0] && \
-Line 152 
 string field names are. */
+Line 216 
 string field names are. */
  #define WAS_NEWLINE(p) \
    ((NLBLOCK->nltype != NLTYPE_FIXED)? \
      ((p) > NLBLOCK->PSSTART && \
-      _pcre_was_newline((p), NLBLOCK->PSSTART, &(NLBLOCK->nllen), utf8) \
+      _pcre_was_newline((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
-     ) \
+        &(NLBLOCK->nllen), utf8)) \
      : \
      ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
       (p)[-NLBLOCK->nllen] == NLBLOCK->nl[0] && \
-Line 178 
 must begin with PCRE_. */
+Line 242 
 must begin with PCRE_. */
  #define USPTR const unsigned char *
  #endif
  /* Include the public PCRE header and the definitions of UCP character property
  values. */
-Line 202 
 define a macro for memmove() if HAVE_MEM
+Line 268 
 define a macro for memmove() if HAVE_MEM
  is set. Otherwise, include an emulating function for those systems that have
  neither (there some non-Unix environments where this is the case). */
- #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 */
  static void *
-Line 223 
 if (dest > src)
+Line 289 
 if (dest > src)
  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 310 
 capturing parenthesis numbers in back re
+Line 376 
 capturing parenthesis numbers in back re
  /* When UTF-8 encoding is being used, a character is no longer just a single
  byte. The macros for character handling generate simple sequences when used in
- byte-mode, and more complicated ones for UTF-8 characters. */
+ byte-mode, and more complicated ones for UTF-8 characters. BACKCHAR should
+ never be called in byte mode. To make sure it can never even appear when UTF-8
+ support is omitted, we don't even define it. */
  #ifndef SUPPORT_UTF8
  #define GETCHAR(c, eptr) c = *eptr;
-Line 318 
 byte-mode, and more complicated ones for
+Line 386 
 byte-mode, and more complicated ones for
  #define GETCHARINC(c, eptr) c = *eptr++;
  #define GETCHARINCTEST(c, eptr) c = *eptr++;
  #define GETCHARLEN(c, eptr, len) c = *eptr;
- #define BACKCHAR(eptr)
+ /* #define BACKCHAR(eptr) */
  #else   /* SUPPORT_UTF8 */
-Line 410 
 if there are extra bytes. This is called
+Line 478 
 if there are extra bytes. This is called
      len += gcaa; \
      }
+ /* Get the next UTF-8 character, testing for UTF-8 mode, not advancing the
+ pointer, incrementing length if there are extra bytes. This is called when we
+ know we are in UTF-8 mode. */
+ #define GETCHARLENTEST(c, eptr, len) \
+   c = *eptr; \
+   if (utf8 && c >= 0xc0) \
+     { \
+     int gcii; \
+     int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
+     int gcss = 6*gcaa; \
+     c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
+     for (gcii = 1; gcii <= gcaa; gcii++) \
+       { \
+       gcss -= 6; \
+       c |= (eptr[gcii] & 0x3f) << gcss; \
+       } \
+     len += gcaa; \
+     }
  /* If the pointer is not at the start of a character, move it back until
- it is. Called only in UTF-8 mode. */
+ it is. This is called only in UTF-8 mode - we don't put a test within the macro
+ because almost all calls are already within a block of UTF-8 only code. */
- #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--;
+ #define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--
  #endif
-Line 430 
 Standard C system should have one. */
+Line 519 
 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 flags containing information about the compiled regex. They used to
- The public options defined in pcre.h start at the least significant end. Make
+ live at the top end of the options word, but that got almost full, so now they
- sure they don't overlap! The bits are getting a bit scarce now -- when we run
+ are in a 16-bit flags word. */
- out, there is a dummy word in the structure that could be used for the private
- bits. */
+ #define PCRE_NOPARTIAL     0x0001  /* can't use partial with this regex */
+ #define PCRE_FIRSTSET      0x0002  /* first_byte is set */
- #define PCRE_NOPARTIAL     0x80000000  /* can't use partial with this regex */
+ #define PCRE_REQCHSET      0x0004  /* req_byte is set */
- #define PCRE_FIRSTSET      0x40000000  /* first_byte is set */
+ #define PCRE_STARTLINE     0x0008  /* start after \n for multiline */
- #define PCRE_REQCHSET      0x20000000  /* req_byte is set */
+ #define PCRE_JCHANGED      0x0010  /* j option used in regex */
- #define PCRE_STARTLINE     0x10000000  /* start after \n for multiline */
+ #define PCRE_HASCRORLF     0x0020  /* explicit \r or \n in pattern */
- #define PCRE_JCHANGED      0x08000000  /* j option changes within regex */
  /* Options for the "extra" block produced by pcre_study(). */
-Line 449 
 bits. */
+Line 537 
 bits. */
  /* 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)
+ #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_DUPNAMES|PCRE_NEWLINE_BITS)
+    PCRE_DUPNAMES|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
+    PCRE_JAVASCRIPT_COMPAT)
  #define PUBLIC_EXEC_OPTIONS \
    (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
-    PCRE_PARTIAL|PCRE_NEWLINE_BITS)
+    PCRE_PARTIAL|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)
  #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_NEWLINE_BITS)
+    PCRE_PARTIAL|PCRE_DFA_SHORTEST|PCRE_DFA_RESTART|PCRE_NEWLINE_BITS| \
+    PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)
  #define PUBLIC_STUDY_OPTIONS 0   /* None defined */
-Line 488 
 variable-length repeat, or a anything ot
+Line 579 
 variable-length repeat, or a anything ot
  #define REQ_CASELESS 0x0100    /* indicates caselessness */
  #define REQ_VARY     0x0200    /* reqbyte followed non-literal item */
- /* Miscellaneous definitions */
+ /* Miscellaneous definitions. The #ifndef is to pacify compiler warnings in
+ environments where these macros are defined elsewhere. Unfortunately, there
+ is no way to do the same for the typedef. */
  typedef int BOOL;
+ #ifndef FALSE
  #define FALSE   0
  #define TRUE    1
+ #endif
  /* Escape items that are just an encoding of a particular data value. */
-Line 544 
 contain UTF-8 characters with values gre
+Line 639 
 contain UTF-8 characters with values gre
  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. There's a dummy for OP_ANY because it
- corresponds to "." rather than an escape sequence. The final one must be
+ corresponds to "." rather than an escape sequence, and another for OP_ALLANY
- ESC_REF as subsequent values are used for backreferences (\1, \2, \3, etc).
+ (which is used for [^] in JavaScript compatibility mode).
- There are two tests in the code for an escape greater than ESC_b and less than
- ESC_Z to detect the types that may be repeated. These are the types that
+ The final escape must be ESC_REF as subsequent values are used for
- consume characters. If any new escapes are put in between that don't consume a
+ backreferences (\1, \2, \3, etc). There are two tests in the code for an escape
- character, that code will have to change. */
+ greater than ESC_b and less than ESC_Z to detect the types that may be
+ repeated. These are the types that consume characters. If any new escapes are
- enum { ESC_A = 1, ESC_G, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s, ESC_W,
+ put in between that don't consume a character, that code will have to change.
-        ESC_w, ESC_dum1, ESC_C, ESC_P, ESC_p, ESC_R, ESC_X, ESC_Z, ESC_z,
+ */
-        ESC_E, ESC_Q, ESC_k, ESC_REF };
+ enum { ESC_A = 1, ESC_G, ESC_K, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s,
+        ESC_W, ESC_w, ESC_dum1, ESC_dum2, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
+        ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z, ESC_E, ESC_Q, ESC_g, 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.
- To keep stored, compiled patterns compatible, new opcodes should be added
+ /* Opcode table: Starting from 1 (i.e. after OP_END), the values up to
- immediately before OP_BRA, where (since release 7.0) a gap is left for this
+ OP_EOD must correspond in order to the list of escapes immediately above.
- 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
-Line 575 
 enum {
+Line 669 
 enum {
    OP_SOD,            /* 1 Start of data: \A */
    OP_SOM,            /* 2 Start of match (subject + offset): \G */
-   OP_NOT_WORD_BOUNDARY,  /*  3 \B */
+   OP_SET_SOM,        /* 3 Set start of match (\K) */
-   OP_WORD_BOUNDARY,      /*  4 \b */
+   OP_NOT_WORD_BOUNDARY,  /*  4 \B */
-   OP_NOT_DIGIT,          /*  5 \D */
+   OP_WORD_BOUNDARY,      /*  5 \b */
-   OP_DIGIT,              /*  6 \d */
+   OP_NOT_DIGIT,          /*  6 \D */
-   OP_NOT_WHITESPACE,     /*  7 \S */
+   OP_DIGIT,              /*  7 \d */
-   OP_WHITESPACE,         /*  8 \s */
+   OP_NOT_WHITESPACE,     /*  8 \S */
-   OP_NOT_WORDCHAR,       /*  9 \W */
+   OP_WHITESPACE,         /*  9 \s */
-   OP_WORDCHAR,           /* 10 \w */
+   OP_NOT_WORDCHAR,       /* 10 \W */
-   OP_ANY,            /* 11 Match any character */
+   OP_WORDCHAR,           /* 11 \w */
-   OP_ANYBYTE,        /* 12 Match any byte (\C); different to OP_ANY for UTF-8 */
+   OP_ANY,            /* 12 Match any character (subject to DOTALL) */
-   OP_NOTPROP,        /* 13 \P (not Unicode property) */
+   OP_ALLANY,         /* 13 Match any character (not subject to DOTALL) */
-   OP_PROP,           /* 14 \p (Unicode property) */
+   OP_ANYBYTE,        /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
-   OP_ANYNL,          /* 15 \R (any newline sequence) */
+   OP_NOTPROP,        /* 15 \P (not Unicode property) */
-   OP_EXTUNI,         /* 16 \X (extended Unicode sequence */
+   OP_PROP,           /* 16 \p (Unicode property) */
-   OP_EODN,           /* 17 End of data or \n at end of data: \Z. */
+   OP_ANYNL,          /* 17 \R (any newline sequence) */
-   OP_EOD,            /* 18 End of data: \z */
+   OP_NOT_HSPACE,     /* 18 \H (not horizontal whitespace) */
+   OP_HSPACE,         /* 19 \h (horizontal whitespace) */
-   OP_OPT,            /* 19 Set runtime options */
+   OP_NOT_VSPACE,     /* 20 \V (not vertical whitespace) */
-   OP_CIRC,           /* 20 Start of line - varies with multiline switch */
+   OP_VSPACE,         /* 21 \v (vertical whitespace) */
-   OP_DOLL,           /* 21 End of line - varies with multiline switch */
+   OP_EXTUNI,         /* 22 \X (extended Unicode sequence */
-   OP_CHAR,           /* 22 Match one character, casefully */
+   OP_EODN,           /* 23 End of data or \n at end of data: \Z. */
-   OP_CHARNC,         /* 23 Match one character, caselessly */
+   OP_EOD,            /* 24 End of data: \z */
-   OP_NOT,            /* 24 Match one character, not the following one */
+   OP_OPT,            /* 25 Set runtime options */
-   OP_STAR,           /* 25 The maximizing and minimizing versions of */
+   OP_CIRC,           /* 26 Start of line - varies with multiline switch */
-   OP_MINSTAR,        /* 26 these six opcodes must come in pairs, with */
+   OP_DOLL,           /* 27 End of line - varies with multiline switch */
-   OP_PLUS,           /* 27 the minimizing one second. */
+   OP_CHAR,           /* 28 Match one character, casefully */
-   OP_MINPLUS,        /* 28 This first set applies to single characters.*/
+   OP_CHARNC,         /* 29 Match one character, caselessly */
-   OP_QUERY,          /* 29 */
+   OP_NOT,            /* 30 Match one character, not the following one */
-   OP_MINQUERY,       /* 30 */
+   OP_STAR,           /* 31 The maximizing and minimizing versions of */
-   OP_UPTO,           /* 31 From 0 to n matches */
+   OP_MINSTAR,        /* 32 these six opcodes must come in pairs, with */
-   OP_MINUPTO,        /* 32 */
+   OP_PLUS,           /* 33 the minimizing one second. */
-   OP_EXACT,          /* 33 Exactly n matches */
+   OP_MINPLUS,        /* 34 This first set applies to single characters.*/
+   OP_QUERY,          /* 35 */
-   OP_POSSTAR,        /* 34 Possessified star */
+   OP_MINQUERY,       /* 36 */
-   OP_POSPLUS,        /* 35 Possessified plus */
-   OP_POSQUERY,       /* 36 Posesssified query */
+   OP_UPTO,           /* 37 From 0 to n matches */
-   OP_POSUPTO,        /* 37 Possessified upto */
+   OP_MINUPTO,        /* 38 */
+   OP_EXACT,          /* 39 Exactly n matches */
-   OP_NOTSTAR,        /* 38 The maximizing and minimizing versions of */
-   OP_NOTMINSTAR,     /* 39 these six opcodes must come in pairs, with */
+   OP_POSSTAR,        /* 40 Possessified star */
-   OP_NOTPLUS,        /* 40 the minimizing one second. They must be in */
+   OP_POSPLUS,        /* 41 Possessified plus */
-   OP_NOTMINPLUS,     /* 41 exactly the same order as those above. */
+   OP_POSQUERY,       /* 42 Posesssified query */
-   OP_NOTQUERY,       /* 42 This set applies to "not" single characters. */
+   OP_POSUPTO,        /* 43 Possessified upto */
-   OP_NOTMINQUERY,    /* 43 */
+   OP_NOTSTAR,        /* 44 The maximizing and minimizing versions of */
-   OP_NOTUPTO,        /* 44 From 0 to n matches */
+   OP_NOTMINSTAR,     /* 45 these six opcodes must come in pairs, with */
-   OP_NOTMINUPTO,     /* 45 */
+   OP_NOTPLUS,        /* 46 the minimizing one second. They must be in */
-   OP_NOTEXACT,       /* 46 Exactly n matches */
+   OP_NOTMINPLUS,     /* 47 exactly the same order as those above. */
+   OP_NOTQUERY,       /* 48 This set applies to "not" single characters. */
-   OP_NOTPOSSTAR,     /* 47 Possessified versions */
+   OP_NOTMINQUERY,    /* 49 */
-   OP_NOTPOSPLUS,     /* 48 */
-   OP_NOTPOSQUERY,    /* 49 */
+   OP_NOTUPTO,        /* 50 From 0 to n matches */
-   OP_NOTPOSUPTO,     /* 50 */
+   OP_NOTMINUPTO,     /* 51 */
+   OP_NOTEXACT,       /* 52 Exactly n matches */
-   OP_TYPESTAR,       /* 51 The maximizing and minimizing versions of */
-   OP_TYPEMINSTAR,    /* 52 these six opcodes must come in pairs, with */
+   OP_NOTPOSSTAR,     /* 53 Possessified versions */
-   OP_TYPEPLUS,       /* 53 the minimizing one second. These codes must */
+   OP_NOTPOSPLUS,     /* 54 */
-   OP_TYPEMINPLUS,    /* 54 be in exactly the same order as those above. */
+   OP_NOTPOSQUERY,    /* 55 */
-   OP_TYPEQUERY,      /* 55 This set applies to character types such as \d */
+   OP_NOTPOSUPTO,     /* 56 */
-   OP_TYPEMINQUERY,   /* 56 */
+   OP_TYPESTAR,       /* 57 The maximizing and minimizing versions of */
-   OP_TYPEUPTO,       /* 57 From 0 to n matches */
+   OP_TYPEMINSTAR,    /* 58 these six opcodes must come in pairs, with */
-   OP_TYPEMINUPTO,    /* 58 */
+   OP_TYPEPLUS,       /* 59 the minimizing one second. These codes must */
-   OP_TYPEEXACT,      /* 59 Exactly n matches */
+   OP_TYPEMINPLUS,    /* 60 be in exactly the same order as those above. */
+   OP_TYPEQUERY,      /* 61 This set applies to character types such as \d */
-   OP_TYPEPOSSTAR,    /* 60 Possessified versions */
+   OP_TYPEMINQUERY,   /* 62 */
-   OP_TYPEPOSPLUS,    /* 61 */
-   OP_TYPEPOSQUERY,   /* 62 */
+   OP_TYPEUPTO,       /* 63 From 0 to n matches */
-   OP_TYPEPOSUPTO,    /* 63 */
+   OP_TYPEMINUPTO,    /* 64 */
+   OP_TYPEEXACT,      /* 65 Exactly n matches */
-   OP_CRSTAR,         /* 64 The maximizing and minimizing versions of */
-   OP_CRMINSTAR,      /* 65 all these opcodes must come in pairs, with */
+   OP_TYPEPOSSTAR,    /* 66 Possessified versions */
-   OP_CRPLUS,         /* 66 the minimizing one second. These codes must */
+   OP_TYPEPOSPLUS,    /* 67 */
-   OP_CRMINPLUS,      /* 67 be in exactly the same order as those above. */
+   OP_TYPEPOSQUERY,   /* 68 */
-   OP_CRQUERY,        /* 68 These are for character classes and back refs */
+   OP_TYPEPOSUPTO,    /* 69 */
-   OP_CRMINQUERY,     /* 69 */
-   OP_CRRANGE,        /* 70 These are different to the three sets above. */
+   OP_CRSTAR,         /* 70 The maximizing and minimizing versions of */
-   OP_CRMINRANGE,     /* 71 */
+   OP_CRMINSTAR,      /* 71 all these opcodes must come in pairs, with */
+   OP_CRPLUS,         /* 72 the minimizing one second. These codes must */
+   OP_CRMINPLUS,      /* 73 be in exactly the same order as those above. */
+   OP_CRQUERY,        /* 74 These are for character classes and back refs */
+   OP_CRMINQUERY,     /* 75 */
+   OP_CRRANGE,        /* 76 These are different to the three sets above. */
+   OP_CRMINRANGE,     /* 77 */
-   OP_CLASS,          /* 72 Match a character class, chars < 256 only */
+   OP_CLASS,          /* 78 Match a character class, chars < 256 only */
-   OP_NCLASS,         /* 73 Same, but the bitmap was created from a negative
+   OP_NCLASS,         /* 79 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,         /* 74 Extended class for handling UTF-8 chars within the
+   OP_XCLASS,         /* 80 Extended class for handling UTF-8 chars within the
                             class. This does both positive and negative. */
-   OP_REF,            /* 75 Match a back reference */
+   OP_REF,            /* 81 Match a back reference */
-   OP_RECURSE,        /* 76 Match a numbered subpattern (possibly recursive) */
+   OP_RECURSE,        /* 82 Match a numbered subpattern (possibly recursive) */
-   OP_CALLOUT,        /* 77 Call out to external function if provided */
+   OP_CALLOUT,        /* 83 Call out to external function if provided */
-   OP_ALT,            /* 78 Start of alternation */
+   OP_ALT,            /* 84 Start of alternation */
-   OP_KET,            /* 79 End of group that doesn't have an unbounded repeat */
+   OP_KET,            /* 85 End of group that doesn't have an unbounded repeat */
-   OP_KETRMAX,        /* 80 These two must remain together and in this */
+   OP_KETRMAX,        /* 86 These two must remain together and in this */
-   OP_KETRMIN,        /* 81 order. They are for groups the repeat for ever. */
+   OP_KETRMIN,        /* 87 order. They are for groups the repeat for ever. */
    /* The assertions must come before BRA, CBRA, ONCE, and COND.*/
-   OP_ASSERT,         /* 82 Positive lookahead */
+   OP_ASSERT,         /* 88 Positive lookahead */
-   OP_ASSERT_NOT,     /* 83 Negative lookahead */
+   OP_ASSERT_NOT,     /* 89 Negative lookahead */
-   OP_ASSERTBACK,     /* 84 Positive lookbehind */
+   OP_ASSERTBACK,     /* 90 Positive lookbehind */
-   OP_ASSERTBACK_NOT, /* 85 Negative lookbehind */
+   OP_ASSERTBACK_NOT, /* 91 Negative lookbehind */
-   OP_REVERSE,        /* 86 Move pointer back - used in lookbehind assertions */
+   OP_REVERSE,        /* 92 Move pointer back - used in lookbehind assertions */
    /* ONCE, BRA, CBRA, 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,           /* 87 Atomic group */
+   OP_ONCE,           /* 93 Atomic group */
-   OP_BRA,            /* 88 Start of non-capturing bracket */
+   OP_BRA,            /* 94 Start of non-capturing bracket */
-   OP_CBRA,           /* 89 Start of capturing bracket */
+   OP_CBRA,           /* 95 Start of capturing bracket */
-   OP_COND,           /* 90 Conditional group */
+   OP_COND,           /* 96 Conditional group */
    /* These three must follow the previous three, in the same order. There's a
    check for >= SBRA to distinguish the two sets. */
-   OP_SBRA,           /* 91 Start of non-capturing bracket, check empty  */
+   OP_SBRA,           /* 97 Start of non-capturing bracket, check empty  */
-   OP_SCBRA,          /* 92 Start of capturing bracket, check empty */
+   OP_SCBRA,          /* 98 Start of capturing bracket, check empty */
-   OP_SCOND,          /* 93 Conditional group, check empty */
+   OP_SCOND,          /* 99 Conditional group, check empty */
-   OP_CREF,           /* 94 Used to hold a capture number as condition */
+   OP_CREF,           /* 100 Used to hold a capture number as condition */
-   OP_RREF,           /* 95 Used to hold a recursion number as condition */
+   OP_RREF,           /* 101 Used to hold a recursion number as condition */
-   OP_DEF,            /* 96 The DEFINE condition */
+   OP_DEF,            /* 102 The DEFINE condition */
+   OP_BRAZERO,        /* 103 These two must remain together and in this */
+   OP_BRAMINZERO,     /* 104 order. */
+   /* These are backtracking control verbs */
-   OP_BRAZERO,        /* 97 These two must remain together and in this */
+   OP_PRUNE,          /* 105 */
-   OP_BRAMINZERO      /* 98 order. */
+   OP_SKIP,           /* 106 */
+   OP_THEN,           /* 107 */
+   OP_COMMIT,         /* 108 */
+   /* These are forced failure and success verbs */
+   OP_FAIL,           /* 109 */
+   OP_ACCEPT,         /* 110 */
+   /* This is used to skip a subpattern with a {0} quantifier */
+   OP_SKIPZERO        /* 111 */
  };
-Line 709 
 enum {
+Line 825 
 enum {
  for debugging. The macro is referenced only in pcre_printint.c. */
  #define OP_NAME_LIST \
-   "End", "\\A", "\\G", "\\B", "\\b", "\\D", "\\d",                \
+   "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d",         \
-   "\\S", "\\s", "\\W", "\\w", "Any", "Anybyte",                   \
+   "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte",         \
-   "notprop", "prop", "anynl", "extuni",                           \
+   "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v",           \
-   "\\Z", "\\z",                                                   \
+   "extuni",  "\\Z", "\\z",                                        \
    "Opt", "^", "$", "char", "charnc", "not",                       \
    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
    "*+","++", "?+", "{",                                           \
-Line 724 
 for debugging. The macro is referenced o
+Line 840 
 for debugging. The macro is referenced o
    "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \
    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
    "AssertB", "AssertB not", "Reverse",                            \
-   "Once", "Bra 0", "Bra", "Cond", "SBra 0", "SBra", "SCond",      \
+   "Once", "Bra", "CBra", "Cond", "SBra", "SCBra", "SCond",        \
-   "Cond ref", "Cond rec", "Cond def", "Brazero", "Braminzero"
+   "Cond ref", "Cond rec", "Cond def", "Brazero", "Braminzero",    \
+   "*PRUNE", "*SKIP", "*THEN", "*COMMIT", "*FAIL", "*ACCEPT",      \
+   "Skip zero"
  /* This macro defines the length of fixed length operations in the compiled
-Line 739 
 in UTF-8 mode. The code that uses this t
+Line 857 
 in UTF-8 mode. The code that uses this t
  #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, 1,                 /* \A, \G, \K, \B, \b                     */ \
-, 1,                          /* Any, Anybyte                           */ \
+, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */ \
-, 3, 1, 1,                    /* NOTPROP, PROP, EXTUNI, ANYNL           */ \
+, 1, 1,                       /* Any, AllAny, Anybyte                   */ \
+, 3, 1,                       /* NOTPROP, PROP, EXTUNI                  */ \
+, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */ \
 , 1, 2, 1, 1,                 /* \Z, \z, Opt, ^, $                      */ \
 ,                             /* Char  - the minimum length             */ \
 ,                             /* Charnc  - the minimum length           */ \
-Line 787 
 in UTF-8 mode. The code that uses this t
+Line 907 
 in UTF-8 mode. The code that uses this t
 ,                             /* RREF                                   */ \
 ,                             /* DEF                                    */ \
 , 1,                          /* BRAZERO, BRAMINZERO                    */ \
+, 1, 1, 1,                    /* PRUNE, SKIP, THEN, COMMIT,             */ \
+, 1, 1                        /* FAIL, ACCEPT, SKIPZERO                 */
  /* A magic value for OP_RREF to indicate the "any recursion" condition. */
-Line 801 
 enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,
+Line 923 
 enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,
         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, ERR48, ERR49,
-        ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57 };
+        ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59,
+        ERR60, ERR61, ERR62, ERR63, ERR64 };
  /* 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 823 
 NOTE NOTE NOTE:
+Line 946 
 NOTE NOTE NOTE:
  typedef struct real_pcre {
    pcre_uint32 magic_number;
    pcre_uint32 size;               /* Total that was malloced */
-   pcre_uint32 options;
+   pcre_uint32 options;            /* Public options */
-   pcre_uint32 dummy1;             /* For future use, maybe */
+   pcre_uint16 flags;              /* Private flags */
+   pcre_uint16 dummy1;             /* For future use */
    pcre_uint16 top_bracket;
    pcre_uint16 top_backref;
    pcre_uint16 first_byte;
-Line 864 
 typedef struct compile_data {
+Line 987 
 typedef struct compile_data {
    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  bracount;                /* Count of capturing parens as we compile */
+   int  final_bracount;          /* Saved value after first pass */
    int  top_backref;             /* Maximum back reference */
    unsigned int backref_map;     /* Bitmap of low back refs */
    int  external_options;        /* External (initial) options */
+   int  external_flags;          /* External flag bits to be set */
    int  req_varyopt;             /* "After variable item" flag for reqbyte */
-   BOOL nopartial;               /* Set TRUE if partial won't work */
+   BOOL had_accept;              /* (*ACCEPT) encountered */
    int  nltype;                  /* Newline type */
    int  nllen;                   /* Newline string length */
    uschar nl[4];                 /* Newline string when fixed length */
-Line 890 
 typedef struct recursion_info {
+Line 1015 
 typedef struct recursion_info {
    struct recursion_info *prevrec; /* 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 */
-   USPTR save_start;             /* Old value of md->start_match */
+   USPTR save_start;             /* Old value of mstart */
    int *offset_save;             /* Pointer to start of saved offsets */
    int saved_max;                /* Number of saved offsets */
  } 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_exec.c, close to the match() function, so that it is easy to keep it in
- step with any changes of local variable. However, the pointer to the current
- 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. NOTE:
- 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. */
-Line 934 
 typedef struct match_data {
+Line 1049 
 typedef struct match_data {
    BOOL   notbol;                /* NOTBOL flag */
    BOOL   noteol;                /* NOTEOL flag */
    BOOL   utf8;                  /* UTF8 flag */
+   BOOL   jscript_compat;        /* JAVASCRIPT_COMPAT flag */
    BOOL   endonly;               /* Dollar not before final \n */
    BOOL   notempty;              /* Empty string match not wanted */
    BOOL   partial;               /* PARTIAL flag */
    BOOL   hitend;                /* Hit the end of the subject at some point */
+   BOOL   bsr_anycrlf;           /* \R is just any CRLF, not full Unicode */
    const uschar *start_code;     /* For use when recursing */
    USPTR  start_subject;         /* Start of the subject string */
    USPTR  end_subject;           /* End of the subject string */
-   USPTR  start_match;           /* Start of this match attempt */
+   USPTR  start_match_ptr;       /* Start of matched string */
    USPTR  end_match_ptr;         /* Subject position at end match */
    int    end_offset_top;        /* Highwater mark at end of match */
    int    capture_last;          /* Most recent capture number */
-Line 950 
 typedef struct match_data {
+Line 1067 
 typedef struct match_data {
    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 */
  } match_data;
  /* A similar structure is used for the same purpose by the DFA matching
-Line 975 
 typedef struct dfa_match_data {
+Line 1091 
 typedef struct dfa_match_data {
  #define ctype_letter  0x02
  #define ctype_digit   0x04
  #define ctype_xdigit  0x08
- #define ctype_word    0x10   /* alphameric or '_' */
+ #define ctype_word    0x10   /* alphanumeric or '_' */
  #define ctype_meta    0x80   /* regexp meta char or zero (end pattern) */
  /* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
-Line 1003 
 total length. */
+Line 1119 
 total length. */
  #define tables_length (ctypes_offset + 256)
  /* Layout of the UCP type table that translates property names into types and
- codes. */
+ codes. Each entry used to point directly to a name, but to reduce the number of
+ relocations in shared libraries, it now has an offset into a single string
+ instead. */
  typedef struct {
-   const char *name;
+   pcre_uint16 name_offset;
    pcre_uint16 type;
    pcre_uint16 value;
  } ucp_type_table;
-Line 1024 
 extern const uschar _pcre_utf8_table4[];
+Line 1142 
 extern const uschar _pcre_utf8_table4[];
  extern const int    _pcre_utf8_table1_size;
+ extern const char   _pcre_utt_names[];
  extern const ucp_type_table _pcre_utt[];
  extern const int _pcre_utt_size;
-Line 1036 
 extern const uschar _pcre_OP_lengths[];
+Line 1155 
 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 BOOL         _pcre_is_newline(const uschar *, const uschar *, int *,
+ extern BOOL         _pcre_is_newline(const uschar *, int, const uschar *,
-                       BOOL);
+                       int *, BOOL);
  extern int          _pcre_ord2utf8(int, uschar *);
  extern real_pcre   *_pcre_try_flipped(const real_pcre *, real_pcre *,
                        const pcre_study_data *, pcre_study_data *);
- extern int          _pcre_ucp_findprop(const unsigned int, int *, int *);
- extern unsigned int _pcre_ucp_othercase(const unsigned int);
  extern int          _pcre_valid_utf8(const uschar *, int);
- extern BOOL         _pcre_was_newline(const uschar *, const uschar *, int *,
+ extern BOOL         _pcre_was_newline(const uschar *, int, const uschar *,
-                       BOOL);
+                       int *, BOOL);
  extern BOOL         _pcre_xclass(int, const uschar *);
+ /* Unicode character database (UCD) */
+ typedef struct {
+   uschar script;
+   uschar chartype;
+   pcre_int32 other_case;
+ } ucd_record;
+ extern const ucd_record  _pcre_ucd_records[];
+ extern const uschar      _pcre_ucd_stage1[];
+ extern const pcre_uint16 _pcre_ucd_stage2[];
+ extern const int         _pcre_ucp_gentype[];
+ /* UCD access macros */
+ #define UCD_BLOCK_SIZE 128
+ #define GET_UCD(ch) (_pcre_ucd_records + \
+         _pcre_ucd_stage2[_pcre_ucd_stage1[(ch) / UCD_BLOCK_SIZE] * \
+         UCD_BLOCK_SIZE + ch % UCD_BLOCK_SIZE])
+ #define UCD_CHARTYPE(ch)  GET_UCD(ch)->chartype
+ #define UCD_SCRIPT(ch)    GET_UCD(ch)->script
+ #define UCD_CATEGORY(ch)  _pcre_ucp_gentype[UCD_CHARTYPE(ch)]
+ #define UCD_OTHERCASE(ch) (ch + GET_UCD(ch)->other_case)
  #endif
  /* End of pcre_internal.h */

 Legend:



Removed from v.118
 


changed lines


 
Added in v.384
 Legend:



Removed from v.118
 


changed lines


 
Added in v.384
-Removed from v.118
+Added in v.384

webmaster@exim.org	ViewVC Help
Powered by ViewVC 1.1.12