symtab.c

在linux下实行的简单的c语言编译器

/*Symtab.c
 *operations on symtab
 */
#include "Symtab.h"

Symtab *GlobalTable;
Symtab *pTable;
FunEntry *FunTable[SIZE];

/*generate hash value*/
static int hash(char *key)
{
	int tmp = 0;
	int i;
	for (i = 0; key[i] != '\0'; i++)
		tmp = ((tmp<<SHIFT)+key[i])%SIZE;
	return tmp;
}

Symtab *CreateTab(Symtab *pTable, FunEntry *pEntry)
{
	Symtab *newtab = (Symtab*)malloc(sizeof(Symtab));
	if (newtab == NULL)
		return NULL;
	newtab->parent = pTable;
	newtab->level = (pTable==NULL)?0:(pTable->level+1);
	newtab->memloc = 0;
	memset(newtab->valTable, 0, SIZE*sizeof(ValEntry*));
	newtab->funEntry = pEntry;
	return newtab;
}

ValEntry *Insert_Var(Symtab *pTable, char *name, Type type, int count)
{
	int hashnum = hash(name);
	int size;
	
	ValEntry *pNew = (ValEntry*)malloc(sizeof(ValEntry));
	switch(type)
	{
		case Int:
			size = sizeof(int);
			break;
		case Float:
			size = sizeof(float);
			break;
		case Char:
			size = sizeof(char);
			break;
		default:
			size = sizeof(int);
			break;
	}
	pTable->memloc += size * count;
	pNew->name = strdup(name);
	pNew->type = type;
	pNew->offset = -pTable->memloc;
	pNew->next = pTable->valTable[hashnum];
	pTable->valTable[hashnum] = pNew;
	return pNew;
}

int Lookup_Var(Symtab *pTable, FunEntry *pFun, char *name, ValEntry *pEntry)
{
	int hashnum = hash(name);
	ValEntry *pTmp;
	
	for (;pTable != NULL; pTable = pTable->parent)
	{
		for (pTmp = pTable->valTable[hashnum]; pTmp !=NULL; pTmp = pTmp->next)
			if (strcmp(pTmp->name, name) == 0)
			{
				pEntry->name = strdup(pTmp->name);
				pEntry->type = pTmp->type;
				pEntry->offset = pTmp->offset;
				pEntry->next = NULL;
				return pTable->level;
			}
	}

	if (pFun != NULL)
	{
		for (pTmp = pFun->para; pTmp!=NULL;pTmp=pTmp->next)
			if (strcmp(name, pTmp->name)==0)
			{
				pEntry->name = strdup(pTmp->name);
				pEntry->type = pTmp->type;
				pEntry->offset = pTmp->offset;
				pEntry->next = NULL;
				return 1;
			}
	}
	return -1;
}

FunEntry *Insert_Fun(char *name, Type type, TreeNode *pTreeNode)
{
	int hashnum = hash(name);
	int size = 14;
	FunEntry *pNew = (FunEntry*)malloc(sizeof(FunEntry));
	ValEntry *para;
	TreeNode *pTmp;
	
	pNew->name = strdup(name);
	pNew->type = type;
	pNew->para = NULL;

	if (strcmp(name, "main")==0)
		size+=4;
	if (pTreeNode != NULL)
	{
		pNew->para = (ValEntry*)malloc(sizeof(ValEntry));
		pNew->para->name = strdup(pTreeNode->attr.name);
		pNew->para->type = pTreeNode->type;
		pNew->para->offset = size;
		if (pTreeNode->child[0] == NULL)
		{
			switch (pNew->para->type)
			{
				case Int:
					size += sizeof(int);
					break;
				case Float:
					size += sizeof(float);
					break;
				case Char:
					size += sizeof(char);
					break;
				default:
					size += sizeof(int);
					break;
			}
		}
		else
			size += sizeof(int);

		for (pTmp = pTreeNode->sibling, para = pNew->para;
		     pTmp != NULL;
		     pTmp = pTmp->sibling, para=para->next)
		{
			para->next = (ValEntry*)malloc(sizeof(ValEntry));
			para->next->name = strdup(pTmp->attr.name);
			para->next->type = pTmp->type;
			para->next->offset = size;
			if (pTmp->child[0]==NULL)
			{
				switch(para->next->type)
				{
					case Int:
						size += sizeof(int);
						break;
					case Float:
						size += sizeof(float);
						break;
					case Char:
						size += sizeof(char);
						break;
					default:
						size += sizeof(int);
						break;
				}
			}
			else
				size += sizeof(int);
		}
		para->next = NULL;
	}
	pNew->ret_val = -size;
	pNew->next = FunTable[hashnum];
	FunTable[hashnum] = pNew;
	return pNew;
}

FunEntry *Lookup_Fun(char *name)
{
	int hashnum = hash(name);
	FunEntry *pEntry;
	
	for (pEntry = FunTable[hashnum]; pEntry !=NULL; pEntry = pEntry->next)
		if (strcmp(pEntry->name, name) == 0)
			return pEntry;
	return NULL;
}


void printFunTab()
{
	int i;
	fprintf(g_lst_file, "\nFunction table:\n");
	fprintf(g_lst_file, "\nFunction Name Type\t\n");
	fprintf(g_lst_file,   "_____________ ____\n");
	for (i = 0; i < SIZE; i++)
	{
		FunEntry *pEntry;
		for (pEntry = FunTable[i]; pEntry != NULL; pEntry = pEntry->next)
		{
			ValEntry *para;
			fprintf(g_lst_file, "%-14s ", pEntry->name);
			printType(pEntry->type);
			fprintf(g_lst_file, "\nParameter\n");
			fprintf(g_lst_file, "___________\n");
			for (para = pEntry->para; para != NULL; para = para->next)
			{
				fprintf(g_lst_file, "%s ", para->name);
				printType(para->type);
				fprintf(g_lst_file, "% -d\n", para->offset);
			}
		}
	}
}

void printSymTab(TreeNode *tree)
{
	static int GlobalPrinted = FALSE;
	Symtab *pTable;

	if (!GlobalPrinted)
	{
		int i;
		fprintf(g_lst_file, "\nSymbol table:\n");
		fprintf(g_lst_file, "\nLevel: %d\n", GlobalTable->level);
		fprintf(g_lst_file, "Variable Name Type&&Offset\n");
		fprintf(g_lst_file, "_____________ ____________\n");
		for (i = 0; i <SIZE; ++i)
		{
			ValEntry *pEntry;
			for (pEntry = GlobalTable->valTable[i]; pEntry!=NULL; pEntry = pEntry->next)
			{
				fprintf(g_lst_file, "%-14s",pEntry->name);
				printType(pEntry->type);
				fprintf(g_lst_file, "  % -d\n", pEntry->offset);
			}
		}
		GlobalPrinted = TRUE;
	}
	while (tree!=NULL)
	{
		int i;
		if (tree->nodeKind == Dec && tree->kind.dec == CompK)
		{
			pTable = tree->attr.table; fprintf(g_lst_file, "\nlevel: %d\n", pTable->level); fprintf(g_lst_file, "Variable name Type&&offset\n"); fprintf(g_lst_file, "_____________ ____________\n"); for (i = 0; i < SIZE; i++) {
				ValEntry *pEntry;
				for (pEntry = pTable->valTable[i]; pEntry!=NULL; pEntry=pEntry->next)
				{
					fprintf(g_lst_file, "%-14s", pEntry->name);
					printType(pEntry->type);
					fprintf(g_lst_file, "% -d\n", pEntry->offset);
				}
			}
		}
		for (i = 0; i < MAXCHILDREN; i++)
			printSymTab(tree->child[i]);
		tree = tree->sibling;
	}
}