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.
19 * regcomp and regexec -- regsub and regerror are not used in perl
21 * Copyright (c) 1986 by University of Toronto.
22 * Written by Henry Spencer. Not derived from licensed software.
24 * Permission is granted to anyone to use this software for any
25 * purpose on any computer system, and to redistribute it freely,
26 * subject to the following restrictions:
28 * 1. The author is not responsible for the consequences of use of
29 * this software, no matter how awful, even if they arise
32 * 2. The origin of this software must not be misrepresented, either
33 * by explicit claim or by omission.
35 * 3. Altered versions must be plainly marked as such, and must not
36 * be misrepresented as being the original software.
39 **** Alterations to Henry's code are...
41 **** Copyright (c) 1991-1994, Larry Wall
43 **** You may distribute under the terms of either the GNU General Public
44 **** License or the Artistic License, as specified in the README file.
47 * Beware that some of this code is subtly aware of the way operator
48 * precedence is structured in regular expressions. Serious changes in
49 * regular-expression syntax might require a total rethink.
57 # if defined(BUGGY_MSC6)
58 /* MSC 6.00A breaks on op/regexp.t test 85 unless we turn this off */
59 # pragma optimize("a",off)
60 /* But MSC 6.00A is happy with 'w', for aliases only across function calls*/
61 # pragma optimize("w",on )
62 # endif /* BUGGY_MSC6 */
69 #define ISMULT1(c) ((c) == '*' || (c) == '+' || (c) == '?')
70 #define ISMULT2(s) ((*s) == '*' || (*s) == '+' || (*s) == '?' || \
71 ((*s) == '{' && regcurly(s)))
73 #define PERL_META "^$.[()|?+*\\"
75 #define META "^$.[()|?+*\\"
79 #undef SPSTART /* dratted cpp namespace... */
82 * Flags to be passed up and down.
84 #define WORST 0 /* Worst case. */
85 #define HASWIDTH 0x1 /* Known never to match null string. */
86 #define SIMPLE 0x2 /* Simple enough to be STAR/PLUS operand. */
87 #define SPSTART 0x4 /* Starts with * or +. */
88 #define TRYAGAIN 0x8 /* Weeded out a declaration. */
91 * Forward declarations for regcomp()'s friends.
94 static char *reg _((I32, I32 *));
95 static char *reganode _((char, unsigned short));
96 static char *regatom _((I32 *));
97 static char *regbranch _((I32 *));
98 static void regc _((char));
99 static char *regclass _((void));
100 STATIC I32 regcurly _((char *));
101 static char *regnode _((char));
102 static char *regpiece _((I32 *));
103 static void reginsert _((char, char *));
104 static void regoptail _((char *, char *));
105 static void regset _((char *, I32, I32));
106 static void regtail _((char *, char *));
107 static char* nextchar _((void));
110 - regcomp - compile a regular expression into internal code
112 * We can't allocate space until we know how big the compiled form will be,
113 * but we can't compile it (and thus know how big it is) until we've got a
114 * place to put the code. So we cheat: we compile it twice, once with code
115 * generation turned off and size counting turned on, and once "for real".
116 * This also means that we don't allocate space until we are sure that the
117 * thing really will compile successfully, and we never have to move the
118 * code and thus invalidate pointers into it. (Note that it has to be in
119 * one piece because free() must be able to free it all.) [NB: not true in perl]
121 * Beware that the optimization-preparation code in here knows about some
122 * of the structure of the compiled regexp. [I'll say.]
130 I32 fold = pm->op_pmflags & PMf_FOLD;
133 register SV *longish;
136 register char *first;
146 croak("NULL regexp argument");
148 /* First pass: determine size, legality. */
149 regflags = pm->op_pmflags;
152 regprecomp = savepvn(exp,xend-exp);
159 if (reg(0, &flags) == NULL) {
160 Safefree(regprecomp);
165 /* Small enough for pointer-storage convention? */
166 if (regsize >= 32767L) /* Probably could be 65535L. */
167 FAIL("regexp too big");
169 /* Allocate space. */
170 Newc(1001, r, sizeof(regexp) + (unsigned)regsize, char, regexp);
172 FAIL("regexp out of space");
174 /* Second pass: emit code. */
175 r->prelen = xend-exp;
176 r->precomp = regprecomp;
177 r->subbeg = r->subbase = NULL;
181 regcode = r->program;
183 if (reg(0, &flags) == NULL)
186 /* Dig out information for optimizations. */
187 pm->op_pmflags = regflags;
188 fold = pm->op_pmflags & PMf_FOLD;
189 r->regstart = Nullsv; /* Worst-case defaults. */
193 r->regstclass = Nullch;
194 r->naughty = regnaughty >= 10; /* Probably an expensive pattern. */
195 scan = r->program+1; /* First BRANCH. */
196 if (OP(regnext(scan)) == END) {/* Only one top-level choice. */
197 scan = NEXTOPER(scan);
200 while ((OP(first) == OPEN && (sawopen = 1)) ||
201 (OP(first) == BRANCH && OP(regnext(first)) != BRANCH) ||
202 (OP(first) == PLUS) ||
203 (OP(first) == MINMOD) ||
204 (regkind[(U8)OP(first)] == CURLY && ARG1(first) > 0) ) {
205 if (OP(first) == PLUS)
208 first += regarglen[(U8)OP(first)];
209 first = NEXTOPER(first);
212 /* Starting-point info. */
214 if (OP(first) == EXACTLY) {
215 r->regstart = newSVpv(OPERAND(first)+1,*OPERAND(first));
216 if (SvCUR(r->regstart) > !(sawstudy|fold))
217 fbm_compile(r->regstart,fold);
219 sv_upgrade(r->regstart, SVt_PVBM);
221 else if (strchr(simple+2,OP(first)))
222 r->regstclass = first;
223 else if (OP(first) == BOUND || OP(first) == NBOUND)
224 r->regstclass = first;
225 else if (regkind[(U8)OP(first)] == BOL) {
226 r->reganch = ROPT_ANCH;
227 first = NEXTOPER(first);
230 else if ((OP(first) == STAR &&
231 regkind[(U8)OP(NEXTOPER(first))] == ANY) &&
232 !(r->reganch & ROPT_ANCH) )
234 /* turn .* into ^.* with an implied $*=1 */
235 r->reganch = ROPT_ANCH | ROPT_IMPLICIT;
236 first = NEXTOPER(first);
239 if (sawplus && (!sawopen || !regsawback))
240 r->reganch |= ROPT_SKIP; /* x+ must match 1st of run */
242 DEBUG_r(fprintf(stderr,"first %d next %d offset %d\n",
243 OP(first), OP(NEXTOPER(first)), first - scan));
245 * If there's something expensive in the r.e., find the
246 * longest literal string that must appear and make it the
247 * regmust. Resolve ties in favor of later strings, since
248 * the regstart check works with the beginning of the r.e.
249 * and avoiding duplication strengthens checking. Not a
250 * strong reason, but sufficient in the absence of others.
251 * [Now we resolve ties in favor of the earlier string if
252 * it happens that curback has been invalidated, since the
253 * earlier string may buy us something the later one won't.]
255 longish = newSVpv("",0);
256 longest = newSVpv("",0);
262 while (OP(scan) != END) {
263 if (OP(scan) == BRANCH) {
264 if (OP(regnext(scan)) == BRANCH) {
266 while (OP(scan) == BRANCH)
267 scan = regnext(scan);
269 else /* single branch is ok */
270 scan = NEXTOPER(scan);
273 if (OP(scan) == UNLESSM) {
275 scan = regnext(scan);
278 if (OP(scan) == EXACTLY) {
282 while (OP(t = regnext(scan)) == CLOSE)
284 minlen += *OPERAND(first);
285 if (curback - backish == len) {
286 sv_catpvn(longish, OPERAND(first)+1,
288 len += *OPERAND(first);
289 curback += *OPERAND(first);
290 first = regnext(scan);
292 else if (*OPERAND(first) >= len + (curback >= 0)) {
293 len = *OPERAND(first);
294 sv_setpvn(longish, OPERAND(first)+1,len);
297 first = regnext(scan);
300 curback += *OPERAND(first);
302 else if (strchr(varies,OP(scan))) {
305 if (SvCUR(longish) > SvCUR(longest)) {
306 sv_setsv(longest,longish);
309 sv_setpvn(longish,"",0);
310 if (OP(scan) == PLUS && strchr(simple,OP(NEXTOPER(scan))))
312 else if (regkind[(U8)OP(scan)] == CURLY &&
313 strchr(simple,OP(NEXTOPER(scan)+4)))
314 minlen += ARG1(scan);
316 else if (strchr(simple,OP(scan))) {
320 if (SvCUR(longish) > SvCUR(longest)) {
321 sv_setsv(longest,longish);
324 sv_setpvn(longish,"",0);
326 scan = regnext(scan);
329 /* Prefer earlier on tie, unless we can tail match latter */
331 if (SvCUR(longish) + (regkind[(U8)OP(first)] == EOL) >
334 sv_setsv(longest,longish);
338 sv_setpvn(longish,"",0);
343 !fbm_instr((unsigned char*) SvPVX(r->regstart),
344 (unsigned char *) SvPVX(r->regstart)
345 + SvCUR(r->regstart),
350 r->regmust = longest;
353 r->regback = backest;
354 if (SvCUR(longest) > !(sawstudy || fold ||
355 regkind[(U8)OP(first)]==EOL))
356 fbm_compile(r->regmust,fold);
357 (void)SvUPGRADE(r->regmust, SVt_PVBM);
358 BmUSEFUL(r->regmust) = 100;
359 if (regkind[(U8)OP(first)] == EOL && SvCUR(longish))
360 SvTAIL_on(r->regmust);
363 SvREFCNT_dec(longest);
366 SvREFCNT_dec(longish);
369 r->do_folding = fold;
370 r->nparens = regnpar - 1;
372 Newz(1002, r->startp, regnpar, char*);
373 Newz(1002, r->endp, regnpar, char*);
379 - reg - regular expression, i.e. main body or parenthesized thing
381 * Caller must absorb opening parenthesis.
383 * Combining parenthesis handling with the base level of regular expression
384 * is a trifle forced, but the need to tie the tails of the branches to what
385 * follows makes it hard to avoid.
389 I32 paren; /* Parenthesized? */
394 register char *ender = 0;
395 register I32 parno = 0;
398 *flagp = HASWIDTH; /* Tentatively. */
400 /* Make an OPEN node, if parenthesized. */
402 if (*regparse == '?') {
413 croak("Sequence (?%c...) not implemented", paren);
416 while (*regparse && *regparse != ')')
418 if (*regparse != ')')
419 croak("Sequence (?#... not terminated");
425 while (*regparse && strchr("iogmsx", *regparse))
426 pmflag(®flags, *regparse++);
427 if (*regparse != ')')
428 croak("Sequence (?%c...) not recognized", *regparse);
437 ret = reganode(OPEN, parno);
442 /* Pick up the branches, linking them together. */
443 br = regbranch(&flags);
447 regtail(ret, br); /* OPEN -> first. */
450 if (!(flags&HASWIDTH))
452 *flagp |= flags&SPSTART;
453 while (*regparse == '|') {
455 br = regbranch(&flags);
458 regtail(ret, br); /* BRANCH -> BRANCH. */
459 if (!(flags&HASWIDTH))
461 *flagp |= flags&SPSTART;
464 /* Make a closing node, and hook it on the end. */
467 ender = regnode(NOTHING);
470 ender = reganode(CLOSE, parno);
474 ender = regnode(SUCCEED);
478 ender = regnode(END);
483 /* Hook the tails of the branches to the closing node. */
484 for (br = ret; br != NULL; br = regnext(br))
485 regoptail(br, ender);
488 reginsert(IFMATCH,ret);
489 regtail(ret, regnode(NOTHING));
491 else if (paren == '!') {
492 reginsert(UNLESSM,ret);
493 regtail(ret, regnode(NOTHING));
496 /* Check for proper termination. */
497 if (paren && *nextchar() != ')') {
498 FAIL("unmatched () in regexp");
499 } else if (!paren && regparse < regxend) {
500 if (*regparse == ')') {
501 FAIL("unmatched () in regexp");
503 FAIL("junk on end of regexp"); /* "Can't happen". */
511 - regbranch - one alternative of an | operator
513 * Implements the concatenation operator.
520 register char *chain;
521 register char *latest;
524 *flagp = WORST; /* Tentatively. */
526 ret = regnode(BRANCH);
530 while (regparse < regxend && *regparse != '|' && *regparse != ')') {
532 latest = regpiece(&flags);
533 if (latest == NULL) {
534 if (flags & TRYAGAIN)
538 *flagp |= flags&HASWIDTH;
539 if (chain == NULL) /* First piece. */
540 *flagp |= flags&SPSTART;
543 regtail(chain, latest);
547 if (chain == NULL) /* Loop ran zero times. */
548 (void) regnode(NOTHING);
554 - regpiece - something followed by possible [*+?]
556 * Note that the branching code sequences used for ? and the general cases
557 * of * and + are somewhat optimized: they use the same NOTHING node as
558 * both the endmarker for their branch list and the body of the last branch.
559 * It might seem that this node could be dispensed with entirely, but the
560 * endmarker role is not redundant.
570 char *origparse = regparse;
575 ret = regatom(&flags);
577 if (flags & TRYAGAIN)
583 if (op == '(' && regparse[1] == '?' && regparse[2] == '#') {
584 while (op && op != ')')
592 if (op == '{' && regcurly(regparse)) {
595 while (isDIGIT(*next) || *next == ',') {
604 if (*next == '}') { /* got one */
608 min = atoi(regparse);
614 if (!max && *maxpos != '0')
615 max = 32767; /* meaning "infinity" */
620 if ((flags&SIMPLE)) {
621 regnaughty += 2 + regnaughty / 2;
622 reginsert(CURLY, ret);
625 regnaughty += 4 + regnaughty; /* compound interest */
626 regtail(ret, regnode(WHILEM));
627 reginsert(CURLYX,ret);
628 regtail(ret, regnode(NOTHING));
632 *flagp = (WORST|HASWIDTH);
633 if (max && max < min)
634 croak("Can't do {n,m} with n > m");
635 if (regcode != ®dummy) {
637 *(unsigned short *)(ret+3) = min;
638 *(unsigned short *)(ret+5) = max;
640 ret[3] = min >> 8; ret[4] = min & 0377;
641 ret[5] = max >> 8; ret[6] = max & 0377;
655 *flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);
657 if (op == '*' && (flags&SIMPLE)) {
658 reginsert(STAR, ret);
661 else if (op == '*') {
664 } else if (op == '+' && (flags&SIMPLE)) {
665 reginsert(PLUS, ret);
668 else if (op == '+') {
671 } else if (op == '?') {
676 if (dowarn && regcode != ®dummy && !(flags&HASWIDTH) && max > 10000) {
677 warn("%.*s matches null string many times",
678 regparse - origparse, origparse);
681 if (*regparse == '?') {
683 reginsert(MINMOD, ret);
685 regtail(ret, ret + 4);
687 regtail(ret, ret + 3);
690 if (ISMULT2(regparse))
691 FAIL("nested *?+ in regexp");
697 - regatom - the lowest level
699 * Optimization: gobbles an entire sequence of ordinary characters so that
700 * it can turn them into a single node, which is smaller to store and
701 * faster to run. Backslashed characters are exceptions, each becoming a
702 * separate node; the code is simpler that way and it's not worth fixing.
704 * [Yes, it is worth fixing, some scripts can run twice the speed.]
710 register char *ret = 0;
713 *flagp = WORST; /* Tentatively. */
719 if (regflags & PMf_MULTILINE)
721 else if (regflags & PMf_SINGLELINE)
728 if (regflags & PMf_MULTILINE)
730 else if (regflags & PMf_SINGLELINE)
737 if (regflags & PMf_SINGLELINE)
742 *flagp |= HASWIDTH|SIMPLE;
747 *flagp |= HASWIDTH|SIMPLE;
751 ret = reg(1, &flags);
753 if (flags & TRYAGAIN)
757 *flagp |= flags&(HASWIDTH|SPSTART);
761 if (flags & TRYAGAIN) {
765 croak("internal urp in regexp at /%s/", regparse);
766 /* Supposed to be caught earlier. */
771 FAIL("?+* follows nothing in regexp");
774 switch (*++regparse) {
791 ret = regnode(ALNUM);
792 *flagp |= HASWIDTH|SIMPLE;
796 ret = regnode(NALNUM);
797 *flagp |= HASWIDTH|SIMPLE;
801 ret = regnode(BOUND);
806 ret = regnode(NBOUND);
811 ret = regnode(SPACE);
812 *flagp |= HASWIDTH|SIMPLE;
816 ret = regnode(NSPACE);
817 *flagp |= HASWIDTH|SIMPLE;
821 ret = regnode(DIGIT);
822 *flagp |= HASWIDTH|SIMPLE;
826 ret = regnode(NDIGIT);
827 *flagp |= HASWIDTH|SIMPLE;
840 case '1': case '2': case '3': case '4':
841 case '5': case '6': case '7': case '8': case '9':
843 I32 num = atoi(regparse);
845 if (num > 9 && num >= regnpar)
849 ret = reganode(REF, num);
851 while (isDIGIT(*regparse))
859 if (regparse >= regxend)
860 FAIL("trailing \\ in regexp");
876 ret = regnode(EXACTLY);
877 regc(0); /* save spot for len */
878 for (len = 0, p = regparse - 1;
879 len < 127 && p < regxend;
932 ender = scan_hex(++p, 2, &numlen);
939 ender = toUPPER(ender);
942 case '0': case '1': case '2': case '3':case '4':
943 case '5': case '6': case '7': case '8':case '9':
945 (isDIGIT(p[1]) && atoi(p) >= regnpar) ) {
946 ender = scan_oct(p, 3, &numlen);
956 FAIL("trailing \\ in regexp");
963 case ' ': case '\t': case '\n': case '\r': case '\f': case '\v':
964 if (regflags & PMf_EXTENDED) {
974 if (regflags & PMf_FOLD && isUPPER(ender))
975 ender = toLOWER(ender);
976 if (ISMULT2(p)) { /* Back off on ?+*. */
991 FAIL("internal disaster in regexp");
996 if (regcode != ®dummy)
1012 if (regcode == ®dummy)
1016 bits[c >> 3] &= ~(1 << (c & 7));
1018 bits[c >> 3] |= (1 << (c & 7));
1024 register char *bits;
1026 register I32 lastclass = 1234;
1027 register I32 range = 0;
1032 ret = regnode(ANYOF);
1033 if (*regparse == '^') { /* Complement of range. */
1041 for (class = 0; class < 32; class++)
1043 if (*regparse == ']' || *regparse == '-')
1044 goto skipcond; /* allow 1st char to be ] or - */
1045 while (regparse < regxend && *regparse != ']') {
1047 class = UCHARAT(regparse++);
1048 if (class == '\\') {
1049 class = UCHARAT(regparse++);
1052 for (class = 0; class < 256; class++)
1054 regset(bits,def,class);
1058 for (class = 0; class < 256; class++)
1059 if (!isALNUM(class))
1060 regset(bits,def,class);
1064 for (class = 0; class < 256; class++)
1066 regset(bits,def,class);
1070 for (class = 0; class < 256; class++)
1071 if (!isSPACE(class))
1072 regset(bits,def,class);
1076 for (class = '0'; class <= '9'; class++)
1077 regset(bits,def,class);
1081 for (class = 0; class < '0'; class++)
1082 regset(bits,def,class);
1083 for (class = '9' + 1; class < 256; class++)
1084 regset(bits,def,class);
1109 class = scan_hex(regparse, 2, &numlen);
1113 class = *regparse++;
1115 class = toUPPER(class);
1118 case '0': case '1': case '2': case '3': case '4':
1119 case '5': case '6': case '7': case '8': case '9':
1120 class = scan_oct(--regparse, 3, &numlen);
1126 if (lastclass > class)
1127 FAIL("invalid [] range in regexp");
1132 if (*regparse == '-' && regparse+1 < regxend &&
1133 regparse[1] != ']') {
1136 continue; /* do it next time */
1139 for ( ; lastclass <= class; lastclass++) {
1140 regset(bits,def,lastclass);
1141 if (regflags & PMf_FOLD && isUPPER(lastclass))
1142 regset(bits,def,toLOWER(lastclass));
1146 if (*regparse != ']')
1147 FAIL("unmatched [] in regexp");
1155 char* retval = regparse++;
1157 if (regflags & PMf_EXTENDED) {
1159 if (isSPACE(*regparse)) {
1163 else if (*regparse == '(' && regparse[1] == '?' &&
1164 regparse[2] == '#') {
1165 while (*regparse && *regparse != ')')
1170 else if (*regparse == '#') {
1171 while (*regparse && *regparse != '\n')
1183 - regnode - emit a node
1185 #ifdef CAN_PROTOTYPE
1186 static char * /* Location. */
1189 static char * /* Location. */
1198 if (ret == ®dummy) {
1209 if (!((long)ret & 1))
1215 *ptr++ = '\0'; /* Null "next" pointer. */
1223 - reganode - emit a node with an argument
1225 #ifdef CAN_PROTOTYPE
1226 static char * /* Location. */
1227 reganode(char op, unsigned short arg)
1229 static char * /* Location. */
1239 if (ret == ®dummy) {
1250 if (!((long)ret & 1))
1256 *ptr++ = '\0'; /* Null "next" pointer. */
1259 *(unsigned short *)(ret+3) = arg;
1261 ret[3] = arg >> 8; ret[4] = arg & 0377;
1270 - regc - emit (if appropriate) a byte of code
1272 #ifdef CAN_PROTOTYPE
1281 if (regcode != ®dummy)
1288 - reginsert - insert an operator in front of already-emitted operand
1290 * Means relocating the operand.
1292 #ifdef CAN_PROTOTYPE
1294 reginsert(char op, char *opnd)
1304 register char *place;
1305 register int offset = (regkind[(U8)op] == CURLY ? 4 : 0);
1307 if (regcode == ®dummy) {
1309 regsize += 4 + offset;
1311 regsize += 3 + offset;
1318 regcode += 4 + offset;
1320 regcode += 3 + offset;
1326 place = opnd; /* Op node, where operand used to be. */
1330 while (offset-- > 0)
1338 - regtail - set the next-pointer at the end of a node chain
1345 register char *scan;
1346 register char *temp;
1347 register I32 offset;
1352 /* Find last node. */
1355 temp = regnext(scan);
1362 offset = val - scan;
1364 *(short*)(scan+1) = offset;
1369 if (OP(scan) == BACK)
1370 offset = scan - val;
1372 offset = val - scan;
1373 *(scan+1) = (offset>>8)&0377;
1374 *(scan+2) = offset&0377;
1379 - regoptail - regtail on operand of first argument; nop if operandless
1386 /* "Operandless" and "op != BRANCH" are synonymous in practice. */
1387 if (p == NULL || p == ®dummy || regkind[(U8)OP(p)] != BRANCH)
1389 regtail(NEXTOPER(p), val);
1393 - regcurly - a little FSA that accepts {\d+,?\d*}
1417 - regdump - dump a regexp onto stderr in vaguely comprehensible form
1424 register char op = EXACTLY; /* Arbitrary non-END op. */
1425 register char *next;
1429 while (op != END) { /* While that wasn't END last time... */
1435 fprintf(stderr,"%2d%s", s-r->program, regprop(s)); /* Where, what. */
1437 s += regarglen[(U8)op];
1438 if (next == NULL) /* Next ptr. */
1439 fprintf(stderr,"(0)");
1441 fprintf(stderr,"(%d)", (s-r->program)+(next-s));
1446 if (op == EXACTLY) {
1447 /* Literal string, where present. */
1449 (void)putc(' ', stderr);
1450 (void)putc('<', stderr);
1451 while (*s != '\0') {
1452 (void)putc(*s, stderr);
1455 (void)putc('>', stderr);
1458 (void)putc('\n', stderr);
1461 /* Header fields of interest. */
1463 fprintf(stderr,"start `%s' ", SvPVX(r->regstart));
1465 fprintf(stderr,"stclass `%s' ", regprop(r->regstclass));
1466 if (r->reganch & ROPT_ANCH)
1467 fprintf(stderr,"anchored ");
1468 if (r->reganch & ROPT_SKIP)
1469 fprintf(stderr,"plus ");
1470 if (r->reganch & ROPT_IMPLICIT)
1471 fprintf(stderr,"implicit ");
1472 if (r->regmust != NULL)
1473 fprintf(stderr,"must have \"%s\" back %ld ", SvPVX(r->regmust),
1475 fprintf(stderr, "minlen %ld ", (long) r->minlen);
1476 fprintf(stderr,"\n");
1480 - regprop - printable representation of opcode
1486 register char *p = 0;
1488 (void) strcpy(buf, ":");
1558 (void)sprintf(buf+strlen(buf), "CURLY {%d,%d}", ARG1(op),ARG2(op));
1562 (void)sprintf(buf+strlen(buf), "CURLYX {%d,%d}", ARG1(op),ARG2(op));
1566 (void)sprintf(buf+strlen(buf), "REF%d", ARG1(op));
1570 (void)sprintf(buf+strlen(buf), "OPEN%d", ARG1(op));
1574 (void)sprintf(buf+strlen(buf), "CLOSE%d", ARG1(op));
1602 FAIL("corrupted regexp opcode");
1605 (void) strcat(buf, p);
1608 #endif /* DEBUGGING */
1617 Safefree(r->precomp);
1618 r->precomp = Nullch;
1621 Safefree(r->subbase);
1622 r->subbase = Nullch;
1625 SvREFCNT_dec(r->regmust);
1626 r->regmust = Nullsv;
1629 SvREFCNT_dec(r->regstart);
1630 r->regstart = Nullsv;
1632 Safefree(r->startp);