Annotation of embedaddon/pcre/pcredemo.c, revision 1.1.1.2
1.1 misho 1: /*************************************************
2: * PCRE DEMONSTRATION PROGRAM *
3: *************************************************/
4:
5: /* This is a demonstration program to illustrate the most straightforward ways
6: of calling the PCRE regular expression library from a C program. See the
7: pcresample documentation for a short discussion ("man pcresample" if you have
8: the PCRE man pages installed).
9:
10: In Unix-like environments, if PCRE is installed in your standard system
11: libraries, you should be able to compile this program using this command:
12:
13: gcc -Wall pcredemo.c -lpcre -o pcredemo
14:
15: If PCRE is not installed in a standard place, it is likely to be installed with
16: support for the pkg-config mechanism. If you have pkg-config, you can compile
17: this program using this command:
18:
19: gcc -Wall pcredemo.c `pkg-config --cflags --libs libpcre` -o pcredemo
20:
21: If you do not have pkg-config, you may have to use this:
22:
23: gcc -Wall pcredemo.c -I/usr/local/include -L/usr/local/lib \
24: -R/usr/local/lib -lpcre -o pcredemo
25:
26: Replace "/usr/local/include" and "/usr/local/lib" with wherever the include and
27: library files for PCRE are installed on your system. Only some operating
28: systems (e.g. Solaris) use the -R option.
29:
30: Building under Windows:
31:
32: If you want to statically link this program against a non-dll .a file, you must
33: define PCRE_STATIC before including pcre.h, otherwise the pcre_malloc() and
34: pcre_free() exported functions will be declared __declspec(dllimport), with
35: unwanted results. So in this environment, uncomment the following line. */
36:
37: /* #define PCRE_STATIC */
38:
39: #include <stdio.h>
40: #include <string.h>
41: #include <pcre.h>
42:
43: #define OVECCOUNT 30 /* should be a multiple of 3 */
44:
45:
46: int main(int argc, char **argv)
47: {
48: pcre *re;
49: const char *error;
50: char *pattern;
51: char *subject;
52: unsigned char *name_table;
53: unsigned int option_bits;
54: int erroffset;
55: int find_all;
56: int crlf_is_newline;
57: int namecount;
58: int name_entry_size;
59: int ovector[OVECCOUNT];
60: int subject_length;
61: int rc, i;
62: int utf8;
63:
64:
65: /**************************************************************************
66: * First, sort out the command line. There is only one possible option at *
67: * the moment, "-g" to request repeated matching to find all occurrences, *
68: * like Perl's /g option. We set the variable find_all to a non-zero value *
69: * if the -g option is present. Apart from that, there must be exactly two *
70: * arguments. *
71: **************************************************************************/
72:
73: find_all = 0;
74: for (i = 1; i < argc; i++)
75: {
76: if (strcmp(argv[i], "-g") == 0) find_all = 1;
77: else break;
78: }
79:
80: /* After the options, we require exactly two arguments, which are the pattern,
81: and the subject string. */
82:
83: if (argc - i != 2)
84: {
85: printf("Two arguments required: a regex and a subject string\n");
86: return 1;
87: }
88:
89: pattern = argv[i];
90: subject = argv[i+1];
91: subject_length = (int)strlen(subject);
92:
93:
94: /*************************************************************************
95: * Now we are going to compile the regular expression pattern, and handle *
96: * and errors that are detected. *
97: *************************************************************************/
98:
99: re = pcre_compile(
100: pattern, /* the pattern */
101: 0, /* default options */
102: &error, /* for error message */
103: &erroffset, /* for error offset */
104: NULL); /* use default character tables */
105:
106: /* Compilation failed: print the error message and exit */
107:
108: if (re == NULL)
109: {
110: printf("PCRE compilation failed at offset %d: %s\n", erroffset, error);
111: return 1;
112: }
113:
114:
115: /*************************************************************************
116: * If the compilation succeeded, we call PCRE again, in order to do a *
117: * pattern match against the subject string. This does just ONE match. If *
118: * further matching is needed, it will be done below. *
119: *************************************************************************/
120:
121: rc = pcre_exec(
122: re, /* the compiled pattern */
123: NULL, /* no extra data - we didn't study the pattern */
124: subject, /* the subject string */
125: subject_length, /* the length of the subject */
126: 0, /* start at offset 0 in the subject */
127: 0, /* default options */
128: ovector, /* output vector for substring information */
129: OVECCOUNT); /* number of elements in the output vector */
130:
131: /* Matching failed: handle error cases */
132:
133: if (rc < 0)
134: {
135: switch(rc)
136: {
137: case PCRE_ERROR_NOMATCH: printf("No match\n"); break;
138: /*
139: Handle other special cases if you like
140: */
141: default: printf("Matching error %d\n", rc); break;
142: }
143: pcre_free(re); /* Release memory used for the compiled pattern */
144: return 1;
145: }
146:
147: /* Match succeded */
148:
149: printf("\nMatch succeeded at offset %d\n", ovector[0]);
150:
151:
152: /*************************************************************************
153: * We have found the first match within the subject string. If the output *
154: * vector wasn't big enough, say so. Then output any substrings that were *
155: * captured. *
156: *************************************************************************/
157:
158: /* The output vector wasn't big enough */
159:
160: if (rc == 0)
161: {
162: rc = OVECCOUNT/3;
163: printf("ovector only has room for %d captured substrings\n", rc - 1);
164: }
165:
166: /* Show substrings stored in the output vector by number. Obviously, in a real
167: application you might want to do things other than print them. */
168:
169: for (i = 0; i < rc; i++)
170: {
171: char *substring_start = subject + ovector[2*i];
172: int substring_length = ovector[2*i+1] - ovector[2*i];
173: printf("%2d: %.*s\n", i, substring_length, substring_start);
174: }
175:
176:
177: /**************************************************************************
178: * That concludes the basic part of this demonstration program. We have *
179: * compiled a pattern, and performed a single match. The code that follows *
180: * shows first how to access named substrings, and then how to code for *
181: * repeated matches on the same subject. *
182: **************************************************************************/
183:
184: /* See if there are any named substrings, and if so, show them by name. First
185: we have to extract the count of named parentheses from the pattern. */
186:
187: (void)pcre_fullinfo(
188: re, /* the compiled pattern */
189: NULL, /* no extra data - we didn't study the pattern */
190: PCRE_INFO_NAMECOUNT, /* number of named substrings */
191: &namecount); /* where to put the answer */
192:
193: if (namecount <= 0) printf("No named substrings\n"); else
194: {
195: unsigned char *tabptr;
196: printf("Named substrings\n");
197:
198: /* Before we can access the substrings, we must extract the table for
199: translating names to numbers, and the size of each entry in the table. */
200:
201: (void)pcre_fullinfo(
202: re, /* the compiled pattern */
203: NULL, /* no extra data - we didn't study the pattern */
204: PCRE_INFO_NAMETABLE, /* address of the table */
205: &name_table); /* where to put the answer */
206:
207: (void)pcre_fullinfo(
208: re, /* the compiled pattern */
209: NULL, /* no extra data - we didn't study the pattern */
210: PCRE_INFO_NAMEENTRYSIZE, /* size of each entry in the table */
211: &name_entry_size); /* where to put the answer */
212:
213: /* Now we can scan the table and, for each entry, print the number, the name,
214: and the substring itself. */
215:
216: tabptr = name_table;
217: for (i = 0; i < namecount; i++)
218: {
219: int n = (tabptr[0] << 8) | tabptr[1];
220: printf("(%d) %*s: %.*s\n", n, name_entry_size - 3, tabptr + 2,
221: ovector[2*n+1] - ovector[2*n], subject + ovector[2*n]);
222: tabptr += name_entry_size;
223: }
224: }
225:
226:
227: /*************************************************************************
228: * If the "-g" option was given on the command line, we want to continue *
229: * to search for additional matches in the subject string, in a similar *
230: * way to the /g option in Perl. This turns out to be trickier than you *
231: * might think because of the possibility of matching an empty string. *
232: * What happens is as follows: *
233: * *
234: * If the previous match was NOT for an empty string, we can just start *
235: * the next match at the end of the previous one. *
236: * *
237: * If the previous match WAS for an empty string, we can't do that, as it *
238: * would lead to an infinite loop. Instead, a special call of pcre_exec() *
239: * is made with the PCRE_NOTEMPTY_ATSTART and PCRE_ANCHORED flags set. *
240: * The first of these tells PCRE that an empty string at the start of the *
241: * subject is not a valid match; other possibilities must be tried. The *
242: * second flag restricts PCRE to one match attempt at the initial string *
243: * position. If this match succeeds, an alternative to the empty string *
244: * match has been found, and we can print it and proceed round the loop, *
245: * advancing by the length of whatever was found. If this match does not *
246: * succeed, we still stay in the loop, advancing by just one character. *
247: * In UTF-8 mode, which can be set by (*UTF8) in the pattern, this may be *
248: * more than one byte. *
249: * *
250: * However, there is a complication concerned with newlines. When the *
1.1.1.2 ! misho 251: * newline convention is such that CRLF is a valid newline, we must *
1.1 misho 252: * advance by two characters rather than one. The newline convention can *
253: * be set in the regex by (*CR), etc.; if not, we must find the default. *
254: *************************************************************************/
255:
256: if (!find_all) /* Check for -g */
257: {
258: pcre_free(re); /* Release the memory used for the compiled pattern */
259: return 0; /* Finish unless -g was given */
260: }
261:
262: /* Before running the loop, check for UTF-8 and whether CRLF is a valid newline
263: sequence. First, find the options with which the regex was compiled; extract
264: the UTF-8 state, and mask off all but the newline options. */
265:
266: (void)pcre_fullinfo(re, NULL, PCRE_INFO_OPTIONS, &option_bits);
267: utf8 = option_bits & PCRE_UTF8;
268: option_bits &= PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_CRLF|
269: PCRE_NEWLINE_ANY|PCRE_NEWLINE_ANYCRLF;
270:
271: /* If no newline options were set, find the default newline convention from the
272: build configuration. */
273:
274: if (option_bits == 0)
275: {
276: int d;
277: (void)pcre_config(PCRE_CONFIG_NEWLINE, &d);
278: /* Note that these values are always the ASCII ones, even in
279: EBCDIC environments. CR = 13, NL = 10. */
280: option_bits = (d == 13)? PCRE_NEWLINE_CR :
281: (d == 10)? PCRE_NEWLINE_LF :
282: (d == (13<<8 | 10))? PCRE_NEWLINE_CRLF :
283: (d == -2)? PCRE_NEWLINE_ANYCRLF :
284: (d == -1)? PCRE_NEWLINE_ANY : 0;
285: }
286:
287: /* See if CRLF is a valid newline sequence. */
288:
289: crlf_is_newline =
290: option_bits == PCRE_NEWLINE_ANY ||
291: option_bits == PCRE_NEWLINE_CRLF ||
292: option_bits == PCRE_NEWLINE_ANYCRLF;
293:
294: /* Loop for second and subsequent matches */
295:
296: for (;;)
297: {
298: int options = 0; /* Normally no options */
299: int start_offset = ovector[1]; /* Start at end of previous match */
300:
301: /* If the previous match was for an empty string, we are finished if we are
302: at the end of the subject. Otherwise, arrange to run another match at the
303: same point to see if a non-empty match can be found. */
304:
305: if (ovector[0] == ovector[1])
306: {
307: if (ovector[0] == subject_length) break;
308: options = PCRE_NOTEMPTY_ATSTART | PCRE_ANCHORED;
309: }
310:
311: /* Run the next matching operation */
312:
313: rc = pcre_exec(
314: re, /* the compiled pattern */
315: NULL, /* no extra data - we didn't study the pattern */
316: subject, /* the subject string */
317: subject_length, /* the length of the subject */
318: start_offset, /* starting offset in the subject */
319: options, /* options */
320: ovector, /* output vector for substring information */
321: OVECCOUNT); /* number of elements in the output vector */
322:
323: /* This time, a result of NOMATCH isn't an error. If the value in "options"
324: is zero, it just means we have found all possible matches, so the loop ends.
325: Otherwise, it means we have failed to find a non-empty-string match at a
326: point where there was a previous empty-string match. In this case, we do what
327: Perl does: advance the matching position by one character, and continue. We
328: do this by setting the "end of previous match" offset, because that is picked
329: up at the top of the loop as the point at which to start again.
330:
331: There are two complications: (a) When CRLF is a valid newline sequence, and
332: the current position is just before it, advance by an extra byte. (b)
333: Otherwise we must ensure that we skip an entire UTF-8 character if we are in
334: UTF-8 mode. */
335:
336: if (rc == PCRE_ERROR_NOMATCH)
337: {
338: if (options == 0) break; /* All matches found */
339: ovector[1] = start_offset + 1; /* Advance one byte */
340: if (crlf_is_newline && /* If CRLF is newline & */
341: start_offset < subject_length - 1 && /* we are at CRLF, */
342: subject[start_offset] == '\r' &&
343: subject[start_offset + 1] == '\n')
344: ovector[1] += 1; /* Advance by one more. */
345: else if (utf8) /* Otherwise, ensure we */
346: { /* advance a whole UTF-8 */
347: while (ovector[1] < subject_length) /* character. */
348: {
349: if ((subject[ovector[1]] & 0xc0) != 0x80) break;
350: ovector[1] += 1;
351: }
352: }
353: continue; /* Go round the loop again */
354: }
355:
356: /* Other matching errors are not recoverable. */
357:
358: if (rc < 0)
359: {
360: printf("Matching error %d\n", rc);
361: pcre_free(re); /* Release memory used for the compiled pattern */
362: return 1;
363: }
364:
365: /* Match succeded */
366:
367: printf("\nMatch succeeded again at offset %d\n", ovector[0]);
368:
369: /* The match succeeded, but the output vector wasn't big enough. */
370:
371: if (rc == 0)
372: {
373: rc = OVECCOUNT/3;
374: printf("ovector only has room for %d captured substrings\n", rc - 1);
375: }
376:
377: /* As before, show substrings stored in the output vector by number, and then
378: also any named substrings. */
379:
380: for (i = 0; i < rc; i++)
381: {
382: char *substring_start = subject + ovector[2*i];
383: int substring_length = ovector[2*i+1] - ovector[2*i];
384: printf("%2d: %.*s\n", i, substring_length, substring_start);
385: }
386:
387: if (namecount <= 0) printf("No named substrings\n"); else
388: {
389: unsigned char *tabptr = name_table;
390: printf("Named substrings\n");
391: for (i = 0; i < namecount; i++)
392: {
393: int n = (tabptr[0] << 8) | tabptr[1];
394: printf("(%d) %*s: %.*s\n", n, name_entry_size - 3, tabptr + 2,
395: ovector[2*n+1] - ovector[2*n], subject + ovector[2*n]);
396: tabptr += name_entry_size;
397: }
398: }
399: } /* End of loop to find second and subsequent matches */
400:
401: printf("\n");
402: pcre_free(re); /* Release memory used for the compiled pattern */
403: return 0;
404: }
405:
406: /* End of pcredemo.c */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to pcredemo.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