各函数伪代码

1.1各函数伪代码

1.1.1 辅助函数

1.1.1.1 字符串转整型

int str2int(string str){
   int res=0;
   int len=str.length();
   for(int i=0;i<len;i++){
       res=res*10;
       res+=str[i]-'0';
   }
   return res;
}

1.1.1.2 字符串转浮点型

float str2float(string str){
   float res=0;
   int len=str.length();
   int loc=str.find('.');
   for(int i=0;i<loc;i++){
       res*=10;
       res+=str[i]-'0';
   }
   float base=1;
   for(int i=loc+1;i<len;i++){
       base=base*0.1;
       res+=base*(str[i]-'0');
   }
   return res;
}

1.1.2 转化为AST的函数

这一部分函数在实现的时候，必须参照文法的设计，才能搞清楚普通语法分析树每个节点是什么，每个节点有哪些孩子，这些孩子之间按照什么顺序排列。
且为了方便DEBUG，检测程序编写错误，每个函数在一开始都要检查当前的普通语法分析树节点是否是需要的那类节点。例如getIdList函数需要检查Type*节点的记号是否是”idlist”。

1.1.2.1 获取标识符列表

void getIdList(Type *now,vector< pair<string,int> >& res,bool reverseFlag){
   if(now->token!="idlist"){
       cout << "getIdList error" << endl;
       return;
   }
   if(是产生式（4.1）){
       res中加入当前id及其行号;
       getIdList(now->children[0],res,reverseFlag);//递归调用获取下一个id
   }
   else{//产生式（4.2）
       res中加入当前id及其行号;
        if(reverseFlag)
            res反转;
   }
}

1.1.2.2 获取数组上下界列表

void getArrayRangeList(Type *now,vector< pair<int,int> >& _arrayRangeList){
   if(now->token!="period"){
       cout << "getArrayRangeList error" << endl;
       return;
   }
   _arrayRangeList中加入当前维上下界;
   if(是产生式（11.1）)
       递归调用getArrayRangeList获取数组的下一维上下界;
   else//产生式（11.2）
       _arrayRangeList反转;
}

1.1.2.3 获取类型

_Type* getType(Type *now){
   if(now->token!="type"){
       cout << "getType error" << endl;
       return NULL;
   }
   _Type* _type = new _Type;//新建一个_Type节点
   _type中加入基本类型及其行号;
   if(是产生式10.2){
       _type标记为数组类型;
       调用getArrayRangeList获取数组上下界
   }
   else//产生式10.1
       _type标记为非数组类型;
   return _type;
}

1.1.2.4 获取变量定义

void getVariant(Type *now,vector<_Variant*>& _variantList){
   if(now->token!="var_declaration"){
       cout << "getVariant error" << endl;
       return;
   }
   vector< pair<string,int> > _idList;
   调用getIdList获取_idList;//不反转
   _Type *_type=调用getType获取变量类型;
   遍历_idList
       新建变量节点，加入id和类型信息，并添加到_variantList中;
   if(是产生式9.1)
       调用getVariant获取下一段变量定义;
   else//产生式9.2
       _variantList反转;
}

1.1.2.5 获取变量定义列表

void getVariantList(Type *now,vector<_Variant*>& _variantList){
   if(now->token!="var_declarations"){
       cout << "getVariantList error" << endl;
       return;
   }
   if(是产生式8.1)
       调用getVariant获取变量定义列表;
}

1.1.2.6 获取常量定义节点具体信息

void setConst(Type *now,_Constant* &_constant){//pascal在定义常量时，并没有指定常量的类型，所以需要自行判断
   if(now->token!="const_value"){
       cout << "setConst error" << endl;
       return;
   }
   if(是产生式7.1或7.2或7.3){
       _constant类型标记为"id"，即由别的常量标识符定义其取值;
       _constant添加id及其行号;
        _constant添加定义其取值的常量标识符;
       if(是产生式7.2)
            _constant标记出现了负号;
   }
   else if(是产生式7.4或7.5或7.6){
       _constant类型标记为"integer";
       _constant->intValue=str2int(字符串表示的无符号整数);
        _constant->strOfVal=字符串表示的无符号整数;
       if(是产生式7.5)
            _constant标记出现了负号;
   }
   else if(是产生式7.7或7.8或7.9){
       _constant类型标记为"real";
       _constant->realValue=str2float(字符串表示的无符号浮点数);
        _constant->strOfVal=字符串表示的无符号浮点数;
       if(是产生式7.8)
            _constant标记出现了负号;
   }
   else if(是产生式7.10){
       _constant类型标记为"char";
       _constant->charValue=字符常量;
        _constant->strOfVal=now->字符常量;
   }
   else{
       cout << "setConst error" << endl;
   }
}

1.1.2.7 获取常量定义节点

void getConst(Type *now,vector<_Constant*>& _constantList){
   if(now->token!="const_declaration"){
       cout << "getConst error" << endl;
       return;
   }
   _Constant* _constant=new _Constant;
   _constant添加id及其行号;
   调用setConst获取_constant的剩余信息;
   _constant添加到_constantList中;
   if(是产生式6.1)
       调用getConst获取下一个常量定义;
   else
       _constantList反转;
}

1.1.2.8 获取常量定义节点列表

void getConstList(Type *now,vector<_Constant*>& _constantList){
   if(now->token!="const_declarations"){
       cout << "getConstList error" << endl;
       return;
   }
   if(是产生式5.1)
       调用getConst获取常量定义列表;
}

1.1.2.9 获取形式参数的具体信息

void getValueParameter(Type *now,vector<_FormalParameter*>& _formalParaList,int flag){
   if(now->token!="value_parameter"){
       cout << "getValueParameter error" << endl;
       return;
    }
   vector< pair<string,int> > _idList;
   调用getIdList获取_idList;//不反转
   遍历idList
       新建一个形参节点类，添加id，类型，传值参数还是引用参数等信息，并添加到_formalParaList中;
}

1.1.2.10 区别形式参数

void getParameter(Type *now,vector<_FormalParameter*>& _formalParaList){
   if(now->token!="parameter"){
       cout << "getParameter error" << endl;
       return;
   }
   if(是产生式17.1)//引用参数
       调用getValueParameter获取引用参数列表，调用时表明是引用参数;
   else if(是产生式17.2)//传值参数
       调用getValueParameter获取传值参数列表，调用时表明是传值参数;
   else
       cout << "getParameter error" << endl;
}

1.1.2.11 获取形式参数

void getFormalParameter(Type *now,vector<_FormalParameter*>& _formalParaList){
   if(now->token!="parameter_list"){
       cout << "getFormalParameter error" << endl;
       return;
   }
   调用getParameter获取当前这一段形式参数列表;
   if(是产生式16.1)
       调用getFormalParameter获取下一段形式参数列表;
   else//产生式16.2
       _formalParaList反转;
}

1.1.2.12 获取形式参数节点列表

void getFormalParaList(Type *now,vector<_FormalParameter*>& _formalParaList){
   if(now->token!="formal_parameter"){
       cout << "getFormalParaList error" << endl;
       return;
   }
   if(是产生式15.1)
       调用getFormalParameter形式参数列表;
}

1.1.2.13 获取子程序头

void getSubprogramHead(Type *now,pair<string,int>& functionID,vector<_FormalParameter*>& _formalParaList,pair<string,int> &_type){
   if(now->token!="subprogram_head"){
       cout << "getSubprogramHead error" << endl;
       return;
   }
   获取子程序名及其行号赋值给functionID;
   调用getFormalParaList获取形式参数列表;
   if (是产生式14.2) //表示函数
        _type=获取返回值类型及其行号;
   else //产生式14.1 表示过程
        _type=空;//表示没有返回值
}

1.1.2.14 获取factor

//"var"表示变量,"integer"表示整数,"real"表示浮点数,"char"表示字符常量
//"function"表示函数调用,"compound"表示复合表达式
//compound有普通的二目运算符，还有minus、not、bracket等单目运算符
_Expression* getFactor(Type *now){
   if(now->token!="factor"){
       cout << "getFactor error" << endl;
        return NULL;
   }
   _Expression* _expression = new_Expression;
   if(是产生式32.1){
       _expression类型标记为"integer";
        _expression->strOfNum=字符串表示的无符号整数;
       _expression->intNum=str2int(字符串表示的无符号整数);
       所在行号=整数所在行号;
   }
   else if(是产生式32.2){
       _expression类型标记为"real";
        _expression->strOfNum=字符串表示的无符号浮点数;
       _expression->realNum=str2int(字符串表示的无符号浮点数);
       所在行号=浮点数所在行号;
   }
   else if(是产生式32.3){
       _expression类型标记为"var";
       调用getVariantReference获取变量引用节点;
        所在行号=变量引用所在行号;
   }
   else if(是产生式32.4){
       _expression类型标记为"function";
       新建一个_FunctionCall节点;
       获取函数名及其行号;
       调用getExpressionList获取函数调用的实参表达式列表;
        所在行号=函数名所在行号;
   }
   else if(是产生式32.5){
       _expression类型标记为"compound";
       运算符="bracket";//在表达式两边添加括号
        运算符类型="single";//单目运算符
       调用getExpression获取操作数表达式;
        所在行号=操作数表达式所在行号;
   }
   else if(是产生式32.6){
       _expression类型标记为"compound";
       运算符="not";//取非
        运算符类型="single";//单目运算符
       调用getFactor获取操作数表达式;
        所在行号=操作数表达式所在行号;
   }
   else if(是产生式32.7){
       _expression类型标记为"compound";
       运算符="minus";//取相反数
        运算符类型="single"; //单目运算符
       调用getFactor获取操作数表达式;
        所在行号=操作数表达式所在行号;
   }
    else if (是产生式32.8) {
        _expression类型标记为"char";
        _expression->charVal=字符常量;
        所在行号=字符常量所在行号;
    }
   else{
       cout << "getFactor error" << endl;
       return NULL;
   }
   return _expression;
}

1.1.2.15 获取term

_Expression* getTerm(Type *now){
   if(now->token!="term"){
       cout << "term" << endl;
        return NULL;
   }
   _Expression* _expression=NULL;
   if(是产生式31.1){
       _expression = new_Expression;
       _expression类型标记为"compound";
       获取运算符;
       运算符类型="mulop";
       调用getTerm获取左操作数表达式;
       调用getFactor获取右操作数表达式;
        所在行号=左操作数表达式所在行号;
   }
   else //是产生式31.2
       _expression=调用getFactor获取表达式;
   return _expression;
}

1.1.2.16 获取simple expression

_Expression* getSimpleExpression(Type *now){
   if(now->token!="simple_expression"){
       cout << "getSimpleExpression error" << endl;
        return NULL;
   }
   _Expression* _expression=NULL;
   if(是产生式30.1){
       _expression = new_Expression;
       _expression类型标记为"compound";
       获取运算符;
        运算符类型="addop";
       调用getSimpleExpression获取左操作数表达式;
       调用getTerm获取右操作数表达式;
        所在行号=左操作数表达式所在行号;
   }
   else //是产生式30.2
       _expression=调用getTerm获取表达式;
   return _expression;
}

1.1.2.17 获取expression

_Expression* getExpression(Type *now){
   if(now->token!="expression"){
       cout << "getExpression error" << endl;
        return NULL;
   }
   _Expression* _expression=NULL;
   if(是产生式29.1或29.2){
       _expression = new_Expression;
       _expression类型标记为="compound";
       获取运算符;
       运算符类型="relop";
       调用getSimpleExpression获取左操作数表达式;
       调用getSimpleExpression获取右操作数表达式;
        _expression->lineNumber=左操作数表达式所在行号
   }
   else
       _expression=getSimpleExpression(now->children[0]);
   return _expression;
}

1.1.2.18 获取表达式列表

void getExpressionList(Type *now,vector<_Expression*>& _expressionList){
   if(now->token!="expression_list"){
       cout << "getExpressionList error" << endl;
       return;
   }
   获取当前表达式，添加到_expressionList中;
   if(是产生式28.1)
       调用getExpressionList获取下一个表达式;
   else//产生式28.2
       _expressionList反转;
}

1.1.2.19 获取变量引用节点

void getVariantReferenceList(Type *now,vector<_Expression*>& _expressionList){
   if(now->token!="id_varpart"){
       cout << "getVariantReferenceList error" << endl;
       return;
   }
   if(是产生式26.1)
       调用getExpressionList获取数组下标表达式列表;
}

1.1.2.20 获取变量引用节点列表

_VariantReference* getVariantReference(Type *now){
   if(now->token!="variable"){
       cout << "getVariantReference error" << endl;
        return NULL;
   }
   _VariantReference* _variantReference = new _VariantReference;
   获取id及其行号;
   调用getVariantReferenceList获取数组下标表达式列表;
    if (下标表达式列表不为空)
        标记为数组;
    else
        标记为非数组;
   return _variantReference;
}

1.1.2.21 获取else部分语句

_Statement* getElseStatement(Type *now){
   if(now->token!="else_part"){
       cout << "getElseStatement error" << endl;
       return NULL;
   }
   if(是产生式24.2)
       return NULL;
   //产生式24.1
   return 调用getStatement获取else部分语句;
}

1.1.2.22 获取过程调用

_Statement* getProcedureCall(Type *now) {
    if (now->token != "procedure_call") {
        cout << "getProcedureCall error" << endl;
        return NULL;
    }
    _ProcedureCall *_procedureCall = new_ProcedureCall;
    获取过程调用所在行号;
    _procedureCall类型标记为"procedure";
    获取过程id及其行号;
    if (是产生式27.2)
        调用getExpressionList获取过程调用实参表达式列表;
    return _procedureCall;
}

1.1.2.23 获取各种类型的语句

_Statement* getStatement(Type *now){
   if(now->token!="statement"){
       cout << "getStatement error" << endl;
       return NULL;
   }
    if (是产生式23.8)
        return NULL;
   if(是产生式23.1){
       _AssignStatement *_assignStatement = new _AssignStatement;
        获取赋值语句所在行号;
       _assignStatement类型标记为"assign";
       获取左值变量引用;
       获取右值表达式;
       return _assignStatement;
   }
   else if(是产生式23.2)
        return 调用getProcedureCall获取过程调用语句;
   else if(是产生式23.3)
        return 调用getCompoundStatement获取复合语句块;
   else if(是产生式23.4){
       _IfStatement* _ifStatement = new_IfStatement;
        获取if语句所在行号;
       _ifStatement类型标记为"if";
       调用getExpression获取condition表达式;
       调用getStatement获取then语句;
       调用getElseStatement获取else语句;
       return _ifStatement;
   }
   else if(是产生式23.5){
       _ForStatement* _forStatement = new_ForStatement;
        获取for语句所在行号;
       _forStatement类型标记为"for";
        获取循环变量id;
       调用getExpression获取初值表达式;
       调用getExpression获取终值表达式;
       调用getStatement获取循环体语句;
       return _forStatement;
   }
   else if(是产生式23.6){
       _WhileStatement* _whileStatement = new _WhileStatement;
        获取while语句所在行号;
       _whileStatement类型标记为"while";
       调用getExpression获取condition表达式;
       调用getStatement获取循环体语句;
       return _whileStatement;
   }
   else if(是产生式23.7){
        _RepeatStatement* _repeatStatement = new _RepeatStatement;
        获取repeat语句所在行号;
       _repeatStatement类型标记为"repeat";
       调用getExpression获取condition表达式;
       调用getStatement获取循环体语句;
       return _repeatStatement;
   }
   else{
       cout << "[getStatement] statement token error" << endl;
       return NULL;
   }
}

1.1.2.24 获取语句列表

void getStatementList(Type *now,vector<_Statement*>& _statementList){
   if(now->token!="statement_list"){
       cout << "getStatementList error" << endl;
       return;
   }
    调用getStatement获取当前语句;
    if(获取的语句不为空)
        将获取的语句添加到_statementList中;
   if(是产生式22.1)
       调用getStatementList获取下一条语句;
   else
       _statementList列表翻转;
}

1.1.2.25 获取复合语句块

_Compound* getCompoundStatement(Type *now){
   if(now->token!="compound_statement"){
       cout << "getCompoundStatement error" << endl;
       return NULL;
   }
    _Compound *_compound = new_Compound;
    获取compound语句所在行号;
    _compound类型标记为"compound";
   调用getStatementList获取复合语句块的语句列表;
   return _compound;
}

1.1.2.26 获取子程序体

void getSubprogramBody(Type *now,vector<_Constant*>& _constList,vector<_Variant*>& _variantList,_Compound* &_compound){
   if(now->token!="subprogram_body"){
       cout << "getSubprogramBody error" <<endl;
       return;
   }
   调用getConstList获取常量定义列表;
   调用getVariantList获取变量定义列表;
    调用getCompoundStatement复合语句块;
}

1.1.2.27 获取函数定义

_FunctionDefinition* getSubprogramDefinition(Type *now){
   if(now->token!="subprogram"){
       cout << "getSubprogramDefinition error" << endl;
       return NULL;
   }
   _FunctionDefinition *_functionDefinition=new _FunctionDefinition;
   调用getSubprogramHead获取子程序定义头;
   调用getSubprogramBody获取子程序定义体;
   return _functionDefinition;
}

1.1.2.28 获取子程序定义列表

void getSubprogramDefinitionList(Type *now,vector<_FunctionDefinition*>& _subprogramDefinitionList){
   if(now->token!="subprogram_declarations"){
       cout << "getSubprogramDefinitionList error" << endl;
       return;
   }
    if (是产生式12.1) {
       调用getSubprogramDefinition获取子程序定义,并添加到子程序定义列表中;
        调用getSubprogramDefinitionList获取下一个子程序定义;
    }
   else //产生式12.2
       _subprogramDefinitionList反转;
}

1.1.2.29 获取主程序体

_SubProgram* getProgramBody(Type *now){
   if(now->token!="program_body"){
       cout << "getProgramBody error" << endl;
       return NULL;
   }
   _SubProgram *_subProgram=new_SubProgram;
   调用getConstList获取常量定义列表;
   调用getVariantList获取变量定义列表;
   调用getSubprogramDefinitionList获取子程序定义列表;
    调用getCompoundStatement获取主程序体;
   return _subProgram;
}

1.1.2.30 获取主程序头

void getProgramHead(Type *now,pair<string,int>& _programId,vector< pair<string,int> >& _paraList){
   if(now->token!="program_head"){
       cout << "getProgramHead error" << endl;
       return; 
   }
   获取主程序id及其行号;
   调用getIdList获取主程序参数列表;//反转
}

1.1.2.31 获取整个程序

_Program* getProgram(Type *now){
   if(now->token!="programstruct"){
       cout << "getProgram error" << endl;
       return NULL;
   }
   _Program* ASTRoot=new _Program;
   调用getProgramHead获取主程序头;
   调用getProgramBody获取主程序体;
   return ASTRoot;
}