tags/pcre-4.1/printint.c

/*************************************************
*      Perl-Compatible Regular Expressions       *
*************************************************/

/*
This is a library of functions to support regular expressions whose syntax
and semantics are as close as possible to those of the Perl 5 language. See
the file Tech.Notes for some information on the internals.

Written by: Philip Hazel <ph10@cam.ac.uk>

           Copyright (c) 1997-2003 University of Cambridge

-----------------------------------------------------------------------------
Permission is granted to anyone to use this software for any purpose on any
computer system, and to redistribute it freely, subject to the following
restrictions:

1. This software is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2. The origin of this software must not be misrepresented, either by
   explicit claim or by omission.

3. Altered versions must be plainly marked as such, and must not be
   misrepresented as being the original software.

4. If PCRE is embedded in any software that is released under the GNU
   General Purpose Licence (GPL), then the terms of that licence shall
   supersede any condition above with which it is incompatible.
-----------------------------------------------------------------------------
*/


/* This module contains a debugging function for printing out the internal form
of a compiled regular expression. It is kept in a separate file so that it can
be #included both in the pcretest program, and in the library itself when
compiled with the debugging switch. */


static const char *OP_names[] = { OP_NAME_LIST };


/*************************************************
*       Print single- or multi-byte character    *
*************************************************/

/* These tables are actually copies of ones in pcre.c. If we compile the
library with debugging, they are included twice, but that isn't really a
problem - compiling with debugging is pretty rare and these are very small. */

static int utf8_t3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};

static uschar utf8_t4[] = {
  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
  3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };

static int
print_char(FILE *f, uschar *ptr, BOOL utf8)
{
int c = *ptr;

if (!utf8 || (c & 0xc0) != 0xc0)
  {
  if (isprint(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
  return 0;
  }
else
  {
  int i;
  int a = utf8_t4[c & 0x3f];  /* Number of additional bytes */
  int s = 6*a;
  c = (c & utf8_t3[a]) << s;
  for (i = 1; i <= a; i++)
    {
    s -= 6;
    c |= (ptr[i] & 0x3f) << s;
    }
  if (c < 128) fprintf(f, "\\x%02x", c); else fprintf(f, "\\x{%x}", c);
  return a;
  }
}


/*************************************************
*         Print compiled regex                   *
*************************************************/

static void
print_internals(pcre *external_re, FILE *f)
{
real_pcre *re = (real_pcre *)external_re;
uschar *codestart =
  (uschar *)re + sizeof(real_pcre) + re->name_count * re->name_entry_size;
uschar *code = codestart;
BOOL utf8 = (re->options & PCRE_UTF8) != 0;

for(;;)
  {
  uschar *ccode;
  int c;
  int extra = 0;

  fprintf(f, "%3d ", code - codestart);

  if (*code >= OP_BRA)
    {
    if (*code - OP_BRA > EXTRACT_BASIC_MAX)
      fprintf(f, "%3d Bra extra\n", GET(code, 1));
    else
      fprintf(f, "%3d Bra %d\n", GET(code, 1), *code - OP_BRA);
    code += OP_lengths[OP_BRA];
    continue;
    }

  switch(*code)
    {
    case OP_END:
    fprintf(f, "    %s\n", OP_names[*code]);
    fprintf(f, "------------------------------------------------------------------\n");
    return;

    case OP_OPT:
    fprintf(f, " %.2x %s", code[1], OP_names[*code]);
    break;

    case OP_CHARS:
      {
      int charlength = code[1];
      ccode = code + 2;
      extra = charlength;
      fprintf(f, "%3d ", charlength);
      while (charlength > 0)
        {
        int extra = print_char(f, ccode, utf8);
        ccode += 1 + extra;
        charlength -= 1 + extra;
        }
      }
    break;

    case OP_KETRMAX:
    case OP_KETRMIN:
    case OP_ALT:
    case OP_KET:
    case OP_ASSERT:
    case OP_ASSERT_NOT:
    case OP_ASSERTBACK:
    case OP_ASSERTBACK_NOT:
    case OP_ONCE:
    case OP_COND:
    case OP_REVERSE:
    fprintf(f, "%3d %s", GET(code, 1), OP_names[*code]);
    break;

    case OP_BRANUMBER:
    printf("%3d %s", GET2(code, 1), OP_names[*code]);
    break;

    case OP_CREF:
    if (GET2(code, 1) == CREF_RECURSE)
      fprintf(f, "    Cond recurse");
    else
      fprintf(f, "%3d %s", GET2(code,1), OP_names[*code]);
    break;

    case OP_STAR:
    case OP_MINSTAR:
    case OP_PLUS:
    case OP_MINPLUS:
    case OP_QUERY:
    case OP_MINQUERY:
    case OP_TYPESTAR:
    case OP_TYPEMINSTAR:
    case OP_TYPEPLUS:
    case OP_TYPEMINPLUS:
    case OP_TYPEQUERY:
    case OP_TYPEMINQUERY:
    fprintf(f, "    ");
    if (*code >= OP_TYPESTAR) fprintf(f, "%s", OP_names[code[1]]);
      else extra = print_char(f, code+1, utf8);
    fprintf(f, "%s", OP_names[*code]);
    break;

    case OP_EXACT:
    case OP_UPTO:
    case OP_MINUPTO:
    fprintf(f, "    ");
    extra = print_char(f, code+3, utf8);
    fprintf(f, "{");
    if (*code != OP_EXACT) fprintf(f, ",");
    fprintf(f, "%d}", GET2(code,1));
    if (*code == OP_MINUPTO) fprintf(f, "?");
    break;

    case OP_TYPEEXACT:
    case OP_TYPEUPTO:
    case OP_TYPEMINUPTO:
    fprintf(f, "    %s{", OP_names[code[3]]);
    if (*code != OP_TYPEEXACT) fprintf(f, "0,");
    fprintf(f, "%d}", GET2(code,1));
    if (*code == OP_TYPEMINUPTO) fprintf(f, "?");
    break;

    case OP_NOT:
    if (isprint(c = code[1])) fprintf(f, "    [^%c]", c);
      else fprintf(f, "    [^\\x%02x]", c);
    break;

    case OP_NOTSTAR:
    case OP_NOTMINSTAR:
    case OP_NOTPLUS:
    case OP_NOTMINPLUS:
    case OP_NOTQUERY:
    case OP_NOTMINQUERY:
    if (isprint(c = code[1])) fprintf(f, "    [^%c]", c);
      else fprintf(f, "    [^\\x%02x]", c);
    fprintf(f, "%s", OP_names[*code]);
    break;

    case OP_NOTEXACT:
    case OP_NOTUPTO:
    case OP_NOTMINUPTO:
    if (isprint(c = code[3])) fprintf(f, "    [^%c]{", c);
      else fprintf(f, "    [^\\x%02x]{", c);
    if (*code != OP_NOTEXACT) fprintf(f, ",");
    fprintf(f, "%d}", GET2(code,1));
    if (*code == OP_NOTMINUPTO) fprintf(f, "?");
    break;

    case OP_RECURSE:
    fprintf(f, "%3d %s", GET(code, 1), OP_names[*code]);
    break;

    case OP_REF:
    fprintf(f, "    \\%d", GET2(code,1));
    ccode = code + OP_lengths[*code];
    goto CLASS_REF_REPEAT;

    case OP_CALLOUT:
    fprintf(f, "    %s %d", OP_names[*code], code[1]);
    break;

    /* OP_XCLASS can only occur in UTF-8 mode. However, there's no harm in
    having this code always here, and it makes it less messy without all those
    #ifdefs. */

    case OP_CLASS:
    case OP_NCLASS:
    case OP_XCLASS:
      {
      int i, min, max;
      BOOL printmap;

      fprintf(f, "    [");

      if (*code == OP_XCLASS)
        {
        extra = GET(code, 1);
        ccode = code + LINK_SIZE + 1;
        printmap = (*ccode & XCL_MAP) != 0;
        if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");
        }
      else
        {
        printmap = TRUE;
        ccode = code + 1;
        }

      /* Print a bit map */

      if (printmap)
        {
        for (i = 0; i < 256; i++)
          {
          if ((ccode[i/8] & (1 << (i&7))) != 0)
            {
            int j;
            for (j = i+1; j < 256; j++)
              if ((ccode[j/8] & (1 << (j&7))) == 0) break;
            if (i == '-' || i == ']') fprintf(f, "\\");
            if (isprint(i)) fprintf(f, "%c", i); else fprintf(f, "\\x%02x", i);
            if (--j > i)
              {
              fprintf(f, "-");
              if (j == '-' || j == ']') fprintf(f, "\\");
              if (isprint(j)) fprintf(f, "%c", j); else fprintf(f, "\\x%02x", j);
              }
            i = j;
            }
          }
        ccode += 32;
        }

      /* For an XCLASS there is always some additional data */

      if (*code == OP_XCLASS)
        {
        int c;
        while ((c = *ccode++) != XCL_END)
          {
          ccode += 1 + print_char(f, ccode, TRUE);
          if (c == XCL_RANGE)
            {
            fprintf(f, "-");
            ccode += 1 + print_char(f, ccode, TRUE);
            }
          }
        }

      /* Indicate a non-UTF8 class which was created by negation */

      fprintf(f, "]%s", (*code == OP_NCLASS)? " (neg)" : "");

      /* Handle repeats after a class or a back reference */

      CLASS_REF_REPEAT:
      switch(*ccode)
        {
        case OP_CRSTAR:
        case OP_CRMINSTAR:
        case OP_CRPLUS:
        case OP_CRMINPLUS:
        case OP_CRQUERY:
        case OP_CRMINQUERY:
        fprintf(f, "%s", OP_names[*ccode]);
        extra = OP_lengths[*ccode];
        break;

        case OP_CRRANGE:
        case OP_CRMINRANGE:
        min = GET2(ccode,1);
        max = GET2(ccode,3);
        if (max == 0) fprintf(f, "{%d,}", min);
        else fprintf(f, "{%d,%d}", min, max);
        if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
        extra = OP_lengths[*ccode];
        break;
        }
      }
    break;

    /* Anything else is just an item with no data*/

    default:
    fprintf(f, "    %s", OP_names[*code]);
    break;
    }

  code += OP_lengths[*code] + extra;
  fprintf(f, "\n");
  }
}

/* End of printint.c */
1	/*************************************************
2	* Perl-Compatible Regular Expressions *
3	*************************************************/
4
5	/*
6	This is a library of functions to support regular expressions whose syntax
7	and semantics are as close as possible to those of the Perl 5 language. See
8	the file Tech.Notes for some information on the internals.
9
10	Written by: Philip Hazel <ph10@cam.ac.uk>
11
12	Copyright (c) 1997-2003 University of Cambridge
13
14	-----------------------------------------------------------------------------
15	Permission is granted to anyone to use this software for any purpose on any
16	computer system, and to redistribute it freely, subject to the following
17	restrictions:
18
19	1. This software is distributed in the hope that it will be useful,
20	but WITHOUT ANY WARRANTY; without even the implied warranty of
21	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
22
23	2. The origin of this software must not be misrepresented, either by
24	explicit claim or by omission.
25
26	3. Altered versions must be plainly marked as such, and must not be
27	misrepresented as being the original software.
28
29	4. If PCRE is embedded in any software that is released under the GNU
30	General Purpose Licence (GPL), then the terms of that licence shall
31	supersede any condition above with which it is incompatible.
32	-----------------------------------------------------------------------------
33	*/
34
35
36	/* This module contains a debugging function for printing out the internal form
37	of a compiled regular expression. It is kept in a separate file so that it can
38	be #included both in the pcretest program, and in the library itself when
39	compiled with the debugging switch. */
40
41
42	static const char *OP_names[] = { OP_NAME_LIST };
43
44
45	/*************************************************
46	* Print single- or multi-byte character *
47	*************************************************/
48
49	/* These tables are actually copies of ones in pcre.c. If we compile the
50	library with debugging, they are included twice, but that isn't really a
51	problem - compiling with debugging is pretty rare and these are very small. */
52
53	static int utf8_t3[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
54
55	static uschar utf8_t4[] = {
56	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
57	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
58	2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
59	3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
60
61	static int
62	print_char(FILE f, uschar ptr, BOOL utf8)
63	{
64	int c = *ptr;
65
66	if (!utf8 \|\| (c & 0xc0) != 0xc0)
67	{
68	if (isprint(c)) fprintf(f, "%c", c); else fprintf(f, "\\x%02x", c);
69	return 0;
70	}
71	else
72	{
73	int i;
74	int a = utf8_t4[c & 0x3f]; /* Number of additional bytes */
75	int s = 6*a;
76	c = (c & utf8_t3[a]) << s;
77	for (i = 1; i <= a; i++)
78	{
79	s -= 6;
80	c \|= (ptr[i] & 0x3f) << s;
81	}
82	if (c < 128) fprintf(f, "\\x%02x", c); else fprintf(f, "\\x{%x}", c);
83	return a;
84	}
85	}
86
87
88
89
90	/*************************************************
91	* Print compiled regex *
92	*************************************************/
93
94	static void
95	print_internals(pcre external_re, FILE f)
96	{
97	real_pcre re = (real_pcre )external_re;
98	uschar *codestart =
99	(uschar )re + sizeof(real_pcre) + re->name_count re->name_entry_size;
100	uschar *code = codestart;
101	BOOL utf8 = (re->options & PCRE_UTF8) != 0;
102
103	for(;;)
104	{
105	uschar *ccode;
106	int c;
107	int extra = 0;
108
109	fprintf(f, "%3d ", code - codestart);
110
111	if (*code >= OP_BRA)
112	{
113	if (*code - OP_BRA > EXTRACT_BASIC_MAX)
114	fprintf(f, "%3d Bra extra\n", GET(code, 1));
115	else
116	fprintf(f, "%3d Bra %d\n", GET(code, 1), *code - OP_BRA);
117	code += OP_lengths[OP_BRA];
118	continue;
119	}
120
121	switch(*code)
122	{
123	case OP_END:
124	fprintf(f, " %s\n", OP_names[*code]);
125	fprintf(f, "------------------------------------------------------------------\n");
126	return;
127
128	case OP_OPT:
129	fprintf(f, " %.2x %s", code[1], OP_names[*code]);
130	break;
131
132	case OP_CHARS:
133	{
134	int charlength = code[1];
135	ccode = code + 2;
136	extra = charlength;
137	fprintf(f, "%3d ", charlength);
138	while (charlength > 0)
139	{
140	int extra = print_char(f, ccode, utf8);
141	ccode += 1 + extra;
142	charlength -= 1 + extra;
143	}
144	}
145	break;
146
147	case OP_KETRMAX:
148	case OP_KETRMIN:
149	case OP_ALT:
150	case OP_KET:
151	case OP_ASSERT:
152	case OP_ASSERT_NOT:
153	case OP_ASSERTBACK:
154	case OP_ASSERTBACK_NOT:
155	case OP_ONCE:
156	case OP_COND:
157	case OP_REVERSE:
158	fprintf(f, "%3d %s", GET(code, 1), OP_names[*code]);
159	break;
160
161	case OP_BRANUMBER:
162	printf("%3d %s", GET2(code, 1), OP_names[*code]);
163	break;
164
165	case OP_CREF:
166	if (GET2(code, 1) == CREF_RECURSE)
167	fprintf(f, " Cond recurse");
168	else
169	fprintf(f, "%3d %s", GET2(code,1), OP_names[*code]);
170	break;
171
172	case OP_STAR:
173	case OP_MINSTAR:
174	case OP_PLUS:
175	case OP_MINPLUS:
176	case OP_QUERY:
177	case OP_MINQUERY:
178	case OP_TYPESTAR:
179	case OP_TYPEMINSTAR:
180	case OP_TYPEPLUS:
181	case OP_TYPEMINPLUS:
182	case OP_TYPEQUERY:
183	case OP_TYPEMINQUERY:
184	fprintf(f, " ");
185	if (*code >= OP_TYPESTAR) fprintf(f, "%s", OP_names[code[1]]);
186	else extra = print_char(f, code+1, utf8);
187	fprintf(f, "%s", OP_names[*code]);
188	break;
189
190	case OP_EXACT:
191	case OP_UPTO:
192	case OP_MINUPTO:
193	fprintf(f, " ");
194	extra = print_char(f, code+3, utf8);
195	fprintf(f, "{");
196	if (*code != OP_EXACT) fprintf(f, ",");
197	fprintf(f, "%d}", GET2(code,1));
198	if (*code == OP_MINUPTO) fprintf(f, "?");
199	break;
200
201	case OP_TYPEEXACT:
202	case OP_TYPEUPTO:
203	case OP_TYPEMINUPTO:
204	fprintf(f, " %s{", OP_names[code[3]]);
205	if (*code != OP_TYPEEXACT) fprintf(f, "0,");
206	fprintf(f, "%d}", GET2(code,1));
207	if (*code == OP_TYPEMINUPTO) fprintf(f, "?");
208	break;
209
210	case OP_NOT:
211	if (isprint(c = code[1])) fprintf(f, " [^%c]", c);
212	else fprintf(f, " [^\\x%02x]", c);
213	break;
214
215	case OP_NOTSTAR:
216	case OP_NOTMINSTAR:
217	case OP_NOTPLUS:
218	case OP_NOTMINPLUS:
219	case OP_NOTQUERY:
220	case OP_NOTMINQUERY:
221	if (isprint(c = code[1])) fprintf(f, " [^%c]", c);
222	else fprintf(f, " [^\\x%02x]", c);
223	fprintf(f, "%s", OP_names[*code]);
224	break;
225
226	case OP_NOTEXACT:
227	case OP_NOTUPTO:
228	case OP_NOTMINUPTO:
229	if (isprint(c = code[3])) fprintf(f, " [^%c]{", c);
230	else fprintf(f, " [^\\x%02x]{", c);
231	if (*code != OP_NOTEXACT) fprintf(f, ",");
232	fprintf(f, "%d}", GET2(code,1));
233	if (*code == OP_NOTMINUPTO) fprintf(f, "?");
234	break;
235
236	case OP_RECURSE:
237	fprintf(f, "%3d %s", GET(code, 1), OP_names[*code]);
238	break;
239
240	case OP_REF:
241	fprintf(f, " \\%d", GET2(code,1));
242	ccode = code + OP_lengths[*code];
243	goto CLASS_REF_REPEAT;
244
245	case OP_CALLOUT:
246	fprintf(f, " %s %d", OP_names[*code], code[1]);
247	break;
248
249	/* OP_XCLASS can only occur in UTF-8 mode. However, there's no harm in
250	having this code always here, and it makes it less messy without all those
251	#ifdefs. */
252
253	case OP_CLASS:
254	case OP_NCLASS:
255	case OP_XCLASS:
256	{
257	int i, min, max;
258	BOOL printmap;
259
260	fprintf(f, " [");
261
262	if (*code == OP_XCLASS)
263	{
264	extra = GET(code, 1);
265	ccode = code + LINK_SIZE + 1;
266	printmap = (*ccode & XCL_MAP) != 0;
267	if ((*ccode++ & XCL_NOT) != 0) fprintf(f, "^");
268	}
269	else
270	{
271	printmap = TRUE;
272	ccode = code + 1;
273	}
274
275	/* Print a bit map */
276
277	if (printmap)
278	{
279	for (i = 0; i < 256; i++)
280	{
281	if ((ccode[i/8] & (1 << (i&7))) != 0)
282	{
283	int j;
284	for (j = i+1; j < 256; j++)
285	if ((ccode[j/8] & (1 << (j&7))) == 0) break;
286	if (i == '-' \|\| i == ']') fprintf(f, "\\");
287	if (isprint(i)) fprintf(f, "%c", i); else fprintf(f, "\\x%02x", i);
288	if (--j > i)
289	{
290	fprintf(f, "-");
291	if (j == '-' \|\| j == ']') fprintf(f, "\\");
292	if (isprint(j)) fprintf(f, "%c", j); else fprintf(f, "\\x%02x", j);
293	}
294	i = j;
295	}
296	}
297	ccode += 32;
298	}
299
300	/* For an XCLASS there is always some additional data */
301
302	if (*code == OP_XCLASS)
303	{
304	int c;
305	while ((c = *ccode++) != XCL_END)
306	{
307	ccode += 1 + print_char(f, ccode, TRUE);
308	if (c == XCL_RANGE)
309	{
310	fprintf(f, "-");
311	ccode += 1 + print_char(f, ccode, TRUE);
312	}
313	}
314	}
315
316	/* Indicate a non-UTF8 class which was created by negation */
317
318	fprintf(f, "]%s", (*code == OP_NCLASS)? " (neg)" : "");
319
320	/* Handle repeats after a class or a back reference */
321
322	CLASS_REF_REPEAT:
323	switch(*ccode)
324	{
325	case OP_CRSTAR:
326	case OP_CRMINSTAR:
327	case OP_CRPLUS:
328	case OP_CRMINPLUS:
329	case OP_CRQUERY:
330	case OP_CRMINQUERY:
331	fprintf(f, "%s", OP_names[*ccode]);
332	extra = OP_lengths[*ccode];
333	break;
334
335	case OP_CRRANGE:
336	case OP_CRMINRANGE:
337	min = GET2(ccode,1);
338	max = GET2(ccode,3);
339	if (max == 0) fprintf(f, "{%d,}", min);
340	else fprintf(f, "{%d,%d}", min, max);
341	if (*ccode == OP_CRMINRANGE) fprintf(f, "?");
342	extra = OP_lengths[*ccode];
343	break;
344	}
345	}
346	break;
347
348	/* Anything else is just an item with no data*/
349
350	default:
351	fprintf(f, " %s", OP_names[*code]);
352	break;
353	}
354
355	code += OP_lengths[*code] + extra;
356	fprintf(f, "\n");
357	}
358	}
359
360	/* End of printint.c */