src/external/pcre2-10.32/src/pcre2_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      Original API code Copyright (c) 1997-2012 University of Cambridge
  10           New API code Copyright (c) 2016-2018 University of Cambridge
  11
  12 -----------------------------------------------------------------------------
  13 Redistribution and use in source and binary forms, with or without
  14 modification, are permitted provided that the following conditions are met:
  15
  16     * Redistributions of source code must retain the above copyright notice,
  17       this list of conditions and the following disclaimer.
  18
  19     * Redistributions in binary form must reproduce the above copyright
  20       notice, this list of conditions and the following disclaimer in the
  21       documentation and/or other materials provided with the distribution.
  22
  23     * Neither the name of the University of Cambridge nor the names of its
  24       contributors may be used to endorse or promote products derived from
  25       this software without specific prior written permission.
  26
  27 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  28 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  29 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  30 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  31 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  34 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  35 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  36 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  37 POSSIBILITY OF SUCH DAMAGE.
  38 -----------------------------------------------------------------------------
  39 */
  40
  41
  42 /* This module contains a PCRE private debugging function for printing out the
  43 internal form of a compiled regular expression, along with some supporting
  44 local functions. This source file is #included in pcre2test.c at each supported
  45 code unit width, with PCRE2_SUFFIX set appropriately, just like the functions
  46 that comprise the library. It can also optionally be included in
  47 pcre2_compile.c for detailed debugging in error situations. */
  48
  49
  50 /* Tables of operator names. The same 8-bit table is used for all code unit
  51 widths, so it must be defined only once. The list itself is defined in
  52 pcre2_internal.h, which is #included by pcre2test before this file. */
  53
  54 #ifndef OP_LISTS_DEFINED
  55 static const char *OP_names[] = { OP_NAME_LIST };
  56 #define OP_LISTS_DEFINED
  57 #endif
  58
  59 /* The functions and tables herein must all have mode-dependent names. */
  60
  61 #define OP_lengths            PCRE2_SUFFIX(OP_lengths_)
  62 #define get_ucpname           PCRE2_SUFFIX(get_ucpname_)
  63 #define pcre2_printint        PCRE2_SUFFIX(pcre2_printint_)
  64 #define print_char            PCRE2_SUFFIX(print_char_)
  65 #define print_custring        PCRE2_SUFFIX(print_custring_)
  66 #define print_custring_bylen  PCRE2_SUFFIX(print_custring_bylen_)
  67 #define print_prop            PCRE2_SUFFIX(print_prop_)
  68
  69 /* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
  70 the definition is next to the definition of the opcodes in pcre2_internal.h.
  71 The contents of the table are, however, mode-dependent. */
  72
  73 static const uint8_t OP_lengths[] = { OP_LENGTHS };
  74
  75
  76
  77 /*************************************************
  78 *       Print one character from a string        *
  79 *************************************************/
  80
  81 /* In UTF mode the character may occupy more than one code unit.
  82
  83 Arguments:
  84   f           file to write to
  85   ptr         pointer to first code unit of the character
  86   utf         TRUE if string is UTF (will be FALSE if UTF is not supported)
  87
  88 Returns:      number of additional code units used
  89 */
  90
  91 static unsigned int
  92 print_char(FILE *f, PCRE2_SPTR ptr, BOOL utf)
  93 {
  94 uint32_t c = *ptr;
  95 BOOL one_code_unit = !utf;
  96
  97 /* If UTF is supported and requested, check for a valid single code unit. */
  98
  99 #ifdef SUPPORT_UNICODE
 100 if (utf)
 101   {
 102 #if PCRE2_CODE_UNIT_WIDTH == 8
 103   one_code_unit = c < 0x80;
 104 #elif PCRE2_CODE_UNIT_WIDTH == 16
 105   one_code_unit = (c & 0xfc00) != 0xd800;
 106 #else
 107   one_code_unit = (c & 0xfffff800u) != 0xd800u;
 108 #endif  /* CODE_UNIT_WIDTH */
 109   }
 110 #endif  /* SUPPORT_UNICODE */
 111
 112 /* Handle a valid one-code-unit character at any width. */
 113
 114 if (one_code_unit)
 115   {
 116   if (PRINTABLE(c)) fprintf(f, "%c", (char)c);
 117   else if (c < 0x80) fprintf(f, "\\x%02x", c);
 118   else fprintf(f, "\\x{%02x}", c);
 119   return 0;
 120   }
 121
 122 /* Code for invalid UTF code units and multi-unit UTF characters is different
 123 for each width. If UTF is not supported, control should never get here, but we
 124 need a return statement to keep the compiler happy. */
 125
 126 #ifndef SUPPORT_UNICODE
 127 return 0;
 128 #else
 129
 130 /* Malformed UTF-8 should occur only if the sanity check has been turned off.
 131 Rather than swallow random bytes, just stop if we hit a bad one. Print it with
 132 \X instead of \x as an indication. */
 133
 134 #if PCRE2_CODE_UNIT_WIDTH == 8
 135 if ((c & 0xc0) != 0xc0)
 136   {
 137   fprintf(f, "\\X{%x}", c);       /* Invalid starting byte */
 138   return 0;
 139   }
 140 else
 141   {
 142   int i;
 143   int a = PRIV(utf8_table4)[c & 0x3f];  /* Number of additional bytes */
 144   int s = 6*a;
 145   c = (c & PRIV(utf8_table3)[a]) << s;
 146   for (i = 1; i <= a; i++)
 147     {
 148     if ((ptr[i] & 0xc0) != 0x80)
 149       {
 150       fprintf(f, "\\X{%x}", c);   /* Invalid secondary byte */
 151       return i - 1;
 152       }
 153     s -= 6;
 154     c |= (ptr[i] & 0x3f) << s;
 155     }
 156   fprintf(f, "\\x{%x}", c);
 157   return a;
 158 }
 159 #endif  /* PCRE2_CODE_UNIT_WIDTH == 8 */
 160
 161 /* UTF-16: rather than swallow a low surrogate, just stop if we hit a bad one.
 162 Print it with \X instead of \x as an indication. */
 163
 164 #if PCRE2_CODE_UNIT_WIDTH == 16
 165 if ((ptr[1] & 0xfc00) != 0xdc00)
 166   {
 167   fprintf(f, "\\X{%x}", c);
 168   return 0;
 169   }
 170 c = (((c & 0x3ff) << 10) | (ptr[1] & 0x3ff)) + 0x10000;
 171 fprintf(f, "\\x{%x}", c);
 172 return 1;
 173 #endif  /* PCRE2_CODE_UNIT_WIDTH == 16 */
 174
 175 /* For UTF-32 we get here only for a malformed code unit, which should only
 176 occur if the sanity check has been turned off. Print it with \X instead of \x
 177 as an indication. */
 178
 179 #if PCRE2_CODE_UNIT_WIDTH == 32
 180 fprintf(f, "\\X{%x}", c);
 181 return 0;
 182 #endif  /* PCRE2_CODE_UNIT_WIDTH == 32 */
 183 #endif  /* SUPPORT_UNICODE */
 184 }
 185
 186
 187
 188 /*************************************************
 189 *     Print string as a list of code units       *
 190 *************************************************/
 191
 192 /* These take no account of UTF as they always print each individual code unit.
 193 The string is zero-terminated for print_custring(); the length is given for
 194 print_custring_bylen().
 195
 196 Arguments:
 197   f          file to write to
 198   ptr        point to the string
 199   len        length for print_custring_bylen()
 200
 201 Returns:     nothing
 202 */
 203
 204 static void
 205 print_custring(FILE *f, PCRE2_SPTR ptr)
 206 {
 207 while (*ptr != '\0')
 208   {
 209   uint32_t c = *ptr++;
 210   if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x{%x}", c);
 211   }
 212 }
 213
 214 static void
 215 print_custring_bylen(FILE *f, PCRE2_SPTR ptr, PCRE2_UCHAR len)
 216 {
 217 for (; len > 0; len--)
 218   {
 219   uint32_t c = *ptr++;
 220   if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x{%x}", c);
 221   }
 222 }
 223
 224
 225
 226 /*************************************************
 227 *          Find Unicode property name            *
 228 *************************************************/
 229
 230 /* When there is no UTF/UCP support, the table of names does not exist. This
 231 function should not be called in such configurations, because a pattern that
 232 tries to use Unicode properties won't compile. Rather than put lots of #ifdefs
 233 into the main code, however, we just put one into this function. */
 234
 235 static const char *
 236 get_ucpname(unsigned int ptype, unsigned int pvalue)
 237 {
 238 #ifdef SUPPORT_UNICODE
 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   /* No UTF support */
 246 (void)ptype;
 247 (void)pvalue;
 248 return "??";
 249 #endif  /* SUPPORT_UNICODE */
 250 }
 251
 252
 253
 254 /*************************************************
 255 *       Print Unicode property value             *
 256 *************************************************/
 257
 258 /* "Normal" properties can be printed from tables. The PT_CLIST property is a
 259 pseudo-property that contains a pointer to a list of case-equivalent
 260 characters.
 261
 262 Arguments:
 263   f            file to write to
 264   code         pointer in the compiled code
 265   before       text to print before
 266   after        text to print after
 267
 268 Returns:       nothing
 269 */
 270
 271 static void
 272 print_prop(FILE *f, PCRE2_SPTR code, const char *before, const char *after)
 273 {
 274 if (code[1] != PT_CLIST)
 275   {
 276   fprintf(f, "%s%s %s%s", before, OP_names[*code], get_ucpname(code[1],
 277     code[2]), after);
 278   }
 279 else
 280   {
 281   const char *not = (*code == OP_PROP)? "" : "not ";
 282   const uint32_t *p = PRIV(ucd_caseless_sets) + code[2];
 283   fprintf (f, "%s%sclist", before, not);
 284   while (*p < NOTACHAR) fprintf(f, " %04x", *p++);
 285   fprintf(f, "%s", after);
 286   }
 287 }
 288
 289
 290
 291 /*************************************************
 292 *            Print compiled pattern              *
 293 *************************************************/
 294
 295 /* The print_lengths flag controls whether offsets and lengths of items are
 296 printed. Lenths can be turned off from pcre2test so that automatic tests on
 297 bytecode can be written that do not depend on the value of LINK_SIZE.
 298
 299 Arguments:
 300   re              a compiled pattern
 301   f               the file to write to
 302   print_lengths   show various lengths
 303
 304 Returns:          nothing
 305 */
 306
 307 static void
 308 pcre2_printint(pcre2_code *re, FILE *f, BOOL print_lengths)
 309 {
 310 PCRE2_SPTR codestart, nametable, code;
 311 uint32_t nesize = re->name_entry_size;
 312 BOOL utf = (re->overall_options & PCRE2_UTF) != 0;
 313
 314 nametable = (PCRE2_SPTR)((uint8_t *)re + sizeof(pcre2_real_code));
 315 code = codestart = nametable + re->name_count * re->name_entry_size;
 316
 317 for(;;)
 318   {
 319   PCRE2_SPTR ccode;
 320   uint32_t c;
 321   int i;
 322   const char *flag = "  ";
 323   unsigned int extra = 0;
 324
 325   if (print_lengths)
 326     fprintf(f, "%3d ", (int)(code - codestart));
 327   else
 328     fprintf(f, "    ");
 329
 330   switch(*code)
 331     {
 332 /* ========================================================================== */
 333       /* These cases are never obeyed. This is a fudge that causes a compile-
 334       time error if the vectors OP_names or OP_lengths, which are indexed
 335       by opcode, are not the correct length. It seems to be the only way to do
 336       such a check at compile time, as the sizeof() operator does not work in
 337       the C preprocessor. */
 338
 339       case OP_TABLE_LENGTH:
 340       case OP_TABLE_LENGTH +
 341         ((sizeof(OP_names)/sizeof(const char *) == OP_TABLE_LENGTH) &&
 342         (sizeof(OP_lengths) == OP_TABLE_LENGTH)):
 343       return;
 344 /* ========================================================================== */
 345
 346     case OP_END:
 347     fprintf(f, "    %s\n", OP_names[*code]);
 348     fprintf(f, "------------------------------------------------------------------\n");
 349     return;
 350
 351     case OP_CHAR:
 352     fprintf(f, "    ");
 353     do
 354       {
 355       code++;
 356       code += 1 + print_char(f, code, utf);
 357       }
 358     while (*code == OP_CHAR);
 359     fprintf(f, "\n");
 360     continue;
 361
 362     case OP_CHARI:
 363     fprintf(f, " /i ");
 364     do
 365       {
 366       code++;
 367       code += 1 + print_char(f, code, utf);
 368       }
 369     while (*code == OP_CHARI);
 370     fprintf(f, "\n");
 371     continue;
 372
 373     case OP_CBRA:
 374     case OP_CBRAPOS:
 375     case OP_SCBRA:
 376     case OP_SCBRAPOS:
 377     if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
 378       else fprintf(f, "    ");
 379     fprintf(f, "%s %d", OP_names[*code], GET2(code, 1+LINK_SIZE));
 380     break;
 381
 382     case OP_BRA:
 383     case OP_BRAPOS:
 384     case OP_SBRA:
 385     case OP_SBRAPOS:
 386     case OP_KETRMAX:
 387     case OP_KETRMIN:
 388     case OP_KETRPOS:
 389     case OP_ALT:
 390     case OP_KET:
 391     case OP_ASSERT:
 392     case OP_ASSERT_NOT:
 393     case OP_ASSERTBACK:
 394     case OP_ASSERTBACK_NOT:
 395     case OP_ONCE:
 396     case OP_COND:
 397     case OP_SCOND:
 398     case OP_REVERSE:
 399     if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
 400       else fprintf(f, "    ");
 401     fprintf(f, "%s", OP_names[*code]);
 402     break;
 403
 404     case OP_CLOSE:
 405     fprintf(f, "    %s %d", OP_names[*code], GET2(code, 1));
 406     break;
 407
 408     case OP_CREF:
 409     fprintf(f, "%3d %s", GET2(code,1), OP_names[*code]);
 410     break;
 411
 412     case OP_DNCREF:
 413       {
 414       PCRE2_SPTR entry = nametable + (GET2(code, 1) * nesize) + IMM2_SIZE;
 415       fprintf(f, " %s Cond ref <", flag);
 416       print_custring(f, entry);
 417       fprintf(f, ">%d", GET2(code, 1 + IMM2_SIZE));
 418       }
 419     break;
 420
 421     case OP_RREF:
 422     c = GET2(code, 1);
 423     if (c == RREF_ANY)
 424       fprintf(f, "    Cond recurse any");
 425     else
 426       fprintf(f, "    Cond recurse %d", c);
 427     break;
 428
 429     case OP_DNRREF:
 430       {
 431       PCRE2_SPTR entry = nametable + (GET2(code, 1) * nesize) + IMM2_SIZE;
 432       fprintf(f, " %s Cond recurse <", flag);
 433       print_custring(f, entry);
 434       fprintf(f, ">%d", GET2(code, 1 + IMM2_SIZE));
 435       }
 436     break;
 437
 438     case OP_FALSE:
 439     fprintf(f, "    Cond false");
 440     break;
 441
 442     case OP_TRUE:
 443     fprintf(f, "    Cond true");
 444     break;
 445
 446     case OP_STARI:
 447     case OP_MINSTARI:
 448     case OP_POSSTARI:
 449     case OP_PLUSI:
 450     case OP_MINPLUSI:
 451     case OP_POSPLUSI:
 452     case OP_QUERYI:
 453     case OP_MINQUERYI:
 454     case OP_POSQUERYI:
 455     flag = "/i";
 456     /* Fall through */
 457     case OP_STAR:
 458     case OP_MINSTAR:
 459     case OP_POSSTAR:
 460     case OP_PLUS:
 461     case OP_MINPLUS:
 462     case OP_POSPLUS:
 463     case OP_QUERY:
 464     case OP_MINQUERY:
 465     case OP_POSQUERY:
 466     case OP_TYPESTAR:
 467     case OP_TYPEMINSTAR:
 468     case OP_TYPEPOSSTAR:
 469     case OP_TYPEPLUS:
 470     case OP_TYPEMINPLUS:
 471     case OP_TYPEPOSPLUS:
 472     case OP_TYPEQUERY:
 473     case OP_TYPEMINQUERY:
 474     case OP_TYPEPOSQUERY:
 475     fprintf(f, " %s ", flag);
 476
 477     if (*code >= OP_TYPESTAR)
 478       {
 479       if (code[1] == OP_PROP || code[1] == OP_NOTPROP)
 480         {
 481         print_prop(f, code + 1, "", " ");
 482         extra = 2;
 483         }
 484       else fprintf(f, "%s", OP_names[code[1]]);
 485       }
 486     else extra = print_char(f, code+1, utf);
 487     fprintf(f, "%s", OP_names[*code]);
 488     break;
 489
 490     case OP_EXACTI:
 491     case OP_UPTOI:
 492     case OP_MINUPTOI:
 493     case OP_POSUPTOI:
 494     flag = "/i";
 495     /* Fall through */
 496     case OP_EXACT:
 497     case OP_UPTO:
 498     case OP_MINUPTO:
 499     case OP_POSUPTO:
 500     fprintf(f, " %s ", flag);
 501     extra = print_char(f, code + 1 + IMM2_SIZE, utf);
 502     fprintf(f, "{");
 503     if (*code != OP_EXACT && *code != OP_EXACTI) fprintf(f, "0,");
 504     fprintf(f, "%d}", GET2(code,1));
 505     if (*code == OP_MINUPTO || *code == OP_MINUPTOI) fprintf(f, "?");
 506       else if (*code == OP_POSUPTO || *code == OP_POSUPTOI) fprintf(f, "+");
 507     break;
 508
 509     case OP_TYPEEXACT:
 510     case OP_TYPEUPTO:
 511     case OP_TYPEMINUPTO:
 512     case OP_TYPEPOSUPTO:
 513     if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
 514       {
 515       print_prop(f, code + IMM2_SIZE + 1, "    ", " ");
 516       extra = 2;
 517       }
 518     else fprintf(f, "    %s", OP_names[code[1 + IMM2_SIZE]]);
 519     fprintf(f, "{");
 520     if (*code != OP_TYPEEXACT) fprintf(f, "0,");
 521     fprintf(f, "%d}", GET2(code,1));
 522     if (*code == OP_TYPEMINUPTO) fprintf(f, "?");
 523       else if (*code == OP_TYPEPOSUPTO) fprintf(f, "+");
 524     break;
 525
 526     case OP_NOTI:
 527     flag = "/i";
 528     /* Fall through */
 529     case OP_NOT:
 530     fprintf(f, " %s [^", flag);
 531     extra = print_char(f, code + 1, utf);
 532     fprintf(f, "]");
 533     break;
 534
 535     case OP_NOTSTARI:
 536     case OP_NOTMINSTARI:
 537     case OP_NOTPOSSTARI:
 538     case OP_NOTPLUSI:
 539     case OP_NOTMINPLUSI:
 540     case OP_NOTPOSPLUSI:
 541     case OP_NOTQUERYI:
 542     case OP_NOTMINQUERYI:
 543     case OP_NOTPOSQUERYI:
 544     flag = "/i";
 545     /* Fall through */
 546
 547     case OP_NOTSTAR:
 548     case OP_NOTMINSTAR:
 549     case OP_NOTPOSSTAR:
 550     case OP_NOTPLUS:
 551     case OP_NOTMINPLUS:
 552     case OP_NOTPOSPLUS:
 553     case OP_NOTQUERY:
 554     case OP_NOTMINQUERY:
 555     case OP_NOTPOSQUERY:
 556     fprintf(f, " %s [^", flag);
 557     extra = print_char(f, code + 1, utf);
 558     fprintf(f, "]%s", OP_names[*code]);
 559     break;
 560
 561     case OP_NOTEXACTI:
 562     case OP_NOTUPTOI:
 563     case OP_NOTMINUPTOI:
 564     case OP_NOTPOSUPTOI:
 565     flag = "/i";
 566     /* Fall through */
 567
 568     case OP_NOTEXACT:
 569     case OP_NOTUPTO:
 570     case OP_NOTMINUPTO:
 571     case OP_NOTPOSUPTO:
 572     fprintf(f, " %s [^", flag);
 573     extra = print_char(f, code + 1 + IMM2_SIZE, utf);
 574     fprintf(f, "]{");
 575     if (*code != OP_NOTEXACT && *code != OP_NOTEXACTI) fprintf(f, "0,");
 576     fprintf(f, "%d}", GET2(code,1));
 577     if (*code == OP_NOTMINUPTO || *code == OP_NOTMINUPTOI) fprintf(f, "?");
 578       else
 579     if (*code == OP_NOTPOSUPTO || *code == OP_NOTPOSUPTOI) fprintf(f, "+");
 580     break;
 581
 582     case OP_RECURSE:
 583     if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
 584       else fprintf(f, "    ");
 585     fprintf(f, "%s", OP_names[*code]);
 586     break;
 587
 588     case OP_REFI:
 589     flag = "/i";
 590     /* Fall through */
 591     case OP_REF:
 592     fprintf(f, " %s \\%d", flag, GET2(code,1));
 593     ccode = code + OP_lengths[*code];
 594     goto CLASS_REF_REPEAT;
 595
 596     case OP_DNREFI:
 597     flag = "/i";
 598     /* Fall through */
 599     case OP_DNREF:
 600       {
 601       PCRE2_SPTR entry = nametable + (GET2(code, 1) * nesize) + IMM2_SIZE;
 602       fprintf(f, " %s \\k<", flag);
 603       print_custring(f, entry);
 604       fprintf(f, ">%d", GET2(code, 1 + IMM2_SIZE));
 605       }
 606     ccode = code + OP_lengths[*code];
 607     goto CLASS_REF_REPEAT;
 608
 609     case OP_CALLOUT:
 610     fprintf(f, "    %s %d %d %d", OP_names[*code], code[1 + 2*LINK_SIZE],
 611       GET(code, 1), GET(code, 1 + LINK_SIZE));
 612     break;
 613
 614     case OP_CALLOUT_STR:
 615     c = code[1 + 4*LINK_SIZE];
 616     fprintf(f, "    %s %c", OP_names[*code], c);
 617     extra = GET(code, 1 + 2*LINK_SIZE);
 618     print_custring_bylen(f, code + 2 + 4*LINK_SIZE, extra - 3 - 4*LINK_SIZE);
 619     for (i = 0; PRIV(callout_start_delims)[i] != 0; i++)
 620       if (c == PRIV(callout_start_delims)[i])
 621         {
 622         c = PRIV(callout_end_delims)[i];
 623         break;
 624         }
 625     fprintf(f, "%c %d %d %d", c, GET(code, 1 + 3*LINK_SIZE), GET(code, 1),
 626       GET(code, 1 + LINK_SIZE));
 627     break;
 628
 629     case OP_PROP:
 630     case OP_NOTPROP:
 631     print_prop(f, code, "    ", "");
 632     break;
 633
 634     /* OP_XCLASS cannot occur in 8-bit, non-UTF mode. However, there's no harm
 635     in having this code always here, and it makes it less messy without all
 636     those #ifdefs. */
 637
 638     case OP_CLASS:
 639     case OP_NCLASS:
 640     case OP_XCLASS:
 641       {
 642       unsigned int min, max;
 643       BOOL printmap;
 644       BOOL invertmap = FALSE;
 645       uint8_t *map;
 646       uint8_t inverted_map[32];
 647
 648       fprintf(f, "    [");
 649
 650       if (*code == OP_XCLASS)
 651         {
 652         extra = GET(code, 1);
 653         ccode = code + LINK_SIZE + 1;
 654         printmap = (*ccode & XCL_MAP) != 0;
 655         if ((*ccode & XCL_NOT) != 0)
 656           {
 657           invertmap = (*ccode & XCL_HASPROP) == 0;
 658           fprintf(f, "^");
 659           }
 660         ccode++;
 661         }
 662       else
 663         {
 664         printmap = TRUE;
 665         ccode = code + 1;
 666         }
 667
 668       /* Print a bit map */
 669
 670       if (printmap)
 671         {
 672         map = (uint8_t *)ccode;
 673         if (invertmap)
 674           {
 675           for (i = 0; i < 32; i++) inverted_map[i] = ~map[i];
 676           map = inverted_map;
 677           }
 678
 679         for (i = 0; i < 256; i++)
 680           {
 681           if ((map[i/8] & (1 << (i&7))) != 0)
 682             {
 683             int j;
 684             for (j = i+1; j < 256; j++)
 685               if ((map[j/8] & (1 << (j&7))) == 0) break;
 686             if (i == '-' || i == ']') fprintf(f, "\\");
 687             if (PRINTABLE(i)) fprintf(f, "%c", i);
 688               else fprintf(f, "\\x%02x", i);
 689             if (--j > i)
 690               {
 691               if (j != i + 1) fprintf(f, "-");
 692               if (j == '-' || j == ']') fprintf(f, "\\");
 693               if (PRINTABLE(j)) fprintf(f, "%c", j);
 694                 else fprintf(f, "\\x%02x", j);
 695               }
 696             i = j;
 697             }
 698           }
 699         ccode += 32 / sizeof(PCRE2_UCHAR);
 700         }
 701
 702       /* For an XCLASS there is always some additional data */
 703
 704       if (*code == OP_XCLASS)
 705         {
 706         PCRE2_UCHAR ch;
 707         while ((ch = *ccode++) != XCL_END)
 708           {
 709           BOOL not = FALSE;
 710           const char *notch = "";
 711
 712           switch(ch)
 713             {
 714             case XCL_NOTPROP:
 715             not = TRUE;
 716             notch = "^";
 717             /* Fall through */
 718
 719             case XCL_PROP:
 720               {
 721               unsigned int ptype = *ccode++;
 722               unsigned int pvalue = *ccode++;
 723
 724               switch(ptype)
 725                 {
 726                 case PT_PXGRAPH:
 727                 fprintf(f, "[:%sgraph:]", notch);
 728                 break;
 729
 730                 case PT_PXPRINT:
 731                 fprintf(f, "[:%sprint:]", notch);
 732                 break;
 733
 734                 case PT_PXPUNCT:
 735                 fprintf(f, "[:%spunct:]", notch);
 736                 break;
 737
 738                 default:
 739                 fprintf(f, "\\%c{%s}", (not? 'P':'p'),
 740                   get_ucpname(ptype, pvalue));
 741                 break;
 742                 }
 743               }
 744             break;
 745
 746             default:
 747             ccode += 1 + print_char(f, ccode, utf);
 748             if (ch == XCL_RANGE)
 749               {
 750               fprintf(f, "-");
 751               ccode += 1 + print_char(f, ccode, utf);
 752               }
 753             break;
 754             }
 755           }
 756         }
 757
 758       /* Indicate a non-UTF class which was created by negation */
 759
 760       fprintf(f, "]%s", (*code == OP_NCLASS)? " (neg)" : "");
 761
 762       /* Handle repeats after a class or a back reference */
 763
 764       CLASS_REF_REPEAT:
 765       switch(*ccode)
 766         {
 767         case OP_CRSTAR:
 768         case OP_CRMINSTAR:
 769         case OP_CRPLUS:
 770         case OP_CRMINPLUS:
 771         case OP_CRQUERY:
 772         case OP_CRMINQUERY:
 773         case OP_CRPOSSTAR:
 774         case OP_CRPOSPLUS:
 775         case OP_CRPOSQUERY:
 776         fprintf(f, "%s", OP_names[*ccode]);
 777         extra += OP_lengths[*ccode];
 778         break;
 779
 780         case OP_CRRANGE:
 781         case OP_CRMINRANGE:
 782         case OP_CRPOSRANGE:
 783         min = GET2(ccode,1);
 784         max = GET2(ccode,1 + IMM2_SIZE);
 785         if (max == 0) fprintf(f, "{%u,}", min);
 786         else fprintf(f, "{%u,%u}", min, max);
 787         if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
 788         else if (*ccode == OP_CRPOSRANGE) fprintf(f, "+");
 789         extra += OP_lengths[*ccode];
 790         break;
 791
 792         /* Do nothing if it's not a repeat; this code stops picky compilers
 793         warning about the lack of a default code path. */
 794
 795         default:
 796         break;
 797         }
 798       }
 799     break;
 800
 801     case OP_MARK:
 802     case OP_COMMIT_ARG:
 803     case OP_PRUNE_ARG:
 804     case OP_SKIP_ARG:
 805     case OP_THEN_ARG:
 806     fprintf(f, "    %s ", OP_names[*code]);
 807     print_custring_bylen(f, code + 2, code[1]);
 808     extra += code[1];
 809     break;
 810
 811     case OP_THEN:
 812     fprintf(f, "    %s", OP_names[*code]);
 813     break;
 814
 815     case OP_CIRCM:
 816     case OP_DOLLM:
 817     flag = "/m";
 818     /* Fall through */
 819
 820     /* Anything else is just an item with no data, but possibly a flag. */
 821
 822     default:
 823     fprintf(f, " %s %s", flag, OP_names[*code]);
 824     break;
 825     }
 826
 827   code += OP_lengths[*code] + extra;
 828   fprintf(f, "\n");
 829   }
 830 }
 831
 832 /* End of pcre2_printint.c */