symboltable.c

decafc的源代码

		if (strcmp(elementPtr->next->id, id) == 0) {

			/* delete the symbol from the list */

			tempElementPtr = elementPtr->next;
			elementPtr->next = tempElementPtr->next;
			free(tempElementPtr->id);
			free(tempElementPtr);
			return;
		}
		elementPtr = elementPtr->next;
	}
}

/****************************************************************************
 Function name:		Difference
 Description:		delete symbols appearing in the second symbol table
			from the first symble table
 Procedure:		for every symbol appearing in the sechond symbol table
				delete it from the first symbol table
 Return value:		none
 Input parameter:	symbolTable1	pointer to the first symbol table
			symbolTable2	pointer to the second symbol table
 Output parameter:	none
 ****************************************************************************/
void Difference(SymbolTablePtr	symbolTable1,
		SymbolTablePtr	symbolTable2)
{
	int		index;
	HashTableEntry	hashTableEntry = NULL;
	ElementPtr	elementPtr = NULL;

	for (index = 0; index < symbolTable2->numberOfEntries; index ++) {
		hashTableEntry = (symbolTable1->hashTable)[index];
		if (hashTableEntry != NULL) {
			elementPtr = hashTableEntry;
			do {
				Delete(symbolTable1, elementPtr->id);
				elementPtr = elementPtr->next;
			} while (elementPtr != NULL);
		}
	}
}

/****************************************************************************
 Function name:		Hash
 Description:		caculate the entry index of a symbol in the hash
			table
 Procedure:		add every character of the id of the symbol and mod
			the result by the size of the hash table
 Return value:		entry index in the hash table
 Input parameter:	id		id of the symbol
			numberOfEntries	size of the hash table
 Output parameter:	none
 ****************************************************************************/
int Hash(String	id,
	 int	numberOfEntries)
{
	String		p = NULL;
	unsigned int	h = 0;
	unsigned int	g;

	for (p = id; *p != EOS; p ++) {
		h = (h << 4) + *p;
		if (g = h & 0xf0000000) {
			h = h ^ ( g >> 24);
			h = h ^ g;
		}
	}

	return(h % numberOfEntries);
}

/****************************************************************************
 Function name:		FreeSymbolTable
 Description:		free memory space occupied by the symbol table
 Procedure:		1. for every entry in the hash table of this symbol
			   table
			   do
				free this entry
			   done
			2. free the hash table itself
			3. free the symbol table itself
 Return value:		none
 Input parameter:	symbolTablePtr	pointer to symbol table
 Output parameter:	none
 ****************************************************************************/
void FreeSymbolTable(SymbolTablePtr	symbolTablePtr)
{
	int		index;
	HashTableEntry	hashTableEntry = NULL;

	if (symbolTablePtr == NULL) {
		return;
	}

	/* free every entry of the hash table */

	for (index = 0; index < symbolTablePtr->numberOfEntries; index ++) {
		if ((symbolTablePtr->hashTable)[index] != NULL) {
			FreeHashTableEntry((symbolTablePtr->hashTable)[index]);
			(symbolTablePtr->hashTable)[index] = NULL;
		}
	}

	/* free the hash table itself */

	free(symbolTablePtr->hashTable);

	/* free the symbol table itself */

	free(symbolTablePtr);
}

/****************************************************************************
 Function name:		FreeHashTableEntry
 Description:		free the memory space occupied by one hash table
			entry
 Procedure:		free elements in this entry
 Return value:		none
 Input parameter:	hashTableEntry	hash table entry
 Output parameter:	none
 ****************************************************************************/
static void FreeHashTableEntry(HashTableEntry	hashTableEntry)
{
	/* free the elements in this entry */

	FreeElement((ElementPtr)hashTableEntry);
}

/****************************************************************************
 Function name:		Free element
 Description:		free elements in one hash table entry
 Procedure:		free the elements backwards
 Return value:		none
 Input parameter:	elementPtr	pointer to the first element
 Output parameter:	none
 ****************************************************************************/
static void FreeElement(ElementPtr	elementPtr)
{
	/* if this element is not the last one, free the next element */

	if (elementPtr->next != NULL) {
		FreeElement(elementPtr->next);
	}

	/* free this element */

	free(elementPtr->id);
	free(elementPtr);
}

/****************************************************************************
 Function name:		DisplaySymbolTable
 Description:		display information of one symbol table
 Procedure:		for every entry in the hash table of this symbol table
			do
				display information of this entry
			done
 Return value:		none
 Input parameter:	symbolTablePtr	pointer to the symbol table
 Output parameter:	none
 ****************************************************************************/
void DisplaySymbolTable(SymbolTablePtr	symbolTablePtr)
{
	int		index;
	HashTableEntry	hashTableEntry = NULL;
	ElementPtr	elementPtr = NULL;

	/* do nothing if this symbol table does not exist */

	if (symbolTablePtr == NULL) {
		return;
	}

	/* display information of every entry in the hash table */

	for (index = 0; index < symbolTablePtr->numberOfEntries; index ++) {
		hashTableEntry = (symbolTablePtr->hashTable)[index];
		if (hashTableEntry != NULL) {
			printf("%d ", index);
		}

		elementPtr = hashTableEntry;
		while (elementPtr != NULL) {
			printf("(\"%s\", %d, %x) ",
			       elementPtr->id,
			       elementPtr->offset,
			       elementPtr->typePtr);
			elementPtr = elementPtr->next;
		}

		if (hashTableEntry != NULL) {
			printf("\n");
		}
	}
}

void NewSymbolTableStack(SymbolTableStackPtr	symbolTableStackPtr)
{
	symbolTableStackPtr->top = NULL;
}

void Push(SymbolTableStackPtr	symbolTableStackPtr,
	  SymbolTablePtr	symbolTablePtr,
	  int			beginLocalVarID)
{
	SymbolTableStackEntryPtr	symbolTableStackEntryPtr = NULL;

	symbolTableStackEntryPtr =
	  (SymbolTableStackEntryPtr)malloc(sizeof(SymbolTableStackEntry));

	if (symbolTableStackEntryPtr == NULL) {
		fprintf(stderr, "Out of memory.\n");
		exit(1);
	}

	symbolTableStackEntryPtr->symbolTablePtr = symbolTablePtr;
	symbolTableStackEntryPtr->beginLocalVarID = beginLocalVarID;
	symbolTableStackEntryPtr->next = symbolTableStackPtr->top;
	symbolTableStackPtr->top = symbolTableStackEntryPtr;
}

// SymbolTablePtr Pop(SymbolTableStackPtr	symbolTableStackPtr)
void Pop(SymbolTableStackPtr	symbolTableStackPtr,
	 SymbolTablePtr		*symbolTablePtrPtr,
	 int			*beginLocalVarIDPtr)
{
	SymbolTableStackEntryPtr	symbolTableStackEntryPtr = NULL;
	// SymbolTablePtr			symbolTablePtr = NULL;


	if (symbolTableStackPtr->top == NULL) {
		//return(NULL);
		return;
	}

	symbolTableStackEntryPtr = symbolTableStackPtr->top;
	// symbolTablePtr = symbolTableStackEntryPtr->symbolTablePtr;
	symbolTableStackPtr->top = symbolTableStackPtr->top->next;
	*symbolTablePtrPtr =
		symbolTableStackEntryPtr->symbolTablePtr;
	*beginLocalVarIDPtr =
		symbolTableStackEntryPtr->beginLocalVarID;
	free(symbolTableStackEntryPtr);
	// return(symbolTablePtr);
	// return(symbolTableStackEntry);
}

/*
SymbolTablePtr Top(SymbolTableStackPtr	symbolTableStackPtr)
{
	if (symbolTableStackPtr->top == NULL) {
		return(NULL);
	} else {
		return(symbolTableStackPtr->top->symbolTablePtr);
	}
}

int Height(SymbolTableStackPtr	symbolTableStackPtr)
{
	SymbolTableStackEntryPtr	symbolTableStackEntryPtr;
	int				height;

	if (symbolTableStackPtr->top == NULL) {
	printf("stack height is 0\n");
		return(0);
	}

	symbolTableStackEntryPtr = symbolTableStackPtr->top;

	height = 0;
	do {
		height ++;
		symbolTableStackEntryPtr = symbolTableStackEntryPtr->next;
	} while (symbolTableStackEntryPtr != NULL);
	printf("stack height is %d\n", height);
	return(height);
	
}
*/