regnodes.h

   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 EOL     5       /*  0x5 Match "" at end of line. */
  12 #define MEOL    6       /*  0x6 Same, assuming multiline. */
  13 #define SEOL    7       /*  0x7 Same, assuming singleline. */
  14 #define BOUND   8       /*  0x8 Match "" at any word boundary */
  15 #define BOUNDL  9       /*  0x9 Match "" at any word boundary */
  16 #define NBOUND  10      /*  0xa Match "" at any word non-boundary */
  17 #define NBOUNDL 11      /*  0xb Match "" at any word non-boundary */
  18 #define GPOS    12      /*  0xc Matches where last m//g left off. */
  19 #define ANY     13      /*  0xd Match any one character (except newline). */
  20 #define SANY    14      /*  0xe Match any one character. */
  21 #define ANYOF   15      /*  0xf Match character in (or not in) this class. */
  22 #define ALNUM   16      /* 0x10 Match any alphanumeric character */
  23 #define ALNUML  17      /* 0x11 Match any alphanumeric char in locale */
  24 #define NALNUM  18      /* 0x12 Match any non-alphanumeric character */
  25 #define NALNUML 19      /* 0x13 Match any non-alphanumeric char in locale */
  26 #define SPACE   20      /* 0x14 Match any whitespace character */
  27 #define SPACEL  21      /* 0x15 Match any whitespace char in locale */
  28 #define NSPACE  22      /* 0x16 Match any non-whitespace character */
  29 #define NSPACEL 23      /* 0x17 Match any non-whitespace char in locale */
  30 #define DIGIT   24      /* 0x18 Match any numeric character */
  31 #define NDIGIT  25      /* 0x19 Match any non-numeric character */
  32 #define BRANCH  26      /* 0x1a Match this alternative, or the next... */
  33 #define BACK    27      /* 0x1b Match "", "next" ptr points backward. */
  34 #define EXACT   28      /* 0x1c Match this string (preceded by length). */
  35 #define EXACTF  29      /* 0x1d Match this string, folded (prec. by length). */
  36 #define EXACTFL 30      /* 0x1e Match this string, folded in locale (w/len). */
  37 #define NOTHING 31      /* 0x1f Match empty string. */
  38 #define TAIL    32      /* 0x20 Match empty string. Can jump here from outside. */
  39 #define STAR    33      /* 0x21 Match this (simple) thing 0 or more times. */
  40 #define PLUS    34      /* 0x22 Match this (simple) thing 1 or more times. */
  41 #define CURLY   35      /* 0x23 Match this simple thing {n,m} times. */
  42 #define CURLYN  36      /* 0x24 Match next-after-this simple thing  */
  43 #define CURLYM  37      /* 0x25 Match this medium-complex thing {n,m} times. */
  44 #define CURLYX  38      /* 0x26 Match this complex thing {n,m} times. */
  45 #define WHILEM  39      /* 0x27 Do curly processing and see if rest matches. */
  46 #define OPEN    40      /* 0x28 Mark this point in input as start of #n. */
  47 #define CLOSE   41      /* 0x29 Analogous to OPEN. */
  48 #define REF     42      /* 0x2a Match some already matched string */
  49 #define REFF    43      /* 0x2b Match already matched string, folded */
  50 #define REFFL   44      /* 0x2c Match already matched string, folded in loc. */
  51 #define IFMATCH 45      /* 0x2d Succeeds if the following matches. */
  52 #define UNLESSM 46      /* 0x2e Fails if the following matches. */
  53 #define SUSPEND 47      /* 0x2f "Independent" sub-RE. */
  54 #define IFTHEN  48      /* 0x30 Switch, should be preceeded by switcher . */
  55 #define GROUPP  49      /* 0x31 Whether the group matched. */
  56 #define LONGJMP 50      /* 0x32 Jump far away. */
  57 #define BRANCHJ 51      /* 0x33 BRANCH with long offset. */
  58 #define EVAL    52      /* 0x34 Execute some Perl code. */
  59 #define MINMOD  53      /* 0x35 Next operator is not greedy. */
  60 #define LOGICAL 54      /* 0x36 Next opcode should set the flag only. */
  61 #define RENUM   55      /* 0x37 Group with independently numbered parens. */
  62 #define OPTIMIZED       56      /* 0x38 Placeholder for dump. */
  63
  64 #ifndef DOINIT
  65 EXTCONST U8 regkind[];
  66 #else
  67 EXTCONST U8 regkind[] = {
  68         END,            /* END */
  69         END,            /* SUCCEED */
  70         BOL,            /* BOL */
  71         BOL,            /* MBOL */
  72         BOL,            /* SBOL */
  73         EOL,            /* EOL */
  74         EOL,            /* MEOL */
  75         EOL,            /* SEOL */
  76         BOUND,          /* BOUND */
  77         BOUND,          /* BOUNDL */
  78         NBOUND,         /* NBOUND */
  79         NBOUND,         /* NBOUNDL */
  80         GPOS,           /* GPOS */
  81         ANY,            /* ANY */
  82         ANY,            /* SANY */
  83         ANYOF,          /* ANYOF */
  84         ALNUM,          /* ALNUM */
  85         ALNUM,          /* ALNUML */
  86         NALNUM,         /* NALNUM */
  87         NALNUM,         /* NALNUML */
  88         SPACE,          /* SPACE */
  89         SPACE,          /* SPACEL */
  90         NSPACE,         /* NSPACE */
  91         NSPACE,         /* NSPACEL */
  92         DIGIT,          /* DIGIT */
  93         NDIGIT,         /* NDIGIT */
  94         BRANCH,         /* BRANCH */
  95         BACK,           /* BACK */
  96         EXACT,          /* EXACT */
  97         EXACT,          /* EXACTF */
  98         EXACT,          /* EXACTFL */
  99         NOTHING,                /* NOTHING */
 100         NOTHING,                /* TAIL */
 101         STAR,           /* STAR */
 102         PLUS,           /* PLUS */
 103         CURLY,          /* CURLY */
 104         CURLY,          /* CURLYN */
 105         CURLY,          /* CURLYM */
 106         CURLY,          /* CURLYX */
 107         WHILEM,         /* WHILEM */
 108         OPEN,           /* OPEN */
 109         CLOSE,          /* CLOSE */
 110         REF,            /* REF */
 111         REF,            /* REFF */
 112         REF,            /* REFFL */
 113         BRANCHJ,                /* IFMATCH */
 114         BRANCHJ,                /* UNLESSM */
 115         BRANCHJ,                /* SUSPEND */
 116         BRANCHJ,                /* IFTHEN */
 117         GROUPP,         /* GROUPP */
 118         LONGJMP,                /* LONGJMP */
 119         BRANCHJ,                /* BRANCHJ */
 120         EVAL,           /* EVAL */
 121         MINMOD,         /* MINMOD */
 122         LOGICAL,                /* LOGICAL */
 123         BRANCHJ,                /* RENUM */
 124         NOTHING,                /* OPTIMIZED */
 125 };
 126 #endif
 127
 128
 129 #ifdef REG_COMP_C
 130 const static U8 regarglen[] = {
 131         0,              /* END */
 132         0,              /* SUCCEED */
 133         0,              /* BOL */
 134         0,              /* MBOL */
 135         0,              /* SBOL */
 136         0,              /* EOL */
 137         0,              /* MEOL */
 138         0,              /* SEOL */
 139         0,              /* BOUND */
 140         0,              /* BOUNDL */
 141         0,              /* NBOUND */
 142         0,              /* NBOUNDL */
 143         0,              /* GPOS */
 144         0,              /* ANY */
 145         0,              /* SANY */
 146         0,              /* ANYOF */
 147         0,              /* ALNUM */
 148         0,              /* ALNUML */
 149         0,              /* NALNUM */
 150         0,              /* NALNUML */
 151         0,              /* SPACE */
 152         0,              /* SPACEL */
 153         0,              /* NSPACE */
 154         0,              /* NSPACEL */
 155         0,              /* DIGIT */
 156         0,              /* NDIGIT */
 157         0,              /* BRANCH */
 158         0,              /* BACK */
 159         0,              /* EXACT */
 160         0,              /* EXACTF */
 161         0,              /* EXACTFL */
 162         0,              /* NOTHING */
 163         0,              /* TAIL */
 164         0,              /* STAR */
 165         0,              /* PLUS */
 166         EXTRA_SIZE(struct regnode_2),           /* CURLY */
 167         EXTRA_SIZE(struct regnode_2),           /* CURLYN */
 168         EXTRA_SIZE(struct regnode_2),           /* CURLYM */
 169         EXTRA_SIZE(struct regnode_2),           /* CURLYX */
 170         0,              /* WHILEM */
 171         EXTRA_SIZE(struct regnode_1),           /* OPEN */
 172         EXTRA_SIZE(struct regnode_1),           /* CLOSE */
 173         EXTRA_SIZE(struct regnode_1),           /* REF */
 174         EXTRA_SIZE(struct regnode_1),           /* REFF */
 175         EXTRA_SIZE(struct regnode_1),           /* REFFL */
 176         EXTRA_SIZE(struct regnode_1),           /* IFMATCH */
 177         EXTRA_SIZE(struct regnode_1),           /* UNLESSM */
 178         EXTRA_SIZE(struct regnode_1),           /* SUSPEND */
 179         EXTRA_SIZE(struct regnode_1),           /* IFTHEN */
 180         EXTRA_SIZE(struct regnode_1),           /* GROUPP */
 181         EXTRA_SIZE(struct regnode_1),           /* LONGJMP */
 182         EXTRA_SIZE(struct regnode_1),           /* BRANCHJ */
 183         EXTRA_SIZE(struct regnode_1),           /* EVAL */
 184         0,              /* MINMOD */
 185         0,              /* LOGICAL */
 186         EXTRA_SIZE(struct regnode_1),           /* RENUM */
 187         0,              /* OPTIMIZED */
 188 };
 189
 190 const static char reg_off_by_arg[] = {
 191         0,              /* END */
 192         0,              /* SUCCEED */
 193         0,              /* BOL */
 194         0,              /* MBOL */
 195         0,              /* SBOL */
 196         0,              /* EOL */
 197         0,              /* MEOL */
 198         0,              /* SEOL */
 199         0,              /* BOUND */
 200         0,              /* BOUNDL */
 201         0,              /* NBOUND */
 202         0,              /* NBOUNDL */
 203         0,              /* GPOS */
 204         0,              /* ANY */
 205         0,              /* SANY */
 206         0,              /* ANYOF */
 207         0,              /* ALNUM */
 208         0,              /* ALNUML */
 209         0,              /* NALNUM */
 210         0,              /* NALNUML */
 211         0,              /* SPACE */
 212         0,              /* SPACEL */
 213         0,              /* NSPACE */
 214         0,              /* NSPACEL */
 215         0,              /* DIGIT */
 216         0,              /* NDIGIT */
 217         0,              /* BRANCH */
 218         0,              /* BACK */
 219         0,              /* EXACT */
 220         0,              /* EXACTF */
 221         0,              /* EXACTFL */
 222         0,              /* NOTHING */
 223         0,              /* TAIL */
 224         0,              /* STAR */
 225         0,              /* PLUS */
 226         0,              /* CURLY */
 227         0,              /* CURLYN */
 228         0,              /* CURLYM */
 229         0,              /* CURLYX */
 230         0,              /* WHILEM */
 231         0,              /* OPEN */
 232         0,              /* CLOSE */
 233         0,              /* REF */
 234         0,              /* REFF */
 235         0,              /* REFFL */
 236         2,              /* IFMATCH */
 237         2,              /* UNLESSM */
 238         1,              /* SUSPEND */
 239         1,              /* IFTHEN */
 240         0,              /* GROUPP */
 241         1,              /* LONGJMP */
 242         1,              /* BRANCHJ */
 243         0,              /* EVAL */
 244         0,              /* MINMOD */
 245         0,              /* LOGICAL */
 246         1,              /* RENUM */
 247         0,              /* OPTIMIZED */
 248 };
 249 #endif /* REG_COMP_C */
 250