Test for namedprotos: @_ should be a valid slurpy param
[perl.git] / regnodes.h
1 /* -*- buffer-read-only: t -*-
2    !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
3    This file is built by regen/regcomp.pl from regcomp.sym.
4    Any changes made here will be lost!
5  */
6
7 /* Regops and State definitions */
8
9 #define REGNODE_MAX             121
10 #define REGMATCH_STATE_MAX      161
11
12 #define END                     0       /* 0000 End of program. */
13 #define SUCCEED                 1       /* 0x01 Return from a subroutine, basically. */
14 #define BOL                     2       /* 0x02 Match "" at beginning of line. */
15 #define MBOL                    3       /* 0x03 Same, assuming multiline. */
16 #define SBOL                    4       /* 0x04 Same, assuming singleline. */
17 #define EOS                     5       /* 0x05 Match "" at end of string. */
18 #define EOL                     6       /* 0x06 Match "" at end of line. */
19 #define MEOL                    7       /* 0x07 Same, assuming multiline. */
20 #define SEOL                    8       /* 0x08 Same, assuming singleline. */
21 #define BOUND                   9       /* 0x09 Match "" at any word boundary using native charset semantics for non-utf8 */
22 #define BOUNDL                  10      /* 0x0a Match "" at any locale word boundary */
23 #define BOUNDU                  11      /* 0x0b Match "" at any word boundary using Unicode semantics */
24 #define BOUNDA                  12      /* 0x0c Match "" at any word boundary using ASCII semantics */
25 #define NBOUND                  13      /* 0x0d Match "" at any word non-boundary using native charset semantics for non-utf8 */
26 #define NBOUNDL                 14      /* 0x0e Match "" at any locale word non-boundary */
27 #define NBOUNDU                 15      /* 0x0f Match "" at any word non-boundary using Unicode semantics */
28 #define NBOUNDA                 16      /* 0x10 Match "" at any word non-boundary using ASCII semantics */
29 #define GPOS                    17      /* 0x11 Matches where last m//g left off. */
30 #define REG_ANY                 18      /* 0x12 Match any one character (except newline). */
31 #define SANY                    19      /* 0x13 Match any one character. */
32 #define CANY                    20      /* 0x14 Match any one byte. */
33 #define ANYOF                   21      /* 0x15 Match character in (or not in) this class, single char match only */
34 #define ALNUM                   22      /* 0x16 Match any alphanumeric character using native charset semantics for non-utf8 */
35 #define ALNUML                  23      /* 0x17 Match any alphanumeric char in locale */
36 #define ALNUMU                  24      /* 0x18 Match any alphanumeric char using Unicode semantics */
37 #define ALNUMA                  25      /* 0x19 Match [A-Za-z_0-9] */
38 #define NALNUM                  26      /* 0x1a Match any non-alphanumeric character using native charset semantics for non-utf8 */
39 #define NALNUML                 27      /* 0x1b Match any non-alphanumeric char in locale */
40 #define NALNUMU                 28      /* 0x1c Match any non-alphanumeric char using Unicode semantics */
41 #define NALNUMA                 29      /* 0x1d Match [^A-Za-z_0-9] */
42 #define SPACE                   30      /* 0x1e Match any whitespace character using native charset semantics for non-utf8 */
43 #define SPACEL                  31      /* 0x1f Match any whitespace char in locale */
44 #define SPACEU                  32      /* 0x20 Match any whitespace char using Unicode semantics */
45 #define SPACEA                  33      /* 0x21 Match [ \t\n\f\r] */
46 #define NSPACE                  34      /* 0x22 Match any non-whitespace character using native charset semantics for non-utf8 */
47 #define NSPACEL                 35      /* 0x23 Match any non-whitespace char in locale */
48 #define NSPACEU                 36      /* 0x24 Match any non-whitespace char using Unicode semantics */
49 #define NSPACEA                 37      /* 0x25 Match [^ \t\n\f\r] */
50 #define DIGIT                   38      /* 0x26 Match any numeric character using native charset semantics for non-utf8 */
51 #define DIGITL                  39      /* 0x27 Match any numeric character in locale */
52 #define PLACEHOLDER1            40      /* 0x28 placeholder for missing DIGITU */
53 #define DIGITA                  41      /* 0x29 Match [0-9] */
54 #define NDIGIT                  42      /* 0x2a Match any non-numeric character using native charset semantics for non-utf8 */
55 #define NDIGITL                 43      /* 0x2b Match any non-numeric character in locale */
56 #define PLACEHOLDER2            44      /* 0x2c placeholder for missing NDIGITU */
57 #define NDIGITA                 45      /* 0x2d Match [^0-9] */
58 #define POSIXD                  46      /* 0x2e currently unused except as a placeholder */
59 #define POSIXL                  47      /* 0x2f currently unused except as a placeholder */
60 #define POSIXU                  48      /* 0x30 currently unused except as a placeholder */
61 #define POSIXA                  49      /* 0x31 Some [[:class:]] under /a; the FLAGS field gives which one */
62 #define NPOSIXD                 50      /* 0x32 currently unused except as a placeholder */
63 #define NPOSIXL                 51      /* 0x33 currently unused except as a placeholder */
64 #define NPOSIXU                 52      /* 0x34 currently unused except as a placeholder */
65 #define NPOSIXA                 53      /* 0x35 complement of POSIXA, [[:^class:]] */
66 #define CLUMP                   54      /* 0x36 Match any extended grapheme cluster sequence */
67 #define BRANCH                  55      /* 0x37 Match this alternative, or the next... */
68 #define BACK                    56      /* 0x38 Match "", "next" ptr points backward. */
69 #define EXACT                   57      /* 0x39 Match this string (preceded by length). */
70 #define EXACTF                  58      /* 0x3a Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
71 #define EXACTFL                 59      /* 0x3b Match this string (not guaranteed to be folded) using /il rules (w/len). */
72 #define EXACTFU                 60      /* 0x3c Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */
73 #define EXACTFA                 61      /* 0x3d Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
74 #define EXACTFU_SS              62      /* 0x3e Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */
75 #define EXACTFU_TRICKYFOLD      63      /* 0x3f Match this folded UTF-8 string using /iu rules */
76 #define NOTHING                 64      /* 0x40 Match empty string. */
77 #define TAIL                    65      /* 0x41 Match empty string. Can jump here from outside. */
78 #define STAR                    66      /* 0x42 Match this (simple) thing 0 or more times. */
79 #define PLUS                    67      /* 0x43 Match this (simple) thing 1 or more times. */
80 #define CURLY                   68      /* 0x44 Match this simple thing {n,m} times. */
81 #define CURLYN                  69      /* 0x45 Capture next-after-this simple thing */
82 #define CURLYM                  70      /* 0x46 Capture this medium-complex thing {n,m} times. */
83 #define CURLYX                  71      /* 0x47 Match this complex thing {n,m} times. */
84 #define WHILEM                  72      /* 0x48 Do curly processing and see if rest matches. */
85 #define OPEN                    73      /* 0x49 Mark this point in input as start of */
86 #define CLOSE                   74      /* 0x4a Analogous to OPEN. */
87 #define REF                     75      /* 0x4b Match some already matched string */
88 #define REFF                    76      /* 0x4c Match already matched string, folded using native charset semantics for non-utf8 */
89 #define REFFL                   77      /* 0x4d Match already matched string, folded in loc. */
90 #define REFFU                   78      /* 0x4e Match already matched string, folded using unicode semantics for non-utf8 */
91 #define REFFA                   79      /* 0x4f Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
92 #define NREF                    80      /* 0x50 Match some already matched string */
93 #define NREFF                   81      /* 0x51 Match already matched string, folded using native charset semantics for non-utf8 */
94 #define NREFFL                  82      /* 0x52 Match already matched string, folded in loc. */
95 #define NREFFU                  83      /* 0x53 Match already matched string, folded using unicode semantics for non-utf8 */
96 #define NREFFA                  84      /* 0x54 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
97 #define IFMATCH                 85      /* 0x55 Succeeds if the following matches. */
98 #define UNLESSM                 86      /* 0x56 Fails if the following matches. */
99 #define SUSPEND                 87      /* 0x57 "Independent" sub-RE. */
100 #define IFTHEN                  88      /* 0x58 Switch, should be preceded by switcher . */
101 #define GROUPP                  89      /* 0x59 Whether the group matched. */
102 #define LONGJMP                 90      /* 0x5a Jump far away. */
103 #define BRANCHJ                 91      /* 0x5b BRANCH with long offset. */
104 #define EVAL                    92      /* 0x5c Execute some Perl code. */
105 #define MINMOD                  93      /* 0x5d Next operator is not greedy. */
106 #define LOGICAL                 94      /* 0x5e Next opcode should set the flag only. */
107 #define RENUM                   95      /* 0x5f Group with independently numbered parens. */
108 #define TRIE                    96      /* 0x60 Match many EXACT(F[ALU]?)? at once. flags==type */
109 #define TRIEC                   97      /* 0x61 Same as TRIE, but with embedded charclass data */
110 #define AHOCORASICK             98      /* 0x62 Aho Corasick stclass. flags==type */
111 #define AHOCORASICKC            99      /* 0x63 Same as AHOCORASICK, but with embedded charclass data */
112 #define GOSUB                   100     /* 0x64 recurse to paren arg1 at (signed) ofs arg2 */
113 #define GOSTART                 101     /* 0x65 recurse to start of pattern */
114 #define NGROUPP                 102     /* 0x66 Whether the group matched. */
115 #define INSUBP                  103     /* 0x67 Whether we are in a specific recurse. */
116 #define DEFINEP                 104     /* 0x68 Never execute directly. */
117 #define ENDLIKE                 105     /* 0x69 Used only for the type field of verbs */
118 #define OPFAIL                  106     /* 0x6a Same as (?!) */
119 #define ACCEPT                  107     /* 0x6b Accepts the current matched string. */
120 #define VERB                    108     /* 0x6c Used only for the type field of verbs */
121 #define PRUNE                   109     /* 0x6d Pattern fails at this startpoint if no-backtracking through this */
122 #define MARKPOINT               110     /* 0x6e Push the current location for rollback by cut. */
123 #define SKIP                    111     /* 0x6f On failure skip forward (to the mark) before retrying */
124 #define COMMIT                  112     /* 0x70 Pattern fails outright if backtracking through this */
125 #define CUTGROUP                113     /* 0x71 On failure go to the next alternation in the group */
126 #define KEEPS                   114     /* 0x72 $& begins here. */
127 #define LNBREAK                 115     /* 0x73 generic newline pattern */
128 #define VERTWS                  116     /* 0x74 vertical whitespace         (Perl 6) */
129 #define NVERTWS                 117     /* 0x75 not vertical whitespace     (Perl 6) */
130 #define HORIZWS                 118     /* 0x76 horizontal whitespace       (Perl 6) */
131 #define NHORIZWS                119     /* 0x77 not horizontal whitespace   (Perl 6) */
132 #define OPTIMIZED               120     /* 0x78 Placeholder for dump. */
133 #define PSEUDO                  121     /* 0x79 Pseudo opcode for internal use. */
134         /* ------------ States ------------- */
135 #define TRIE_next               (REGNODE_MAX + 1)       /* state for TRIE */
136 #define TRIE_next_fail          (REGNODE_MAX + 2)       /* state for TRIE */
137 #define EVAL_AB                 (REGNODE_MAX + 3)       /* state for EVAL */
138 #define EVAL_AB_fail            (REGNODE_MAX + 4)       /* state for EVAL */
139 #define CURLYX_end              (REGNODE_MAX + 5)       /* state for CURLYX */
140 #define CURLYX_end_fail         (REGNODE_MAX + 6)       /* state for CURLYX */
141 #define WHILEM_A_pre            (REGNODE_MAX + 7)       /* state for WHILEM */
142 #define WHILEM_A_pre_fail       (REGNODE_MAX + 8)       /* state for WHILEM */
143 #define WHILEM_A_min            (REGNODE_MAX + 9)       /* state for WHILEM */
144 #define WHILEM_A_min_fail       (REGNODE_MAX + 10)      /* state for WHILEM */
145 #define WHILEM_A_max            (REGNODE_MAX + 11)      /* state for WHILEM */
146 #define WHILEM_A_max_fail       (REGNODE_MAX + 12)      /* state for WHILEM */
147 #define WHILEM_B_min            (REGNODE_MAX + 13)      /* state for WHILEM */
148 #define WHILEM_B_min_fail       (REGNODE_MAX + 14)      /* state for WHILEM */
149 #define WHILEM_B_max            (REGNODE_MAX + 15)      /* state for WHILEM */
150 #define WHILEM_B_max_fail       (REGNODE_MAX + 16)      /* state for WHILEM */
151 #define BRANCH_next             (REGNODE_MAX + 17)      /* state for BRANCH */
152 #define BRANCH_next_fail        (REGNODE_MAX + 18)      /* state for BRANCH */
153 #define CURLYM_A                (REGNODE_MAX + 19)      /* state for CURLYM */
154 #define CURLYM_A_fail           (REGNODE_MAX + 20)      /* state for CURLYM */
155 #define CURLYM_B                (REGNODE_MAX + 21)      /* state for CURLYM */
156 #define CURLYM_B_fail           (REGNODE_MAX + 22)      /* state for CURLYM */
157 #define IFMATCH_A               (REGNODE_MAX + 23)      /* state for IFMATCH */
158 #define IFMATCH_A_fail          (REGNODE_MAX + 24)      /* state for IFMATCH */
159 #define CURLY_B_min_known       (REGNODE_MAX + 25)      /* state for CURLY */
160 #define CURLY_B_min_known_fail  (REGNODE_MAX + 26)      /* state for CURLY */
161 #define CURLY_B_min             (REGNODE_MAX + 27)      /* state for CURLY */
162 #define CURLY_B_min_fail        (REGNODE_MAX + 28)      /* state for CURLY */
163 #define CURLY_B_max             (REGNODE_MAX + 29)      /* state for CURLY */
164 #define CURLY_B_max_fail        (REGNODE_MAX + 30)      /* state for CURLY */
165 #define COMMIT_next             (REGNODE_MAX + 31)      /* state for COMMIT */
166 #define COMMIT_next_fail        (REGNODE_MAX + 32)      /* state for COMMIT */
167 #define MARKPOINT_next          (REGNODE_MAX + 33)      /* state for MARKPOINT */
168 #define MARKPOINT_next_fail     (REGNODE_MAX + 34)      /* state for MARKPOINT */
169 #define SKIP_next               (REGNODE_MAX + 35)      /* state for SKIP */
170 #define SKIP_next_fail          (REGNODE_MAX + 36)      /* state for SKIP */
171 #define CUTGROUP_next           (REGNODE_MAX + 37)      /* state for CUTGROUP */
172 #define CUTGROUP_next_fail      (REGNODE_MAX + 38)      /* state for CUTGROUP */
173 #define KEEPS_next              (REGNODE_MAX + 39)      /* state for KEEPS */
174 #define KEEPS_next_fail         (REGNODE_MAX + 40)      /* state for KEEPS */
175
176 /* PL_regkind[] What type of regop or state is this. */
177
178 #ifndef DOINIT
179 EXTCONST U8 PL_regkind[];
180 #else
181 EXTCONST U8 PL_regkind[] = {
182         END,            /* END                    */
183         END,            /* SUCCEED                */
184         BOL,            /* BOL                    */
185         BOL,            /* MBOL                   */
186         BOL,            /* SBOL                   */
187         EOL,            /* EOS                    */
188         EOL,            /* EOL                    */
189         EOL,            /* MEOL                   */
190         EOL,            /* SEOL                   */
191         BOUND,          /* BOUND                  */
192         BOUND,          /* BOUNDL                 */
193         BOUND,          /* BOUNDU                 */
194         BOUND,          /* BOUNDA                 */
195         NBOUND,         /* NBOUND                 */
196         NBOUND,         /* NBOUNDL                */
197         NBOUND,         /* NBOUNDU                */
198         NBOUND,         /* NBOUNDA                */
199         GPOS,           /* GPOS                   */
200         REG_ANY,        /* REG_ANY                */
201         REG_ANY,        /* SANY                   */
202         REG_ANY,        /* CANY                   */
203         ANYOF,          /* ANYOF                  */
204         ALNUM,          /* ALNUM                  */
205         ALNUM,          /* ALNUML                 */
206         ALNUM,          /* ALNUMU                 */
207         ALNUM,          /* ALNUMA                 */
208         NALNUM,         /* NALNUM                 */
209         NALNUM,         /* NALNUML                */
210         NALNUM,         /* NALNUMU                */
211         NALNUM,         /* NALNUMA                */
212         SPACE,          /* SPACE                  */
213         SPACE,          /* SPACEL                 */
214         SPACE,          /* SPACEU                 */
215         SPACE,          /* SPACEA                 */
216         NSPACE,         /* NSPACE                 */
217         NSPACE,         /* NSPACEL                */
218         NSPACE,         /* NSPACEU                */
219         NSPACE,         /* NSPACEA                */
220         DIGIT,          /* DIGIT                  */
221         DIGIT,          /* DIGITL                 */
222         NOTHING,        /* PLACEHOLDER1           */
223         DIGIT,          /* DIGITA                 */
224         NDIGIT,         /* NDIGIT                 */
225         NDIGIT,         /* NDIGITL                */
226         NOTHING,        /* PLACEHOLDER2           */
227         NDIGIT,         /* NDIGITA                */
228         POSIXD,         /* POSIXD                 */
229         POSIXD,         /* POSIXL                 */
230         POSIXD,         /* POSIXU                 */
231         POSIXD,         /* POSIXA                 */
232         POSIXD,         /* NPOSIXD                */
233         POSIXD,         /* NPOSIXL                */
234         POSIXD,         /* NPOSIXU                */
235         POSIXD,         /* NPOSIXA                */
236         CLUMP,          /* CLUMP                  */
237         BRANCH,         /* BRANCH                 */
238         BACK,           /* BACK                   */
239         EXACT,          /* EXACT                  */
240         EXACT,          /* EXACTF                 */
241         EXACT,          /* EXACTFL                */
242         EXACT,          /* EXACTFU                */
243         EXACT,          /* EXACTFA                */
244         EXACT,          /* EXACTFU_SS             */
245         EXACT,          /* EXACTFU_TRICKYFOLD     */
246         NOTHING,        /* NOTHING                */
247         NOTHING,        /* TAIL                   */
248         STAR,           /* STAR                   */
249         PLUS,           /* PLUS                   */
250         CURLY,          /* CURLY                  */
251         CURLY,          /* CURLYN                 */
252         CURLY,          /* CURLYM                 */
253         CURLY,          /* CURLYX                 */
254         WHILEM,         /* WHILEM                 */
255         OPEN,           /* OPEN                   */
256         CLOSE,          /* CLOSE                  */
257         REF,            /* REF                    */
258         REF,            /* REFF                   */
259         REF,            /* REFFL                  */
260         REF,            /* REFFU                  */
261         REF,            /* REFFA                  */
262         REF,            /* NREF                   */
263         REF,            /* NREFF                  */
264         REF,            /* NREFFL                 */
265         REF,            /* NREFFU                 */
266         REF,            /* NREFFA                 */
267         BRANCHJ,        /* IFMATCH                */
268         BRANCHJ,        /* UNLESSM                */
269         BRANCHJ,        /* SUSPEND                */
270         BRANCHJ,        /* IFTHEN                 */
271         GROUPP,         /* GROUPP                 */
272         LONGJMP,        /* LONGJMP                */
273         BRANCHJ,        /* BRANCHJ                */
274         EVAL,           /* EVAL                   */
275         MINMOD,         /* MINMOD                 */
276         LOGICAL,        /* LOGICAL                */
277         BRANCHJ,        /* RENUM                  */
278         TRIE,           /* TRIE                   */
279         TRIE,           /* TRIEC                  */
280         TRIE,           /* AHOCORASICK            */
281         TRIE,           /* AHOCORASICKC           */
282         GOSUB,          /* GOSUB                  */
283         GOSTART,        /* GOSTART                */
284         NGROUPP,        /* NGROUPP                */
285         INSUBP,         /* INSUBP                 */
286         DEFINEP,        /* DEFINEP                */
287         ENDLIKE,        /* ENDLIKE                */
288         ENDLIKE,        /* OPFAIL                 */
289         ENDLIKE,        /* ACCEPT                 */
290         VERB,           /* VERB                   */
291         VERB,           /* PRUNE                  */
292         VERB,           /* MARKPOINT              */
293         VERB,           /* SKIP                   */
294         VERB,           /* COMMIT                 */
295         VERB,           /* CUTGROUP               */
296         KEEPS,          /* KEEPS                  */
297         LNBREAK,        /* LNBREAK                */
298         VERTWS,         /* VERTWS                 */
299         NVERTWS,        /* NVERTWS                */
300         HORIZWS,        /* HORIZWS                */
301         NHORIZWS,       /* NHORIZWS               */
302         NOTHING,        /* OPTIMIZED              */
303         PSEUDO,         /* PSEUDO                 */
304         /* ------------ States ------------- */
305         TRIE,           /* TRIE_next              */
306         TRIE,           /* TRIE_next_fail         */
307         EVAL,           /* EVAL_AB                */
308         EVAL,           /* EVAL_AB_fail           */
309         CURLYX,         /* CURLYX_end             */
310         CURLYX,         /* CURLYX_end_fail        */
311         WHILEM,         /* WHILEM_A_pre           */
312         WHILEM,         /* WHILEM_A_pre_fail      */
313         WHILEM,         /* WHILEM_A_min           */
314         WHILEM,         /* WHILEM_A_min_fail      */
315         WHILEM,         /* WHILEM_A_max           */
316         WHILEM,         /* WHILEM_A_max_fail      */
317         WHILEM,         /* WHILEM_B_min           */
318         WHILEM,         /* WHILEM_B_min_fail      */
319         WHILEM,         /* WHILEM_B_max           */
320         WHILEM,         /* WHILEM_B_max_fail      */
321         BRANCH,         /* BRANCH_next            */
322         BRANCH,         /* BRANCH_next_fail       */
323         CURLYM,         /* CURLYM_A               */
324         CURLYM,         /* CURLYM_A_fail          */
325         CURLYM,         /* CURLYM_B               */
326         CURLYM,         /* CURLYM_B_fail          */
327         IFMATCH,        /* IFMATCH_A              */
328         IFMATCH,        /* IFMATCH_A_fail         */
329         CURLY,          /* CURLY_B_min_known      */
330         CURLY,          /* CURLY_B_min_known_fail */
331         CURLY,          /* CURLY_B_min            */
332         CURLY,          /* CURLY_B_min_fail       */
333         CURLY,          /* CURLY_B_max            */
334         CURLY,          /* CURLY_B_max_fail       */
335         COMMIT,         /* COMMIT_next            */
336         COMMIT,         /* COMMIT_next_fail       */
337         MARKPOINT,      /* MARKPOINT_next         */
338         MARKPOINT,      /* MARKPOINT_next_fail    */
339         SKIP,           /* SKIP_next              */
340         SKIP,           /* SKIP_next_fail         */
341         CUTGROUP,       /* CUTGROUP_next          */
342         CUTGROUP,       /* CUTGROUP_next_fail     */
343         KEEPS,          /* KEEPS_next             */
344         KEEPS,          /* KEEPS_next_fail        */
345 };
346 #endif
347
348 /* regarglen[] - How large is the argument part of the node (in regnodes) */
349
350 #ifdef REG_COMP_C
351 static const U8 regarglen[] = {
352         0,                                      /* END          */
353         0,                                      /* SUCCEED      */
354         0,                                      /* BOL          */
355         0,                                      /* MBOL         */
356         0,                                      /* SBOL         */
357         0,                                      /* EOS          */
358         0,                                      /* EOL          */
359         0,                                      /* MEOL         */
360         0,                                      /* SEOL         */
361         0,                                      /* BOUND        */
362         0,                                      /* BOUNDL       */
363         0,                                      /* BOUNDU       */
364         0,                                      /* BOUNDA       */
365         0,                                      /* NBOUND       */
366         0,                                      /* NBOUNDL      */
367         0,                                      /* NBOUNDU      */
368         0,                                      /* NBOUNDA      */
369         0,                                      /* GPOS         */
370         0,                                      /* REG_ANY      */
371         0,                                      /* SANY         */
372         0,                                      /* CANY         */
373         0,                                      /* ANYOF        */
374         0,                                      /* ALNUM        */
375         0,                                      /* ALNUML       */
376         0,                                      /* ALNUMU       */
377         0,                                      /* ALNUMA       */
378         0,                                      /* NALNUM       */
379         0,                                      /* NALNUML      */
380         0,                                      /* NALNUMU      */
381         0,                                      /* NALNUMA      */
382         0,                                      /* SPACE        */
383         0,                                      /* SPACEL       */
384         0,                                      /* SPACEU       */
385         0,                                      /* SPACEA       */
386         0,                                      /* NSPACE       */
387         0,                                      /* NSPACEL      */
388         0,                                      /* NSPACEU      */
389         0,                                      /* NSPACEA      */
390         0,                                      /* DIGIT        */
391         0,                                      /* DIGITL       */
392         0,                                      /* PLACEHOLDER1 */
393         0,                                      /* DIGITA       */
394         0,                                      /* NDIGIT       */
395         0,                                      /* NDIGITL      */
396         0,                                      /* PLACEHOLDER2 */
397         0,                                      /* NDIGITA      */
398         0,                                      /* POSIXD       */
399         0,                                      /* POSIXL       */
400         0,                                      /* POSIXU       */
401         0,                                      /* POSIXA       */
402         0,                                      /* NPOSIXD      */
403         0,                                      /* NPOSIXL      */
404         0,                                      /* NPOSIXU      */
405         0,                                      /* NPOSIXA      */
406         0,                                      /* CLUMP        */
407         0,                                      /* BRANCH       */
408         0,                                      /* BACK         */
409         0,                                      /* EXACT        */
410         0,                                      /* EXACTF       */
411         0,                                      /* EXACTFL      */
412         0,                                      /* EXACTFU      */
413         0,                                      /* EXACTFA      */
414         0,                                      /* EXACTFU_SS   */
415         0,                                      /* EXACTFU_TRICKYFOLD */
416         0,                                      /* NOTHING      */
417         0,                                      /* TAIL         */
418         0,                                      /* STAR         */
419         0,                                      /* PLUS         */
420         EXTRA_SIZE(struct regnode_2),           /* CURLY        */
421         EXTRA_SIZE(struct regnode_2),           /* CURLYN       */
422         EXTRA_SIZE(struct regnode_2),           /* CURLYM       */
423         EXTRA_SIZE(struct regnode_2),           /* CURLYX       */
424         0,                                      /* WHILEM       */
425         EXTRA_SIZE(struct regnode_1),           /* OPEN         */
426         EXTRA_SIZE(struct regnode_1),           /* CLOSE        */
427         EXTRA_SIZE(struct regnode_1),           /* REF          */
428         EXTRA_SIZE(struct regnode_1),           /* REFF         */
429         EXTRA_SIZE(struct regnode_1),           /* REFFL        */
430         EXTRA_SIZE(struct regnode_1),           /* REFFU        */
431         EXTRA_SIZE(struct regnode_1),           /* REFFA        */
432         EXTRA_SIZE(struct regnode_1),           /* NREF         */
433         EXTRA_SIZE(struct regnode_1),           /* NREFF        */
434         EXTRA_SIZE(struct regnode_1),           /* NREFFL       */
435         EXTRA_SIZE(struct regnode_1),           /* NREFFU       */
436         EXTRA_SIZE(struct regnode_1),           /* NREFFA       */
437         EXTRA_SIZE(struct regnode_1),           /* IFMATCH      */
438         EXTRA_SIZE(struct regnode_1),           /* UNLESSM      */
439         EXTRA_SIZE(struct regnode_1),           /* SUSPEND      */
440         EXTRA_SIZE(struct regnode_1),           /* IFTHEN       */
441         EXTRA_SIZE(struct regnode_1),           /* GROUPP       */
442         EXTRA_SIZE(struct regnode_1),           /* LONGJMP      */
443         EXTRA_SIZE(struct regnode_1),           /* BRANCHJ      */
444         EXTRA_SIZE(struct regnode_1),           /* EVAL         */
445         0,                                      /* MINMOD       */
446         0,                                      /* LOGICAL      */
447         EXTRA_SIZE(struct regnode_1),           /* RENUM        */
448         EXTRA_SIZE(struct regnode_1),           /* TRIE         */
449         EXTRA_SIZE(struct regnode_charclass),   /* TRIEC        */
450         EXTRA_SIZE(struct regnode_1),           /* AHOCORASICK  */
451         EXTRA_SIZE(struct regnode_charclass),   /* AHOCORASICKC */
452         EXTRA_SIZE(struct regnode_2L),          /* GOSUB        */
453         0,                                      /* GOSTART      */
454         EXTRA_SIZE(struct regnode_1),           /* NGROUPP      */
455         EXTRA_SIZE(struct regnode_1),           /* INSUBP       */
456         EXTRA_SIZE(struct regnode_1),           /* DEFINEP      */
457         0,                                      /* ENDLIKE      */
458         0,                                      /* OPFAIL       */
459         EXTRA_SIZE(struct regnode_1),           /* ACCEPT       */
460         EXTRA_SIZE(struct regnode_1),           /* VERB         */
461         EXTRA_SIZE(struct regnode_1),           /* PRUNE        */
462         EXTRA_SIZE(struct regnode_1),           /* MARKPOINT    */
463         EXTRA_SIZE(struct regnode_1),           /* SKIP         */
464         EXTRA_SIZE(struct regnode_1),           /* COMMIT       */
465         EXTRA_SIZE(struct regnode_1),           /* CUTGROUP     */
466         0,                                      /* KEEPS        */
467         0,                                      /* LNBREAK      */
468         0,                                      /* VERTWS       */
469         0,                                      /* NVERTWS      */
470         0,                                      /* HORIZWS      */
471         0,                                      /* NHORIZWS     */
472         0,                                      /* OPTIMIZED    */
473         0,                                      /* PSEUDO       */
474 };
475
476 /* reg_off_by_arg[] - Which argument holds the offset to the next node */
477
478 static const char reg_off_by_arg[] = {
479         0,      /* END          */
480         0,      /* SUCCEED      */
481         0,      /* BOL          */
482         0,      /* MBOL         */
483         0,      /* SBOL         */
484         0,      /* EOS          */
485         0,      /* EOL          */
486         0,      /* MEOL         */
487         0,      /* SEOL         */
488         0,      /* BOUND        */
489         0,      /* BOUNDL       */
490         0,      /* BOUNDU       */
491         0,      /* BOUNDA       */
492         0,      /* NBOUND       */
493         0,      /* NBOUNDL      */
494         0,      /* NBOUNDU      */
495         0,      /* NBOUNDA      */
496         0,      /* GPOS         */
497         0,      /* REG_ANY      */
498         0,      /* SANY         */
499         0,      /* CANY         */
500         0,      /* ANYOF        */
501         0,      /* ALNUM        */
502         0,      /* ALNUML       */
503         0,      /* ALNUMU       */
504         0,      /* ALNUMA       */
505         0,      /* NALNUM       */
506         0,      /* NALNUML      */
507         0,      /* NALNUMU      */
508         0,      /* NALNUMA      */
509         0,      /* SPACE        */
510         0,      /* SPACEL       */
511         0,      /* SPACEU       */
512         0,      /* SPACEA       */
513         0,      /* NSPACE       */
514         0,      /* NSPACEL      */
515         0,      /* NSPACEU      */
516         0,      /* NSPACEA      */
517         0,      /* DIGIT        */
518         0,      /* DIGITL       */
519         0,      /* PLACEHOLDER1 */
520         0,      /* DIGITA       */
521         0,      /* NDIGIT       */
522         0,      /* NDIGITL      */
523         0,      /* PLACEHOLDER2 */
524         0,      /* NDIGITA      */
525         0,      /* POSIXD       */
526         0,      /* POSIXL       */
527         0,      /* POSIXU       */
528         0,      /* POSIXA       */
529         0,      /* NPOSIXD      */
530         0,      /* NPOSIXL      */
531         0,      /* NPOSIXU      */
532         0,      /* NPOSIXA      */
533         0,      /* CLUMP        */
534         0,      /* BRANCH       */
535         0,      /* BACK         */
536         0,      /* EXACT        */
537         0,      /* EXACTF       */
538         0,      /* EXACTFL      */
539         0,      /* EXACTFU      */
540         0,      /* EXACTFA      */
541         0,      /* EXACTFU_SS   */
542         0,      /* EXACTFU_TRICKYFOLD */
543         0,      /* NOTHING      */
544         0,      /* TAIL         */
545         0,      /* STAR         */
546         0,      /* PLUS         */
547         0,      /* CURLY        */
548         0,      /* CURLYN       */
549         0,      /* CURLYM       */
550         0,      /* CURLYX       */
551         0,      /* WHILEM       */
552         0,      /* OPEN         */
553         0,      /* CLOSE        */
554         0,      /* REF          */
555         0,      /* REFF         */
556         0,      /* REFFL        */
557         0,      /* REFFU        */
558         0,      /* REFFA        */
559         0,      /* NREF         */
560         0,      /* NREFF        */
561         0,      /* NREFFL       */
562         0,      /* NREFFU       */
563         0,      /* NREFFA       */
564         2,      /* IFMATCH      */
565         2,      /* UNLESSM      */
566         1,      /* SUSPEND      */
567         1,      /* IFTHEN       */
568         0,      /* GROUPP       */
569         1,      /* LONGJMP      */
570         1,      /* BRANCHJ      */
571         0,      /* EVAL         */
572         0,      /* MINMOD       */
573         0,      /* LOGICAL      */
574         1,      /* RENUM        */
575         0,      /* TRIE         */
576         0,      /* TRIEC        */
577         0,      /* AHOCORASICK  */
578         0,      /* AHOCORASICKC */
579         0,      /* GOSUB        */
580         0,      /* GOSTART      */
581         0,      /* NGROUPP      */
582         0,      /* INSUBP       */
583         0,      /* DEFINEP      */
584         0,      /* ENDLIKE      */
585         0,      /* OPFAIL       */
586         0,      /* ACCEPT       */
587         0,      /* VERB         */
588         0,      /* PRUNE        */
589         0,      /* MARKPOINT    */
590         0,      /* SKIP         */
591         0,      /* COMMIT       */
592         0,      /* CUTGROUP     */
593         0,      /* KEEPS        */
594         0,      /* LNBREAK      */
595         0,      /* VERTWS       */
596         0,      /* NVERTWS      */
597         0,      /* HORIZWS      */
598         0,      /* NHORIZWS     */
599         0,      /* OPTIMIZED    */
600         0,      /* PSEUDO       */
601 };
602
603 #endif /* REG_COMP_C */
604
605 /* reg_name[] - Opcode/state names in string form, for debugging */
606
607 #ifndef DOINIT
608 EXTCONST char * PL_reg_name[];
609 #else
610 EXTCONST char * const PL_reg_name[] = {
611         "END",                          /* 0000 */
612         "SUCCEED",                      /* 0x01 */
613         "BOL",                          /* 0x02 */
614         "MBOL",                         /* 0x03 */
615         "SBOL",                         /* 0x04 */
616         "EOS",                          /* 0x05 */
617         "EOL",                          /* 0x06 */
618         "MEOL",                         /* 0x07 */
619         "SEOL",                         /* 0x08 */
620         "BOUND",                        /* 0x09 */
621         "BOUNDL",                       /* 0x0a */
622         "BOUNDU",                       /* 0x0b */
623         "BOUNDA",                       /* 0x0c */
624         "NBOUND",                       /* 0x0d */
625         "NBOUNDL",                      /* 0x0e */
626         "NBOUNDU",                      /* 0x0f */
627         "NBOUNDA",                      /* 0x10 */
628         "GPOS",                         /* 0x11 */
629         "REG_ANY",                      /* 0x12 */
630         "SANY",                         /* 0x13 */
631         "CANY",                         /* 0x14 */
632         "ANYOF",                        /* 0x15 */
633         "ALNUM",                        /* 0x16 */
634         "ALNUML",                       /* 0x17 */
635         "ALNUMU",                       /* 0x18 */
636         "ALNUMA",                       /* 0x19 */
637         "NALNUM",                       /* 0x1a */
638         "NALNUML",                      /* 0x1b */
639         "NALNUMU",                      /* 0x1c */
640         "NALNUMA",                      /* 0x1d */
641         "SPACE",                        /* 0x1e */
642         "SPACEL",                       /* 0x1f */
643         "SPACEU",                       /* 0x20 */
644         "SPACEA",                       /* 0x21 */
645         "NSPACE",                       /* 0x22 */
646         "NSPACEL",                      /* 0x23 */
647         "NSPACEU",                      /* 0x24 */
648         "NSPACEA",                      /* 0x25 */
649         "DIGIT",                        /* 0x26 */
650         "DIGITL",                       /* 0x27 */
651         "PLACEHOLDER1",                 /* 0x28 */
652         "DIGITA",                       /* 0x29 */
653         "NDIGIT",                       /* 0x2a */
654         "NDIGITL",                      /* 0x2b */
655         "PLACEHOLDER2",                 /* 0x2c */
656         "NDIGITA",                      /* 0x2d */
657         "POSIXD",                       /* 0x2e */
658         "POSIXL",                       /* 0x2f */
659         "POSIXU",                       /* 0x30 */
660         "POSIXA",                       /* 0x31 */
661         "NPOSIXD",                      /* 0x32 */
662         "NPOSIXL",                      /* 0x33 */
663         "NPOSIXU",                      /* 0x34 */
664         "NPOSIXA",                      /* 0x35 */
665         "CLUMP",                        /* 0x36 */
666         "BRANCH",                       /* 0x37 */
667         "BACK",                         /* 0x38 */
668         "EXACT",                        /* 0x39 */
669         "EXACTF",                       /* 0x3a */
670         "EXACTFL",                      /* 0x3b */
671         "EXACTFU",                      /* 0x3c */
672         "EXACTFA",                      /* 0x3d */
673         "EXACTFU_SS",                   /* 0x3e */
674         "EXACTFU_TRICKYFOLD",           /* 0x3f */
675         "NOTHING",                      /* 0x40 */
676         "TAIL",                         /* 0x41 */
677         "STAR",                         /* 0x42 */
678         "PLUS",                         /* 0x43 */
679         "CURLY",                        /* 0x44 */
680         "CURLYN",                       /* 0x45 */
681         "CURLYM",                       /* 0x46 */
682         "CURLYX",                       /* 0x47 */
683         "WHILEM",                       /* 0x48 */
684         "OPEN",                         /* 0x49 */
685         "CLOSE",                        /* 0x4a */
686         "REF",                          /* 0x4b */
687         "REFF",                         /* 0x4c */
688         "REFFL",                        /* 0x4d */
689         "REFFU",                        /* 0x4e */
690         "REFFA",                        /* 0x4f */
691         "NREF",                         /* 0x50 */
692         "NREFF",                        /* 0x51 */
693         "NREFFL",                       /* 0x52 */
694         "NREFFU",                       /* 0x53 */
695         "NREFFA",                       /* 0x54 */
696         "IFMATCH",                      /* 0x55 */
697         "UNLESSM",                      /* 0x56 */
698         "SUSPEND",                      /* 0x57 */
699         "IFTHEN",                       /* 0x58 */
700         "GROUPP",                       /* 0x59 */
701         "LONGJMP",                      /* 0x5a */
702         "BRANCHJ",                      /* 0x5b */
703         "EVAL",                         /* 0x5c */
704         "MINMOD",                       /* 0x5d */
705         "LOGICAL",                      /* 0x5e */
706         "RENUM",                        /* 0x5f */
707         "TRIE",                         /* 0x60 */
708         "TRIEC",                        /* 0x61 */
709         "AHOCORASICK",                  /* 0x62 */
710         "AHOCORASICKC",                 /* 0x63 */
711         "GOSUB",                        /* 0x64 */
712         "GOSTART",                      /* 0x65 */
713         "NGROUPP",                      /* 0x66 */
714         "INSUBP",                       /* 0x67 */
715         "DEFINEP",                      /* 0x68 */
716         "ENDLIKE",                      /* 0x69 */
717         "OPFAIL",                       /* 0x6a */
718         "ACCEPT",                       /* 0x6b */
719         "VERB",                         /* 0x6c */
720         "PRUNE",                        /* 0x6d */
721         "MARKPOINT",                    /* 0x6e */
722         "SKIP",                         /* 0x6f */
723         "COMMIT",                       /* 0x70 */
724         "CUTGROUP",                     /* 0x71 */
725         "KEEPS",                        /* 0x72 */
726         "LNBREAK",                      /* 0x73 */
727         "VERTWS",                       /* 0x74 */
728         "NVERTWS",                      /* 0x75 */
729         "HORIZWS",                      /* 0x76 */
730         "NHORIZWS",                     /* 0x77 */
731         "OPTIMIZED",                    /* 0x78 */
732         "PSEUDO",                       /* 0x79 */
733         /* ------------ States ------------- */
734         "TRIE_next",                    /* REGNODE_MAX +0x01 */
735         "TRIE_next_fail",               /* REGNODE_MAX +0x02 */
736         "EVAL_AB",                      /* REGNODE_MAX +0x03 */
737         "EVAL_AB_fail",                 /* REGNODE_MAX +0x04 */
738         "CURLYX_end",                   /* REGNODE_MAX +0x05 */
739         "CURLYX_end_fail",              /* REGNODE_MAX +0x06 */
740         "WHILEM_A_pre",                 /* REGNODE_MAX +0x07 */
741         "WHILEM_A_pre_fail",            /* REGNODE_MAX +0x08 */
742         "WHILEM_A_min",                 /* REGNODE_MAX +0x09 */
743         "WHILEM_A_min_fail",            /* REGNODE_MAX +0x0a */
744         "WHILEM_A_max",                 /* REGNODE_MAX +0x0b */
745         "WHILEM_A_max_fail",            /* REGNODE_MAX +0x0c */
746         "WHILEM_B_min",                 /* REGNODE_MAX +0x0d */
747         "WHILEM_B_min_fail",            /* REGNODE_MAX +0x0e */
748         "WHILEM_B_max",                 /* REGNODE_MAX +0x0f */
749         "WHILEM_B_max_fail",            /* REGNODE_MAX +0x10 */
750         "BRANCH_next",                  /* REGNODE_MAX +0x11 */
751         "BRANCH_next_fail",             /* REGNODE_MAX +0x12 */
752         "CURLYM_A",                     /* REGNODE_MAX +0x13 */
753         "CURLYM_A_fail",                /* REGNODE_MAX +0x14 */
754         "CURLYM_B",                     /* REGNODE_MAX +0x15 */
755         "CURLYM_B_fail",                /* REGNODE_MAX +0x16 */
756         "IFMATCH_A",                    /* REGNODE_MAX +0x17 */
757         "IFMATCH_A_fail",               /* REGNODE_MAX +0x18 */
758         "CURLY_B_min_known",            /* REGNODE_MAX +0x19 */
759         "CURLY_B_min_known_fail",       /* REGNODE_MAX +0x1a */
760         "CURLY_B_min",                  /* REGNODE_MAX +0x1b */
761         "CURLY_B_min_fail",             /* REGNODE_MAX +0x1c */
762         "CURLY_B_max",                  /* REGNODE_MAX +0x1d */
763         "CURLY_B_max_fail",             /* REGNODE_MAX +0x1e */
764         "COMMIT_next",                  /* REGNODE_MAX +0x1f */
765         "COMMIT_next_fail",             /* REGNODE_MAX +0x20 */
766         "MARKPOINT_next",               /* REGNODE_MAX +0x21 */
767         "MARKPOINT_next_fail",          /* REGNODE_MAX +0x22 */
768         "SKIP_next",                    /* REGNODE_MAX +0x23 */
769         "SKIP_next_fail",               /* REGNODE_MAX +0x24 */
770         "CUTGROUP_next",                /* REGNODE_MAX +0x25 */
771         "CUTGROUP_next_fail",           /* REGNODE_MAX +0x26 */
772         "KEEPS_next",                   /* REGNODE_MAX +0x27 */
773         "KEEPS_next_fail",              /* REGNODE_MAX +0x28 */
774 };
775 #endif /* DOINIT */
776
777 /* PL_reg_extflags_name[] - Opcode/state names in string form, for debugging */
778
779 #ifndef DOINIT
780 EXTCONST char * PL_reg_extflags_name[];
781 #else
782 EXTCONST char * const PL_reg_extflags_name[] = {
783         /* Bits in extflags defined: 11011111111111111111111011111111 */
784         "MULTILINE",        /* 0x00000001 */
785         "SINGLELINE",       /* 0x00000002 */
786         "FOLD",             /* 0x00000004 */
787         "EXTENDED",         /* 0x00000008 */
788         "KEEPCOPY",         /* 0x00000010 */
789         "CHARSET",          /* 0x000000e0 */
790         "CHARSET",          /* 0x000000e0 */
791         "CHARSET",          /* 0x000000e0 */
792         "UNUSED_BIT_8",     /* 0x00000100 */
793         "ANCH_BOL",         /* 0x00000200 */
794         "ANCH_MBOL",        /* 0x00000400 */
795         "ANCH_SBOL",        /* 0x00000800 */
796         "ANCH_GPOS",        /* 0x00001000 */
797         "GPOS_SEEN",        /* 0x00002000 */
798         "GPOS_FLOAT",       /* 0x00004000 */
799         "LOOKBEHIND_SEEN",  /* 0x00008000 */
800         "EVAL_SEEN",        /* 0x00010000 */
801         "CANY_SEEN",        /* 0x00020000 */
802         "NOSCAN",           /* 0x00040000 */
803         "CHECK_ALL",        /* 0x00080000 */
804         "MATCH_UTF8",       /* 0x00100000 */
805         "USE_INTUIT_NOML",  /* 0x00200000 */
806         "USE_INTUIT_ML",    /* 0x00400000 */
807         "INTUIT_TAIL",      /* 0x00800000 */
808         "MODIFIES_VARS",    /* 0x01000000 */
809         "COPY_DONE",        /* 0x02000000 */
810         "TAINTED_SEEN",     /* 0x04000000 */
811         "TAINTED",          /* 0x08000000 */
812         "START_ONLY",       /* 0x10000000 */
813         "UNUSED_BIT_29",    /* 0x20000000 */
814         "WHITE",            /* 0x40000000 */
815         "NULL",             /* 0x80000000 */
816 };
817 #endif /* DOINIT */
818
819 /* The following have no fixed length. U8 so we can do strchr() on it. */
820 #define REGNODE_VARIES(node) (PL_varies_bitmask[(node) >> 3] & (1 << ((node) & 7)))
821
822 #ifndef DOINIT
823 EXTCONST U8 PL_varies[] __attribute__deprecated__;
824 #else
825 EXTCONST U8 PL_varies[] __attribute__deprecated__ = {
826     CLUMP, BRANCH, BACK, STAR, PLUS, CURLY, CURLYN, CURLYM, CURLYX, WHILEM,
827     REF, REFF, REFFL, REFFU, REFFA, NREF, NREFF, NREFFL, NREFFU, NREFFA,
828     SUSPEND, IFTHEN, BRANCHJ,
829     0
830 };
831 #endif /* DOINIT */
832
833 #ifndef DOINIT
834 EXTCONST U8 PL_varies_bitmask[];
835 #else
836 EXTCONST U8 PL_varies_bitmask[] = {
837     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x01, 0xFC, 0xF9, 0x9F, 0x09, 0x00, 0x00, 0x00, 0x00
838 };
839 #endif /* DOINIT */
840
841 /* The following always have a length of 1. U8 we can do strchr() on it. */
842 /* (Note that length 1 means "one character" under UTF8, not "one octet".) */
843 #define REGNODE_SIMPLE(node) (PL_simple_bitmask[(node) >> 3] & (1 << ((node) & 7)))
844
845 #ifndef DOINIT
846 EXTCONST U8 PL_simple[] __attribute__deprecated__;
847 #else
848 EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
849     REG_ANY, SANY, CANY, ANYOF, ALNUM, ALNUML, ALNUMU, ALNUMA, NALNUM,
850     NALNUML, NALNUMU, NALNUMA, SPACE, SPACEL, SPACEU, SPACEA, NSPACE,
851     NSPACEL, NSPACEU, NSPACEA, DIGIT, DIGITL, DIGITA, NDIGIT, NDIGITL,
852     NDIGITA, POSIXD, POSIXL, POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU,
853     NPOSIXA, VERTWS, NVERTWS, HORIZWS, NHORIZWS,
854     0
855 };
856 #endif /* DOINIT */
857
858 #ifndef DOINIT
859 EXTCONST U8 PL_simple_bitmask[];
860 #else
861 EXTCONST U8 PL_simple_bitmask[] = {
862     0x00, 0x00, 0xFC, 0xFF, 0xFF, 0xEE, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00
863 };
864 #endif /* DOINIT */
865
866 /* ex: set ro: */