release/src/router/pcre/pcre_printint.c

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