Annotation of embedaddon/pcre/pcre_printint.src, revision 1.1
1.1 ! misho 1: /*************************************************
! 2: * Perl-Compatible Regular Expressions *
! 3: *************************************************/
! 4:
! 5: /* PCRE is a library of functions to support regular expressions whose syntax
! 6: and semantics are as close as possible to those of the Perl 5 language.
! 7:
! 8: Written by Philip Hazel
! 9: Copyright (c) 1997-2010 University of Cambridge
! 10:
! 11: -----------------------------------------------------------------------------
! 12: Redistribution and use in source and binary forms, with or without
! 13: modification, are permitted provided that the following conditions are met:
! 14:
! 15: * Redistributions of source code must retain the above copyright notice,
! 16: this list of conditions and the following disclaimer.
! 17:
! 18: * Redistributions in binary form must reproduce the above copyright
! 19: notice, this list of conditions and the following disclaimer in the
! 20: documentation and/or other materials provided with the distribution.
! 21:
! 22: * Neither the name of the University of Cambridge nor the names of its
! 23: contributors may be used to endorse or promote products derived from
! 24: this software without specific prior written permission.
! 25:
! 26: THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
! 27: AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 28: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 29: ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
! 30: LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 31: CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 32: SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 33: INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 34: CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 35: ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 36: POSSIBILITY OF SUCH DAMAGE.
! 37: -----------------------------------------------------------------------------
! 38: */
! 39:
! 40:
! 41: /* This module contains a PCRE private debugging function for printing out the
! 42: internal form of a compiled regular expression, along with some supporting
! 43: local functions. This source file is used in two places:
! 44:
! 45: (1) It is #included by pcre_compile.c when it is compiled in debugging mode
! 46: (PCRE_DEBUG defined in pcre_internal.h). It is not included in production
! 47: compiles.
! 48:
! 49: (2) It is always #included by pcretest.c, which can be asked to print out a
! 50: compiled regex for debugging purposes. */
! 51:
! 52:
! 53: /* Macro that decides whether a character should be output as a literal or in
! 54: hexadecimal. We don't use isprint() because that can vary from system to system
! 55: (even without the use of locales) and we want the output always to be the same,
! 56: for testing purposes. This macro is used in pcretest as well as in this file. */
! 57:
! 58: #ifdef EBCDIC
! 59: #define PRINTABLE(c) ((c) >= 64 && (c) < 255)
! 60: #else
! 61: #define PRINTABLE(c) ((c) >= 32 && (c) < 127)
! 62: #endif
! 63:
! 64: /* The table of operator names. */
! 65:
! 66: static const char *OP_names[] = { OP_NAME_LIST };
! 67:
! 68:
! 69:
! 70: /*************************************************
! 71: * Print single- or multi-byte character *
! 72: *************************************************/
! 73:
! 74: static int
! 75: print_char(FILE *f, uschar *ptr, BOOL utf8)
! 76: {
! 77: int c = *ptr;
! 78:
! 79: #ifndef SUPPORT_UTF8
! 80: utf8 = utf8; /* Avoid compiler warning */
! 81: if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
! 82: return 0;
! 83:
! 84: #else
! 85: if (!utf8 || (c & 0xc0) != 0xc0)
! 86: {
! 87: if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
! 88: return 0;
! 89: }
! 90: else
! 91: {
! 92: int i;
! 93: int a = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */
! 94: int s = 6*a;
! 95: c = (c & _pcre_utf8_table3[a]) << s;
! 96: for (i = 1; i <= a; i++)
! 97: {
! 98: /* This is a check for malformed UTF-8; it should only occur if the sanity
! 99: check has been turned off. Rather than swallow random bytes, just stop if
! 100: we hit a bad one. Print it with \X instead of \x as an indication. */
! 101:
! 102: if ((ptr[i] & 0xc0) != 0x80)
! 103: {
! 104: fprintf(f, "\\X{%x}", c);
! 105: return i - 1;
! 106: }
! 107:
! 108: /* The byte is OK */
! 109:
! 110: s -= 6;
! 111: c |= (ptr[i] & 0x3f) << s;
! 112: }
! 113: if (c < 128) fprintf(f, "\\x%02x", c); else fprintf(f, "\\x{%x}", c);
! 114: return a;
! 115: }
! 116: #endif
! 117: }
! 118:
! 119:
! 120:
! 121: /*************************************************
! 122: * Find Unicode property name *
! 123: *************************************************/
! 124:
! 125: static const char *
! 126: get_ucpname(int ptype, int pvalue)
! 127: {
! 128: #ifdef SUPPORT_UCP
! 129: int i;
! 130: for (i = _pcre_utt_size - 1; i >= 0; i--)
! 131: {
! 132: if (ptype == _pcre_utt[i].type && pvalue == _pcre_utt[i].value) break;
! 133: }
! 134: return (i >= 0)? _pcre_utt_names + _pcre_utt[i].name_offset : "??";
! 135: #else
! 136: /* It gets harder and harder to shut off unwanted compiler warnings. */
! 137: ptype = ptype * pvalue;
! 138: return (ptype == pvalue)? "??" : "??";
! 139: #endif
! 140: }
! 141:
! 142:
! 143:
! 144: /*************************************************
! 145: * Print compiled regex *
! 146: *************************************************/
! 147:
! 148: /* Make this function work for a regex with integers either byte order.
! 149: However, we assume that what we are passed is a compiled regex. The
! 150: print_lengths flag controls whether offsets and lengths of items are printed.
! 151: They can be turned off from pcretest so that automatic tests on bytecode can be
! 152: written that do not depend on the value of LINK_SIZE. */
! 153:
! 154: static void
! 155: pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths)
! 156: {
! 157: real_pcre *re = (real_pcre *)external_re;
! 158: uschar *codestart, *code;
! 159: BOOL utf8;
! 160:
! 161: unsigned int options = re->options;
! 162: int offset = re->name_table_offset;
! 163: int count = re->name_count;
! 164: int size = re->name_entry_size;
! 165:
! 166: if (re->magic_number != MAGIC_NUMBER)
! 167: {
! 168: offset = ((offset << 8) & 0xff00) | ((offset >> 8) & 0xff);
! 169: count = ((count << 8) & 0xff00) | ((count >> 8) & 0xff);
! 170: size = ((size << 8) & 0xff00) | ((size >> 8) & 0xff);
! 171: options = ((options << 24) & 0xff000000) |
! 172: ((options << 8) & 0x00ff0000) |
! 173: ((options >> 8) & 0x0000ff00) |
! 174: ((options >> 24) & 0x000000ff);
! 175: }
! 176:
! 177: code = codestart = (uschar *)re + offset + count * size;
! 178: utf8 = (options & PCRE_UTF8) != 0;
! 179:
! 180: for(;;)
! 181: {
! 182: uschar *ccode;
! 183: const char *flag = " ";
! 184: int c;
! 185: int extra = 0;
! 186:
! 187: if (print_lengths)
! 188: fprintf(f, "%3d ", (int)(code - codestart));
! 189: else
! 190: fprintf(f, " ");
! 191:
! 192: switch(*code)
! 193: {
! 194: /* ========================================================================== */
! 195: /* These cases are never obeyed. This is a fudge that causes a compile-
! 196: time error if the vectors OP_names or _pcre_OP_lengths, which are indexed
! 197: by opcode, are not the correct length. It seems to be the only way to do
! 198: such a check at compile time, as the sizeof() operator does not work in
! 199: the C preprocessor. We do this while compiling pcretest, because that
! 200: #includes pcre_tables.c, which holds _pcre_OP_lengths. We can't do this
! 201: when building pcre_compile.c with PCRE_DEBUG set, because it doesn't then
! 202: know the size of _pcre_OP_lengths. */
! 203:
! 204: #ifdef COMPILING_PCRETEST
! 205: case OP_TABLE_LENGTH:
! 206: case OP_TABLE_LENGTH +
! 207: ((sizeof(OP_names)/sizeof(const char *) == OP_TABLE_LENGTH) &&
! 208: (sizeof(_pcre_OP_lengths) == OP_TABLE_LENGTH)):
! 209: break;
! 210: #endif
! 211: /* ========================================================================== */
! 212:
! 213: case OP_END:
! 214: fprintf(f, " %s\n", OP_names[*code]);
! 215: fprintf(f, "------------------------------------------------------------------\n");
! 216: return;
! 217:
! 218: case OP_CHAR:
! 219: fprintf(f, " ");
! 220: do
! 221: {
! 222: code++;
! 223: code += 1 + print_char(f, code, utf8);
! 224: }
! 225: while (*code == OP_CHAR);
! 226: fprintf(f, "\n");
! 227: continue;
! 228:
! 229: case OP_CHARI:
! 230: fprintf(f, " /i ");
! 231: do
! 232: {
! 233: code++;
! 234: code += 1 + print_char(f, code, utf8);
! 235: }
! 236: while (*code == OP_CHARI);
! 237: fprintf(f, "\n");
! 238: continue;
! 239:
! 240: case OP_CBRA:
! 241: case OP_CBRAPOS:
! 242: case OP_SCBRA:
! 243: case OP_SCBRAPOS:
! 244: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
! 245: else fprintf(f, " ");
! 246: fprintf(f, "%s %d", OP_names[*code], GET2(code, 1+LINK_SIZE));
! 247: break;
! 248:
! 249: case OP_BRA:
! 250: case OP_BRAPOS:
! 251: case OP_SBRA:
! 252: case OP_SBRAPOS:
! 253: case OP_KETRMAX:
! 254: case OP_KETRMIN:
! 255: case OP_KETRPOS:
! 256: case OP_ALT:
! 257: case OP_KET:
! 258: case OP_ASSERT:
! 259: case OP_ASSERT_NOT:
! 260: case OP_ASSERTBACK:
! 261: case OP_ASSERTBACK_NOT:
! 262: case OP_ONCE:
! 263: case OP_ONCE_NC:
! 264: case OP_COND:
! 265: case OP_SCOND:
! 266: case OP_REVERSE:
! 267: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
! 268: else fprintf(f, " ");
! 269: fprintf(f, "%s", OP_names[*code]);
! 270: break;
! 271:
! 272: case OP_CLOSE:
! 273: fprintf(f, " %s %d", OP_names[*code], GET2(code, 1));
! 274: break;
! 275:
! 276: case OP_CREF:
! 277: case OP_NCREF:
! 278: fprintf(f, "%3d %s", GET2(code,1), OP_names[*code]);
! 279: break;
! 280:
! 281: case OP_RREF:
! 282: c = GET2(code, 1);
! 283: if (c == RREF_ANY)
! 284: fprintf(f, " Cond recurse any");
! 285: else
! 286: fprintf(f, " Cond recurse %d", c);
! 287: break;
! 288:
! 289: case OP_NRREF:
! 290: c = GET2(code, 1);
! 291: if (c == RREF_ANY)
! 292: fprintf(f, " Cond nrecurse any");
! 293: else
! 294: fprintf(f, " Cond nrecurse %d", c);
! 295: break;
! 296:
! 297: case OP_DEF:
! 298: fprintf(f, " Cond def");
! 299: break;
! 300:
! 301: case OP_STARI:
! 302: case OP_MINSTARI:
! 303: case OP_POSSTARI:
! 304: case OP_PLUSI:
! 305: case OP_MINPLUSI:
! 306: case OP_POSPLUSI:
! 307: case OP_QUERYI:
! 308: case OP_MINQUERYI:
! 309: case OP_POSQUERYI:
! 310: flag = "/i";
! 311: /* Fall through */
! 312: case OP_STAR:
! 313: case OP_MINSTAR:
! 314: case OP_POSSTAR:
! 315: case OP_PLUS:
! 316: case OP_MINPLUS:
! 317: case OP_POSPLUS:
! 318: case OP_QUERY:
! 319: case OP_MINQUERY:
! 320: case OP_POSQUERY:
! 321: case OP_TYPESTAR:
! 322: case OP_TYPEMINSTAR:
! 323: case OP_TYPEPOSSTAR:
! 324: case OP_TYPEPLUS:
! 325: case OP_TYPEMINPLUS:
! 326: case OP_TYPEPOSPLUS:
! 327: case OP_TYPEQUERY:
! 328: case OP_TYPEMINQUERY:
! 329: case OP_TYPEPOSQUERY:
! 330: fprintf(f, " %s ", flag);
! 331: if (*code >= OP_TYPESTAR)
! 332: {
! 333: fprintf(f, "%s", OP_names[code[1]]);
! 334: if (code[1] == OP_PROP || code[1] == OP_NOTPROP)
! 335: {
! 336: fprintf(f, " %s ", get_ucpname(code[2], code[3]));
! 337: extra = 2;
! 338: }
! 339: }
! 340: else extra = print_char(f, code+1, utf8);
! 341: fprintf(f, "%s", OP_names[*code]);
! 342: break;
! 343:
! 344: case OP_EXACTI:
! 345: case OP_UPTOI:
! 346: case OP_MINUPTOI:
! 347: case OP_POSUPTOI:
! 348: flag = "/i";
! 349: /* Fall through */
! 350: case OP_EXACT:
! 351: case OP_UPTO:
! 352: case OP_MINUPTO:
! 353: case OP_POSUPTO:
! 354: fprintf(f, " %s ", flag);
! 355: extra = print_char(f, code+3, utf8);
! 356: fprintf(f, "{");
! 357: if (*code != OP_EXACT && *code != OP_EXACTI) fprintf(f, "0,");
! 358: fprintf(f, "%d}", GET2(code,1));
! 359: if (*code == OP_MINUPTO || *code == OP_MINUPTOI) fprintf(f, "?");
! 360: else if (*code == OP_POSUPTO || *code == OP_POSUPTOI) fprintf(f, "+");
! 361: break;
! 362:
! 363: case OP_TYPEEXACT:
! 364: case OP_TYPEUPTO:
! 365: case OP_TYPEMINUPTO:
! 366: case OP_TYPEPOSUPTO:
! 367: fprintf(f, " %s", OP_names[code[3]]);
! 368: if (code[3] == OP_PROP || code[3] == OP_NOTPROP)
! 369: {
! 370: fprintf(f, " %s ", get_ucpname(code[4], code[5]));
! 371: extra = 2;
! 372: }
! 373: fprintf(f, "{");
! 374: if (*code != OP_TYPEEXACT) fprintf(f, "0,");
! 375: fprintf(f, "%d}", GET2(code,1));
! 376: if (*code == OP_TYPEMINUPTO) fprintf(f, "?");
! 377: else if (*code == OP_TYPEPOSUPTO) fprintf(f, "+");
! 378: break;
! 379:
! 380: case OP_NOTI:
! 381: flag = "/i";
! 382: /* Fall through */
! 383: case OP_NOT:
! 384: c = code[1];
! 385: if (PRINTABLE(c)) fprintf(f, " %s [^%c]", flag, c);
! 386: else fprintf(f, " %s [^\\x%02x]", flag, c);
! 387: break;
! 388:
! 389: case OP_NOTSTARI:
! 390: case OP_NOTMINSTARI:
! 391: case OP_NOTPOSSTARI:
! 392: case OP_NOTPLUSI:
! 393: case OP_NOTMINPLUSI:
! 394: case OP_NOTPOSPLUSI:
! 395: case OP_NOTQUERYI:
! 396: case OP_NOTMINQUERYI:
! 397: case OP_NOTPOSQUERYI:
! 398: flag = "/i";
! 399: /* Fall through */
! 400:
! 401: case OP_NOTSTAR:
! 402: case OP_NOTMINSTAR:
! 403: case OP_NOTPOSSTAR:
! 404: case OP_NOTPLUS:
! 405: case OP_NOTMINPLUS:
! 406: case OP_NOTPOSPLUS:
! 407: case OP_NOTQUERY:
! 408: case OP_NOTMINQUERY:
! 409: case OP_NOTPOSQUERY:
! 410: c = code[1];
! 411: if (PRINTABLE(c)) fprintf(f, " %s [^%c]", flag, c);
! 412: else fprintf(f, " %s [^\\x%02x]", flag, c);
! 413: fprintf(f, "%s", OP_names[*code]);
! 414: break;
! 415:
! 416: case OP_NOTEXACTI:
! 417: case OP_NOTUPTOI:
! 418: case OP_NOTMINUPTOI:
! 419: case OP_NOTPOSUPTOI:
! 420: flag = "/i";
! 421: /* Fall through */
! 422:
! 423: case OP_NOTEXACT:
! 424: case OP_NOTUPTO:
! 425: case OP_NOTMINUPTO:
! 426: case OP_NOTPOSUPTO:
! 427: c = code[3];
! 428: if (PRINTABLE(c)) fprintf(f, " %s [^%c]{", flag, c);
! 429: else fprintf(f, " %s [^\\x%02x]{", flag, c);
! 430: if (*code != OP_NOTEXACT && *code != OP_NOTEXACTI) fprintf(f, "0,");
! 431: fprintf(f, "%d}", GET2(code,1));
! 432: if (*code == OP_NOTMINUPTO || *code == OP_NOTMINUPTOI) fprintf(f, "?");
! 433: else
! 434: if (*code == OP_NOTPOSUPTO || *code == OP_NOTPOSUPTOI) fprintf(f, "+");
! 435: break;
! 436:
! 437: case OP_RECURSE:
! 438: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
! 439: else fprintf(f, " ");
! 440: fprintf(f, "%s", OP_names[*code]);
! 441: break;
! 442:
! 443: case OP_REFI:
! 444: flag = "/i";
! 445: /* Fall through */
! 446: case OP_REF:
! 447: fprintf(f, " %s \\%d", flag, GET2(code,1));
! 448: ccode = code + _pcre_OP_lengths[*code];
! 449: goto CLASS_REF_REPEAT;
! 450:
! 451: case OP_CALLOUT:
! 452: fprintf(f, " %s %d %d %d", OP_names[*code], code[1], GET(code,2),
! 453: GET(code, 2 + LINK_SIZE));
! 454: break;
! 455:
! 456: case OP_PROP:
! 457: case OP_NOTPROP:
! 458: fprintf(f, " %s %s", OP_names[*code], get_ucpname(code[1], code[2]));
! 459: break;
! 460:
! 461: /* OP_XCLASS can only occur in UTF-8 mode. However, there's no harm in
! 462: having this code always here, and it makes it less messy without all those
! 463: #ifdefs. */
! 464:
! 465: case OP_CLASS:
! 466: case OP_NCLASS:
! 467: case OP_XCLASS:
! 468: {
! 469: int i, min, max;
! 470: BOOL printmap;
! 471:
! 472: fprintf(f, " [");
! 473:
! 474: if (*code == OP_XCLASS)
! 475: {
! 476: extra = GET(code, 1);
! 477: ccode = code + LINK_SIZE + 1;
! 478: printmap = (*ccode & XCL_MAP) != 0;
! 479: if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");
! 480: }
! 481: else
! 482: {
! 483: printmap = TRUE;
! 484: ccode = code + 1;
! 485: }
! 486:
! 487: /* Print a bit map */
! 488:
! 489: if (printmap)
! 490: {
! 491: for (i = 0; i < 256; i++)
! 492: {
! 493: if ((ccode[i/8] & (1 << (i&7))) != 0)
! 494: {
! 495: int j;
! 496: for (j = i+1; j < 256; j++)
! 497: if ((ccode[j/8] & (1 << (j&7))) == 0) break;
! 498: if (i == '-' || i == ']') fprintf(f, "\\");
! 499: if (PRINTABLE(i)) fprintf(f, "%c", i);
! 500: else fprintf(f, "\\x%02x", i);
! 501: if (--j > i)
! 502: {
! 503: if (j != i + 1) fprintf(f, "-");
! 504: if (j == '-' || j == ']') fprintf(f, "\\");
! 505: if (PRINTABLE(j)) fprintf(f, "%c", j);
! 506: else fprintf(f, "\\x%02x", j);
! 507: }
! 508: i = j;
! 509: }
! 510: }
! 511: ccode += 32;
! 512: }
! 513:
! 514: /* For an XCLASS there is always some additional data */
! 515:
! 516: if (*code == OP_XCLASS)
! 517: {
! 518: int ch;
! 519: while ((ch = *ccode++) != XCL_END)
! 520: {
! 521: if (ch == XCL_PROP)
! 522: {
! 523: int ptype = *ccode++;
! 524: int pvalue = *ccode++;
! 525: fprintf(f, "\\p{%s}", get_ucpname(ptype, pvalue));
! 526: }
! 527: else if (ch == XCL_NOTPROP)
! 528: {
! 529: int ptype = *ccode++;
! 530: int pvalue = *ccode++;
! 531: fprintf(f, "\\P{%s}", get_ucpname(ptype, pvalue));
! 532: }
! 533: else
! 534: {
! 535: ccode += 1 + print_char(f, ccode, TRUE);
! 536: if (ch == XCL_RANGE)
! 537: {
! 538: fprintf(f, "-");
! 539: ccode += 1 + print_char(f, ccode, TRUE);
! 540: }
! 541: }
! 542: }
! 543: }
! 544:
! 545: /* Indicate a non-UTF8 class which was created by negation */
! 546:
! 547: fprintf(f, "]%s", (*code == OP_NCLASS)? " (neg)" : "");
! 548:
! 549: /* Handle repeats after a class or a back reference */
! 550:
! 551: CLASS_REF_REPEAT:
! 552: switch(*ccode)
! 553: {
! 554: case OP_CRSTAR:
! 555: case OP_CRMINSTAR:
! 556: case OP_CRPLUS:
! 557: case OP_CRMINPLUS:
! 558: case OP_CRQUERY:
! 559: case OP_CRMINQUERY:
! 560: fprintf(f, "%s", OP_names[*ccode]);
! 561: extra += _pcre_OP_lengths[*ccode];
! 562: break;
! 563:
! 564: case OP_CRRANGE:
! 565: case OP_CRMINRANGE:
! 566: min = GET2(ccode,1);
! 567: max = GET2(ccode,3);
! 568: if (max == 0) fprintf(f, "{%d,}", min);
! 569: else fprintf(f, "{%d,%d}", min, max);
! 570: if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
! 571: extra += _pcre_OP_lengths[*ccode];
! 572: break;
! 573:
! 574: /* Do nothing if it's not a repeat; this code stops picky compilers
! 575: warning about the lack of a default code path. */
! 576:
! 577: default:
! 578: break;
! 579: }
! 580: }
! 581: break;
! 582:
! 583: case OP_MARK:
! 584: case OP_PRUNE_ARG:
! 585: case OP_SKIP_ARG:
! 586: fprintf(f, " %s %s", OP_names[*code], code + 2);
! 587: extra += code[1];
! 588: break;
! 589:
! 590: case OP_THEN:
! 591: fprintf(f, " %s", OP_names[*code]);
! 592: break;
! 593:
! 594: case OP_THEN_ARG:
! 595: fprintf(f, " %s %s", OP_names[*code], code + 2);
! 596: extra += code[1];
! 597: break;
! 598:
! 599: case OP_CIRCM:
! 600: case OP_DOLLM:
! 601: flag = "/m";
! 602: /* Fall through */
! 603:
! 604: /* Anything else is just an item with no data, but possibly a flag. */
! 605:
! 606: default:
! 607: fprintf(f, " %s %s", flag, OP_names[*code]);
! 608: break;
! 609: }
! 610:
! 611: code += _pcre_OP_lengths[*code] + extra;
! 612: fprintf(f, "\n");
! 613: }
! 614: }
! 615:
! 616: /* End of pcre_printint.src */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_printint.src CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre