src/src/pcre/pcretest.c

   1 /* $Cambridge: exim/src/src/pcre/pcretest.c,v 1.3 2005/08/08 10:22:14 ph10 Exp $ */
   2
   3 /*************************************************
   4 *             PCRE testing program               *
   5 *************************************************/
   6
   7 /* This program was hacked up as a tester for PCRE. I really should have
   8 written it more tidily in the first place. Will I ever learn? It has grown and
   9 been extended and consequently is now rather, er, *very* untidy in places.
  10
  11 -----------------------------------------------------------------------------
  12 Redistribution and use in source and binary forms, with or without
  13 modification, are permitted provided that the following conditions are met:
  14
  15     * Redistributions of source code must retain the above copyright notice,
  16       this list of conditions and the following disclaimer.
  17
  18     * Redistributions in binary form must reproduce the above copyright
  19       notice, this list of conditions and the following disclaimer in the
  20       documentation and/or other materials provided with the distribution.
  21
  22     * Neither the name of the University of Cambridge nor the names of its
  23       contributors may be used to endorse or promote products derived from
  24       this software without specific prior written permission.
  25
  26 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  27 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  28 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  29 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  30 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36 POSSIBILITY OF SUCH DAMAGE.
  37 -----------------------------------------------------------------------------
  38 */
  39
  40
  41 #include <ctype.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <stdlib.h>
  45 #include <time.h>
  46 #include <locale.h>
  47 #include <errno.h>
  48
  49 #define PCRE_SPY        /* For Win32 build, import data, not export */
  50
  51 /* We need the internal info for displaying the results of pcre_study() and
  52 other internal data; pcretest also uses some of the fixed tables, and generally
  53 has "inside information" compared to a program that strictly follows the PCRE
  54 API. */
  55
  56 #include "pcre_internal.h"
  57
  58
  59 /* It is possible to compile this test program without including support for
  60 testing the POSIX interface, though this is not available via the standard
  61 Makefile. */
  62
  63 #if !defined NOPOSIX
  64 #include "pcreposix.h"
  65 #endif
  66
  67 /* It is also possible, for the benefit of the version imported into Exim, to
  68 build pcretest without support for UTF8 (define NOUTF8), without the interface
  69 to the DFA matcher (NODFA), and without the doublecheck of the old "info"
  70 function (define NOINFOCHECK). */
  71
  72
  73 #ifndef CLOCKS_PER_SEC
  74 #ifdef CLK_TCK
  75 #define CLOCKS_PER_SEC CLK_TCK
  76 #else
  77 #define CLOCKS_PER_SEC 100
  78 #endif
  79 #endif
  80
  81 #define LOOPREPEAT 500000
  82
  83 #define BUFFER_SIZE 30000
  84 #define PBUFFER_SIZE BUFFER_SIZE
  85 #define DBUFFER_SIZE BUFFER_SIZE
  86
  87
  88 static FILE *outfile;
  89 static int log_store = 0;
  90 static int callout_count;
  91 static int callout_extra;
  92 static int callout_fail_count;
  93 static int callout_fail_id;
  94 static int first_callout;
  95 static int show_malloc;
  96 static int use_utf8;
  97 static size_t gotten_store;
  98
  99 static uschar *pbuffer = NULL;
 100
 101
 102
 103 /*************************************************
 104 *          Read number from string               *
 105 *************************************************/
 106
 107 /* We don't use strtoul() because SunOS4 doesn't have it. Rather than mess
 108 around with conditional compilation, just do the job by hand. It is only used
 109 for unpicking the -o argument, so just keep it simple.
 110
 111 Arguments:
 112   str           string to be converted
 113   endptr        where to put the end pointer
 114
 115 Returns:        the unsigned long
 116 */
 117
 118 static int
 119 get_value(unsigned char *str, unsigned char **endptr)
 120 {
 121 int result = 0;
 122 while(*str != 0 && isspace(*str)) str++;
 123 while (isdigit(*str)) result = result * 10 + (int)(*str++ - '0');
 124 *endptr = str;
 125 return(result);
 126 }
 127
 128
 129
 130
 131 /*************************************************
 132 *            Convert UTF-8 string to value       *
 133 *************************************************/
 134
 135 /* This function takes one or more bytes that represents a UTF-8 character,
 136 and returns the value of the character.
 137
 138 Argument:
 139   buffer   a pointer to the byte vector
 140   vptr     a pointer to an int to receive the value
 141
 142 Returns:   >  0 => the number of bytes consumed
 143            -6 to 0 => malformed UTF-8 character at offset = (-return)
 144 */
 145
 146 #if !defined NOUTF8
 147
 148 static int
 149 utf82ord(unsigned char *buffer, int *vptr)
 150 {
 151 int c = *buffer++;
 152 int d = c;
 153 int i, j, s;
 154
 155 for (i = -1; i < 6; i++)               /* i is number of additional bytes */
 156   {
 157   if ((d & 0x80) == 0) break;
 158   d <<= 1;
 159   }
 160
 161 if (i == -1) { *vptr = c; return 1; }  /* ascii character */
 162 if (i == 0 || i == 6) return 0;        /* invalid UTF-8 */
 163
 164 /* i now has a value in the range 1-5 */
 165
 166 s = 6*i;
 167 d = (c & _pcre_utf8_table3[i]) << s;
 168
 169 for (j = 0; j < i; j++)
 170   {
 171   c = *buffer++;
 172   if ((c & 0xc0) != 0x80) return -(j+1);
 173   s -= 6;
 174   d |= (c & 0x3f) << s;
 175   }
 176
 177 /* Check that encoding was the correct unique one */
 178
 179 for (j = 0; j < _pcre_utf8_table1_size; j++)
 180   if (d <= _pcre_utf8_table1[j]) break;
 181 if (j != i) return -(i+1);
 182
 183 /* Valid value */
 184
 185 *vptr = d;
 186 return i+1;
 187 }
 188
 189 #endif
 190
 191
 192
 193 /*************************************************
 194 *             Print character string             *
 195 *************************************************/
 196
 197 /* Character string printing function. Must handle UTF-8 strings in utf8
 198 mode. Yields number of characters printed. If handed a NULL file, just counts
 199 chars without printing. */
 200
 201 static int pchars(unsigned char *p, int length, FILE *f)
 202 {
 203 int c;
 204 int yield = 0;
 205
 206 while (length-- > 0)
 207   {
 208 #if !defined NOUTF8
 209   if (use_utf8)
 210     {
 211     int rc = utf82ord(p, &c);
 212
 213     if (rc > 0 && rc <= length + 1)   /* Mustn't run over the end */
 214       {
 215       length -= rc - 1;
 216       p += rc;
 217       if (c < 256 && isprint(c))
 218         {
 219         if (f != NULL) fprintf(f, "%c", c);
 220         yield++;
 221         }
 222       else
 223         {
 224         int n;
 225         if (f != NULL) fprintf(f, "\\x{%02x}%n", c, &n);
 226         yield += n;
 227         }
 228       continue;
 229       }
 230     }
 231 #endif
 232
 233    /* Not UTF-8, or malformed UTF-8  */
 234
 235   if (isprint(c = *(p++)))
 236     {
 237     if (f != NULL) fprintf(f, "%c", c);
 238     yield++;
 239     }
 240   else
 241     {
 242     if (f != NULL) fprintf(f, "\\x%02x", c);
 243     yield += 4;
 244     }
 245   }
 246
 247 return yield;
 248 }
 249
 250
 251
 252 /*************************************************
 253 *              Callout function                  *
 254 *************************************************/
 255
 256 /* Called from PCRE as a result of the (?C) item. We print out where we are in
 257 the match. Yield zero unless more callouts than the fail count, or the callout
 258 data is not zero. */
 259
 260 static int callout(pcre_callout_block *cb)
 261 {
 262 FILE *f = (first_callout | callout_extra)? outfile : NULL;
 263 int i, pre_start, post_start, subject_length;
 264
 265 if (callout_extra)
 266   {
 267   fprintf(f, "Callout %d: last capture = %d\n",
 268     cb->callout_number, cb->capture_last);
 269
 270   for (i = 0; i < cb->capture_top * 2; i += 2)
 271     {
 272     if (cb->offset_vector[i] < 0)
 273       fprintf(f, "%2d: <unset>\n", i/2);
 274     else
 275       {
 276       fprintf(f, "%2d: ", i/2);
 277       (void)pchars((unsigned char *)cb->subject + cb->offset_vector[i],
 278         cb->offset_vector[i+1] - cb->offset_vector[i], f);
 279       fprintf(f, "\n");
 280       }
 281     }
 282   }
 283
 284 /* Re-print the subject in canonical form, the first time or if giving full
 285 datails. On subsequent calls in the same match, we use pchars just to find the
 286 printed lengths of the substrings. */
 287
 288 if (f != NULL) fprintf(f, "--->");
 289
 290 pre_start = pchars((unsigned char *)cb->subject, cb->start_match, f);
 291 post_start = pchars((unsigned char *)(cb->subject + cb->start_match),
 292   cb->current_position - cb->start_match, f);
 293
 294 subject_length = pchars((unsigned char *)cb->subject, cb->subject_length, NULL);
 295
 296 (void)pchars((unsigned char *)(cb->subject + cb->current_position),
 297   cb->subject_length - cb->current_position, f);
 298
 299 if (f != NULL) fprintf(f, "\n");
 300
 301 /* Always print appropriate indicators, with callout number if not already
 302 shown. For automatic callouts, show the pattern offset. */
 303
 304 if (cb->callout_number == 255)
 305   {
 306   fprintf(outfile, "%+3d ", cb->pattern_position);
 307   if (cb->pattern_position > 99) fprintf(outfile, "\n    ");
 308   }
 309 else
 310   {
 311   if (callout_extra) fprintf(outfile, "    ");
 312     else fprintf(outfile, "%3d ", cb->callout_number);
 313   }
 314
 315 for (i = 0; i < pre_start; i++) fprintf(outfile, " ");
 316 fprintf(outfile, "^");
 317
 318 if (post_start > 0)
 319   {
 320   for (i = 0; i < post_start - 1; i++) fprintf(outfile, " ");
 321   fprintf(outfile, "^");
 322   }
 323
 324 for (i = 0; i < subject_length - pre_start - post_start + 4; i++)
 325   fprintf(outfile, " ");
 326
 327 fprintf(outfile, "%.*s", (cb->next_item_length == 0)? 1 : cb->next_item_length,
 328   pbuffer + cb->pattern_position);
 329
 330 fprintf(outfile, "\n");
 331 first_callout = 0;
 332
 333 if (cb->callout_data != NULL)
 334   {
 335   int callout_data = *((int *)(cb->callout_data));
 336   if (callout_data != 0)
 337     {
 338     fprintf(outfile, "Callout data = %d\n", callout_data);
 339     return callout_data;
 340     }
 341   }
 342
 343 return (cb->callout_number != callout_fail_id)? 0 :
 344        (++callout_count >= callout_fail_count)? 1 : 0;
 345 }
 346
 347
 348 /*************************************************
 349 *            Local malloc functions              *
 350 *************************************************/
 351
 352 /* Alternative malloc function, to test functionality and show the size of the
 353 compiled re. */
 354
 355 static void *new_malloc(size_t size)
 356 {
 357 void *block = malloc(size);
 358 gotten_store = size;
 359 if (show_malloc)
 360   fprintf(outfile, "malloc       %3d %p\n", (int)size, block);
 361 return block;
 362 }
 363
 364 static void new_free(void *block)
 365 {
 366 if (show_malloc)
 367   fprintf(outfile, "free             %p\n", block);
 368 free(block);
 369 }
 370
 371
 372 /* For recursion malloc/free, to test stacking calls */
 373
 374 static void *stack_malloc(size_t size)
 375 {
 376 void *block = malloc(size);
 377 if (show_malloc)
 378   fprintf(outfile, "stack_malloc %3d %p\n", (int)size, block);
 379 return block;
 380 }
 381
 382 static void stack_free(void *block)
 383 {
 384 if (show_malloc)
 385   fprintf(outfile, "stack_free       %p\n", block);
 386 free(block);
 387 }
 388
 389
 390 /*************************************************
 391 *          Call pcre_fullinfo()                  *
 392 *************************************************/
 393
 394 /* Get one piece of information from the pcre_fullinfo() function */
 395
 396 static void new_info(pcre *re, pcre_extra *study, int option, void *ptr)
 397 {
 398 int rc;
 399 if ((rc = pcre_fullinfo(re, study, option, ptr)) < 0)
 400   fprintf(outfile, "Error %d from pcre_fullinfo(%d)\n", rc, option);
 401 }
 402
 403
 404
 405 /*************************************************
 406 *         Byte flipping function                 *
 407 *************************************************/
 408
 409 static long int
 410 byteflip(long int value, int n)
 411 {
 412 if (n == 2) return ((value & 0x00ff) << 8) | ((value & 0xff00) >> 8);
 413 return ((value & 0x000000ff) << 24) |
 414        ((value & 0x0000ff00) <<  8) |
 415        ((value & 0x00ff0000) >>  8) |
 416        ((value & 0xff000000) >> 24);
 417 }
 418
 419
 420
 421
 422 /*************************************************
 423 *                Main Program                    *
 424 *************************************************/
 425
 426 /* Read lines from named file or stdin and write to named file or stdout; lines
 427 consist of a regular expression, in delimiters and optionally followed by
 428 options, followed by a set of test data, terminated by an empty line. */
 429
 430 int main(int argc, char **argv)
 431 {
 432 FILE *infile = stdin;
 433 int options = 0;
 434 int study_options = 0;
 435 int op = 1;
 436 int timeit = 0;
 437 int showinfo = 0;
 438 int showstore = 0;
 439 int size_offsets = 45;
 440 int size_offsets_max;
 441 int *offsets = NULL;
 442 #if !defined NOPOSIX
 443 int posix = 0;
 444 #endif
 445 int debug = 0;
 446 int done = 0;
 447 int all_use_dfa = 0;
 448 int yield = 0;
 449
 450 unsigned char *buffer;
 451 unsigned char *dbuffer;
 452
 453 /* Get buffers from malloc() so that Electric Fence will check their misuse
 454 when I am debugging. */
 455
 456 buffer = (unsigned char *)malloc(BUFFER_SIZE);
 457 dbuffer = (unsigned char *)malloc(DBUFFER_SIZE);
 458 pbuffer = (unsigned char *)malloc(PBUFFER_SIZE);
 459
 460 /* The outfile variable is static so that new_malloc can use it. The _setmode()
 461 stuff is some magic that I don't understand, but which apparently does good
 462 things in Windows. It's related to line terminations.  */
 463
 464 #if defined(_WIN32) || defined(WIN32)
 465 _setmode( _fileno( stdout ), 0x8000 );
 466 #endif  /* defined(_WIN32) || defined(WIN32) */
 467
 468 outfile = stdout;
 469
 470 /* Scan options */
 471
 472 while (argc > 1 && argv[op][0] == '-')
 473   {
 474   unsigned char *endptr;
 475
 476   if (strcmp(argv[op], "-s") == 0 || strcmp(argv[op], "-m") == 0)
 477     showstore = 1;
 478   else if (strcmp(argv[op], "-t") == 0) timeit = 1;
 479   else if (strcmp(argv[op], "-i") == 0) showinfo = 1;
 480   else if (strcmp(argv[op], "-d") == 0) showinfo = debug = 1;
 481 #if !defined NODFA
 482   else if (strcmp(argv[op], "-dfa") == 0) all_use_dfa = 1;
 483 #endif
 484   else if (strcmp(argv[op], "-o") == 0 && argc > 2 &&
 485       ((size_offsets = get_value((unsigned char *)argv[op+1], &endptr)),
 486         *endptr == 0))
 487     {
 488     op++;
 489     argc--;
 490     }
 491 #if !defined NOPOSIX
 492   else if (strcmp(argv[op], "-p") == 0) posix = 1;
 493 #endif
 494   else if (strcmp(argv[op], "-C") == 0)
 495     {
 496     int rc;
 497     printf("PCRE version %s\n", pcre_version());
 498     printf("Compiled with\n");
 499     (void)pcre_config(PCRE_CONFIG_UTF8, &rc);
 500     printf("  %sUTF-8 support\n", rc? "" : "No ");
 501     (void)pcre_config(PCRE_CONFIG_UNICODE_PROPERTIES, &rc);
 502     printf("  %sUnicode properties support\n", rc? "" : "No ");
 503     (void)pcre_config(PCRE_CONFIG_NEWLINE, &rc);
 504     printf("  Newline character is %s\n", (rc == '\r')? "CR" : "LF");
 505     (void)pcre_config(PCRE_CONFIG_LINK_SIZE, &rc);
 506     printf("  Internal link size = %d\n", rc);
 507     (void)pcre_config(PCRE_CONFIG_POSIX_MALLOC_THRESHOLD, &rc);
 508     printf("  POSIX malloc threshold = %d\n", rc);
 509     (void)pcre_config(PCRE_CONFIG_MATCH_LIMIT, &rc);
 510     printf("  Default match limit = %d\n", rc);
 511     (void)pcre_config(PCRE_CONFIG_STACKRECURSE, &rc);
 512     printf("  Match recursion uses %s\n", rc? "stack" : "heap");
 513     exit(0);
 514     }
 515   else
 516     {
 517     printf("** Unknown or malformed option %s\n", argv[op]);
 518     printf("Usage:   pcretest [-d] [-i] [-o <n>] [-p] [-s] [-t] [<input> [<output>]]\n");
 519     printf("  -C     show PCRE compile-time options and exit\n");
 520     printf("  -d     debug: show compiled code; implies -i\n");
 521 #if !defined NODFA
 522     printf("  -dfa   force DFA matching for all subjects\n");
 523 #endif
 524     printf("  -i     show information about compiled pattern\n"
 525            "  -m     output memory used information\n"
 526            "  -o <n> set size of offsets vector to <n>\n");
 527 #if !defined NOPOSIX
 528     printf("  -p     use POSIX interface\n");
 529 #endif
 530     printf("  -s     output store (memory) used information\n"
 531            "  -t     time compilation and execution\n");
 532     yield = 1;
 533     goto EXIT;
 534     }
 535   op++;
 536   argc--;
 537   }
 538
 539 /* Get the store for the offsets vector, and remember what it was */
 540
 541 size_offsets_max = size_offsets;
 542 offsets = (int *)malloc(size_offsets_max * sizeof(int));
 543 if (offsets == NULL)
 544   {
 545   printf("** Failed to get %d bytes of memory for offsets vector\n",
 546     size_offsets_max * sizeof(int));
 547   yield = 1;
 548   goto EXIT;
 549   }
 550
 551 /* Sort out the input and output files */
 552
 553 if (argc > 1)
 554   {
 555   infile = fopen(argv[op], "rb");
 556   if (infile == NULL)
 557     {
 558     printf("** Failed to open %s\n", argv[op]);
 559     yield = 1;
 560     goto EXIT;
 561     }
 562   }
 563
 564 if (argc > 2)
 565   {
 566   outfile = fopen(argv[op+1], "wb");
 567   if (outfile == NULL)
 568     {
 569     printf("** Failed to open %s\n", argv[op+1]);
 570     yield = 1;
 571     goto EXIT;
 572     }
 573   }
 574
 575 /* Set alternative malloc function */
 576
 577 pcre_malloc = new_malloc;
 578 pcre_free = new_free;
 579 pcre_stack_malloc = stack_malloc;
 580 pcre_stack_free = stack_free;
 581
 582 /* Heading line, then prompt for first regex if stdin */
 583
 584 fprintf(outfile, "PCRE version %s\n\n", pcre_version());
 585
 586 /* Main loop */
 587
 588 while (!done)
 589   {
 590   pcre *re = NULL;
 591   pcre_extra *extra = NULL;
 592
 593 #if !defined NOPOSIX  /* There are still compilers that require no indent */
 594   regex_t preg;
 595   int do_posix = 0;
 596 #endif
 597
 598   const char *error;
 599   unsigned char *p, *pp, *ppp;
 600   unsigned char *to_file = NULL;
 601   const unsigned char *tables = NULL;
 602   unsigned long int true_size, true_study_size = 0;
 603   size_t size, regex_gotten_store;
 604   int do_study = 0;
 605   int do_debug = debug;
 606   int do_G = 0;
 607   int do_g = 0;
 608   int do_showinfo = showinfo;
 609   int do_showrest = 0;
 610   int do_flip = 0;
 611   int erroroffset, len, delimiter;
 612
 613   use_utf8 = 0;
 614
 615   if (infile == stdin) printf("  re> ");
 616   if (fgets((char *)buffer, BUFFER_SIZE, infile) == NULL) break;
 617   if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
 618   fflush(outfile);
 619
 620   p = buffer;
 621   while (isspace(*p)) p++;
 622   if (*p == 0) continue;
 623
 624   /* See if the pattern is to be loaded pre-compiled from a file. */
 625
 626   if (*p == '<' && strchr((char *)(p+1), '<') == NULL)
 627     {
 628     unsigned long int magic;
 629     uschar sbuf[8];
 630     FILE *f;
 631
 632     p++;
 633     pp = p + (int)strlen((char *)p);
 634     while (isspace(pp[-1])) pp--;
 635     *pp = 0;
 636
 637     f = fopen((char *)p, "rb");
 638     if (f == NULL)
 639       {
 640       fprintf(outfile, "Failed to open %s: %s\n", p, strerror(errno));
 641       continue;
 642       }
 643
 644     if (fread(sbuf, 1, 8, f) != 8) goto FAIL_READ;
 645
 646     true_size =
 647       (sbuf[0] << 24) | (sbuf[1] << 16) | (sbuf[2] << 8) | sbuf[3];
 648     true_study_size =
 649       (sbuf[4] << 24) | (sbuf[5] << 16) | (sbuf[6] << 8) | sbuf[7];
 650
 651     re = (real_pcre *)new_malloc(true_size);
 652     regex_gotten_store = gotten_store;
 653
 654     if (fread(re, 1, true_size, f) != true_size) goto FAIL_READ;
 655
 656     magic = ((real_pcre *)re)->magic_number;
 657     if (magic != MAGIC_NUMBER)
 658       {
 659       if (byteflip(magic, sizeof(magic)) == MAGIC_NUMBER)
 660         {
 661         do_flip = 1;
 662         }
 663       else
 664         {
 665         fprintf(outfile, "Data in %s is not a compiled PCRE regex\n", p);
 666         fclose(f);
 667         continue;
 668         }
 669       }
 670
 671     fprintf(outfile, "Compiled regex%s loaded from %s\n",
 672       do_flip? " (byte-inverted)" : "", p);
 673
 674     /* Need to know if UTF-8 for printing data strings */
 675
 676     new_info(re, NULL, PCRE_INFO_OPTIONS, &options);
 677     use_utf8 = (options & PCRE_UTF8) != 0;
 678
 679     /* Now see if there is any following study data */
 680
 681     if (true_study_size != 0)
 682       {
 683       pcre_study_data *psd;
 684
 685       extra = (pcre_extra *)new_malloc(sizeof(pcre_extra) + true_study_size);
 686       extra->flags = PCRE_EXTRA_STUDY_DATA;
 687
 688       psd = (pcre_study_data *)(((char *)extra) + sizeof(pcre_extra));
 689       extra->study_data = psd;
 690
 691       if (fread(psd, 1, true_study_size, f) != true_study_size)
 692         {
 693         FAIL_READ:
 694         fprintf(outfile, "Failed to read data from %s\n", p);
 695         if (extra != NULL) new_free(extra);
 696         if (re != NULL) new_free(re);
 697         fclose(f);
 698         continue;
 699         }
 700       fprintf(outfile, "Study data loaded from %s\n", p);
 701       do_study = 1;     /* To get the data output if requested */
 702       }
 703     else fprintf(outfile, "No study data\n");
 704
 705     fclose(f);
 706     goto SHOW_INFO;
 707     }
 708
 709   /* In-line pattern (the usual case). Get the delimiter and seek the end of
 710   the pattern; if is isn't complete, read more. */
 711
 712   delimiter = *p++;
 713
 714   if (isalnum(delimiter) || delimiter == '\\')
 715     {
 716     fprintf(outfile, "** Delimiter must not be alphameric or \\\n");
 717     goto SKIP_DATA;
 718     }
 719
 720   pp = p;
 721
 722   for(;;)
 723     {
 724     while (*pp != 0)
 725       {
 726       if (*pp == '\\' && pp[1] != 0) pp++;
 727         else if (*pp == delimiter) break;
 728       pp++;
 729       }
 730     if (*pp != 0) break;
 731
 732     len = BUFFER_SIZE - (pp - buffer);
 733     if (len < 256)
 734       {
 735       fprintf(outfile, "** Expression too long - missing delimiter?\n");
 736       goto SKIP_DATA;
 737       }
 738
 739     if (infile == stdin) printf("    > ");
 740     if (fgets((char *)pp, len, infile) == NULL)
 741       {
 742       fprintf(outfile, "** Unexpected EOF\n");
 743       done = 1;
 744       goto CONTINUE;
 745       }
 746     if (infile != stdin) fprintf(outfile, "%s", (char *)pp);
 747     }
 748
 749   /* If the first character after the delimiter is backslash, make
 750   the pattern end with backslash. This is purely to provide a way
 751   of testing for the error message when a pattern ends with backslash. */
 752
 753   if (pp[1] == '\\') *pp++ = '\\';
 754
 755   /* Terminate the pattern at the delimiter, and save a copy of the pattern
 756   for callouts. */
 757
 758   *pp++ = 0;
 759   strcpy((char *)pbuffer, (char *)p);
 760
 761   /* Look for options after final delimiter */
 762
 763   options = 0;
 764   study_options = 0;
 765   log_store = showstore;  /* default from command line */
 766
 767   while (*pp != 0)
 768     {
 769     switch (*pp++)
 770       {
 771       case 'f': options |= PCRE_FIRSTLINE; break;
 772       case 'g': do_g = 1; break;
 773       case 'i': options |= PCRE_CASELESS; break;
 774       case 'm': options |= PCRE_MULTILINE; break;
 775       case 's': options |= PCRE_DOTALL; break;
 776       case 'x': options |= PCRE_EXTENDED; break;
 777
 778       case '+': do_showrest = 1; break;
 779       case 'A': options |= PCRE_ANCHORED; break;
 780       case 'C': options |= PCRE_AUTO_CALLOUT; break;
 781       case 'D': do_debug = do_showinfo = 1; break;
 782       case 'E': options |= PCRE_DOLLAR_ENDONLY; break;
 783       case 'F': do_flip = 1; break;
 784       case 'G': do_G = 1; break;
 785       case 'I': do_showinfo = 1; break;
 786       case 'M': log_store = 1; break;
 787       case 'N': options |= PCRE_NO_AUTO_CAPTURE; break;
 788
 789 #if !defined NOPOSIX
 790       case 'P': do_posix = 1; break;
 791 #endif
 792
 793       case 'S': do_study = 1; break;
 794       case 'U': options |= PCRE_UNGREEDY; break;
 795       case 'X': options |= PCRE_EXTRA; break;
 796       case '8': options |= PCRE_UTF8; use_utf8 = 1; break;
 797       case '?': options |= PCRE_NO_UTF8_CHECK; break;
 798
 799       case 'L':
 800       ppp = pp;
 801       /* The '\r' test here is so that it works on Windows */
 802       while (*ppp != '\n' && *ppp != '\r' && *ppp != ' ') ppp++;
 803       *ppp = 0;
 804       if (setlocale(LC_CTYPE, (const char *)pp) == NULL)
 805         {
 806         fprintf(outfile, "** Failed to set locale \"%s\"\n", pp);
 807         goto SKIP_DATA;
 808         }
 809       tables = pcre_maketables();
 810       pp = ppp;
 811       break;
 812
 813       case '>':
 814       to_file = pp;
 815       while (*pp != 0) pp++;
 816       while (isspace(pp[-1])) pp--;
 817       *pp = 0;
 818       break;
 819
 820       case '\r':                      /* So that it works in Windows */
 821       case '\n':
 822       case ' ':
 823       break;
 824
 825       default:
 826       fprintf(outfile, "** Unknown option '%c'\n", pp[-1]);
 827       goto SKIP_DATA;
 828       }
 829     }
 830
 831   /* Handle compiling via the POSIX interface, which doesn't support the
 832   timing, showing, or debugging options, nor the ability to pass over
 833   local character tables. */
 834
 835 #if !defined NOPOSIX
 836   if (posix || do_posix)
 837     {
 838     int rc;
 839     int cflags = 0;
 840
 841     if ((options & PCRE_CASELESS) != 0) cflags |= REG_ICASE;
 842     if ((options & PCRE_MULTILINE) != 0) cflags |= REG_NEWLINE;
 843     if ((options & PCRE_DOTALL) != 0) cflags |= REG_DOTALL;
 844     rc = regcomp(&preg, (char *)p, cflags);
 845
 846     /* Compilation failed; go back for another re, skipping to blank line
 847     if non-interactive. */
 848
 849     if (rc != 0)
 850       {
 851       (void)regerror(rc, &preg, (char *)buffer, BUFFER_SIZE);
 852       fprintf(outfile, "Failed: POSIX code %d: %s\n", rc, buffer);
 853       goto SKIP_DATA;
 854       }
 855     }
 856
 857   /* Handle compiling via the native interface */
 858
 859   else
 860 #endif  /* !defined NOPOSIX */
 861
 862     {
 863     if (timeit)
 864       {
 865       register int i;
 866       clock_t time_taken;
 867       clock_t start_time = clock();
 868       for (i = 0; i < LOOPREPEAT; i++)
 869         {
 870         re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
 871         if (re != NULL) free(re);
 872         }
 873       time_taken = clock() - start_time;
 874       fprintf(outfile, "Compile time %.3f milliseconds\n",
 875         (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /
 876           (double)CLOCKS_PER_SEC);
 877       }
 878
 879     re = pcre_compile((char *)p, options, &error, &erroroffset, tables);
 880
 881     /* Compilation failed; go back for another re, skipping to blank line
 882     if non-interactive. */
 883
 884     if (re == NULL)
 885       {
 886       fprintf(outfile, "Failed: %s at offset %d\n", error, erroroffset);
 887       SKIP_DATA:
 888       if (infile != stdin)
 889         {
 890         for (;;)
 891           {
 892           if (fgets((char *)buffer, BUFFER_SIZE, infile) == NULL)
 893             {
 894             done = 1;
 895             goto CONTINUE;
 896             }
 897           len = (int)strlen((char *)buffer);
 898           while (len > 0 && isspace(buffer[len-1])) len--;
 899           if (len == 0) break;
 900           }
 901         fprintf(outfile, "\n");
 902         }
 903       goto CONTINUE;
 904       }
 905
 906     /* Compilation succeeded; print data if required. There are now two
 907     info-returning functions. The old one has a limited interface and
 908     returns only limited data. Check that it agrees with the newer one. */
 909
 910     if (log_store)
 911       fprintf(outfile, "Memory allocation (code space): %d\n",
 912         (int)(gotten_store -
 913               sizeof(real_pcre) -
 914               ((real_pcre *)re)->name_count * ((real_pcre *)re)->name_entry_size));
 915
 916     /* Extract the size for possible writing before possibly flipping it,
 917     and remember the store that was got. */
 918
 919     true_size = ((real_pcre *)re)->size;
 920     regex_gotten_store = gotten_store;
 921
 922     /* If /S was present, study the regexp to generate additional info to
 923     help with the matching. */
 924
 925     if (do_study)
 926       {
 927       if (timeit)
 928         {
 929         register int i;
 930         clock_t time_taken;
 931         clock_t start_time = clock();
 932         for (i = 0; i < LOOPREPEAT; i++)
 933           extra = pcre_study(re, study_options, &error);
 934         time_taken = clock() - start_time;
 935         if (extra != NULL) free(extra);
 936         fprintf(outfile, "  Study time %.3f milliseconds\n",
 937           (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /
 938             (double)CLOCKS_PER_SEC);
 939         }
 940       extra = pcre_study(re, study_options, &error);
 941       if (error != NULL)
 942         fprintf(outfile, "Failed to study: %s\n", error);
 943       else if (extra != NULL)
 944         true_study_size = ((pcre_study_data *)(extra->study_data))->size;
 945       }
 946
 947     /* If the 'F' option was present, we flip the bytes of all the integer
 948     fields in the regex data block and the study block. This is to make it
 949     possible to test PCRE's handling of byte-flipped patterns, e.g. those
 950     compiled on a different architecture. */
 951
 952     if (do_flip)
 953       {
 954       real_pcre *rre = (real_pcre *)re;
 955       rre->magic_number = byteflip(rre->magic_number, sizeof(rre->magic_number));
 956       rre->size = byteflip(rre->size, sizeof(rre->size));
 957       rre->options = byteflip(rre->options, sizeof(rre->options));
 958       rre->top_bracket = byteflip(rre->top_bracket, sizeof(rre->top_bracket));
 959       rre->top_backref = byteflip(rre->top_backref, sizeof(rre->top_backref));
 960       rre->first_byte = byteflip(rre->first_byte, sizeof(rre->first_byte));
 961       rre->req_byte = byteflip(rre->req_byte, sizeof(rre->req_byte));
 962       rre->name_table_offset = byteflip(rre->name_table_offset,
 963         sizeof(rre->name_table_offset));
 964       rre->name_entry_size = byteflip(rre->name_entry_size,
 965         sizeof(rre->name_entry_size));
 966       rre->name_count = byteflip(rre->name_count, sizeof(rre->name_count));
 967
 968       if (extra != NULL)
 969         {
 970         pcre_study_data *rsd = (pcre_study_data *)(extra->study_data);
 971         rsd->size = byteflip(rsd->size, sizeof(rsd->size));
 972         rsd->options = byteflip(rsd->options, sizeof(rsd->options));
 973         }
 974       }
 975
 976     /* Extract information from the compiled data if required */
 977
 978     SHOW_INFO:
 979
 980     if (do_showinfo)
 981       {
 982       unsigned long int get_options, all_options;
 983 #if !defined NOINFOCHECK
 984       int old_first_char, old_options, old_count;
 985 #endif
 986       int count, backrefmax, first_char, need_char;
 987       int nameentrysize, namecount;
 988       const uschar *nametable;
 989
 990       if (do_debug)
 991         {
 992         fprintf(outfile, "------------------------------------------------------------------\n");
 993         _pcre_printint(re, outfile);
 994         }
 995
 996       new_info(re, NULL, PCRE_INFO_OPTIONS, &get_options);
 997       new_info(re, NULL, PCRE_INFO_SIZE, &size);
 998       new_info(re, NULL, PCRE_INFO_CAPTURECOUNT, &count);
 999       new_info(re, NULL, PCRE_INFO_BACKREFMAX, &backrefmax);
1000       new_info(re, NULL, PCRE_INFO_FIRSTBYTE, &first_char);
1001       new_info(re, NULL, PCRE_INFO_LASTLITERAL, &need_char);
1002       new_info(re, NULL, PCRE_INFO_NAMEENTRYSIZE, &nameentrysize);
1003       new_info(re, NULL, PCRE_INFO_NAMECOUNT, &namecount);
1004       new_info(re, NULL, PCRE_INFO_NAMETABLE, (void *)&nametable);
1005
1006 #if !defined NOINFOCHECK
1007       old_count = pcre_info(re, &old_options, &old_first_char);
1008       if (count < 0) fprintf(outfile,
1009         "Error %d from pcre_info()\n", count);
1010       else
1011         {
1012         if (old_count != count) fprintf(outfile,
1013           "Count disagreement: pcre_fullinfo=%d pcre_info=%d\n", count,
1014             old_count);
1015
1016         if (old_first_char != first_char) fprintf(outfile,
1017           "First char disagreement: pcre_fullinfo=%d pcre_info=%d\n",
1018             first_char, old_first_char);
1019
1020         if (old_options != (int)get_options) fprintf(outfile,
1021           "Options disagreement: pcre_fullinfo=%ld pcre_info=%d\n",
1022             get_options, old_options);
1023         }
1024 #endif
1025
1026       if (size != regex_gotten_store) fprintf(outfile,
1027         "Size disagreement: pcre_fullinfo=%d call to malloc for %d\n",
1028         (int)size, (int)regex_gotten_store);
1029
1030       fprintf(outfile, "Capturing subpattern count = %d\n", count);
1031       if (backrefmax > 0)
1032         fprintf(outfile, "Max back reference = %d\n", backrefmax);
1033
1034       if (namecount > 0)
1035         {
1036         fprintf(outfile, "Named capturing subpatterns:\n");
1037         while (namecount-- > 0)
1038           {
1039           fprintf(outfile, "  %s %*s%3d\n", nametable + 2,
1040             nameentrysize - 3 - (int)strlen((char *)nametable + 2), "",
1041             GET2(nametable, 0));
1042           nametable += nameentrysize;
1043           }
1044         }
1045
1046       /* The NOPARTIAL bit is a private bit in the options, so we have
1047       to fish it out via out back door */
1048
1049       all_options = ((real_pcre *)re)->options;
1050       if (do_flip)
1051         {
1052         all_options = byteflip(all_options, sizeof(all_options));
1053         }
1054
1055       if ((all_options & PCRE_NOPARTIAL) != 0)
1056         fprintf(outfile, "Partial matching not supported\n");
1057
1058       if (get_options == 0) fprintf(outfile, "No options\n");
1059         else fprintf(outfile, "Options:%s%s%s%s%s%s%s%s%s%s%s\n",
1060           ((get_options & PCRE_ANCHORED) != 0)? " anchored" : "",
1061           ((get_options & PCRE_CASELESS) != 0)? " caseless" : "",
1062           ((get_options & PCRE_EXTENDED) != 0)? " extended" : "",
1063           ((get_options & PCRE_MULTILINE) != 0)? " multiline" : "",
1064           ((get_options & PCRE_FIRSTLINE) != 0)? " firstline" : "",
1065           ((get_options & PCRE_DOTALL) != 0)? " dotall" : "",
1066           ((get_options & PCRE_DOLLAR_ENDONLY) != 0)? " dollar_endonly" : "",
1067           ((get_options & PCRE_EXTRA) != 0)? " extra" : "",
1068           ((get_options & PCRE_UNGREEDY) != 0)? " ungreedy" : "",
1069           ((get_options & PCRE_UTF8) != 0)? " utf8" : "",
1070           ((get_options & PCRE_NO_UTF8_CHECK) != 0)? " no_utf8_check" : "");
1071
1072       if (((((real_pcre *)re)->options) & PCRE_ICHANGED) != 0)
1073         fprintf(outfile, "Case state changes\n");
1074
1075       if (first_char == -1)
1076         {
1077         fprintf(outfile, "First char at start or follows \\n\n");
1078         }
1079       else if (first_char < 0)
1080         {
1081         fprintf(outfile, "No first char\n");
1082         }
1083       else
1084         {
1085         int ch = first_char & 255;
1086         const char *caseless = ((first_char & REQ_CASELESS) == 0)?
1087           "" : " (caseless)";
1088         if (isprint(ch))
1089           fprintf(outfile, "First char = \'%c\'%s\n", ch, caseless);
1090         else
1091           fprintf(outfile, "First char = %d%s\n", ch, caseless);
1092         }
1093
1094       if (need_char < 0)
1095         {
1096         fprintf(outfile, "No need char\n");
1097         }
1098       else
1099         {
1100         int ch = need_char & 255;
1101         const char *caseless = ((need_char & REQ_CASELESS) == 0)?
1102           "" : " (caseless)";
1103         if (isprint(ch))
1104           fprintf(outfile, "Need char = \'%c\'%s\n", ch, caseless);
1105         else
1106           fprintf(outfile, "Need char = %d%s\n", ch, caseless);
1107         }
1108
1109       /* Don't output study size; at present it is in any case a fixed
1110       value, but it varies, depending on the computer architecture, and
1111       so messes up the test suite. (And with the /F option, it might be
1112       flipped.) */
1113
1114       if (do_study)
1115         {
1116         if (extra == NULL)
1117           fprintf(outfile, "Study returned NULL\n");
1118         else
1119           {
1120           uschar *start_bits = NULL;
1121           new_info(re, extra, PCRE_INFO_FIRSTTABLE, &start_bits);
1122
1123           if (start_bits == NULL)
1124             fprintf(outfile, "No starting byte set\n");
1125           else
1126             {
1127             int i;
1128             int c = 24;
1129             fprintf(outfile, "Starting byte set: ");
1130             for (i = 0; i < 256; i++)
1131               {
1132               if ((start_bits[i/8] & (1<<(i&7))) != 0)
1133                 {
1134                 if (c > 75)
1135                   {
1136                   fprintf(outfile, "\n  ");
1137                   c = 2;
1138                   }
1139                 if (isprint(i) && i != ' ')
1140                   {
1141                   fprintf(outfile, "%c ", i);
1142                   c += 2;
1143                   }
1144                 else
1145                   {
1146                   fprintf(outfile, "\\x%02x ", i);
1147                   c += 5;
1148                   }
1149                 }
1150               }
1151             fprintf(outfile, "\n");
1152             }
1153           }
1154         }
1155       }
1156
1157     /* If the '>' option was present, we write out the regex to a file, and
1158     that is all. The first 8 bytes of the file are the regex length and then
1159     the study length, in big-endian order. */
1160
1161     if (to_file != NULL)
1162       {
1163       FILE *f = fopen((char *)to_file, "wb");
1164       if (f == NULL)
1165         {
1166         fprintf(outfile, "Unable to open %s: %s\n", to_file, strerror(errno));
1167         }
1168       else
1169         {
1170         uschar sbuf[8];
1171         sbuf[0] = (true_size >> 24)  & 255;
1172         sbuf[1] = (true_size >> 16)  & 255;
1173         sbuf[2] = (true_size >>  8)  & 255;
1174         sbuf[3] = (true_size)  & 255;
1175
1176         sbuf[4] = (true_study_size >> 24)  & 255;
1177         sbuf[5] = (true_study_size >> 16)  & 255;
1178         sbuf[6] = (true_study_size >>  8)  & 255;
1179         sbuf[7] = (true_study_size)  & 255;
1180
1181         if (fwrite(sbuf, 1, 8, f) < 8 ||
1182             fwrite(re, 1, true_size, f) < true_size)
1183           {
1184           fprintf(outfile, "Write error on %s: %s\n", to_file, strerror(errno));
1185           }
1186         else
1187           {
1188           fprintf(outfile, "Compiled regex written to %s\n", to_file);
1189           if (extra != NULL)
1190             {
1191             if (fwrite(extra->study_data, 1, true_study_size, f) <
1192                 true_study_size)
1193               {
1194               fprintf(outfile, "Write error on %s: %s\n", to_file,
1195                 strerror(errno));
1196               }
1197             else fprintf(outfile, "Study data written to %s\n", to_file);
1198             }
1199           }
1200         fclose(f);
1201         }
1202
1203       new_free(re);
1204       if (extra != NULL) new_free(extra);
1205       if (tables != NULL) new_free((void *)tables);
1206       continue;  /* With next regex */
1207       }
1208     }        /* End of non-POSIX compile */
1209
1210   /* Read data lines and test them */
1211
1212   for (;;)
1213     {
1214     unsigned char *q;
1215     unsigned char *bptr = dbuffer;
1216     int *use_offsets = offsets;
1217     int use_size_offsets = size_offsets;
1218     int callout_data = 0;
1219     int callout_data_set = 0;
1220     int count, c;
1221     int copystrings = 0;
1222     int find_match_limit = 0;
1223     int getstrings = 0;
1224     int getlist = 0;
1225     int gmatched = 0;
1226     int start_offset = 0;
1227     int g_notempty = 0;
1228     int use_dfa = 0;
1229
1230     options = 0;
1231
1232     pcre_callout = callout;
1233     first_callout = 1;
1234     callout_extra = 0;
1235     callout_count = 0;
1236     callout_fail_count = 999999;
1237     callout_fail_id = -1;
1238     show_malloc = 0;
1239
1240     if (infile == stdin) printf("data> ");
1241     if (fgets((char *)buffer, BUFFER_SIZE, infile) == NULL)
1242       {
1243       done = 1;
1244       goto CONTINUE;
1245       }
1246     if (infile != stdin) fprintf(outfile, "%s", (char *)buffer);
1247
1248     len = (int)strlen((char *)buffer);
1249     while (len > 0 && isspace(buffer[len-1])) len--;
1250     buffer[len] = 0;
1251     if (len == 0) break;
1252
1253     p = buffer;
1254     while (isspace(*p)) p++;
1255
1256     q = dbuffer;
1257     while ((c = *p++) != 0)
1258       {
1259       int i = 0;
1260       int n = 0;
1261
1262       if (c == '\\') switch ((c = *p++))
1263         {
1264         case 'a': c =    7; break;
1265         case 'b': c = '\b'; break;
1266         case 'e': c =   27; break;
1267         case 'f': c = '\f'; break;
1268         case 'n': c = '\n'; break;
1269         case 'r': c = '\r'; break;
1270         case 't': c = '\t'; break;
1271         case 'v': c = '\v'; break;
1272
1273         case '0': case '1': case '2': case '3':
1274         case '4': case '5': case '6': case '7':
1275         c -= '0';
1276         while (i++ < 2 && isdigit(*p) && *p != '8' && *p != '9')
1277           c = c * 8 + *p++ - '0';
1278         break;
1279
1280         case 'x':
1281
1282         /* Handle \x{..} specially - new Perl thing for utf8 */
1283
1284 #if !defined NOUTF8
1285         if (*p == '{')
1286           {
1287           unsigned char *pt = p;
1288           c = 0;
1289           while (isxdigit(*(++pt)))
1290             c = c * 16 + tolower(*pt) - ((isdigit(*pt))? '0' : 'W');
1291           if (*pt == '}')
1292             {
1293             unsigned char buff8[8];
1294             int ii, utn;
1295             utn = _pcre_ord2utf8(c, buff8);
1296             for (ii = 0; ii < utn - 1; ii++) *q++ = buff8[ii];
1297             c = buff8[ii];   /* Last byte */
1298             p = pt + 1;
1299             break;
1300             }
1301           /* Not correct form; fall through */
1302           }
1303 #endif
1304
1305         /* Ordinary \x */
1306
1307         c = 0;
1308         while (i++ < 2 && isxdigit(*p))
1309           {
1310           c = c * 16 + tolower(*p) - ((isdigit(*p))? '0' : 'W');
1311           p++;
1312           }
1313         break;
1314
1315         case 0:   /* \ followed by EOF allows for an empty line */
1316         p--;
1317         continue;
1318
1319         case '>':
1320         while(isdigit(*p)) start_offset = start_offset * 10 + *p++ - '0';
1321         continue;
1322
1323         case 'A':  /* Option setting */
1324         options |= PCRE_ANCHORED;
1325         continue;
1326
1327         case 'B':
1328         options |= PCRE_NOTBOL;
1329         continue;
1330
1331         case 'C':
1332         if (isdigit(*p))    /* Set copy string */
1333           {
1334           while(isdigit(*p)) n = n * 10 + *p++ - '0';
1335           copystrings |= 1 << n;
1336           }
1337         else if (isalnum(*p))
1338           {
1339           uschar name[256];
1340           uschar *npp = name;
1341           while (isalnum(*p)) *npp++ = *p++;
1342           *npp = 0;
1343           n = pcre_get_stringnumber(re, (char *)name);
1344           if (n < 0)
1345             fprintf(outfile, "no parentheses with name \"%s\"\n", name);
1346           else copystrings |= 1 << n;
1347           }
1348         else if (*p == '+')
1349           {
1350           callout_extra = 1;
1351           p++;
1352           }
1353         else if (*p == '-')
1354           {
1355           pcre_callout = NULL;
1356           p++;
1357           }
1358         else if (*p == '!')
1359           {
1360           callout_fail_id = 0;
1361           p++;
1362           while(isdigit(*p))
1363             callout_fail_id = callout_fail_id * 10 + *p++ - '0';
1364           callout_fail_count = 0;
1365           if (*p == '!')
1366             {
1367             p++;
1368             while(isdigit(*p))
1369               callout_fail_count = callout_fail_count * 10 + *p++ - '0';
1370             }
1371           }
1372         else if (*p == '*')
1373           {
1374           int sign = 1;
1375           callout_data = 0;
1376           if (*(++p) == '-') { sign = -1; p++; }
1377           while(isdigit(*p))
1378             callout_data = callout_data * 10 + *p++ - '0';
1379           callout_data *= sign;
1380           callout_data_set = 1;
1381           }
1382         continue;
1383
1384 #if !defined NODFA
1385         case 'D':
1386 #if !defined NOPOSIX
1387         if (posix || do_posix)
1388           printf("** Can't use dfa matching in POSIX mode: \\D ignored\n");
1389         else
1390 #endif
1391           use_dfa = 1;
1392         continue;
1393
1394         case 'F':
1395         options |= PCRE_DFA_SHORTEST;
1396         continue;
1397 #endif
1398
1399         case 'G':
1400         if (isdigit(*p))
1401           {
1402           while(isdigit(*p)) n = n * 10 + *p++ - '0';
1403           getstrings |= 1 << n;
1404           }
1405         else if (isalnum(*p))
1406           {
1407           uschar name[256];
1408           uschar *npp = name;
1409           while (isalnum(*p)) *npp++ = *p++;
1410           *npp = 0;
1411           n = pcre_get_stringnumber(re, (char *)name);
1412           if (n < 0)
1413             fprintf(outfile, "no parentheses with name \"%s\"\n", name);
1414           else getstrings |= 1 << n;
1415           }
1416         continue;
1417
1418         case 'L':
1419         getlist = 1;
1420         continue;
1421
1422         case 'M':
1423         find_match_limit = 1;
1424         continue;
1425
1426         case 'N':
1427         options |= PCRE_NOTEMPTY;
1428         continue;
1429
1430         case 'O':
1431         while(isdigit(*p)) n = n * 10 + *p++ - '0';
1432         if (n > size_offsets_max)
1433           {
1434           size_offsets_max = n;
1435           free(offsets);
1436           use_offsets = offsets = (int *)malloc(size_offsets_max * sizeof(int));
1437           if (offsets == NULL)
1438             {
1439             printf("** Failed to get %d bytes of memory for offsets vector\n",
1440               size_offsets_max * sizeof(int));
1441             yield = 1;
1442             goto EXIT;
1443             }
1444           }
1445         use_size_offsets = n;
1446         if (n == 0) use_offsets = NULL;   /* Ensures it can't write to it */
1447         continue;
1448
1449         case 'P':
1450         options |= PCRE_PARTIAL;
1451         continue;
1452
1453 #if !defined NODFA
1454         case 'R':
1455         options |= PCRE_DFA_RESTART;
1456         continue;
1457 #endif
1458
1459         case 'S':
1460         show_malloc = 1;
1461         continue;
1462
1463         case 'Z':
1464         options |= PCRE_NOTEOL;
1465         continue;
1466
1467         case '?':
1468         options |= PCRE_NO_UTF8_CHECK;
1469         continue;
1470         }
1471       *q++ = c;
1472       }
1473     *q = 0;
1474     len = q - dbuffer;
1475
1476     if ((all_use_dfa || use_dfa) && find_match_limit)
1477       {
1478       printf("**Match limit not relevant for DFA matching: ignored\n");
1479       find_match_limit = 0;
1480       }
1481
1482     /* Handle matching via the POSIX interface, which does not
1483     support timing or playing with the match limit or callout data. */
1484
1485 #if !defined NOPOSIX
1486     if (posix || do_posix)
1487       {
1488       int rc;
1489       int eflags = 0;
1490       regmatch_t *pmatch = NULL;
1491       if (use_size_offsets > 0)
1492         pmatch = (regmatch_t *)malloc(sizeof(regmatch_t) * use_size_offsets);
1493       if ((options & PCRE_NOTBOL) != 0) eflags |= REG_NOTBOL;
1494       if ((options & PCRE_NOTEOL) != 0) eflags |= REG_NOTEOL;
1495
1496       rc = regexec(&preg, (const char *)bptr, use_size_offsets, pmatch, eflags);
1497
1498       if (rc != 0)
1499         {
1500         (void)regerror(rc, &preg, (char *)buffer, BUFFER_SIZE);
1501         fprintf(outfile, "No match: POSIX code %d: %s\n", rc, buffer);
1502         }
1503       else
1504         {
1505         size_t i;
1506         for (i = 0; i < (size_t)use_size_offsets; i++)
1507           {
1508           if (pmatch[i].rm_so >= 0)
1509             {
1510             fprintf(outfile, "%2d: ", (int)i);
1511             (void)pchars(dbuffer + pmatch[i].rm_so,
1512               pmatch[i].rm_eo - pmatch[i].rm_so, outfile);
1513             fprintf(outfile, "\n");
1514             if (i == 0 && do_showrest)
1515               {
1516               fprintf(outfile, " 0+ ");
1517               (void)pchars(dbuffer + pmatch[i].rm_eo, len - pmatch[i].rm_eo,
1518                 outfile);
1519               fprintf(outfile, "\n");
1520               }
1521             }
1522           }
1523         }
1524       free(pmatch);
1525       }
1526
1527     /* Handle matching via the native interface - repeats for /g and /G */
1528
1529     else
1530 #endif  /* !defined NOPOSIX */
1531
1532     for (;; gmatched++)    /* Loop for /g or /G */
1533       {
1534       if (timeit)
1535         {
1536         register int i;
1537         clock_t time_taken;
1538         clock_t start_time = clock();
1539
1540 #if !defined NODFA
1541         if (all_use_dfa || use_dfa)
1542           {
1543           int workspace[1000];
1544           for (i = 0; i < LOOPREPEAT; i++)
1545             count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,
1546               options | g_notempty, use_offsets, use_size_offsets, workspace,
1547               sizeof(workspace)/sizeof(int));
1548           }
1549         else
1550 #endif
1551
1552         for (i = 0; i < LOOPREPEAT; i++)
1553           count = pcre_exec(re, extra, (char *)bptr, len,
1554             start_offset, options | g_notempty, use_offsets, use_size_offsets);
1555
1556         time_taken = clock() - start_time;
1557         fprintf(outfile, "Execute time %.3f milliseconds\n",
1558           (((double)time_taken * 1000.0) / (double)LOOPREPEAT) /
1559             (double)CLOCKS_PER_SEC);
1560         }
1561
1562       /* If find_match_limit is set, we want to do repeated matches with
1563       varying limits in order to find the minimum value. */
1564
1565       if (find_match_limit)
1566         {
1567         int min = 0;
1568         int mid = 64;
1569         int max = -1;
1570
1571         if (extra == NULL)
1572           {
1573           extra = (pcre_extra *)malloc(sizeof(pcre_extra));
1574           extra->flags = 0;
1575           }
1576         extra->flags |= PCRE_EXTRA_MATCH_LIMIT;
1577
1578         for (;;)
1579           {
1580           extra->match_limit = mid;
1581           count = pcre_exec(re, extra, (char *)bptr, len, start_offset,
1582             options | g_notempty, use_offsets, use_size_offsets);
1583           if (count == PCRE_ERROR_MATCHLIMIT)
1584             {
1585             /* fprintf(outfile, "Testing match limit = %d\n", mid); */
1586             min = mid;
1587             mid = (mid == max - 1)? max : (max > 0)? (min + max)/2 : mid*2;
1588             }
1589           else if (count >= 0 || count == PCRE_ERROR_NOMATCH ||
1590                                  count == PCRE_ERROR_PARTIAL)
1591             {
1592             if (mid == min + 1)
1593               {
1594               fprintf(outfile, "Minimum match limit = %d\n", mid);
1595               break;
1596               }
1597             /* fprintf(outfile, "Testing match limit = %d\n", mid); */
1598             max = mid;
1599             mid = (min + mid)/2;
1600             }
1601           else break;    /* Some other error */
1602           }
1603
1604         extra->flags &= ~PCRE_EXTRA_MATCH_LIMIT;
1605         }
1606
1607       /* If callout_data is set, use the interface with additional data */
1608
1609       else if (callout_data_set)
1610         {
1611         if (extra == NULL)
1612           {
1613           extra = (pcre_extra *)malloc(sizeof(pcre_extra));
1614           extra->flags = 0;
1615           }
1616         extra->flags |= PCRE_EXTRA_CALLOUT_DATA;
1617         extra->callout_data = &callout_data;
1618         count = pcre_exec(re, extra, (char *)bptr, len, start_offset,
1619           options | g_notempty, use_offsets, use_size_offsets);
1620         extra->flags &= ~PCRE_EXTRA_CALLOUT_DATA;
1621         }
1622
1623       /* The normal case is just to do the match once, with the default
1624       value of match_limit. */
1625
1626 #if !defined NODFA
1627       else if (all_use_dfa || use_dfa)
1628         {
1629         int workspace[1000];
1630         count = pcre_dfa_exec(re, NULL, (char *)bptr, len, start_offset,
1631           options | g_notempty, use_offsets, use_size_offsets, workspace,
1632           sizeof(workspace)/sizeof(int));
1633         if (count == 0)
1634           {
1635           fprintf(outfile, "Matched, but too many subsidiary matches\n");
1636           count = use_size_offsets/2;
1637           }
1638         }
1639 #endif
1640
1641       else
1642         {
1643         count = pcre_exec(re, extra, (char *)bptr, len,
1644           start_offset, options | g_notempty, use_offsets, use_size_offsets);
1645         if (count == 0)
1646           {
1647           fprintf(outfile, "Matched, but too many substrings\n");
1648           count = use_size_offsets/3;
1649           }
1650         }
1651
1652       /* Matched */
1653
1654       if (count >= 0)
1655         {
1656         int i;
1657         for (i = 0; i < count * 2; i += 2)
1658           {
1659           if (use_offsets[i] < 0)
1660             fprintf(outfile, "%2d: <unset>\n", i/2);
1661           else
1662             {
1663             fprintf(outfile, "%2d: ", i/2);
1664             (void)pchars(bptr + use_offsets[i],
1665               use_offsets[i+1] - use_offsets[i], outfile);
1666             fprintf(outfile, "\n");
1667             if (i == 0)
1668               {
1669               if (do_showrest)
1670                 {
1671                 fprintf(outfile, " 0+ ");
1672                 (void)pchars(bptr + use_offsets[i+1], len - use_offsets[i+1],
1673                   outfile);
1674                 fprintf(outfile, "\n");
1675                 }
1676               }
1677             }
1678           }
1679
1680         for (i = 0; i < 32; i++)
1681           {
1682           if ((copystrings & (1 << i)) != 0)
1683             {
1684             char copybuffer[16];
1685             int rc = pcre_copy_substring((char *)bptr, use_offsets, count,
1686               i, copybuffer, sizeof(copybuffer));
1687             if (rc < 0)
1688               fprintf(outfile, "copy substring %d failed %d\n", i, rc);
1689             else
1690               fprintf(outfile, "%2dC %s (%d)\n", i, copybuffer, rc);
1691             }
1692           }
1693
1694         for (i = 0; i < 32; i++)
1695           {
1696           if ((getstrings & (1 << i)) != 0)
1697             {
1698             const char *substring;
1699             int rc = pcre_get_substring((char *)bptr, use_offsets, count,
1700               i, &substring);
1701             if (rc < 0)
1702               fprintf(outfile, "get substring %d failed %d\n", i, rc);
1703             else
1704               {
1705               fprintf(outfile, "%2dG %s (%d)\n", i, substring, rc);
1706               /* free((void *)substring); */
1707               pcre_free_substring(substring);
1708               }
1709             }
1710           }
1711
1712         if (getlist)
1713           {
1714           const char **stringlist;
1715           int rc = pcre_get_substring_list((char *)bptr, use_offsets, count,
1716             &stringlist);
1717           if (rc < 0)
1718             fprintf(outfile, "get substring list failed %d\n", rc);
1719           else
1720             {
1721             for (i = 0; i < count; i++)
1722               fprintf(outfile, "%2dL %s\n", i, stringlist[i]);
1723             if (stringlist[i] != NULL)
1724               fprintf(outfile, "string list not terminated by NULL\n");
1725             /* free((void *)stringlist); */
1726             pcre_free_substring_list(stringlist);
1727             }
1728           }
1729         }
1730
1731       /* There was a partial match */
1732
1733       else if (count == PCRE_ERROR_PARTIAL)
1734         {
1735         fprintf(outfile, "Partial match");
1736 #if !defined NODFA
1737         if ((all_use_dfa || use_dfa) && use_size_offsets > 2)
1738           fprintf(outfile, ": %.*s", use_offsets[1] - use_offsets[0],
1739             bptr + use_offsets[0]);
1740 #endif
1741         fprintf(outfile, "\n");
1742         break;  /* Out of the /g loop */
1743         }
1744
1745       /* Failed to match. If this is a /g or /G loop and we previously set
1746       g_notempty after a null match, this is not necessarily the end.
1747       We want to advance the start offset, and continue. In the case of UTF-8
1748       matching, the advance must be one character, not one byte. Fudge the
1749       offset values to achieve this. We won't be at the end of the string -
1750       that was checked before setting g_notempty. */
1751
1752       else
1753         {
1754         if (g_notempty != 0)
1755           {
1756           int onechar = 1;
1757           use_offsets[0] = start_offset;
1758           if (use_utf8)
1759             {
1760             while (start_offset + onechar < len)
1761               {
1762               int tb = bptr[start_offset+onechar];
1763               if (tb <= 127) break;
1764               tb &= 0xc0;
1765               if (tb != 0 && tb != 0xc0) onechar++;
1766               }
1767             }
1768           use_offsets[1] = start_offset + onechar;
1769           }
1770         else
1771           {
1772           if (count == PCRE_ERROR_NOMATCH)
1773             {
1774             if (gmatched == 0) fprintf(outfile, "No match\n");
1775             }
1776           else fprintf(outfile, "Error %d\n", count);
1777           break;  /* Out of the /g loop */
1778           }
1779         }
1780
1781       /* If not /g or /G we are done */
1782
1783       if (!do_g && !do_G) break;
1784
1785       /* If we have matched an empty string, first check to see if we are at
1786       the end of the subject. If so, the /g loop is over. Otherwise, mimic
1787       what Perl's /g options does. This turns out to be rather cunning. First
1788       we set PCRE_NOTEMPTY and PCRE_ANCHORED and try the match again at the
1789       same point. If this fails (picked up above) we advance to the next
1790       character. */
1791
1792       g_notempty = 0;
1793       if (use_offsets[0] == use_offsets[1])
1794         {
1795         if (use_offsets[0] == len) break;
1796         g_notempty = PCRE_NOTEMPTY | PCRE_ANCHORED;
1797         }
1798
1799       /* For /g, update the start offset, leaving the rest alone */
1800
1801       if (do_g) start_offset = use_offsets[1];
1802
1803       /* For /G, update the pointer and length */
1804
1805       else
1806         {
1807         bptr += use_offsets[1];
1808         len -= use_offsets[1];
1809         }
1810       }  /* End of loop for /g and /G */
1811     }    /* End of loop for data lines */
1812
1813   CONTINUE:
1814
1815 #if !defined NOPOSIX
1816   if (posix || do_posix) regfree(&preg);
1817 #endif
1818
1819   if (re != NULL) new_free(re);
1820   if (extra != NULL) new_free(extra);
1821   if (tables != NULL)
1822     {
1823     new_free((void *)tables);
1824     setlocale(LC_CTYPE, "C");
1825     }
1826   }
1827
1828 if (infile == stdin) fprintf(outfile, "\n");
1829
1830 EXIT:
1831
1832 if (infile != NULL && infile != stdin) fclose(infile);
1833 if (outfile != NULL && outfile != stdout) fclose(outfile);
1834
1835 free(buffer);
1836 free(dbuffer);
1837 free(pbuffer);
1838 free(offsets);
1839
1840 return yield;
1841 }
1842
1843 /* End of pcretest.c */