Virgin import of gcc from EGCS 1.1.2

1 files changed, 130 insertions, 0 deletions

diff --git a/contrib/gcc/hash.h b/contrib/gcc/hash.h
new file mode 100644
index 0000000..5a3838c
--- /dev/null
+++ b/contrib/gcc/hash.h
@@ -0,0 +1,130 @@
+/* Header file for generic hash table support.
+   Copyright (C) 1993, 94 Free Software Foundation, Inc.
+   Written by Steve Chamberlain <sac@cygnus.com>
+
+This file was lifted from BFD, the Binary File Descriptor library.
+
+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 2 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, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
+#ifdef IN_GCC
+
+/* Add prototype support.  */
+#ifndef PROTO
+#if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__)
+#define PROTO(ARGS) ARGS
+#else
+#define PROTO(ARGS) ()
+#endif
+#endif
+
+#define PARAMS(ARGS) PROTO(ARGS)
+
+#ifdef __STDC__
+#define PTR void *
+#else
+#ifndef const
+#define const
+#endif
+#define PTR char *
+#endif
+
+#else /* ! IN_GCC */
+#include <ansidecl.h>
+#endif /* IN_GCC */
+
+#include "obstack.h"
+
+typedef enum {false, true} boolean;
+
+/* Hash table routines.  There is no way to free up a hash table.  */
+
+/* An element in the hash table.  Most uses will actually use a larger
+   structure, and an instance of this will be the first field.  */
+
+struct hash_entry
+{
+  /* Next entry for this hash code.  */
+  struct hash_entry *next;
+  /* String being hashed.  */
+  const char *string;
+  /* Hash code.  This is the full hash code, not the index into the
+     table.  */
+  unsigned long hash;
+};
+
+/* A hash table.  */
+
+struct hash_table
+{
+  /* The hash array.  */
+  struct hash_entry **table;
+  /* The number of slots in the hash table.  */
+  unsigned int size;
+  /* A function used to create new elements in the hash table.  The
+     first entry is itself a pointer to an element.  When this
+     function is first invoked, this pointer will be NULL.  However,
+     having the pointer permits a hierarchy of method functions to be
+     built each of which calls the function in the superclass.  Thus
+     each function should be written to allocate a new block of memory
+     only if the argument is NULL.  */
+  struct hash_entry *(*newfunc) PARAMS ((struct hash_entry *,
+					 struct hash_table *,
+					 const char *));
+  /* An obstack for this hash table.  */
+  struct obstack memory;
+};
+
+/* Initialize a hash table.  */
+extern boolean hash_table_init
+  PARAMS ((struct hash_table *,
+	   struct hash_entry *(*) (struct hash_entry *,
+				   struct hash_table *,
+				   const char *)));
+
+/* Initialize a hash table specifying a size.  */
+extern boolean hash_table_init_n
+  PARAMS ((struct hash_table *,
+	   struct hash_entry *(*) (struct hash_entry *,
+				   struct hash_table *,
+				   const char *),
+	   unsigned int size));
+
+/* Free up a hash table.  */
+extern void hash_table_free PARAMS ((struct hash_table *));
+
+/* Look up a string in a hash table.  If CREATE is true, a new entry
+   will be created for this string if one does not already exist.  The
+   COPY argument must be true if this routine should copy the string
+   into newly allocated memory when adding an entry.  */
+extern struct hash_entry *hash_lookup
+  PARAMS ((struct hash_table *, const char *, boolean create,
+	   boolean copy));
+
+/* Base method for creating a hash table entry.  */
+extern struct hash_entry *hash_newfunc
+  PARAMS ((struct hash_entry *, struct hash_table *,
+	   const char *));
+
+/* Grab some space for a hash table entry.  */
+extern PTR hash_allocate PARAMS ((struct hash_table *,
+				  unsigned int));
+
+/* Traverse a hash table in a random order, calling a function on each
+   element.  If the function returns false, the traversal stops.  The
+   INFO argument is passed to the function.  */
+extern void hash_traverse PARAMS ((struct hash_table *,
+				   boolean (*) (struct hash_entry *,
+						PTR),
+				   PTR info));