//number→real_number |integer 产生实数或整数 public static Value eval_number(NonterminalStackElement number_node) { if (number_node.branches.Count != 1) { throw new ExecutorException("文法发生了变化", number_node.linenum); } else { StackElement number = (StackElement)number_node.branches[0]; if (number.type_code == 2) { IntStackElement int_number = (IntStackElement)number; return(new IntValue("int", true, int_number.content, int_number.linenum)); } else if (number.type_code == 5) { RealStackElement real_number = (RealStackElement)number; return(new RealValue("real", true, real_number.content, real_number.linenum)); } else { throw new ExecutorException("文法发生了变化", number_node.linenum); } } }
//自顶向下,深度优先遍历语法树(与生成树顺序一致) private static void goThroughAST_toExecute(StackElement e) { if (e.type_code == 3) { NonterminalStackElement ee = (NonterminalStackElement)e; if (ee.name == "func_definition") { addFuncDefinition(ee); return; } else if (ee.name == "declare_stmt") { declareVaraible(ee, mainFrameStack); return; } else { foreach (object b in e.branches) { StackElement child = (StackElement)b; goThroughAST_toExecute(child); } } } }
private static void printStack() { Stack <StackElement> temp = new Stack <StackElement>(); foreach (object o in stack_to_parse) { StackElement s_ele = (StackElement)o; temp.Push(s_ele); } foreach (StackElement s in temp) { Console.WriteLine(s.ToString()); } }
private static void constructGlobalSymbolTable() { object top_node = Parser.stack_to_parse.Peek(); StackElement top = (StackElement)top_node; mainFrameStack.Add(globalSymbolTable); if (top.type_code == 3) { object initial_node = Parser.stack_to_parse.Pop(); StackElement root_node = (StackElement)initial_node; goThroughAST_toExecute(root_node); showGlobalBindings(); } else { throw new ExecutorException("应该是语法树的根节点E在栈顶"); } }
private void drawTheAbstractSyntaxTree() { int index = 0; while (Parser.stack_to_parse.Count != 0) { //获取栈的最里面的节点 StackElement first_ele = (StackElement)Parser.stack_to_parse.Peek(); //准备添加的树节点 TreeViewItem new_node = new TreeViewItem(); if (first_ele.type_code == 6) { Parser.stack_to_parse.Pop(); continue; } else if (first_ele.type_code != 3) { throw new ParserException("怎么会有不是非终结符的最外层栈元素,它怎么过的语法分析?"); } else { NonterminalStackElement e = (NonterminalStackElement)first_ele; try { Console.WriteLine("index" + index); recursiveAddNodes(e, new_node); } catch (Exception ee) { Console.WriteLine(ee); } myAST_Node1.Items.Add(new_node); return; } } }
//这里情况就不同了,上面是对应着+-*/四则运算的,所以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); } }
/* * 初始化所有变量:规则(未给出初始化值initializer的,也就是只是声明的变量都赋0) * declaratee→identifier | identifier[simple_expr] | identifier initializer | identifier [simple_expr] initializer | identifier[] initializer * 接收参数declaratees:初始化数组/单个变量均可 * 可能出现错误:重复声明,void类型变量错误 * 声明单个变量:用数组给单个变量赋值,initializer值的类型与声明类型不符合 * 声明变量数组:用单个变量给数组变量赋值,initializer值的类型与声明类型不符合,initializer值的长度大于声明长度 * 可能有多个变量一起声明甚至初始化,但是他们类型必须相同(符合C语法) */ private static void initialize_declaratees(string type, List <NonterminalStackElement> declaratees, List <Dictionary <string, Value> > bindings_stack) { foreach (NonterminalStackElement declaratee in declaratees) { IdentifierStackElement id_node = (IdentifierStackElement)declaratee.branches[0]; string new_identifier = id_node.content; int linenum = id_node.linenum; //检查重复声明 Dictionary <string, Value> bindings = ExecutorTools.findBindings(bindings_stack, new_identifier, true); //也就是已经有了同名变量 if (bindings != null) { throw new ExecutorException("重复声明已存在的变量" + new_identifier, id_node.linenum); } else { //那就在最上层准备声明 bindings = bindings_stack[bindings_stack.Count - 1]; //declaratee→identifier声明变量 if (declaratee.branches.Count == 1) { if (type == "int") { bindings.Add(new_identifier, new IntValue("int", false, "0", id_node.linenum)); } else if (type == "real") { bindings.Add(new_identifier, new RealValue("real", false, "0.0", id_node.linenum)); } else if (type == "char") { bindings.Add(new_identifier, new CharValue("char", false, "", id_node.linenum)); } else if (type == "string") { bindings.Add(new_identifier, new StringValue("string", false, "", id_node.linenum)); } else { throw new ExecutorException("试图声明一个void类型的变量" + new_identifier, id_node.linenum); } } //declaratee→identifier initializer 声明并初始化变量 else if (declaratee.branches.Count == 2) { NonterminalStackElement initializer_node = (NonterminalStackElement)declaratee.branches[1]; if (initializer_node.branches.Count != 2) { throw new ExecutorException("试图用数组给单个变量" + new_identifier + "进行初始化", linenum); } //排除后,必然是initializer→=expr NonterminalStackElement expr_node = (NonterminalStackElement)initializer_node.branches[1]; Value v = Evaluator.eval_expr(expr_node, mainFrameStack); v = ExecutorTools.adjustType(type, v); bindings.Add(new_identifier, v); } //declaratee→identifier[simple_expr] | identifier[] initializer声明定长数组,初始化auto自适应长度数组 else if (declaratee.branches.Count == 4) { StackElement third_child_of_last_declaratee = (StackElement)declaratee.branches[2]; //declaratee→identifier[] initializer if (third_child_of_last_declaratee.type_code == 4) { //现在还不知道数组长度,要根据initializer算 int array_len; NonterminalStackElement initializer_node = (NonterminalStackElement)declaratee.branches[3]; //initializer→ = expr |={ initializer_lst} if (initializer_node.branches.Count != 4) { throw new ExecutorException("试图用单个变量给数组" + new_identifier + "进行初始化", linenum); } //排除后,必然是initializer→={initializer_lst} NonterminalStackElement initializer_lst_node = (NonterminalStackElement)initializer_node.branches[2]; //获取initializer数组的长度 intializer_lst→expr | expr,initializer_lst | expr, //获取给出的initializer中的值的集合 List <Value> given_values = new List <Value>(); while (initializer_lst_node.branches.Count == 3) { Value vv = Evaluator.eval_expr((NonterminalStackElement)initializer_lst_node.branches[0], mainFrameStack); vv = ExecutorTools.adjustType(type, vv); given_values.Add(vv); initializer_lst_node = (NonterminalStackElement)initializer_lst_node.branches[2]; } Value v = Evaluator.eval_expr((NonterminalStackElement)initializer_lst_node.branches[0], mainFrameStack); v = ExecutorTools.adjustType(type, v); given_values.Add(v); initializer_lst_node = (NonterminalStackElement)initializer_lst_node.branches[2]; //根据给出的值数量,确定我们数组的长度 array_len = given_values.Count; if (type == "int") { int[] arrayElements = new int[array_len]; for (int i = 0; i < array_len; i++) { if (given_values[i].type != "int") { throw new ExecutorException("用" + given_values[i].type + "类型给" + type + "类型数组变量" + new_identifier + "初始化", linenum); } IntValue value = (IntValue)given_values[i]; arrayElements[i] = value.value; } bindings.Add(new_identifier, new IntArrayValue("intArray", false, array_len, arrayElements, linenum)); } else if (type == "real") { double[] arrayElements = new double[array_len]; for (int i = 0; i < array_len; i++) { if (given_values[i].type != "real") { throw new ExecutorException("用" + given_values[i].type + "类型给" + type + "类型数组变量" + new_identifier + "初始化", linenum); } RealValue value = (RealValue)given_values[i]; arrayElements[i] = value.value; } bindings.Add(new_identifier, new RealArrayValue("realArray", false, array_len, arrayElements, linenum)); } else if (type == "char") { string[] arrayElements = new string[array_len]; for (int i = 0; i < array_len; i++) { if (given_values[i].type != "char") { throw new ExecutorException("用" + given_values[i].type + "类型给" + type + "类型数组变量" + new_identifier + "初始化", linenum); } CharValue value = (CharValue)given_values[i]; arrayElements[i] = value.value; } bindings.Add(new_identifier, new CharArrayValue("charArray", false, array_len, arrayElements, linenum)); } else if (type == "string") { string[] arrayElements = new string[array_len]; for (int i = 0; i < array_len; i++) { if (given_values[i].type != "string") { throw new ExecutorException("用" + given_values[i].type + "类型给" + type + "类型数组变量" + new_identifier + "初始化", linenum); } StringValue value = (StringValue)given_values[i]; arrayElements[i] = value.value; } bindings.Add(new_identifier, new StringArrayValue("stringArray", false, array_len, arrayElements, linenum)); } else { throw new ExecutorException("试图声明一个void类型的变量数组" + new_identifier, linenum); } } //declaratee→identifier[simple_expr] else { NonterminalStackElement simple_expr_node = (NonterminalStackElement)declaratee.branches[2]; int array_len = ExecutorTools.get_array_len_from_simple_expr(simple_expr_node, mainFrameStack); if (type == "int") { int[] arrayElements = new int[array_len]; for (int i = 0; i < array_len; i++) { arrayElements[i] = 0; } bindings.Add(new_identifier, new IntArrayValue("intArray", false, array_len, arrayElements, linenum)); } else if (type == "real") { double[] arrayElements = new double[array_len]; for (int i = 0; i < array_len; i++) { arrayElements[i] = 0.0; } bindings.Add(new_identifier, new RealArrayValue("realArray", false, array_len, arrayElements, linenum)); } else if (type == "char") { string[] arrayElements = new string[array_len]; for (int i = 0; i < array_len; i++) { arrayElements[i] = "\0"; } bindings.Add(new_identifier, new CharArrayValue("charArray", false, array_len, arrayElements, linenum)); } else if (type == "string") { string[] arrayElements = new string[array_len]; for (int i = 0; i < array_len; i++) { arrayElements[i] = ""; } bindings.Add(new_identifier, new StringArrayValue("stringArray", false, array_len, arrayElements, linenum)); } else { throw new ExecutorException("试图声明一个void类型的变量数组" + new_identifier, linenum); } } } //declaratee→identifier [simple_expr] initializer else if (declaratee.branches.Count == 5) { NonterminalStackElement simple_expr_node = (NonterminalStackElement)declaratee.branches[2]; //数组声明的长度 int array_len = ExecutorTools.get_array_len_from_simple_expr(simple_expr_node, mainFrameStack); //现在还不知道被赋值的数组长度,要根据initializer算 NonterminalStackElement initializer_node = (NonterminalStackElement)declaratee.branches[4]; //initializer→ = expr | ={ initializer_lst} if (initializer_node.branches.Count != 4) { throw new ExecutorException("试图用单个变量给数组" + new_identifier + "进行初始化", linenum); } //排除后,必然是initializer→={initializer_lst} NonterminalStackElement initializer_lst_node = (NonterminalStackElement)initializer_node.branches[2]; //获取initializer数组的长度 intializer_lst→expr | expr,initializer_lst | expr, //获取给出的initializer中的值的集合 List <Value> given_values = new List <Value>(); while (initializer_lst_node.branches.Count == 3) { Value vv = Evaluator.eval_expr((NonterminalStackElement)initializer_lst_node.branches[0], mainFrameStack); vv = ExecutorTools.adjustType(type, vv); given_values.Add(vv); initializer_lst_node = (NonterminalStackElement)initializer_lst_node.branches[2]; } Value v = Evaluator.eval_expr((NonterminalStackElement)initializer_lst_node.branches[0], mainFrameStack); v = ExecutorTools.adjustType(type, v); given_values.Add(v); //赋值 if (given_values.Count > array_len) { throw new ExecutorException("数组" + new_identifier + "的初始值设定项长度" + given_values.Count + "大于声明的长度" + array_len, linenum); } if (type == "int") { int[] arrayElements = new int[array_len]; for (int i = 0; i < array_len; i++) { if (i < given_values.Count) { IntValue intv = (IntValue)given_values[i]; arrayElements[i] = intv.value; } else { arrayElements[i] = 0; } } bindings.Add(new_identifier, new IntArrayValue("intArray", false, array_len, arrayElements, linenum)); } else if (type == "real") { double[] arrayElements = new double[array_len]; for (int i = 0; i < array_len; i++) { if (i < given_values.Count) { RealValue intv = (RealValue)given_values[i]; arrayElements[i] = intv.value; } else { arrayElements[i] = 0.0; } } bindings.Add(new_identifier, new RealArrayValue("realArray", false, array_len, arrayElements, linenum)); } else if (type == "char") { string[] arrayElements = new string[array_len]; for (int i = 0; i < array_len; i++) { if (i < given_values.Count) { CharValue intv = (CharValue)given_values[i]; arrayElements[i] = intv.value; } else { arrayElements[i] = "\0"; } } bindings.Add(new_identifier, new CharArrayValue("charArray", false, array_len, arrayElements, linenum)); } else if (type == "string") { string[] arrayElements = new string[array_len]; for (int i = 0; i < array_len; i++) { if (i < given_values.Count) { StringValue intv = (StringValue)given_values[i]; arrayElements[i] = intv.value; } else { arrayElements[i] = ""; } } bindings.Add(new_identifier, new StringArrayValue("stringArray", false, array_len, arrayElements, linenum)); } else { throw new ExecutorException("试图声明一个void类型的变量数组" + new_identifier, linenum); } } else { throw new ExecutorException("initialize_declaratee_withzero出现不正常的错误,可能是语法树解析declaratee出现问题"); } } } }
public static bool parse_tokens() { try { all_tokens.Clear(); stack_to_parse = new Stack <object>(); StateStackElement initial_state = new StateStackElement(1); stack_to_parse.Push(initial_state); foreach (Token t in MainWindow.allTokens) { all_tokens.Add(t); } while (all_tokens.Count != 0) { //获取分析栈的状态(第一个状态元素) StateStackElement first = (StateStackElement)(stack_to_parse.Peek()); //获取剩余tokens的第一个 Token t = all_tokens[0]; //根据第一个token,构建一个栈元素(type_code自动赋予,用来判断token是哪一种stackelement) StackElement ele = (StackElement)Tools.transformTokenToSymbol(t); //结合分析表,获取应该进行的语法动作 Action a = getActionByTransformedToken(first.state, ele.type_code, t.content); //进行该语法动作 conductAction(a, t, ele, first); } //下面这部分就与tokens无关了,如果上面tokens没有出错,就会进入下面的收尾部分: while (true) { //这部分的意义主要是在于,tokens一旦为空,上面的while循环自动结束,但是这并不意味着语法分析的结束 //程序只是进行了最后一次真正token的移入,但是还有很多规约,甚至是报错的工作要进行 //这一部分每次都会接收到一个我们固定的empty,如果程序认为它不能在empty下规约,那么要么是到了最后的E,要么是报错 StateStackElement last_state = (StateStackElement)stack_to_parse.Peek(); Action last_action = GrammerConfig.analysis_table[last_state.state]["empty"]; //执行语法动作,应该是一个规约,否则就是已经规约到头err,那就是结束err if (last_action.action == "reduce") { //规约产生的肯定都是非终结符 NonterminalStackElement e = new NonterminalStackElement(-1, last_action.left); int count = last_action.right.Count; for (int i = 0; i < count * 2; i++) { if (i % 2 == 1) { StackElement s = (StackElement)stack_to_parse.Pop(); s.layersIncreaseRecursively(); e.branches.Insert(0, s); } else { stack_to_parse.Pop(); } } StateStackElement first_now = (StateStackElement)(stack_to_parse.Peek()); Console.WriteLine("last_action.left:" + last_action.left); Action aa = getActionByTransformedToken(first_now.state, e.type_code, last_action.left); if (aa.action == "shift") { stack_to_parse.Push(e); stack_to_parse.Push(new StateStackElement(aa.new_state)); } else if (aa.action == "error") { stack_to_parse.Push(e); stack_to_parse.Push(new StateStackElement(0)); break; } else if (aa.action == "acc") { stack_to_parse.Push(e); stack_to_parse.Push(new StateStackElement(0)); break; } else { throw new ParserException("规约之后难道不是移进吗"); } } else if (last_action.action == "error") { throw new ParserException("程序定义不完整或者出现错误"); } else if (last_action.action == "acc") { stack_to_parse.Push(new StateStackElement(0)); break; } else if (last_action.action == "special action") { throw new ParserException("程序定义不完整或者出现错误"); } else { MessageBox.Show(last_action.action); throw new ParserException("不可能的情况"); } } printStack(); AbstractSyntaxTree ast_window = new AbstractSyntaxTree(); if (MainWindow.grammer_output) { ast_window.Show(); } return(true); } catch (ParserException pe) { MessageBox.Show(pe.getExceptionMsg()); return(false); } catch (Exception ee) { MessageBox.Show(ee.ToString()); return(false); } }
//执行五种语法动作之一 语法动作 - 目前的第一个token - 根据token构建的栈元素 private static void conductAction(Action a, Token t, StackElement ele, StateStackElement first) { if (a.action == "error") { throw new ParserException("第" + t.lineNum + "行:" + "遇到无法解析的语法成分:" + Token.getALineOfTokens(t.lineNum)); } else if (a.action == "shift") { stack_to_parse.Push(ele); stack_to_parse.Push(new StateStackElement(a.new_state)); all_tokens.RemoveAt(0); } else if (a.action == "reduce") { //规约产生的肯定都是非终结符 NonterminalStackElement e = new NonterminalStackElement(-1, a.left); int count = a.right.Count; for (int i = 0; i < count * 2; i++) { //第偶数个pop出去的元素不是代表状态的元素,是需要规约的元素 if (i % 2 == 1) { //保证是子结点是顺序的 StackElement s = (StackElement)stack_to_parse.Pop(); s.layersIncreaseRecursively(); e.branches.Insert(0, s); } else { stack_to_parse.Pop(); } } StateStackElement first_now = (StateStackElement)(stack_to_parse.Peek()); Action aa = getActionByTransformedToken(first_now.state, e.type_code, a.left); if (aa.action == "shift") { stack_to_parse.Push(e); stack_to_parse.Push(new StateStackElement(aa.new_state)); } else { throw new ParserException("规约之后难道不是移进吗"); } } else if (a.action == "special action") { //根据当前状态,将自动移入的nullable非终结符,获取分析表要我们执行的动作 Action next_action = GrammerConfig.analysis_table[first.state][a.auto_shifted]; if (next_action.action == "shift") { stack_to_parse.Push(new NonterminalStackElement(-1, a.auto_shifted)); stack_to_parse.Push(new StateStackElement(next_action.new_state)); } else { throw new ParserException("special action自动移入才对呀"); } } else { throw new ParserException("还未实现acc"); } }
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()); } }