精华内容
下载资源
问答
  • 第 7 章 目标代码生成 (3) 对于变量 c 有 USE(c,B 2 )=2 LIVE(c,B 2 )=1 USE(c,B 3 )=1 LIVE(c,B 3 )=0 USE(c,B 4 )=1 LIVE(c,B 4 )=0 因此变量 c 在一次循环中执行代价的节省总数为 [USE(c,B)+ 2*LIVE(c,B)] B L =2...
  • 编译原理课程词法分析器,语法分析器(递归实现),中间代码生成
  • 编译器设计-符号表-中间代码生成Compiler Design - Symbol TableCompiler - Intermediate Code Generation一.Compiler Design - Symbol Table符号表是编译器为存储变量名、函数名、对象、类、接口等各种实体的出现...

    编译器设计-符号表-中间代码生成

    Compiler Design - Symbol Table

    Compiler - Intermediate Code Generation

    一.Compiler Design - Symbol Table

    符号表是编译器为存储变量名、函数名、对象、类、接口等各种实体的出现情况而创建和维护的一种重要的数据结构。符号表既可用于编译器的分析部分,也可用于编译器的综合部分。 符号表可用于以下目的,具体取决于所使用的语言:

    将所有实体的名称以结构化形式存储在一个位置。

    以验证是否已声明变量。

    要实现类型检查,请验证源代码中的赋值和表达式在语义上是否正确。

    确定名称的作用域(作用域解析)。

    符号表只是一个可以是线性表或哈希表的表。它以以下格式为每个名称维护一个条目:

    <symbol name, type, attribute>

    例如,如果符号表必须存储有关以下变量声明的信息:

    static int interest;

    然后它应该存储条目,例如:

    <interest, int, static>

    attribute子句包含与名称相关的条目。

    实施Implementation

    如果编译器要处理少量数据,那么符号表可以实现为无序列表,这很容易编码,但它只适用于小表。符号表可以通过以下方式之一实现:

    线性(排序或未排序)列表

    二叉搜索树

    哈希表

    其中,符号表主要实现为哈希表,其中源代码符号本身被视为哈希函数的键,返回值是关于符号的信息。

    操作Operations

    符号表(线性或哈希)应提供以下操作。

    插入()

    此操作在分析阶段使用得更频繁,即编译器的前半部分,其中标识了标记并将名称存储在表中。此操作用于在符号表中添加有关源代码中出现的唯一名称的信息。存储名称的格式或结构取决于手头的编译器。

    源代码中符号的属性是与该符号关联的信息。此信息包含有关符号的值、状态、范围和类型。函数的作用是:将符号及其属性作为参数,并将信息存储在符号表中。

    For example:

    int a;

    应该由编译器处理为should be processed by the compiler as:

    insert(a, int);
    查找()              
    lookup()操作用于搜索符号表中的名称以确定:              
    如果符号存在于表中。              
    如果在使用前声明。              
    如果在作用域中使用了该名称。              
    如果符号已初始化。              
    如果符号声明了多次。  
    lookup(symbol)            
    lookup()函数的格式因编程语言而异。基本格式应符合以下要求:
    如果符号表中不存在该符号,则此方法返回0(零)。如果符号存在于符号表中,则返回存储在表中的其属性。              
    范围管理              
    编译器维护两种类型的符号表:一种全局符号表,它可以被所有过程访问,另一种是为程序中的每个作用域创建的作用域符号表。              
    为了确定名称的范围,符号表按层次结构排列,如下例所示:
    . . . 
    int value=10;
     
    void pro_one()
       {
       int one_1;
       int one_2;
       
          {              
          int one_3;      |_  inner scope 1 
          int one_4;      | 
          }              /
          
       int one_5; 
       
          {                 
          int one_6;      |_  inner scope 2
          int one_7;      |
          }              /
       }
       
    void pro_two()
       {
       int two_1;
       int two_2;
       
          {              
          int two_3;      |_  inner scope 3
          int two_4;      |
          }              /
          
       int two_5;
       }
    . . . 
    上述程序可以用符号表的层次结构表示:
    

    399163de4814da7bb52331abccab4f02.png
    全局符号表包含一个全局变量(int值)的名称和两个过程名称,这些名称应该对上面显示的所有子节点都可用。pro_one symbol表(及其所有子表)中提到的名称不适用于pro_two symbol及其子表。              
    此符号表数据结构层次结构存储在语义分析器中,当需要在符号表中搜索名称时,将使用以下算法进行搜索:              
    首先在当前范围内搜索一个符号,即当前符号表。              
    如果找到名称,则搜索完成,否则将在父符号表中搜索,直到,              
    找到该名称或已在全局符号表中搜索该名称。

    二.Compiler - Intermediate Code Generation

    一个源代码可以直接翻译成它的目标机器代码,那么我们为什么要把源代码翻译成一个中间代码,然后再翻译成它的目标代码呢?让我们看看需要中间代码的原因。
    

    45fbbb04dd432bb6c3d22e0baaf09849.png
    如果编译器在没有生成中间代码的选项的情况下将源语言转换为目标机器语言,那么对于每台新机器,都需要一个完整的本机编译器。              
    中间代码通过保持所有编译器的分析部分相同,消除了对每台唯一计算机使用新的完整编译器的需要。              
    编译器的第二部分,synthesis,是根据目标机器而改变的。              
    通过在中间代码上应用代码优化技术,可以更容易地应用源代码修改来提高代码性能。
    中间表示法Intermediate Representation              
    中间代码可以用多种方式表示,它们有自己的优点。              
    高级别的IR-高级别的中间代码表示非常接近源语言本身。它们可以很容易地从源代码生成,我们可以很容易地应用代码修改来提高性能。但对于目标机优化,则不太可取。              
    低级别的IR-这是一个接近目标机器,这使得它适合于寄存器和内存分配,指令集选择等。这是一个很好的机器相关的优化。              
    中间代码可以是特定于语言的(例如,Java的字节码)或独立于语言的(三地址码)。
    三地址码 Three-Address Code             
    中间代码生成器以带注释的语法树的形式接收来自其前一阶段语义分析器的输入。然后,可以将该语法树转换为线性表示法,例如后缀表示法。中间代码往往是与机器无关的代码。因此,代码生成器假设有无限数量的内存存储(寄存器)来生成代码。

    For example:

    a = b + c * d;
    中间代码生成器将尝试将此表达式划分为子表达式,然后生成相应的代码。
    r1 = c * d;
    r2 = b + r1;
    a = r2
    r用作目标程序中的寄存器。              
    一个三地址码最多有三个地址位置来计算表达式。三地址码可以用两种形式表示:四位和三位。              
    四倍Quadruples              
    四位数表示中的每条指令分为四个字段:operator、arg1、arg2和result。以上示例以四位数格式表示如下:
    

    dd839e97193dd5e21eb0d17a008adcfd.png
    三元组              
    三元组表示中的每条指令都有三个字段:op、arg1和arg2。各子表达式的结果由表达式的位置表示。三元组表示与DAG和语法树的相似性。它们在表示表达式时等价于DAG。
    

    f4088c222ebfbbb3c4209b65f96c906a.png
    三元组在优化时面临代码不可移动的问题,因为结果是位置的,更改表达式的顺序或位置可能会导致问题。              
    间接三元组              
    此表示是对三元组表示的增强。它使用指针而不是位置来存储结果。这使优化器能够自由地重新定位子表达式以生成优化的代码。              
    声明 Declarations             
    变量或过程在使用之前必须声明。声明涉及内存空间的分配以及符号表中类型和名称的输入。一个程序的编码和设计可以考虑到目标机器的结构,但可能并不总是能够准确地将源代码转换成目标语言。              
    将整个程序作为过程和子过程的集合,就可以声明过程的所有本地名称。内存分配是以连续的方式完成的,名称是按照在程序中声明的顺序分配给内存的。我们使用offset变量并将其设置为零{offset=0},表示基址。              
    源程序设计语言和目标机器体系结构的名称存储方式可能不同,因此使用相对寻址。当从内存位置0{offset=0}开始分配第一个名称时,后面声明的下一个名称应该在第一个名称旁边分配内存。              
    例子:              
    我们以C语言为例,其中一个整数变量被分配2字节的内存,一个浮点变量被分配4字节的内存。
    int a;
    float b;
     
    Allocation process:
    {offset = 0}
     
       int a;
       id.type = int
       id.width = 2
     
    offset = offset + id.width 
    {offset = 2}
     
       float b;
       id.type = float
       id.width = 4
       
    offset = offset + id.width 
    {offset = 6}
    要在符号表中输入此详细信息,可以使用过程enter。该方法可以具有以下结构:              
    enter(name, type, offset)             
    此过程应在符号表中为变量名创建一个条目,将其类型设置为类型,并在其数据区域中设置相对地址偏移量。
     
     
    展开全文
  • 完整的编译原理实验报告 关于语法、语义和词法分析器三部分的 很全哦 一、实验题目 表达式中间代码生成 二、实验目的 熟悉算术表达式的语法分析与中间代码生成原理。 三、实验内容 1. 构造算术表达式的四元式翻译...
  • 编译原理中间代码生成--java实现

    万次阅读 2018-05-31 08:17:38
    程序要求能自动生成AST抽象语法树。Lab3Main.javapackage sch.cauc.edu.token; import edu.ustc.cs.compile.platform.interfaces.InterRepresent; /** * * * Lab3Main * 创建人:xrzhang * 时间:2018年5月...

    本人博客内编译原理文章的配套资源jar包,包括词法分析,语法分析,中间代码生成,静态语义检查,代码解释执行以及抽象语法树的手动生成:https://download.csdn.net/download/as1072966956/10448935

    转载请注明出处。


    程序要求能自动生成AST抽象语法树。

    Lab3Main.java

    package sch.cauc.edu.token;
    
    import edu.ustc.cs.compile.platform.interfaces.InterRepresent;
    /**
     * 
     * 
     * Lab3Main
     * 创建人:xrzhang 
     * 时间:2018年5月25日-上午8:13:05 
     * @version 1.0.0
     *
     */
    public class Lab3Main {
    
    	public static void main(String[] args) {
    		//String srcFileName="test/expr3.txt";
    		//String srcFileName="test/expr221.txt";
    		String srcFileName="test/expr222.txt";
    		//String srcFileName="test/testown.txt";
    		SyntaxDirectedTranslation parser=new SyntaxDirectedTranslation();
    		InterRepresent ir=parser.doParse(srcFileName);
    		ir.showIR();
    	}
    }
    

    SyntaxDirectedTranslation.java

    package sch.cauc.edu.token;
    import java.util.LinkedList;
    
    
    
    import org.eclipse.jdt.core.dom.*;
    import edu.ustc.cs.compile.platform.interfaces.InterRepresent;
    import edu.ustc.cs.compile.util.ir.HIRPack;
    
    public class SyntaxDirectedTranslation {
    	/*抽象语法树的根节点*/
    	private AST ast=null;
    	private BlockLexer lexer=null;
    	private Token lookAhead=null;
    	 public SyntaxDirectedTranslation() {
    		ast = AST.newAST(AST.JLS3);
    	}
    	 public InterRepresent doParse(String filePath){
    		 lexer=new BlockLexer(filePath);
    		 Block mainBody = this.parse();
    		 HIRPack ir = new HIRPack();
    		 ir.setIR(mainBody);
    		 return ir;
    	 }
    	 public Token matchToken(TokenType type,String functionName){
    		
    		 if(lookAhead.getType()!=type){
    			 parsingError(type.toString(),functionName);
    		 }
    		 Token matchedSymbol = lookAhead;
    		 lookAhead = lexer.nextToken();
    		 return matchedSymbol; 
    	 }
    	 public void parsingError(String types,String functionName){
    			System.out.println("Parsing Error! in"+functionName);
    			System.out.println("encounter "+lookAhead.getLexeme());
    			System.out.println("at line "+lookAhead.getLine()+",column "+lookAhead.getColumn());
    			System.out.println("while expecting "+types);
    			System.exit(1);
    		}
    	 /**
    	 * 
    	 * 调用开始符号对应的方法,进行语法分析
    	 * 方法名:parse
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-上午10:27:14 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	public Block parse() {
    		System.out.println("In parse();-----jmzhang-----");
    		lookAhead=lexer.nextToken();
    		Block mainBody=simpleblock();
    		System.out.println("Parsing Success!");
    		return mainBody;
    	}
    	/**
    	 * 
    	 * simpleblock = LBRACE sequence RBRACE
    	 * B->{S}
    	 * 方法名:simpleblock
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月19日-下午6:59:57 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	public  Block simpleblock() {
    		System.out.println("In simpleblock();-----jmzhang-----");
    		if(lookAhead.getType()==TokenType.LBRACKET){
    			matchToken(TokenType.LBRACKET, "simpleblock");
    			System.out.println("***********{*********");
    			LinkedList seq =sequence();
    			matchToken(TokenType.RBRACKET, "simpleblock");
    			System.out.println("***********}*********");
    			Block mainBody=ast.newBlock();
    			if (seq!=null) {
    				for(int i=0;i<seq.size();i++){
    					mainBody.statements().add(seq.get(i));
    				}
    			}
    			return mainBody;
    		}else{
    			parsingError(TokenType.LBRACKET.toString(), "simpleblock");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * sequence=assognmentStatement sequence |
    	 * 			ifStatement sequence |
    	 * 			whileStatement sequence |
    	 * 			epsilon
    	 * S->AS | IS |WS | ε
    	 * 方法名:Sequence
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午8:54:23 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private LinkedList sequence() {
    		System.out.println("In Sequence();-----jmzhang-----");
    		if(lookAhead.getType()==TokenType.IDENTIFIER){
    		
    			ExpressionStatement es=assignmentStatement();
    			LinkedList seq=sequence();
    			if (seq==null) {
    				seq=new LinkedList();
    				}
    			seq.addFirst(es);
    			return seq;
    		}else if (lookAhead.getType()==TokenType.KEY_IF) {
    			
    			IfStatement es=ifStatement();
    			LinkedList seq=sequence();
    			if (seq==null) {
    				seq=new LinkedList();
    				}
    			seq.addFirst(es);
    			return seq;
    		}else if (lookAhead.getType()==TokenType.KEY_WHILE) {
    			System.out.println("In Sequence();-----jmzhang-----WHILE");
    			WhileStatement es=whileStatement();
    			LinkedList seq=sequence();
    			if (seq==null) {
    				seq=new LinkedList();
    				}
    			seq.addFirst(es);
    			return seq;
    		}else if (lookAhead.getType()==TokenType.RBRACKET) {
    			//match epslon
    			return null;
    		}else {
    			String errorTypes=TokenType.IDENTIFIER.toString()+","+TokenType.RBRACKET.toString();
    			parsingError(errorTypes, "sequence");
    			return null;
    		}
    	}
    	/************************************>
    	 * @return ************************************/
    	
    	
    	
    	
    	
    	private WhileStatement whileStatement() {
    		System.out.println("In whileStatement();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.KEY_WHILE) {
    			matchToken(TokenType.KEY_WHILE, "whileStatement");
    			WhileStatement wStatement=ast.newWhileStatement();
    			
    			System.out.println("***********while*********");
    			matchToken(TokenType.LPAREN, "whileStatement");
    			System.out.println("***********(*********");
    			Expression be=Boolexpression();
    			wStatement.setExpression(be);
    			matchToken(TokenType.RPAREN, "whileStatement");
    			System.out.println("***********)*********");
    			matchToken(TokenType.LBRACKET, "whileStatement");
    			System.out.println("***********{*********");
    			
    			Block ifbody=ast.newBlock();
    			LinkedList seq =sequence();
    			if (seq!=null) {
    				for(int i=0;i<seq.size();i++){
    					ifbody.statements().add(seq.get(i));
    				}
    			}
    			wStatement.setBody(ifbody);
    			matchToken(TokenType.RBRACKET, "whileStatement");
    			System.out.println("***********}*********");
    			
    			/*if (seq!=null) {
    				for(int i=0;i<seq.size();i++){
    					mainBody.statements().add(seq.get(i));
    				}
    			}*/
    			return wStatement;
    		}else {
    			String errorTypes=TokenType.KEY_WHILE.toString();
    			parsingError(errorTypes, "whileStatement");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * 
    	 * 方法名:Boolexpression
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月19日-下午8:58:23 
    	 * 邮件:jmzhang_15_cauc@163.com
    	 * @return Expression
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression Boolexpression() {
    		System.out.println("In Boolexpression();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.BOOL_TRUE
    				||lookAhead.getType()==TokenType.BOOL_FALSE
    				||lookAhead.getType()==TokenType.LPAREN
    				||lookAhead.getType()==TokenType.IDENTIFIER
    				||lookAhead.getType()==TokenType.INTEGER_LITERAL) {
    			InfixExpression infix=ast.newInfixExpression();
    			
    			Expression left=Boolterm();
    			Expression right=Boolexpression_1(left);
    			return right;
    		}else {
    			String errorTypes =TokenType.BOOL_TRUE.toString()
    					+","+TokenType.BOOL_FALSE.toString()
    					+","+TokenType.LPAREN.toString()
    					+","+TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString();
    			parsingError(errorTypes, "Boolexpression");
    			return null;
    		}	
    	}
    	/**
    	 * 
    	 * 方法名:Boolexpression_1
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月19日-下午9:02:26 
    	 * 邮件:jmzhang_15_cauc@163.com
    	 * @param left
    	 * @return Expression
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression Boolexpression_1(Expression left) {
    		System.out.println("In Boolexpression_1();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.LOGICAL_OR) {
    			matchToken(TokenType.LOGICAL_OR, "Boolexpression_1");
    			System.out.println("***********||*********");
    			Expression right=Boolterm();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			Expression e=Boolexpression_1(infixEx);
    			return e;
    		}else if (lookAhead.getType()==TokenType.RPAREN) {
    			//match epslin
    			//follow(E')={')',','}
    			return left;
    		}else {
    			String errorTypes =TokenType.LOGICAL_OR.toString()
    					+","+TokenType.RPAREN.toString();
    			parsingError(errorTypes, "Boolexpression_1");
    			return null;
    		}	
    	}
    	/**
    	 * 
    	 * 方法名:Boolterm
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月19日-下午9:03:36 
    	 * 邮件:jmzhang_15_cauc@163.com
    	 * @return Expression
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression Boolterm() {
    		System.out.println("In Boolterm();-----jmzhang-----");
    		if(lookAhead.getType()==TokenType.BOOL_TRUE
    				||lookAhead.getType()==TokenType.BOOL_FALSE
    				||lookAhead.getType()==TokenType.LPAREN
    				||lookAhead.getType()==TokenType.IDENTIFIER
    				||lookAhead.getType()==TokenType.INTEGER_LITERAL){
    			Expression f=Boolfactor();
    			Expression t=Boolterm_1(f);
    			return t;
    		}else {
    			String errorTypes =TokenType.BOOL_TRUE.toString()
    					+","+TokenType.BOOL_FALSE.toString()
    					+","+TokenType.LPAREN.toString()
    					+","+TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString();
    			parsingError(errorTypes, "Boolterm");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * 方法名:Boolterm_1
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月19日-下午9:08:20 
    	 * 邮件:jmzhang_15_cauc@163.com
    	 * @param left
    	 * @return Expression
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression Boolterm_1(Expression left) {
    		System.out.println("In Boolterm_1();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.LOGICAL_AND) {
    			matchToken(TokenType.LOGICAL_AND, "Boolterm_1");
    			System.out.println("***********&&*********");
    			Expression right=Boolfactor();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setOperator(InfixExpression.Operator.AND);
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			Expression t=Boolterm_1(infixEx);
    			return t;
    		}else if (lookAhead.getType()==TokenType.LOGICAL_OR
    				||lookAhead.getType()==TokenType.RPAREN) {
    			//match e[slion
    			//follow(T')={'+','-',')',',')
    			return left;
    		}else {
    			String errorTypes =TokenType.LOGICAL_AND.toString()
    					+","+TokenType.LOGICAL_OR.toString()
    					+","+TokenType.RPAREN.toString();
    			parsingError(errorTypes, "Boolterm_1");
    			return null;
    		}
    		
    		
    	}
    
    	private Expression Boolfactor() {
    		System.out.println("In Boolfactor();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.BOOL_TRUE) {
    			Token id=matchToken(TokenType.BOOL_TRUE, "Boolfactor");
    			System.out.println("***********true*********");
    			SimpleName sn=ast.newSimpleName(id.getLexeme());
    			return sn;
    			
    		}else if (lookAhead.getType()==TokenType.BOOL_FALSE) {
    			
    			Token num=matchToken(TokenType.BOOL_FALSE, "Boolfactor");
    			System.out.println("***********flase*********");
    			NumberLiteral nl=ast.newNumberLiteral(num.getLexeme());
    			return nl;
    		}else if (lookAhead.getType()==TokenType.LPAREN||
    				lookAhead.getType()==TokenType.IDENTIFIER||
    				lookAhead.getType()==TokenType.INTEGER_LITERAL){
    			Expression r=relationlExpression();
    			return r;
    		}else {
    			String errorTypes =TokenType.BOOL_TRUE.toString()
    					+","+TokenType.BOOL_FALSE.toString()
    					+","+TokenType.LPAREN.toString()
    					+","+TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString();
    			parsingError(errorTypes, "relationlExpressionOperator");
    			return null;
    		}		
    	}
    
    	private Expression relationlExpression() {
    		System.out.println("In relationlExpression();-----jmzhang-----");
    		
    		if (lookAhead.getType()==TokenType.LPAREN||
    				lookAhead.getType()==TokenType.IDENTIFIER||
    				lookAhead.getType()==TokenType.INTEGER_LITERAL) {
    			InfixExpression infix=ast.newInfixExpression();
    			Expression left=expression();
    			infix.setLeftOperand(left);
    			//Expression r=relationlExpressionOperator();
    			infix.setOperator(relationlExpressionOperator());
    			Expression right=expression();
    			infix.setRightOperand(right);
    			return infix;
    		}else {
    			String errorTypes =TokenType.LPAREN.toString()
    					+","+TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString();
    			parsingError(errorTypes, "relationlExpression");
    			return null;
    		}
    	}
    
    	private InfixExpression.Operator relationlExpressionOperator() {
    		System.out.println("In relationlExpressionOperator();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.LESS) {
    			matchToken(TokenType.LESS, "relationlExpressionOperator");
    			System.out.println("***********<*********");
    			return InfixExpression.Operator.LESS;
    		}else if (lookAhead.getType()==TokenType.GREATER) {
    			matchToken(TokenType.GREATER, "relationlExpressionOperator");
    			System.out.println("***********>*********");
    			return InfixExpression.Operator.GREATER;
    		}else if (lookAhead.getType()==TokenType.LESS_EQUAL) {
    			matchToken(TokenType.LESS_EQUAL, "relationlExpressionOperator");
    			System.out.println("***********<=*********");
    			return InfixExpression.Operator.LESS_EQUALS;
    		}else if (lookAhead.getType()==TokenType.GREATER_EQUAL) {
    			matchToken(TokenType.GREATER_EQUAL, "relationlExpressionOperator");
    			System.out.println("***********>=*********");
    			return InfixExpression.Operator.GREATER_EQUALS;
    		}else if (lookAhead.getType()==TokenType.NOT_EQUAL) {
    			matchToken(TokenType.NOT_EQUAL, "relationlExpressionOperator");
    			System.out.println("***********!=*********");
    			return InfixExpression.Operator.NOT_EQUALS;
    		}else if(lookAhead.getType()==TokenType.EQUAL) {
    			matchToken(TokenType.EQUAL, "relationlExpressionOperator");
    			System.out.println("***********==*********");
    			return InfixExpression.Operator.EQUALS;
    		}else {
    			String errorTypes =TokenType.LESS.toString()
    					+","+TokenType.GREATER.toString()
    					+","+TokenType.LESS_EQUAL.toString()
    					+","+TokenType.GREATER_EQUAL.toString()
    					+","+TokenType.NOT_EQUAL.toString()
    					+","+TokenType.EQUAL.toString();
    			parsingError(errorTypes, "relationlExpressionOperator");
    			return null;
    		}
    	}
    
    	private IfStatement ifStatement() {
    		System.out.println("In ifStatement();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.KEY_IF) {
    			
    			matchToken(TokenType.KEY_IF, "ifStatement");
    			IfStatement is = ast.newIfStatement();
    			System.out.println("***********if*********");
    			matchToken(TokenType.LPAREN, "ifStatement");
    			System.out.println("***********(*********");
    			
    			Expression be=Boolexpression();
    			is.setExpression(be);
    			matchToken(TokenType.RPAREN, "ifStatement");
    			System.out.println("***********)*********");
    			matchToken(TokenType.LBRACKET, "ifStatement");
    			System.out.println("***********{*********");
    			
    			Block ifbody=ast.newBlock();
    			LinkedList seq =sequence();
    			if (seq!=null) {
    				for(int i=0;i<seq.size();i++){
    					ifbody.statements().add(seq.get(i));
    				}
    			}
    			
    			is.setThenStatement(ifbody);
    			matchToken(TokenType.RBRACKET, "ifStatement");
    			System.out.println("***********}*********");
    			if(lookAhead.getType()==TokenType.KEY_ELSE)
    			{
    				
    				Block o=OptionalElse();
    				is.setElseStatement(o);
    			}
    			return is;
    		}else {
    			String errorTypes=TokenType.KEY_IF.toString();
    			parsingError(errorTypes, "ifStatement");
    			return null;
    		}
    	}
    
    	private Block OptionalElse() {
    		System.out.println("In OptionalElse();-----jmzhang-----");
    		if(lookAhead.getType()==TokenType.KEY_ELSE){
    			System.out.println("In OptionalElse();-----jmzhang-----1");
    			matchToken(TokenType.KEY_ELSE, "OptionalElse");
    			IfStatement elIfStatement =ast.newIfStatement();
    			System.out.println("***********else*********");
    			matchToken(TokenType.LBRACKET, "OptionalElse");
    			System.out.println("***********{*********");
    			Block ifbody=ast.newBlock();
    			LinkedList seq =sequence();
    			if (seq!=null) {
    				for(int i=0;i<seq.size();i++){
    					ifbody.statements().add(seq.get(i));
    				}
    			}
    			
    			
    		
    			
    			matchToken(TokenType.RBRACKET, "OptionalElse");
    			System.out.println("***********}*********");
    			return ifbody;
    		}else if (lookAhead.getType()==TokenType.RBRACKET
    				||lookAhead.getType()==TokenType.KEY_IF
    				||lookAhead.getType()==TokenType.KEY_WHILE
    				||lookAhead.getType()==TokenType.IDENTIFIER) {
    			//match epslion
    			return null;
    		}else {
    			String errorTypes =TokenType.KEY_ELSE.toString()
    					+","+TokenType.RBRACKET.toString()
    					+","+TokenType.KEY_IF.toString()
    					+","+TokenType.KEY_WHILE.toString()
    					+","+TokenType.IDENTIFIER.toString();
    			parsingError(errorTypes, "OptionalElse");
    			return null;
    		}
    		
    	}
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	/*************************************<**********************************/
    	/**
    	 * 
    	 * assignmentStatement =IDENTIFIER ASSIGN expression SEMICOLON
    	 * A->id = E;
    	 * 方法名:assignmentStatement
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午8:56:26 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private ExpressionStatement assignmentStatement() {
    		System.out.println("In assignmentStatement();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.IDENTIFIER) {
    			
    			Token id =matchToken(TokenType.IDENTIFIER, "assignmentStatement");
    			System.out.println("***********id*********");
    			matchToken(TokenType.ASSIGN, "assignmentStatement");
    			System.out.println("***********=*********");
    			Expression e=expression();
    			matchToken(TokenType.SEMICOLON, "assignmentStatement");
    			System.out.println("***********;*********");
    			SimpleName sn=ast.newSimpleName(id.getLexeme());
    			Assignment assign=ast.newAssignment();
    			assign.setLeftHandSide(sn);
    			assign.setOperator(Assignment.Operator.ASSIGN);
    			assign.setRightHandSide(e);
    			ExpressionStatement es=ast.newExpressionStatement(assign);
    			return es;
    		}else {
    			String errorTypes=TokenType.IDENTIFIER.toString();
    			parsingError(errorTypes, "assignmentStatement");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * expression = term expression_1
    	 * E->TE'
    	 * 方法名:expression
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午9:00:40 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression expression() {
    		System.out.println("In expression();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.IDENTIFIER
    				||lookAhead.getType()==TokenType.LPAREN
    				||lookAhead.getType()==TokenType.INTEGER_LITERAL) {
    			Expression left=term();
    			Expression right=expression_1(left);
    			return right;
    		}else {
    			String errorTypes =TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString()
    					+","+TokenType.LPAREN.toString();
    			parsingError(errorTypes, "expression");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * expression_1=PLUS term expression_1 | MINUS term expression_1 | epslin
    	 * E'->TE' | -TE' | ε
    	 * 方法名:expression_1
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午9:06:26 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression expression_1(Expression left) {
    		System.out.println("In expression_1();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.PLUS) {
    			matchToken(TokenType.PLUS, "expression_1");
    			System.out.println("***********+*********");
    			Expression right=term();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			
    			Expression e=expression_1(infixEx);
    			return e;
    		}else if (lookAhead.getType()==TokenType.MINUS) {
    			
    			matchToken(TokenType.MINUS, "expression_1");
    			System.out.println("***********-*********");
    			Expression right=term();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setOperator(InfixExpression.Operator.MINUS);
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			Expression e=expression_1(infixEx);
    			return e;
    		}else if (lookAhead.getType()==TokenType.SEMICOLON
    				||lookAhead.getType()==TokenType.LESS
    				||lookAhead.getType()==TokenType.GREATER
    				||lookAhead.getType()==TokenType.LESS_EQUAL
    				||lookAhead.getType()==TokenType.GREATER_EQUAL
    				||lookAhead.getType()==TokenType.NOT_EQUAL
    				||lookAhead.getType()==TokenType.EQUAL
    				||lookAhead.getType()==TokenType.LOGICAL_AND
    				||lookAhead.getType()==TokenType.LOGICAL_OR
    				||lookAhead.getType()==TokenType.RPAREN) {
    			System.out.println("In expression_1();-----jmzhang-----follow");
    			//match epslin
    			//follow(E')={')',','}
    			return left;
    		}else {
    			System.out.println("In expression_1();-----jmzhang-----else");
    			String errorTypes =TokenType.PLUS.toString()
    					+","+TokenType.MINUS.toString()
    					+","+TokenType.SEMICOLON.toString()
    					+","+TokenType.LESS.toString()
    					+","+TokenType.GREATER.toString()
    					+","+TokenType.LESS_EQUAL.toString()
    					+","+TokenType.GREATER_EQUAL.toString()
    					+","+TokenType.NOT_EQUAL.toString()
    					+","+TokenType.EQUAL.toString();
    			parsingError(errorTypes, "expression_1");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * term=factor term_1
    	 * T->FT'
    	 * 方法名:term
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午9:16:51 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression term() {
    		System.out.println("In term();-----jmzhang-----");
    		if(lookAhead.getType()==TokenType.IDENTIFIER
    				||lookAhead.getType()==TokenType.LPAREN
    				||lookAhead.getType()==TokenType.INTEGER_LITERAL){
    			Expression f=factor();
    			Expression t=term_1(f);
    			return t;
    		}else {
    			String errorTypes =TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString()
    					+","+TokenType.LPAREN.toString();
    			parsingError(errorTypes, "term");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * term_1=MULT factor term_1 | DIV factor term_1 | MOD factor term_1 | epslin
    	 * T'->*FT' | /FT' |%FT'|ε
    	 * 方法名:term_1
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午9:20:00 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression term_1(Expression left) {
    		System.out.println("In term_1();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.TIMES) {
    			matchToken(TokenType.TIMES, "term_1");
    			System.out.println("***********乘*********");
    			Expression right=factor();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setOperator(InfixExpression.Operator.TIMES);
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			Expression t=term_1(infixEx);
    			return t;
    		}else if (lookAhead.getType()==TokenType.DIVIDE) {
    			matchToken(TokenType.DIVIDE, "term_1");
    			System.out.println("***********/*********");
    			Expression right=factor();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setOperator(InfixExpression.Operator.DIVIDE);
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			Expression t=term_1(infixEx);
    			return t;
    		}else if (lookAhead.getType()==TokenType.REMAINDER) {
    			matchToken(TokenType.REMAINDER, "term_1");
    			System.out.println("***********%*********");
    			Expression right=factor();
    			InfixExpression infixEx=ast.newInfixExpression();
    			infixEx.setOperator(InfixExpression.Operator.REMAINDER);
    			infixEx.setLeftOperand(left);
    			infixEx.setRightOperand(right);
    			Expression t=term_1(infixEx);
    			return t;
    		}else if (lookAhead.getType()==TokenType.PLUS
    				||lookAhead.getType()==TokenType.MINUS
    				||lookAhead.getType()==TokenType.RPAREN
    				||lookAhead.getType()==TokenType.SEMICOLON
    				||lookAhead.getType()==TokenType.LESS
    				||lookAhead.getType()==TokenType.GREATER
    				||lookAhead.getType()==TokenType.LESS_EQUAL
    				||lookAhead.getType()==TokenType.GREATER_EQUAL
    				||lookAhead.getType()==TokenType.NOT_EQUAL
    				||lookAhead.getType()==TokenType.EQUAL
    				||lookAhead.getType()==TokenType.LOGICAL_AND
    				||lookAhead.getType()==TokenType.LOGICAL_OR
    				||lookAhead.getType()==TokenType.RPAREN) {
    			//match e[slion
    			//follow(T')={'+','-',')',',')
    			return left;
    		}else {
    			String errorTypes =TokenType.TIMES.toString()
    					+","+TokenType.DIVIDE.toString()
    					+","+TokenType.REMAINDER.toString()
    					+","+TokenType.PLUS.toString()
    					+","+TokenType.MINUS.toString()
    					+","+TokenType.SEMICOLON.toString()
    					+","+TokenType.LESS.toString()
    					+","+TokenType.GREATER.toString()
    					+","+TokenType.LESS_EQUAL.toString()
    					+","+TokenType.GREATER_EQUAL.toString()
    					+","+TokenType.NOT_EQUAL.toString()
    					+","+TokenType.EQUAL.toString()
    					+","+TokenType.LOGICAL_AND.toString()
    					+","+TokenType.LOGICAL_OR.toString();
    			parsingError(errorTypes, "term_1");
    			return null;
    		}
    	}
    	/**
    	 * 
    	 * factor = LPAREN expression RPAREN | IDENTIFER|INTEGER_LITERAL
    	 * F->(E)|id| number
    	 * 方法名:factor
    	 * 创建人:xrzhang 
    	 * 时间:2018年5月16日-下午9:29:47 
    	 * 邮件:jmzhang_15_cauc@163.com void
    	 * @exception 
    	 * @since  1.0.0
    	 */
    	private Expression factor() {
    		System.out.println("In factor();-----jmzhang-----");
    		if (lookAhead.getType()==TokenType.LPAREN) {
    			matchToken(TokenType.LPAREN, "factor");
    			System.out.println("***********(*********");
    			Expression e=expression();
    			matchToken(TokenType.RPAREN, "factor");
    			System.out.println("***********)*********");
    			ParenthesizedExpression pe=ast.newParenthesizedExpression();
    			pe.setExpression(e);
    			return pe;
    		}else if (lookAhead.getType()==TokenType.IDENTIFIER) {
    			Token id=matchToken(TokenType.IDENTIFIER, "factor");
    			System.out.println("***********id*********");
    			SimpleName sn=ast.newSimpleName(id.getLexeme());
    			return sn;
    		}else if (lookAhead.getType()==TokenType.INTEGER_LITERAL) {
    			Token num=matchToken(TokenType.INTEGER_LITERAL, "factor");
    			System.out.println("***********int*********");
    			NumberLiteral nl=ast.newNumberLiteral(num.getLexeme());
    			return nl;
    		}else {
    			String errorTypes =TokenType.LPAREN.toString()
    					+","+TokenType.IDENTIFIER.toString()
    					+","+TokenType.INTEGER_LITERAL.toString();
    			parsingError(errorTypes, "factor");
    			return null;
    		}
    	}
    }


    测试文件expr3.txt

    {
    	i1=14;
    	i2=i1+2*3;
    	i3=i1-5*(i2%2)+5;
    }

    测试文件expr221.txt

    {
    	i1=14;
    	i2=i1+2*3;
    	i3=i1-5*(i2%2)+5;
    	if(4<5){}
    	if(i1==i4&&i2>=20){
    		i3=i3+1;}
    	else{
    	i3=i3+2;}
    }

    测试文件expr222.txt

    {
    	m=12;n=21;
    	if(m<n){
    		t=m;m=n;n=t;
    	}
    	r=1;
    	d=m%n;
    	while(r!=0){m=n;n=r;r=m%n;}
    	
    }




    展开全文
  • 编译原理中间代码生成

    千次阅读 2020-04-07 12:35:44
    如果不生成中间代码而是直接生成机器语言或者汇编语言形式的目标代码,优点是编译时间短,缺点是目标代码执行效率和质量都比较低,移植性差。 为什么不直接翻译成机器码呢,而多此一举生成中间代码再转换?(代码的...

    中间代码定义

    源程序的一种内部表示,不依赖目标机的结构,易于机械生成目标代码的中间表示。
    如果不生成中间代码而是直接生成机器语言或者汇编语言形式的目标代码,优点是编译时间短,缺点是目标代码执行效率和质量都比较低,移植性差。

    为什么不直接翻译成机器码呢,而多此一举生成中间代码再转换?(代码的鲁棒性)

    是为了提高编译器的可移植性,因为不同的cpu的指令集是不一样的,假如直接翻译成机器代码,那么当你换了一块cpu之后,可能你的编译器就完全不能运行了,所以为了鲁棒性,将代码先翻译成中间代码,然后在能在多个不同的cpu上做出相应的改变并且运行了。
    在这里插入图片描述

    使用中间代码的好处:

    1)一是便于编译器程序的开发和移植(鲁棒性)
    2)二是代码进行优化处理

    常见的中间代码表示形式

    逆波兰式(后缀式)、三地址码(三元式、四元式)、抽象语法树、有向无环图。

    逆波兰式 运算量(操作数)写在前面,把运算符写在后面,因此又称为后缀表示法
    在这里插入图片描述

    三地址码——最常用的中间代码形式是三地址码,它的实现形式常采用四元式形式。
    指每条代码包含一个运算和三个地址,两个地址用于存放运算对象,一个地址用于存放运算结果。其一般形式为x=y op z。
    四元式
    一个四元式具有四个域的记录结构,表示为:(op,arg1,arg2,result)。op为运算符;result存放运算结果;arg为运算对象,如果为空,则使用空格,留出位置。
    四元式与三元式的唯一区别:
    将由序号所表示的运算结果改为:用(临时)变量来表示。
    此改变使得四元式的运算结果与其在四元式序列中的位置无关.为代码的优化提供了极大方便,因为这样可以删除或移动四元式而不会影响运算结果.
    在这里插入图片描述

    例:将 a=b*c+b*d用三元形式
    (1) (*,b,c)
    (2) (*,b,d)
    (3) (+,(1),(2))
    (4) (=,(3),a)
    
    例:将 a=b*c+b*d用四元式形式
    写成三地址码的赋值语句形式如下:
        1) t1 = b*c
        2) t2 = b*d
        3) t3 =t1+t2
        4) a = t3
    写成四元形式如下:
        1) (*,b,c,t1)
        2) (*,b,d,t2)
        3) (+,t1,t2,t3)
        4) (=,t3, ,a)
    

    抽象语法树
    抽象语法树(Abstract SyntaxCode,AST)是语法树的一种简化形式,是源程序的抽象语法结构的树状表示,树的每个节点都表示源代码中的一种结构。

    有向无环图
    有向无环图(Directed Acyclic Graph,简称DAG)对表达式中的每个子表达式都有一个结点,内部结点表示运算符,它的孩子代表运算分量。DAG中代表公共子表达式的结点只出现一次,具有多个父结点。

    一个例子

    声明语句的翻译之变量的声明 一个变量的声明应该由两部分来完成:类型的定义和变量的声明
    类型定义:为编译器提供存储空间大小的信息
    变量声明:为变量分配存储空间
    组合数据的类型定义和变量声明:定义与声明在一起,定义与声明分离.

    引用于介篇文章

    展开全文
  • 编译原理-中间代码生成

    千次阅读 2019-04-17 10:43:52
    如果不生成中间代码而是直接生成机器语言或者汇编语言形式的目标代码,优点是编译时间短,缺点是目标代码执行效率和质量都比较低,移植性差。 1.2 表示形式 逆波兰式(后缀式)、三地址码(三元式、四元式)、...

     

    1.概述

    1.1 定义

        源程序的一种内部表示,不依赖目标机的结构,易于机械生成目标代码的中间表示。如果不生成中间代码而是直接生成机器语言或者汇编语言形式的目标代码,优点是编译时间短,缺点是目标代码执行效率和质量都比较低,移植性差。

    1.2 表示形式

        逆波兰式(后缀式)、三地址码(三元式、四元式)、抽象语法树、有向无环图。

    1.3 地位

        如下所示:

     

    2.逆波兰式

    2.1 定义

          把运算量(操作数)写在前面,把运算符写在后面,因此又称为后缀表示法

    2.2 案例

          如下所示:

    表达式语句 逆波兰式
    a+b ab+
    (a+b)*c ab+c*
    a+b*c abc*+
    a=b*c+b*d abc*bd*+=

     

    3.三元地址

    3.1 定义

        指每条代码包含一个运算和三个地址,两个地址用于存放运算对象,一个地址用于存放运算结果。其一般形式为

    x=y op z。

    3.2 四元式

    3.2.1 定义

        一个四元式具有四个域的记录结构,表示为:(op,arg1,arg2,result)。op为运算符;result存放运算结果;arg为运算对象,如果为空,则使用空格,留出位置。

    3.2.2 案例

    例:将 a=b*c+b*d用四元式形式
    写成三地址码的赋值语句形式如下:
        1) t1 = b*c
        2) t2 = b*d
        3) t3 =t1+t2
        4) a = t3
    写成四元形式如下:
        1) (*,b,c,t1)
        2) (*,b,d,t2)
        3) (+,t1,t2,t3)
        4) (=,t3, ,a)

    3.3 三元式

    3.3.1 定义

           一个三元式具有三个域的记录结构,表示为:(op,arg1,arg2)。

    3.3.2 案例

    例:将 a=b*c+b*d用三元形式
    (1) (*,b,c)
    (2) (*,b,d)
    (3) (+,(1),(2))
    (4) (=,(3),a)

    3.4 抽象语法树

    3.4.1 定义

         抽象语法树(Abstract Syntax Code,AST)是语法树的一种简化形式,是源程序的抽象语法结构的树状表示,树的每个节点都表示源代码中的一种结构。

    3.5 有向无环图

    3.5.1 定义

       有向无环图(Directed Acyclic Graph,简称DAG)对表达式中的每个子表达式都有一个结点,内部结点表示运算符,它的孩子代表运算分量。DAG中代表公共子表达式的结点只出现一次,具有多个父结点。

     

     

     

     

     

    展开全文
  • 预备知识 源语言->中间代码->目标语言 中间代码(Intermediate Representation或者IR):复杂性...编译程序锁使用的中间代码有多种形式。常见的有逆波兰记号,三元式。四元式。和树形表示。四元式是一种普...
  • (3)使编译程序的结构在逻辑上更为简单明确,以中间语言为界面,编译前端和后端的接口更清晰。 中间语言的形式:后缀式,图表示法,三元式 编译过程中不同语言的翻译或处理方法:说明语句的翻译,赋值语句的...
  • 采用递归下降语法制导翻译法,对算术表达式、赋值语句进行语义分析并生成三地址指令。
  • 编译原理代码生成

    千次阅读 2017-12-18 16:13:41
    目标代码生成阶段的任务是:将此前的中间代码转换成特定机器上的机器语言或汇编语言,这种转换程序便被称为代码生成器。1. 程序移植性和编译器模块设计的关系 之所以将编译原理分成这种多阶段多模块的组织形式,...
  • 第1页/共73页7.1 一个简单代码生成器 我们首先介绍一个简单的代码生成器此生成器依次把每条中间代码变换成目标代码并且在一个基本块范围内考虑如何充分利用寄存器的问题一方面在基本块中当生成计算某变量值的目标...
  • 属性文法;表达式文法 ET+T| T or T T n | b E T1 + T2 { T1.type = int T2.type= T1.type E.type :=int} E T1 or T2 { T1.type = bool T2.type= T1.type E.type :=bool} T n { T.type := int} T b { T.type := bool}...
  • Java 实现《编译原理中间代码生成 -逆波兰式生成与计算 编译原理学习笔记 (一)逆波兰式是什么? 逆波兰式(Reverse Polish notation,RPN,或逆波兰记法),也叫 后缀表达式(将运算符写在操作数之后) 一般的...
  • 一个简单的编辑器 编译原理课设 对简单的程序进行语义分析并将中间代码生成
  • 编译原理语义分析和中间代码生成实验报告,基于VS2010开发的纯C#的程序,附程序执行截图

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 910
精华内容 364
关键字:

编译原理中间代码生成代码