Annotation of embedaddon/pcre/pcredemo.c, revision 1.1.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>