Bring helpers/testdfa.c up to date.

2 files changed, 12 insertions, 366 deletions

diff --git a/helpers/ChangeLog b/helpers/ChangeLog
index bd7e5486..c1a74d5b 100644
--- a/helpers/ChangeLog
+++ b/helpers/ChangeLog
@@ -1,3 +1,8 @@
+2017-06-27         Arnold D. Robbins     <arnold@skeeve.com>
+
+	* testdfa.c: Bring up to date, fix compile warnings.
+	Remove more xmalloc stuff.
+
 2017-06-25         Andrew J. Schorr      <aschorr@telemetry-investments.com>
 
 	* testdfa.c (xcalloc): Replace xmalloc+memset with calloc.
diff --git a/helpers/testdfa.c b/helpers/testdfa.c
index f61d4e26..0f7911a1 100644
--- a/helpers/testdfa.c
+++ b/helpers/testdfa.c
@@ -1,9 +1,11 @@
 /*
  * 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.
@@ -131,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) {
@@ -174,8 +176,7 @@ int main(int argc, char **argv)
 
 	dfareg = dfaalloc();
 	init_localeinfo(&localeinfo);
-	dfasyntax(dfareg, &localeinfo, dfa_syn,
-		  ignorecase ? DFA_CASE_FOLD : 0);
+	dfasyntax(dfareg, &localeinfo, dfa_syn, 0);
 
 	printf("Calling dfacomp(%s, %d, %p, true)\n",
 			pattern, (int) len, dfareg);
@@ -202,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);
@@ -342,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
@@ -737,348 +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 = calloc (nmemb, size);
-
-  if (p == NULL) {
-    fprintf(stderr, "xcalloc: calloc failed: %s\n", strerror(errno));
-    exit(EXIT_FAILURE);
-  }
-
-  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 xcalloc (1, 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 */