/[pcre]/code/trunk/pcretest.c
ViewVC logotype

Diff of /code/trunk/pcretest.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 92 by nigel, Sat Feb 24 21:41:34 2007 UTC revision 93 by nigel, Sat Feb 24 21:41:42 2007 UTC
# Line 44  POSSIBILITY OF SUCH DAMAGE. Line 44  POSSIBILITY OF SUCH DAMAGE.
44  #include <locale.h>  #include <locale.h>
45  #include <errno.h>  #include <errno.h>
46    
47  #ifndef _WIN32  
48  #include <sys/resource.h>  /* A number of things vary for Windows builds. Originally, pcretest opened its
49    input and output without "b"; then I was told that "b" was needed in some
50    environments, so it was added for release 5.0 to both the input and output. (It
51    makes no difference on Unix-like systems.) Later I was told that it is wrong
52    for the input on Windows. I've now abstracted the modes into two macros that
53    are set here, to make it easier to fiddle with them, and removed "b" from the
54    input mode under Windows. */
55    
56    #if defined(_WIN32) || defined(WIN32)
57    #include <io.h>                /* For _setmode() */
58    #include <fcntl.h>             /* For _O_BINARY */
59    #define INPUT_MODE   "r"
60    #define OUTPUT_MODE  "wb"
61    
62    #else
63    #include <sys/time.h>          /* These two includes are needed */
64    #include <sys/resource.h>      /* for setrlimit(). */
65    #define INPUT_MODE   "rb"
66    #define OUTPUT_MODE  "wb"
67  #endif  #endif
68    
69    
70  #define PCRE_SPY        /* For Win32 build, import data, not export */  #define PCRE_SPY        /* For Win32 build, import data, not export */
71    
72  /* We include pcre_internal.h because we need the internal info for displaying  /* We include pcre_internal.h because we need the internal info for displaying
# Line 74  symbols to prevent clashes. */ Line 93  symbols to prevent clashes. */
93    
94  /* We also need the pcre_printint() function for printing out compiled  /* We also need the pcre_printint() function for printing out compiled
95  patterns. This function is in a separate file so that it can be included in  patterns. This function is in a separate file so that it can be included in
96  pcre_compile.c when that module is compiled with debugging enabled. */  pcre_compile.c when that module is compiled with debugging enabled.
97    
98    The definition of the macro PRINTABLE, which determines whether to print an
99    output character as-is or as a hex value when showing compiled patterns, is
100    contained in this file. We uses it here also, in cases when the locale has not
101    been explicitly changed, so as to get consistent output from systems that
102    differ in their output from isprint() even in the "C" locale. */
103    
104  #include "pcre_printint.src"  #include "pcre_printint.src"
105    
106    #define PRINTHEX(c) (locale_set? isprint(c) : PRINTABLE(c))
107    
108    
109  /* It is possible to compile this test program without including support for  /* It is possible to compile this test program without including support for
110  testing the POSIX interface, though this is not available via the standard  testing the POSIX interface, though this is not available via the standard
# Line 103  function (define NOINFOCHECK). */ Line 130  function (define NOINFOCHECK). */
130  #endif  #endif
131  #endif  #endif
132    
133    /* This is the default loop count for timing. */
134    
135  #define LOOPREPEAT 500000  #define LOOPREPEAT 500000
136    
137  /* Static variables */  /* Static variables */
# Line 114  static int callout_extra; Line 143  static int callout_extra;
143  static int callout_fail_count;  static int callout_fail_count;
144  static int callout_fail_id;  static int callout_fail_id;
145  static int first_callout;  static int first_callout;
146    static int locale_set = 0;
147  static int show_malloc;  static int show_malloc;
148  static int use_utf8;  static int use_utf8;
149  static size_t gotten_store;  static size_t gotten_store;
# Line 157  uschar *here = start; Line 187  uschar *here = start;
187  for (;;)  for (;;)
188    {    {
189    int rlen = buffer_size - (here - buffer);    int rlen = buffer_size - (here - buffer);
190    
191    if (rlen > 1000)    if (rlen > 1000)
192      {      {
193      int dlen;      int dlen;
# Line 213  return NULL; /* Control never gets here Line 244  return NULL; /* Control never gets here
244    
245  /* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess  /* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess
246  around with conditional compilation, just do the job by hand. It is only used  around with conditional compilation, just do the job by hand. It is only used
247  for unpicking the -o argument, so just keep it simple.  for unpicking arguments, so just keep it simple.
248    
249  Arguments:  Arguments:
250    str           string to be converted    str           string to be converted
# Line 311  Arguments: Line 342  Arguments:
342  Returns:     number of characters placed in the buffer  Returns:     number of characters placed in the buffer
343  */  */
344    
345    #if !defined NOUTF8
346    
347  static int  static int
348  ord2utf8(int cvalue, uschar *utf8bytes)  ord2utf8(int cvalue, uschar *utf8bytes)
349  {  {
# Line 327  for (j = i; j > 0; j--) Line 360  for (j = i; j > 0; j--)
360  return i + 1;  return i + 1;
361  }  }
362    
363    #endif
364    
365    
366    
367  /*************************************************  /*************************************************
# Line 353  while (length-- > 0) Line 388  while (length-- > 0)
388        {        {
389        length -= rc - 1;        length -= rc - 1;
390        p += rc;        p += rc;
391        if (c < 256 && isprint(c))        if (PRINTHEX(c))
392          {          {
393          if (f != NULL) fprintf(f, "%c", c);          if (f != NULL) fprintf(f, "%c", c);
394          yield++;          yield++;
395          }          }
396        else        else
397          {          {
398          int n;          int n = 4;
399          if (f != NULL) fprintf(f, "\\x{%02x}%n", c, &n);          if (f != NULL) fprintf(f, "\\x{%02x}", c);
400          yield += n;          yield += (n <= 0x000000ff)? 2 :
401                     (n <= 0x00000fff)? 3 :
402                     (n <= 0x0000ffff)? 4 :
403                     (n <= 0x000fffff)? 5 : 6;
404          }          }
405        continue;        continue;
406        }        }
# Line 371  while (length-- > 0) Line 409  while (length-- > 0)
409    
410     /* Not UTF-8, or malformed UTF-8  */     /* Not UTF-8, or malformed UTF-8  */
411    
412    if (isprint(c = *(p++)))    c = *p++;
413      if (PRINTHEX(c))
414      {      {
415      if (f != NULL) fprintf(f, "%c", c);      if (f != NULL) fprintf(f, "%c", c);
416      yield++;      yield++;
# Line 614  return count; Line 653  return count;
653  *************************************************/  *************************************************/
654    
655  /* This is used both at compile and run-time to check for <xxx> escapes, where  /* This is used both at compile and run-time to check for <xxx> escapes, where
656  xxx is LF, CR, or CRLF. Print a message and return 0 if there is no match.  xxx is LF, CR, CRLF, or ANY. Print a message and return 0 if there is no match.
657    
658  Arguments:  Arguments:
659    p           points after the leading '<'    p           points after the leading '<'
# Line 629  check_newline(uschar *p, FILE *f) Line 668  check_newline(uschar *p, FILE *f)
668  if (strncmp((char *)p, "cr>", 3) == 0) return PCRE_NEWLINE_CR;  if (strncmp((char *)p, "cr>", 3) == 0) return PCRE_NEWLINE_CR;
669  if (strncmp((char *)p, "lf>", 3) == 0) return PCRE_NEWLINE_LF;  if (strncmp((char *)p, "lf>", 3) == 0) return PCRE_NEWLINE_LF;
670  if (strncmp((char *)p, "crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;  if (strncmp((char *)p, "crlf>", 5) == 0) return PCRE_NEWLINE_CRLF;
671    if (strncmp((char *)p, "any>", 4) == 0) return PCRE_NEWLINE_ANY;
672  fprintf(f, "Unknown newline type at: <%s\n", p);  fprintf(f, "Unknown newline type at: <%s\n", p);
673  return 0;  return 0;
674  }  }
# Line 636  return 0; Line 676  return 0;
676    
677    
678  /*************************************************  /*************************************************
679    *             Usage function                     *
680    *************************************************/
681    
682    static void
683    usage(void)
684    {
685    printf("Usage:     pcretest [options] [<input> [<output>]]\n");
686    printf("  -b       show compiled code (bytecode)\n");
687    printf("  -C       show PCRE compile-time options and exit\n");
688    printf("  -d       debug: show compiled code and information (-b and -i)\n");
689    #if !defined NODFA
690    printf("  -dfa     force DFA matching for all subjects\n");
691    #endif
692    printf("  -help    show usage information\n");
693    printf("  -i       show information about compiled patterns\n"
694           "  -m       output memory used information\n"
695           "  -o <n>   set size of offsets vector to <n>\n");
696    #if !defined NOPOSIX
697    printf("  -p       use POSIX interface\n");
698    #endif
699    printf("  -q       quiet: do not output PCRE version number at start\n");
700    printf("  -S <n>   set stack size to <n> megabytes\n");
701    printf("  -s       output store (memory) used information\n"
702           "  -t       time compilation and execution\n");
703    printf("  -t <n>   time compilation and execution, repeating <n> times\n");
704    printf("  -tm      time execution (matching) only\n");
705    printf("  -tm <n>  time execution (matching) only, repeating <n> times\n");
706    }
707    
708    
709    
710    /*************************************************
711  *                Main Program                    *  *                Main Program                    *
712  *************************************************/  *************************************************/
713    
# Line 650  int options = 0; Line 722  int options = 0;
722  int study_options = 0;  int study_options = 0;
723  int op = 1;  int op = 1;
724  int timeit = 0;  int timeit = 0;
725    int timeitm = 0;
726  int showinfo = 0;  int showinfo = 0;
727  int showstore = 0;  int showstore = 0;
728  int quiet = 0;  int quiet = 0;
# Line 681  buffer = (unsigned char *)malloc(buffer_ Line 754  buffer = (unsigned char *)malloc(buffer_
754  dbuffer = (unsigned char *)malloc(buffer_size);  dbuffer = (unsigned char *)malloc(buffer_size);
755  pbuffer = (unsigned char *)malloc(buffer_size);  pbuffer = (unsigned char *)malloc(buffer_size);
756    
757  /* The outfile variable is static so that new_malloc can use it. The _setmode()  /* The outfile variable is static so that new_malloc can use it. */
 stuff is some magic that I don't understand, but which apparently does good  
 things in Windows. It's related to line terminations.  */  
   
 #if defined(_WIN32) || defined(WIN32)  
 _setmode( _fileno( stdout ), 0x8000 );  
 #endif  /* defined(_WIN32) || defined(WIN32) */  
758    
759  outfile = stdout;  outfile = stdout;
760    
761    /* The following  _setmode() stuff is some Windows magic that tells its runtime
762    library to translate CRLF into a single LF character. At least, that's what
763    I've been told: never having used Windows I take this all on trust. Originally
764    it set 0x8000, but then I was advised that _O_BINARY was better. */
765    
766    #if defined(_WIN32) || defined(WIN32)
767    _setmode( _fileno( stdout ), _O_BINARY );
768    #endif
769    
770  /* Scan options */  /* Scan options */
771    
772  while (argc > 1 && argv[op][0] == '-')  while (argc > 1 && argv[op][0] == '-')
# Line 699  while (argc > 1 && argv[op][0] == '-') Line 775  while (argc > 1 && argv[op][0] == '-')
775    
776    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)    if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)
777      showstore = 1;      showstore = 1;
   else if (strcmp(argv[op], "-t") == 0) timeit = 1;  
778    else if (strcmp(argv[op], "-q") == 0) quiet = 1;    else if (strcmp(argv[op], "-q") == 0) quiet = 1;
779      else if (strcmp(argv[op], "-b") == 0) debug = 1;
780    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;    else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
781    else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;    else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;
782  #if !defined NODFA  #if !defined NODFA
# Line 713  while (argc > 1 && argv[op][0] == '-') Line 789  while (argc > 1 && argv[op][0] == '-')
789      op++;      op++;
790      argc--;      argc--;
791      }      }
792      else if (strcmp(argv[op], "-t") == 0 || strcmp(argv[op], "-tm") == 0)
793        {
794        int both = argv[op][2] == 0;
795        int temp;
796        if (argc > 2 && (temp = get_value((unsigned char *)argv[op+1], &endptr),
797                         *endptr == 0))
798          {
799          timeitm = temp;
800          op++;
801          argc--;
802          }
803        else timeitm = LOOPREPEAT;
804        if (both) timeit = timeitm;
805        }
806    else if (strcmp(argv[op], "-S") == 0 && argc > 2 &&    else if (strcmp(argv[op], "-S") == 0 && argc > 2 &&
807        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),        ((stack_size = get_value((unsigned char *)argv[op+1], &endptr)),
808          *endptr == 0))          *endptr == 0))
809      {      {
810  #ifdef _WIN32  #if defined(_WIN32) || defined(WIN32)
811      printf("PCRE: -S not supported on this OS\n");      printf("PCRE: -S not supported on this OS\n");
812      exit(1);      exit(1);
813  #else  #else
# Line 749  while (argc > 1 && argv[op][0] == '-') Line 839  while (argc > 1 && argv[op][0] == '-')
839      printf("  %sUnicode properties support\n", rc? "" : "No ");      printf("  %sUnicode properties support\n", rc? "" : "No ");
840      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);      (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
841      printf("  Newline sequence is %s\n", (rc == '\r')? "CR" :      printf("  Newline sequence is %s\n", (rc == '\r')? "CR" :
842        (rc == '\n')? "LF" : "CRLF");        (rc == '\n')? "LF" : (rc == ('\r'<<8 | '\n'))? "CRLF" :
843          (rc == -1)? "ANY" : "???");
844      (void)pcre_config(PCRE_CONFIG_LINK_SIZE, &rc);      (void)pcre_config(PCRE_CONFIG_LINK_SIZE, &rc);
845      printf("  Internal link size = %d\n", rc);      printf("  Internal link size = %d\n", rc);
846      (void)pcre_config(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);      (void)pcre_config(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);
# Line 762  while (argc > 1 && argv[op][0] == '-') Line 853  while (argc > 1 && argv[op][0] == '-')
853      printf("  Match recursion uses %s\n", rc? "stack" : "heap");      printf("  Match recursion uses %s\n", rc? "stack" : "heap");
854      exit(0);      exit(0);
855      }      }
856      else if (strcmp(argv[op], "-help") == 0 ||
857               strcmp(argv[op], "--help") == 0)
858        {
859        usage();
860        goto EXIT;
861        }
862    else    else
863      {      {
864      printf("** Unknown or malformed option %s\n", argv[op]);      printf("** Unknown or malformed option %s\n", argv[op]);
865      printf("Usage:   pcretest [options] [<input> [<output>]]\n");      usage();
     printf("  -C     show PCRE compile-time options and exit\n");  
     printf("  -d     debug: show compiled code; implies -i\n");  
 #if !defined NODFA  
     printf("  -dfa   force DFA matching for all subjects\n");  
 #endif  
     printf("  -i     show information about compiled pattern\n"  
            "  -m     output memory used information\n"  
            "  -o <n> set size of offsets vector to <n>\n");  
 #if !defined NOPOSIX  
     printf("  -p     use POSIX interface\n");  
 #endif  
     printf("  -S <n> set stack size to <n> megabytes\n");  
     printf("  -s     output store (memory) used information\n"  
            "  -t     time compilation and execution\n");  
866      yield = 1;      yield = 1;
867      goto EXIT;      goto EXIT;
868      }      }
# Line 803  if (offsets == NULL) Line 886  if (offsets == NULL)
886    
887  if (argc > 1)  if (argc > 1)
888    {    {
889    infile = fopen(argv[op], "rb");    infile = fopen(argv[op], INPUT_MODE);
890    if (infile == NULL)    if (infile == NULL)
891      {      {
892      printf("** Failed to open %s\n", argv[op]);      printf("** Failed to open %s\n", argv[op]);
# Line 814  if (argc > 1) Line 897  if (argc > 1)
897    
898  if (argc > 2)  if (argc > 2)
899    {    {
900    outfile = fopen(argv[op+1], "wb");    outfile = fopen(argv[op+1], OUTPUT_MODE);
901    if (outfile == NULL)    if (outfile == NULL)
902      {      {
903      printf("** Failed to open %s\n", argv[op+1]);      printf("** Failed to open %s\n", argv[op+1]);
# Line 859  while (!done) Line 942  while (!done)
942    int do_showinfo = showinfo;    int do_showinfo = showinfo;
943    int do_showrest = 0;    int do_showrest = 0;
944    int do_flip = 0;    int do_flip = 0;
945    int erroroffset, len, delimiter;    int erroroffset, len, delimiter, poffset;
946    
947    use_utf8 = 0;    use_utf8 = 0;
948    
# Line 969  while (!done) Line 1052  while (!done)
1052      }      }
1053    
1054    pp = p;    pp = p;
1055      poffset = p - buffer;
1056    
1057    for(;;)    for(;;)
1058      {      {
# Line 989  while (!done) Line 1073  while (!done)
1073      if (infile != stdin) fprintf(outfile, "%s", (char *)pp);      if (infile != stdin) fprintf(outfile, "%s", (char *)pp);
1074      }      }
1075    
1076      /* The buffer may have moved while being extended; reset the start of data
1077      pointer to the correct relative point in the buffer. */
1078    
1079      p = buffer + poffset;
1080    
1081    /* If the first character after the delimiter is backslash, make    /* If the first character after the delimiter is backslash, make
1082    the pattern end with backslash. This is purely to provide a way    the pattern end with backslash. This is purely to provide a way
1083    of testing for the error message when a pattern ends with backslash. */    of testing for the error message when a pattern ends with backslash. */
# Line 1020  while (!done) Line 1109  while (!done)
1109    
1110        case '+': do_showrest = 1; break;        case '+': do_showrest = 1; break;
1111        case 'A': options |= PCRE_ANCHORED; break;        case 'A': options |= PCRE_ANCHORED; break;
1112          case 'B': do_debug = 1; break;
1113        case 'C': options |= PCRE_AUTO_CALLOUT; break;        case 'C': options |= PCRE_AUTO_CALLOUT; break;
1114        case 'D': do_debug = do_showinfo = 1; break;        case 'D': do_debug = do_showinfo = 1; break;
1115        case 'E': options |= PCRE_DOLLAR_ENDONLY; break;        case 'E': options |= PCRE_DOLLAR_ENDONLY; break;
# Line 1042  while (!done) Line 1132  while (!done)
1132    
1133        case 'L':        case 'L':
1134        ppp = pp;        ppp = pp;
1135        /* The '\r' test here is so that it works on Windows */        /* The '\r' test here is so that it works on Windows. */
1136        while (*ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++;        /* The '0' test is just in case this is an unterminated line. */
1137          while (*ppp != 0 && *ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++;
1138        *ppp = 0;        *ppp = 0;
1139        if (setlocale(LC_CTYPE, (const char *)pp) == NULL)        if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
1140          {          {
1141          fprintf(outfile, "** Failed to set locale \"%s\"\n", pp);          fprintf(outfile, "** Failed to set locale \"%s\"\n", pp);
1142          goto SKIP_DATA;          goto SKIP_DATA;
1143          }          }
1144          locale_set = 1;
1145        tables = pcre_maketables();        tables = pcre_maketables();
1146        pp = ppp;        pp = ppp;
1147        break;        break;
# Line 1116  while (!done) Line 1208  while (!done)
1208  #endif  /* !defined NOPOSIX */  #endif  /* !defined NOPOSIX */
1209    
1210      {      {
1211      if (timeit)      if (timeit > 0)
1212        {        {
1213        register int i;        register int i;
1214        clock_t time_taken;        clock_t time_taken;
1215        clock_t start_time = clock();        clock_t start_time = clock();
1216        for (i = 0; i < LOOPREPEAT; i++)        for (i = 0; i < timeit; i++)
1217          {          {
1218          re = pcre_compile((char *)p, options, &error, &erroroffset, tables);          re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
1219          if (re != NULL) free(re);          if (re != NULL) free(re);
1220          }          }
1221        time_taken = clock() - start_time;        time_taken = clock() - start_time;
1222        fprintf(outfile, "Compile time %.3f milliseconds\n",        fprintf(outfile, "Compile time %.4f milliseconds\n",
1223          (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /          (((double)time_taken * 1000.0) / (double)timeit) /
1224            (double)CLOCKS_PER_SEC);            (double)CLOCKS_PER_SEC);
1225        }        }
1226    
# Line 1180  while (!done) Line 1272  while (!done)
1272    
1273      if (do_study)      if (do_study)
1274        {        {
1275        if (timeit)        if (timeit > 0)
1276          {          {
1277          register int i;          register int i;
1278          clock_t time_taken;          clock_t time_taken;
1279          clock_t start_time = clock();          clock_t start_time = clock();
1280          for (i = 0; i < LOOPREPEAT; i++)          for (i = 0; i < timeit; i++)
1281            extra = pcre_study(re, study_options, &error);            extra = pcre_study(re, study_options, &error);
1282          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1283          if (extra != NULL) free(extra);          if (extra != NULL) free(extra);
1284          fprintf(outfile, "  Study time %.3f milliseconds\n",          fprintf(outfile, "  Study time %.4f milliseconds\n",
1285            (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /            (((double)time_taken * 1000.0) / (double)timeit) /
1286              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1287          }          }
1288        extra = pcre_study(re, study_options, &error);        extra = pcre_study(re, study_options, &error);
# Line 1233  while (!done) Line 1325  while (!done)
1325    
1326      SHOW_INFO:      SHOW_INFO:
1327    
1328        if (do_debug)
1329          {
1330          fprintf(outfile, "------------------------------------------------------------------\n");
1331          pcre_printint(re, outfile);
1332          }
1333    
1334      if (do_showinfo)      if (do_showinfo)
1335        {        {
1336        unsigned long int get_options, all_options;        unsigned long int get_options, all_options;
# Line 1243  while (!done) Line 1341  while (!done)
1341        int nameentrysize, namecount;        int nameentrysize, namecount;
1342        const uschar *nametable;        const uschar *nametable;
1343    
       if (do_debug)  
         {  
         fprintf(outfile, "------------------------------------------------------------------\n");  
         pcre_printint(re, outfile);  
         }  
   
1344        new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);        new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
1345        new_info(re, NULL, PCRE_INFO_SIZE, &size);        new_info(re, NULL, PCRE_INFO_SIZE, &size);
1346        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);        new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
# Line 1327  while (!done) Line 1419  while (!done)
1419            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",            ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "",
1420            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");            ((get_options & PCRE_DUPNAMES) != 0)? " dupnames" : "");
1421    
1422        switch (get_options & PCRE_NEWLINE_CRLF)        switch (get_options & PCRE_NEWLINE_BITS)
1423          {          {
1424          case PCRE_NEWLINE_CR:          case PCRE_NEWLINE_CR:
1425          fprintf(outfile, "Forced newline sequence: CR\n");          fprintf(outfile, "Forced newline sequence: CR\n");
# Line 1341  while (!done) Line 1433  while (!done)
1433          fprintf(outfile, "Forced newline sequence: CRLF\n");          fprintf(outfile, "Forced newline sequence: CRLF\n");
1434          break;          break;
1435    
1436            case PCRE_NEWLINE_ANY:
1437            fprintf(outfile, "Forced newline sequence: ANY\n");
1438            break;
1439    
1440          default:          default:
1441          break;          break;
1442          }          }
# Line 1358  while (!done) Line 1454  while (!done)
1454          int ch = first_char & 255;          int ch = first_char & 255;
1455          const char *caseless = ((first_char & REQ_CASELESS) == 0)?          const char *caseless = ((first_char & REQ_CASELESS) == 0)?
1456            "" : " (caseless)";            "" : " (caseless)";
1457          if (isprint(ch))          if (PRINTHEX(ch))
1458            fprintf(outfile, "First char = \'%c\'%s\n", ch, caseless);            fprintf(outfile, "First char = \'%c\'%s\n", ch, caseless);
1459          else          else
1460            fprintf(outfile, "First char = %d%s\n", ch, caseless);            fprintf(outfile, "First char = %d%s\n", ch, caseless);
# Line 1373  while (!done) Line 1469  while (!done)
1469          int ch = need_char & 255;          int ch = need_char & 255;
1470          const char *caseless = ((need_char & REQ_CASELESS) == 0)?          const char *caseless = ((need_char & REQ_CASELESS) == 0)?
1471            "" : " (caseless)";            "" : " (caseless)";
1472          if (isprint(ch))          if (PRINTHEX(ch))
1473            fprintf(outfile, "Need char = \'%c\'%s\n", ch, caseless);            fprintf(outfile, "Need char = \'%c\'%s\n", ch, caseless);
1474          else          else
1475            fprintf(outfile, "Need char = %d%s\n", ch, caseless);            fprintf(outfile, "Need char = %d%s\n", ch, caseless);
# Line 1409  while (!done) Line 1505  while (!done)
1505                    fprintf(outfile, "\n  ");                    fprintf(outfile, "\n  ");
1506                    c = 2;                    c = 2;
1507                    }                    }
1508                  if (isprint(i) && i != ' ')                  if (PRINTHEX(i) && i != ' ')
1509                    {                    {
1510                    fprintf(outfile, "%c ", i);                    fprintf(outfile, "%c ", i);
1511                    c += 2;                    c += 2;
# Line 1468  while (!done) Line 1564  while (!done)
1564                  strerror(errno));                  strerror(errno));
1565                }                }
1566              else fprintf(outfile, "Study data written to %s\n", to_file);              else fprintf(outfile, "Study data written to %s\n", to_file);
1567    
1568              }              }
1569            }            }
1570          fclose(f);          fclose(f);
# Line 1866  while (!done) Line 1963  while (!done)
1963    
1964      for (;; gmatched++)    /* Loop for /g or /G */      for (;; gmatched++)    /* Loop for /g or /G */
1965        {        {
1966        if (timeit)        if (timeitm > 0)
1967          {          {
1968          register int i;          register int i;
1969          clock_t time_taken;          clock_t time_taken;
# Line 1876  while (!done) Line 1973  while (!done)
1973          if (all_use_dfa || use_dfa)          if (all_use_dfa || use_dfa)
1974            {            {
1975            int workspace[1000];            int workspace[1000];
1976            for (i = 0; i < LOOPREPEAT; i++)            for (i = 0; i < timeitm; i++)
1977              count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,              count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,
1978                options | g_notempty, use_offsets, use_size_offsets, workspace,                options | g_notempty, use_offsets, use_size_offsets, workspace,
1979                sizeof(workspace)/sizeof(int));                sizeof(workspace)/sizeof(int));
# Line 1884  while (!done) Line 1981  while (!done)
1981          else          else
1982  #endif  #endif
1983    
1984          for (i = 0; i < LOOPREPEAT; i++)          for (i = 0; i < timeitm; i++)
1985            count = pcre_exec(re, extra, (char *)bptr, len,            count = pcre_exec(re, extra, (char *)bptr, len,
1986              start_offset, options | g_notempty, use_offsets, use_size_offsets);              start_offset, options | g_notempty, use_offsets, use_size_offsets);
1987    
1988          time_taken = clock() - start_time;          time_taken = clock() - start_time;
1989          fprintf(outfile, "Execute time %.3f milliseconds\n",          fprintf(outfile, "Execute time %.4f milliseconds\n",
1990            (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /            (((double)time_taken * 1000.0) / (double)timeitm) /
1991              (double)CLOCKS_PER_SEC);              (double)CLOCKS_PER_SEC);
1992          }          }
1993    
# Line 1966  while (!done) Line 2063  while (!done)
2063    
2064        if (count >= 0)        if (count >= 0)
2065          {          {
2066          int i;          int i, maxcount;
2067    
2068    #if !defined NODFA
2069            if (all_use_dfa || use_dfa) maxcount = use_size_offsets/2; else
2070    #endif
2071              maxcount = use_size_offsets/3;
2072    
2073            /* This is a check against a lunatic return value. */
2074    
2075            if (count > maxcount)
2076              {
2077              fprintf(outfile,
2078                "** PCRE error: returned count %d is too big for offset size %d\n",
2079                count, use_size_offsets);
2080              count = use_size_offsets/3;
2081              if (do_g || do_G)
2082                {
2083                fprintf(outfile, "** /%c loop abandoned\n", do_g? 'g' : 'G');
2084                do_g = do_G = FALSE;        /* Break g/G loop */
2085                }
2086              }
2087    
2088          for (i = 0; i < count * 2; i += 2)          for (i = 0; i < count * 2; i += 2)
2089            {            {
2090            if (use_offsets[i] < 0)            if (use_offsets[i] < 0)
# Line 2165  while (!done) Line 2283  while (!done)
2283      {      {
2284      new_free((void *)tables);      new_free((void *)tables);
2285      setlocale(LC_CTYPE, "C");      setlocale(LC_CTYPE, "C");
2286        locale_set = 0;
2287      }      }
2288    }    }
2289    

Legend:
Removed from v.92  
changed lines
  Added in v.93

webmaster@exim.org
ViewVC Help
Powered by ViewVC 1.1.12