/* term → factor more_factor * factor→+factor |-factor|number|identifier more_identifier|(expr)|"string"|'char' * more_factor→ε|mul_op factor more_factor * mul_op → *|/ * 如法炮制 */ public static Value eval_term(NonterminalStackElement term_node, List <Dictionary <string, Value> > bindings_stack) { NonterminalStackElement factor_node = (NonterminalStackElement)term_node.branches[0]; NonterminalStackElement more_factor_node; more_factor_node = (NonterminalStackElement)term_node.branches[1]; Value first_factor_value = eval_factor(factor_node, bindings_stack); //more_factor → ε while (more_factor_node.branches.Count == 3) { NonterminalStackElement mul_op_node = (NonterminalStackElement)more_factor_node.branches[0]; OtherTerminalStackElement mul_op = (OtherTerminalStackElement)mul_op_node.branches[0]; NonterminalStackElement second_factor_node = (NonterminalStackElement)more_factor_node.branches[1]; Value second_factor_value = eval_factor(second_factor_node, bindings_stack); if (Value.computable_types.Contains(first_factor_value.type) && Value.computable_types.Contains(second_factor_value.type)) { first_factor_value = first_factor_value.mathCalculate(second_factor_value, mul_op.content); } else { throw new ExecutorException("无法直接进行乘除运算的类型", mul_op.linenum); } more_factor_node = (NonterminalStackElement)more_factor_node.branches[2]; } return(first_factor_value); }
//当该节点为declare_stmt时进入这个函数,把变量添加到符号表bindings //可能一个declare语句会声明很多个变量,这些变量可能是数组也可能不是,这些变量可能被赋值也可能没有 // declare_stmt→type declaratee_lst; public static void declareVaraible(NonterminalStackElement declarate_stmt, List <Dictionary <string, Value> > bindings_stack) { if (declarate_stmt.branches.Count == 3) { NonterminalStackElement type_nonterminal = (NonterminalStackElement)declarate_stmt.branches[0]; OtherTerminalStackElement type_node = (OtherTerminalStackElement)type_nonterminal.branches[0]; //获得变量类型 string type = type_node.content; //声明的所有变量名 List <NonterminalStackElement> declaratees = new List <NonterminalStackElement>(); //有两种可能:declaratee_lst→declaratee,declaratee_lst|declaratee NonterminalStackElement declaratee_lst_node = (NonterminalStackElement)declarate_stmt.branches[1]; //处理递归,把每个declaratee加到declaratees while (declaratee_lst_node.branches.Count != 1) { NonterminalStackElement first_declaratee_node = (NonterminalStackElement)declaratee_lst_node.branches[0]; declaratees.Add(first_declaratee_node); declaratee_lst_node = (NonterminalStackElement)declaratee_lst_node.branches[2]; } NonterminalStackElement declaratee_node = (NonterminalStackElement)declaratee_lst_node.branches[0]; declaratees.Add(declaratee_node); //现在已经获取到的东西有:变量类型(暂时未区分数组),声明的变量个数,所有的declaratees //还缺少:初始化所有变量 initialize_declaratees(type, declaratees, bindings_stack); } else { throw new ExecutorException("语法树的declare_stmt应该有且只有三个子结点"); } }
//logical_expr→relational_expr logical_expr_more // logical_expr_more→ ε | logical_op relational_expr logical_expr_more public static Value eval_logical_expr(NonterminalStackElement logical_expr_node, List <Dictionary <string, Value> > bindings_stack) { if (logical_expr_node.branches.Count != 2) { throw new ExecutorException("文法发生了变化", logical_expr_node.linenum); } else { NonterminalStackElement relational_expr_node = (NonterminalStackElement)logical_expr_node.branches[0]; NonterminalStackElement logical_expr_more_node = (NonterminalStackElement)logical_expr_node.branches[1]; Value first_relational_expr_value = eval_relational_expr(relational_expr_node, bindings_stack); //逐个迭代,很自然的左结合 while (logical_expr_more_node.branches.Count == 3) { NonterminalStackElement logical_op_node = (NonterminalStackElement)logical_expr_more_node.branches[0]; NonterminalStackElement second_relational_expr_node = (NonterminalStackElement)logical_expr_more_node.branches[1]; OtherTerminalStackElement logical_op = (OtherTerminalStackElement)logical_op_node.branches[0]; if (logical_op.content == "&&") { //short circuit evaluation短路求值 if (!first_relational_expr_value.getBoolean()) { return(new BoolValue("bool", true, false, logical_op.linenum)); } //短路求值! Value second_relational_expr_value = eval_relational_expr(second_relational_expr_node, bindings_stack); first_relational_expr_value = new BoolValue("bool", true, second_relational_expr_value.getBoolean(), logical_op.linenum); } else { //short circuit evaluation短路求值 if (first_relational_expr_value.getBoolean()) { return(new BoolValue("bool", true, true, logical_op.linenum)); } //短路求值! Value second_relational_expr_value = eval_relational_expr(second_relational_expr_node, bindings_stack); first_relational_expr_value = new BoolValue("bool", true, second_relational_expr_value.getBoolean(), logical_op.linenum); } logical_expr_more_node = (NonterminalStackElement)logical_expr_more_node.branches[2]; } return(first_relational_expr_value); } }
//relational_expr→simple_expr relational_expr_more 返回一个value,这个value是truthy还是falsey交给上层函数 // relational_expr_more →ε | comparasion_op simple_expr relational_expr_more //这里只要进行了compare,那返回int value而不是其他的,其原因是:3>2>1 -> false public static Value eval_relational_expr(NonterminalStackElement relational_expr_node, List <Dictionary <string, Value> > bindings_stack) { NonterminalStackElement simple_expr_node = (NonterminalStackElement)relational_expr_node.branches[0]; NonterminalStackElement relational_expr_more_node = (NonterminalStackElement)relational_expr_node.branches[1]; //这里面临一个问题,如果comparison是==或者空,那么simple_expr什么都可以,如果comparison是> <=等等,那就只能是number Value first_simple_expr_value = eval_simple_expr(simple_expr_node, bindings_stack); while (relational_expr_more_node.branches.Count == 3) { NonterminalStackElement comparison_op_node = (NonterminalStackElement)relational_expr_more_node.branches[0]; NonterminalStackElement second_simple_expr = (NonterminalStackElement)relational_expr_more_node.branches[1]; relational_expr_more_node = (NonterminalStackElement)relational_expr_more_node.branches[2]; OtherTerminalStackElement comparison_op = (OtherTerminalStackElement)comparison_op_node.branches[0]; if (comparison_op.content == "==") { first_simple_expr_value = first_simple_expr_value.compareWith(eval_simple_expr(second_simple_expr, bindings_stack)); } //这里相对上面是反过来的(不等于) else if (comparison_op.content == "!=" || comparison_op.content == "<>") { IntValue result = first_simple_expr_value.compareWith(eval_simple_expr(second_simple_expr, bindings_stack)); if (result.value == 0) { result.value = 1; } else { result.value = 0; } first_simple_expr_value = result; } else { first_simple_expr_value = first_simple_expr_value.compareWith(eval_simple_expr(second_simple_expr, bindings_stack), comparison_op.content); } } return(first_simple_expr_value); }
/* Function: 返回type类型的Value * 若不能返回type类型的Value,那么就报错 * 注意:要区分负数,把负数放到value里面返回 * 引入type的原因:real i = 1 + 2; 在evaluate这个expr时,我们不知道到底是int还是real * 相关的产生式: * simple_expr→term more_term * term→factor more_factor * more_term→ε|add_op term more_term * add_op→+|- */ public static Value eval_simple_expr(NonterminalStackElement simple_expr_node, List <Dictionary <string, Value> > bindings_stack) { NonterminalStackElement term_node = (NonterminalStackElement)simple_expr_node.branches[0]; NonterminalStackElement more_term_node = (NonterminalStackElement)simple_expr_node.branches[1]; Value first_term_value = eval_term(term_node, bindings_stack); while (more_term_node.branches.Count == 3) { NonterminalStackElement add_op_node = (NonterminalStackElement)more_term_node.branches[0]; OtherTerminalStackElement add_op = (OtherTerminalStackElement)add_op_node.branches[0]; NonterminalStackElement second_term_node = (NonterminalStackElement)more_term_node.branches[1]; Value second_term_value = eval_term(second_term_node, bindings_stack); if (Value.computable_types.Contains(first_term_value.type) && Value.computable_types.Contains(second_term_value.type)) { first_term_value = first_term_value.mathCalculate(second_term_value, add_op.content); } else { throw new ExecutorException("无法直接进行加减运算的类型", add_op.linenum); } more_term_node = (NonterminalStackElement)more_term_node.branches[2]; } return(first_term_value); }
//这里情况就不同了,上面是对应着+-*/四则运算的,所以char/string/数组 都不应该直接进行这些运算,但是他们可以被访问赋值,因此这里不做过多限制 /* * factor→+factor |-factor|number|identifier more_identifier|(expr)|"string"|'char' * more_identifier→ ε | [simple_expr] | () | (param_values) * number→real_number |integer */ public static Value eval_factor(NonterminalStackElement factor_node, List <Dictionary <string, Value> > bindings_stack) { StackElement first_child = (StackElement)factor_node.branches[0]; //factor → number | "string" | 'char' if (factor_node.branches.Count == 1) { //char if (first_child.type_code == 7) { CharStackElement char_node = (CharStackElement)first_child; return(new CharValue("char", true, char_node.content, char_node.linenum)); } //string else if (first_child.type_code == 8) { StringStackElement string_node = (StringStackElement)first_child; return(new StringValue("string", true, string_node.content, string_node.linenum)); } //number else if (first_child.type_code == 3) { NonterminalStackElement number_node = (NonterminalStackElement)first_child; return(eval_number(number_node)); } else { throw new ExecutorException("eval_factor运行中发现factor文法发生了意想不到的变化"); } } //factor→+factor |-factor | identifier more_identifier else if (factor_node.branches.Count == 2) { //+ - factor if (first_child.type_code == 4) { int linenum = ((OtherTerminalStackElement)first_child).linenum; OtherTerminalStackElement positive_or_negative = (OtherTerminalStackElement)first_child; NonterminalStackElement child_factor_node = (NonterminalStackElement)factor_node.branches[1]; if (positive_or_negative.content == "+") { return(eval_factor(child_factor_node, bindings_stack)); } //负号就要把值的符号颠倒 else { Value child_factor_node_value = eval_factor(child_factor_node, bindings_stack); if (!Value.computable_types.Contains(child_factor_node_value.type)) { throw new ExecutorException("不可在非数值类型前加上正号或者负号", linenum); } if (child_factor_node_value.type == "real") { RealValue value = (RealValue)child_factor_node_value; value.value = -value.value; return(value); } else if (child_factor_node_value.type == "int") { IntValue value = (IntValue)child_factor_node_value; value.value = -value.value; return(value); } else if (child_factor_node_value.type == "number") { NumberValue value = (NumberValue)child_factor_node_value; value.value = -value.value; return(value); } else { throw new ExecutorException("eval_factor运行中发现factor文法发生了意想不到的变化"); } } } //factor→ identifier more_identifier // more_identifier→ε | [simple_expr] | () | (param_values) else { IdentifierStackElement identifier_node = (IdentifierStackElement)factor_node.branches[0]; int linenum = identifier_node.linenum; NonterminalStackElement more_identifier_node = (NonterminalStackElement)factor_node.branches[1]; //检查是否定义 Dictionary <string, Value> bindings = ExecutorTools.findBindings(bindings_stack, identifier_node.content); if (bindings != null) { //只是访问一个identifier 即 factor→ identifier // more_identifier→ε if (more_identifier_node.branches.Count == 0) { Value identifier_value = bindings[identifier_node.content]; return(identifier_value); } //应该是调用了一个不接受任何参数的函数比如foo()这样, more_identifier→ () else if (more_identifier_node.branches.Count == 2) { Value identifier_value = bindings[identifier_node.content]; if (identifier_value.type != "func") { throw new ExecutorException("标识符后带()应该是调用函数,但该标识符" + identifier_node.content + "对应函数并不存在", linenum); } FuncValue relevant_fucntion = (FuncValue)identifier_value; Value return_value = relevant_fucntion.executeFunction(); return(return_value); } // 应该是调用了一个带参数的函数,或者是访问数组的某个元素 more_identifier → [simple_expr] | (param_values) else if (more_identifier_node.branches.Count == 3) { Value identifier_value = bindings[identifier_node.content]; NonterminalStackElement second_element = (NonterminalStackElement)more_identifier_node.branches[1]; // more_identifier → [simple_expr] 要检查:第一,数组访问越界了没有;第二,访问的数组元素类型是否与要求的类型type相符合 if (second_element.name == "simple_expr") { //类型错误 if (!identifier_value.type.Contains("Array")) { throw new ExecutorException("标识符后带[ ]应该是访问数组某个元素,但该标识符" + identifier_node.content + "对应的并不是数组", linenum); } string array_type = identifier_value.type.Substring(0, identifier_value.type.Length - 5); NonterminalStackElement simple_expr_node = second_element; int index_to_access = ExecutorTools.get_array_len_from_simple_expr(simple_expr_node, bindings_stack); //越界错误 if (index_to_access >= identifier_value.getArrayLen()) { throw new ExecutorException("访问数组" + identifier_node.content + "时出现越界访问错误,数组长度只有" + identifier_value.getArrayLen(), linenum); } //eval要求就是获取到值,所以这里直接获取数组中元素的值,再转换为Value类型 else { if (identifier_value.type.Contains("int")) { return(new IntValue("int", false, identifier_value.getIntArrayElement(index_to_access).ToString(), linenum)); } else if (identifier_value.type.Contains("real")) { return(new RealValue("real", false, identifier_value.getRealArrayElement(index_to_access).ToString(), linenum)); } else if (identifier_value.type.Contains("int")) { return(new CharValue("char", false, identifier_value.getCharArrayElement(index_to_access).ToString(), linenum)); } else { return(new StringValue("string", false, identifier_value.getStringArrayElement(index_to_access).ToString(), linenum)); } } } // more_identifier → (param_values) 要检查:第一,函数签名是否符合(类型,次序);第二,函数返回类型是否与要求的类型type相符合 else if (second_element.name == "param_values") { //类型错误 if (!identifier_value.type.Contains("func")) { throw new ExecutorException(identifier_node.content + "对应的并不是函数,无法调用", linenum); } FuncValue func_value = (FuncValue)identifier_value; List <Value> args = new List <Value>(); NonterminalStackElement expr_node; //param_values →expr,param_values|expr NonterminalStackElement param_values_node = second_element; while (param_values_node.branches.Count == 3) { expr_node = (NonterminalStackElement)param_values_node.branches[0]; param_values_node = (NonterminalStackElement)param_values_node.branches[2]; args.Add(eval_expr(expr_node, bindings_stack)); } expr_node = (NonterminalStackElement)param_values_node.branches[0]; args.Add(eval_expr(expr_node, bindings_stack)); return(ExecutorTools.executeFunction(func_value, args, linenum)); } else { throw new ExecutorException("文法发生了变化", linenum); } } else { //Value relevant_value = Frame.curr_frame.local_bindings[identifier_node.content]; throw new ExecutorException("怎么到这的?", linenum); } } throw new ExecutorException("语句中访问未定义的标识符" + identifier_node.content, linenum); } } //factor→ ( expr ) else if (factor_node.branches.Count == 3) { NonterminalStackElement expr_node = (NonterminalStackElement)factor_node.branches[1]; return(eval_expr(expr_node, bindings_stack)); } else { throw new ExecutorException("文法发生了变化", factor_node.linenum); } }
public override string ToString() { string text = ""; if (type_code == 1) { IdentifierStackElement e = (IdentifierStackElement)this; text += "第" + e.linenum + "行标识符"; text += e.content; } else if (type_code == 2) { IntStackElement e = (IntStackElement)this; text += "第" + e.linenum + "行整数"; text += e.content; } else if (type_code == 3) { NonterminalStackElement e = (NonterminalStackElement)this; text += "非终结符"; text += e.name; //递归调用 foreach (StackElement s in e.branches) { text += Environment.NewLine; for (int i = 1; i < s.layers; i++) { text += " "; } text += s.ToString(); } } else if (type_code == 4) { OtherTerminalStackElement e = (OtherTerminalStackElement)this; text += "第" + e.linenum + "行终结符"; text += e.content; } else if (type_code == 5) { RealStackElement e = (RealStackElement)this; text += "第" + e.linenum + "行实数"; text += e.content; } else if (type_code == 7) { CharStackElement e = (CharStackElement)this; text += "第" + e.linenum + "行字符"; text += e.content; } else if (type_code == 8) { StringStackElement e = (StringStackElement)this; text += "第" + e.linenum + "行字符串"; text += e.content; } else { StateStackElement e = (StateStackElement)this; text += "状态" + e.state; } return(text); }
//执行函数(传入参数,返回类型等等) //注意创建一个新的bindings和Stack,且这个Stack目前只有globalBingdings->newBindings //可能return null-->(仅在void函数中可能) public static Value executeFunction(FuncValue func_value, List <Value> arguments_lst, int linenum) { //可以看到,所有的东西都是局部变量,因此函数调用结束这些Bindings都会自动free List <Dictionary <string, Value> > binding_stack = new List <Dictionary <string, Value> >(); Dictionary <string, Value> local_bindings = new Dictionary <string, Value>(); binding_stack.Add(Executor.globalSymbolTable); binding_stack.Add(local_bindings); //获得返回类型 NonterminalStackElement return_type_node = (NonterminalStackElement)func_value.func_def_node.branches[0]; OtherTerminalStackElement specific_return_type_node = (OtherTerminalStackElement)return_type_node.branches[0]; string return_type = specific_return_type_node.content; //获得函数名 NonterminalStackElement func_declaratee = (NonterminalStackElement)func_value.func_def_node.branches[1]; IdentifierStackElement identifier_node = (IdentifierStackElement)func_declaratee.branches[0]; string func_name = identifier_node.content; List <string> params_lst = new List <string>(); //part1 传参 //先把实参传进来(加到local_bindings顺便做一个类型检查,函数签名和传入参数) //func_declaratee →identifier()|identifier(param_lst) if (func_declaratee.branches.Count == 4) { int index = 0; NonterminalStackElement param_lst_node = (NonterminalStackElement)func_declaratee.branches[2]; //param_lst→param_declaration,param_lst | param_declaration NonterminalStackElement param_declaration_node = (NonterminalStackElement)param_lst_node.branches[0]; while (param_lst_node.branches.Count == 3) { if (arguments_lst.Count <= index) { throw new ExecutorException("传入实参多于形参", linenum); } //param_declaration→type identifier|type identifier[simple_expr] NonterminalStackElement type_node = (NonterminalStackElement)param_declaration_node.branches[0]; OtherTerminalStackElement specific_type_node = (OtherTerminalStackElement)type_node.branches[0]; IdentifierStackElement identifier_Node = (IdentifierStackElement)param_declaration_node.branches[1]; param_lst_node = (NonterminalStackElement)param_lst_node.branches[2]; param_declaration_node = (NonterminalStackElement)param_lst_node.branches[0]; string type = specific_type_node.content; //传入数组会更特殊 if (param_declaration_node.branches.Count == 4) { type += "Array"; if (arguments_lst[index].type != type) { throw new ExecutorException("函数形参类型与实际传入参数类型不符", linenum); } NonterminalStackElement simple_expr_node = (NonterminalStackElement)param_declaration_node.branches[3]; if (arguments_lst[index].getArrayLen() > get_array_len_from_simple_expr(simple_expr_node, binding_stack)) { throw new ExecutorException("传入的数组长度大于对应的形参数组长度", linenum); } } //如果符合要求,那就在local_bindings增加定义 if (arguments_lst[index].type == type) { local_bindings.Add(identifier_Node.content, arguments_lst[index]); index++; } else { throw new ExecutorException("函数形参类型与实际传入参数类型不符", linenum); } } if ((index + 1) > arguments_lst.Count) { throw new ExecutorException("传入实参少于形参", linenum); } //最后一个参数,重复一遍上面的工作 NonterminalStackElement _type_node = (NonterminalStackElement)param_declaration_node.branches[0]; OtherTerminalStackElement _specific_type_node = (OtherTerminalStackElement)_type_node.branches[0]; IdentifierStackElement _identifier_Node = (IdentifierStackElement)param_declaration_node.branches[1]; string _type = _specific_type_node.content; //传入数组会更特殊 if (param_declaration_node.branches.Count == 4) { _type += "Array"; if (arguments_lst[index].type != _type) { throw new ExecutorException("函数形参类型与实际传入参数类型不符", linenum); } NonterminalStackElement simple_expr_node = (NonterminalStackElement)param_declaration_node.branches[3]; if (arguments_lst[index].getArrayLen() > get_array_len_from_simple_expr(simple_expr_node, binding_stack)) { throw new ExecutorException("传入的数组长度大于对应的形参数组长度", linenum); } } //如果符合要求,那就在local_bindings增加定义 if (arguments_lst[index].type == _type) { local_bindings.Add(_identifier_Node.content, arguments_lst[index]); index++; } else { throw new ExecutorException("函数形参类型与实际传入参数类型不符", linenum); } } //func_declaratee →identifier() 这样的话local_bindings就不需要任何东西了 else { if (arguments_lst.Count != 0) { throw new ExecutorException("函数" + identifier_node.content + "不需要接受任何参数", linenum); } //do nothing } //part2 实际执行 //func_definition→type func_declaratee {stmt_lst} | type func_declaratee {} if (func_value.func_def_node.branches.Count == 4) { if (return_type == "void") { return(null); } else { throw new ExecutorException("函数" + identifier_node.content + "没有返回任何值", linenum); } } //func_definition → type func_declaratee {stmt_lst} //stmt_lst → stmt stmt_lst | stmt NonterminalStackElement stmt_lst_node = (NonterminalStackElement)func_value.func_def_node.branches[3]; Value return_value = executeStmtLst(stmt_lst_node, binding_stack); //如果返回一个NullValue或者Null,那要检查是否是void if (return_value == null || return_value.type == "null") { if (return_type == "void") { return(null); } else { throw new ExecutorException("函数" + func_name + "的返回值必须是" + return_type + "类型", linenum); } } //返回不是Null,返回了一个实际的Value,那就要检查类型是否相符,检查返回类型不是void else { if (return_type == "void") { throw new ExecutorException("函数" + func_name + "的返回值必须是null", linenum); } else { try { Value v = adjustType(return_type, return_value); return(v); } //重新捕获调整再抛出 catch (ExecutorException ee) { throw new ExecutorException("函数" + func_name + "的返回值必须是" + return_type + "类型", linenum); } catch (Exception eee) { throw eee; } } } }
private void recursiveAddNodes(StackElement e, TreeViewItem newItem) { try { if (e.type_code == 6) { throw new ParserException("这个表示状态的栈元素不应该出现在Tree的递归子结点中!"); } else if (e.type_code == 1) { IdentifierStackElement ele = (IdentifierStackElement)e; newItem.Header = "第" + ele.linenum + "行的标识符:" + ele.content; } else if (e.type_code == 2) { IntStackElement ele = (IntStackElement)e; newItem.Header = "第" + ele.linenum + "行的整数:" + ele.content; } else if (e.type_code == 3) { NonterminalStackElement ele = (NonterminalStackElement)e; newItem.Header = "非终结符:" + ele.name; } else if (e.type_code == 4) { OtherTerminalStackElement ele = (OtherTerminalStackElement)e; newItem.Header = "第" + ele.linenum + "行的终结符:" + ele.content; } else if (e.type_code == 5) { RealStackElement ele = (RealStackElement)e; newItem.Header = "第" + ele.linenum + "行的实数:" + ele.content; } else if (e.type_code == 7) { CharStackElement ele = (CharStackElement)e; newItem.Header = "第" + ele.linenum + "行的字符:" + ele.content; } else if (e.type_code == 8) { StringStackElement ele = (StringStackElement)e; newItem.Header = "第" + ele.linenum + "行的字符串:" + ele.content; } else { throw new ParserException("这是啥栈元素?"); } //若是终结符,branches就是空,若不是非终结符,它也终究会走到末端叶子节点,也就是非终结符,然后递归终止 if (e.branches.Count != 0) { foreach (StackElement ele in e.branches) { TreeViewItem new_node = new TreeViewItem(); newItem.Items.Add(new_node); recursiveAddNodes(ele, new_node); } } } catch (ParserException pe) { MessageBox.Show(pe.err_msg); } catch (Exception ee) { MessageBox.Show(ee.ToString()); } }