精华内容
下载资源
问答
  • 编译原理语法分析实验
    千次阅读
    2015-05-31 00:09:49

    import java.util.Stack;
    
    
    public class LL1 {
    	
    	//加入同步符号的LL(1)分析表
    	private  String [][] analysisTable = new String[][]{
    			{"TZ","","","TZ","synch","synch"},
    			{"","+TZ","","","ε","ε"},
    			{"FY","synch","","FY","synch","synch"},
    			{"","ε","*FY","","ε","ε"},
    			{"i","synch","synch","(E)","synch","synch"}
    	};
    	
    	//存储终结符
    	private String [] VT = new String[]{"i","+","*","(",")","#"};
    	
    	//存储终结符
    	private String [] VN = new String[]{"E","Z","T","Y","F"};
    	
    	//输入串
    	private StringBuilder strToken = new StringBuilder(")i*+i");
    	
    	//分析栈
    	private Stack<String> stack = new Stack<String>();
    	
    	//a保存从输入串中读取的一个输入符号,当前符号
    	private String a = null;
    	
    	//X中保存stack栈顶符号
    	private String X = null;
    	
    	//flag标志预测分析是否成功
    	private boolean flag = true;
    	
    	//记录输入串中当前字符的位置
    	private int cur = 0;
    	
    	//记录步数
    	private int count = 0;
    
    	//初始化
    	protected void init(){
    		strToken.append("#");
    		stack.push("#");
    		System.out.printf("%-9s %-38s %6s %-20s\n","步骤 ","符号栈 ","输入串 ","所用产生式 ");
    		stack.push("E");
    		curCharacter();
    		System.out.printf("%-6d %-20s %6s \n",count,stack.toString(),strToken.substring(cur, strToken.length()));
    	}
    	
    	//读取当前栈顶符号
    	protected String stackPeek(){
    		X = stack.peek();
    		return X;
    	}
    	
    	//返回输入串中当前位置的字母
    	private String curCharacter(){
    			a = String.valueOf(strToken.charAt(cur));
    		return a;
    	}
    	
    	//判断X是否是终结符
    	protected boolean XisVT(){
    		for(int i = 0 ; i < (VT.length - 1); i++){
    			if(VT[i].equals(X)){
    				return true;
    			}
    		}
    		return false;
    	}
    	
    	//查找X在非终结符中分析表中的横坐标
    	protected String VNTI(){
    		int Ni = 0 , Tj = 0;
    		for(int i = 0 ; i < VN.length ; i++){
    			if(VN[i].equals(X)){
    				Ni = i;
    			}
    		}
    		for(int j = 0 ; j < VT.length ; j++){
    			if(VT[j].equals(a)){
    				Tj = j;
    			}
    		}
    		return analysisTable[Ni][Tj];
    	}
    	
    	//判断M[A,a]={X->X1X2...Xk}
    	//把X1X2...Xk推进栈
    	//X1X2...Xk=ε,不推什么进栈
    	protected boolean productionType(){
    		if(VNTI() != ""){
    			return true;
    		}
    		return false;
    	}
    	
    	//推进stack栈
    	protected void pushStack(){
    		stack.pop();
    		String M = VNTI();
    		String ch;
    		for(int i = (M.length() -1) ; i >= 0 ; i--){
    			ch = String.valueOf(M.charAt(i));
    			stack.push(ch);
    		}
    		System.out.printf("%-6d %-20s %6s %-1s->%-12s\n",(++count),stack.toString(),strToken.substring(cur, strToken.length()),X,M);
    	}
    	
    	//总控程序
    	protected void totalControlProgram(){
    		while(flag == true){
    			stackPeek();
    			if(XisVT() == true){
    				if(X.equals(a)){
    					cur++;
    					a = curCharacter();
    					stack.pop();
    					System.out.printf("%-6d %-20s %6s \n",(++count),stack.toString(),strToken.substring(cur, strToken.length()));
    				}else{
    					ERROR();
    				}
    			}else if(X.equals("#")){
    				if(X.equals(a)){
    					flag = false;
    				}else{
    					ERROR();
    				}
    			}else if(productionType() == true){
    				if(VNTI().equals("synch")){
    					ERROR();
    				}else if(VNTI().equals("ε")){
    					stack.pop();
    					System.out.printf("%-6d %-20s %6s %-1s->%-12s\n",(++count),stack.toString(),strToken.substring(cur, strToken.length()),X,VNTI());
    				}else{
    					pushStack();
    				}
    			}else{
    				ERROR();
    			}
    		}
    	}
    	
    	//出现错误
    	protected void ERROR(){
    		System.out.println("输入串出现错误,无法进行分析");
    		System.exit(0);
    	}
    	
    	//打印存储分析表
    	protected void printf(){
    		if(flag == false){
    			System.out.println("========分析成功");
    		}else {
    			System.out.println("========分析失败");
    		}
    		
    	}
    	
    	public static void main(String[] args) {
    		LL1 ll1 = new LL1();
    		ll1.init();
    		ll1.totalControlProgram();
    		ll1.printf();
    	}
    	
    }
    


    测试数据1:i*i+i

    测试结果1:

    步骤        符号栈                                      输入串  所用产生式               
    0      [#, E]               i*i+i# 
    1      [#, Z, T]            i*i+i# E->TZ          
    2      [#, Z, Y, F]         i*i+i# T->FY          
    3      [#, Z, Y, i]         i*i+i# F->i           
    4      [#, Z, Y]             *i+i# 
    5      [#, Z, Y, F, *]       *i+i# Y->*FY         
    6      [#, Z, Y, F]           i+i# 
    7      [#, Z, Y, i]           i+i# F->i           
    8      [#, Z, Y]               +i# 
    9      [#, Z]                  +i# Y->ε           
    10     [#, Z, T, +]            +i# Z->+TZ         
    11     [#, Z, T]                i# 
    12     [#, Z, Y, F]             i# T->FY          
    13     [#, Z, Y, i]             i# F->i           
    14     [#, Z, Y]                 # 
    15     [#, Z]                    # Y->ε           
    16     [#]                       # Z->ε           
    ========分析成功

    测试数据2:)i*+i

    测试结果2:

    步骤        符号栈                                      输入串  所用产生式               
    0      [#, E]               )i*+i# 
    输入串出现错误,无法进行分析

    更多相关内容
  • 编译原理实验 词法分析 语法分析递归下降 预测分析 Python(3个实验
  • TINY扩充语言的语法分析 扩充的语法规则有:实现while、do while、for语句和求余计算式子,具体文法规则自行构造。 要求: 要提供一个源程序编辑界面,以让用户输入源程序(可保存、打开源程序)。 可由用户选择是否...
  • 编译原理词法分析实验报告配套源代码.zip,Lexer-Parser-master,Lexer-Parser.iml,src,frame,ReadText.java,OutText.java,window,ReadText.java,OutText.java,pojo,SingleComment.java,MultiComment.java,TokenList....
  • 编译原理课程 实验报告 题目 用递归下降法进行表达式分析 专业 班级 学号 姓名 一 . 实验题目 用递归下降法进行语法分析的方法 二 . 实验日期 三 . 实验环境操作系统开发语言 专业资料 . 操作系统是 Windows 开发...
  • 编写一个语法分析程序,要求能够根据用户给定的任意文法,采用LR分析方法测试句式是否符合给定的语法规范。 程序测试数据的一个示例如下: 输入LR语法:E→E+T|T T→T*F|F F→(E)|-F|id 改写文法为增广文法,构造移...
  • 通过完成预测分析法的语法分析程序,了解预测分析法和递归子程序法的区别和联系。使了解语法分析的功能,掌握语法分析程序设计的原理和构造方法,训练掌握开发应用程序的基本方法。
  • 请根据给定的文法设计并实现语法分析程序,能基于上次作业的词法分析程序所识别出的单词,识别出各类语法成分。输入输出及处理要求如下: (1)需按文法规则,用递归子程序法对文法中定义的所有种语法成分进行分析;...
  • 编制一个递归下降分析程序,实现对词法分析程序所提供的单词序列的语法检查和结构分析。利用C语言编制递归下降分析程序,并对简单语言进行语法分析
  • 北邮编译原理实验二:语法分析程序的设计与实现,源代码和实验报告
  • 直接运行“语法分析.exe”, 它会自动读入“result.txt”的内容 并分析其中词法。 结果保存在“语法分析.txt”文件里。 其中“语法分析.cpp”是原代码。
  • 编译原理语法分析实验报告

    千次阅读 2022-05-08 19:45:07
    第一部分 语言语法规则 Mini语言包含程序设计所需要的最基本语言成分,包括 程序定义语句 :以 program 开头 end 结尾,中间需要有 main()函数 赋值语句 :var 标识符 = 表达式; 算数.

    编号:

    实习总评教师签名
    成绩

     

    第一部分 语言语法规则

    Mini语言包含程序设计所需要的最基本语言成分,包括

    • 程序定义语句 :以 program 开头 end 结尾,中间需要有 main()函数

    • 赋值语句 :var 标识符 = 表达式;

    • 算数表达式:包含 + - * / ()运算

    • 逻辑表达式:包含 II && ! ()运算

    • if-else 语句:if (逻辑表达式或变量)begin 程序体 end else begin 程序体 end

    • while 循环语句:while(逻辑表达式或变量)begin 循环体 end

    • break 语句:break;

    第二部分 文法定义

    简化后的单词编码表为

    单词符号编码单词符号编码
    main1+15
    if2-16
    else3*17
    while4/18
    program5=19
    begin6&&20
    end7||21
    var8!22
    break9==23
    true10整数常量表24
    false11浮点数常量表25
    (12标识符表26
    )13
    ;14

    先有词法分析器将程序扫描一遍,得到Token串,例如main转为<1,->,if转为<2,->...!转为<22,->,特别的标识符,整数常量,浮点数常量有两个表分别转换为<23,i>.<24,i>,<25,i>.

    但是在语法分析的文法中,为了方便理解,这里依然用main等字符串,而不是使用<1,->进行分析,其中标识符用id表示,整数常量用wholenum表示,浮点数用floatnum表示。

    得到如下的上下文无关文法G(S),(小写表示终结符号,大写表示非终结符号)


    • S ->PROGRAM //PROGRAM为整个语法程序

    • PROGRAM -> program PROBODY end

      //PROBODY为程序体

    • PROBODY -> main begin PROSTATEMENT end

      //PROSTATEMENT为程序语句

    • PROSTATEMENT -> ASSIGNMENT PROSTATEMENT | CONDITION PROSTATEMENT | LOOP PROSTATEMENT | BREAK PROSTATEMENT | ε //ASSIGNMENT为赋值语句 COUNT 为算数表达式 LOGIC 为逻辑表达式 CONDITION 为if else 分支语句 LOOP 为while循环语句 BREAK 为break语句,用于跳出循环//

    • ASSIGNMENT -> var id = VALUE ;

      //VAlUE 为赋值语句可以赋的值,id为变量,属于词法分析器中单词编码表中的标识符

    • VALUE -> id | COUNT | LOGIC

    • COUNT -> TF F -> +T | -T | ε T -> GH H -> *G | /G | ε G -> (COUNT) | wholenum | floatunm | id

      //wholenum 为词法分析器中单词编码表中的整数,floatnum为词法分析器中词法编码表中的浮点数,整个算术运算符表达,每个算数单元可以是数字也可以是变量

    • LOGIC -> IJ J -> ||I | ==I | ε I -> KL L -> &&K |ε K -> !M | M M -> (LOGIC) | true | false | id

      //这里是逻辑表达式,每个逻辑单元可以是true false 也可以是变量

    • CONDITION -> if (LOGIC) begin PROSTATEMENT end ELSE

      //ELSE是else语句

    • ELSE -> begin PROSTATEMENT end | ε

      //if else语句中,先进行逻辑语句的判读,然后进入程序语句,else是可空的

    • LOOP -> while (LOGIC) begin PROSTATEMENT end

      //循环语句

    • BREAK -> break ;

      //break跳出语句


    第三部分 语法分析算法

    使用递归下降算法,结合词法分析器,用get_nexttoken();函数表示取到下一个token串,用w.nexttoken();表示w后面的token串,用Token数据结构表示token串,所有的终结符号都使用Token进行定义,由于这些字符原本就是c语言的关键字,所以为了区分,将所有Mini文法中的关键字在程序表达中都加上s,边界符使用S+所对应的数字表示,如‘(’用S12表示。

    Token mains = new Token(1);
    Token ifs = new Token(1);
    Token elses = new Token(1);
    Token whiles = new Token(1);
    .
    .
    .
    Token S12 = new Token(12);
    Token S13 = new Token(13);
    Token S14 = new Token(14);
    Token S15 = new Token(15);
    .
    .
    .
    Token id = new Token(26);
    Token wholenum = new Token(24);
    Token floatnum = new Token(25);

    get_nexttoken(w);从词法分析器中取下一个token串,存放在全局变量w中

    每个非终结符号都是一个函数,如下所示

    void PROGRAM (){
        if(w==programs) 
        {
            get_nexttoken(w);
            PROBODY();
            if(w==end){
                print("程序正确!");
            }
            else{
                error(0);
            }
        }
        else error(0);
    }
    void PROBODY (){
        if(w==mains){
            get_nexttoken(w);
            if(w==begins){
                get_nexttoken(w);
                PROSTATEMENT();
                if(w==ends){
                    get_nexttoken(w);
                }
                else error(1);
            }
            else error(1);
        }
        else error(1);
    }
    void PROSTATEMENT (){
        if(w==vars) { 
            ASSIGNMEN();
            PROSTATEMENT ();
        }
        else if(w==ifs) {
            CONDITION();
            PROSTATEMENT ();
        }
        else if(w==whiles) {
            LOOP();
            PROSTATEMENT ();
        }
        else if(w==breaks) {
            BREAK();
            PROSTATEMENT ();
        }
        else if(w==ends);
        else error(2);
    }
    void ASSIGNMENT (){
        if(w==var){
            get_nexttoken(w);
            if(w==id){
                get_nexttoken(w);
                if(w==S19){
                    get_nexttoken(w);
                    VALUE();
                    if(w==S14)
                    get_nexttoken(w);
                    else error(3);
                }
                else error(3);
            }
            else error(3);
        }
        else error(3);
    }
    void VALUE (){
        if(w==wholenum)  COUNT();
        else if(w==floatnum) COUNT();
        else if(w==trues) LOGIC();
        else if(w==falses) gLOGIC();
        else if(w==id&&w.nexttoken==S14) get_nexttoken(w);
        else if (!(w==id&&w.nexttoken==S14)||w==S12||w==id){
                if(w==S12&&w.nexttoken==id){
                    if(w.nexttoken.nexttoken==(S15||S16||S17||S18){
                        COUNT();
                    }
                    else if(w.nexttoken.nexttoken==(S20||S21||S23){
                        LOGIC();
                    }
                    else error(4);
                }
                 else if(w==S12&&(w.nexttoken==(wholenum||floatnum))){
                     COUNT();
                 }
                 else if (w==S12&&(w.nexttoken==(true||false))){
                     LOGIC();
                 }
                   else if(w==id&&(w.nexttoken==(S15||S16||S17||S18)){
                        COUNT();
                    }
                    else if(w==id&&(w.nexttoken==S20||S21||S23)){
                        LOGIC();
                    }
                     else error(4);
                         
        }
           
             else error(4);
    }
    void COUNT(){
        T();
        F();
    }
    void F(){
        if(w==S15||w==S16){
            get_nexttoken(w);
            T();
        }
        
    }
    void T(){
        G();
        H();
    }
    void H(){
        if(w==S17||w==S18){
            get_nettoken(w);
            G();
        }
    }
    void G(){
        if(w==S12){
            get_nexttoken(w);
            COUNT();
            if(w==S13){
                get_nexttoken(w);
            }
            else error(5);
        }
        else if(w==(wholenum||floatnum||id)){
            get_nexttoken(w);
        }
        else error(5);
    }
    void LOGIC(){
        I();
        J();
    }
    void J(){
        if(w==(S21||23)){
            get_nexttoken(w);
            I();
        }
    }
    void I(){
        K();
        L();
    }
    void L(){
        if(w==S20)
        {
            get_nexttoken(w);
            K();
        }
    }
    void K(){
        if(w==!){
            get_nexttoken(w);
            M();
        }
        else{
            M();
        }
    }
    void M(){
        if(w==S11){
            get_nexttoken(w);
            LOGIC();
            if(w==S12){
                get_nexttoken(w);
            }
            else error(6);
        }
        else if(w==(trues||falses||id)){
            get_nexttoken(w);
        }
        else error(6);
    }
    void CONDITION(){
        if(w==ifs){
            get_nexttoken(w);
            if(w==S12){
                get_nexttoken(w);
                LOGIC();
                if(w==S13){
                    get_nexttoken(w);
                    if(w==begins){
                        get_nexttoken(w);
                        PROSTATEMNT();
                        if(w==ends){
                            get_nexttoken(w);
                            ELSE();
                        }
                        else error(7);
                    }
                    else error(7);
                }
                else error(7);
            }
            else error(7);
        }
        else error(7);
    }
    ​
    void ELSE(){
        if(w==begins){
            get_nexttoken(w);
            PROSTATEMENT();
            if(w==ends){
                get_nexttoken(w);
            }
            else{
                error(7);
            }
        }
    }
    void LOOP(){
        if(w==whiles&&(w.nexttoken==S12)){
            get_nexttoken(w);
            get_nexttoken(w);
            LOGIC();
            if(w==begins){
                get_nexttoken(w);
                PROSTATEMENT();
                if(w==ends){
                    get_nexttoken(w);
                }
                else error(8);
            }
            else error(8);
        }
        else error(8);
    }
    void BREAK(){
        if(w==breaks&&(w.nexttoken==S14)){
            get_nexttoken(w);
            get_nexttoken(w);
        }
        else{
            error(9);
        }
    }

    第四部分 出错处理出口

    程序出错时,其实w记录了出错所在的token串,只需用另一个变量记录token串所在整个程序的位置,在使用get_nettoken()取到下一个token串时,变量加一,就可以判断程序出错的位置。

    错误函数错误产生式错误类型
    error(0)PROGRAM -> program PROBODY end程序定义错误
    error(1)PROBODY -> main begin PROSTATEMENT end程序体定义错误
    error(2)PROSTATEMENT -> ASSIGNMENT | CONDITION | LOOP | BREAK | ε语句定义不合法
    error(3)ASSIGNMENT -> var id = VALUE ;赋值语句格式错误
    error(4)VALUE -> id | COUNT | LOGIC赋值语句右值不正确
    error(5)G -> (COUNT) | wholenum | floatunm | id算数表达式格式错误
    error(6)M -> (LOGIC) | true | false | id逻辑表达式格式错误
    error(7)CONDITION -> if (LOGIC) begin PROSTATEMENT end ELSE条件语句错误
    error(8)LOOP -> while (LOGIC) begin PROSTATEMENT end循环语句错误
    error(9)BREAK -> break ;跳出语句错误

    第五部分 测试计划

    测试用例中所包括的语法单位应该尽可能覆盖Mini语言的文法中的所有非终结符包括程序定义变量声明if-else语句赋值语句条件语句循环语句跳出语句算数表达式逻辑表达式

    测试用例如下

    program 
        main begin 
        var logic=true;
        var i=0;
        while(i<10)
            begin
            if(logic&&(!(!true)))
                begin
                i=i+1;
                logic=!logic;
                end
            else
                begin
                logic=!logic;
                end
            end
        end
    end

    测试结果,无错误!

    展开全文
  • 本次上传的是编译原理语法分析LL1文法程序部分,耗费了我2个星期的时间,真的是煞费苦心。里面增加了很多注释,大家应该能够看懂,有需要的朋友赶紧下载吧!希望对大家有所帮助!!!
  • 本文为编译原理语法分析实验: 设计要求:创建一个语法分析程序,它采用LL(1)方法或LR(1)方法。该程序的输入是一个文本文档,包括一组2型文法(上下文无关文法)的产生式和任务1程序输出的符号表。任务2的输出...

    一、语法分析简介

    语法分析是编译过程的一个逻辑阶段。语法分析的任务是在词法分析的基础上将单词序列组合成各类语法短语,如“程序”,“语句”,“表达式”等等.语法分析程序判断源程序在结构上是否正确.源程序的结构由上下文无关文法描述.语法分析程序可以用YACC等工具自动生成。
    完成语法分析任务的程序称为语法分析器,或语法分析程序。按照源语言的语法规则,从词法分析的结果中识别出相应的语法范畴,同时进行语法检查。
    目前,已存在许多语法分析的方法。但就产生语法树的方向而言,可大致把他们分为自底向上和自顶向下两大类。目前比较流行LL分析法和LR分析法。

    二、设计要求

    创建一个语法分析程序,它采用LL(1)方法或LR(1)方法。该程序的输入是一个文本文档,包括一组2型文法(上下文无关文法)的产生式和任务1程序输出的符号表。任务2的输出是一个YES或NO,即源代码字符串是否符合本2型文法。

    三、开发环境

    硬件环境:PC机 windows10 64 位
    编程语言:C++
    运行环境:codeblocks或vs

    四、实现过程

    从预先写好的文本文件中读入2型文法,保存在一个char类型的二维数组中,每个文法的长度由length数组记录。
    计算first集,具体实现过程为:不停的扫描每个文法,其首个字符是终结符,则加入到对应的非终结符的first集中,如果首个字符是非终结符,则扫描该非终结符的first集,把他们全部加入到当前非终结符的first集中,为空,则扫描下一个字符。直到某一次没有发生任何改动,说明first集计算完成。
    然后求LR(1)项目集族,构造LR(1)分析表。
    分析过程与书上类似,用一个状态栈,一个符号栈。

    五、分析过程框架图

    在这里插入图片描述

    六、运行结果

    语法分析对应的文法,包含了头文件、while语句、定义函数语句,赋值语句,定义变量语句等,可以嵌套配合使用
    在这里插入图片描述
    求得
    在这里插入图片描述
    项目集输出(部分):
    在这里插入图片描述
    分析表(部分):
    在这里插入图片描述
    分析过程(部分)
    在这里插入图片描述

    七、资源下载与学习

    CSDN:语法分析 编译原理实验/课程设计(C++实现)

    其他

    编译原理 词法分析实验/课程设计博文

    展开全文
  • 编译原理实验报告代码C#版——词法分析、LL1分析、LR1分析-附件资源
  • 编译原理语法分析器的Python实现-LL1文法,属于编译原理课程相关作业。输出结果保存为csv文件,直观了解分析全过程
  • 编译原理 实验报告 语法分析器 c语言版
  • 这个文本文档是只有编译原理的词法分析语法分析两个实验的源代码,没题目及其要求,需要自行用vc6.0或者其他软件运行调试
  • 编译原理-18-语法分析实验代码示例

    Sematics3-实验代码示例

    1. while语句的翻译

    1. 类型声明与使用(符号表)
    2. 类型检查
    3. 中间代码生成,要有大局观
    4. 认清"你"在语法分析树中所处的位置

    1.1. While语句的SDD

    S . c o d e = ⋅ ⋅ ⋅ ∣ g o t o   L 1 S.code = ···|goto\ L1 S.code=goto L1

    1. C.code是返回回来的
      1. C.false的赋值就是告诉其应该跳转到哪里,这里跳转到S.next,也就是跳转到S的兄弟节点
      2. C.true的赋值就是跳转到L2进行
    2. S1.next = L1是保证其可以完成循环中提前跳转,比如continue
    3. 后面那是S1.code
    4. C.true和C.false都是继承属性。

    1.2. while语句的SDT

    1.3. 用一个递归下降语法分析器实现while语句的翻译

    1. next是S的继承属性

    1. 使用全局缓冲区
      1. 比如L1在缓冲区,C生成的部分放到缓冲区即可,以此类推。
      2. 避免了出现中间代码有重复
      3. 避免了拼接的问题

    2. Definition (符号表(Symbol Table))

    符号表是用于保存各种信息的数据结构

    1. 标识符:词素、类型、大小、存储位置等

    1. 通常使用HashTable

    2.1. 为每个作用域建立单独的符号表

    可以使用符号表栈实现树形的嵌套关系

    1. 每一个作用于都会有一张单独的符号表(哈希表)
    2. 符号表栈:及时出栈

    翻译任务:忽略声明部分,为每个标识符标明类型

    2.2. Definition (类型表达式(Type Expressions))

    1. 基本类型是类型表达式;
      1. char, bool, int, float, double, void,. . .
    2. 类名是类型表达式;
    3. 如果t是类型表达式,则array(num, t)是类型表达式;
    4. record(⟨id : t, . . .⟩)是类型表达式;
    5. 如果 s s s t t t是类型表达式,则 s ∗ t s * t st(笛卡尔积)是类型表达式;
    6. 如果 s s s t t t是类型表达式,则 s → t s \rightarrow t st(表示函数, s s s输入, t t t为输出)是类型表达式;
    7. 类型表达式可以包含取值为类型表达式的变量。



    2.3. 类型声明

    1. 符号表中记录标识符的类型、宽度(width)、偏移地址(offset)

    2.4. 需要为每个record生成单独的符号表

    1. 全局变量t与w将B的类型与宽度信息递给产生式 C → ϵ C \rightarrow \epsilon Cϵ
    2. float x

    2.5. 数组类型的语法制导

    i n t [ 2 ] [ 3 ] int[2][3] int[2][3]

    1. 全局变量offset表示变量的相对地址
    2. 全局变量top表示当前的符号表

    f l o a t   x ; f l o a t   y ; float\ x; float\ y; float x;float y;

    1. record类型表达式:record(top)
    2. 全局变量top表示当前的符号表
    3. 全局变量Env表示符号表栈
    4. record { float x; float y; } p;

    2.6. 完整的例子

    • offset稳定增长
    • top可能会回退

    2.7. 类型检查的常见形式

    2.8. 结构等价和名等价

    2.8.1. Definition (结构等价(Structurally Equivalent))

    1. 两种类型结构等价当且仅当以下任一条件为真:
      1. 它们是相同的基本类型;
      2. 它们是将相同的类型构造算子应用于结构等价的类型而构造得到;
      3. 一个类型是另一个类型表达式的名字。

    2.8.2. Definition (名等价(Name Equivalent))

    1. 两种类型名等价当且仅当以下任一条件为真:
      1. 它们是相同的基本类型;
      2. 它们是将相同的类型构造算子应用于结构等价的类型而构造得到。

    2.8.3. 结构等价中的"结构"又是什么意思?

    array(n, t)       array(m, t)
    record(⟨a: int⟩)   record(⟨b: int⟩)
    
    1. 取决于语言设计者的"大局观"

    2.9. 类型综合

    根据子表达式的类型确定表达式的类型

    E 1 + E 2 E_1+E_2 E1+E2

    1. 重载函数的类型综合规则

    2.10. 类型推导

    根据某语言结构的使用方式确定表达式的类型

    • null(x) :x是一个列表,它的元素类型未知
    • C++ 的 Template

    2.11. 类型转换


    1. 拓宽是从下向上,比如short和char做运算,那么会都先转化为int然后计算,也就是找到最小共有祖先。
    2. 窄化是从上向下

    1. 类型不相同,但是兼容,则转化。
    展开全文
  • 编译原理词法分析语法分析报告+代码(C语言版)[1]
  • 华北水利水电学院 编译原理 实验报告 20122013学年 第 一 学期 2011 级 计算机科学与技术 专业 班级 2011179 学号 2011179 姓名 一实验题目语法分析算符优先分析程序 1选择最有代表性的语法分析方法算符优先法 2选择...
  • 语法分析器的代码和EXE文件 由编译原理的算法编出的
  • 实验内容在自底向上语法分析基础上设计语义规则(语法制导翻译),将源程序翻译为四元式输出,若有错误将错误信息输出。其中包含C++实现代码、测试用例等基本报告内容。
  • 本次实验采用C语言编写词法语法分析器,要求通过数字调用之前做的两次手动实验。通过输入数字1,实现C语言子集符号的识别,通过输入数字2,对之前输入的单词符号进行语法分析。词法分析通过状态转换图实现,语法分析...
  • 两个计算机编译原理语法分析实验代码,可以运行,用C语言写的,简单实用,非常不错。
  • 四川大学 编译原理 Tiny语法分析器 基于VS2013的纯代码
  • 该源码提供了以下功能:求First集和Follow集,展示出LL(1)分析表,对用户输入的字符串,系统展示出分析过程并给出分析结论。 文法存于txt文件中,一行一句规则,建议以E::=AB|a的形式存储。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,264
精华内容 8,105
关键字:

编译原理语法分析实验