diff options
Diffstat (limited to 'helpers/testdfa.c')
| -rw-r--r-- | helpers/testdfa.c | 417 |
1 files changed, 30 insertions, 387 deletions
diff --git a/helpers/testdfa.c b/helpers/testdfa.c index 1e144bd7..0f7911a1 100644 --- a/helpers/testdfa.c +++ b/helpers/testdfa.c @@ -1,23 +1,25 @@ /* * testdfa.c --- abstracted from gawk. + * + * gcc -I.. -I../support testdfa.c ../support/libsupport.a -o testdfa */ -/* - * Copyright (C) 1986, 1988, 1989, 1991-2013 the Free Software Foundation, Inc. - * +/* + * Copyright (C) 1986, 1988, 1989, 1991-2017 the Free Software Foundation, Inc. + * * This file is part of GAWK, the GNU implementation of the * AWK Programming Language. - * + * * GAWK is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. - * + * * GAWK is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA @@ -44,6 +46,7 @@ #define _Noreturn #define _GL_ATTRIBUTE_PURE #include "dfa.h" +#include "localeinfo.h" const char *regexflags2str(int flags); char *databuf(int fd); @@ -71,7 +74,8 @@ void usage(const char *myname) int main(int argc, char **argv) { - int c, ret, try_backref; + int c, ret; + bool try_backref; struct re_pattern_buffer pat; struct re_registers regs; struct dfa *dfareg; @@ -84,6 +88,7 @@ int main(int argc, char **argv) char save; size_t count = 0; char *place; + struct localeinfo localeinfo; if (argc < 2) usage(argv[0]); @@ -128,10 +133,10 @@ int main(int argc, char **argv) printf("Ignorecase: %s\nSyntax: %s\n", (ignorecase ? "true" : "false"), reflags2str(syn)); - printf("Pattern: /%s/, len = %d\n", pattern, len); + printf("Pattern: /%s/, len = %lu\n", pattern, len); pattern = setup_pattern(pattern, & len); - printf("After setup_pattern(), len = %d\n", len); + printf("After setup_pattern(), len = %lu\n", len); pat.fastmap = (char *) malloc(256); if (pat.fastmap == NULL) { @@ -158,7 +163,6 @@ int main(int argc, char **argv) dfa_syn = syn; if (ignorecase) dfa_syn |= RE_ICASE; - dfasyntax(dfa_syn, ignorecase, '\n'); re_set_syntax(syn); if ((rerr = re_compile_pattern(pattern, len, & pat)) != NULL) { @@ -171,6 +175,9 @@ int main(int argc, char **argv) pat.newline_anchor = false; /* don't get \n in middle of string */ dfareg = dfaalloc(); + init_localeinfo(&localeinfo); + dfasyntax(dfareg, &localeinfo, dfa_syn, 0); + printf("Calling dfacomp(%s, %d, %p, true)\n", pattern, (int) len, dfareg); @@ -196,7 +203,7 @@ int main(int argc, char **argv) if (place == NULL) printf("dfaexec returned NULL\n"); else - printf("dfaexec returned %d (%.3s)\n", place - data, place); + printf("dfaexec returned %ld (%.3s)\n", place - data, place); /* release storage */ regfree(& pat); @@ -336,21 +343,6 @@ databuf(int fd) return buf; } -/* xmalloc --- for dfa.c */ - -void * -xmalloc(size_t bytes) -{ - void *p = malloc(bytes); - - if (p == NULL) { - fprintf(stderr, "xmalloc: malloc failed: %s\n", strerror(errno)); - exit(EXIT_FAILURE); - } - - return p; -} - /* r_fatal --- print a fatal error message. also for dfa.c */ void @@ -372,10 +364,10 @@ setup_pattern(const char *pattern, size_t *len) { size_t is_multibyte = 0; int c, c2; - size_t buflen = 0; + size_t buflen; mbstate_t mbs; bool has_anchor = false; - char *buf = NULL; + char *buf; char *dest; const char *src, *end; @@ -389,23 +381,14 @@ setup_pattern(const char *pattern, size_t *len) /* * Build a copy of the string (in buf) with the * escaped characters translated, and generate the regex - * from that. + * from that. */ + buf = (char *) malloc(*len + 1); if (buf == NULL) { - buf = (char *) malloc(*len + 2); - if (buf == NULL) { - fprintf(stderr, "%s: malloc failed\n", __func__); - exit(EXIT_FAILURE); - } - buflen = *len; - } else if (*len > buflen) { - buf = (char *) realloc(buf, *len + 2); - if (buf == NULL) { - fprintf(stderr, "%s: realloc failed\n", __func__); - exit(EXIT_FAILURE); - } - buflen = *len; + fprintf(stderr, "%s: malloc failed\n", __func__); + exit(EXIT_FAILURE); } + buflen = *len; dest = buf; while (src < end) { @@ -502,16 +485,16 @@ setup_pattern(const char *pattern, size_t *len) * * Parse a C escape sequence. STRING_PTR points to a variable containing a * pointer to the string to parse. That pointer is updated past the - * characters we use. The value of the escape sequence is returned. + * characters we use. The value of the escape sequence is returned. * * A negative value means the sequence \ newline was seen, which is supposed to - * be equivalent to nothing at all. + * be equivalent to nothing at all. * * If \ is followed by a null character, we return a negative value and leave - * the string pointer pointing at the null character. + * the string pointer pointing at the null character. * * If \ is followed by 000, we return 0 and leave the string pointer after the - * zeros. A value of 0 does not mean end of string. + * zeros. A value of 0 does not mean end of string. * * POSIX doesn't allow \x. */ @@ -600,7 +583,7 @@ parse_escape(const char **string_ptr) #ifdef C #undef C #endif -#define C(c) ((char)c) +#define C(c) ((char)c) /* * This table is used by the regexp routines to do case independent * matching. Basically, every ascii character maps to itself, except @@ -740,343 +723,3 @@ char casetable[] = { #endif #undef C - -#ifdef GREP_DFA /* not needed for gawk */ -/* xalloc.h -- malloc with out-of-memory checking - - Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2003, 2004, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, - Inc. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. */ - -#ifndef XALLOC_H_ -# define XALLOC_H_ - -# include <stddef.h> - - -# ifdef __cplusplus -extern "C" { -# endif - - -# ifndef __attribute__ -# if __GNUC__ < 2 || (__GNUC__ == 2 && __GNUC_MINOR__ < 8) -# define __attribute__(x) -# endif -# endif - -# ifndef ATTRIBUTE_NORETURN -# define ATTRIBUTE_NORETURN __attribute__ ((__noreturn__)) -# endif - -# ifndef ATTRIBUTE_MALLOC -# if __GNUC__ >= 3 -# define ATTRIBUTE_MALLOC __attribute__ ((__malloc__)) -# else -# define ATTRIBUTE_MALLOC -# endif -# endif - -/* This function is always triggered when memory is exhausted. - It must be defined by the application, either explicitly - or by using gnulib's xalloc-die module. This is the - function to call when one wants the program to die because of a - memory allocation failure. */ -extern void xalloc_die (void); - -void *xmalloc (size_t s) ATTRIBUTE_MALLOC; -void *xzalloc (size_t s) ATTRIBUTE_MALLOC; -void *xcalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; -void *xrealloc (void *p, size_t s); -void *x2realloc (void *p, size_t *pn); -void *xmemdup (void const *p, size_t s) ATTRIBUTE_MALLOC; -char *xstrdup (char const *str) ATTRIBUTE_MALLOC; - -/* Return 1 if an array of N objects, each of size S, cannot exist due - to size arithmetic overflow. S must be positive and N must be - nonnegative. This is a macro, not an inline function, so that it - works correctly even when SIZE_MAX < N. - - By gnulib convention, SIZE_MAX represents overflow in size - calculations, so the conservative dividend to use here is - SIZE_MAX - 1, since SIZE_MAX might represent an overflowed value. - However, malloc (SIZE_MAX) fails on all known hosts where - sizeof (ptrdiff_t) <= sizeof (size_t), so do not bother to test for - exactly-SIZE_MAX allocations on such hosts; this avoids a test and - branch when S is known to be 1. */ -# define xalloc_oversized(n, s) \ - ((size_t) (sizeof (ptrdiff_t) <= sizeof (size_t) ? -1 : -2) / (s) < (n)) - - -/* In the following macros, T must be an elementary or structure/union or - typedef'ed type, or a pointer to such a type. To apply one of the - following macros to a function pointer or array type, you need to typedef - it first and use the typedef name. */ - -/* Allocate an object of type T dynamically, with error checking. */ -/* extern t *XMALLOC (typename t); */ -# define XMALLOC(t) ((t *) xmalloc (sizeof (t))) - -/* Allocate memory for N elements of type T, with error checking. */ -/* extern t *XNMALLOC (size_t n, typename t); */ -# define XNMALLOC(n, t) \ - ((t *) (sizeof (t) == 1 ? xmalloc (n) : xnmalloc (n, sizeof (t)))) - -/* Allocate an object of type T dynamically, with error checking, - and zero it. */ -/* extern t *XZALLOC (typename t); */ -# define XZALLOC(t) ((t *) xzalloc (sizeof (t))) - -/* Allocate memory for N elements of type T, with error checking, - and zero it. */ -/* extern t *XCALLOC (size_t n, typename t); */ -# define XCALLOC(n, t) \ - ((t *) (sizeof (t) == 1 ? xzalloc (n) : xcalloc (n, sizeof (t)))) - -/* - * Gawk uses this file only to keep dfa.c happy. - * We're therefore safe in manually defining HAVE_INLINE to - * make the !@#$%^&*() thing just work. - */ -#ifdef GAWK -#define HAVE_INLINE 1 /* so there. nyah, nyah, nyah. */ -#endif - -# if HAVE_INLINE -# define static_inline static inline -# else -void *xnmalloc (size_t n, size_t s) ATTRIBUTE_MALLOC; -void *xnrealloc (void *p, size_t n, size_t s); -void *x2nrealloc (void *p, size_t *pn, size_t s); -char *xcharalloc (size_t n) ATTRIBUTE_MALLOC; -# endif - - -/* Allocate an array of N objects, each with S bytes of memory, - dynamically, with error checking. S must be nonzero. */ - -void * -xnmalloc (size_t n, size_t s) -{ - if (xalloc_oversized (n, s)) - xalloc_die (); - return xmalloc (n * s); -} - -/* Allocate an array of N objects, each with S bytes of memory, - dynamically, with error checking. S must be nonzero. - Clear the contents afterwards. */ - -void * -xcalloc(size_t nmemb, size_t size) -{ - void *p = xmalloc (nmemb * size); - memset(p, '\0', nmemb * size); - return p; -} - -/* Reallocate a pointer to a new size, with error checking. */ - -void * -xrealloc(void *p, size_t size) -{ - void *new_p = realloc(p, size); - if (new_p == 0) - xalloc_die (); - - return new_p; -} - -/* xalloc_die --- fatal error message when malloc fails, needed by dfa.c */ - -void -xalloc_die (void) -{ - r_fatal("xalloc: malloc failed: %s"), strerror(errno); -} - -/* Clone an object P of size S, with error checking. There's no need - for xnmemdup (P, N, S), since xmemdup (P, N * S) works without any - need for an arithmetic overflow check. */ - -void * -xmemdup (void const *p, size_t s) -{ - return memcpy (xmalloc (s), p, s); -} - -/* Change the size of an allocated block of memory P to an array of N - objects each of S bytes, with error checking. S must be nonzero. */ - -void * -xnrealloc (void *p, size_t n, size_t s) -{ - if (xalloc_oversized (n, s)) - xalloc_die (); - return xrealloc (p, n * s); -} - -/* If P is null, allocate a block of at least *PN such objects; - otherwise, reallocate P so that it contains more than *PN objects - each of S bytes. *PN must be nonzero unless P is null, and S must - be nonzero. Set *PN to the new number of objects, and return the - pointer to the new block. *PN is never set to zero, and the - returned pointer is never null. - - Repeated reallocations are guaranteed to make progress, either by - allocating an initial block with a nonzero size, or by allocating a - larger block. - - In the following implementation, nonzero sizes are increased by a - factor of approximately 1.5 so that repeated reallocations have - O(N) overall cost rather than O(N**2) cost, but the - specification for this function does not guarantee that rate. - - Here is an example of use: - - int *p = NULL; - size_t used = 0; - size_t allocated = 0; - - void - append_int (int value) - { - if (used == allocated) - p = x2nrealloc (p, &allocated, sizeof *p); - p[used++] = value; - } - - This causes x2nrealloc to allocate a block of some nonzero size the - first time it is called. - - To have finer-grained control over the initial size, set *PN to a - nonzero value before calling this function with P == NULL. For - example: - - int *p = NULL; - size_t used = 0; - size_t allocated = 0; - size_t allocated1 = 1000; - - void - append_int (int value) - { - if (used == allocated) - { - p = x2nrealloc (p, &allocated1, sizeof *p); - allocated = allocated1; - } - p[used++] = value; - } - - */ - -void * -x2nrealloc (void *p, size_t *pn, size_t s) -{ - size_t n = *pn; - - if (! p) - { - if (! n) - { - /* The approximate size to use for initial small allocation - requests, when the invoking code specifies an old size of - zero. 64 bytes is the largest "small" request for the - GNU C library malloc. */ - enum { DEFAULT_MXFAST = 64 }; - - n = DEFAULT_MXFAST / s; - n += !n; - } - } - else - { - /* Set N = ceil (1.5 * N) so that progress is made if N == 1. - Check for overflow, so that N * S stays in size_t range. - The check is slightly conservative, but an exact check isn't - worth the trouble. */ - if ((size_t) -1 / 3 * 2 / s <= n) - xalloc_die (); - n += (n + 1) / 2; - } - - *pn = n; - return xrealloc (p, n * s); -} - -/* Return a pointer to a new buffer of N bytes. This is like xmalloc, - except it returns char *. */ - -char * -xcharalloc (size_t n) -{ - return XNMALLOC (n, char); -} - -/* Allocate S bytes of zeroed memory dynamically, with error checking. - There's no need for xnzalloc (N, S), since it would be equivalent - to xcalloc (N, S). */ - -void * -xzalloc (size_t s) -{ - return memset (xmalloc (s), 0, s); -} - -# endif - -# ifdef __cplusplus -} - -/* C++ does not allow conversions from void * to other pointer types - without a cast. Use templates to work around the problem when - possible. */ - -template <typename T> inline T * -xrealloc (T *p, size_t s) -{ - return (T *) xrealloc ((void *) p, s); -} - -template <typename T> inline T * -xnrealloc (T *p, size_t n, size_t s) -{ - return (T *) xnrealloc ((void *) p, n, s); -} - -template <typename T> inline T * -x2realloc (T *p, size_t *pn) -{ - return (T *) x2realloc ((void *) p, pn); -} - -template <typename T> inline T * -x2nrealloc (T *p, size_t *pn, size_t s) -{ - return (T *) x2nrealloc ((void *) p, pn, s); -} - -template <typename T> inline T * -xmemdup (T const *p, size_t s) -{ - return (T *) xmemdup ((void const *) p, s); -} - - - -#endif /* !XALLOC_H_ */ -#endif /* GREP_DFA */ |