|
|
/*********以下程序只完成了部分静态语义检查，需自行补充完整*******************/
|
|
|
#include <utility>
|
|
|
|
|
|
#include "def.h"
|
|
|
|
|
|
#define YYSTYPE int //此行是为了包含parser.tab.hpp不引起错误而加,可以在后面使用相关常量
|
|
|
|
|
|
#include "parser.tab.hpp"
|
|
|
|
|
|
SymbolStackDef AST::SymbolStack = SymbolStackDef(); //初始化静态成员符号表
|
|
|
FunctionCallTable AST::functionCallTable = FunctionCallTable();
|
|
|
|
|
|
map<int, int> TypeWidth = {{T_CHAR, 1},
|
|
|
{T_INT, 4},
|
|
|
{T_FLOAT, 8}}; //各类型所占字节数
|
|
|
map<char, string> KindName = {{'V', "变量"},
|
|
|
{'F', "函数"},
|
|
|
{'P', "形参"},
|
|
|
{'A', "数组"}}; //各类型所占字节数
|
|
|
|
|
|
|
|
|
vector<Error>Errors::Errs = {};
|
|
|
|
|
|
void Errors::ErrorAdd(int Line, int Column, string ErrMsg) {
|
|
|
Error e = {Line, Column, std::move(ErrMsg)};
|
|
|
Errs.push_back(e);
|
|
|
}
|
|
|
|
|
|
void Errors::ErrorsDisplay() {
|
|
|
for (const auto& a: Errs)
|
|
|
cout << "第" << a.Line << "行、第" << a.Column << "列处错误: " << a.ErrMsg << endl;
|
|
|
}
|
|
|
|
|
|
string NewAlias() {
|
|
|
static int num = 0;
|
|
|
return "V_" + to_string(++num);
|
|
|
}
|
|
|
|
|
|
void DisplaySymbolTable(SymbolStackDef *SYM) {
|
|
|
for (auto i = 0; i < SYM->Symbols.size(); i++) {
|
|
|
cout << "----------------------------------------------------------------------" << endl;
|
|
|
cout << " 层号: " << i << endl;
|
|
|
cout << " 符 号 名 别名 类型 种 类 其它信息" << endl;
|
|
|
cout << "----------------------------------------------------------------------" << endl;
|
|
|
if (SYM->Symbols.at(i)->Symbols.empty())
|
|
|
cout << " 空 表" << endl;
|
|
|
else
|
|
|
for (auto SymPtr : SYM->Symbols.at(i)->Symbols) {
|
|
|
//取第i层第j个符号对象的指针
|
|
|
cout.width(20);
|
|
|
cout << SymPtr->Name;
|
|
|
cout.width(8);
|
|
|
if (SymPtr->Kind == 'V' || SymPtr->Kind == 'A' || SymPtr->Kind == 'P') //符号是变量,形参,显示别名
|
|
|
cout << ((VarSymbol *) SymPtr)->Alias;
|
|
|
else cout << " ";
|
|
|
cout.width(8);
|
|
|
cout << SymbolMap[SymPtr->Type];
|
|
|
cout.width(8);
|
|
|
cout << KindName[SymPtr->Kind];
|
|
|
if (SymPtr->Kind == 'V' || SymPtr->Kind == 'P') //符号是变量,形参
|
|
|
cout << "偏移量: " << ((VarSymbol *) SymPtr)->Offset << " 全局: "
|
|
|
<< ((VarSymbol *) SymPtr)->isGolbal;
|
|
|
else if (SymPtr->Kind == 'F') //符号是函数
|
|
|
{
|
|
|
cout << "形参数: " << ((FuncSymbol *) SymPtr)->ParamNum;
|
|
|
cout << " 变量空间: " << ((FuncSymbol *) SymPtr)->ARSize;
|
|
|
} else if (SymPtr->Kind == 'A') //符号是数组，需要显示各维大小
|
|
|
{
|
|
|
cout << "偏移量: " << ((VarSymbol *) SymPtr)->Offset << " 全局: "
|
|
|
<< ((VarSymbol *) SymPtr)->isGolbal << " ";
|
|
|
cout << ((VarSymbol *) SymPtr)->Dims.size() << "维：";
|
|
|
for (int Dim : ((VarSymbol *) SymPtr)->Dims)
|
|
|
cout << Dim << " ";
|
|
|
}
|
|
|
cout << endl;
|
|
|
}
|
|
|
cout << "----------------------------------------------------------------------" << endl;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool IsLeftValue(ExpAST *PExp) {
|
|
|
if (typeid(*PExp) == typeid(VarAST)) return true; //对简单变量、数组下标变量,需要查符号表
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool IsConstValue(ExpAST *PExp) {
|
|
|
if (typeid(*PExp) == typeid(ConstAST)) return true;
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
Symbol *SymbolStackDef::LocateNameCurrent(const string& Name) //在当前(最内层)作用域中查找该符号是否有定义
|
|
|
{
|
|
|
SymbolsInAScope *curScope = Symbols.back();
|
|
|
for (auto & Symbol : curScope->Symbols)
|
|
|
if (Symbol->Name == Name)
|
|
|
return Symbol;
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
Symbol *SymbolStackDef::LocateNameGlobal(const string& Name)//由内向外，整个符号表中查找该符号是否有定义
|
|
|
{
|
|
|
for (int i = Symbols.size() - 1; i >= 0; i--) {
|
|
|
for (auto & Symbol : Symbols.at(i)->Symbols)
|
|
|
if (Symbol->Name == Name)
|
|
|
return Symbol;
|
|
|
|
|
|
}
|
|
|
return nullptr;
|
|
|
}
|
|
|
|
|
|
void FunctionCallTable::addFuncCalls(int Line, int Column, string Name) {
|
|
|
FunctionCall FuncCall(Line, Column, std::move(Name));
|
|
|
FuncCalls.push_back(FuncCall);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
void FunctionCallTable::deleteFuncCalls(string Name) {
|
|
|
for (auto fC = FuncCalls.begin(); fC != FuncCalls.end(); fC++)
|
|
|
if (fC->Name == Name) {
|
|
|
FuncCalls.erase(fC--);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void ProgAST::Semantics0() {
|
|
|
int Offset = 0;
|
|
|
Semantics(Offset);
|
|
|
Errors::ErrorsDisplay();
|
|
|
}
|
|
|
|
|
|
void ProgAST::Semantics(int &Offset) {
|
|
|
auto *Global = new SymbolsInAScope(); //全局变量的作用域符号表，记录外部变量、函数名
|
|
|
SymbolStack.Symbols.push_back(Global);
|
|
|
GlobalSymbolTable = Global; //程序对象挂一个全局符号表
|
|
|
|
|
|
//预先设置缺省函数read和write
|
|
|
auto *FuncDefPtr = new FuncSymbol();
|
|
|
FuncDefPtr->Name = string("read");
|
|
|
FuncDefPtr->Type = T_INT;
|
|
|
FuncDefPtr->Kind = 'F';
|
|
|
FuncDefPtr->ParamNum = 0;
|
|
|
FuncDefPtr->ARSize = 12;
|
|
|
FuncDefPtr->Declaration = 0;
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(FuncDefPtr);
|
|
|
FuncDefPtr = new FuncSymbol();
|
|
|
FuncDefPtr->Name = string("write");
|
|
|
FuncDefPtr->Type = T_VOID;
|
|
|
FuncDefPtr->Kind = 'F';
|
|
|
FuncDefPtr->ParamNum = 1;
|
|
|
FuncDefPtr->ARSize = 4;
|
|
|
FuncDefPtr->Declaration = 0;
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(FuncDefPtr);
|
|
|
|
|
|
auto *VarDefPtr = new VarSymbol();
|
|
|
VarDefPtr->Name = VarDefPtr->Alias = string("x");
|
|
|
VarDefPtr->Type = T_INT;
|
|
|
VarDefPtr->Kind = 'P';
|
|
|
VarDefPtr->Offset = 4;
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(VarDefPtr);
|
|
|
|
|
|
for (auto a: ExtDefs) {
|
|
|
a->Semantics(Offset);
|
|
|
}
|
|
|
|
|
|
if (!functionCallTable.FuncCalls.empty()) {
|
|
|
for (auto fC: (functionCallTable.FuncCalls))
|
|
|
Errors::ErrorAdd(fC.Line, fC.Column, "调用的函数未定义");
|
|
|
}
|
|
|
|
|
|
DisplaySymbolTable(&SymbolStack);
|
|
|
}
|
|
|
|
|
|
void ExtVarDefAST::Semantics(int &Offset) //外部定义对象的语义
|
|
|
{
|
|
|
int GlobalOffset = 0;
|
|
|
for (auto a: ExtVars)
|
|
|
a->Semantics(Offset, GlobalOffset, Type);
|
|
|
}
|
|
|
|
|
|
void VarDecAST::Semantics(int &Offset, TypeAST *Type) {
|
|
|
if (!SymbolStack.LocateNameCurrent(Name)) //当前作用域未定义，将变量加入符号表
|
|
|
{
|
|
|
VarDefPtr = new VarSymbol();
|
|
|
VarDefPtr->Name = Name;
|
|
|
VarDefPtr->Dims = Dims;
|
|
|
VarDefPtr->isGolbal = 0;
|
|
|
VarDefPtr->Alias = NewAlias();
|
|
|
if (typeid(*Type) == typeid(BasicTypeAST))
|
|
|
VarDefPtr->Type = ((BasicTypeAST *) Type)->Type;
|
|
|
VarDefPtr->Offset = Offset;
|
|
|
|
|
|
if (!Dims.size()) {
|
|
|
VarDefPtr->Kind = 'V';
|
|
|
Offset += TypeWidth[VarDefPtr->Type];
|
|
|
} else {
|
|
|
VarDefPtr->Kind = 'A';
|
|
|
int ans = 1;
|
|
|
for (int i = 0; i < Dims.size(); i++)
|
|
|
ans *= Dims[i];
|
|
|
Offset += ans * TypeWidth[VarDefPtr->Type];
|
|
|
}
|
|
|
|
|
|
if (Exp) //有初值表达式时的处理
|
|
|
{
|
|
|
Exp->Semantics(Offset);
|
|
|
if (Dims.size())
|
|
|
Errors::ErrorAdd(Line, Column, "数组用表达式初始化");
|
|
|
}
|
|
|
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(VarDefPtr);
|
|
|
} else Errors::ErrorAdd(Line, Column, "变量 " + Name + " 重复定义");
|
|
|
}
|
|
|
|
|
|
void VarDecAST::Semantics(int &Offset, int &GolbalOffset, TypeAST *Type) {
|
|
|
if (!SymbolStack.LocateNameCurrent(Name)) //当前作用域未定义，将变量加入符号表
|
|
|
{
|
|
|
VarDefPtr = new VarSymbol();
|
|
|
VarDefPtr->Name = Name;
|
|
|
VarDefPtr->Dims = Dims;
|
|
|
VarDefPtr->isGolbal = 1;
|
|
|
VarDefPtr->Alias = NewAlias();
|
|
|
if (typeid(*Type) == typeid(BasicTypeAST))
|
|
|
VarDefPtr->Type = ((BasicTypeAST *) Type)->Type;
|
|
|
|
|
|
VarDefPtr->Offset = GolbalOffset;
|
|
|
|
|
|
if (!Dims.size()) {
|
|
|
VarDefPtr->Kind = 'V';
|
|
|
GolbalOffset += TypeWidth[VarDefPtr->Type];
|
|
|
} else {
|
|
|
VarDefPtr->Kind = 'A';
|
|
|
int ans = 1;
|
|
|
for (int i = 0; i < Dims.size(); i++)
|
|
|
ans *= Dims[i];
|
|
|
GolbalOffset += ans * TypeWidth[VarDefPtr->Type];
|
|
|
}
|
|
|
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(VarDefPtr);
|
|
|
} else Errors::ErrorAdd(Line, Column, "变量 " + Name + " 重复定义");
|
|
|
}
|
|
|
|
|
|
void DefAST::Semantics(int &Offset) { //依次提取变量符号进行语义分析
|
|
|
for (auto a: LocVars)
|
|
|
a->Semantics(Offset, Type);
|
|
|
}
|
|
|
|
|
|
void BasicTypeAST::Semantics(int &Offset) {
|
|
|
}
|
|
|
|
|
|
void FuncDefAST::Semantics(int &Offset) {
|
|
|
if (!SymbolStack.LocateNameCurrent(Name)) //当前作用域未定义，将变量加入符号表
|
|
|
{
|
|
|
int Offset = 12; //局部变量偏移量初始化,预留12个字节存放返回地址等信息，可根据实际情况修改
|
|
|
MaxVarSize = 12; //计算函数变量需要的最大容量
|
|
|
FuncDefPtr = new FuncSymbol();
|
|
|
FuncDefPtr->Name = Name;
|
|
|
FuncDefPtr->Kind = 'F';
|
|
|
if (typeid(*Type) == typeid(BasicTypeAST)) //处理符号项的返回类型，目前仅基本类型T_CHAR,T_INT,T_FLOAT
|
|
|
FuncDefPtr->Type = ((BasicTypeAST *) Type)->Type;
|
|
|
FuncDefPtr->ParamNum = Params.size();
|
|
|
FuncDefPtr->Params = Params;
|
|
|
|
|
|
if (Body) {
|
|
|
SymbolsInAScope *Local = new SymbolsInAScope(); //生成函数体作用域变量表
|
|
|
FuncDefPtr->ParamPtr = Local; //函数符号表项，指向形参
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(FuncDefPtr);//填写函数符号到符号表
|
|
|
SymbolStack.Symbols.push_back(Local); //函数体符号表（含形参）进栈
|
|
|
for (auto a: Params)
|
|
|
a->Semantics(Offset); //未考虑参数用寄存器，只是简单在AR中分配单元
|
|
|
Body->LocalSymbolTable = Local;
|
|
|
|
|
|
int isReturn = 0;
|
|
|
Body->Semantics(Offset, 0, 0, isReturn,
|
|
|
((BasicTypeAST *) Type)->Type); //对函数中的变量，在AR中接在参数后分配单元
|
|
|
if (isReturn == 0 && ((BasicTypeAST *) Type)->Type != T_VOID)
|
|
|
Errors::ErrorAdd(Line, Column, "函数没有返回语句");
|
|
|
FuncDefPtr->ARSize = MaxVarSize; //函数变量需要空间大小（未考虑临时变量），后续再加临时变量单元得到AR大小
|
|
|
FuncDefPtr->Declaration = 0;
|
|
|
} else {
|
|
|
FuncDefPtr->Declaration = 1;
|
|
|
FuncDefPtr->ARSize = MaxVarSize;
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(FuncDefPtr);//填写函数符号到符号表
|
|
|
}
|
|
|
} else if (((FuncSymbol *) SymbolStack.LocateNameCurrent(Name))->Declaration == 1 && Body) {
|
|
|
int Offset = 12; //局部变量偏移量初始化,预留12个字节存放返回地址等信息，可根据实际情况修改
|
|
|
MaxVarSize = 12; //计算函数变量需要的最大容量
|
|
|
FuncDefPtr = ((FuncSymbol *) SymbolStack.LocateNameCurrent(Name));
|
|
|
if (((BasicTypeAST *) Type)->Type != FuncDefPtr->Type)
|
|
|
Errors::ErrorAdd(Line, Column, "函数声明和定义的返回类型不同");
|
|
|
if (FuncDefPtr->ParamNum != Params.size())
|
|
|
Errors::ErrorAdd(Line, Column, "函数声明和定义的参数数目不同");
|
|
|
|
|
|
auto *Local = new SymbolsInAScope(); //生成函数体作用域变量表
|
|
|
FuncDefPtr->ParamPtr = Local; //函数符号表项，指向形参
|
|
|
SymbolStack.Symbols.push_back(Local); //函数体符号表（含形参）进栈
|
|
|
int i = 0;
|
|
|
for (auto a: Params) {
|
|
|
a->Semantics(Offset); //未考虑参数用寄存器，只是简单在AR中分配单元
|
|
|
auto *param = (ParamAST *) ((FuncDefPtr->Params).at(i++));
|
|
|
if (((BasicTypeAST *) (param->Type))->Type != ((BasicTypeAST *) (a->Type))->Type) {
|
|
|
Errors::ErrorAdd(Line, Column, "函数声明和定义的形参类型不一致 ");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
Body->LocalSymbolTable = Local;
|
|
|
|
|
|
int isReturn = 0;
|
|
|
Body->Semantics(Offset, 0, 0, isReturn, ((BasicTypeAST *) Type)->Type); //对函数中的变量，在AR中接在参数后分配单元
|
|
|
if (isReturn == 0 && ((BasicTypeAST *) Type)->Type != T_VOID)
|
|
|
Errors::ErrorAdd(Line, Column, "函数没有返回语句");
|
|
|
FuncDefPtr->ARSize = MaxVarSize; //函数变量需要空间大小（未考虑临时变量），后续再加临时变量单元得到AR大小
|
|
|
FuncDefPtr->Declaration = 0;
|
|
|
functionCallTable.deleteFuncCalls(Name);
|
|
|
} else Errors::ErrorAdd(Line, Column, "函数 " + Name + " 重复声明或定义");
|
|
|
}
|
|
|
|
|
|
void FuncCallAST::Semantics(int &Offset) {
|
|
|
if (FuncRef = (FuncSymbol *) SymbolStack.LocateNameGlobal(Name)) {
|
|
|
if (FuncRef->Kind != 'F')
|
|
|
Errors::ErrorAdd(Line, Column, "对非函数名采用函数调用形式 ");
|
|
|
else if (FuncRef->ParamNum != Params.size())
|
|
|
Errors::ErrorAdd(Line, Column, "实参表达式个数和形参不一致 ");
|
|
|
else {
|
|
|
int i = 0;
|
|
|
Type = FuncRef->Type;
|
|
|
|
|
|
for (auto a: Params) {
|
|
|
//未考虑参数用寄存器，只是简单在AR中分配单元
|
|
|
a->Semantics(Offset);
|
|
|
if (Name != "write") {
|
|
|
auto *param = (ParamAST *) ((FuncRef->Params).at(i++));
|
|
|
if (((BasicTypeAST *) (param->Type))->Type != a->Type) {
|
|
|
Errors::ErrorAdd(Line, Column, "实参表达式类型和形参不一致 ");
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (FuncRef->Declaration == 1)
|
|
|
functionCallTable.addFuncCalls(Line, Column, Name);
|
|
|
}
|
|
|
} else Errors::ErrorAdd(Line, Column, "引用未定义的函数 " + Name);
|
|
|
}
|
|
|
|
|
|
void ParamAST::Semantics(int &Offset) {
|
|
|
if (!SymbolStack.LocateNameCurrent(ParamName->Name)) //当前作用域未重复定义，将形参名加入符号表
|
|
|
{
|
|
|
auto *SymPtr = new VarSymbol();
|
|
|
SymPtr->Name = ParamName->Name;
|
|
|
SymPtr->Kind = 'P';
|
|
|
SymPtr->Alias = NewAlias();
|
|
|
if (typeid(*Type) == typeid(BasicTypeAST))
|
|
|
SymPtr->Type = ((BasicTypeAST *) Type)->Type;
|
|
|
SymPtr->Offset = Offset;
|
|
|
Offset += TypeWidth[SymPtr->Type];
|
|
|
SymbolStack.Symbols.back()->Symbols.push_back(SymPtr);
|
|
|
} else Errors::ErrorAdd(Line, Column, "形参名 " + ParamName->Name + " 重复定义");
|
|
|
|
|
|
}
|
|
|
|
|
|
/**************语句显示******************************/
|
|
|
void CompStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
if (!LocalSymbolTable) //如果不是函数体的复合语句，需自行生成局部符号表
|
|
|
{
|
|
|
auto *Local = new SymbolsInAScope(); //全局变量的作用域符号表，记录外部变量、函数名
|
|
|
SymbolStack.Symbols.push_back(Local);
|
|
|
LocalSymbolTable = Local; //程序对象挂一个符号表
|
|
|
}
|
|
|
for (auto a: Decls)
|
|
|
a->Semantics(Offset);
|
|
|
if (Offset > MaxVarSize) MaxVarSize = Offset;
|
|
|
for (auto a: Stms) {
|
|
|
int Offset_S = Offset; //前后并列语句可以使用同一片单元，所以取最大值，这里保存起始偏移量
|
|
|
a->Semantics(Offset, canBreak, canContinue, isReturn, returnType);
|
|
|
if (Offset > MaxVarSize) MaxVarSize = Offset;
|
|
|
Offset = Offset_S;
|
|
|
}
|
|
|
cout << "\n\n********************当前复合语句符号表状态**************************" << endl;
|
|
|
DisplaySymbolTable(&SymbolStack);
|
|
|
cout << endl << endl;
|
|
|
SymbolStack.Symbols.pop_back(); //复合语句的符号表退栈
|
|
|
}
|
|
|
|
|
|
void ExprStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
Exp->Semantics(Offset);
|
|
|
}
|
|
|
|
|
|
void IfStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
Cond->Semantics(Offset);
|
|
|
ThenStm->Semantics(Offset, canBreak, canContinue, isReturn, returnType);
|
|
|
}
|
|
|
|
|
|
void IfElseStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
Cond->Semantics(Offset);
|
|
|
ThenStm->Semantics(Offset, canBreak, canContinue, isReturn, returnType);
|
|
|
ElseStm->Semantics(Offset, canBreak, canContinue, isReturn, returnType);
|
|
|
}
|
|
|
|
|
|
void WhileStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
Cond->Semantics(Offset);
|
|
|
Body->Semantics(Offset, 1, 1, isReturn, returnType);
|
|
|
}
|
|
|
|
|
|
void ForStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
SinExp->Semantics(Offset);
|
|
|
Cond->Semantics(Offset);
|
|
|
EndExp->Semantics(Offset);
|
|
|
Body->Semantics(Offset, 1, 1, isReturn, returnType);
|
|
|
}
|
|
|
|
|
|
void CaseStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
Cond->Semantics(Offset);
|
|
|
if (!IsConstValue(Cond))
|
|
|
Errors::ErrorAdd(Line, Column, "case中不是常量");
|
|
|
|
|
|
for (auto a: Body) {
|
|
|
int Offset_S = Offset; //前后并列语句可以使用同一片单元，所以取最大值，这里保存起始偏移量
|
|
|
a->Semantics(Offset, 1, canContinue, isReturn, returnType);
|
|
|
if (Offset > MaxVarSize) MaxVarSize = Offset;
|
|
|
Offset = Offset_S;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SwitchStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
Exp->Semantics(Offset);
|
|
|
for (auto a: Cases)
|
|
|
a->Semantics(Offset, 1, canContinue, isReturn, returnType);
|
|
|
for (auto a: Cases) {
|
|
|
int EqualNum = 0;
|
|
|
for (auto b: Cases) {
|
|
|
if (((ConstAST *) (a->Cond))->ConstVal.constCHAR == ((ConstAST *) (b->Cond))->ConstVal.constCHAR &&
|
|
|
((ConstAST *) (a->Cond))->ConstVal.constFLOAT == ((ConstAST *) (b->Cond))->ConstVal.constFLOAT &&
|
|
|
((ConstAST *) (a->Cond))->ConstVal.constINT == ((ConstAST *) (b->Cond))->ConstVal.constINT)
|
|
|
EqualNum++;
|
|
|
}
|
|
|
if (EqualNum > 1)
|
|
|
Errors::ErrorAdd(Line, Column, "switch语句的key值相等");
|
|
|
}
|
|
|
|
|
|
for (auto a: Default) {
|
|
|
int Offset_S = Offset; //前后并列语句可以使用同一片单元，所以取最大值，这里保存起始偏移量
|
|
|
a->Semantics(Offset, 1, canContinue, isReturn, returnType);
|
|
|
if (Offset > MaxVarSize) MaxVarSize = Offset;
|
|
|
Offset = Offset_S;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void ReturnStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
if (Exp) Exp->Semantics(Offset);
|
|
|
if ((returnType == T_VOID && Exp) || (returnType != T_VOID && !Exp) ||
|
|
|
(returnType != T_VOID && Exp && returnType != Exp->Type))
|
|
|
Errors::ErrorAdd(Line, Column, "函数返回值类型与函数定义的返回值类型不匹配");
|
|
|
isReturn = 1;
|
|
|
}
|
|
|
|
|
|
void BreakStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
if (canBreak == 0)
|
|
|
Errors::ErrorAdd(Line, Column, "break语句不在循环语句或switch语句中");
|
|
|
}
|
|
|
|
|
|
void ContinueStmAST::Semantics(int &Offset, int canBreak, int canContinue, int &isReturn, BasicTypes returnType) {
|
|
|
if (canContinue == 0)
|
|
|
Errors::ErrorAdd(Line, Column, "continue语句不在循环语句中");
|
|
|
}
|
|
|
|
|
|
|
|
|
/**************表达式显示******************************/
|
|
|
void VarAST::Semantics(int &Offset) {
|
|
|
if ((VarRef = (VarSymbol *) SymbolStack.LocateNameGlobal(Name)))
|
|
|
//如果是函数名，报错，
|
|
|
if (VarRef->Kind == 'F')
|
|
|
Errors::ErrorAdd(Line, Column, "对函数名采用非函数调用形式访问 ");
|
|
|
//简单变量则提取变量类型属性
|
|
|
else {
|
|
|
Type = VarRef->Type;
|
|
|
if (VarRef->Kind == 'V' && index.size() > 0)
|
|
|
Errors::ErrorAdd(Line, Column, "对非数组变量采用下标变量的形式访问");
|
|
|
else if (VarRef->Kind == 'A') {
|
|
|
if (index.size() != VarRef->Dims.size())
|
|
|
Errors::ErrorAdd(Line, Column, "数组维数不正确");
|
|
|
for (auto a: index) {
|
|
|
a->Semantics(Offset);
|
|
|
if (a->Type != T_INT)
|
|
|
Errors::ErrorAdd(Line, Column, "数组变量的下标不是整型表达式");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else Errors::ErrorAdd(Line, Column, "引用未定义的符号 " + Name);
|
|
|
|
|
|
}
|
|
|
|
|
|
void ConstAST::Semantics(int &Offset) {
|
|
|
//提取类型属性
|
|
|
}
|
|
|
|
|
|
void AssignAST::Semantics(int &Offset) {
|
|
|
LeftValExp->Semantics(Offset);
|
|
|
if (!IsLeftValue(LeftValExp))
|
|
|
Errors::ErrorAdd(Line, Column, "非左值表达式赋值");
|
|
|
RightValExp->Semantics(Offset);
|
|
|
if (LeftValExp->Type == T_VOID || RightValExp->Type == T_VOID)
|
|
|
Errors::ErrorAdd(Line, Column, "弱类型语言里void类型也不允许赋值");
|
|
|
Type = LeftValExp->Type;
|
|
|
}
|
|
|
|
|
|
void BinaryExprAST::Semantics(int &Offset) {
|
|
|
LeftExp->Semantics(Offset);
|
|
|
RightExp->Semantics(Offset);
|
|
|
if (LeftExp->Type == T_VOID || RightExp->Type == T_VOID)
|
|
|
Errors::ErrorAdd(Line, Column, "弱类型语言里void类型也不允许计算");
|
|
|
|
|
|
if (LeftExp->Type == T_FLOAT || RightExp->Type == T_FLOAT)
|
|
|
Type = T_FLOAT;
|
|
|
else if (LeftExp->Type == T_INT || RightExp->Type == T_INT)
|
|
|
Type = T_INT;
|
|
|
else if (LeftExp->Type == T_CHAR && RightExp->Type == T_CHAR)
|
|
|
Type = T_CHAR;
|
|
|
//根据左右值类型，判断是否能进行运算，并确定运算结果类型
|
|
|
}
|
|
|
|
|
|
void UnaryExprAST::Semantics(int &Offset) {
|
|
|
Exp->Semantics(Offset);
|
|
|
if (!IsLeftValue(Exp) && (Op != UPLUS && Op != UMINUS && Op != NOT))
|
|
|
Errors::ErrorAdd(Line, Column, "非左值表达式自增、自减");
|
|
|
Type = Exp->Type;
|
|
|
}
|
