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