contrib/pdxautoserializer/src/impl/CPPParser/Dictionary.cpp - geode-native - Git at Google

 /*
  * PUBLIC DOMAIN PCCTS-BASED C++ GRAMMAR (cplusplus.g, stat.g, expr.g)
  *
  * Authors: Sumana Srinivasan, NeXT Inc.;            sumana_srinivasan@next.com
  *          Terence Parr, Parr Research Corporation; parrt@parr-research.com
  *          Russell Quong, Purdue University;        quong@ecn.purdue.edu
  *
  * VERSION 1.1
  *
  * SOFTWARE RIGHTS
  *
  * This file is a part of the ANTLR-based C++ grammar and is free
  * software.  We do not reserve any LEGAL rights to its use or
  * distribution, but you may NOT claim ownership or authorship of this
  * grammar or support code.  An individual or company may otherwise do
  * whatever they wish with the grammar distributed herewith including the
  * incorporation of the grammar or the output generated by ANTLR into
  * commerical software.  You may redistribute in source or binary form
  * without payment of royalties to us as long as this header remains
  * in all source distributions.
  *
  * We encourage users to develop parsers/tools using this grammar.
  * In return, we ask that credit is given to us for developing this
  * grammar.  By "credit", we mean that if you incorporate our grammar or
  * the generated code into one of your programs (commercial product,
  * research project, or otherwise) that you acknowledge this fact in the
  * documentation, research report, etc....  In addition, you should say nice
  * things about us at every opportunity.
  *
  * As long as these guidelines are kept, we expect to continue enhancing
  * this grammar.  Feel free to send us enhancements, fixes, bug reports,
  * suggestions, or general words of encouragement at parrt@parr-research.com.
  *
  * NeXT Computer Inc.
  * 900 Chesapeake Dr.
  * Redwood City, CA 94555
  * 12/02/1994
  *
  * Restructured for public consumption by Terence Parr late February, 1995.
  *
  * Requires PCCTS 1.32b4 or higher to get past ANTLR.
  *
  * DISCLAIMER: we make no guarantees that this grammar works, makes sense,
  *             or can be used to do anything useful.
  */
 /* 1999-2004 Version 3.0 July 2004
  * Modified by David Wigg at London South Bank University for CPP_parser.g
  */
 /* 2004-2005 Version 3.1 November 2005
  * Modified by David Wigg at London South Bank University for CPP_parser.g
  *
  * See MyReadMe.txt for further information
  *
  * This file is best viewed in courier font with tabs set to 4 spaces
  *
  * See NotesScopes.txt for information about storing symbol names within scope
  *levels
  *
  * Symbols names are stored in lists selected by hashing
  *
  * Symbols are also chained in lists for each scope level,
  *	[0] = template scope	Note: Not used at present
  *	[1] = external scope	Note: These symbols (types) are never deleted.
  *"std" is allocated this scope in CPPParser::init()
  *	[2+]= function/variable scopes	Note: These symbol references are
  *deleted when they go out of scope.
  */

 extern "C" {
 #include <string.h>
 #include <stdlib.h>
 #include <stdio.h>
 }
 #include "Dictionary.hpp"

 /* Hashing function described in                   */
 /* "Fast Hashing of Variable-Length Text Strings," */
 /* by Peter K. Pearson, CACM, June 1990. */
 /* Table from p. 678.*/
 /* Pseudorandom Permutation of the Integers 0 through 255: */
 unsigned char Dictionary::randomNumbers[] = {
     1,   14,  110, 25,  97,  174, 132, 119, 138, 170, 125, 118, 27,  233, 140,
     51,  87,  197, 177, 107, 234, 169, 56,  68,  30,  7,   173, 73,  188, 40,
     36,  65,  49,  213, 104, 190, 57,  211, 148, 223, 48,  115, 15,  2,   67,
     186, 210, 28,  12,  181, 103, 70,  22,  58,  75,  78,  183, 167, 238, 157,
     124, 147, 172, 144, 176, 161, 141, 86,  60,  66,  128, 83,  156, 241, 79,
     46,  168, 198, 41,  254, 178, 85,  253, 237, 250, 154, 133, 88,  35,  206,
     95,  116, 252, 192, 54,  221, 102, 218, 255, 240, 82,  106, 158, 201, 61,
     3,   89,  9,   42,  155, 159, 93,  166, 80,  50,  34,  175, 195, 100, 99,
     26,  150, 16,  145, 4,   33,  8,   189, 121, 64,  77,  72,  208, 245, 130,
     122, 143, 55,  105, 134, 29,  164, 185, 194, 193, 239, 101, 242, 5,   171,
     126, 11,  74,  59,  137, 228, 108, 191, 232, 139, 6,   24,  81,  20,  127,
     17,  91,  92,  251, 151, 225, 207, 21,  98,  113, 112, 84,  226, 18,  214,
     199, 187, 13,  32,  94,  220, 224, 212, 247, 204, 196, 43,  249, 236, 45,
     244, 111, 182, 153, 136, 129, 90,  217, 202, 19,  165, 231, 71,  230, 142,
     96,  227, 62,  179, 246, 114, 162, 53,  160, 215, 205, 180, 47,  109, 44,
     38,  31,  149, 135, 0,   216, 52,  63,  23,  37,  69,  39,  117, 146, 184,
     163, 200, 222, 235, 248, 243, 219, 10,  152, 131, 123, 229, 203, 76,  120,
     209};

 char *Dictionary::strings = NULL;
 char *Dictionary::strp = NULL;
 unsigned Dictionary::strsize = 0;

 Dictionary::Dictionary(int nb, int ns, int nc) {
   int i;

   // allocate buckets for names
   bucket = new DictEntry *[nb];
   if (bucket == NULL) panic((const char *)"can't alloc buckets");

   // Initialize buckets for names
   nbuckets = nb;
   for (i = 0; i < nb; i++) bucket[i] = NULL;

   // allocate a scope list for the start of each scope list
   scope = new DictEntry *[ns];
   if (scope == NULL) panic("can't alloc scopes");

   // allocate an endScope list for the end of each scope list
   endScope = new DictEntry *[ns];
   if (endScope == NULL) panic("can't alloc endScope");

   // Initialize scopes and endscopes
   nscopes = ns;
   for (i = 0; i < ns; i++) {
     scope[i] = NULL;
     endScope[i] = NULL;
   }

   currentScope = 0;

   strsize = nc;
   strings = new char[nc];
   strp = strings;
 }

 Dictionary::~Dictionary() {
   delete[] bucket;
   delete[] scope;
   delete[] endScope;
   nbuckets = nscopes = 0;
   currentScope = -1;
 }

 /* Hashing function described in                   */
 /* "Fast Hashing of Variable-Length Text Strings," */
 /* by Peter K. Pearson, CACM, June 1990.           */
 int Dictionary::hash(const char *string) {
   int hash1 = 0;
   int hash2 = 0;
   int length = 0;
   int r = 0;

   while (*string != 0) {
     length++;
     /* Hash function is XOR of successive characters randomized by
      * the hash table.
      */
     hash1 ^= randomNumbers[static_cast<int>(*string++)];
     if (*string != 0) hash2 ^= randomNumbers[static_cast<int>(*string++)];
   }
   r = (hash1 << 8) | hash2;
   return r;
 }

 /* Return ptr to 1st entry found in table under key
  * (return NULL if none found).
  */
 DictEntry *Dictionary::lookup(const char *key, CPPSymbol::ObjectType tp) {
   // tp is type to be looked for
   // Default, 0, is to look for any symbol irrespective of type
   // Each new DictEntry is stored at start of its list so most
   // recent additions are reached first
   // DictEntry *q;
   CPPSymbol *q;
   // int scope = getCurrentScopeIndex();
   // if(sc != -1)
   //		scope = sc;

   int h = hash(key) % nbuckets;
   q = (CPPSymbol *)bucket[h];

   for (; q != NULL; q = (CPPSymbol *)q->getNext()) {
     // printf("Dictionary.cpp lookup symbol %s in scope %d current scope %d\n",
     //	q->getKey(),q->this_scope,getCurrentScopeIndex());
     if (h != q->getHashCode()) {
       fprintf(stderr,
               "dictionary.cpp lookup, h not equal to q->getHashCode() for %s\n",
               key);
     }

     if (h == q->getHashCode() && strcmp(key, q->getKey()) == 0) {
       if (tp == 0) {  // Search for first matching symbol
         return q;
       } else {
         CPPSymbol::ObjectType type = q->getType();
         if (tp == CPPSymbol::otTypename)  // Search for first type name
         {
           if (type == CPPSymbol::otTypedef || type == CPPSymbol::otEnum ||
               type == CPPSymbol::otClass || type == CPPSymbol::otStruct ||
               type == CPPSymbol::otUnion) {
             return q;
           }
         } else if (tp ==
                    CPPSymbol::otNonTypename)  // Search for first non type name
         {
           if (type == CPPSymbol::otVariable || type == CPPSymbol::otFunction) {
             return q;
           }
         } else if (type == tp) {  // Search for first symbol with specific type
           return q;
         } else {
           return NULL;
         }
       }
     }
   }
   return NULL;
 }

 void Dictionary::define(const char *key, DictEntry *entry) {
   defineInScope(key, entry, currentScope);
 }

 void Dictionary::defineInScope(const char *key, DictEntry *entry, int sc) {
   int h = hash(key) % nbuckets;  // July 2005, nbuckets = 4001 See CPP_parser.g
   // printf("Dictionary.cpp defineInScope key %s hash(key) %d bucket %d scope
   // %d\n",
   //	key,hash(key),h,sc);
   entry->this_scope = sc;
   entry->setKey(strdup(key));  // Make a local copy of key
   entry->setHashCode(h);
   entry->setNext(bucket[h]);  // Set next pointer to current entry in bucket
   bucket[h] = entry;          // Replace current entry in bucket
   if (endScope[sc] == NULL) {
     scope[sc] = endScope[sc] = entry;
   } else {
     endScope[sc]->setScope(entry);
     endScope[sc] = entry;
   }
 }

 int Dictionary::getCurrentScopeIndex() { return currentScope; }

 DictEntry *Dictionary::getCurrentScope() {
   if (currentScope < 0 || currentScope > nscopes) {
     panic("getCurrentScope: no scope");
   }
   return scope[currentScope];
 }

 void Dictionary::saveScope() {
   // Advance scope number (for included scope)
   if (currentScope < nscopes) currentScope++;
   /*
   if ( currentScope>=nscopes )
     panic( "saveScope: overflow" );
   */
   // printf("Dictionary saveScope entered. Scope now %d\n",currentScope);
 }

 void Dictionary::restoreScope() {
   // Reduce scope number for next highest scope
   // if ( currentScope==0 )
   //  panic( "restoreScope: underflow" );
   if (currentScope > 0) currentScope--;
   // printf("Dictionary restoreScope entered. Scope now %d\n",currentScope);
 }

 /*	This unlinks all entries from the Dictionary that are members
  *	of the current scope.  The scope level is not restored to the previous
  *	scope however. This requires use of restoreScope() above
  */
 DictEntry *Dictionary::removeScope(int sc) {
   DictEntry *de, *r;
   if (sc == -1) {  // removeScope() without parameter value defaults sc to -1
     sc = currentScope;
   }
   for (de = scope[sc]; de != NULL; de = de->getNextInScope()) {
     remove(de);
   }
   r = scope[sc];
   scope[sc] = endScope[sc] = NULL;
   return r;
 }

 //	Remove this dictEntry from its bucket by unlinking it
 DictEntry *Dictionary::remove(DictEntry *de) {
   DictEntry *prev, *curr;
   if (de == NULL) panic("Dictionary.cpp remove: NULL ptr");
   int h = hash(de->getKey()) % nbuckets;  // Find pointer to bucket
   for (prev = NULL, curr = bucket[h]; curr != NULL;
        prev = curr, curr = curr->getNext()) {
     if (de == curr) {
       if (prev == NULL) {
         bucket[h] = de->getNext();
       } else {
         prev->setNext(de->getNext());
       }
       de->setNext(NULL);
       return de;
     }
   }
   return NULL;  // should never get here...
 }

 /*	Lookup the object referred to by 'key' and then physically remove
  *	it from the Dictionary.  Return the object referred to by the key.
  *	If more than one definition is found for 'key', then only the
  *	first one is removed.  Return NULL if not found.
  *  Note: DW 12/06/03 Probably not used
  */
 DictEntry *Dictionary::remove(char *key) {
   DictEntry *q, *prev;

   int h = hash(key) % nbuckets;
   for (prev = NULL, q = bucket[h]; q != NULL; prev = q, q = q->getNext()) {
     if (h == q->getHashCode() && strcmp(key, q->getKey()) == 0) {
       if (prev == NULL) {
         bucket[h] = q->getNext();
       } else {
         prev->setNext(q->getNext());
       }
       q->setNext(NULL);
       return q;
     }
   }
   return NULL;  // should never get here, but make compiler happy
 }

 void Dictionary::dumpScope(FILE *f, int sc) {
   DictEntry *s;

   if (sc == -1) {  // dumpScope() without parameter value defaults sc to -1
     sc = currentScope;
   }
   for (s = scope[sc]; s != NULL; s = s->getNextInScope()) {
     dumpSymbol(f, s);
   }
 }

 // This is overridden in CPPDictionary.hpp
 void Dictionary::dumpSymbol(FILE *f, DictEntry *de) {
   fprintf(f, "%s\n", de->getKey());
 }

 // Diagnostic function
 // Contents of first 10 scopes printed
 void Dictionary::dumpScopes() {
   DictEntry *dictEntry;
   int i;

   printf("Scopes");
   for (i = 0; i < 10; i++) {
     printf("     %d     ", i);
   }
   printf("\n");
   printf(" first");
   for (i = 0; i < 10; i++) {
     if (scope[i] != NULL) {
       dictEntry = scope[i];
       printf("%10s ", dictEntry->getKey());
     } else {
       printf("           ");
     }
   }
   printf("\n");
   printf(" last ");
   for (i = 0; i < 10; i++) {
     if (endScope[i] != NULL) {
       dictEntry = endScope[i];
       printf("%10s ", dictEntry->getKey());
     } else {
       printf("           ");
     }
   }
   printf("\n");
 }

 /* Add a string to the string table and return a pointer to it.
  * Bump the pointer into the string table to next avail position.
  */
 char *Dictionary::strdup(const char *s) {
   char *start = strp;
   if (s == NULL) panic("strdup: NULL string");
   if (start + strlen(s) + 1 > &(strings[strsize - 2])) {
     panic("string table overflow");
   }
   while (*s != '\0') {
     *strp++ = *s++;
   }
   *strp++ = '\0';
   return start;
 }

 void Dictionary::panic(const char *err) {
   fprintf(stdout, "Dictionary panic: %s\n", err);
   exit(-1);
 }
	/*
	* PUBLIC DOMAIN PCCTS-BASED C++ GRAMMAR (cplusplus.g, stat.g, expr.g)
	*
	* Authors: Sumana Srinivasan, NeXT Inc.; sumana_srinivasan@next.com
	* Terence Parr, Parr Research Corporation; parrt@parr-research.com
	* Russell Quong, Purdue University; quong@ecn.purdue.edu
	*
	* VERSION 1.1
	*
	* SOFTWARE RIGHTS
	*
	* This file is a part of the ANTLR-based C++ grammar and is free
	* software. We do not reserve any LEGAL rights to its use or
	* distribution, but you may NOT claim ownership or authorship of this
	* grammar or support code. An individual or company may otherwise do
	* whatever they wish with the grammar distributed herewith including the
	* incorporation of the grammar or the output generated by ANTLR into
	* commerical software. You may redistribute in source or binary form
	* without payment of royalties to us as long as this header remains
	* in all source distributions.
	*
	* We encourage users to develop parsers/tools using this grammar.
	* In return, we ask that credit is given to us for developing this
	* grammar. By "credit", we mean that if you incorporate our grammar or
	* the generated code into one of your programs (commercial product,
	* research project, or otherwise) that you acknowledge this fact in the
	* documentation, research report, etc.... In addition, you should say nice
	* things about us at every opportunity.
	*
	* As long as these guidelines are kept, we expect to continue enhancing
	* this grammar. Feel free to send us enhancements, fixes, bug reports,
	* suggestions, or general words of encouragement at parrt@parr-research.com.
	*
	* NeXT Computer Inc.
	* 900 Chesapeake Dr.
	* Redwood City, CA 94555
	* 12/02/1994
	*
	* Restructured for public consumption by Terence Parr late February, 1995.
	*
	* Requires PCCTS 1.32b4 or higher to get past ANTLR.
	*
	* DISCLAIMER: we make no guarantees that this grammar works, makes sense,
	* or can be used to do anything useful.
	*/
	/* 1999-2004 Version 3.0 July 2004
	* Modified by David Wigg at London South Bank University for CPP_parser.g
	*/
	/* 2004-2005 Version 3.1 November 2005
	* Modified by David Wigg at London South Bank University for CPP_parser.g
	*
	* See MyReadMe.txt for further information
	*
	* This file is best viewed in courier font with tabs set to 4 spaces
	*
	* See NotesScopes.txt for information about storing symbol names within scope
	*levels
	*
	* Symbols names are stored in lists selected by hashing
	*
	* Symbols are also chained in lists for each scope level,
	* [0] = template scope Note: Not used at present
	* [1] = external scope Note: These symbols (types) are never deleted.
	*"std" is allocated this scope in CPPParser::init()
	* [2+]= function/variable scopes Note: These symbol references are
	*deleted when they go out of scope.
	*/

	extern "C" {
	#include <string.h>
	#include <stdlib.h>
	#include <stdio.h>
	}
	#include "Dictionary.hpp"

	/* Hashing function described in */
	/* "Fast Hashing of Variable-Length Text Strings," */
	/* by Peter K. Pearson, CACM, June 1990. */
	/* Table from p. 678.*/
	/* Pseudorandom Permutation of the Integers 0 through 255: */
	unsigned char Dictionary::randomNumbers[] = {
	1, 14, 110, 25, 97, 174, 132, 119, 138, 170, 125, 118, 27, 233, 140,
	51, 87, 197, 177, 107, 234, 169, 56, 68, 30, 7, 173, 73, 188, 40,
	36, 65, 49, 213, 104, 190, 57, 211, 148, 223, 48, 115, 15, 2, 67,
	186, 210, 28, 12, 181, 103, 70, 22, 58, 75, 78, 183, 167, 238, 157,
	124, 147, 172, 144, 176, 161, 141, 86, 60, 66, 128, 83, 156, 241, 79,
	46, 168, 198, 41, 254, 178, 85, 253, 237, 250, 154, 133, 88, 35, 206,
	95, 116, 252, 192, 54, 221, 102, 218, 255, 240, 82, 106, 158, 201, 61,
	3, 89, 9, 42, 155, 159, 93, 166, 80, 50, 34, 175, 195, 100, 99,
	26, 150, 16, 145, 4, 33, 8, 189, 121, 64, 77, 72, 208, 245, 130,
	122, 143, 55, 105, 134, 29, 164, 185, 194, 193, 239, 101, 242, 5, 171,
	126, 11, 74, 59, 137, 228, 108, 191, 232, 139, 6, 24, 81, 20, 127,
	17, 91, 92, 251, 151, 225, 207, 21, 98, 113, 112, 84, 226, 18, 214,
	199, 187, 13, 32, 94, 220, 224, 212, 247, 204, 196, 43, 249, 236, 45,
	244, 111, 182, 153, 136, 129, 90, 217, 202, 19, 165, 231, 71, 230, 142,
	96, 227, 62, 179, 246, 114, 162, 53, 160, 215, 205, 180, 47, 109, 44,
	38, 31, 149, 135, 0, 216, 52, 63, 23, 37, 69, 39, 117, 146, 184,
	163, 200, 222, 235, 248, 243, 219, 10, 152, 131, 123, 229, 203, 76, 120,
	209};

	char *Dictionary::strings = NULL;
	char *Dictionary::strp = NULL;
	unsigned Dictionary::strsize = 0;

	Dictionary::Dictionary(int nb, int ns, int nc) {
	int i;

	// allocate buckets for names
	bucket = new DictEntry *[nb];
	if (bucket == NULL) panic((const char *)"can't alloc buckets");

	// Initialize buckets for names
	nbuckets = nb;
	for (i = 0; i < nb; i++) bucket[i] = NULL;

	// allocate a scope list for the start of each scope list
	scope = new DictEntry *[ns];
	if (scope == NULL) panic("can't alloc scopes");

	// allocate an endScope list for the end of each scope list
	endScope = new DictEntry *[ns];
	if (endScope == NULL) panic("can't alloc endScope");

	// Initialize scopes and endscopes
	nscopes = ns;
	for (i = 0; i < ns; i++) {
	scope[i] = NULL;
	endScope[i] = NULL;
	}

	currentScope = 0;

	strsize = nc;
	strings = new char[nc];
	strp = strings;
	}

	Dictionary::~Dictionary() {
	delete[] bucket;
	delete[] scope;
	delete[] endScope;
	nbuckets = nscopes = 0;
	currentScope = -1;
	}

	/* Hashing function described in */
	/* "Fast Hashing of Variable-Length Text Strings," */
	/* by Peter K. Pearson, CACM, June 1990. */
	int Dictionary::hash(const char *string) {
	int hash1 = 0;
	int hash2 = 0;
	int length = 0;
	int r = 0;

	while (*string != 0) {
	length++;
	/* Hash function is XOR of successive characters randomized by
	* the hash table.
	*/
	hash1 ^= randomNumbers[static_cast<int>(*string++)];
	if (string != 0) hash2 ^= randomNumbers[static_cast<int>(string++)];
	}
	r = (hash1 << 8) \| hash2;
	return r;
	}

	/* Return ptr to 1st entry found in table under key
	* (return NULL if none found).
	*/
	DictEntry Dictionary::lookup(const char key, CPPSymbol::ObjectType tp) {
	// tp is type to be looked for
	// Default, 0, is to look for any symbol irrespective of type
	// Each new DictEntry is stored at start of its list so most
	// recent additions are reached first
	// DictEntry *q;
	CPPSymbol *q;
	// int scope = getCurrentScopeIndex();
	// if(sc != -1)
	// scope = sc;

	int h = hash(key) % nbuckets;
	q = (CPPSymbol *)bucket[h];

	for (; q != NULL; q = (CPPSymbol *)q->getNext()) {
	// printf("Dictionary.cpp lookup symbol %s in scope %d current scope %d\n",
	// q->getKey(),q->this_scope,getCurrentScopeIndex());
	if (h != q->getHashCode()) {
	fprintf(stderr,
	"dictionary.cpp lookup, h not equal to q->getHashCode() for %s\n",
	key);
	}

	if (h == q->getHashCode() && strcmp(key, q->getKey()) == 0) {
	if (tp == 0) { // Search for first matching symbol
	return q;
	} else {
	CPPSymbol::ObjectType type = q->getType();
	if (tp == CPPSymbol::otTypename) // Search for first type name
	{
	if (type == CPPSymbol::otTypedef \|\| type == CPPSymbol::otEnum \|\|
	type == CPPSymbol::otClass \|\| type == CPPSymbol::otStruct \|\|
	type == CPPSymbol::otUnion) {
	return q;
	}
	} else if (tp ==
	CPPSymbol::otNonTypename) // Search for first non type name
	{
	if (type == CPPSymbol::otVariable \|\| type == CPPSymbol::otFunction) {
	return q;
	}
	} else if (type == tp) { // Search for first symbol with specific type
	return q;
	} else {
	return NULL;
	}
	}
	}
	}
	return NULL;
	}

	void Dictionary::define(const char key, DictEntry entry) {
	defineInScope(key, entry, currentScope);
	}

	void Dictionary::defineInScope(const char key, DictEntry entry, int sc) {
	int h = hash(key) % nbuckets; // July 2005, nbuckets = 4001 See CPP_parser.g
	// printf("Dictionary.cpp defineInScope key %s hash(key) %d bucket %d scope
	// %d\n",
	// key,hash(key),h,sc);
	entry->this_scope = sc;
	entry->setKey(strdup(key)); // Make a local copy of key
	entry->setHashCode(h);
	entry->setNext(bucket[h]); // Set next pointer to current entry in bucket
	bucket[h] = entry; // Replace current entry in bucket
	if (endScope[sc] == NULL) {
	scope[sc] = endScope[sc] = entry;
	} else {
	endScope[sc]->setScope(entry);
	endScope[sc] = entry;
	}
	}

	int Dictionary::getCurrentScopeIndex() { return currentScope; }

	DictEntry *Dictionary::getCurrentScope() {
	if (currentScope < 0 \|\| currentScope > nscopes) {
	panic("getCurrentScope: no scope");
	}
	return scope[currentScope];
	}

	void Dictionary::saveScope() {
	// Advance scope number (for included scope)
	if (currentScope < nscopes) currentScope++;
	/*
	if ( currentScope>=nscopes )
	panic( "saveScope: overflow" );
	*/
	// printf("Dictionary saveScope entered. Scope now %d\n",currentScope);
	}

	void Dictionary::restoreScope() {
	// Reduce scope number for next highest scope
	// if ( currentScope==0 )
	// panic( "restoreScope: underflow" );
	if (currentScope > 0) currentScope--;
	// printf("Dictionary restoreScope entered. Scope now %d\n",currentScope);
	}

	/* This unlinks all entries from the Dictionary that are members
	* of the current scope. The scope level is not restored to the previous
	* scope however. This requires use of restoreScope() above
	*/
	DictEntry *Dictionary::removeScope(int sc) {
	DictEntry de, r;
	if (sc == -1) { // removeScope() without parameter value defaults sc to -1
	sc = currentScope;
	}
	for (de = scope[sc]; de != NULL; de = de->getNextInScope()) {
	remove(de);
	}
	r = scope[sc];
	scope[sc] = endScope[sc] = NULL;
	return r;
	}

	// Remove this dictEntry from its bucket by unlinking it
	DictEntry Dictionary::remove(DictEntry de) {
	DictEntry prev, curr;
	if (de == NULL) panic("Dictionary.cpp remove: NULL ptr");
	int h = hash(de->getKey()) % nbuckets; // Find pointer to bucket
	for (prev = NULL, curr = bucket[h]; curr != NULL;
	prev = curr, curr = curr->getNext()) {
	if (de == curr) {
	if (prev == NULL) {
	bucket[h] = de->getNext();
	} else {
	prev->setNext(de->getNext());
	}
	de->setNext(NULL);
	return de;
	}
	}
	return NULL; // should never get here...
	}

	/* Lookup the object referred to by 'key' and then physically remove
	* it from the Dictionary. Return the object referred to by the key.
	* If more than one definition is found for 'key', then only the
	* first one is removed. Return NULL if not found.
	* Note: DW 12/06/03 Probably not used
	*/
	DictEntry Dictionary::remove(char key) {
	DictEntry q, prev;

	int h = hash(key) % nbuckets;
	for (prev = NULL, q = bucket[h]; q != NULL; prev = q, q = q->getNext()) {
	if (h == q->getHashCode() && strcmp(key, q->getKey()) == 0) {
	if (prev == NULL) {
	bucket[h] = q->getNext();
	} else {
	prev->setNext(q->getNext());
	}
	q->setNext(NULL);
	return q;
	}
	}
	return NULL; // should never get here, but make compiler happy
	}

	void Dictionary::dumpScope(FILE *f, int sc) {
	DictEntry *s;

	if (sc == -1) { // dumpScope() without parameter value defaults sc to -1
	sc = currentScope;
	}
	for (s = scope[sc]; s != NULL; s = s->getNextInScope()) {
	dumpSymbol(f, s);
	}
	}

	// This is overridden in CPPDictionary.hpp
	void Dictionary::dumpSymbol(FILE f, DictEntry de) {
	fprintf(f, "%s\n", de->getKey());
	}

	// Diagnostic function
	// Contents of first 10 scopes printed
	void Dictionary::dumpScopes() {
	DictEntry *dictEntry;
	int i;

	printf("Scopes");
	for (i = 0; i < 10; i++) {
	printf(" %d ", i);
	}
	printf("\n");
	printf(" first");
	for (i = 0; i < 10; i++) {
	if (scope[i] != NULL) {
	dictEntry = scope[i];
	printf("%10s ", dictEntry->getKey());
	} else {
	printf(" ");
	}
	}
	printf("\n");
	printf(" last ");
	for (i = 0; i < 10; i++) {
	if (endScope[i] != NULL) {
	dictEntry = endScope[i];
	printf("%10s ", dictEntry->getKey());
	} else {
	printf(" ");
	}
	}
	printf("\n");
	}

	/* Add a string to the string table and return a pointer to it.
	* Bump the pointer into the string table to next avail position.
	*/
	char Dictionary::strdup(const char s) {
	char *start = strp;
	if (s == NULL) panic("strdup: NULL string");
	if (start + strlen(s) + 1 > &(strings[strsize - 2])) {
	panic("string table overflow");
	}
	while (*s != '\0') {
	strp++ = s++;
	}
	*strp++ = '\0';
	return start;
	}

	void Dictionary::panic(const char *err) {
	fprintf(stdout, "Dictionary panic: %s\n", err);
	exit(-1);
	}