| 48 |
#include <locale.h> |
#include <locale.h> |
| 49 |
#include <errno.h> |
#include <errno.h> |
| 50 |
|
|
| 51 |
|
#ifdef SUPPORT_LIBREADLINE |
| 52 |
|
#ifdef HAVE_UNISTD_H |
| 53 |
|
#include <unistd.h> |
| 54 |
|
#endif |
| 55 |
|
#include <readline/readline.h> |
| 56 |
|
#include <readline/history.h> |
| 57 |
|
#endif |
| 58 |
|
|
| 59 |
|
|
| 60 |
/* A number of things vary for Windows builds. Originally, pcretest opened its |
/* A number of things vary for Windows builds. Originally, pcretest opened its |
| 61 |
input and output without "b"; then I was told that "b" was needed in some |
input and output without "b"; then I was told that "b" was needed in some |
| 71 |
#define INPUT_MODE "r" |
#define INPUT_MODE "r" |
| 72 |
#define OUTPUT_MODE "wb" |
#define OUTPUT_MODE "wb" |
| 73 |
|
|
| 74 |
|
#define isatty _isatty /* This is what Windows calls them, I'm told */ |
| 75 |
|
#define fileno _fileno |
| 76 |
|
|
| 77 |
#else |
#else |
| 78 |
#include <sys/time.h> /* These two includes are needed */ |
#include <sys/time.h> /* These two includes are needed */ |
| 79 |
#include <sys/resource.h> /* for setrlimit(). */ |
#include <sys/resource.h> /* for setrlimit(). */ |
| 94 |
#include "pcre.h" |
#include "pcre.h" |
| 95 |
#include "pcre_internal.h" |
#include "pcre_internal.h" |
| 96 |
|
|
| 97 |
/* We need access to the data tables that PCRE uses. So as not to have to keep |
/* We need access to some of the data tables that PCRE uses. So as not to have |
| 98 |
two copies, we include the source file here, changing the names of the external |
to keep two copies, we include the source file here, changing the names of the |
| 99 |
symbols to prevent clashes. */ |
external symbols to prevent clashes. */ |
| 100 |
|
|
| 101 |
|
#define _pcre_ucp_gentype ucp_gentype |
| 102 |
#define _pcre_utf8_table1 utf8_table1 |
#define _pcre_utf8_table1 utf8_table1 |
| 103 |
#define _pcre_utf8_table1_size utf8_table1_size |
#define _pcre_utf8_table1_size utf8_table1_size |
| 104 |
#define _pcre_utf8_table2 utf8_table2 |
#define _pcre_utf8_table2 utf8_table2 |
| 201 |
Arguments: |
Arguments: |
| 202 |
f the file to read |
f the file to read |
| 203 |
start where in buffer to start (this *must* be within buffer) |
start where in buffer to start (this *must* be within buffer) |
| 204 |
|
prompt for stdin or readline() |
| 205 |
|
|
| 206 |
Returns: pointer to the start of new data |
Returns: pointer to the start of new data |
| 207 |
could be a copy of start, or could be moved |
could be a copy of start, or could be moved |
| 209 |
*/ |
*/ |
| 210 |
|
|
| 211 |
static uschar * |
static uschar * |
| 212 |
extend_inputline(FILE *f, uschar *start) |
extend_inputline(FILE *f, uschar *start, const char *prompt) |
| 213 |
{ |
{ |
| 214 |
uschar *here = start; |
uschar *here = start; |
| 215 |
|
|
| 220 |
if (rlen > 1000) |
if (rlen > 1000) |
| 221 |
{ |
{ |
| 222 |
int dlen; |
int dlen; |
| 223 |
if (fgets((char *)here, rlen, f) == NULL) |
|
| 224 |
return (here == start)? NULL : start; |
/* If libreadline support is required, use readline() to read a line if the |
| 225 |
|
input is a terminal. Note that readline() removes the trailing newline, so |
| 226 |
|
we must put it back again, to be compatible with fgets(). */ |
| 227 |
|
|
| 228 |
|
#ifdef SUPPORT_LIBREADLINE |
| 229 |
|
if (isatty(fileno(f))) |
| 230 |
|
{ |
| 231 |
|
size_t len; |
| 232 |
|
char *s = readline(prompt); |
| 233 |
|
if (s == NULL) return (here == start)? NULL : start; |
| 234 |
|
len = strlen(s); |
| 235 |
|
if (len > 0) add_history(s); |
| 236 |
|
if (len > rlen - 1) len = rlen - 1; |
| 237 |
|
memcpy(here, s, len); |
| 238 |
|
here[len] = '\n'; |
| 239 |
|
here[len+1] = 0; |
| 240 |
|
free(s); |
| 241 |
|
} |
| 242 |
|
else |
| 243 |
|
#endif |
| 244 |
|
|
| 245 |
|
/* Read the next line by normal means, prompting if the file is stdin. */ |
| 246 |
|
|
| 247 |
|
{ |
| 248 |
|
if (f == stdin) printf(prompt); |
| 249 |
|
if (fgets((char *)here, rlen, f) == NULL) |
| 250 |
|
return (here == start)? NULL : start; |
| 251 |
|
} |
| 252 |
|
|
| 253 |
dlen = (int)strlen((char *)here); |
dlen = (int)strlen((char *)here); |
| 254 |
if (dlen > 0 && here[dlen - 1] == '\n') return start; |
if (dlen > 0 && here[dlen - 1] == '\n') return start; |
| 255 |
here += dlen; |
here += dlen; |
| 769 |
static void |
static void |
| 770 |
usage(void) |
usage(void) |
| 771 |
{ |
{ |
| 772 |
printf("Usage: pcretest [options] [<input> [<output>]]\n"); |
printf("Usage: pcretest [options] [<input file> [<output file>]]\n\n"); |
| 773 |
|
printf("Input and output default to stdin and stdout.\n"); |
| 774 |
|
#ifdef SUPPORT_LIBREADLINE |
| 775 |
|
printf("If input is a terminal, readline() is used to read from it.\n"); |
| 776 |
|
#else |
| 777 |
|
printf("This version of pcretest is not linked with readline().\n"); |
| 778 |
|
#endif |
| 779 |
|
printf("\nOptions:\n"); |
| 780 |
printf(" -b show compiled code (bytecode)\n"); |
printf(" -b show compiled code (bytecode)\n"); |
| 781 |
printf(" -C show PCRE compile-time options and exit\n"); |
printf(" -C show PCRE compile-time options and exit\n"); |
| 782 |
printf(" -d debug: show compiled code and information (-b and -i)\n"); |
printf(" -d debug: show compiled code and information (-b and -i)\n"); |
| 1045 |
use_utf8 = 0; |
use_utf8 = 0; |
| 1046 |
debug_lengths = 1; |
debug_lengths = 1; |
| 1047 |
|
|
| 1048 |
if (infile == stdin) printf(" re> "); |
if (extend_inputline(infile, buffer, " re> ") == NULL) break; |
|
if (extend_inputline(infile, buffer) == NULL) break; |
|
| 1049 |
if (infile != stdin) fprintf(outfile, "%s", (char *)buffer); |
if (infile != stdin) fprintf(outfile, "%s", (char *)buffer); |
| 1050 |
fflush(outfile); |
fflush(outfile); |
| 1051 |
|
|
| 1145 |
|
|
| 1146 |
if (isalnum(delimiter) || delimiter == '\\') |
if (isalnum(delimiter) || delimiter == '\\') |
| 1147 |
{ |
{ |
| 1148 |
fprintf(outfile, "** Delimiter must not be alphameric or \\\n"); |
fprintf(outfile, "** Delimiter must not be alphanumeric or \\\n"); |
| 1149 |
goto SKIP_DATA; |
goto SKIP_DATA; |
| 1150 |
} |
} |
| 1151 |
|
|
| 1161 |
pp++; |
pp++; |
| 1162 |
} |
} |
| 1163 |
if (*pp != 0) break; |
if (*pp != 0) break; |
| 1164 |
if (infile == stdin) printf(" > "); |
if ((pp = extend_inputline(infile, pp, " > ")) == NULL) |
|
if ((pp = extend_inputline(infile, pp)) == NULL) |
|
| 1165 |
{ |
{ |
| 1166 |
fprintf(outfile, "** Unexpected EOF\n"); |
fprintf(outfile, "** Unexpected EOF\n"); |
| 1167 |
done = 1; |
done = 1; |
| 1253 |
|
|
| 1254 |
case '<': |
case '<': |
| 1255 |
{ |
{ |
| 1256 |
int x = check_newline(pp, outfile); |
if (strncmp((char *)pp, "JS>", 3) == 0) |
| 1257 |
if (x == 0) goto SKIP_DATA; |
{ |
| 1258 |
options |= x; |
options |= PCRE_JAVASCRIPT_COMPAT; |
| 1259 |
while (*pp++ != '>'); |
pp += 3; |
| 1260 |
|
} |
| 1261 |
|
else |
| 1262 |
|
{ |
| 1263 |
|
int x = check_newline(pp, outfile); |
| 1264 |
|
if (x == 0) goto SKIP_DATA; |
| 1265 |
|
options |= x; |
| 1266 |
|
while (*pp++ != '>'); |
| 1267 |
|
} |
| 1268 |
} |
} |
| 1269 |
break; |
break; |
| 1270 |
|
|
| 1343 |
{ |
{ |
| 1344 |
for (;;) |
for (;;) |
| 1345 |
{ |
{ |
| 1346 |
if (extend_inputline(infile, buffer) == NULL) |
if (extend_inputline(infile, buffer, NULL) == NULL) |
| 1347 |
{ |
{ |
| 1348 |
done = 1; |
done = 1; |
| 1349 |
goto CONTINUE; |
goto CONTINUE; |
| 1406 |
if (do_flip) |
if (do_flip) |
| 1407 |
{ |
{ |
| 1408 |
real_pcre *rre = (real_pcre *)re; |
real_pcre *rre = (real_pcre *)re; |
| 1409 |
rre->magic_number = byteflip(rre->magic_number, sizeof(rre->magic_number)); |
rre->magic_number = |
| 1410 |
|
byteflip(rre->magic_number, sizeof(rre->magic_number)); |
| 1411 |
rre->size = byteflip(rre->size, sizeof(rre->size)); |
rre->size = byteflip(rre->size, sizeof(rre->size)); |
| 1412 |
rre->options = byteflip(rre->options, sizeof(rre->options)); |
rre->options = byteflip(rre->options, sizeof(rre->options)); |
| 1413 |
rre->flags = byteflip(rre->flags, sizeof(rre->flags)); |
rre->flags = (pcre_uint16)byteflip(rre->flags, sizeof(rre->flags)); |
| 1414 |
rre->top_bracket = byteflip(rre->top_bracket, sizeof(rre->top_bracket)); |
rre->top_bracket = |
| 1415 |
rre->top_backref = byteflip(rre->top_backref, sizeof(rre->top_backref)); |
(pcre_uint16)byteflip(rre->top_bracket, sizeof(rre->top_bracket)); |
| 1416 |
rre->first_byte = byteflip(rre->first_byte, sizeof(rre->first_byte)); |
rre->top_backref = |
| 1417 |
rre->req_byte = byteflip(rre->req_byte, sizeof(rre->req_byte)); |
(pcre_uint16)byteflip(rre->top_backref, sizeof(rre->top_backref)); |
| 1418 |
rre->name_table_offset = byteflip(rre->name_table_offset, |
rre->first_byte = |
| 1419 |
|
(pcre_uint16)byteflip(rre->first_byte, sizeof(rre->first_byte)); |
| 1420 |
|
rre->req_byte = |
| 1421 |
|
(pcre_uint16)byteflip(rre->req_byte, sizeof(rre->req_byte)); |
| 1422 |
|
rre->name_table_offset = (pcre_uint16)byteflip(rre->name_table_offset, |
| 1423 |
sizeof(rre->name_table_offset)); |
sizeof(rre->name_table_offset)); |
| 1424 |
rre->name_entry_size = byteflip(rre->name_entry_size, |
rre->name_entry_size = (pcre_uint16)byteflip(rre->name_entry_size, |
| 1425 |
sizeof(rre->name_entry_size)); |
sizeof(rre->name_entry_size)); |
| 1426 |
rre->name_count = byteflip(rre->name_count, sizeof(rre->name_count)); |
rre->name_count = (pcre_uint16)byteflip(rre->name_count, |
| 1427 |
|
sizeof(rre->name_count)); |
| 1428 |
|
|
| 1429 |
if (extra != NULL) |
if (extra != NULL) |
| 1430 |
{ |
{ |
| 1656 |
else |
else |
| 1657 |
{ |
{ |
| 1658 |
uschar sbuf[8]; |
uschar sbuf[8]; |
| 1659 |
sbuf[0] = (true_size >> 24) & 255; |
sbuf[0] = (uschar)((true_size >> 24) & 255); |
| 1660 |
sbuf[1] = (true_size >> 16) & 255; |
sbuf[1] = (uschar)((true_size >> 16) & 255); |
| 1661 |
sbuf[2] = (true_size >> 8) & 255; |
sbuf[2] = (uschar)((true_size >> 8) & 255); |
| 1662 |
sbuf[3] = (true_size) & 255; |
sbuf[3] = (uschar)((true_size) & 255); |
| 1663 |
|
|
| 1664 |
sbuf[4] = (true_study_size >> 24) & 255; |
sbuf[4] = (uschar)((true_study_size >> 24) & 255); |
| 1665 |
sbuf[5] = (true_study_size >> 16) & 255; |
sbuf[5] = (uschar)((true_study_size >> 16) & 255); |
| 1666 |
sbuf[6] = (true_study_size >> 8) & 255; |
sbuf[6] = (uschar)((true_study_size >> 8) & 255); |
| 1667 |
sbuf[7] = (true_study_size) & 255; |
sbuf[7] = (uschar)((true_study_size) & 255); |
| 1668 |
|
|
| 1669 |
if (fwrite(sbuf, 1, 8, f) < 8 || |
if (fwrite(sbuf, 1, 8, f) < 8 || |
| 1670 |
fwrite(re, 1, true_size, f) < true_size) |
fwrite(re, 1, true_size, f) < true_size) |
| 1738 |
len = 0; |
len = 0; |
| 1739 |
for (;;) |
for (;;) |
| 1740 |
{ |
{ |
| 1741 |
if (infile == stdin) printf("data> "); |
if (extend_inputline(infile, buffer + len, "data> ") == NULL) |
|
if (extend_inputline(infile, buffer + len) == NULL) |
|
| 1742 |
{ |
{ |
| 1743 |
if (len > 0) break; |
if (len > 0) break; |
| 1744 |
done = 1; |
done = 1; |
| 1806 |
{ |
{ |
| 1807 |
unsigned char buff8[8]; |
unsigned char buff8[8]; |
| 1808 |
int ii, utn; |
int ii, utn; |
| 1809 |
utn = ord2utf8(c, buff8); |
if (use_utf8) |
| 1810 |
for (ii = 0; ii < utn - 1; ii++) *q++ = buff8[ii]; |
{ |
| 1811 |
c = buff8[ii]; /* Last byte */ |
utn = ord2utf8(c, buff8); |
| 1812 |
|
for (ii = 0; ii < utn - 1; ii++) *q++ = buff8[ii]; |
| 1813 |
|
c = buff8[ii]; /* Last byte */ |
| 1814 |
|
} |
| 1815 |
|
else |
| 1816 |
|
{ |
| 1817 |
|
if (c > 255) |
| 1818 |
|
fprintf(outfile, "** Character \\x{%x} is greater than 255 and " |
| 1819 |
|
"UTF-8 mode is not enabled.\n" |
| 1820 |
|
"** Truncation will probably give the wrong result.\n", c); |
| 1821 |
|
} |
| 1822 |
p = pt + 1; |
p = pt + 1; |
| 1823 |
break; |
break; |
| 1824 |
} |
} |