chksymtable.cpp

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

#ifndef __CHKSYMTABLE_CPP__
#define __CHKSYMTABLE_CPP__

#include <vector>
#include <list>

#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				type_undefined				=		-1000;
const		int				var_undefined				=		type_undefined;


const		int				var_type_void				=		-1;
const		int				var_type_int				=		-2;
const		int				var_type_bool				=		-3;
const		int				var_type_double				=		-4;
const		int				var_type_char				=		-6;
const		int				var_type_NULL				=		-7;
const		int				var_type_notfound			=		type_undefined;

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				SymbolList_id_notdefined	=		-1;

struct TSymbolListVariableEntry {
	int id;
	int level;
	int defined_line;
	int var_type;
	int lvalue;
	int const_sign;
	int const_val;
	TSymbolListVariableEntry() : id(SymbolList_id_notdefined) { const_sign = 0; }
};

struct TSymbolListFunctionEntry {
	int id;
	int func_type;
	int defined;
	int defined_line;
	int valid;
	list <TSymbolListVariableEntry> arg_list;
	TSymbolListFunctionEntry() { id = SymbolList_id_notdefined; func_type = type_undefined; defined = 0; }
};

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

list <TSymbolListVariableEntry> SymbolListVariable[Limit_ID];
TSymbolListFunctionEntry SymbolListFunction[Limit_ID];
TSymbolListTypeEntry SymbolListType[Limit_ID];
list <int> SymbolListLevelDefined[Limit_Level];
vector <int> SymbolListFuncDefined;

int SymbolListNowLevel = 0;

int __get_sizeof(int var_type);
int __get_sizeof(const TSymbolListVariableEntry& var);
int __chk_basic_type (int var_type);
int SymbolListChkFind(int id);
int SymbolListChkDefined(int id);
int SymbolListGetDefinedLine(int id);
int SymbolListAddVariableEntry(int id, TSymbolListVariableEntry Ventry);
int SymbolListAddFunctionEntry(int id, const TSymbolListFunctionEntry& Fentry);
int SymbolListAddTypeEntry(int id, const TSymbolListTypeEntry& Tentry);
int SymbolListRemoveVariableEntry(int id, int level);
void SymbolListIncLevel();
void SymbolListDecLevel();
int SymbolListTypeADDStar(int var_type);
int SymbolListTypeDELStar(int var_type);
int SymbolListTypeADDArrayList(int var_type, list <int> & array_subs);
int SymbolListTypeADDArrayList(int var_type, list <int> & array_subs);
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 >= 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 SymbolListChkFind(int id)
{
	if (SymbolListFunction[id].id != SymbolList_id_notdefined) return 1;
	if (SymbolListType[id].total_size != type_undefined) return 1;
	if (!SymbolListVariable[id].empty()) return 1;
	return 0;
}

int SymbolListChkDefined(int id)
{
	if (SymbolListNowLevel == 0)
	{
		if (SymbolListFunction[id].id != SymbolList_id_notdefined) 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 SymbolListGetDefinedLine(int id)
{
	if (SymbolListNowLevel == 0)
	{
		if (SymbolListFunction[id].id != SymbolList_id_notdefined) return SymbolListFunction[id].defined_line;
		if (SymbolListType[id].total_size != type_undefined) return SymbolListType[id].defined_line;
	}
	if (!SymbolListVariable[id].empty() && SymbolListVariable[id].begin()->level == SymbolListNowLevel)
	{
		return SymbolListVariable[id].begin()->defined_line;
	}
	return 0;
}

string __vartype2str(int var_type);
int SymbolListAddVariableEntry(int id, TSymbolListVariableEntry Ventry)
{
	if (SymbolListChkDefined(id))
	{
		return 1;
	}

//	printf("Add : %s, %s\n", __vartype2str(Ventry.var_type).c_str(), IDHash_int2ID(id).c_str());
	Ventry.level = SymbolListNowLevel;
	SymbolListVariable[id].push_front(Ventry);
	SymbolListLevelDefined[SymbolListNowLevel].push_front(id);
	return 0;
}

int SymbolListAddFunctionEntry(int id, const TSymbolListFunctionEntry& Fentry)
{
	if (SymbolListChkDefined(id))
	{
		return 1;
	}

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

int SymbolListAddTypeEntry(int id, const TSymbolListTypeEntry& Tentry)
{
	if (SymbolListChkDefined(id))
	{
		return 1;
	}

	SymbolListType[id] = Tentry;
	SymbolListLevelDefined[0].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)
{
	if (var_type == type_undefined) return type_undefined;
	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 (var_type == type_undefined) return type_undefined;
	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)
{
	if (var_type == type_undefined) return type_undefined;
	if (array_sub <= 0) return type_undefined;
	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;
}

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)
{
	if (ret_type == type_undefined) return type_undefined;
	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 ++)
	{
		if (p->var_type == type_undefined) return type_undefined;
		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				// __CHKSYMTABLE_CPP__