chksupport.cpp

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

	var.lvalue = 0;
	if (op_type == SRC_calculational_MINUS) var.const_val = - var1.const_val;
	else if (op_type == SRC_calculational_NOT) var.const_val = ~ var.const_val;
}

void CheckExprUnaryCalculational(TSymbolListVariableEntry& var1, int op_type, TSymbolListVariableEntry& var)
{
	var.var_type = var_type_notfound;
	var.const_sign = 0;
	var.lvalue = 0;
	if (var1.var_type == var_type_notfound) return;
	if (!__chk_calculational_type(var1))
	{
		errormsg(8, PROGRAM_LineNumber, SRC_OP_name[op_type], __vartype2str(var1));
		var.var_type = var_type_notfound;
		return;
	}
	if (var1.const_sign)
	{
		CheckPerformUnaryCalc(var1, op_type, var);
		return;
	}

	var.var_type = var_type_int;
	var.const_sign = 0;
	var.lvalue = 0;
}

int CheckVoidArray(int var_type)
{
	if (var_type == var_type_notfound) return 0;
	if (var_type >= 0 && SymbolListType[var_type].type_number == type_number_array && SymbolListType[var_type].ret_type_id == var_type_void) return 1;
	if (var_type >= 0 && (SymbolListType[var_type].type_number == type_number_array || SymbolListType[var_type].type_number == type_number_pointer))
		return CheckVoidArray(SymbolListType[var_type].ret_type_id);
	return 0;
}

void CheckMakeNewVarDecl(TSymbolListVariableEntry& Ventry)
{
	if (Ventry.var_type == var_type_notfound) return;
	if (SymbolListChkDefined(Ventry.id))
	{
		errormsg(2, Ventry.defined_line, IDHash_int2ID(Ventry.id), __int2str(SymbolListGetDefinedLine(Ventry.id)));
		return;
	}
	if (Ventry.var_type == var_type_void)
	{
		errormsg(26, Ventry.defined_line, IDHash_int2ID(Ventry.id));
		return;
	}
	if (CheckVoidArray(Ventry.var_type))
	{
		errormsg(27, Ventry.defined_line, IDHash_int2ID(Ventry.id));
		return;
	}
	SymbolListAddVariableEntry(Ventry.id, Ventry);
}

void CheckMakeNewVarDecls(int var_type, list <int>& var_name)
{
	TSymbolListVariableEntry Ventry;
	Ventry.var_type = var_type;
	Ventry.level = SymbolListNowLevel;
	Ventry.const_sign = 0;
	Ventry.defined_line = PROGRAM_LineNumber;

	for (list <int> :: iterator p = var_name.begin(); p != var_name.end(); p ++)
	{
		Ventry.id = *p;
		CheckMakeNewVarDecl(Ventry);
	}
}

int CheckCastCompatibility(TSymbolListVariableEntry& var1, TSymbolListVariableEntry& var2)
{
	if (var1.var_type == var_type_notfound || var2.var_type == var_type_notfound) return 1;
	if (var1.var_type >= 0)
	{
		if (SymbolListType[var1.var_type].type_number == type_number_pointer && var2.var_type == var_type_NULL)
		{
			return 1;
		}
		if (SymbolListType[var1.var_type].type_number == type_number_pointer && 
				var2.var_type > 0 && SymbolListType[var2.var_type].type_number == type_number_pointer && SymbolListType[var2.var_type].ret_type_id == var_type_void)
		{
			return 1;
		}
	}
	if (var1.var_type >= 0 && var2.var_type >= 0)
	{
		if (SymbolListType[var1.var_type].type_number == type_number_pointer && SymbolListType[var2.var_type].type_number == type_number_array)
		{
			if (SymbolListType[var1.var_type].ret_type_id == SymbolListType[var2.var_type].ret_type_id)
			{
				return 1;
			}
		}
	}
	if (var1.var_type != var2.var_type) return 0;
	return 1;
}

int CheckCastCompatibility(int var1_type, TSymbolListVariableEntry& var2)
{
	TSymbolListVariableEntry var1;
	var1.var_type = var1_type;
	return CheckCastCompatibility(var1, var2);
}

void CheckAddConstVariable(int var_type, int id, TSymbolListVariableEntry& Ventry)
{
	if (var_type == var_type_notfound) return;
	if (SymbolListChkDefined(id))
	{
		errormsg(2, PROGRAM_LineNumber, IDHash_int2ID(id), __int2str(SymbolListGetDefinedLine(id)));
		return;
	}
	if (!Ventry.const_sign)
	{
		errormsg(39, PROGRAM_LineNumber);
		return;
	}
	if (!CheckCastCompatibility(var_type, Ventry))
	{
		errormsg(7, PROGRAM_LineNumber, __vartype2str(var_type), "=", __vartype2str(Ventry));
		return;
	}
	Ventry.id = id;
	Ventry.var_type = var_type;
	Ventry.lvalue = 0;
	SymbolListAddVariableEntry(id, Ventry);
}

void CheckMakeNewStructDef(int id, TSymbolListTypeEntry& Tentry, int defined_line)
{
	Tentry.defined_line = defined_line;
	if (SymbolListChkDefined(id))
	{
		errormsg(2, Tentry.defined_line, "struct " + IDHash_int2ID(id), __int2str(SymbolListGetDefinedLine(id)));
		return;
	}
	SymbolListAddTypeEntry(id, Tentry);
}

int AddVar2Field(TSymbolListTypeEntry& Tentry, TSymbolListVariableEntry Ventry)
{
	if (Ventry.var_type == var_type_notfound) return 0;
	if (Ventry.var_type == var_type_void)
	{
		errormsg(26, Ventry.defined_line, IDHash_int2ID(Ventry.id));
		return 0;
	}
	if (CheckVoidArray(Ventry.var_type))
	{
		errormsg(27, Ventry.defined_line, IDHash_int2ID(Ventry.id));
		return 0;
	}
	for (list <TSymbolListVariableEntry> :: iterator p = Tentry.field_var.begin(); p != Tentry.field_var.end(); p ++)
	{
		if (p->id == Ventry.id)
		{
			errormsg(2, Ventry.defined_line, IDHash_int2ID(Ventry.id), 
				__int2str(p->defined_line));
			return 0;
		}
	}
	Tentry.field_var.push_back(Ventry);
	return 1;
}

int AddVars2Field(TSymbolListTypeEntry& Tentry, int var_type, list <int>& var_list)
{
	int ok = 1;
	TSymbolListVariableEntry Ventry;
	Ventry.defined_line = PROGRAM_LineNumber;
	Ventry.lvalue = 1; Ventry.const_sign = 0;
	Ventry.var_type = var_type;

	for (list <int> :: iterator p = var_list.begin(); p != var_list.end(); p ++)
	{
		Ventry.id = *p;
		ok &= AddVar2Field(Tentry, Ventry);
	}

	return ok;
}

int __chk_argument_consistency(TSymbolListVariableEntry& var1, TSymbolListVariableEntry& var2)
{
	if (var1.var_type == var_type_notfound || var2.var_type == var_type_notfound) return 1;
	return (var1.var_type == var2.var_type);
}

int __chk_arguments_consistency(list <TSymbolListVariableEntry>& arg1, list <TSymbolListVariableEntry>& arg2)
{
	list <TSymbolListVariableEntry> :: iterator p1 = arg1.begin();
	list <TSymbolListVariableEntry> :: iterator p2 = arg2.begin();
	while (p1 != arg1.end() && p2 != arg2.end())
	{
		if (!__chk_argument_consistency(*p1, *p2))
		{
			return 0;
		}
		p1 ++; p2 ++;
	}
	if (p1 != arg1.end() || p2 != arg2.end())
	{
		return 0;
	}
	return 1;
}

void CheckCondExpr(TSymbolListVariableEntry& var)
{
	if (!__chk_bool_type(var))
	{
		errormsg(9, PROGRAM_LineNumber);
	}
}

int CheckForceCast(TSymbolListVariableEntry& var, int target_type)
{
	if (target_type == var_type_int) return (var.var_type == var_type_int || var.var_type == var_type_bool || var.var_type == var_type_char
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_pointer)
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_function));
	if (target_type == var_type_char) return (var.var_type == var_type_int || var.var_type == var_type_bool || var.var_type == var_type_char
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_pointer)
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_function));
	if (target_type == var_type_bool) return (var.var_type == var_type_int || var.var_type == var_type_bool || var.var_type == var_type_char
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_pointer)
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_function));
	if (target_type >= 0 && SymbolListType[target_type].type_number == type_number_pointer)
	{
		return (var.var_type == var_type_NULL || var.var_type == var_type_int || var.var_type == var_type_bool || var.var_type == var_type_char ||
					(var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_pointer) ||
					(var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_function));
	}
	if (target_type >= 0 && (SymbolListType[target_type].type_number == type_number_struct || SymbolListType[target_type].type_number == type_number_array))
	{
		return (var.var_type >= 0) && 
					(SymbolListType[var.var_type].type_number == type_number_struct || SymbolListType[var.var_type].type_number == type_number_struct) &&
					(SymbolListType[var.var_type].total_size == SymbolListType[target_type].total_size);
	}
	if (target_type >= 0 && (SymbolListType[target_type].type_number == type_number_function))
	{
		return (var.var_type == var_type_int || var.var_type == var_type_bool || var.var_type == var_type_char
												|| (var.var_type >= 0 && SymbolListType[var.var_type].type_number == type_number_pointer));
	}
	return var.var_type == target_type;
}

void ForceCast(TSymbolListVariableEntry& var1, int target_type, TSymbolListVariableEntry& var)
{
	var = var1; var.var_type = target_type;
	if (!CheckForceCast(var1, target_type))
	{
		errormsg(40, PROGRAM_LineNumber, __vartype2str(var1.var_type), __vartype2str(target_type));
	}
}

void GetVariable(int id, TSymbolListVariableEntry& var)
{
	if (!SymbolListVariable[id].empty()) 
	{
		var = *SymbolListVariable[id].begin();
		var.id = id; 
	}
	else if (SymbolListFunction[id].id != SymbolList_id_notdefined)
	{
		var.id = id; var.lvalue = 0; var.const_sign = 0;
		var.defined_line = SymbolListFunction[id].defined_line;
		var.var_type = SymbolListFunction[id].func_type;
	}
	else
	{
		errormsg(5, PROGRAM_LineNumber, IDHash_int2ID(id));
		var.var_type = var_type_notfound;
		var.lvalue = 0; var.const_sign = 0;
	}
}

int GetFieldVariable_sub(int structid, int fieldid, TSymbolListVariableEntry& var)
{
	for (list <TSymbolListVariableEntry> :: iterator p = SymbolListType[structid].field_var.begin(); 
			p != SymbolListType[structid].field_var.end(); p ++)
	{
		if (p->id == fieldid)
		{
			var = *p;
			return 1;
		}
	}
	return 0;
}

int __chk_struct(int var_type)
{
	if (var_type < 0) return 0;
	return (SymbolListType[var_type].type_number == type_number_struct);
}

int __chk_function(int var_type)
{
	if (var_type < 0) return 0;
	return (SymbolListType[var_type].type_number == type_number_function);
}

void GetFieldVariable(TSymbolListVariableEntry& var1, int id, TSymbolListVariableEntry& var)
{
	if (var1.var_type == var_type_notfound)
	{
		var = var1;
		return;
	}
	if (!__chk_struct(var1.var_type))
	{
		errormsg(23, PROGRAM_LineNumber, __vartype2str(var1));
		var.var_type = var_type_notfound;
		var.lvalue = 0; var.const_sign = 0;
		return;
	}
	if (!GetFieldVariable_sub(var1.var_type, id, var))
	{
		errormsg(25, PROGRAM_LineNumber, IDHash_int2ID(id), IDHash_int2ID(var1.var_type));
		var.var_type = var_type_notfound;
		var.lvalue = 0; var.const_sign = 0;
		return;
	}
	var.lvalue = 1;
}

void CheckCall(TSymbolListVariableEntry& func, list <TSymbolListVariableEntry>& var_list, TSymbolListVariableEntry& var)
{
	if (func.var_type == var_type_notfound)
	{
		var = func;
		return;
	}
	if (!__chk_function(func.var_type))
	{
		errormsg(16, PROGRAM_LineNumber);
		var.var_type = var_type_notfound;
		var.lvalue = 0; var.const_sign = 0;
		return;
	}

	list <TSymbolListVariableEntry> :: iterator p1 = SymbolListType[func.var_type].field_var.begin();
	list <TSymbolListVariableEntry> :: iterator p2 = var_list.begin();
	int size1 = 0, size2 = 0;
	while (p1 != SymbolListType[func.var_type].field_var.end() && p2 != var_list.end())
	{
		if (!CheckCastCompatibility(*p1, *p2))
		{
			errormsg(20, PROGRAM_LineNumber, __int2str(size1 + 1), __vartype2str(p2->var_type),