文件列表:

定稿论文\论文一：词法分析器.doc (241152, 2009-03-04)
定稿论文\论文三：中间代码生成.doc (240640, 2009-03-04)
定稿论文\论文二：语法分析器.doc (144896, 2009-03-04)
生成三地址码的Compiler\Compiler\Compiler\Bi_buf.cpp (3083, 2009-02-01)
生成三地址码的Compiler\Compiler\Compiler\Bi_buf.h (1420, 2009-02-12)
生成三地址码的Compiler\Compiler\Compiler\code.fc (214, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Compiler.cpp (335, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler\Compiler.vcproj (5063, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler\Compiler.vcproj.vspscc (256, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler\Compiler.vcproj.WangJia-PC.WangJia.user (1417, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\Bi_buf.obj (84754, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\BuildLog.htm (6420, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\Compiler.exe.embed.manifest (405, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\Compiler.exe.embed.manifest.res (472, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\Compiler.exe.intermediate.manifest (387, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\Compiler.obj (27830, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\Compiler.pch (1048576, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\Id_table.obj (280897, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\lexer.obj (161189, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\mt.dep (63, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\parser.obj (919211, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\stdafx.obj (10555, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Debug\vc80.idb (289792, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Debug\vc80.pdb (323584, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\Id_table.cpp (1165, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\Id_table.h (744, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\lexer.cpp (5688, 2009-02-16)
生成三地址码的Compiler\Compiler\Compiler\lexer.h (980, 2009-02-12)
生成三地址码的Compiler\Compiler\Compiler\mssccprj.scc (132, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler\parser.cpp (16897, 2009-03-02)
生成三地址码的Compiler\Compiler\Compiler\parser.h (3616, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler\stdafx.cpp (213, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler\stdafx.h (378, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler\vssver2.scc (424, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler.ncb (1723392, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler.sln (1086, 2009-02-27)
生成三地址码的Compiler\Compiler\Compiler.suo (29184, 2009-03-03)
生成三地址码的Compiler\Compiler\Compiler.vssscc (256, 2009-02-27)
生成三地址码的Compiler\Compiler\debug\Compiler.exe (258048, 2009-03-03)
... ...

////////////////////////////////////////////////////////////////////////// //------------第一次签入记录---------------// 2009-01-31 0:40 词法分析器完成 能输出二元式组，输出完后瘫痪 输出的二元式组有问题（至少有符号表相关的问题） 还没有来得及写注释 总共587行 //------------第一次签入记录---------------// ////////////////////////////////////////////////////////////////////////// //------------第二次签入记录---------------// 2009-02-01 1:00 词法分析器纠错 能输出正确的二元式组 {另注： 昨天的错误是因为匹配‘(’类似的单字符之后，缓冲区的两个指针没有统一 因为统一只有在空白符的处理分支里有，和在标志符的get_lexeme的标志符里有， 所以当(int出现时，int本应是词素，但却因为‘(’没有被lexeme_beginning过掉而变成了(int词素 } 输出完成后瘫痪，是因为不能正确处理EOF字符；为了测试，暂时如此（主函数里写了个while(1)） 依然没来得及写注释 因为测试用的源代码太短，实际上只用了一个缓冲区，双缓冲区未经测试 //------------第二次签入记录---------------// //------------第三次签入记录---------------// 构建基于带回溯的递归下降分析法的语法分析器 语法如下： 1.program --> declaration-list 2.declaration-list --> declaration declaration-list | declaration 4.declaration --> var-declaration | fun-declaration 5.var-declaration --> “int” ID; 6.fun-declaration --> type-specifier ID (params) compound-stmt | type-specifier ID () compound-stmt 7.type-specifier --> "int" | "void" 8.params --> param params’ 9.params’ --> , param params’ | empty 10.param --> “int” ID 11.compound-stmt --> {local-declarations statement-list} 12.local-declarations --> var-declaration local-declarations | empty 13.statement-list --> statement statement-list | empty 14.statement --> expression-stmt | compound-stmt | selection-stmt | iteration-stmt | return-stmt 15.expression-stmt --> expression; | ; 16.selection-stmt --> "if" (expression) statement | “if” (expression) statement “else” statement 17.iteration-stmt --> "while" (expression) statement 18.return-stmt --> “return”; | “return” expression; 19.expression --> ID = expression | simple-expression 20.simple-expression --> additive-expression RELOP additive-expression | additive-expression 21.additive-expression --> term additive-expression' 22.additive-expression' --> ADDOP term additive-expression' | empty 23.term --> factor term' 24.term' --> MULOP factor term' | empty 25.factor --> (expression) | ID | call | NUM 26.call --> ID (args) | ID () 27.args --> expression args' 28.args' --> ,expression args' | empty 语法分析器构造完毕，与词法分析器的接口正常工作（可在调试时跟踪tokens容器，符号表对象和词素表对象） 语法分析不显示构造分析树，调用函数的过程即是分析树（对语法分析器的调试即是测试） 先前的词法分析器做了以下改动： 1. 能够处理文件结束的情况，state==0时加入一个抛出异常的cur == -52的检测 2. 返回 这样的二元组，而非返回 <'+', 0> 这样做是为了简化语法分析器的语法定义 2009-2-16 18：05 测试成功，签入 //------------第三次签入记录---------------// //------------第四次签入记录---------------// 改写语法分析器，使其输出语法树 生成语法树的翻译模式如下 1.program --> declaration-list { program.nptr := declaration-list.nptr } 2.declaration-list --> declaration declaration-list1 { declaration-list.nptr := mknode(“”, declaration.nptr, declaration-list1.nptr) } | declaration1 { declaration.nptr := declaration1.nptr } 3.declaration --> var-declaration { declaration.nptr := var-declaration.nptr } | fun-declaration { declaration.nptr := fun-declaration.nptr } 4.var-declaration --> “int”ID; { var-declaration.nptr := mknode(“int”, mkleaf(“id”, id.place)) } 5.fun-declaration --> type-specifier ID (params) compound-stmt { fun-declaration.nptr := mknode(“()”, type-specifier.nptr, mkleaf(“id”, id.place), params.nptr, compound-stmt.nptr) } | type-specifier ID () compound-stmt { fun-declaration.nptr := mknode(“()”, type-specifier.nptr, mkleaf(“id”, id.place), compound-stmt.nptr) } 6.type-specifier --> "int" { type-specifier.nptr := mknode(“int”, -1) } | "void" { type-specifier.nptr := mknode(“void”, -1) } 7. params --> param { paramsR.i := param.nptr } paramsR { params.nptr := paramsR.nptr } 8. paramsR --> , param { paramsR1.i := mknode(“,”, paramsR.i, param.nptr) } paramsR1 { paramsR.nptr := paramsR1.nptr } | empty { paramsR.nptr := paramsR.i } 9.param --> “int”ID { param.nptr := mknode(“int”, mkleaf(“id”, id.place)) } 10.compound-stmt --> {local-declarations statement-list} { compound-stmt.nptr := mknode(“{}”, local-declarations.nptr, statement-list.nptr) } 11.local-declarations --> var-declaration local-declarations { local-declarations.nptr := mknode(“”, var-declaration.nptr, local-declarations.nptr) } | empty { local-declarations.nptr := -1 } 12.statement-list --> statement statement-list { statement-list.nptr := mknode(“”, statement.nptr, statement-list.nptr) } | empty { statement-list.nptr := -1 } 13.statement --> expression-stmt { statement.nptr := expression-stmt.nptr } | compound-stmt { statement.nptr := compound-stmt.nptr } | selection-stmt { statement.nptr := selection-stmt.nptr } | iteration-stmt { statement.nptr := iteration-stmt.nptr } | return-stmt { statement.nptr := return-stmt.nptr } 14.expression-stmt --> expression; { expression-stmt.nptr := mknode(“;”, expression.nptr) } | ; { expression-stmt.nptr := mknode(“;”, -1) } 15.selection-stmt --> "if" (expression) statement { selection-stmt.nptr := mknode(“if()”, expression.nptr, statement.nptr) } | “if”(expression) statement1 “else”statement2 { selection-stmt.nptr := mknode(“if()else”, expression.nptr, statement1.nptr, statement2.nptr) } 16.iteration-stmt --> "while" (expression) statement { iteration-stmt.nptr := mknode(“while()”, expression.nptr, statement.nptr) } 17.return-stmt --> “return”; { return-stmt.nptr := mknode(“return;”, -1) } | “return”expression; { return-stmt.nptr := mknode(“return;”, expression.nptr) } 18.expression --> ID = expression1 { expression.nptr := mknode(“=”, mkleaf(“id”, id.place), expression1.nptr) } | simple-expression { expression.nptr := simple-expression.nptr } 19.simple-expression --> additive-expression1 RELOP additive-expression2 { simple-expression.nptr := mknode(“RELOP”, additive-expression1.nptr, additive-expression2.nptr) } | additive-expression { simple-expression.nptr := additive-expression.nptr } 20.additive-expression --> term { additive-expressionR.i := term.nptr } additive-expressionR { additive-expression.nptr := additive-expressionR.nptr } 21. additive-expressionR --> ADDOP term { additive-expressionR1.i := mknode(“ADDOP”, additive-expressionR.i, term.nptr) } additive-expressionR1 { additive-expressionR.nptr := additive-expressionR1.nptr } | empty { additive-expressionR.nptr := additive-expressionR.i } 22. term --> factor { termR.i := factor.nptr } termR { term.nptr := termR.nptr } 23. termR --> MULOP factor { termR1.i := mknode(“MULOP”, termR.i, factor.nptr) } termR1 { termR.nptr := termR1.nptr } | empty { termR.nptr := termR.i } 24.factor --> (expression) { factor.nptr := expression.nptr } | ID { factor.nptr := mkleaf(“id”, id.place) } | call { factor.nptr := call.nptr } | NUM { factor.nptr := mkleaf(“num”, num.value) } 25.call --> ID (args) { call.nptr := mknode(“()”, mkleaf(“id”, id.place), args.nptr) } | ID () { call.nptr := mknode(“()”, mkleaf(“id”, id.place)) } 26. args --> expression { argsR.i := expression.nptr } argsR { args.nptr := argsR.nptr } 27. argsR --> , expression { argsR1.i := mknode(“,”, argsR.i, expression.nptr) } argsR1 { argsR.nptr := argsR1.nptr } | empty { argsR.nptr := argsR.i } RELOP, ADDOP, MULOP在翻译时需要翻译成具体的符号---->已完成! 2009-2-27 完成预期目的，能够顺利生成语法树，签入！ //------------第四次签入记录---------------// 全局变量Par_table_chain 全局变量 Quads_code 1.program --> { Par_table_chain.mktable() } declaration-list 2.declaration-list --> declaration declaration-list1 | declaration1 3.declaration --> var-declaration | { Par_table_chain.mktable() } fun-declaration {Par_table_chain.jumpout()} 4.var-declaration --> “int”ID; { Par_table_chain.enter(ID.name, "int", 4) } 5.fun-declaration --> type-specifier ID { Par_table_chain.set_name_type(ID.name, type-specifier.type)} {Par_table_chain.add_to_previous()}{ Quads_code.gen_entry(ID.name) } (params) compound-stmt | type-specifier ID { Par_table_chain.set_name_type(ID.name, type-specifier.type)} { Quads_code.gen_entry(ID.name) } () compound-stmt 6.type-specifier --> "int" { type-specifier.type := "int"} | "void" { type-specifier.type := "void"} 7.params --> param, params | param 8. param --> "int" ID { Par_table_chain.enter(ID.name, "int", 4) } {Quads_code.gen_param_load(Par_table_chain, "load", ID.name)} 9.compound-stmt --> {local-declarations statement-list} 10.local-declarations --> var-declaration local-declarations | empty 12.statement-list --> statement statement-list | empty 13.statement --> expression-stmt | selection-stmt | iteration-stmt | return-stmt | { Par_table_chain.mktable() } {Par_table_chain.add_to_previous()}compound-stmt { Par_table_chain.jumpout() } 14.expression-stmt --> expression; | ; 15.selection-stmt --> "if" ( { to_true := newlabel; to_false := newlabel } {condition-expression.to_true := to_true} {condition-expression.to_false := to_false} condition-expression) {Quads_code.gen_label(to_true)} statement {Quads_code.gen_label(to_false)} | "if" ( { to_true := newlabel; to_false := newlabel } {condition-expression.to_true := to_true} {condition-expression.to_false := to_false} condition-expression) {Quads_code.gen_label(to_true)} statement1 {to_next = newlabel} “else”{Quads_code.gen_goto(to_next)} {Quads_code.gen_label(to_false)} statement2 {Quads_code.gen_label(to_next)} 16.iteration-stmt --> "while" ( {to_begin := newlabel} {Quads_code.gen_label(to_begin)} { to_true := newlabel; to_false := newlabel } {condition-expression.to_true := to_true} {condition-expression.to_false := to_false} condition-expression) {Quads_code.gen_label(to_true)} statement {Quads_code.gen_goto(to_begin)} {Quads_code.gen_label(to_false)} 19.condition-expression --> additive-expression1 RELOP additive-expression2 { Quads_code.gen_condition(Par_table_chain, RELOP.name, additive-expression1.name, additive-expression2.name, condition-expression.to_true)} { Quads_code.gen_goto(condition-expression.to_false)} 17.return-stmt --> “return”; { Quads_code.gen_uni("return") } | “return”expression; {Quads_code.gen_param_load(Par_table_chain, "return", expression.name)} 18.expression --> ID = expression1 { Quads_code.gen_bi(Par_table_chain, ID.name, expression1.name)} {expression.name := ID.name} | additive-expression { expression.name := additive-expression.name } 20. additive-expression --> term {additive-expressionR.i := term.name} additive-expressionR {additive-expression.name := additive-expressionR.s} additive-expressionR --> ADDOP term {additive-expressionR.n := newtemp} {Par_table_chain.enter(additive-expressionR.n, "int", 4)} {Quads_code.gen_tri(Par_table_chain, ADDOP.name, additive-expressionR.n, additive-expressionR.i, term.name)} {additive-expressionR1.i := additive-expressionR.n} additive-expressionR1 {additive-expressionR.s := additive-expressionR1.s} additive-expressionR --> empty {additive-expressionR.s := additive-expressionR.i} 21. term --> factor {termR.i := factor.name} termR {term.name := termR.s} termR --> MULOP factor {termR.n := newtemp} {Par_table_chain.enter(termR.n, "int", 4)} {Quads_code.gen_tri(Par_table_chain, MULOP.name, termR.n, termR.i, factor.name)} {termR1.i := termR.n} termR1 {termR.s := termR1.s} termR --> empty {termR.s := termR.i} 22.factor --> (additive-expression) { factor.name := additive-expression.name} | ID {factor.name := ID.name} | call {factor.name := call.name} | NUM { factor.name := int_to_str(NUM.value) } 23.call --> ID ( {call.name := newtemp } { Par_table_chain.enter(call.name, "int", 4) }{ Quads_code.gen_uni("begin_args")} args ) { Quads_code.gen_call(Par_table_chain, ID.name) } | ID ( {call.name := newtemp } { Par_table_chain.enter(call.name, "int", 4)} {Quads_code.gen_uni("begin_args")} ) { Quads_code.gen_call(Par_table_chain, ID.name) } 24. args --> additive-expression { Quads_code.gen_param_load(Par_table_chain, "param", additive-expression.name) } , args | additive-expression { Quads_code.gen_param_load(Par_table_chain, "param", additive-expression.name) }

近期下载者：

相关文件：

评论：[我要评论] [举报此文件]

收藏者：