pcre_internal.h

php-4.4.7学习linux时下载的源代码

      c |= (eptr[gcii] & 0x3f) << gcss; \
      } \
    }

/* Get the next UTF-8 character, advancing the pointer. This is called when we
know we are in UTF-8 mode. */

#define GETCHARINC(c, eptr) \
  c = *eptr++; \
  if (c >= 0xc0) \
    { \
    int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
    int gcss = 6*gcaa; \
    c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
    while (gcaa-- > 0) \
      { \
      gcss -= 6; \
      c |= (*eptr++ & 0x3f) << gcss; \
      } \
    }

/* Get the next character, testing for UTF-8 mode, and advancing the pointer */

#define GETCHARINCTEST(c, eptr) \
  c = *eptr++; \
  if (utf8 && c >= 0xc0) \
    { \
    int gcaa = _pcre_utf8_table4[c & 0x3f];  /* Number of additional bytes */ \
    int gcss = 6*gcaa; \
    c = (c & _pcre_utf8_table3[gcaa]) << gcss; \
    while (gcaa-- > 0) \
      { \
      gcss -= 6; \
      c |= (*eptr++ & 0x3f) << gcss; \
      } \
    }

/* Get the next UTF-8 character, not advancing the pointer, incrementing length
if there are extra bytes. This is called when we know we are in UTF-8 mode. */

#define GETCHARLEN(c, eptr, len) \
  c = *eptr; \
  if (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. */

#define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--;

#endif


/* In case there is no definition of offsetof() provided - though any proper
Standard C system should have one. */

#ifndef offsetof
#define offsetof(p_type,field) ((size_t)&(((p_type *)0)->field))
#endif


/* These are the public options that can change during matching. */

#define PCRE_IMS (PCRE_CASELESS|PCRE_MULTILINE|PCRE_DOTALL)

/* Private options flags start at the most significant end of the four bytes.
The public options defined in pcre.h start at the least significant end. Make
sure they don't overlap! The bits are getting a bit scarce now -- when we run
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_JCHANGED      0x08000000  /* j option changes within regex */

/* Options for the "extra" block produced by pcre_study(). */

#define PCRE_STUDY_MAPPED   0x01     /* a map of starting chars exists */

/* 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 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)

#define PUBLIC_EXEC_OPTIONS \
  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NO_UTF8_CHECK| \
   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_NEWLINE_BITS)

#define PUBLIC_STUDY_OPTIONS 0   /* None defined */

/* Magic number to provide a small check against being handed junk. Also used
to detect whether a pattern was compiled on a host of different endianness. */

#define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */

/* Negative values for the firstchar and reqchar variables */

#define REQ_UNSET (-2)
#define REQ_NONE  (-1)

/* The maximum remaining length of subject we are prepared to search for a
req_byte match. */

#define REQ_BYTE_MAX 1000

/* 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;

#define FALSE   0
#define TRUE    1

/* Escape items that are just an encoding of a particular data value. */

#ifndef ESC_e
#define ESC_e 27
#endif

#ifndef ESC_f
#define ESC_f '\f'
#endif

#ifndef ESC_n
#define ESC_n '\n'
#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

/* Codes for different types of Unicode property */

#define PT_ANY        0    /* Any property - matches all chars */
#define PT_LAMP       1    /* L& - the union of Lu, Ll, Lt */
#define PT_GC         2    /* General characteristic (e.g. L) */
#define PT_PC         3    /* Particular characteristic (e.g. Lu) */
#define PT_SC         4    /* Script (e.g. Han) */

/* 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 */
#define XCL_PROP      3    /* Unicode property (2-byte property code follows) */
#define XCL_NOTPROP   4    /* Unicode inverted property (ditto) */

/* 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. 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 backreferences (\1, \2, \3, etc).
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
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_R, ESC_X, ESC_Z, ESC_z,
       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.

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 */

  /* Values corresponding to backslashed metacharacters */

  OP_SOD,            /* 1 Start of data: \A */
  OP_SOM,            /* 2 Start of match (subject + offset): \G */
  OP_NOT_WORD_BOUNDARY,  /*  3 \B */
  OP_WORD_BOUNDARY,      /*  4 \b */
  OP_NOT_DIGIT,          /*  5 \D */
  OP_DIGIT,              /*  6 \d */
  OP_NOT_WHITESPACE,     /*  7 \S */
  OP_WHITESPACE,         /*  8 \s */
  OP_NOT_WORDCHAR,       /*  9 \W */
  OP_WORDCHAR,           /* 10 \w */
  OP_ANY,            /* 11 Match any character */
  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_ANYNL,          /* 15 \R (any newline sequence) */
  OP_EXTUNI,         /* 16 \X (extended Unicode sequence */
  OP_EODN,           /* 17 End of data or \n at end of data: \Z. */
  OP_EOD,            /* 18 End of data: \z */

  OP_OPT,            /* 19 Set runtime options */
  OP_CIRC,           /* 20 Start of line - varies with multiline switch */
  OP_DOLL,           /* 21 End of line - varies with multiline switch */
  OP_CHAR,           /* 22 Match one character, casefully */
  OP_CHARNC,         /* 23 Match one character, caselessly */
  OP_NOT,            /* 24 Match one character, not the following one */

  OP_STAR,           /* 25 The maximizing and minimizing versions of */
  OP_MINSTAR,        /* 26 these six opcodes must come in pairs, with */
  OP_PLUS,           /* 27 the minimizing one second. */
  OP_MINPLUS,        /* 28 This first set applies to single characters.*/
  OP_QUERY,          /* 29 */
  OP_MINQUERY,       /* 30 */

  OP_UPTO,           /* 31 From 0 to n matches */
  OP_MINUPTO,        /* 32 */
  OP_EXACT,          /* 33 Exactly n matches */

  OP_POSSTAR,        /* 34 Possessified star */
  OP_POSPLUS,        /* 35 Possessified plus */
  OP_POSQUERY,       /* 36 Posesssified query */
  OP_POSUPTO,        /* 37 Possessified upto */

  OP_NOTSTAR,        /* 38 The maximizing and minimizing versions of */
  OP_NOTMINSTAR,     /* 39 these six opcodes must come in pairs, with */
  OP_NOTPLUS,        /* 40 the minimizing one second. They must be in */
  OP_NOTMINPLUS,     /* 41 exactly the same order as those above. */
  OP_NOTQUERY,       /* 42 This set applies to "not" single characters. */
  OP_NOTMINQUERY,    /* 43 */

  OP_NOTUPTO,        /* 44 From 0 to n matches */
  OP_NOTMINUPTO,     /* 45 */
  OP_NOTEXACT,       /* 46 Exactly n matches */

  OP_NOTPOSSTAR,     /* 47 Possessified versions */
  OP_NOTPOSPLUS,     /* 48 */
  OP_NOTPOSQUERY,    /* 49 */
  OP_NOTPOSUPTO,     /* 50 */

  OP_TYPESTAR,       /* 51 The maximizing and minimizing versions of */
  OP_TYPEMINSTAR,    /* 52 these six opcodes must come in pairs, with */
  OP_TYPEPLUS,       /* 53 the minimizing one second. These codes must */
  OP_TYPEMINPLUS,    /* 54 be in exactly the same order as those above. */
  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,          /* 72 Match a character class, chars < 256 only */
  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,         /* 74 Extended class for handling UTF-8 chars within the
                           class. This does both positive and negative. */

  OP_REF,            /* 75 Match a back reference */
  OP_RECURSE,        /* 76 Match a numbered subpattern (possibly recursive) */
  OP_CALLOUT,        /* 77 Call out to external function if provided */

  OP_ALT,            /* 78 Start of alternation */
  OP_KET,            /* 79 End of group that doesn't have an unbounded repeat */
  OP_KETRMAX,        /* 80 These two must remain together and in this */
  OP_KETRMIN,        /* 81 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_NOT,     /* 83 Negative lookahead */
  OP_ASSERTBACK,     /* 84 Positive lookbehind */
  OP_ASSERTBACK_NOT, /* 85 Negative lookbehind */
  OP_REVERSE,        /* 86 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_BRA,            /* 88 Start of non-capturing bracket */
  OP_CBRA,           /* 89 Start of capturing bracket */
  OP_COND,           /* 90 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_SCBRA,          /* 92 Start of capturing bracket, check empty */
  OP_SCOND,          /* 93 Conditional group, check empty */

  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 */

  OP_BRAZERO,        /* 97 These two must remain together and in this */
  OP_BRAMINZERO      /* 98 order. */
};