Annotation of embedaddon/pcre/pcredemo.c, revision 1.1
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 *
! 251: * newline convention is such that CRLF is a valid newline, we want must *
! 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