Annotation of embedaddon/php/ext/pcre/pcrelib/pcre_printint.src, revision 1.1.1.1
1.1 misho 1: /*************************************************
2: * Perl-Compatible Regular Expressions *
3: *************************************************/
4:
5: /* PCRE is a library of functions to support regular expressions whose syntax
6: and semantics are as close as possible to those of the Perl 5 language.
7:
8: Written by Philip Hazel
9: Copyright (c) 1997-2010 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.
48:
49: (2) It is always #included by pcretest.c, which can be asked to print out a
50: compiled regex for debugging purposes. */
51:
52:
53: /* Macro that decides whether a character should be output as a literal or in
54: hexadecimal. We don't use isprint() because that can vary from system to system
55: (even without the use of locales) and we want the output always to be the same,
56: for testing purposes. This macro is used in pcretest as well as in this file. */
57:
58: #ifdef EBCDIC
59: #define PRINTABLE(c) ((c) >= 64 && (c) < 255)
60: #else
61: #define PRINTABLE(c) ((c) >= 32 && (c) < 127)
62: #endif
63:
64: /* The table of operator names. */
65:
66: static const char *OP_names[] = { OP_NAME_LIST };
67:
68:
69:
70: /*************************************************
71: * Print single- or multi-byte character *
72: *************************************************/
73:
74: static int
75: print_char(FILE *f, uschar *ptr, BOOL utf8)
76: {
77: int c = *ptr;
78:
79: #ifndef SUPPORT_UTF8
80: utf8 = utf8; /* Avoid compiler warning */
81: if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
82: return 0;
83:
84: #else
85: if (!utf8 || (c & 0xc0) != 0xc0)
86: {
87: if (PRINTABLE(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
88: return 0;
89: }
90: else
91: {
92: int i;
93: int a = _pcre_utf8_table4[c & 0x3f]; /* Number of additional bytes */
94: int s = 6*a;
95: c = (c & _pcre_utf8_table3[a]) << s;
96: for (i = 1; i <= a; i++)
97: {
98: /* This is a check for malformed UTF-8; it should only occur if the sanity
99: check has been turned off. Rather than swallow random bytes, just stop if
100: we hit a bad one. Print it with \X instead of \x as an indication. */
101:
102: if ((ptr[i] & 0xc0) != 0x80)
103: {
104: fprintf(f, "\\X{%x}", c);
105: return i - 1;
106: }
107:
108: /* The byte is OK */
109:
110: s -= 6;
111: c |= (ptr[i] & 0x3f) << s;
112: }
113: if (c < 128) fprintf(f, "\\x%02x", c); else fprintf(f, "\\x{%x}", c);
114: return a;
115: }
116: #endif
117: }
118:
119:
120:
121: /*************************************************
122: * Find Unicode property name *
123: *************************************************/
124:
125: static const char *
126: get_ucpname(int ptype, int pvalue)
127: {
128: #ifdef SUPPORT_UCP
129: int i;
130: for (i = _pcre_utt_size - 1; i >= 0; i--)
131: {
132: if (ptype == _pcre_utt[i].type && pvalue == _pcre_utt[i].value) break;
133: }
134: return (i >= 0)? _pcre_utt_names + _pcre_utt[i].name_offset : "??";
135: #else
136: /* It gets harder and harder to shut off unwanted compiler warnings. */
137: ptype = ptype * pvalue;
138: return (ptype == pvalue)? "??" : "??";
139: #endif
140: }
141:
142:
143:
144: /*************************************************
145: * Print compiled regex *
146: *************************************************/
147:
148: /* Make this function work for a regex with integers either byte order.
149: However, we assume that what we are passed is a compiled regex. The
150: print_lengths flag controls whether offsets and lengths of items are printed.
151: They can be turned off from pcretest so that automatic tests on bytecode can be
152: written that do not depend on the value of LINK_SIZE. */
153:
154: static void
155: pcre_printint(pcre *external_re, FILE *f, BOOL print_lengths)
156: {
157: real_pcre *re = (real_pcre *)external_re;
158: uschar *codestart, *code;
159: BOOL utf8;
160:
161: unsigned int options = re->options;
162: int offset = re->name_table_offset;
163: int count = re->name_count;
164: int size = re->name_entry_size;
165:
166: if (re->magic_number != MAGIC_NUMBER)
167: {
168: offset = ((offset << 8) & 0xff00) | ((offset >> 8) & 0xff);
169: count = ((count << 8) & 0xff00) | ((count >> 8) & 0xff);
170: size = ((size << 8) & 0xff00) | ((size >> 8) & 0xff);
171: options = ((options << 24) & 0xff000000) |
172: ((options << 8) & 0x00ff0000) |
173: ((options >> 8) & 0x0000ff00) |
174: ((options >> 24) & 0x000000ff);
175: }
176:
177: code = codestart = (uschar *)re + offset + count * size;
178: utf8 = (options & PCRE_UTF8) != 0;
179:
180: for(;;)
181: {
182: uschar *ccode;
183: int c;
184: int extra = 0;
185:
186: if (print_lengths)
187: fprintf(f, "%3d ", (int)(code - codestart));
188: else
189: fprintf(f, " ");
190:
191: switch(*code)
192: {
193: /* ========================================================================== */
194: /* These cases are never obeyed. This is a fudge that causes a compile-
195: time error if the vectors OP_names or _pcre_OP_lengths, which are indexed
196: by opcode, are not the correct length. It seems to be the only way to do
197: such a check at compile time, as the sizeof() operator does not work in
198: the C preprocessor. We do this while compiling pcretest, because that
199: #includes pcre_tables.c, which holds _pcre_OP_lengths. We can't do this
200: when building pcre_compile.c with PCRE_DEBUG set, because it doesn't then
201: know the size of _pcre_OP_lengths. */
202:
203: #ifdef COMPILING_PCRETEST
204: case OP_TABLE_LENGTH:
205: case OP_TABLE_LENGTH +
206: ((sizeof(OP_names)/sizeof(const char *) == OP_TABLE_LENGTH) &&
207: (sizeof(_pcre_OP_lengths) == OP_TABLE_LENGTH)):
208: break;
209: #endif
210: /* ========================================================================== */
211:
212: case OP_END:
213: fprintf(f, " %s\n", OP_names[*code]);
214: fprintf(f, "------------------------------------------------------------------\n");
215: return;
216:
217: case OP_OPT:
218: fprintf(f, " %.2x %s", code[1], OP_names[*code]);
219: break;
220:
221: case OP_CHAR:
222: fprintf(f, " ");
223: do
224: {
225: code++;
226: code += 1 + print_char(f, code, utf8);
227: }
228: while (*code == OP_CHAR);
229: fprintf(f, "\n");
230: continue;
231:
232: case OP_CHARNC:
233: fprintf(f, " NC ");
234: do
235: {
236: code++;
237: code += 1 + print_char(f, code, utf8);
238: }
239: while (*code == OP_CHARNC);
240: fprintf(f, "\n");
241: continue;
242:
243: case OP_CBRA:
244: case OP_SCBRA:
245: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
246: else fprintf(f, " ");
247: fprintf(f, "%s %d", OP_names[*code], GET2(code, 1+LINK_SIZE));
248: break;
249:
250: case OP_BRA:
251: case OP_SBRA:
252: case OP_KETRMAX:
253: case OP_KETRMIN:
254: case OP_ALT:
255: case OP_KET:
256: case OP_ASSERT:
257: case OP_ASSERT_NOT:
258: case OP_ASSERTBACK:
259: case OP_ASSERTBACK_NOT:
260: case OP_ONCE:
261: case OP_COND:
262: case OP_SCOND:
263: case OP_REVERSE:
264: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
265: else fprintf(f, " ");
266: fprintf(f, "%s", OP_names[*code]);
267: break;
268:
269: case OP_CLOSE:
270: fprintf(f, " %s %d", OP_names[*code], GET2(code, 1));
271: break;
272:
273: case OP_CREF:
274: case OP_NCREF:
275: fprintf(f, "%3d %s", GET2(code,1), OP_names[*code]);
276: break;
277:
278: case OP_RREF:
279: c = GET2(code, 1);
280: if (c == RREF_ANY)
281: fprintf(f, " Cond recurse any");
282: else
283: fprintf(f, " Cond recurse %d", c);
284: break;
285:
286: case OP_NRREF:
287: c = GET2(code, 1);
288: if (c == RREF_ANY)
289: fprintf(f, " Cond nrecurse any");
290: else
291: fprintf(f, " Cond nrecurse %d", c);
292: break;
293:
294: case OP_DEF:
295: fprintf(f, " Cond def");
296: break;
297:
298: case OP_STAR:
299: case OP_MINSTAR:
300: case OP_POSSTAR:
301: case OP_PLUS:
302: case OP_MINPLUS:
303: case OP_POSPLUS:
304: case OP_QUERY:
305: case OP_MINQUERY:
306: case OP_POSQUERY:
307: case OP_TYPESTAR:
308: case OP_TYPEMINSTAR:
309: case OP_TYPEPOSSTAR:
310: case OP_TYPEPLUS:
311: case OP_TYPEMINPLUS:
312: case OP_TYPEPOSPLUS:
313: case OP_TYPEQUERY:
314: case OP_TYPEMINQUERY:
315: case OP_TYPEPOSQUERY:
316: fprintf(f, " ");
317: if (*code >= OP_TYPESTAR)
318: {
319: fprintf(f, "%s", OP_names[code[1]]);
320: if (code[1] == OP_PROP || code[1] == OP_NOTPROP)
321: {
322: fprintf(f, " %s ", get_ucpname(code[2], code[3]));
323: extra = 2;
324: }
325: }
326: else extra = print_char(f, code+1, utf8);
327: fprintf(f, "%s", OP_names[*code]);
328: break;
329:
330: case OP_EXACT:
331: case OP_UPTO:
332: case OP_MINUPTO:
333: case OP_POSUPTO:
334: fprintf(f, " ");
335: extra = print_char(f, code+3, utf8);
336: fprintf(f, "{");
337: if (*code != OP_EXACT) fprintf(f, "0,");
338: fprintf(f, "%d}", GET2(code,1));
339: if (*code == OP_MINUPTO) fprintf(f, "?");
340: else if (*code == OP_POSUPTO) fprintf(f, "+");
341: break;
342:
343: case OP_TYPEEXACT:
344: case OP_TYPEUPTO:
345: case OP_TYPEMINUPTO:
346: case OP_TYPEPOSUPTO:
347: fprintf(f, " %s", OP_names[code[3]]);
348: if (code[3] == OP_PROP || code[3] == OP_NOTPROP)
349: {
350: fprintf(f, " %s ", get_ucpname(code[4], code[5]));
351: extra = 2;
352: }
353: fprintf(f, "{");
354: if (*code != OP_TYPEEXACT) fprintf(f, "0,");
355: fprintf(f, "%d}", GET2(code,1));
356: if (*code == OP_TYPEMINUPTO) fprintf(f, "?");
357: else if (*code == OP_TYPEPOSUPTO) fprintf(f, "+");
358: break;
359:
360: case OP_NOT:
361: c = code[1];
362: if (PRINTABLE(c)) fprintf(f, " [^%c]", c);
363: else fprintf(f, " [^\\x%02x]", c);
364: break;
365:
366: case OP_NOTSTAR:
367: case OP_NOTMINSTAR:
368: case OP_NOTPOSSTAR:
369: case OP_NOTPLUS:
370: case OP_NOTMINPLUS:
371: case OP_NOTPOSPLUS:
372: case OP_NOTQUERY:
373: case OP_NOTMINQUERY:
374: case OP_NOTPOSQUERY:
375: c = code[1];
376: if (PRINTABLE(c)) fprintf(f, " [^%c]", c);
377: else fprintf(f, " [^\\x%02x]", c);
378: fprintf(f, "%s", OP_names[*code]);
379: break;
380:
381: case OP_NOTEXACT:
382: case OP_NOTUPTO:
383: case OP_NOTMINUPTO:
384: case OP_NOTPOSUPTO:
385: c = code[3];
386: if (PRINTABLE(c)) fprintf(f, " [^%c]{", c);
387: else fprintf(f, " [^\\x%02x]{", c);
388: if (*code != OP_NOTEXACT) fprintf(f, "0,");
389: fprintf(f, "%d}", GET2(code,1));
390: if (*code == OP_NOTMINUPTO) fprintf(f, "?");
391: else if (*code == OP_NOTPOSUPTO) fprintf(f, "+");
392: break;
393:
394: case OP_RECURSE:
395: if (print_lengths) fprintf(f, "%3d ", GET(code, 1));
396: else fprintf(f, " ");
397: fprintf(f, "%s", OP_names[*code]);
398: break;
399:
400: case OP_REF:
401: fprintf(f, " \\%d", GET2(code,1));
402: ccode = code + _pcre_OP_lengths[*code];
403: goto CLASS_REF_REPEAT;
404:
405: case OP_CALLOUT:
406: fprintf(f, " %s %d %d %d", OP_names[*code], code[1], GET(code,2),
407: GET(code, 2 + LINK_SIZE));
408: break;
409:
410: case OP_PROP:
411: case OP_NOTPROP:
412: fprintf(f, " %s %s", OP_names[*code], get_ucpname(code[1], code[2]));
413: break;
414:
415: /* OP_XCLASS can only occur in UTF-8 mode. However, there's no harm in
416: having this code always here, and it makes it less messy without all those
417: #ifdefs. */
418:
419: case OP_CLASS:
420: case OP_NCLASS:
421: case OP_XCLASS:
422: {
423: int i, min, max;
424: BOOL printmap;
425:
426: fprintf(f, " [");
427:
428: if (*code == OP_XCLASS)
429: {
430: extra = GET(code, 1);
431: ccode = code + LINK_SIZE + 1;
432: printmap = (*ccode & XCL_MAP) != 0;
433: if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");
434: }
435: else
436: {
437: printmap = TRUE;
438: ccode = code + 1;
439: }
440:
441: /* Print a bit map */
442:
443: if (printmap)
444: {
445: for (i = 0; i < 256; i++)
446: {
447: if ((ccode[i/8] & (1 << (i&7))) != 0)
448: {
449: int j;
450: for (j = i+1; j < 256; j++)
451: if ((ccode[j/8] & (1 << (j&7))) == 0) break;
452: if (i == '-' || i == ']') fprintf(f, "\\");
453: if (PRINTABLE(i)) fprintf(f, "%c", i);
454: else fprintf(f, "\\x%02x", i);
455: if (--j > i)
456: {
457: if (j != i + 1) fprintf(f, "-");
458: if (j == '-' || j == ']') fprintf(f, "\\");
459: if (PRINTABLE(j)) fprintf(f, "%c", j);
460: else fprintf(f, "\\x%02x", j);
461: }
462: i = j;
463: }
464: }
465: ccode += 32;
466: }
467:
468: /* For an XCLASS there is always some additional data */
469:
470: if (*code == OP_XCLASS)
471: {
472: int ch;
473: while ((ch = *ccode++) != XCL_END)
474: {
475: if (ch == XCL_PROP)
476: {
477: int ptype = *ccode++;
478: int pvalue = *ccode++;
479: fprintf(f, "\\p{%s}", get_ucpname(ptype, pvalue));
480: }
481: else if (ch == XCL_NOTPROP)
482: {
483: int ptype = *ccode++;
484: int pvalue = *ccode++;
485: fprintf(f, "\\P{%s}", get_ucpname(ptype, pvalue));
486: }
487: else
488: {
489: ccode += 1 + print_char(f, ccode, TRUE);
490: if (ch == XCL_RANGE)
491: {
492: fprintf(f, "-");
493: ccode += 1 + print_char(f, ccode, TRUE);
494: }
495: }
496: }
497: }
498:
499: /* Indicate a non-UTF8 class which was created by negation */
500:
501: fprintf(f, "]%s", (*code == OP_NCLASS)? " (neg)" : "");
502:
503: /* Handle repeats after a class or a back reference */
504:
505: CLASS_REF_REPEAT:
506: switch(*ccode)
507: {
508: case OP_CRSTAR:
509: case OP_CRMINSTAR:
510: case OP_CRPLUS:
511: case OP_CRMINPLUS:
512: case OP_CRQUERY:
513: case OP_CRMINQUERY:
514: fprintf(f, "%s", OP_names[*ccode]);
515: extra += _pcre_OP_lengths[*ccode];
516: break;
517:
518: case OP_CRRANGE:
519: case OP_CRMINRANGE:
520: min = GET2(ccode,1);
521: max = GET2(ccode,3);
522: if (max == 0) fprintf(f, "{%d,}", min);
523: else fprintf(f, "{%d,%d}", min, max);
524: if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
525: extra += _pcre_OP_lengths[*ccode];
526: break;
527:
528: /* Do nothing if it's not a repeat; this code stops picky compilers
529: warning about the lack of a default code path. */
530:
531: default:
532: break;
533: }
534: }
535: break;
536:
537: case OP_MARK:
538: case OP_PRUNE_ARG:
539: case OP_SKIP_ARG:
540: fprintf(f, " %s %s", OP_names[*code], code + 2);
541: extra += code[1];
542: break;
543:
544: case OP_THEN:
545: if (print_lengths)
546: fprintf(f, " %s %d", OP_names[*code], GET(code, 1));
547: else
548: fprintf(f, " %s", OP_names[*code]);
549: break;
550:
551: case OP_THEN_ARG:
552: if (print_lengths)
553: fprintf(f, " %s %d %s", OP_names[*code], GET(code, 1),
554: code + 2 + LINK_SIZE);
555: else
556: fprintf(f, " %s %s", OP_names[*code], code + 2 + LINK_SIZE);
557: extra += code[1+LINK_SIZE];
558: break;
559:
560: /* Anything else is just an item with no data*/
561:
562: default:
563: fprintf(f, " %s", OP_names[*code]);
564: break;
565: }
566:
567: code += _pcre_OP_lengths[*code] + extra;
568: fprintf(f, "\n");
569: }
570: }
571:
572: /* End of pcre_printint.src */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcre_printint.src CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / pcre / pcrelib