symtable.cpp

一个用C++实现的C的Compiler。 代码风格良好。 原作者自己写了这个编译器

#ifndef __SYMTABLE_CPP__
#define __SYMTABLE_CPP__

#include <vector>
#include <list>
#include <cstdlib>
#include <iostream>
#include <fstream>

#include "common.cpp"
#include "IDHash.cpp"

using namespace std;

const		int			sizeof_int				=		1;
const		int			sizeof_bool				=		1;
const		int			sizeof_double			=		2;
const		int			sizeof_char				=		1;
const		int			sizeof_void				=		1;

const		int			type_undefined			=		-1000;
const		int			var_undefined			=		-1000;

const		int			SymbolList_name_type_singlevariable		=		0;
const		int			SymbolList_name_type_function			=		1;
const		int			SymbolList_name_type_typename			=		2;

const		int			type_number_struct						=		0;
const		int			type_number_function					=		1;
const		int			type_number_array						=		2;
const		int			type_number_pointer						=		3;

const		int			SymbolListTypeHash						=		99997;

struct TSymbolListVariableEntry {
	int id;
	int level;
	int var_type;
	int var_name_TAC;
	int const_sign;
	int const_val;
};

struct TSymbolListFunctionEntry {
	int id;
	int func_type;
	int end_line;
	int belonging_scope;
	list <TSymbolListVariableEntry> arg_list;
	TSymbolListFunctionEntry() { func_type = type_undefined; }
};

struct TSymbolListTypeEntry {
	int total_size;
	int type_number;							/*
													0 : struct			:	{ list of field_var }
													1 : function		:	ret_type_id (argument : field_var)
													2 : array			:	ret_type_id [array_size]
													3 : ptr				:	point to ret_type_id }
												*/
	int ret_type_id;
	int array_size;
	list <TSymbolListVariableEntry> field_var;
	TSymbolListTypeEntry() { total_size = type_undefined; ret_type_id = type_undefined; }
};

struct TSymbolListScopeEntry {
	int father;
	vector <TSymbolListVariableEntry> var_decl;
};

struct TSymbolListConstStringEntry {
	TSymbolListVariableEntry Ventry;
	list <int> data;
};

list <TSymbolListVariableEntry> SymbolListVariable[Limit_ID];
TSymbolListFunctionEntry SymbolListFunction[Limit_ID];
TSymbolListTypeEntry SymbolListType[Limit_ID];
TSymbolListScopeEntry SymbolListScope[Limit_Scope];
int SymbolListScopeStack[Limit_Scope];
list <int> SymbolListLevelDefined[Limit_Level];
list <int> SymbolListFunctionList;
list <int> SymbolListTypeList;
TSymbolListConstStringEntry SymbolListConstString[Limit_ConstString];
int SymbolListNowLevel = 0, SymbolListScopeCNT = 1, SymbolListScopeStackTOP = 1, SymbolListConstStringCNT = 0;

int __get_sizeof(int var_type);
int __get_sizeof(const TSymbolListVariableEntry& var);
int __chk_basic_type (int var_type);
int SymbolListChkDefined(int id);
int SymbolListAddVariableEntry(int id, const TSymbolListVariableEntry Ventry, int const_string);
int SymbolListAddFunctionEntry(int id, const TSymbolListFunctionEntry Fentry, int compulsive);
int SymbolListAddTypeEntry(int id, const TSymbolListTypeEntry);
int SymbolListRemoveVariableEntry(int id, int level);
void SymbolListIncLevel();
void SymbolListDecLevel();
int SymbolListTypeADDStar(int var_type);
int SymbolListTypeDELStar(int var_type);
int SymbolListTypeADDArray(int var_type, int array_sub);
int SymbolListTypeADDArrayList(int var_type, list <int> & array_subs);
int SymbolListAddConstStringEntry(int id, TSymbolListConstStringEntry& CSentry);
void SymbolListMakeNewStruct(TSymbolListTypeEntry& Tentry);
int SymbolListMakeFunctionType(int ret_type, list <TSymbolListVariableEntry>& Ventry);

int __get_sizeof(int var_type)
{
	if (var_type == var_type_int) return sizeof_int;
	if (var_type == var_type_bool) return sizeof_bool;
	if (var_type == var_type_double) return sizeof_double;
	if (var_type == var_type_char) return sizeof_char;
	if (var_type == var_type_void) return sizeof_void;

	if (var_type >= 0)
	{
		if (!SymbolListType[var_type].total_size != type_undefined)
		{
			return SymbolListType[var_type].total_size;
		}
	}
	return type_undefined;
}
int __get_sizeof(const TSymbolListVariableEntry& var)
{
	return __get_sizeof(var.var_type);
}

int __chk_basic_type (int var_type)
{
	return (var_type < 0 && var_type != type_undefined);
}

int SymbolListChkDefined(int id)
{
	if (SymbolListNowLevel == 0)
	{
		if (SymbolListFunction[id].func_type != type_undefined) return 1;
		if (SymbolListType[id].total_size != type_undefined) return 1;
	}
	if (!SymbolListVariable[id].empty() && SymbolListVariable[id].begin()->level == SymbolListNowLevel)
		return 1;

	return 0;
}

int SymbolListAddVariableEntry(int id, const TSymbolListVariableEntry Ventry, int const_string = 0)
{
	if (SymbolListChkDefined(id))
	{
		return 1;
	}
	SymbolListVariable[id].push_front(Ventry);
	
	if (!const_string)
	{
		SymbolListLevelDefined[Ventry.level].push_front(id);
		SymbolListScope[SymbolListScopeStack[SymbolListScopeStackTOP - 1]].var_decl.push_back(Ventry);
	}
	return 0;
}

int SymbolListAddFunctionEntry(int id, const TSymbolListFunctionEntry Fentry, int compulsive = 0)
{
	if (!compulsive || SymbolListFunction[id].func_type == type_undefined)
	{
		if (SymbolListChkDefined(id))
		{
			return 1;
		}
	}

	SymbolListFunction[id] = Fentry;
	SymbolListLevelDefined[0].push_front(id);
	return 0;
}

int SymbolListAddTypeEntry(int id, const TSymbolListTypeEntry Tentry)
{
//	printf ("Adding type %s\n", IDHash_int2ID(id).c_str());
	for (list <TSymbolListVariableEntry> :: const_iterator p = Tentry.field_var.begin(); p != Tentry.field_var.end(); p ++)
	{
//		printf ("\t%d %s\n", p->var_type, IDHash_int2ID(p->id).c_str());
	}
	if (SymbolListChkDefined(id))
	{
		return 1;
	}

	SymbolListType[id] = Tentry;
	SymbolListLevelDefined[SymbolListNowLevel].push_front(id);
	return 0;
}

int SymbolListRemoveVariableEntry(int id, int level)
{
	if (!SymbolListVariable[id].empty() && SymbolListVariable[id].begin()->level == level)
	{
		SymbolListVariable[id].pop_front();
		return 0;
	}
	return 1;
}

void SymbolListIncLevel()
{
	SymbolListNowLevel ++;
}

void SymbolListDecLevel()
{
	for (; !SymbolListLevelDefined[SymbolListNowLevel].empty(); 
								SymbolListLevelDefined[SymbolListNowLevel].pop_front())
	{
		SymbolListRemoveVariableEntry(*(SymbolListLevelDefined[SymbolListNowLevel].begin()), SymbolListNowLevel);
	}
	SymbolListNowLevel --;
}

int SymbolListTypeADDStar(int var_type)
{
	char buf[10];
	sprintf (buf, "*%d", var_type);
	int id = IDHash_ID2int(string(buf));
	if (SymbolListType[id].total_size == type_undefined)
	{
		SymbolListType[id].total_size = sizeof_int;
		SymbolListType[id].type_number = type_number_pointer;
		SymbolListType[id].ret_type_id = var_type;
	}
	return id;
}

int SymbolListTypeDELStar(int var_type)
{
	if (__chk_basic_type(var_type) || SymbolListType[var_type].type_number != type_number_pointer)
	{
		return type_undefined;
	}

	return SymbolListType[var_type].ret_type_id;
}

int SymbolListTypeADDArray(int var_type, int array_sub)
{
	char buf[20];
	sprintf (buf, "%d[%d]", var_type, array_sub);
	int id = IDHash_ID2int(string(buf));
	if (SymbolListType[id].total_size == type_undefined)
	{
		SymbolListType[id].total_size = __get_sizeof(var_type) * array_sub;
		SymbolListType[id].type_number = type_number_array;
		SymbolListType[id].ret_type_id = var_type;
		SymbolListType[id].array_size = array_sub;
	}
	return id;
}

int SymbolListTypeADDArrayList(int var_type, list <int> & array_subs)
{
	for (list <int> :: reverse_iterator rp = array_subs.rbegin(); rp != array_subs.rend(); rp++)
	{
		var_type = SymbolListTypeADDArray(var_type, *rp);
	}
	return var_type;
}

int SymbolListAddConstStringEntry(int id, TSymbolListConstStringEntry& CSentry)
{
	CSentry.Ventry.level = 0;
	SymbolListConstString[SymbolListConstStringCNT ++] = CSentry;
	return SymbolListAddVariableEntry(id, CSentry.Ventry);
}

void SymbolListMakeNewStruct(TSymbolListTypeEntry& Tentry)
{
	Tentry.total_size = 0;
	Tentry.type_number = type_number_struct;
	Tentry.field_var.clear();
}

int SymbolListMakeFunctionType(int ret_type, list <TSymbolListVariableEntry>& Ventry)
{
	TSymbolListTypeEntry Tentry;
	Tentry.type_number = type_number_function;
	Tentry.field_var.clear();
	Tentry.ret_type_id = ret_type;
	Tentry.total_size = sizeof_int;

	char buffer[30];
	sprintf(buffer, "%d()", ret_type);
	string func_type_name(buffer);
	for (list <TSymbolListVariableEntry> :: iterator p = Ventry.begin(); p != Ventry.end(); p ++)
	{
		Tentry.field_var.push_back(*p);
		sprintf(buffer, "%d,", p->var_type);
		func_type_name += string(buffer);
	}

	int func_type_id = IDHash_ID2int(func_type_name);
	SymbolListAddTypeEntry(func_type_id, Tentry);
	return func_type_id;
}

#endif				// __SYMTABLE_CPP__