home *** CD-ROM | disk | FTP | other *** search
/ Netrunner 2004 October / NETRUNNER0410.ISO / regular / ActivePerl-5.8.4.810-MSWin32-x86.msi / _5e86db192c1fcfff649057ed2a05b7bc < prev    next >
Encoding:
Text File  |  2004-06-01  |  9.8 KB  |  341 lines
  1. /* !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
  2.    This file is built by regcomp.pl from regcomp.sym.
  3.    Any changes made here will be lost!
  4. */
  5.  
  6. #define    END    0    /*    0 End of program. */
  7. #define    SUCCEED    1    /*  0x1 Return from a subroutine, basically. */
  8. #define    BOL    2    /*  0x2 Match "" at beginning of line. */
  9. #define    MBOL    3    /*  0x3 Same, assuming multiline. */
  10. #define    SBOL    4    /*  0x4 Same, assuming singleline. */
  11. #define    EOS    5    /*  0x5 Match "" at end of string. */
  12. #define    EOL    6    /*  0x6 Match "" at end of line. */
  13. #define    MEOL    7    /*  0x7 Same, assuming multiline. */
  14. #define    SEOL    8    /*  0x8 Same, assuming singleline. */
  15. #define    BOUND    9    /*  0x9 Match "" at any word boundary */
  16. #define    BOUNDL    10    /*  0xa Match "" at any word boundary */
  17. #define    NBOUND    11    /*  0xb Match "" at any word non-boundary */
  18. #define    NBOUNDL    12    /*  0xc Match "" at any word non-boundary */
  19. #define    GPOS    13    /*  0xd Matches where last m//g left off. */
  20. #define    REG_ANY    14    /*  0xe Match any one character (except newline). */
  21. #define    SANY    15    /*  0xf Match any one character. */
  22. #define    CANY    16    /* 0x10 Match any one byte. */
  23. #define    ANYOF    17    /* 0x11 Match character in (or not in) this class. */
  24. #define    ALNUM    18    /* 0x12 Match any alphanumeric character */
  25. #define    ALNUML    19    /* 0x13 Match any alphanumeric char in locale */
  26. #define    NALNUM    20    /* 0x14 Match any non-alphanumeric character */
  27. #define    NALNUML    21    /* 0x15 Match any non-alphanumeric char in locale */
  28. #define    SPACE    22    /* 0x16 Match any whitespace character */
  29. #define    SPACEL    23    /* 0x17 Match any whitespace char in locale */
  30. #define    NSPACE    24    /* 0x18 Match any non-whitespace character */
  31. #define    NSPACEL    25    /* 0x19 Match any non-whitespace char in locale */
  32. #define    DIGIT    26    /* 0x1a Match any numeric character */
  33. #define    DIGITL    27    /* 0x1b Match any numeric character in locale */
  34. #define    NDIGIT    28    /* 0x1c Match any non-numeric character */
  35. #define    NDIGITL    29    /* 0x1d Match any non-numeric character in locale */
  36. #define    CLUMP    30    /* 0x1e Match any combining character sequence */
  37. #define    BRANCH    31    /* 0x1f Match this alternative, or the next... */
  38. #define    BACK    32    /* 0x20 Match "", "next" ptr points backward. */
  39. #define    EXACT    33    /* 0x21 Match this string (preceded by length). */
  40. #define    EXACTF    34    /* 0x22 Match this string, folded (prec. by length). */
  41. #define    EXACTFL    35    /* 0x23 Match this string, folded in locale (w/len). */
  42. #define    NOTHING    36    /* 0x24 Match empty string. */
  43. #define    TAIL    37    /* 0x25 Match empty string. Can jump here from outside. */
  44. #define    STAR    38    /* 0x26 Match this (simple) thing 0 or more times. */
  45. #define    PLUS    39    /* 0x27 Match this (simple) thing 1 or more times. */
  46. #define    CURLY    40    /* 0x28 Match this simple thing {n,m} times. */
  47. #define    CURLYN    41    /* 0x29 Match next-after-this simple thing  */
  48. #define    CURLYM    42    /* 0x2a Match this medium-complex thing {n,m} times. */
  49. #define    CURLYX    43    /* 0x2b Match this complex thing {n,m} times. */
  50. #define    WHILEM    44    /* 0x2c Do curly processing and see if rest matches. */
  51. #define    OPEN    45    /* 0x2d Mark this point in input as start of #n. */
  52. #define    CLOSE    46    /* 0x2e Analogous to OPEN. */
  53. #define    REF    47    /* 0x2f Match some already matched string */
  54. #define    REFF    48    /* 0x30 Match already matched string, folded */
  55. #define    REFFL    49    /* 0x31 Match already matched string, folded in loc. */
  56. #define    IFMATCH    50    /* 0x32 Succeeds if the following matches. */
  57. #define    UNLESSM    51    /* 0x33 Fails if the following matches. */
  58. #define    SUSPEND    52    /* 0x34 "Independent" sub-RE. */
  59. #define    IFTHEN    53    /* 0x35 Switch, should be preceeded by switcher . */
  60. #define    GROUPP    54    /* 0x36 Whether the group matched. */
  61. #define    LONGJMP    55    /* 0x37 Jump far away. */
  62. #define    BRANCHJ    56    /* 0x38 BRANCH with long offset. */
  63. #define    EVAL    57    /* 0x39 Execute some Perl code. */
  64. #define    MINMOD    58    /* 0x3a Next operator is not greedy. */
  65. #define    LOGICAL    59    /* 0x3b Next opcode should set the flag only. */
  66. #define    RENUM    60    /* 0x3c Group with independently numbered parens. */
  67. #define    OPTIMIZED    61    /* 0x3d Placeholder for dump. */
  68.  
  69. #ifndef DOINIT
  70. EXTCONST U8 PL_regkind[];
  71. #else
  72. EXTCONST U8 PL_regkind[] = {
  73.     END,        /* END */
  74.     END,        /* SUCCEED */
  75.     BOL,        /* BOL */
  76.     BOL,        /* MBOL */
  77.     BOL,        /* SBOL */
  78.     EOL,        /* EOS */
  79.     EOL,        /* EOL */
  80.     EOL,        /* MEOL */
  81.     EOL,        /* SEOL */
  82.     BOUND,        /* BOUND */
  83.     BOUND,        /* BOUNDL */
  84.     NBOUND,        /* NBOUND */
  85.     NBOUND,        /* NBOUNDL */
  86.     GPOS,        /* GPOS */
  87.     REG_ANY,        /* REG_ANY */
  88.     REG_ANY,        /* SANY */
  89.     REG_ANY,        /* CANY */
  90.     ANYOF,        /* ANYOF */
  91.     ALNUM,        /* ALNUM */
  92.     ALNUM,        /* ALNUML */
  93.     NALNUM,        /* NALNUM */
  94.     NALNUM,        /* NALNUML */
  95.     SPACE,        /* SPACE */
  96.     SPACE,        /* SPACEL */
  97.     NSPACE,        /* NSPACE */
  98.     NSPACE,        /* NSPACEL */
  99.     DIGIT,        /* DIGIT */
  100.     DIGIT,        /* DIGITL */
  101.     NDIGIT,        /* NDIGIT */
  102.     NDIGIT,        /* NDIGITL */
  103.     CLUMP,        /* CLUMP */
  104.     BRANCH,        /* BRANCH */
  105.     BACK,        /* BACK */
  106.     EXACT,        /* EXACT */
  107.     EXACT,        /* EXACTF */
  108.     EXACT,        /* EXACTFL */
  109.     NOTHING,        /* NOTHING */
  110.     NOTHING,        /* TAIL */
  111.     STAR,        /* STAR */
  112.     PLUS,        /* PLUS */
  113.     CURLY,        /* CURLY */
  114.     CURLY,        /* CURLYN */
  115.     CURLY,        /* CURLYM */
  116.     CURLY,        /* CURLYX */
  117.     WHILEM,        /* WHILEM */
  118.     OPEN,        /* OPEN */
  119.     CLOSE,        /* CLOSE */
  120.     REF,        /* REF */
  121.     REF,        /* REFF */
  122.     REF,        /* REFFL */
  123.     BRANCHJ,        /* IFMATCH */
  124.     BRANCHJ,        /* UNLESSM */
  125.     BRANCHJ,        /* SUSPEND */
  126.     BRANCHJ,        /* IFTHEN */
  127.     GROUPP,        /* GROUPP */
  128.     LONGJMP,        /* LONGJMP */
  129.     BRANCHJ,        /* BRANCHJ */
  130.     EVAL,        /* EVAL */
  131.     MINMOD,        /* MINMOD */
  132.     LOGICAL,        /* LOGICAL */
  133.     BRANCHJ,        /* RENUM */
  134.     NOTHING,        /* OPTIMIZED */
  135. };
  136. #endif
  137.  
  138.  
  139. #ifdef REG_COMP_C
  140. static const U8 regarglen[] = {
  141.     0,        /* END */
  142.     0,        /* SUCCEED */
  143.     0,        /* BOL */
  144.     0,        /* MBOL */
  145.     0,        /* SBOL */
  146.     0,        /* EOS */
  147.     0,        /* EOL */
  148.     0,        /* MEOL */
  149.     0,        /* SEOL */
  150.     0,        /* BOUND */
  151.     0,        /* BOUNDL */
  152.     0,        /* NBOUND */
  153.     0,        /* NBOUNDL */
  154.     0,        /* GPOS */
  155.     0,        /* REG_ANY */
  156.     0,        /* SANY */
  157.     0,        /* CANY */
  158.     0,        /* ANYOF */
  159.     0,        /* ALNUM */
  160.     0,        /* ALNUML */
  161.     0,        /* NALNUM */
  162.     0,        /* NALNUML */
  163.     0,        /* SPACE */
  164.     0,        /* SPACEL */
  165.     0,        /* NSPACE */
  166.     0,        /* NSPACEL */
  167.     0,        /* DIGIT */
  168.     0,        /* DIGITL */
  169.     0,        /* NDIGIT */
  170.     0,        /* NDIGITL */
  171.     0,        /* CLUMP */
  172.     0,        /* BRANCH */
  173.     0,        /* BACK */
  174.     0,        /* EXACT */
  175.     0,        /* EXACTF */
  176.     0,        /* EXACTFL */
  177.     0,        /* NOTHING */
  178.     0,        /* TAIL */
  179.     0,        /* STAR */
  180.     0,        /* PLUS */
  181.     EXTRA_SIZE(struct regnode_2),        /* CURLY */
  182.     EXTRA_SIZE(struct regnode_2),        /* CURLYN */
  183.     EXTRA_SIZE(struct regnode_2),        /* CURLYM */
  184.     EXTRA_SIZE(struct regnode_2),        /* CURLYX */
  185.     0,        /* WHILEM */
  186.     EXTRA_SIZE(struct regnode_1),        /* OPEN */
  187.     EXTRA_SIZE(struct regnode_1),        /* CLOSE */
  188.     EXTRA_SIZE(struct regnode_1),        /* REF */
  189.     EXTRA_SIZE(struct regnode_1),        /* REFF */
  190.     EXTRA_SIZE(struct regnode_1),        /* REFFL */
  191.     EXTRA_SIZE(struct regnode_1),        /* IFMATCH */
  192.     EXTRA_SIZE(struct regnode_1),        /* UNLESSM */
  193.     EXTRA_SIZE(struct regnode_1),        /* SUSPEND */
  194.     EXTRA_SIZE(struct regnode_1),        /* IFTHEN */
  195.     EXTRA_SIZE(struct regnode_1),        /* GROUPP */
  196.     EXTRA_SIZE(struct regnode_1),        /* LONGJMP */
  197.     EXTRA_SIZE(struct regnode_1),        /* BRANCHJ */
  198.     EXTRA_SIZE(struct regnode_1),        /* EVAL */
  199.     0,        /* MINMOD */
  200.     0,        /* LOGICAL */
  201.     EXTRA_SIZE(struct regnode_1),        /* RENUM */
  202.     0,        /* OPTIMIZED */
  203. };
  204.  
  205. static const char reg_off_by_arg[] = {
  206.     0,        /* END */
  207.     0,        /* SUCCEED */
  208.     0,        /* BOL */
  209.     0,        /* MBOL */
  210.     0,        /* SBOL */
  211.     0,        /* EOS */
  212.     0,        /* EOL */
  213.     0,        /* MEOL */
  214.     0,        /* SEOL */
  215.     0,        /* BOUND */
  216.     0,        /* BOUNDL */
  217.     0,        /* NBOUND */
  218.     0,        /* NBOUNDL */
  219.     0,        /* GPOS */
  220.     0,        /* REG_ANY */
  221.     0,        /* SANY */
  222.     0,        /* CANY */
  223.     0,        /* ANYOF */
  224.     0,        /* ALNUM */
  225.     0,        /* ALNUML */
  226.     0,        /* NALNUM */
  227.     0,        /* NALNUML */
  228.     0,        /* SPACE */
  229.     0,        /* SPACEL */
  230.     0,        /* NSPACE */
  231.     0,        /* NSPACEL */
  232.     0,        /* DIGIT */
  233.     0,        /* DIGITL */
  234.     0,        /* NDIGIT */
  235.     0,        /* NDIGITL */
  236.     0,        /* CLUMP */
  237.     0,        /* BRANCH */
  238.     0,        /* BACK */
  239.     0,        /* EXACT */
  240.     0,        /* EXACTF */
  241.     0,        /* EXACTFL */
  242.     0,        /* NOTHING */
  243.     0,        /* TAIL */
  244.     0,        /* STAR */
  245.     0,        /* PLUS */
  246.     0,        /* CURLY */
  247.     0,        /* CURLYN */
  248.     0,        /* CURLYM */
  249.     0,        /* CURLYX */
  250.     0,        /* WHILEM */
  251.     0,        /* OPEN */
  252.     0,        /* CLOSE */
  253.     0,        /* REF */
  254.     0,        /* REFF */
  255.     0,        /* REFFL */
  256.     2,        /* IFMATCH */
  257.     2,        /* UNLESSM */
  258.     1,        /* SUSPEND */
  259.     1,        /* IFTHEN */
  260.     0,        /* GROUPP */
  261.     1,        /* LONGJMP */
  262.     1,        /* BRANCHJ */
  263.     0,        /* EVAL */
  264.     0,        /* MINMOD */
  265.     0,        /* LOGICAL */
  266.     1,        /* RENUM */
  267.     0,        /* OPTIMIZED */
  268. };
  269.  
  270. #ifdef DEBUGGING
  271. static const char * const reg_name[] = {
  272.     "END",        /*    0 */
  273.     "SUCCEED",        /*  0x1 */
  274.     "BOL",        /*  0x2 */
  275.     "MBOL",        /*  0x3 */
  276.     "SBOL",        /*  0x4 */
  277.     "EOS",        /*  0x5 */
  278.     "EOL",        /*  0x6 */
  279.     "MEOL",        /*  0x7 */
  280.     "SEOL",        /*  0x8 */
  281.     "BOUND",        /*  0x9 */
  282.     "BOUNDL",        /*  0xa */
  283.     "NBOUND",        /*  0xb */
  284.     "NBOUNDL",        /*  0xc */
  285.     "GPOS",        /*  0xd */
  286.     "REG_ANY",        /*  0xe */
  287.     "SANY",        /*  0xf */
  288.     "CANY",        /* 0x10 */
  289.     "ANYOF",        /* 0x11 */
  290.     "ALNUM",        /* 0x12 */
  291.     "ALNUML",        /* 0x13 */
  292.     "NALNUM",        /* 0x14 */
  293.     "NALNUML",        /* 0x15 */
  294.     "SPACE",        /* 0x16 */
  295.     "SPACEL",        /* 0x17 */
  296.     "NSPACE",        /* 0x18 */
  297.     "NSPACEL",        /* 0x19 */
  298.     "DIGIT",        /* 0x1a */
  299.     "DIGITL",        /* 0x1b */
  300.     "NDIGIT",        /* 0x1c */
  301.     "NDIGITL",        /* 0x1d */
  302.     "CLUMP",        /* 0x1e */
  303.     "BRANCH",        /* 0x1f */
  304.     "BACK",        /* 0x20 */
  305.     "EXACT",        /* 0x21 */
  306.     "EXACTF",        /* 0x22 */
  307.     "EXACTFL",        /* 0x23 */
  308.     "NOTHING",        /* 0x24 */
  309.     "TAIL",        /* 0x25 */
  310.     "STAR",        /* 0x26 */
  311.     "PLUS",        /* 0x27 */
  312.     "CURLY",        /* 0x28 */
  313.     "CURLYN",        /* 0x29 */
  314.     "CURLYM",        /* 0x2a */
  315.     "CURLYX",        /* 0x2b */
  316.     "WHILEM",        /* 0x2c */
  317.     "OPEN",        /* 0x2d */
  318.     "CLOSE",        /* 0x2e */
  319.     "REF",        /* 0x2f */
  320.     "REFF",        /* 0x30 */
  321.     "REFFL",        /* 0x31 */
  322.     "IFMATCH",        /* 0x32 */
  323.     "UNLESSM",        /* 0x33 */
  324.     "SUSPEND",        /* 0x34 */
  325.     "IFTHEN",        /* 0x35 */
  326.     "GROUPP",        /* 0x36 */
  327.     "LONGJMP",        /* 0x37 */
  328.     "BRANCHJ",        /* 0x38 */
  329.     "EVAL",        /* 0x39 */
  330.     "MINMOD",        /* 0x3a */
  331.     "LOGICAL",        /* 0x3b */
  332.     "RENUM",        /* 0x3c */
  333.     "OPTIMIZED",        /* 0x3d */
  334. };
  335.  
  336. static const int reg_num = 62;
  337.  
  338. #endif /* DEBUGGING */
  339. #endif /* REG_COMP_C */
  340.  
  341.