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

Diff of /code/trunk/pcre_internal.h

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

revision 601 by ph10, Sat May 7 15:37:31 2011 UTC revision 602 by ph10, Wed May 25 08:29:03 2011 UTC
# Line 1299  enum { Line 1299  enum {
1299    OP_WHITESPACE,         /*  9 \s */    OP_WHITESPACE,         /*  9 \s */
1300    OP_NOT_WORDCHAR,       /* 10 \W */    OP_NOT_WORDCHAR,       /* 10 \W */
1301    OP_WORDCHAR,           /* 11 \w */    OP_WORDCHAR,           /* 11 \w */
1302    
1303    OP_ANY,            /* 12 Match any character except newline */    OP_ANY,            /* 12 Match any character except newline */
1304    OP_ALLANY,         /* 13 Match any character */    OP_ALLANY,         /* 13 Match any character */
1305    OP_ANYBYTE,        /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */    OP_ANYBYTE,        /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
# Line 1313  enum { Line 1314  enum {
1314    OP_EODN,           /* 23 End of data or \n at end of data: \Z. */    OP_EODN,           /* 23 End of data or \n at end of data: \Z. */
1315    OP_EOD,            /* 24 End of data: \z */    OP_EOD,            /* 24 End of data: \z */
1316    
1317    OP_OPT,            /* 25 Set runtime options */    OP_CIRC,           /* 25 Start of line - not multiline */
1318    OP_CIRC,           /* 26 Start of line - varies with multiline switch */    OP_CIRCM,          /* 26 Start of line - multiline */
1319    OP_DOLL,           /* 27 End of line - varies with multiline switch */    OP_DOLL,           /* 27 End of line - not multiline */
1320    OP_CHAR,           /* 28 Match one character, casefully */    OP_DOLLM,          /* 28 End of line - multiline */
1321    OP_CHARNC,         /* 29 Match one character, caselessly */    OP_CHAR,           /* 29 Match one character, casefully */
1322    OP_NOT,            /* 30 Match one character, not the following one */    OP_CHARI,          /* 30 Match one character, caselessly */
1323      OP_NOT,            /* 31 Match one character, not the given one, casefully */
1324    OP_STAR,           /* 31 The maximizing and minimizing versions of */    OP_NOTI,           /* 32 Match one character, not the given one, caselessly */
1325    OP_MINSTAR,        /* 32 these six opcodes must come in pairs, with */  
1326    OP_PLUS,           /* 33 the minimizing one second. */    /* The following sets of 13 opcodes must always be kept in step because
1327    OP_MINPLUS,        /* 34 This first set applies to single characters.*/    the offset from the first one is used to generate the others. */
1328    OP_QUERY,          /* 35 */  
1329    OP_MINQUERY,       /* 36 */    /**** Single characters, caseful, must precede the caseless ones ****/
1330    
1331    OP_UPTO,           /* 37 From 0 to n matches */    OP_STAR,           /* 33 The maximizing and minimizing versions of */
1332    OP_MINUPTO,        /* 38 */    OP_MINSTAR,        /* 34 these six opcodes must come in pairs, with */
1333    OP_EXACT,          /* 39 Exactly n matches */    OP_PLUS,           /* 35 the minimizing one second. */
1334      OP_MINPLUS,        /* 36 */
1335    OP_POSSTAR,        /* 40 Possessified star */    OP_QUERY,          /* 37 */
1336    OP_POSPLUS,        /* 41 Possessified plus */    OP_MINQUERY,       /* 38 */
1337    OP_POSQUERY,       /* 42 Posesssified query */  
1338    OP_POSUPTO,        /* 43 Possessified upto */    OP_UPTO,           /* 39 From 0 to n matches of one character, caseful*/
1339      OP_MINUPTO,        /* 40 */
1340    OP_NOTSTAR,        /* 44 The maximizing and minimizing versions of */    OP_EXACT,          /* 41 Exactly n matches */
1341    OP_NOTMINSTAR,     /* 45 these six opcodes must come in pairs, with */  
1342    OP_NOTPLUS,        /* 46 the minimizing one second. They must be in */    OP_POSSTAR,        /* 42 Possessified star, caseful */
1343    OP_NOTMINPLUS,     /* 47 exactly the same order as those above. */    OP_POSPLUS,        /* 43 Possessified plus, caseful */
1344    OP_NOTQUERY,       /* 48 This set applies to "not" single characters. */    OP_POSQUERY,       /* 44 Posesssified query, caseful */
1345    OP_NOTMINQUERY,    /* 49 */    OP_POSUPTO,        /* 45 Possessified upto, caseful */
1346    
1347    OP_NOTUPTO,        /* 50 From 0 to n matches */    /**** Single characters, caseless, must follow the caseful ones */
1348    OP_NOTMINUPTO,     /* 51 */  
1349    OP_NOTEXACT,       /* 52 Exactly n matches */    OP_STARI,          /* 46 */
1350      OP_MINSTARI,       /* 47 */
1351    OP_NOTPOSSTAR,     /* 53 Possessified versions */    OP_PLUSI,          /* 48 */
1352    OP_NOTPOSPLUS,     /* 54 */    OP_MINPLUSI,       /* 49 */
1353    OP_NOTPOSQUERY,    /* 55 */    OP_QUERYI,         /* 50 */
1354    OP_NOTPOSUPTO,     /* 56 */    OP_MINQUERYI,      /* 51 */
1355    
1356    OP_TYPESTAR,       /* 57 The maximizing and minimizing versions of */    OP_UPTOI,          /* 52 From 0 to n matches of one character, caseless */
1357    OP_TYPEMINSTAR,    /* 58 these six opcodes must come in pairs, with */    OP_MINUPTOI,       /* 53 */
1358    OP_TYPEPLUS,       /* 59 the minimizing one second. These codes must */    OP_EXACTI,         /* 54 */
1359    OP_TYPEMINPLUS,    /* 60 be in exactly the same order as those above. */  
1360    OP_TYPEQUERY,      /* 61 This set applies to character types such as \d */    OP_POSSTARI,       /* 55 Possessified star, caseless */
1361    OP_TYPEMINQUERY,   /* 62 */    OP_POSPLUSI,       /* 56 Possessified plus, caseless */
1362      OP_POSQUERYI,      /* 57 Posesssified query, caseless */
1363    OP_TYPEUPTO,       /* 63 From 0 to n matches */    OP_POSUPTOI,       /* 58 Possessified upto, caseless */
1364    OP_TYPEMINUPTO,    /* 64 */  
1365    OP_TYPEEXACT,      /* 65 Exactly n matches */    /**** The negated ones must follow the non-negated ones, and match them ****/
1366      /**** Negated single character, caseful; must precede the caseless ones ****/
1367    OP_TYPEPOSSTAR,    /* 66 Possessified versions */  
1368    OP_TYPEPOSPLUS,    /* 67 */    OP_NOTSTAR,        /* 59 The maximizing and minimizing versions of */
1369    OP_TYPEPOSQUERY,   /* 68 */    OP_NOTMINSTAR,     /* 60 these six opcodes must come in pairs, with */
1370    OP_TYPEPOSUPTO,    /* 69 */    OP_NOTPLUS,        /* 61 the minimizing one second. They must be in */
1371      OP_NOTMINPLUS,     /* 62 exactly the same order as those above. */
1372    OP_CRSTAR,         /* 70 The maximizing and minimizing versions of */    OP_NOTQUERY,       /* 63 */
1373    OP_CRMINSTAR,      /* 71 all these opcodes must come in pairs, with */    OP_NOTMINQUERY,    /* 64 */
1374    OP_CRPLUS,         /* 72 the minimizing one second. These codes must */  
1375    OP_CRMINPLUS,      /* 73 be in exactly the same order as those above. */    OP_NOTUPTO,        /* 65 From 0 to n matches, caseful */
1376    OP_CRQUERY,        /* 74 These are for character classes and back refs */    OP_NOTMINUPTO,     /* 66 */
1377    OP_CRMINQUERY,     /* 75 */    OP_NOTEXACT,       /* 67 Exactly n matches */
1378    OP_CRRANGE,        /* 76 These are different to the three sets above. */  
1379    OP_CRMINRANGE,     /* 77 */    OP_NOTPOSSTAR,     /* 68 Possessified versions, caseful */
1380      OP_NOTPOSPLUS,     /* 69 */
1381    OP_CLASS,          /* 78 Match a character class, chars < 256 only */    OP_NOTPOSQUERY,    /* 70 */
1382    OP_NCLASS,         /* 79 Same, but the bitmap was created from a negative    OP_NOTPOSUPTO,     /* 71 */
1383                             class - the difference is relevant only when a UTF-8  
1384                             character > 255 is encountered. */    /**** Negated single character, caseless; must follow the caseful ones ****/
1385    
1386    OP_XCLASS,         /* 80 Extended class for handling UTF-8 chars within the    OP_NOTSTARI,       /* 72 */
1387                             class. This does both positive and negative. */    OP_NOTMINSTARI,    /* 73 */
1388      OP_NOTPLUSI,       /* 74 */
1389    OP_REF,            /* 81 Match a back reference */    OP_NOTMINPLUSI,    /* 75 */
1390    OP_RECURSE,        /* 82 Match a numbered subpattern (possibly recursive) */    OP_NOTQUERYI,      /* 76 */
1391    OP_CALLOUT,        /* 83 Call out to external function if provided */    OP_NOTMINQUERYI,   /* 77 */
1392    
1393    OP_ALT,            /* 84 Start of alternation */    OP_NOTUPTOI,       /* 78 From 0 to n matches, caseless */
1394    OP_KET,            /* 85 End of group that doesn't have an unbounded repeat */    OP_NOTMINUPTOI,    /* 79 */
1395    OP_KETRMAX,        /* 86 These two must remain together and in this */    OP_NOTEXACTI,      /* 80 Exactly n matches */
1396    OP_KETRMIN,        /* 87 order. They are for groups the repeat for ever. */  
1397      OP_NOTPOSSTARI,    /* 81 Possessified versions, caseless */
1398      OP_NOTPOSPLUSI,    /* 82 */
1399      OP_NOTPOSQUERYI,   /* 83 */
1400      OP_NOTPOSUPTOI,    /* 84 */
1401    
1402      /**** Character types ****/
1403    
1404      OP_TYPESTAR,       /* 85 The maximizing and minimizing versions of */
1405      OP_TYPEMINSTAR,    /* 86 these six opcodes must come in pairs, with */
1406      OP_TYPEPLUS,       /* 87 the minimizing one second. These codes must */
1407      OP_TYPEMINPLUS,    /* 88 be in exactly the same order as those above. */
1408      OP_TYPEQUERY,      /* 89 */
1409      OP_TYPEMINQUERY,   /* 90 */
1410    
1411      OP_TYPEUPTO,       /* 91 From 0 to n matches */
1412      OP_TYPEMINUPTO,    /* 92 */
1413      OP_TYPEEXACT,      /* 93 Exactly n matches */
1414    
1415      OP_TYPEPOSSTAR,    /* 94 Possessified versions */
1416      OP_TYPEPOSPLUS,    /* 95 */
1417      OP_TYPEPOSQUERY,   /* 96 */
1418      OP_TYPEPOSUPTO,    /* 97 */
1419    
1420      /* These are used for character classes and back references; only the
1421      first six are the same as the sets above. */
1422    
1423      OP_CRSTAR,         /* 98 The maximizing and minimizing versions of */
1424      OP_CRMINSTAR,      /* 99 all these opcodes must come in pairs, with */
1425      OP_CRPLUS,         /* 100 the minimizing one second. These codes must */
1426      OP_CRMINPLUS,      /* 101 be in exactly the same order as those above. */
1427      OP_CRQUERY,        /* 102 */
1428      OP_CRMINQUERY,     /* 103 */
1429    
1430      OP_CRRANGE,        /* 104 These are different to the three sets above. */
1431      OP_CRMINRANGE,     /* 105 */
1432    
1433      /* End of quantifier opcodes */
1434    
1435      OP_CLASS,          /* 106 Match a character class, chars < 256 only */
1436      OP_NCLASS,         /* 107 Same, but the bitmap was created from a negative
1437                                  class - the difference is relevant only when a
1438                                  UTF-8 character > 255 is encountered. */
1439      OP_XCLASS,         /* 108 Extended class for handling UTF-8 chars within the
1440                                  class. This does both positive and negative. */
1441      OP_REF,            /* 109 Match a back reference, casefully */
1442      OP_REFI,           /* 110 Match a back reference, caselessly */
1443      OP_RECURSE,        /* 111 Match a numbered subpattern (possibly recursive) */
1444      OP_CALLOUT,        /* 112 Call out to external function if provided */
1445    
1446      OP_ALT,            /* 113 Start of alternation */
1447      OP_KET,            /* 114 End of group that doesn't have an unbounded repeat */
1448      OP_KETRMAX,        /* 115 These two must remain together and in this */
1449      OP_KETRMIN,        /* 116 order. They are for groups the repeat for ever. */
1450    
1451    /* The assertions must come before BRA, CBRA, ONCE, and COND.*/    /* The assertions must come before BRA, CBRA, ONCE, and COND.*/
1452    
1453    OP_ASSERT,         /* 88 Positive lookahead */    OP_ASSERT,         /* 117 Positive lookahead */
1454    OP_ASSERT_NOT,     /* 89 Negative lookahead */    OP_ASSERT_NOT,     /* 118 Negative lookahead */
1455    OP_ASSERTBACK,     /* 90 Positive lookbehind */    OP_ASSERTBACK,     /* 119 Positive lookbehind */
1456    OP_ASSERTBACK_NOT, /* 91 Negative lookbehind */    OP_ASSERTBACK_NOT, /* 120 Negative lookbehind */
1457    OP_REVERSE,        /* 92 Move pointer back - used in lookbehind assertions */    OP_REVERSE,        /* 121 Move pointer back - used in lookbehind assertions */
1458    
1459    /* ONCE, BRA, CBRA, and COND must come after the assertions, with ONCE first,    /* ONCE, BRA, CBRA, and COND must come after the assertions, with ONCE first,
1460    as there's 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. */
1461    
1462    OP_ONCE,           /* 93 Atomic group */    OP_ONCE,           /* 122 Atomic group */
1463    OP_BRA,            /* 94 Start of non-capturing bracket */    OP_BRA,            /* 123 Start of non-capturing bracket */
1464    OP_CBRA,           /* 95 Start of capturing bracket */    OP_CBRA,           /* 124 Start of capturing bracket */
1465    OP_COND,           /* 96 Conditional group */    OP_COND,           /* 125 Conditional group */
1466    
1467    /* These three must follow the previous three, in the same order. There's a    /* These three must follow the previous three, in the same order. There's a
1468    check for >= SBRA to distinguish the two sets. */    check for >= SBRA to distinguish the two sets. */
1469    
1470    OP_SBRA,           /* 97 Start of non-capturing bracket, check empty  */    OP_SBRA,           /* 126 Start of non-capturing bracket, check empty  */
1471    OP_SCBRA,          /* 98 Start of capturing bracket, check empty */    OP_SCBRA,          /* 127 Start of capturing bracket, check empty */
1472    OP_SCOND,          /* 99 Conditional group, check empty */    OP_SCOND,          /* 128 Conditional group, check empty */
1473    
1474    /* The next two pairs must (respectively) be kept together. */    /* The next two pairs must (respectively) be kept together. */
1475    
1476    OP_CREF,           /* 100 Used to hold a capture number as condition */    OP_CREF,           /* 129 Used to hold a capture number as condition */
1477    OP_NCREF,          /* 101 Same, but generated by a name reference*/    OP_NCREF,          /* 130 Same, but generated by a name reference*/
1478    OP_RREF,           /* 102 Used to hold a recursion number as condition */    OP_RREF,           /* 131 Used to hold a recursion number as condition */
1479    OP_NRREF,          /* 103 Same, but generated by a name reference*/    OP_NRREF,          /* 132 Same, but generated by a name reference*/
1480    OP_DEF,            /* 104 The DEFINE condition */    OP_DEF,            /* 133 The DEFINE condition */
1481    
1482    OP_BRAZERO,        /* 105 These two must remain together and in this */    OP_BRAZERO,        /* 134 These two must remain together and in this */
1483    OP_BRAMINZERO,     /* 106 order. */    OP_BRAMINZERO,     /* 135 order. */
1484    
1485    /* These are backtracking control verbs */    /* These are backtracking control verbs */
1486    
1487    OP_MARK,           /* 107 always has an argument */    OP_MARK,           /* 136 always has an argument */
1488    OP_PRUNE,          /* 108 */    OP_PRUNE,          /* 137 */
1489    OP_PRUNE_ARG,      /* 109 same, but with argument */    OP_PRUNE_ARG,      /* 138 same, but with argument */
1490    OP_SKIP,           /* 110 */    OP_SKIP,           /* 139 */
1491    OP_SKIP_ARG,       /* 111 same, but with argument */    OP_SKIP_ARG,       /* 140 same, but with argument */
1492    OP_THEN,           /* 112 */    OP_THEN,           /* 141 */
1493    OP_THEN_ARG,       /* 113 same, but with argument */    OP_THEN_ARG,       /* 142 same, but with argument */
1494    OP_COMMIT,         /* 114 */    OP_COMMIT,         /* 143 */
1495    
1496    /* These are forced failure and success verbs */    /* These are forced failure and success verbs */
1497    
1498    OP_FAIL,           /* 115 */    OP_FAIL,           /* 144 */
1499    OP_ACCEPT,         /* 116 */    OP_ACCEPT,         /* 145 */
1500    OP_CLOSE,          /* 117 Used before OP_ACCEPT to close open captures */    OP_CLOSE,          /* 146 Used before OP_ACCEPT to close open captures */
1501    
1502    /* This is used to skip a subpattern with a {0} quantifier */    /* This is used to skip a subpattern with a {0} quantifier */
1503    
1504    OP_SKIPZERO,       /* 118 */    OP_SKIPZERO,       /* 147 */
1505    
1506    /* This is not an opcode, but is used to check that tables indexed by opcode    /* This is not an opcode, but is used to check that tables indexed by opcode
1507    are the correct length, in order to catch updating errors - there have been    are the correct length, in order to catch updating errors - there have been
# Line 1462  called "coptable" and "poptable" in pcre Line 1516  called "coptable" and "poptable" in pcre
1516    
1517    
1518  /* This macro defines textual names for all the opcodes. These are used only  /* This macro defines textual names for all the opcodes. These are used only
1519  for debugging. The macro is referenced only in pcre_printint.c. */  for debugging, and some of them are only partial names. The macro is referenced
1520    only in pcre_printint.c, which fills out the full names in many cases (and in
1521    some cases doesn't actually use these names at all). */
1522    
1523  #define OP_NAME_LIST \  #define OP_NAME_LIST \
1524    "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d",         \    "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d",         \
1525    "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte",         \    "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte",         \
1526    "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v",           \    "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v",           \
1527    "extuni",  "\\Z", "\\z",                                        \    "extuni",  "\\Z", "\\z",                                        \
1528    "Opt", "^", "$", "char", "charnc", "not",                       \    "^", "^", "$", "$", "char", "chari", "not", "noti",             \
1529    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \    "*", "*?", "+", "+?", "?", "??",                                \
1530      "{", "{", "{",                                                  \
1531    "*+","++", "?+", "{",                                           \    "*+","++", "?+", "{",                                           \
1532    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \    "*", "*?", "+", "+?", "?", "??",                                \
1533      "{", "{", "{",                                                  \
1534      "*+","++", "?+", "{",                                           \
1535      "*", "*?", "+", "+?", "?", "??",                                \
1536      "{", "{", "{",                                                  \
1537      "*+","++", "?+", "{",                                           \
1538      "*", "*?", "+", "+?", "?", "??",                                \
1539      "{", "{", "{",                                                  \
1540    "*+","++", "?+", "{",                                           \    "*+","++", "?+", "{",                                           \
1541    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \    "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
1542    "*+","++", "?+", "{",                                           \    "*+","++", "?+", "{",                                           \
1543    "*", "*?", "+", "+?", "?", "??", "{", "{",                      \    "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
1544    "class", "nclass", "xclass", "Ref", "Recurse", "Callout",       \    "class", "nclass", "xclass", "Ref", "Refi",                     \
1545      "Recurse", "Callout",                                           \
1546    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \    "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",     \
1547    "AssertB", "AssertB not", "Reverse",                            \    "AssertB", "AssertB not", "Reverse",                            \
1548    "Once", "Bra", "CBra", "Cond", "SBra", "SCBra", "SCond",        \    "Once", "Bra", "CBra", "Cond", "SBra", "SCBra", "SCond",        \
# Line 1505  in UTF-8 mode. The code that uses this t Line 1570  in UTF-8 mode. The code that uses this t
1570    3, 3,                          /* \P, \p                                 */ \    3, 3,                          /* \P, \p                                 */ \
1571    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */ \    1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */ \
1572    1,                             /* \X                                     */ \    1,                             /* \X                                     */ \
1573    1, 1, 2, 1, 1,                 /* \Z, \z, Opt, ^, $                      */ \    1, 1, 1, 1, 1, 1,              /* \Z, \z, ^, ^M, $, $M                   */ \
1574    2,                             /* Char  - the minimum length             */ \    2,                             /* Char  - the minimum length             */ \
1575    2,                             /* Charnc  - the minimum length           */ \    2,                             /* Chari  - the minimum length            */ \
1576    2,                             /* not                                    */ \    2,                             /* not                                    */ \
1577    /* Positive single-char repeats                            ** These are  */ \    2,                             /* noti                                   */ \
1578    2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??      ** minima in  */ \    /* Positive single-char repeats                             ** These are */ \
1579    4, 4, 4,                       /* upto, minupto, exact     ** UTF-8 mode */ \    2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??       ** minima in */ \
1580      4, 4, 4,                       /* upto, minupto, exact      ** mode      */ \
1581    2, 2, 2, 4,                    /* *+, ++, ?+, upto+                      */ \    2, 2, 2, 4,                    /* *+, ++, ?+, upto+                      */ \
1582      2, 2, 2, 2, 2, 2,              /* *I, *?I, +I, +?I, ?I, ??I ** UTF-8     */ \
1583      4, 4, 4,                       /* upto I, minupto I, exact I             */ \
1584      2, 2, 2, 4,                    /* *+I, ++I, ?+I, upto+I                  */ \
1585    /* Negative single-char repeats - only for chars < 256                   */ \    /* Negative single-char repeats - only for chars < 256                   */ \
1586    2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \    2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
1587    4, 4, 4,                       /* NOT upto, minupto, exact               */ \    4, 4, 4,                       /* NOT upto, minupto, exact               */ \
1588    2, 2, 2, 4,                    /* Possessive *, +, ?, upto               */ \    2, 2, 2, 4,                    /* Possessive NOT *, +, ?, upto           */ \
1589      2, 2, 2, 2, 2, 2,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */ \
1590      4, 4, 4,                       /* NOT upto I, minupto I, exact I         */ \
1591      2, 2, 2, 4,                    /* Possessive NOT *I, +I, ?I, upto I      */ \
1592    /* Positive type repeats                                                 */ \    /* Positive type repeats                                                 */ \
1593    2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \    2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
1594    4, 4, 4,                       /* Type upto, minupto, exact              */ \    4, 4, 4,                       /* Type upto, minupto, exact              */ \
# Line 1528  in UTF-8 mode. The code that uses this t Line 1600  in UTF-8 mode. The code that uses this t
1600   33,                             /* NCLASS                                 */ \   33,                             /* NCLASS                                 */ \
1601    0,                             /* XCLASS - variable length               */ \    0,                             /* XCLASS - variable length               */ \
1602    3,                             /* REF                                    */ \    3,                             /* REF                                    */ \
1603      3,                             /* REFI                                   */ \
1604    1+LINK_SIZE,                   /* RECURSE                                */ \    1+LINK_SIZE,                   /* RECURSE                                */ \
1605    2+2*LINK_SIZE,                 /* CALLOUT                                */ \    2+2*LINK_SIZE,                 /* CALLOUT                                */ \
1606    1+LINK_SIZE,                   /* Alt                                    */ \    1+LINK_SIZE,                   /* Alt                                    */ \
# Line 1553  in UTF-8 mode. The code that uses this t Line 1626  in UTF-8 mode. The code that uses this t
1626    3, 1, 3,                       /* MARK, PRUNE, PRUNE_ARG                 */ \    3, 1, 3,                       /* MARK, PRUNE, PRUNE_ARG                 */ \
1627    1, 3,                          /* SKIP, SKIP_ARG                         */ \    1, 3,                          /* SKIP, SKIP_ARG                         */ \
1628    1+LINK_SIZE, 3+LINK_SIZE,      /* THEN, THEN_ARG                         */ \    1+LINK_SIZE, 3+LINK_SIZE,      /* THEN, THEN_ARG                         */ \
1629    1, 1, 1, 3, 1                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */    1, 1, 1, 3, 1                  /* COMMIT, FAIL, ACCEPT, CLOSE, SKIPZERO  */ \
   
1630    
1631  /* A magic value for OP_RREF and OP_NRREF to indicate the "any recursion"  /* A magic value for OP_RREF and OP_NRREF to indicate the "any recursion"
1632  condition. */  condition. */

Legend:
Removed from v.601  
changed lines
  Added in v.602

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12