5 * "A fair jaw-cracker dwarf-language must be." --Samwise Gamgee
8 /* NOTE: this is derived from Henry Spencer's regexp code, and should not
9 * confused with the original package (see point 3 below). Thanks, Henry!
12 /* Additional note: this code is very heavily munged from Henry's version
13 * in places. In some spots I've traded clarity for efficiency, so don't
14 * blame Henry for some of the lack of readability.
17 /* The names of the functions have been changed from regcomp and
18 * regexec to pregcomp and pregexec in order to avoid conflicts
19 * with the POSIX routines of the same names.
24 * pregcomp and pregexec -- regsub and regerror are not used in perl
26 * Copyright (c) 1986 by University of Toronto.
27 * Written by Henry Spencer. Not derived from licensed software.
29 * Permission is granted to anyone to use this software for any
30 * purpose on any computer system, and to redistribute it freely,
31 * subject to the following restrictions:
33 * 1. The author is not responsible for the consequences of use of
34 * this software, no matter how awful, even if they arise
37 * 2. The origin of this software must not be misrepresented, either
38 * by explicit claim or by omission.
40 * 3. Altered versions must be plainly marked as such, and must not
41 * be misrepresented as being the original software.
44 **** Alterations to Henry's code are...
46 **** Copyright (c) 1991-1994, Larry Wall
48 **** You may distribute under the terms of either the GNU General Public
49 **** License or the Artistic License, as specified in the README file.
52 * Beware that some of this code is subtly aware of the way operator
53 * precedence is structured in regular expressions. Serious changes in
54 * regular-expression syntax might require a total rethink.
63 #endif /* USE_THREADS */
66 # if defined(BUGGY_MSC6)
67 /* MSC 6.00A breaks on op/regexp.t test 85 unless we turn this off */
68 # pragma optimize("a",off)
69 /* But MSC 6.00A is happy with 'w', for aliases only across function calls*/
70 # pragma optimize("w",on )
71 # endif /* BUGGY_MSC6 */
78 #define ISMULT1(c) ((c) == '*' || (c) == '+' || (c) == '?')
79 #define ISMULT2(s) ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
80 ((*s) == '{' && regcurly(s)))
82 #define PERL_META "^$.[()|?+*\\"
84 #define META "^$.[()|?+*\\"
88 #undef SPSTART /* dratted cpp namespace... */
91 * Flags to be passed up and down.
93 #define WORST 0 /* Worst case. */
94 #define HASWIDTH 0x1 /* Known never to match null string. */
95 #define SIMPLE 0x2 /* Simple enough to be STAR/PLUS operand. */
96 #define SPSTART 0x4 /* Starts with * or +. */
97 #define TRYAGAIN 0x8 /* Weeded out a declaration. */
100 * Forward declarations for pregcomp()'s friends.
103 static char *reg _((I32, I32 *));
104 static char *reganode _((char, unsigned short));
105 static char *regatom _((I32 *));
106 static char *regbranch _((I32 *));
107 static void regc _((char));
108 static char *regclass _((void));
109 STATIC I32 regcurly _((char *));
110 static char *regnode _((char));
111 static char *regpiece _((I32 *));
112 static void reginsert _((char, char *));
113 static void regoptail _((char *, char *));
114 static void regset _((char *, I32, I32));
115 static void regtail _((char *, char *));
116 static char* nextchar _((void));
119 - pregcomp - compile a regular expression into internal code
121 * We can't allocate space until we know how big the compiled form will be,
122 * but we can't compile it (and thus know how big it is) until we've got a
123 * place to put the code. So we cheat: we compile it twice, once with code
124 * generation turned off and size counting turned on, and once "for real".
125 * This also means that we don't allocate space until we are sure that the
126 * thing really will compile successfully, and we never have to move the
127 * code and thus invalidate pointers into it. (Note that it has to be in
128 * one piece because free() must be able to free it all.) [NB: not true in perl]
130 * Beware that the optimization-preparation code in here knows about some
131 * of the structure of the compiled regexp. [I'll say.]
134 pregcomp(exp,xend,pm)
139 I32 fold = pm->op_pmflags & PMf_FOLD;
142 register SV *longish;
145 register char *first;
155 croak("NULL regexp argument");
157 /* First pass: determine size, legality. */
158 regflags = pm->op_pmflags;
161 regprecomp = savepvn(exp,xend-exp);
168 if (reg(0, &flags) == NULL) {
169 Safefree(regprecomp);
174 /* Small enough for pointer-storage convention? */
175 if (regsize >= 32767L) /* Probably could be 65535L. */
176 FAIL("regexp too big");
178 /* Allocate space. */
179 Newc(1001, r, sizeof(regexp) + (unsigned)regsize, char, regexp);
181 FAIL("regexp out of space");
183 /* Second pass: emit code. */
184 r->prelen = xend-exp;
185 r->precomp = regprecomp;
186 r->subbeg = r->subbase = NULL;
190 regcode = r->program;
192 if (reg(0, &flags) == NULL)
195 /* Dig out information for optimizations. */
196 pm->op_pmflags = regflags;
197 fold = pm->op_pmflags & PMf_FOLD;
198 r->regstart = Nullsv; /* Worst-case defaults. */
202 r->regstclass = Nullch;
203 r->naughty = regnaughty >= 10; /* Probably an expensive pattern. */
204 scan = r->program+1; /* First BRANCH. */
205 if (OP(regnext(scan)) == END) {/* Only one top-level choice. */
206 scan = NEXTOPER(scan);
209 while ((OP(first) == OPEN && (sawopen = 1)) ||
210 (OP(first) == BRANCH && OP(regnext(first)) != BRANCH) ||
211 (OP(first) == PLUS) ||
212 (OP(first) == MINMOD) ||
213 (regkind[(U8)OP(first)] == CURLY && ARG1(first) > 0) ) {
214 if (OP(first) == PLUS)
217 first += regarglen[(U8)OP(first)];
218 first = NEXTOPER(first);
221 /* Starting-point info. */
223 if (OP(first) == EXACTLY) {
224 r->regstart = newSVpv(OPERAND(first)+1,*OPERAND(first));
225 if (SvCUR(r->regstart) > !(sawstudy|fold))
226 fbm_compile(r->regstart,fold);
228 sv_upgrade(r->regstart, SVt_PVBM);
230 else if (strchr(simple+2,OP(first)))
231 r->regstclass = first;
232 else if (OP(first) == BOUND || OP(first) == NBOUND)
233 r->regstclass = first;
234 else if (regkind[(U8)OP(first)] == BOL) {
235 r->reganch = ROPT_ANCH;
236 first = NEXTOPER(first);
239 else if ((OP(first) == STAR &&
240 regkind[(U8)OP(NEXTOPER(first))] == ANY) &&
241 !(r->reganch & ROPT_ANCH) )
243 /* turn .* into ^.* with an implied $*=1 */
244 r->reganch = ROPT_ANCH | ROPT_IMPLICIT;
245 first = NEXTOPER(first);
248 if (sawplus && (!sawopen || !regsawback))
249 r->reganch |= ROPT_SKIP; /* x+ must match 1st of run */
251 DEBUG_r(fprintf(stderr,"first %d next %d offset %d\n",
252 OP(first), OP(NEXTOPER(first)), first - scan));
254 * If there's something expensive in the r.e., find the
255 * longest literal string that must appear and make it the
256 * regmust. Resolve ties in favor of later strings, since
257 * the regstart check works with the beginning of the r.e.
258 * and avoiding duplication strengthens checking. Not a
259 * strong reason, but sufficient in the absence of others.
260 * [Now we resolve ties in favor of the earlier string if
261 * it happens that curback has been invalidated, since the
262 * earlier string may buy us something the later one won't.]
264 longish = newSVpv("",0);
265 longest = newSVpv("",0);
271 while (OP(scan) != END) {
272 if (OP(scan) == BRANCH) {
273 if (OP(regnext(scan)) == BRANCH) {
275 while (OP(scan) == BRANCH)
276 scan = regnext(scan);
278 else /* single branch is ok */
279 scan = NEXTOPER(scan);
282 if (OP(scan) == UNLESSM) {
284 scan = regnext(scan);
287 if (OP(scan) == EXACTLY) {
291 while (OP(t = regnext(scan)) == CLOSE)
293 minlen += *OPERAND(first);
294 if (curback - backish == len) {
295 sv_catpvn(longish, OPERAND(first)+1,
297 len += *OPERAND(first);
298 curback += *OPERAND(first);
299 first = regnext(scan);
301 else if (*OPERAND(first) >= len + (curback >= 0)) {
302 len = *OPERAND(first);
303 sv_setpvn(longish, OPERAND(first)+1,len);
306 first = regnext(scan);
309 curback += *OPERAND(first);
311 else if (strchr(varies,OP(scan))) {
314 if (SvCUR(longish) > SvCUR(longest)) {
315 sv_setsv(longest,longish);
318 sv_setpvn(longish,"",0);
319 if (OP(scan) == PLUS && strchr(simple,OP(NEXTOPER(scan))))
321 else if (regkind[(U8)OP(scan)] == CURLY &&
322 strchr(simple,OP(NEXTOPER(scan)+4)))
323 minlen += ARG1(scan);
325 else if (strchr(simple,OP(scan))) {
329 if (SvCUR(longish) > SvCUR(longest)) {
330 sv_setsv(longest,longish);
333 sv_setpvn(longish,"",0);
335 scan = regnext(scan);
338 /* Prefer earlier on tie, unless we can tail match latter */
340 if (SvCUR(longish) + (regkind[(U8)OP(first)] == EOL) >
343 sv_setsv(longest,longish);
347 sv_setpvn(longish,"",0);
352 !fbm_instr((unsigned char*) SvPVX(r->regstart),
353 (unsigned char *) SvPVX(r->regstart)
354 + SvCUR(r->regstart),
359 r->regmust = longest;
362 r->regback = backest;
363 if (SvCUR(longest) > !(sawstudy || fold ||
364 regkind[(U8)OP(first)]==EOL))
365 fbm_compile(r->regmust,fold);
366 (void)SvUPGRADE(r->regmust, SVt_PVBM);
367 BmUSEFUL(r->regmust) = 100;
368 if (regkind[(U8)OP(first)] == EOL && SvCUR(longish))
369 SvTAIL_on(r->regmust);
372 SvREFCNT_dec(longest);
375 SvREFCNT_dec(longish);
378 r->do_folding = fold;
379 r->nparens = regnpar - 1;
381 Newz(1002, r->startp, regnpar, char*);
382 Newz(1002, r->endp, regnpar, char*);
388 - reg - regular expression, i.e. main body or parenthesized thing
390 * Caller must absorb opening parenthesis.
392 * Combining parenthesis handling with the base level of regular expression
393 * is a trifle forced, but the need to tie the tails of the branches to what
394 * follows makes it hard to avoid.
398 I32 paren; /* Parenthesized? */
403 register char *ender = 0;
404 register I32 parno = 0;
407 *flagp = HASWIDTH; /* Tentatively. */
409 /* Make an OPEN node, if parenthesized. */
411 if (*regparse == '?') {
422 croak("Sequence (?%c...) not implemented", paren);
425 while (*regparse && *regparse != ')')
427 if (*regparse != ')')
428 croak("Sequence (?#... not terminated");
434 while (*regparse && strchr("iogmsx", *regparse))
435 pmflag(®flags, *regparse++);
436 if (*regparse != ')')
437 croak("Sequence (?%c...) not recognized", *regparse);
446 ret = reganode(OPEN, parno);
451 /* Pick up the branches, linking them together. */
452 br = regbranch(&flags);
456 regtail(ret, br); /* OPEN -> first. */
459 if (!(flags&HASWIDTH))
461 *flagp |= flags&SPSTART;
462 while (*regparse == '|') {
464 br = regbranch(&flags);
467 regtail(ret, br); /* BRANCH -> BRANCH. */
468 if (!(flags&HASWIDTH))
470 *flagp |= flags&SPSTART;
473 /* Make a closing node, and hook it on the end. */
476 ender = regnode(NOTHING);
479 ender = reganode(CLOSE, parno);
483 ender = regnode(SUCCEED);
487 ender = regnode(END);
492 /* Hook the tails of the branches to the closing node. */
493 for (br = ret; br != NULL; br = regnext(br))
494 regoptail(br, ender);
497 reginsert(IFMATCH,ret);
498 regtail(ret, regnode(NOTHING));
500 else if (paren == '!') {
501 reginsert(UNLESSM,ret);
502 regtail(ret, regnode(NOTHING));
505 /* Check for proper termination. */
506 if (paren && (regparse >= regxend || *nextchar() != ')')) {
507 FAIL("unmatched () in regexp");
508 } else if (!paren && regparse < regxend) {
509 if (*regparse == ')') {
510 FAIL("unmatched () in regexp");
512 FAIL("junk on end of regexp"); /* "Can't happen". */
520 - regbranch - one alternative of an | operator
522 * Implements the concatenation operator.
529 register char *chain;
530 register char *latest;
533 *flagp = WORST; /* Tentatively. */
535 ret = regnode(BRANCH);
539 while (regparse < regxend && *regparse != '|' && *regparse != ')') {
541 latest = regpiece(&flags);
542 if (latest == NULL) {
543 if (flags & TRYAGAIN)
547 *flagp |= flags&HASWIDTH;
548 if (chain == NULL) /* First piece. */
549 *flagp |= flags&SPSTART;
552 regtail(chain, latest);
556 if (chain == NULL) /* Loop ran zero times. */
557 (void) regnode(NOTHING);
563 - regpiece - something followed by possible [*+?]
565 * Note that the branching code sequences used for ? and the general cases
566 * of * and + are somewhat optimized: they use the same NOTHING node as
567 * both the endmarker for their branch list and the body of the last branch.
568 * It might seem that this node could be dispensed with entirely, but the
569 * endmarker role is not redundant.
579 char *origparse = regparse;
584 ret = regatom(&flags);
586 if (flags & TRYAGAIN)
592 if (op == '(' && regparse[1] == '?' && regparse[2] == '#') {
593 while (op && op != ')')
601 if (op == '{' && regcurly(regparse)) {
604 while (isDIGIT(*next) || *next == ',') {
613 if (*next == '}') { /* got one */
617 min = atoi(regparse);
623 if (!max && *maxpos != '0')
624 max = 32767; /* meaning "infinity" */
629 if ((flags&SIMPLE)) {
630 regnaughty += 2 + regnaughty / 2;
631 reginsert(CURLY, ret);
634 regnaughty += 4 + regnaughty; /* compound interest */
635 regtail(ret, regnode(WHILEM));
636 reginsert(CURLYX,ret);
637 regtail(ret, regnode(NOTHING));
641 *flagp = (WORST|HASWIDTH);
642 if (max && max < min)
643 croak("Can't do {n,m} with n > m");
644 if (regcode != ®dummy) {
646 *(unsigned short *)(ret+3) = min;
647 *(unsigned short *)(ret+5) = max;
649 ret[3] = min >> 8; ret[4] = min & 0377;
650 ret[5] = max >> 8; ret[6] = max & 0377;
664 *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
666 if (op == '*' && (flags&SIMPLE)) {
667 reginsert(STAR, ret);
670 else if (op == '*') {
673 } else if (op == '+' && (flags&SIMPLE)) {
674 reginsert(PLUS, ret);
677 else if (op == '+') {
680 } else if (op == '?') {
685 if (dowarn && regcode != ®dummy && !(flags&HASWIDTH) && max > 10000) {
686 warn("%.*s matches null string many times",
687 regparse - origparse, origparse);
690 if (*regparse == '?') {
692 reginsert(MINMOD, ret);
694 regtail(ret, ret + 4);
696 regtail(ret, ret + 3);
699 if (ISMULT2(regparse))
700 FAIL("nested *?+ in regexp");
706 - regatom - the lowest level
708 * Optimization: gobbles an entire sequence of ordinary characters so that
709 * it can turn them into a single node, which is smaller to store and
710 * faster to run. Backslashed characters are exceptions, each becoming a
711 * separate node; the code is simpler that way and it's not worth fixing.
713 * [Yes, it is worth fixing, some scripts can run twice the speed.]
719 register char *ret = 0;
722 *flagp = WORST; /* Tentatively. */
728 if (regflags & PMf_MULTILINE)
730 else if (regflags & PMf_SINGLELINE)
737 if (regflags & PMf_MULTILINE)
739 else if (regflags & PMf_SINGLELINE)
746 if (regflags & PMf_SINGLELINE)
751 *flagp |= HASWIDTH|SIMPLE;
756 *flagp |= HASWIDTH|SIMPLE;
760 ret = reg(1, &flags);
762 if (flags & TRYAGAIN)
766 *flagp |= flags&(HASWIDTH|SPSTART);
770 if (flags & TRYAGAIN) {
774 croak("internal urp in regexp at /%s/", regparse);
775 /* Supposed to be caught earlier. */
780 FAIL("?+* follows nothing in regexp");
783 switch (*++regparse) {
800 ret = regnode(ALNUM);
801 *flagp |= HASWIDTH|SIMPLE;
805 ret = regnode(NALNUM);
806 *flagp |= HASWIDTH|SIMPLE;
810 ret = regnode(BOUND);
815 ret = regnode(NBOUND);
820 ret = regnode(SPACE);
821 *flagp |= HASWIDTH|SIMPLE;
825 ret = regnode(NSPACE);
826 *flagp |= HASWIDTH|SIMPLE;
830 ret = regnode(DIGIT);
831 *flagp |= HASWIDTH|SIMPLE;
835 ret = regnode(NDIGIT);
836 *flagp |= HASWIDTH|SIMPLE;
849 case '1': case '2': case '3': case '4':
850 case '5': case '6': case '7': case '8': case '9':
852 I32 num = atoi(regparse);
854 if (num > 9 && num >= regnpar)
858 ret = reganode(REF, num);
860 while (isDIGIT(*regparse))
868 if (regparse >= regxend)
869 FAIL("trailing \\ in regexp");
877 if (regflags & PMf_EXTENDED) {
878 while (regparse < regxend && *regparse != '\n') regparse++;
879 if (regparse < regxend)
894 ret = regnode(EXACTLY);
895 regc(0); /* save spot for len */
896 for (len = 0, p = regparse - 1;
897 len < 127 && p < regxend;
950 ender = scan_hex(++p, 2, &numlen);
957 ender = toUPPER(ender);
960 case '0': case '1': case '2': case '3':case '4':
961 case '5': case '6': case '7': case '8':case '9':
963 (isDIGIT(p[1]) && atoi(p) >= regnpar) ) {
964 ender = scan_oct(p, 3, &numlen);
974 FAIL("trailing \\ in regexp");
982 if (regflags & PMf_EXTENDED) {
983 while (p < regxend && *p != '\n') p++;
986 case ' ': case '\t': case '\n': case '\r': case '\f': case '\v':
987 if (regflags & PMf_EXTENDED) {
997 if (regflags & PMf_FOLD && isUPPER(ender))
998 ender = toLOWER(ender);
999 if (ISMULT2(p)) { /* Back off on ?+*. */
1014 FAIL("internal disaster in regexp");
1019 if (regcode != ®dummy)
1020 *OPERAND(ret) = len;
1035 if (regcode == ®dummy)
1039 bits[c >> 3] &= ~(1 << (c & 7));
1041 bits[c >> 3] |= (1 << (c & 7));
1047 register char *bits;
1049 register I32 lastclass = 1234;
1050 register I32 range = 0;
1055 ret = regnode(ANYOF);
1056 if (*regparse == '^') { /* Complement of range. */
1064 for (class = 0; class < 32; class++)
1066 if (*regparse == ']' || *regparse == '-')
1067 goto skipcond; /* allow 1st char to be ] or - */
1068 while (regparse < regxend && *regparse != ']') {
1070 class = UCHARAT(regparse++);
1071 if (class == '\\') {
1072 class = UCHARAT(regparse++);
1075 for (class = 0; class < 256; class++)
1077 regset(bits,def,class);
1081 for (class = 0; class < 256; class++)
1082 if (!isALNUM(class))
1083 regset(bits,def,class);
1087 for (class = 0; class < 256; class++)
1089 regset(bits,def,class);
1093 for (class = 0; class < 256; class++)
1094 if (!isSPACE(class))
1095 regset(bits,def,class);
1099 for (class = '0'; class <= '9'; class++)
1100 regset(bits,def,class);
1104 for (class = 0; class < '0'; class++)
1105 regset(bits,def,class);
1106 for (class = '9' + 1; class < 256; class++)
1107 regset(bits,def,class);
1132 class = scan_hex(regparse, 2, &numlen);
1136 class = *regparse++;
1138 class = toUPPER(class);
1141 case '0': case '1': case '2': case '3': case '4':
1142 case '5': case '6': case '7': case '8': case '9':
1143 class = scan_oct(--regparse, 3, &numlen);
1149 if (lastclass > class)
1150 FAIL("invalid [] range in regexp");
1155 if (*regparse == '-' && regparse+1 < regxend &&
1156 regparse[1] != ']') {
1159 continue; /* do it next time */
1162 for ( ; lastclass <= class; lastclass++) {
1163 regset(bits,def,lastclass);
1164 if (regflags & PMf_FOLD && isUPPER(lastclass))
1165 regset(bits,def,toLOWER(lastclass));
1169 if (*regparse != ']')
1170 FAIL("unmatched [] in regexp");
1178 char* retval = regparse++;
1181 if (*regparse == '(' && regparse[1] == '?' &&
1182 regparse[2] == '#') {
1183 while (*regparse && *regparse != ')')
1188 if (regflags & PMf_EXTENDED) {
1189 if (isSPACE(*regparse)) {
1193 else if (*regparse == '#') {
1194 while (*regparse && *regparse != '\n')
1205 - regnode - emit a node
1207 #ifdef CAN_PROTOTYPE
1208 static char * /* Location. */
1211 static char * /* Location. */
1220 if (ret == ®dummy) {
1231 if (!((long)ret & 1))
1237 *ptr++ = '\0'; /* Null "next" pointer. */
1245 - reganode - emit a node with an argument
1247 #ifdef CAN_PROTOTYPE
1248 static char * /* Location. */
1249 reganode(char op, unsigned short arg)
1251 static char * /* Location. */
1261 if (ret == ®dummy) {
1272 if (!((long)ret & 1))
1278 *ptr++ = '\0'; /* Null "next" pointer. */
1281 *(unsigned short *)(ret+3) = arg;
1283 ret[3] = arg >> 8; ret[4] = arg & 0377;
1292 - regc - emit (if appropriate) a byte of code
1294 #ifdef CAN_PROTOTYPE
1303 if (regcode != ®dummy)
1310 - reginsert - insert an operator in front of already-emitted operand
1312 * Means relocating the operand.
1314 #ifdef CAN_PROTOTYPE
1316 reginsert(char op, char *opnd)
1326 register char *place;
1327 register int offset = (regkind[(U8)op] == CURLY ? 4 : 0);
1329 if (regcode == ®dummy) {
1331 regsize += 4 + offset;
1333 regsize += 3 + offset;
1340 regcode += 4 + offset;
1342 regcode += 3 + offset;
1348 place = opnd; /* Op node, where operand used to be. */
1352 while (offset-- > 0)
1360 - regtail - set the next-pointer at the end of a node chain
1367 register char *scan;
1368 register char *temp;
1369 register I32 offset;
1374 /* Find last node. */
1377 temp = regnext(scan);
1384 offset = val - scan;
1386 *(short*)(scan+1) = offset;
1391 if (OP(scan) == BACK)
1392 offset = scan - val;
1394 offset = val - scan;
1395 *(scan+1) = (offset>>8)&0377;
1396 *(scan+2) = offset&0377;
1401 - regoptail - regtail on operand of first argument; nop if operandless
1408 /* "Operandless" and "op != BRANCH" are synonymous in practice. */
1409 if (p == NULL || p == ®dummy || regkind[(U8)OP(p)] != BRANCH)
1411 regtail(NEXTOPER(p), val);
1415 - regcurly - a little FSA that accepts {\d+,?\d*}
1439 - regdump - dump a regexp onto stderr in vaguely comprehensible form
1446 register char op = EXACTLY; /* Arbitrary non-END op. */
1447 register char *next;
1451 while (op != END) { /* While that wasn't END last time... */
1457 fprintf(stderr,"%2d%s", s-r->program, regprop(s)); /* Where, what. */
1459 s += regarglen[(U8)op];
1460 if (next == NULL) /* Next ptr. */
1461 fprintf(stderr,"(0)");
1463 fprintf(stderr,"(%d)", (s-r->program)+(next-s));
1468 if (op == EXACTLY) {
1469 /* Literal string, where present. */
1471 (void)putc(' ', stderr);
1472 (void)putc('<', stderr);
1473 while (*s != '\0') {
1474 (void)putc(*s, stderr);
1477 (void)putc('>', stderr);
1480 (void)putc('\n', stderr);
1483 /* Header fields of interest. */
1485 fprintf(stderr,"start `%s' ", SvPVX(r->regstart));
1487 fprintf(stderr,"stclass `%s' ", regprop(r->regstclass));
1488 if (r->reganch & ROPT_ANCH)
1489 fprintf(stderr,"anchored ");
1490 if (r->reganch & ROPT_SKIP)
1491 fprintf(stderr,"plus ");
1492 if (r->reganch & ROPT_IMPLICIT)
1493 fprintf(stderr,"implicit ");
1494 if (r->regmust != NULL)
1495 fprintf(stderr,"must have \"%s\" back %ld ", SvPVX(r->regmust),
1497 fprintf(stderr, "minlen %ld ", (long) r->minlen);
1498 fprintf(stderr,"\n");
1502 - regprop - printable representation of opcode
1508 register char *p = 0;
1510 (void) strcpy(buf, ":");
1580 (void)sprintf(buf+strlen(buf), "CURLY {%d,%d}", ARG1(o),ARG2(o));
1584 (void)sprintf(buf+strlen(buf), "CURLYX {%d,%d}", ARG1(o),ARG2(o));
1588 (void)sprintf(buf+strlen(buf), "REF%d", ARG1(o));
1592 (void)sprintf(buf+strlen(buf), "OPEN%d", ARG1(o));
1596 (void)sprintf(buf+strlen(buf), "CLOSE%d", ARG1(o));
1624 FAIL("corrupted regexp opcode");
1627 (void) strcat(buf, p);
1630 #endif /* DEBUGGING */
1639 Safefree(r->precomp);
1640 r->precomp = Nullch;
1643 Safefree(r->subbase);
1644 r->subbase = Nullch;
1647 SvREFCNT_dec(r->regmust);
1648 r->regmust = Nullsv;
1651 SvREFCNT_dec(r->regstart);
1652 r->regstart = Nullsv;
1654 Safefree(r->startp);