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 */
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