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