开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
pcretest.c
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：33k
源码类别：

生物技术

开发平台：

C/C++

pcretest.c：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: pcretest.c,v $
  4.  * PRODUCTION Revision 1000.1  2004/06/14 19:04:05  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.2
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*************************************************
  11. *             PCRE testing program               *
  12. *************************************************/
  14. #include <ctype.h>
  15. #include <stdio.h>
  16. #include <string.h>
  17. #include <stdlib.h>
  18. #include <time.h>
  19. #include <locale.h>
  21. /* Use the internal info for displaying the results of pcre_study(). */
  23. #include "pcre_internal.h"
  25. /* It is possible to compile this test program without including support for
  26. testing the POSIX interface, though this is not available via the standard
  27. Makefile. */
  29. #if !defined NOPOSIX
  30. #  include "pcreposix.h"
  31. #endif
  33. #ifndef CLOCKS_PER_SEC
  34. #  ifdef CLK_TCK
  35. #    define CLOCKS_PER_SEC CLK_TCK
  36. #  else
  37. #    define CLOCKS_PER_SEC 100
  38. #  endif
  39. #endif
  41. #define LOOPREPEAT 20000
  44. static FILE *outfile;
  45. static int log_store = 0;
  46. static size_t gotten_store;
  50. static int utf8_table1[] = {
  51.   0x0000007f, 0x000007ff, 0x0000ffff, 0x001fffff, 0x03ffffff, 0x7fffffff};
  53. static int utf8_table2[] = {
  54.   0, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
  56. static int utf8_table3[] = {
  57.   0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
  60. /*************************************************
  61. *       Convert character value to UTF-8         *
  62. *************************************************/
  64. /* This function takes an integer value in the range 0 - 0x7fffffff
  65. and encodes it as a UTF-8 character in 0 to 6 bytes.
  67. Arguments:
  68.   cvalue     the character value
  69.   buffer     pointer to buffer for result - at least 6 bytes long
  71. Returns:     number of characters placed in the buffer
  72.              -1 if input character is negative
  73.              0 if input character is positive but too big (only when
  74.              int is longer than 32 bits)
  75. */
  77. static int
  78. ord2utf8(int cvalue, unsigned char *buffer)
  79. {
  80. register int i, j;
  81. for (i = 0; i < sizeof(utf8_table1)/sizeof(int); i++)
  82.   if (cvalue <= utf8_table1[i]) break;
  83. if (i >= sizeof(utf8_table1)/sizeof(int)) return 0;
  84. if (cvalue < 0) return -1;
  86. buffer += i;
  87. for (j = i; j > 0; j--)
  88.  {
  89.  *buffer-- = 0x80 | (cvalue & 0x3f);
  90.  cvalue >>= 6;
  91.  }
  92. *buffer = utf8_table2[i] | cvalue;
  93. return i + 1;
  94. }
  97. /*************************************************
  98. *            Convert UTF-8 string to value       *
  99. *************************************************/
  101. /* This function takes one or more bytes that represents a UTF-8 character,
  102. and returns the value of the character.
  104. Argument:
  105.   buffer   a pointer to the byte vector
  106.   vptr     a pointer to an int to receive the value
  108. Returns:   >  0 => the number of bytes consumed
  109.            -6 to 0 => malformed UTF-8 character at offset = (-return)
  110. */
  112. int
  113. utf82ord(unsigned char *buffer, int *vptr)
  114. {
  115. int c = *buffer++;
  116. int d = c;
  117. int i, j, s;
  119. for (i = -1; i < 6; i++)               /* i is number of additional bytes */
  120.   {
  121.   if ((d & 0x80) == 0) break;
  122.   d <<= 1;
  123.   }
  125. if (i == -1) { *vptr = c; return 1; }  /* ascii character */
  126. if (i == 0 || i == 6) return 0;        /* invalid UTF-8 */
  128. /* i now has a value in the range 1-5 */
  130. s = 6*i;
  131. d = (c & utf8_table3[i]) << s;
  133. for (j = 0; j < i; j++)
  134.   {
  135.   c = *buffer++;
  136.   if ((c & 0xc0) != 0x80) return -(j+1);
  137.   s -= 6;
  138.   d |= (c & 0x3f) << s;
  139.   }
  141. /* Check that encoding was the correct unique one */
  143. for (j = 0; j < sizeof(utf8_table1)/sizeof(int); j++)
  144.   if (d <= utf8_table1[j]) break;
  145. if (j != i) return -(i+1);
  147. /* Valid value */
  149. *vptr = d;
  150. return i+1;
  151. }
  158. /* Debugging function to print the internal form of the regex. This is the same
  159. code as contained in pcre.c under the DEBUG macro. */
  161. static const char *OP_names[] = {
  162.   "End", "\A", "\B", "\b", "\D", "\d",
  163.   "\S", "\s", "\W", "\w", "\Z", "\z",
  164.   "Opt", "^", "$", "Any", "chars", "not",
  165.   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
  166.   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
  167.   "*", "*?", "+", "+?", "?", "??", "{", "{", "{",
  168.   "*", "*?", "+", "+?", "?", "??", "{", "{",
  169.   "class", "Ref", "Recurse",
  170.   "Alt", "Ket", "KetRmax", "KetRmin", "Assert", "Assert not",
  171.   "AssertB", "AssertB not", "Reverse", "Once", "Cond", "Cref",
  172.   "Brazero", "Braminzero", "Branumber", "Bra"
  173. };
  176. static void print_internals(pcre *re)
  177. {
  178. unsigned char *code = ((real_pcre *)re)->code;
  180. fprintf(outfile, "------------------------------------------------------------------n");
  182. for(;;)
  183.   {
  184.   int c;
  185.   int charlength;
  187.   fprintf(outfile, "%3d ", (int)(code - ((real_pcre *)re)->code));
  189.   if (*code >= OP_BRA)
  190.     {
  191.     if (*code - OP_BRA > EXTRACT_BASIC_MAX)
  192.       fprintf(outfile, "%3d Bra extra", (code[1] << 8) + code[2]);
  193.     else
  194.       fprintf(outfile, "%3d Bra %d", (code[1] << 8) + code[2], *code - OP_BRA);
  195.     code += 2;
  196.     }
  198.   else switch(*code)
  199.     {
  200.     case OP_END:
  201.     fprintf(outfile, "    %sn", OP_names[*code]);
  202.     fprintf(outfile, "------------------------------------------------------------------n");
  203.     return;
  205.     case OP_OPT:
  206.     fprintf(outfile, " %.2x %s", code[1], OP_names[*code]);
  207.     code++;
  208.     break;
  210.     case OP_CHARS:
  211.     charlength = *(++code);
  212.     fprintf(outfile, "%3d ", charlength);
  213.     while (charlength-- > 0)
  214.       if (isprint(c = *(++code))) fprintf(outfile, "%c", c);
  215.         else fprintf(outfile, "\x%02x", c);
  216.     break;
  218.     case OP_KETRMAX:
  219.     case OP_KETRMIN:
  220.     case OP_ALT:
  221.     case OP_KET:
  222.     case OP_ASSERT:
  223.     case OP_ASSERT_NOT:
  224.     case OP_ASSERTBACK:
  225.     case OP_ASSERTBACK_NOT:
  226.     case OP_ONCE:
  227.     case OP_COND:
  228.     case OP_BRANUMBER:
  229.     case OP_REVERSE:
  230.     case OP_CREF:
  231.     fprintf(outfile, "%3d %s", (code[1] << 8) + code[2], OP_names[*code]);
  232.     code += 2;
  233.     break;
  235.     case OP_STAR:
  236.     case OP_MINSTAR:
  237.     case OP_PLUS:
  238.     case OP_MINPLUS:
  239.     case OP_QUERY:
  240.     case OP_MINQUERY:
  241.     case OP_TYPESTAR:
  242.     case OP_TYPEMINSTAR:
  243.     case OP_TYPEPLUS:
  244.     case OP_TYPEMINPLUS:
  245.     case OP_TYPEQUERY:
  246.     case OP_TYPEMINQUERY:
  247.     if (*code >= OP_TYPESTAR)
  248.       fprintf(outfile, "    %s", OP_names[code[1]]);
  249.     else if (isprint(c = code[1])) fprintf(outfile, "    %c", c);
  250.       else fprintf(outfile, "    \x%02x", c);
  251.     fprintf(outfile, "%s", OP_names[*code++]);
  252.     break;
  254.     case OP_EXACT:
  255.     case OP_UPTO:
  256.     case OP_MINUPTO:
  257.     if (isprint(c = code[3])) fprintf(outfile, "    %c{", c);
  258.       else fprintf(outfile, "    \x%02x{", c);
  259.     if (*code != OP_EXACT) fprintf(outfile, ",");
  260.     fprintf(outfile, "%d}", (code[1] << 8) + code[2]);
  261.     if (*code == OP_MINUPTO) fprintf(outfile, "?");
  262.     code += 3;
  263.     break;
  265.     case OP_TYPEEXACT:
  266.     case OP_TYPEUPTO:
  267.     case OP_TYPEMINUPTO:
  268.     fprintf(outfile, "    %s{", OP_names[code[3]]);
  269.     if (*code != OP_TYPEEXACT) fprintf(outfile, "0,");
  270.     fprintf(outfile, "%d}", (code[1] << 8) + code[2]);
  271.     if (*code == OP_TYPEMINUPTO) fprintf(outfile, "?");
  272.     code += 3;
  273.     break;
  275.     case OP_NOT:
  276.     if (isprint(c = *(++code))) fprintf(outfile, "    [^%c]", c);
  277.       else fprintf(outfile, "    [^\x%02x]", c);
  278.     break;
  280.     case OP_NOTSTAR:
  281.     case OP_NOTMINSTAR:
  282.     case OP_NOTPLUS:
  283.     case OP_NOTMINPLUS:
  284.     case OP_NOTQUERY:
  285.     case OP_NOTMINQUERY:
  286.     if (isprint(c = code[1])) fprintf(outfile, "    [^%c]", c);
  287.       else fprintf(outfile, "    [^\x%02x]", c);
  288.     fprintf(outfile, "%s", OP_names[*code++]);
  289.     break;
  291.     case OP_NOTEXACT:
  292.     case OP_NOTUPTO:
  293.     case OP_NOTMINUPTO:
  294.     if (isprint(c = code[3])) fprintf(outfile, "    [^%c]{", c);
  295.       else fprintf(outfile, "    [^\x%02x]{", c);
  296.     if (*code != OP_NOTEXACT) fprintf(outfile, ",");
  297.     fprintf(outfile, "%d}", (code[1] << 8) + code[2]);
  298.     if (*code == OP_NOTMINUPTO) fprintf(outfile, "?");
  299.     code += 3;
  300.     break;
  302.     case OP_REF:
  303.     fprintf(outfile, "    \%d", (code[1] << 8) | code[2]);
  304.     code += 3;
  305.     goto CLASS_REF_REPEAT;
  307.     case OP_CLASS:
  308.       {
  309.       int i, min, max;
  310.       code++;
  311.       fprintf(outfile, "    [");
  313.       for (i = 0; i < 256; i++)
  314.         {
  315.         if ((code[i/8] & (1 << (i&7))) != 0)
  316.           {
  317.           int j;
  318.           for (j = i+1; j < 256; j++)
  319.             if ((code[j/8] & (1 << (j&7))) == 0) break;
  320.           if (i == '-' || i == ']') fprintf(outfile, "\");
  321.           if (isprint(i)) fprintf(outfile, "%c", i); else fprintf(outfile, "\x%02x", i);
  322.           if (--j > i)
  323.             {
  324.             fprintf(outfile, "-");
  325.             if (j == '-' || j == ']') fprintf(outfile, "\");
  326.             if (isprint(j)) fprintf(outfile, "%c", j); else fprintf(outfile, "\x%02x", j);
  327.             }
  328.           i = j;
  329.           }
  330.         }
  331.       fprintf(outfile, "]");
  332.       code += 32;
  334.       CLASS_REF_REPEAT:
  336.       switch(*code)
  337.         {
  338.         case OP_CRSTAR:
  339.         case OP_CRMINSTAR:
  340.         case OP_CRPLUS:
  341.         case OP_CRMINPLUS:
  342.         case OP_CRQUERY:
  343.         case OP_CRMINQUERY:
  344.         fprintf(outfile, "%s", OP_names[*code]);
  345.         break;
  347.         case OP_CRRANGE:
  348.         case OP_CRMINRANGE:
  349.         min = (code[1] << 8) + code[2];
  350.         max = (code[3] << 8) + code[4];
  351.         if (max == 0) fprintf(outfile, "{%d,}", min);
  352.         else fprintf(outfile, "{%d,%d}", min, max);
  353.         if (*code == OP_CRMINRANGE) fprintf(outfile, "?");
  354.         code += 4;
  355.         break;
  357.         default:
  358.         code--;
  359.         }
  360.       }
  361.     break;
  363.     /* Anything else is just a one-node item */
  365.     default:
  366.     fprintf(outfile, "    %s", OP_names[*code]);
  367.     break;
  368.     }
  370.   code++;
  371.   fprintf(outfile, "n");
  372.   }
  373. }
  377. /* Character string printing function. A "normal" and a UTF-8 version. */
  379. static void pchars(unsigned char *p, int length, int utf8)
  380. {
  381. int c;
  382. while (length-- > 0)
  383.   {
  384.   if (utf8)
  385.     {
  386.     int rc = utf82ord(p, &c);
  387.     if (rc > 0)
  388.       {
  389.       length -= rc - 1;
  390.       p += rc;
  391.       if (c < 256 && isprint(c)) fprintf(outfile, "%c", c);
  392.         else fprintf(outfile, "\x{%02x}", c);
  393.       continue;
  394.       }
  395.     }
  397.    /* Not UTF-8, or malformed UTF-8  */
  399.   if (isprint(c = *(p++))) fprintf(outfile, "%c", c);
  400.     else fprintf(outfile, "\x%02x", c);
  401.   }
  402. }
  406. /* Alternative malloc function, to test functionality and show the size of the
  407. compiled re. */
  409. static void *new_malloc(size_t size)
  410. {
  411. gotten_store = size;
  412. if (log_store)
  413.   fprintf(outfile, "Memory allocation (code space): %dn",
  414.     (int)((int)size - offsetof(real_pcre, code[0])));
  415. return malloc(size);
  416. }
  421. /* Get one piece of information from the pcre_fullinfo() function */
  423. static void new_info(pcre *re, pcre_extra *study, int option, void *ptr)
  424. {
  425. int rc;
  426. if ((rc = pcre_fullinfo(re, study, option, ptr)) < 0)
  427.   fprintf(outfile, "Error %d from pcre_fullinfo(%d)n", rc, option);
  428. }
  433. /* Read lines from named file or stdin and write to named file or stdout; lines
  434. consist of a regular expression, in delimiters and optionally followed by
  435. options, followed by a set of test data, terminated by an empty line. */
  437. int main(int argc, char **argv)
  438. {
  439. FILE *infile = stdin;
  440. int options = 0;
  441. int study_options = 0;
  442. int op = 1;
  443. int timeit = 0;
  444. int showinfo = 0;
  445. int showstore = 0;
  446. int size_offsets = 45;
  447. int size_offsets_max;
  448. int *offsets;
  449. #if !defined NOPOSIX
  450. int posix = 0;
  451. #endif
  452. int debug = 0;
  453. int done = 0;
  454. unsigned char buffer[30000];
  455. unsigned char dbuffer[1024];
  457. /* Static so that new_malloc can use it. */
  459. outfile = stdout;
  461. /* Scan options */
  463. while (argc > 1 && argv[op][0] == '-')
  464.   {
  465.   char *endptr;
  467.   if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)
  468.     showstore = 1;
  469.   else if (strcmp(argv[op], "-t") == 0) timeit = 1;
  470.   else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
  471.   else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;
  472.   else if (strcmp(argv[op], "-o") == 0 && argc > 2 &&
  473.       ((size_offsets = (int)strtoul(argv[op+1], &endptr, 10)), *endptr == 0))
  474.     {
  475.     op++;
  476.     argc--;
  477.     }
  478. #if !defined NOPOSIX
  479.   else if (strcmp(argv[op], "-p") == 0) posix = 1;
  480. #endif
  481.   else
  482.     {
  483.     printf("** Unknown or malformed option %sn", argv[op]);
  484.     printf("Usage:   pcretest [-d] [-i] [-o <n>] [-p] [-s] [-t] [<input> [<output>]]n");
  485.     printf("  -d     debug: show compiled code; implies -in"
  486.            "  -i     show information about compiled patternn"
  487.            "  -o <n> set size of offsets vector to <n>n");
  488. #if !defined NOPOSIX
  489.     printf("  -p     use POSIX interfacen");
  490. #endif
  491.     printf("  -s     output store informationn"
  492.            "  -t     time compilation and executionn");
  493.     return 1;
  494.     }
  495.   op++;
  496.   argc--;
  497.   }
  499. /* Get the store for the offsets vector, and remember what it was */
  501. size_offsets_max = size_offsets;
  502. offsets = malloc(size_offsets_max * sizeof(int));
  503. if (offsets == NULL)
  504.   {
  505.   printf("** Failed to get %d bytes of memory for offsets vectorn",
  506.     size_offsets_max * sizeof(int));
  507.   return 1;
  508.   }
  510. /* Sort out the input and output files */
  512. if (argc > 1)
  513.   {
  514.   infile = fopen(argv[op], "r");
  515.   if (infile == NULL)
  516.     {
  517.     printf("** Failed to open %sn", argv[op]);
  518.     return 1;
  519.     }
  520.   }
  522. if (argc > 2)
  523.   {
  524.   outfile = fopen(argv[op+1], "wb");
  525.   if (outfile == NULL)
  526.     {
  527.     printf("** Failed to open %sn", argv[op+1]);
  528.     return 1;
  529.     }
  530.   }
  532. /* Set alternative malloc function */
  534. pcre_malloc = new_malloc;
  536. /* Heading line, then prompt for first regex if stdin */
  538. fprintf(outfile, "PCRE version %snn", pcre_version());
  540. /* Main loop */
  542. while (!done)
  543.   {
  544.   pcre *re = NULL;
  545.   pcre_extra *extra = NULL;
  547. #if !defined NOPOSIX  /* There are still compilers that require no indent */
  548.   regex_t preg;
  549.   int do_posix = 0;
  550. #endif
  552.   const char *error;
  553.   unsigned char *p, *pp, *ppp;
  554.   const unsigned char *tables = NULL;
  555.   int do_study = 0;
  556.   int do_debug = debug;
  557.   int do_G = 0;
  558.   int do_g = 0;
  559.   int do_showinfo = showinfo;
  560.   int do_showrest = 0;
  561.   int utf8 = 0;
  562.   int erroroffset, len, delimiter;
  564.   if (infile == stdin) printf("  re> ");
  565.   if (fgets((char *)buffer, sizeof(buffer), infile) == NULL) break;
  566.   if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
  568.   p = buffer;
  569.   while (isspace(*p)) p++;
  570.   if (*p == 0) continue;
  572.   /* Get the delimiter and seek the end of the pattern; if is isn't
  573.   complete, read more. */
  575.   delimiter = *p++;
  577.   if (isalnum(delimiter) || delimiter == '\')
  578.     {
  579.     fprintf(outfile, "** Delimiter must not be alphameric or \n");
  580.     goto SKIP_DATA;
  581.     }
  583.   pp = p;
  585.   for(;;)
  586.     {
  587.     while (*pp != 0)
  588.       {
  589.       if (*pp == '\' && pp[1] != 0) pp++;
  590.         else if (*pp == delimiter) break;
  591.       pp++;
  592.       }
  593.     if (*pp != 0) break;
  595.     len = sizeof(buffer) - (pp - buffer);
  596.     if (len < 256)
  597.       {
  598.       fprintf(outfile, "** Expression too long - missing delimiter?n");
  599.       goto SKIP_DATA;
  600.       }
  602.     if (infile == stdin) printf("    > ");
  603.     if (fgets((char *)pp, len, infile) == NULL)
  604.       {
  605.       fprintf(outfile, "** Unexpected EOFn");
  606.       done = 1;
  607.       goto CONTINUE;
  608.       }
  609.     if (infile != stdin) fprintf(outfile, "%s", (char *)pp);
  610.     }
  612.   /* If the first character after the delimiter is backslash, make
  613.   the pattern end with backslash. This is purely to provide a way
  614.   of testing for the error message when a pattern ends with backslash. */
  616.   if (pp[1] == '\') *pp++ = '\';
  618.   /* Terminate the pattern at the delimiter */
  620.   *pp++ = 0;
  622.   /* Look for options after final delimiter */
  624.   options = 0;
  625.   study_options = 0;
  626.   log_store = showstore;  /* default from command line */
  628.   while (*pp != 0)
  629.     {
  630.     switch (*pp++)
  631.       {
  632.       case 'g': do_g = 1; break;
  633.       case 'i': options |= PCRE_CASELESS; break;
  634.       case 'm': options |= PCRE_MULTILINE; break;
  635.       case 's': options |= PCRE_DOTALL; break;
  636.       case 'x': options |= PCRE_EXTENDED; break;
  638.       case '+': do_showrest = 1; break;
  639.       case 'A': options |= PCRE_ANCHORED; break;
  640.       case 'D': do_debug = do_showinfo = 1; break;
  641.       case 'E': options |= PCRE_DOLLAR_ENDONLY; break;
  642.       case 'G': do_G = 1; break;
  643.       case 'I': do_showinfo = 1; break;
  644.       case 'M': log_store = 1; break;
  646. #if !defined NOPOSIX
  647.       case 'P': do_posix = 1; break;
  648. #endif
  650.       case 'S': do_study = 1; break;
  651.       case 'U': options |= PCRE_UNGREEDY; break;
  652.       case 'X': options |= PCRE_EXTRA; break;
  653.       case '8': options |= PCRE_UTF8; utf8 = 1; break;
  655.       case 'L':
  656.       ppp = pp;
  657.       while (*ppp != 'n' && *ppp != ' ') ppp++;
  658.       *ppp = 0;
  659.       if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
  660.         {
  661.         fprintf(outfile, "** Failed to set locale "%s"n", pp);
  662.         goto SKIP_DATA;
  663.         }
  664.       tables = pcre_maketables();
  665.       pp = ppp;
  666.       break;
  668.       case 'n': case ' ': break;
  669.       default:
  670.       fprintf(outfile, "** Unknown option '%c'n", pp[-1]);
  671.       goto SKIP_DATA;
  672.       }
  673.     }
  675.   /* Handle compiling via the POSIX interface, which doesn't support the
  676.   timing, showing, or debugging options, nor the ability to pass over
  677.   local character tables. */
  679. #if !defined NOPOSIX
  680.   if (posix || do_posix)
  681.     {
  682.     int rc;
  683.     int cflags = 0;
  684.     if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE;
  685.     if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE;
  686.     rc = regcomp(&preg, (char *)p, cflags);
  688.     /* Compilation failed; go back for another re, skipping to blank line
  689.     if non-interactive. */
  691.     if (rc != 0)
  692.       {
  693.       (void)regerror(rc, &preg, (char *)buffer, sizeof(buffer));
  694.       fprintf(outfile, "Failed: POSIX code %d: %sn", rc, buffer);
  695.       goto SKIP_DATA;
  696.       }
  697.     }
  699.   /* Handle compiling via the native interface */
  701.   else
  702. #endif  /* !defined NOPOSIX */
  704.     {
  705.     if (timeit)
  706.       {
  707.       register int i;
  708.       clock_t time_taken;
  709.       clock_t start_time = clock();
  710.       for (i = 0; i < LOOPREPEAT; i++)
  711.         {
  712.         re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
  713.         if (re != NULL) free(re);
  714.         }
  715.       time_taken = clock() - start_time;
  716.       fprintf(outfile, "Compile time %.3f millisecondsn",
  717.         ((double)time_taken * 1000.0) /
  718.         ((double)LOOPREPEAT * (double)CLOCKS_PER_SEC));
  719.       }
  721.     re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
  723.     /* Compilation failed; go back for another re, skipping to blank line
  724.     if non-interactive. */
  726.     if (re == NULL)
  727.       {
  728.       fprintf(outfile, "Failed: %s at offset %dn", error, erroroffset);
  729.       SKIP_DATA:
  730.       if (infile != stdin)
  731.         {
  732.         for (;;)
  733.           {
  734.           if (fgets((char *)buffer, sizeof(buffer), infile) == NULL)
  735.             {
  736.             done = 1;
  737.             goto CONTINUE;
  738.             }
  739.           len = (int)strlen((char *)buffer);
  740.           while (len > 0 && isspace(buffer[len-1])) len--;
  741.           if (len == 0) break;
  742.           }
  743.         fprintf(outfile, "n");
  744.         }
  745.       goto CONTINUE;
  746.       }
  748.     /* Compilation succeeded; print data if required. There are now two
  749.     info-returning functions. The old one has a limited interface and
  750.     returns only limited data. Check that it agrees with the newer one. */
  752.     if (do_showinfo)
  753.       {
  754.       unsigned long int get_options;
  755.       int old_first_char, old_options, old_count;
  756.       int count, backrefmax, first_char, need_char;
  757.       size_t size;
  759.       if (do_debug) print_internals(re);
  761.       new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
  762.       new_info(re, NULL, PCRE_INFO_SIZE, &size);
  763.       new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
  764.       new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax);
  765.       new_info(re, NULL, PCRE_INFO_FIRSTCHAR, &first_char);
  766.       new_info(re, NULL, PCRE_INFO_LASTLITERAL, &need_char);
  768.       old_count = pcre_info(re, &old_options, &old_first_char);
  769.       if (count < 0) fprintf(outfile,
  770.         "Error %d from pcre_info()n", count);
  771.       else
  772.         {
  773.         if (old_count != count) fprintf(outfile,
  774.           "Count disagreement: pcre_fullinfo=%d pcre_info=%dn", count,
  775.             old_count);
  777.         if (old_first_char != first_char) fprintf(outfile,
  778.           "First char disagreement: pcre_fullinfo=%d pcre_info=%dn",
  779.             first_char, old_first_char);
  781.         if (old_options != (int)get_options) fprintf(outfile,
  782.           "Options disagreement: pcre_fullinfo=%ld pcre_info=%dn",
  783.             get_options, old_options);
  784.         }
  786.       if (size != gotten_store) fprintf(outfile,
  787.         "Size disagreement: pcre_fullinfo=%d call to malloc for %dn",
  788.         size, gotten_store);
  790.       fprintf(outfile, "Capturing subpattern count = %dn", count);
  791.       if (backrefmax > 0)
  792.         fprintf(outfile, "Max back reference = %dn", backrefmax);
  793.       if (get_options == 0) fprintf(outfile, "No optionsn");
  794.         else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%sn",
  795.           ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
  796.           ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
  797.           ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
  798.           ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "",
  799.           ((get_options & PCRE_DOTALL) != 0)? " dotall" : "",
  800.           ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "",
  801.           ((get_options & PCRE_EXTRA) != 0)? " extra" : "",
  802.           ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",
  803.           ((get_options & PCRE_UTF8) != 0)? " utf8" : "");
  805.       if (((((real_pcre *)re)->options) & PCRE_ICHANGED) != 0)
  806.         fprintf(outfile, "Case state changesn");
  808.       if (first_char == -1)
  809.         {
  810.         fprintf(outfile, "First char at start or follows \nn");
  811.         }
  812.       else if (first_char < 0)
  813.         {
  814.         fprintf(outfile, "No first charn");
  815.         }
  816.       else
  817.         {
  818.         if (isprint(first_char))
  819.           fprintf(outfile, "First char = '%c'n", first_char);
  820.         else
  821.           fprintf(outfile, "First char = %dn", first_char);
  822.         }
  824.       if (need_char < 0)
  825.         {
  826.         fprintf(outfile, "No need charn");
  827.         }
  828.       else
  829.         {
  830.         if (isprint(need_char))
  831.           fprintf(outfile, "Need char = '%c'n", need_char);
  832.         else
  833.           fprintf(outfile, "Need char = %dn", need_char);
  834.         }
  835.       }
  837.     /* If /S was present, study the regexp to generate additional info to
  838.     help with the matching. */
  840.     if (do_study)
  841.       {
  842.       if (timeit)
  843.         {
  844.         register int i;
  845.         clock_t time_taken;
  846.         clock_t start_time = clock();
  847.         for (i = 0; i < LOOPREPEAT; i++)
  848.           extra = pcre_study(re, study_options, &error);
  849.         time_taken = clock() - start_time;
  850.         if (extra != NULL) free(extra);
  851.         fprintf(outfile, "  Study time %.3f millisecondsn",
  852.           ((double)time_taken * 1000.0)/
  853.           ((double)LOOPREPEAT * (double)CLOCKS_PER_SEC));
  854.         }
  856.       extra = pcre_study(re, study_options, &error);
  857.       if (error != NULL)
  858.         fprintf(outfile, "Failed to study: %sn", error);
  859.       else if (extra == NULL)
  860.         fprintf(outfile, "Study returned NULLn");
  862.       else if (do_showinfo)
  863.         {
  864.         uschar *start_bits = NULL;
  865.         new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits);
  866.         if (start_bits == NULL)
  867.           fprintf(outfile, "No starting character setn");
  868.         else
  869.           {
  870.           int i;
  871.           int c = 24;
  872.           fprintf(outfile, "Starting character set: ");
  873.           for (i = 0; i < 256; i++)
  874.             {
  875.             if ((start_bits[i/8] & (1<<(i%8))) != 0)
  876.               {
  877.               if (c > 75)
  878.                 {
  879.                 fprintf(outfile, "n  ");
  880.                 c = 2;
  881.                 }
  882.               if (isprint(i) && i != ' ')
  883.                 {
  884.                 fprintf(outfile, "%c ", i);
  885.                 c += 2;
  886.                 }
  887.               else
  888.                 {
  889.                 fprintf(outfile, "\x%02x ", i);
  890.                 c += 5;
  891.                 }
  892.               }
  893.             }
  894.           fprintf(outfile, "n");
  895.           }
  896.         }
  897.       }
  898.     }
  900.   /* Read data lines and test them */
  902.   for (;;)
  903.     {
  904.     unsigned char *q;
  905.     unsigned char *bptr = dbuffer;
  906.     int *use_offsets = offsets;
  907.     int use_size_offsets = size_offsets;
  908.     int count, c;
  909.     int copystrings = 0;
  910.     int getstrings = 0;
  911.     int getlist = 0;
  912.     int gmatched = 0;
  913.     int start_offset = 0;
  914.     int g_notempty = 0;
  916.     options = 0;
  918.     if (infile == stdin) printf("data> ");
  919.     if (fgets((char *)buffer, sizeof(buffer), infile) == NULL)
  920.       {
  921.       done = 1;
  922.       goto CONTINUE;
  923.       }
  924.     if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
  926.     len = (int)strlen((char *)buffer);
  927.     while (len > 0 && isspace(buffer[len-1])) len--;
  928.     buffer[len] = 0;
  929.     if (len == 0) break;
  931.     p = buffer;
  932.     while (isspace(*p)) p++;
  934.     q = dbuffer;
  935.     while ((c = *p++) != 0)
  936.       {
  937.       int i = 0;
  938.       int n = 0;
  939.       if (c == '\') switch ((c = *p++))
  940.         {
  941.         case 'a': c =    7; break;
  942.         case 'b': c = 'b'; break;
  943.         case 'e': c =   27; break;
  944.         case 'f': c = 'f'; break;
  945.         case 'n': c = 'n'; break;
  946.         case 'r': c = 'r'; break;
  947.         case 't': c = 't'; break;
  948.         case 'v': c = 'v'; break;
  950.         case '0': case '1': case '2': case '3':
  951.         case '4': case '5': case '6': case '7':
  952.         c -= '0';
  953.         while (i++ < 2 && isdigit(*p) && *p != '8' && *p != '9')
  954.           c = c * 8 + *p++ - '0';
  955.         break;
  957.         case 'x':
  959.         /* Handle x{..} specially - new Perl thing for utf8 */
  961.         if (*p == '{')
  962.           {
  963.           unsigned char *pt = p;
  964.           c = 0;
  965.           while (isxdigit(*(++pt)))
  966.             c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'W');
  967.           if (*pt == '}')
  968.             {
  969.             unsigned char buffer[8];
  970.             int ii, utn;
  971.             utn = ord2utf8(c, buffer);
  972.             for (ii = 0; ii < utn - 1; ii++) *q++ = buffer[ii];
  973.             c = buffer[ii];   /* Last byte */
  974.             p = pt + 1;
  975.             break;
  976.             }
  977.           /* Not correct form; fall through */
  978.           }
  980.         /* Ordinary x */
  982.         c = 0;
  983.         while (i++ < 2 && isxdigit(*p))
  984.           {
  985.           c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'W');
  986.           p++;
  987.           }
  988.         break;
  990.         case 0:   /* Allows for an empty line */
  991.         p--;
  992.         continue;
  994.         case 'A':  /* Option setting */
  995.         options |= PCRE_ANCHORED;
  996.         continue;
  998.         case 'B':
  999.         options |= PCRE_NOTBOL;
  1000.         continue;
  1002.         case 'C':
  1003.         while(isdigit(*p)) n = n * 10 + *p++ - '0';
  1004.         copystrings |= 1 << n;
  1005.         continue;
  1007.         case 'G':
  1008.         while(isdigit(*p)) n = n * 10 + *p++ - '0';
  1009.         getstrings |= 1 << n;
  1010.         continue;
  1012.         case 'L':
  1013.         getlist = 1;
  1014.         continue;
  1016.         case 'N':
  1017.         options |= PCRE_NOTEMPTY;
  1018.         continue;
  1020.         case 'O':
  1021.         while(isdigit(*p)) n = n * 10 + *p++ - '0';
  1022.         if (n > size_offsets_max)
  1023.           {
  1024.           size_offsets_max = n;
  1025.           free(offsets);
  1026.           use_offsets = offsets = malloc(size_offsets_max * sizeof(int));
  1027.           if (offsets == NULL)
  1028.             {
  1029.             printf("** Failed to get %d bytes of memory for offsets vectorn",
  1030.               size_offsets_max * sizeof(int));
  1031.             return 1;
  1032.             }
  1033.           }
  1034.         use_size_offsets = n;
  1035.         if (n == 0) use_offsets = NULL;
  1036.         continue;
  1038.         case 'Z':
  1039.         options |= PCRE_NOTEOL;
  1040.         continue;
  1041.         }
  1042.       *q++ = c;
  1043.       }
  1044.     *q = 0;
  1045.     len = q - dbuffer;
  1047.     /* Handle matching via the POSIX interface, which does not
  1048.     support timing. */
  1050. #if !defined NOPOSIX
  1051.     if (posix || do_posix)
  1052.       {
  1053.       int rc;
  1054.       int eflags = 0;
  1055.       regmatch_t *pmatch = malloc(sizeof(regmatch_t) * use_size_offsets);
  1056.       if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL;
  1057.       if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL;
  1059.       rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags);
  1061.       if (rc != 0)
  1062.         {
  1063.         (void)regerror(rc, &preg, (char *)buffer, sizeof(buffer));
  1064.         fprintf(outfile, "No match: POSIX code %d: %sn", rc, buffer);
  1065.         }
  1066.       else
  1067.         {
  1068.         size_t i;
  1069.         for (i = 0; i < (size_t)use_size_offsets; i++)
  1070.           {
  1071.           if (pmatch[i].rm_so >= 0)
  1072.             {
  1073.             fprintf(outfile, "%2d: ", (int)i);
  1074.             pchars(dbuffer + pmatch[i].rm_so,
  1075.               pmatch[i].rm_eo - pmatch[i].rm_so, utf8);
  1076.             fprintf(outfile, "n");
  1077.             if (i == 0 && do_showrest)
  1078.               {
  1079.               fprintf(outfile, " 0+ ");
  1080.               pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo, utf8);
  1081.               fprintf(outfile, "n");
  1082.               }
  1083.             }
  1084.           }
  1085.         }
  1086.       free(pmatch);
  1087.       }
  1089.     /* Handle matching via the native interface - repeats for /g and /G */
  1091.     else
  1092. #endif  /* !defined NOPOSIX */
  1094.     for (;; gmatched++)    /* Loop for /g or /G */
  1095.       {
  1096.       if (timeit)
  1097.         {
  1098.         register int i;
  1099.         clock_t time_taken;
  1100.         clock_t start_time = clock();
  1101.         for (i = 0; i < LOOPREPEAT; i++)
  1102.           count = pcre_exec(re, extra, (char *)bptr, len,
  1103.             start_offset, options | g_notempty, use_offsets, use_size_offsets);
  1104.         time_taken = clock() - start_time;
  1105.         fprintf(outfile, "Execute time %.3f millisecondsn",
  1106.           ((double)time_taken * 1000.0)/
  1107.           ((double)LOOPREPEAT * (double)CLOCKS_PER_SEC));
  1108.         }
  1110.       count = pcre_exec(re, extra, (char *)bptr, len,
  1111.         start_offset, options | g_notempty, use_offsets, use_size_offsets);
  1113.       if (count == 0)
  1114.         {
  1115.         fprintf(outfile, "Matched, but too many substringsn");
  1116.         count = use_size_offsets/3;
  1117.         }
  1119.       /* Matched */
  1121.       if (count >= 0)
  1122.         {
  1123.         int i;
  1124.         for (i = 0; i < count * 2; i += 2)
  1125.           {
  1126.           if (use_offsets[i] < 0)
  1127.             fprintf(outfile, "%2d: <unset>n", i/2);
  1128.           else
  1129.             {
  1130.             fprintf(outfile, "%2d: ", i/2);
  1131.             pchars(bptr + use_offsets[i], use_offsets[i+1] - use_offsets[i], utf8);
  1132.             fprintf(outfile, "n");
  1133.             if (i == 0)
  1134.               {
  1135.               if (do_showrest)
  1136.                 {
  1137.                 fprintf(outfile, " 0+ ");
  1138.                 pchars(bptr + use_offsets[i+1], len - use_offsets[i+1], utf8);
  1139.                 fprintf(outfile, "n");
  1140.                 }
  1141.               }
  1142.             }
  1143.           }
  1145.         for (i = 0; i < 32; i++)
  1146.           {
  1147.           if ((copystrings & (1 << i)) != 0)
  1148.             {
  1149.             char copybuffer[16];
  1150.             int rc = pcre_copy_substring((char *)bptr, use_offsets, count,
  1151.               i, copybuffer, sizeof(copybuffer));
  1152.             if (rc < 0)
  1153.               fprintf(outfile, "copy substring %d failed %dn", i, rc);
  1154.             else
  1155.               fprintf(outfile, "%2dC %s (%d)n", i, copybuffer, rc);
  1156.             }
  1157.           }
  1159.         for (i = 0; i < 32; i++)
  1160.           {
  1161.           if ((getstrings & (1 << i)) != 0)
  1162.             {
  1163.             const char *substring;
  1164.             int rc = pcre_get_substring((char *)bptr, use_offsets, count,
  1165.               i, &substring);
  1166.             if (rc < 0)
  1167.               fprintf(outfile, "get substring %d failed %dn", i, rc);
  1168.             else
  1169.               {
  1170.               fprintf(outfile, "%2dG %s (%d)n", i, substring, rc);
  1171.               /* free((void *)substring); */
  1172.               pcre_free_substring(substring);
  1173.               }
  1174.             }
  1175.           }
  1177.         if (getlist)
  1178.           {
  1179.           const char **stringlist;
  1180.           int rc = pcre_get_substring_list((char *)bptr, use_offsets, count,
  1181.             &stringlist);
  1182.           if (rc < 0)
  1183.             fprintf(outfile, "get substring list failed %dn", rc);
  1184.           else
  1185.             {
  1186.             for (i = 0; i < count; i++)
  1187.               fprintf(outfile, "%2dL %sn", i, stringlist[i]);
  1188.             if (stringlist[i] != NULL)
  1189.               fprintf(outfile, "string list not terminated by NULLn");
  1190.             /* free((void *)stringlist); */
  1191.             pcre_free_substring_list(stringlist);
  1192.             }
  1193.           }
  1194.         }
  1196.       /* Failed to match. If this is a /g or /G loop and we previously set
  1197.       g_notempty after a null match, this is not necessarily the end.
  1198.       We want to advance the start offset, and continue. Fudge the offset
  1199.       values to achieve this. We won't be at the end of the string - that
  1200.       was checked before setting g_notempty. */
  1202.       else
  1203.         {
  1204.         if (g_notempty != 0)
  1205.           {
  1206.           use_offsets[0] = start_offset;
  1207.           use_offsets[1] = start_offset + 1;
  1208.           }
  1209.         else
  1210.           {
  1211.           if (gmatched == 0)   /* Error if no previous matches */
  1212.             {
  1213.             if (count == -1) fprintf(outfile, "No matchn");
  1214.               else fprintf(outfile, "Error %dn", count);
  1215.             }
  1216.           break;  /* Out of the /g loop */
  1217.           }
  1218.         }
  1220.       /* If not /g or /G we are done */
  1222.       if (!do_g && !do_G) break;
  1224.       /* If we have matched an empty string, first check to see if we are at
  1225.       the end of the subject. If so, the /g loop is over. Otherwise, mimic
  1226.       what Perl's /g options does. This turns out to be rather cunning. First
  1227.       we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match again at the
  1228.       same point. If this fails (picked up above) we advance to the next
  1229.       character. */
  1231.       g_notempty = 0;
  1232.       if (use_offsets[0] == use_offsets[1])
  1233.         {
  1234.         if (use_offsets[0] == len) break;
  1235.         g_notempty = PCRE_NOTEMPTY | PCRE_ANCHORED;
  1236.         }
  1238.       /* For /g, update the start offset, leaving the rest alone */
  1240.       if (do_g) start_offset = use_offsets[1];
  1242.       /* For /G, update the pointer and length */
  1244.       else
  1245.         {
  1246.         bptr += use_offsets[1];
  1247.         len -= use_offsets[1];
  1248.         }
  1249.       }  /* End of loop for /g and /G */
  1250.     }    /* End of loop for data lines */
  1252.   CONTINUE:
  1254. #if !defined NOPOSIX
  1255.   if (posix || do_posix) regfree(&preg);
  1256. #endif
  1258.   if (re != NULL) free(re);
  1259.   if (extra != NULL) free(extra);
  1260.   if (tables != NULL)
  1261.     {
  1262.     free((void *)tables);
  1263.     setlocale(LC_CTYPE, "C");
  1264.     }
  1265.   }
  1267. fprintf(outfile, "n");
  1268. return 0;
  1269. }
  1271. /* End */