Annotation of embedaddon/pcre/pcre_printint.c, 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-2012 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. In this case PCRE_INCLUDED is defined.
! 48:
! 49: (2) It is also compiled separately and linked with pcretest.c, which can be
! 50: asked to print out a compiled regex for debugging purposes. */
! 51:
! 52: #ifndef PCRE_INCLUDED
! 53:
! 54: #ifdef HAVE_CONFIG_H
! 55: #include "config.h"
! 56: #endif
! 57:
! 58: /* For pcretest program. */
! 59: #define PRIV(name) name
! 60:
! 61: /* We have to include pcre_internal.h because we need the internal info for
! 62: displaying the results of pcre_study() and we also need to know about the
! 63: internal macros, structures, and other internal data values; pcretest has
! 64: "inside information" compared to a program that strictly follows the PCRE API.
! 65:
! 66: Although pcre_internal.h does itself include pcre.h, we explicitly include it
! 67: here before pcre_internal.h so that the PCRE_EXP_xxx macros get set
! 68: appropriately for an application, not for building PCRE. */
! 69:
! 70: #include "pcre.h"
! 71: #include "pcre_internal.h"
! 72:
! 73: /* These are the funtions that are contained within. It doesn't seem worth
! 74: having a separate .h file just for this. */
! 75:
! 76: #endif /* PCRE_INCLUDED */
! 77:
! 78: #ifdef PCRE_INCLUDED
! 79: static /* Keep the following function as private. */
! 80: #endif
! 81: #ifdef COMPILE_PCRE8
! 82: void pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths);
! 83: #else
! 84: void pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths);
! 85: #endif
! 86:
! 87: /* Macro that decides whether a character should be output as a literal or in
! 88: hexadecimal. We don't use isprint() because that can vary from system to system
! 89: (even without the use of locales) and we want the output always to be the same,
! 90: for testing purposes. */
! 91:
! 92: #ifdef EBCDIC
! 93: #define PRINTABLE(c) ((c) >= 64 && (c) < 255)
! 94: #else
! 95: #define PRINTABLE(c) ((c) >= 32 && (c) < 127)
! 96: #endif
! 97:
! 98: /* The table of operator names. */
! 99:
! 100: static const char *priv_OP_names[] = { OP_NAME_LIST };
! 101:
! 102: /* This table of operator lengths is not actually used by the working code,
! 103: but its size is needed for a check that ensures it is the correct size for the
! 104: number of opcodes (thus catching update omissions). */
! 105:
! 106: static const pcre_uint8 priv_OP_lengths[] = { OP_LENGTHS };
! 107:
! 108:
! 109:
! 110: /*************************************************
! 111: * Print single- or multi-byte character *
! 112: *************************************************/
! 113:
! 114: static int
! 115: print_char(FILE *f, pcre_uchar *ptr, BOOL utf)
! 116: {
! 117: int c = *ptr;
! 118:
! 119: #ifndef SUPPORT_UTF
! 120:
! 121: (void)utf; /* Avoid compiler warning */
! 122: if (PRINTABLE(c)) fprintf(f, "%c", c);
! 123: else if (c <= 0xff) fprintf(f, "\\x%02x", c);
! 124: else fprintf(f, "\\x{%x}", c);
! 125: return 0;
! 126:
! 127: #else
! 128:
! 129: #ifdef COMPILE_PCRE8
! 130:
! 131: if (!utf || (c & 0xc0) != 0xc0)
! 132: {
! 133: if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
! 134: return 0;
! 135: }
! 136: else
! 137: {
! 138: int i;
! 139: int a = PRIV(utf8_table4)[c & 0x3f]; /* Number of additional bytes */
! 140: int s = 6*a;
! 141: c = (c & PRIV(utf8_table3)[a]) << s;
! 142: for (i = 1; i <= a; i++)
! 143: {
! 144: /* This is a check for malformed UTF-8; it should only occur if the sanity
! 145: check has been turned off. Rather than swallow random bytes, just stop if
! 146: we hit a bad one. Print it with \X instead of \x as an indication. */
! 147:
! 148: if ((ptr[i] & 0xc0) != 0x80)
! 149: {
! 150: fprintf(f, "\\X{%x}", c);
! 151: return i - 1;
! 152: }
! 153:
! 154: /* The byte is OK */
! 155:
! 156: s -= 6;
! 157: c |= (ptr[i] & 0x3f) << s;
! 158: }
! 159: fprintf(f, "\\x{%x}", c);
! 160: return a;
! 161: }
! 162:
! 163: #else
! 164:
! 165: #ifdef COMPILE_PCRE16
! 166:
! 167: if (!utf || (c & 0xfc00) != 0xd800)
! 168: {
! 169: if (PRINTABLE(c)) fprintf(f, "%c", c);
! 170: else if (c <= 0xff) fprintf(f, "\\x%02x", c);
! 171: else fprintf(f, "\\x{%x}", c);
! 172: return 0;
! 173: }
! 174: else
! 175: {
! 176: /* This is a check for malformed UTF-16; it should only occur if the sanity
! 177: check has been turned off. Rather than swallow a low surrogate, just stop if
! 178: we hit a bad one. Print it with \X instead of \x as an indication. */
! 179:
! 180: if ((ptr[1] & 0xfc00) != 0xdc00)
! 181: {
! 182: fprintf(f, "\\X{%x}", c);
! 183: return 0;
! 184: }
! 185:
! 186: c = (((c & 0x3ff) << 10) | (ptr[1] & 0x3ff)) + 0x10000;
! 187: fprintf(f, "\\x{%x}", c);
! 188: return 1;
! 189: }
! 190:
! 191: #endif /* COMPILE_PCRE16 */
! 192:
! 193: #endif /* COMPILE_PCRE8 */
! 194:
! 195: #endif /* SUPPORT_UTF */
! 196: }
! 197:
! 198: /*************************************************
! 199: * Print uchar string (regardless of utf) *
! 200: *************************************************/
! 201:
! 202: static void
! 203: print_puchar(FILE *f, PCRE_PUCHAR ptr)
! 204: {
! 205: while (*ptr != '\0')
! 206: {
! 207: register int c = *ptr++;
! 208: if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x{%x}", c);
! 209: }
! 210: }
! 211:
! 212: /*************************************************
! 213: * Find Unicode property name *
! 214: *************************************************/
! 215:
! 216: static const char *
! 217: get_ucpname(int ptype, int pvalue)
! 218: {
! 219: #ifdef SUPPORT_UCP
! 220: int i;
! 221: for (i = PRIV(utt_size) - 1; i >= 0; i--)
! 222: {
! 223: if (ptype == PRIV(utt)[i].type && pvalue == PRIV(utt)[i].value) break;
! 224: }
! 225: return (i >= 0)? PRIV(utt_names) + PRIV(utt)[i].name_offset : "??";
! 226: #else
! 227: /* It gets harder and harder to shut off unwanted compiler warnings. */
! 228: ptype = ptype * pvalue;
! 229: return (ptype == pvalue)? "??" : "??";
! 230: #endif
! 231: }
! 232:
! 233:
! 234:
! 235: /*************************************************
! 236: * Print compiled regex *
! 237: *************************************************/
! 238:
! 239: /* Make this function work for a regex with integers either byte order.
! 240: However, we assume that what we are passed is a compiled regex. The
! 241: print_lengths flag controls whether offsets and lengths of items are printed.
! 242: They can be turned off from pcretest so that automatic tests on bytecode can be
! 243: written that do not depend on the value of LINK_SIZE. */
! 244:
! 245: #ifdef PCRE_INCLUDED
! 246: static /* Keep the following function as private. */
! 247: #endif
! 248: #ifdef COMPILE_PCRE8
! 249: void
! 250: pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths)
! 251: #else
! 252: void
! 253: pcre16_printint(pcre *external_re, FILE *f, BOOL print_lengths)
! 254: #endif
! 255: {
! 256: REAL_PCRE *re = (REAL_PCRE *)external_re;
! 257: pcre_uchar *codestart, *code;
! 258: BOOL utf;
! 259:
! 260: unsigned int options = re->options;
! 261: int offset = re->name_table_offset;
! 262: int count = re->name_count;
! 263: int size = re->name_entry_size;
! 264:
! 265: if (re->magic_number != MAGIC_NUMBER)
! 266: {
! 267: offset = ((offset << 8) & 0xff00) | ((offset >> 8) & 0xff);
! 268: count = ((count << 8) & 0xff00) | ((count >> 8) & 0xff);
! 269: size = ((size << 8) & 0xff00) | ((size >> 8) & 0xff);
! 270: options = ((options << 24) & 0xff000000) |
! 271: ((options << 8) & 0x00ff0000) |
! 272: ((options >> 8) & 0x0000ff00) |
! 273: ((options >> 24) & 0x000000ff);
! 274: }
! 275:
! 276: code = codestart = (pcre_uchar *)re + offset + count * size;
! 277: /* PCRE_UTF16 has the same value as PCRE_UTF8. */
! 278: utf = (options & PCRE_UTF8) != 0;
! 279:
! 280: for(;;)
! 281: {
! 282: pcre_uchar *ccode;
! 283: const char *flag = " ";
! 284: int c;
! 285: int extra = 0;
! 286:
! 287: if (print_lengths)
! 288: fprintf(f, "%3d ", (int)(code - codestart));
! 289: else
! 290: fprintf(f, " ");
! 291:
! 292: switch(*code)
! 293: {
! 294: /* ========================================================================== */
! 295: /* These cases are never obeyed. This is a fudge that causes a compile-
! 296: time error if the vectors OP_names or OP_lengths, which are indexed
! 297: by opcode, are not the correct length. It seems to be the only way to do
! 298: such a check at compile time, as the sizeof() operator does not work in
! 299: the C preprocessor. */
! 300:
! 301: case OP_TABLE_LENGTH:
! 302: case OP_TABLE_LENGTH +
! 303: ((sizeof(priv_OP_names)/sizeof(const char *) == OP_TABLE_LENGTH) &&
! 304: (sizeof(priv_OP_lengths) == OP_TABLE_LENGTH)):
! 305: break;
! 306: /* ========================================================================== */
! 307:
! 308: case OP_END:
! 309: fprintf(f, " %s\n", priv_OP_names[*code]);
! 310: fprintf(f, "------------------------------------------------------------------\n");
! 311: return;
! 312:
! 313: case OP_CHAR:
! 314: fprintf(f, " ");
! 315: do
! 316: {
! 317: code++;
! 318: code += 1 + print_char(f, code, utf);
! 319: }
! 320: while (*code == OP_CHAR);
! 321: fprintf(f, "\n");
! 322: continue;
! 323:
! 324: case OP_CHARI:
! 325: fprintf(f, " /i ");
! 326: do
! 327: {
! 328: code++;
! 329: code += 1 + print_char(f, code, utf);
! 330: }
! 331: while (*code == OP_CHARI);
! 332: fprintf(f, "\n");
! 333: continue;
! 334:
! 335: case OP_CBRA:
! 336: case OP_CBRAPOS:
! 337: case OP_SCBRA:
! 338: case OP_SCBRAPOS:
! 339: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
! 340: else fprintf(f, " ");
! 341: fprintf(f, "%s %d", priv_OP_names[*code], GET2(code, 1+LINK_SIZE));
! 342: break;
! 343:
! 344: case OP_BRA:
! 345: case OP_BRAPOS:
! 346: case OP_SBRA:
! 347: case OP_SBRAPOS:
! 348: case OP_KETRMAX:
! 349: case OP_KETRMIN:
! 350: case OP_KETRPOS:
! 351: case OP_ALT:
! 352: case OP_KET:
! 353: case OP_ASSERT:
! 354: case OP_ASSERT_NOT:
! 355: case OP_ASSERTBACK:
! 356: case OP_ASSERTBACK_NOT:
! 357: case OP_ONCE:
! 358: case OP_ONCE_NC:
! 359: case OP_COND:
! 360: case OP_SCOND:
! 361: case OP_REVERSE:
! 362: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
! 363: else fprintf(f, " ");
! 364: fprintf(f, "%s", priv_OP_names[*code]);
! 365: break;
! 366:
! 367: case OP_CLOSE:
! 368: fprintf(f, " %s %d", priv_OP_names[*code], GET2(code, 1));
! 369: break;
! 370:
! 371: case OP_CREF:
! 372: case OP_NCREF:
! 373: fprintf(f, "%3d %s", GET2(code,1), priv_OP_names[*code]);
! 374: break;
! 375:
! 376: case OP_RREF:
! 377: c = GET2(code, 1);
! 378: if (c == RREF_ANY)
! 379: fprintf(f, " Cond recurse any");
! 380: else
! 381: fprintf(f, " Cond recurse %d", c);
! 382: break;
! 383:
! 384: case OP_NRREF:
! 385: c = GET2(code, 1);
! 386: if (c == RREF_ANY)
! 387: fprintf(f, " Cond nrecurse any");
! 388: else
! 389: fprintf(f, " Cond nrecurse %d", c);
! 390: break;
! 391:
! 392: case OP_DEF:
! 393: fprintf(f, " Cond def");
! 394: break;
! 395:
! 396: case OP_STARI:
! 397: case OP_MINSTARI:
! 398: case OP_POSSTARI:
! 399: case OP_PLUSI:
! 400: case OP_MINPLUSI:
! 401: case OP_POSPLUSI:
! 402: case OP_QUERYI:
! 403: case OP_MINQUERYI:
! 404: case OP_POSQUERYI:
! 405: flag = "/i";
! 406: /* Fall through */
! 407: case OP_STAR:
! 408: case OP_MINSTAR:
! 409: case OP_POSSTAR:
! 410: case OP_PLUS:
! 411: case OP_MINPLUS:
! 412: case OP_POSPLUS:
! 413: case OP_QUERY:
! 414: case OP_MINQUERY:
! 415: case OP_POSQUERY:
! 416: case OP_TYPESTAR:
! 417: case OP_TYPEMINSTAR:
! 418: case OP_TYPEPOSSTAR:
! 419: case OP_TYPEPLUS:
! 420: case OP_TYPEMINPLUS:
! 421: case OP_TYPEPOSPLUS:
! 422: case OP_TYPEQUERY:
! 423: case OP_TYPEMINQUERY:
! 424: case OP_TYPEPOSQUERY:
! 425: fprintf(f, " %s ", flag);
! 426: if (*code >= OP_TYPESTAR)
! 427: {
! 428: fprintf(f, "%s", priv_OP_names[code[1]]);
! 429: if (code[1] == OP_PROP || code[1] == OP_NOTPROP)
! 430: {
! 431: fprintf(f, " %s ", get_ucpname(code[2], code[3]));
! 432: extra = 2;
! 433: }
! 434: }
! 435: else extra = print_char(f, code+1, utf);
! 436: fprintf(f, "%s", priv_OP_names[*code]);
! 437: break;
! 438:
! 439: case OP_EXACTI:
! 440: case OP_UPTOI:
! 441: case OP_MINUPTOI:
! 442: case OP_POSUPTOI:
! 443: flag = "/i";
! 444: /* Fall through */
! 445: case OP_EXACT:
! 446: case OP_UPTO:
! 447: case OP_MINUPTO:
! 448: case OP_POSUPTO:
! 449: fprintf(f, " %s ", flag);
! 450: extra = print_char(f, code + 1 + IMM2_SIZE, utf);
! 451: fprintf(f, "{");
! 452: if (*code != OP_EXACT && *code != OP_EXACTI) fprintf(f, "0,");
! 453: fprintf(f, "%d}", GET2(code,1));
! 454: if (*code == OP_MINUPTO || *code == OP_MINUPTOI) fprintf(f, "?");
! 455: else if (*code == OP_POSUPTO || *code == OP_POSUPTOI) fprintf(f, "+");
! 456: break;
! 457:
! 458: case OP_TYPEEXACT:
! 459: case OP_TYPEUPTO:
! 460: case OP_TYPEMINUPTO:
! 461: case OP_TYPEPOSUPTO:
! 462: fprintf(f, " %s", priv_OP_names[code[1 + IMM2_SIZE]]);
! 463: if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
! 464: {
! 465: fprintf(f, " %s ", get_ucpname(code[1 + IMM2_SIZE + 1],
! 466: code[1 + IMM2_SIZE + 2]));
! 467: extra = 2;
! 468: }
! 469: fprintf(f, "{");
! 470: if (*code != OP_TYPEEXACT) fprintf(f, "0,");
! 471: fprintf(f, "%d}", GET2(code,1));
! 472: if (*code == OP_TYPEMINUPTO) fprintf(f, "?");
! 473: else if (*code == OP_TYPEPOSUPTO) fprintf(f, "+");
! 474: break;
! 475:
! 476: case OP_NOTI:
! 477: flag = "/i";
! 478: /* Fall through */
! 479: case OP_NOT:
! 480: c = code[1];
! 481: if (PRINTABLE(c)) fprintf(f, " %s [^%c]", flag, c);
! 482: else if (utf || c > 0xff)
! 483: fprintf(f, " %s [^\\x{%02x}]", flag, c);
! 484: else
! 485: fprintf(f, " %s [^\\x%02x]", flag, c);
! 486: break;
! 487:
! 488: case OP_NOTSTARI:
! 489: case OP_NOTMINSTARI:
! 490: case OP_NOTPOSSTARI:
! 491: case OP_NOTPLUSI:
! 492: case OP_NOTMINPLUSI:
! 493: case OP_NOTPOSPLUSI:
! 494: case OP_NOTQUERYI:
! 495: case OP_NOTMINQUERYI:
! 496: case OP_NOTPOSQUERYI:
! 497: flag = "/i";
! 498: /* Fall through */
! 499:
! 500: case OP_NOTSTAR:
! 501: case OP_NOTMINSTAR:
! 502: case OP_NOTPOSSTAR:
! 503: case OP_NOTPLUS:
! 504: case OP_NOTMINPLUS:
! 505: case OP_NOTPOSPLUS:
! 506: case OP_NOTQUERY:
! 507: case OP_NOTMINQUERY:
! 508: case OP_NOTPOSQUERY:
! 509: c = code[1];
! 510: if (PRINTABLE(c)) fprintf(f, " %s [^%c]", flag, c);
! 511: else fprintf(f, " %s [^\\x%02x]", flag, c);
! 512: fprintf(f, "%s", priv_OP_names[*code]);
! 513: break;
! 514:
! 515: case OP_NOTEXACTI:
! 516: case OP_NOTUPTOI:
! 517: case OP_NOTMINUPTOI:
! 518: case OP_NOTPOSUPTOI:
! 519: flag = "/i";
! 520: /* Fall through */
! 521:
! 522: case OP_NOTEXACT:
! 523: case OP_NOTUPTO:
! 524: case OP_NOTMINUPTO:
! 525: case OP_NOTPOSUPTO:
! 526: c = code[1 + IMM2_SIZE];
! 527: if (PRINTABLE(c)) fprintf(f, " %s [^%c]{", flag, c);
! 528: else fprintf(f, " %s [^\\x%02x]{", flag, c);
! 529: if (*code != OP_NOTEXACT && *code != OP_NOTEXACTI) fprintf(f, "0,");
! 530: fprintf(f, "%d}", GET2(code,1));
! 531: if (*code == OP_NOTMINUPTO || *code == OP_NOTMINUPTOI) fprintf(f, "?");
! 532: else
! 533: if (*code == OP_NOTPOSUPTO || *code == OP_NOTPOSUPTOI) fprintf(f, "+");
! 534: break;
! 535:
! 536: case OP_RECURSE:
! 537: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
! 538: else fprintf(f, " ");
! 539: fprintf(f, "%s", priv_OP_names[*code]);
! 540: break;
! 541:
! 542: case OP_REFI:
! 543: flag = "/i";
! 544: /* Fall through */
! 545: case OP_REF:
! 546: fprintf(f, " %s \\%d", flag, GET2(code,1));
! 547: ccode = code + priv_OP_lengths[*code];
! 548: goto CLASS_REF_REPEAT;
! 549:
! 550: case OP_CALLOUT:
! 551: fprintf(f, " %s %d %d %d", priv_OP_names[*code], code[1], GET(code,2),
! 552: GET(code, 2 + LINK_SIZE));
! 553: break;
! 554:
! 555: case OP_PROP:
! 556: case OP_NOTPROP:
! 557: fprintf(f, " %s %s", priv_OP_names[*code], get_ucpname(code[1], code[2]));
! 558: break;
! 559:
! 560: /* OP_XCLASS can only occur in UTF or PCRE16 modes. However, there's no
! 561: harm in having this code always here, and it makes it less messy without
! 562: all those #ifdefs. */
! 563:
! 564: case OP_CLASS:
! 565: case OP_NCLASS:
! 566: case OP_XCLASS:
! 567: {
! 568: int i, min, max;
! 569: BOOL printmap;
! 570: pcre_uint8 *map;
! 571:
! 572: fprintf(f, " [");
! 573:
! 574: if (*code == OP_XCLASS)
! 575: {
! 576: extra = GET(code, 1);
! 577: ccode = code + LINK_SIZE + 1;
! 578: printmap = (*ccode & XCL_MAP) != 0;
! 579: if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");
! 580: }
! 581: else
! 582: {
! 583: printmap = TRUE;
! 584: ccode = code + 1;
! 585: }
! 586:
! 587: /* Print a bit map */
! 588:
! 589: if (printmap)
! 590: {
! 591: map = (pcre_uint8 *)ccode;
! 592: for (i = 0; i < 256; i++)
! 593: {
! 594: if ((map[i/8] & (1 << (i&7))) != 0)
! 595: {
! 596: int j;
! 597: for (j = i+1; j < 256; j++)
! 598: if ((map[j/8] & (1 << (j&7))) == 0) break;
! 599: if (i == '-' || i == ']') fprintf(f, "\\");
! 600: if (PRINTABLE(i)) fprintf(f, "%c", i);
! 601: else fprintf(f, "\\x%02x", i);
! 602: if (--j > i)
! 603: {
! 604: if (j != i + 1) fprintf(f, "-");
! 605: if (j == '-' || j == ']') fprintf(f, "\\");
! 606: if (PRINTABLE(j)) fprintf(f, "%c", j);
! 607: else fprintf(f, "\\x%02x", j);
! 608: }
! 609: i = j;
! 610: }
! 611: }
! 612: ccode += 32 / sizeof(pcre_uchar);
! 613: }
! 614:
! 615: /* For an XCLASS there is always some additional data */
! 616:
! 617: if (*code == OP_XCLASS)
! 618: {
! 619: int ch;
! 620: while ((ch = *ccode++) != XCL_END)
! 621: {
! 622: if (ch == XCL_PROP)
! 623: {
! 624: int ptype = *ccode++;
! 625: int pvalue = *ccode++;
! 626: fprintf(f, "\\p{%s}", get_ucpname(ptype, pvalue));
! 627: }
! 628: else if (ch == XCL_NOTPROP)
! 629: {
! 630: int ptype = *ccode++;
! 631: int pvalue = *ccode++;
! 632: fprintf(f, "\\P{%s}", get_ucpname(ptype, pvalue));
! 633: }
! 634: else
! 635: {
! 636: ccode += 1 + print_char(f, ccode, utf);
! 637: if (ch == XCL_RANGE)
! 638: {
! 639: fprintf(f, "-");
! 640: ccode += 1 + print_char(f, ccode, utf);
! 641: }
! 642: }
! 643: }
! 644: }
! 645:
! 646: /* Indicate a non-UTF class which was created by negation */
! 647:
! 648: fprintf(f, "]%s", (*code == OP_NCLASS)? " (neg)" : "");
! 649:
! 650: /* Handle repeats after a class or a back reference */
! 651:
! 652: CLASS_REF_REPEAT:
! 653: switch(*ccode)
! 654: {
! 655: case OP_CRSTAR:
! 656: case OP_CRMINSTAR:
! 657: case OP_CRPLUS:
! 658: case OP_CRMINPLUS:
! 659: case OP_CRQUERY:
! 660: case OP_CRMINQUERY:
! 661: fprintf(f, "%s", priv_OP_names[*ccode]);
! 662: extra += priv_OP_lengths[*ccode];
! 663: break;
! 664:
! 665: case OP_CRRANGE:
! 666: case OP_CRMINRANGE:
! 667: min = GET2(ccode,1);
! 668: max = GET2(ccode,1 + IMM2_SIZE);
! 669: if (max == 0) fprintf(f, "{%d,}", min);
! 670: else fprintf(f, "{%d,%d}", min, max);
! 671: if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
! 672: extra += priv_OP_lengths[*ccode];
! 673: break;
! 674:
! 675: /* Do nothing if it's not a repeat; this code stops picky compilers
! 676: warning about the lack of a default code path. */
! 677:
! 678: default:
! 679: break;
! 680: }
! 681: }
! 682: break;
! 683:
! 684: case OP_MARK:
! 685: case OP_PRUNE_ARG:
! 686: case OP_SKIP_ARG:
! 687: case OP_THEN_ARG:
! 688: fprintf(f, " %s ", priv_OP_names[*code]);
! 689: print_puchar(f, code + 2);
! 690: extra += code[1];
! 691: break;
! 692:
! 693: case OP_THEN:
! 694: fprintf(f, " %s", priv_OP_names[*code]);
! 695: break;
! 696:
! 697: case OP_CIRCM:
! 698: case OP_DOLLM:
! 699: flag = "/m";
! 700: /* Fall through */
! 701:
! 702: /* Anything else is just an item with no data, but possibly a flag. */
! 703:
! 704: default:
! 705: fprintf(f, " %s %s", flag, priv_OP_names[*code]);
! 706: break;
! 707: }
! 708:
! 709: code += priv_OP_lengths[*code] + extra;
! 710: fprintf(f, "\n");
! 711: }
! 712: }
! 713:
! 714: /* End of pcre_printint.src */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_printint.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / pcre