算符优先分析法

最新推荐文章于 2024-03-30 21:27:32 发布
最新推荐文章于 2024-03-30 21:27:32 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： 编译原理 文章标签： 算符优先分析法 编译原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34602647/article/details/78705759
版权

测试数据：
6
S->#E#
P->i
F->P
T->F
E->T
E->E+T
输出结果：
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
源代码：
第一个类

public class WF {
    public String left="";
    public List<String> right=new ArrayList<String>();

    public WF(String string){
        this.left=string;
    }
    public void insert(String string){
        right.add(string);
    }

    public void print(){
        System.out.printf("%s->%s",left,right.get(0).toString());
        for(int i=1;i<right.size();i++){
            System.out.printf("|%s",right.get(i).toString());
            System.out.println();
        }
        System.out.println();
    }


}

第二个类：

package 语法分析器;
//
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
//测试数据 1 构建关系表好着
//8
//E->E+T
//E->T
//T->T*F
//T->F
//F->P^F
//F->P
//P->(E)
//P->i


//测试数据2（默认输入串为i+i#）
//6
//S->#E#
//P->i
//F->P
//T->F
//E->T
//E->E+T


public class suanfuyouxianwenfa1 {
    static int step=0;//记录第几步从第一步开始
    static int MAX=507;
    char[][] relation=new char[MAX][MAX];//关系表数组
    static List<Character> VT= new ArrayList<Character> ();//终结符集
    static List<WF> VN_set=new ArrayList<WF>();//非终结符 用来分离并存储产生式左部和右部  
    static Map<String,Integer> VN_dic=new HashMap<String,Integer>();//记录VN非终结符
    static int[] used=new int[MAX];//用来记录终结符为第几个终结符
    static String s1;//产生式左部的引用变量
    static String s2;//产生式右部的引用变量
    static boolean[][] F;//firstvt集
    static boolean[][] Fl;//lastvt集
    static char[][] table;//文法优先表
    static char currentRelation;//优先关系
    static int index=-1;//当前符号所在下标  
    static Stack stack=new Stack();//
    static Stack stackl=new Stack();    
    String stackString=null;
    static String str2="i+i#";
    static char a;//当前符号
    static Stack<Character> S=new Stack<Character>();
    //查找某VN（非终结符）所在的VN_set list中所在的位置
    public static int  findindexFromVN_set(char P){
        for(int i=0;i<VN_set.size();i++){
            if(VN_set.get(i).left.charAt(0)==P){
                return i;
            }
        }
        return -1;
    }
    //查找某VT（终结符）所在的VT list中的位置
    public static int findindexFromVT(char a){
        return VT.indexOf(a);
    }
    //构建firstvt用,把(P,a)推进栈//书上91页右下角程序思路
    public static void insert(char P,char a){
//      System.out.println("P->"+P+"|"+"findindexFromVN_set(P)->"+findindexFromVN_set(P));
//      System.out.println("a->"+a+"|"+"VT.indexOf(a)->"+VT.indexOf(a));
        if(!F[findindexFromVN_set(P)][VT.indexOf(a)]){          
            F[findindexFromVN_set(P)][VT.indexOf(a)]=true;
            stack.push(""+'('+P+','+a+')');//把(P,a)推进stack栈end
        }

    }
    //构建lastvt集用,把(P,a)推进栈//书上91页右下角程序思路
    public static void insertl(char P,char a){
//      System.out.println("P->"+P+"|"+"findindexFromVN_set(P)->"+findindexFromVN_set(P));
//      System.out.println("a->"+a+"|"+"VT.indexOf(a)->"+VT.indexOf(a));
        if(!Fl[findindexFromVN_set(P)][VT.indexOf(a)]){
            Fl[findindexFromVN_set(P)][VT.indexOf(a)]=true;
            stackl.push(""+'('+P+','+a+')');//把(P,a)推进stack栈end
        }

    }
    //构造(非终极符)的firstvt函数//书上91页右下角程序思路
    public static void makefirst(){
        F=new boolean[VN_set.size()][VT.size()];
        //先初始化F集
        for(int i=0;i<VN_set.size();i++){
            for(int j=0;j<VT.size();j++){               
                F[i][j]=false;
            }
        }       

        for(int i=0;i<VN_set.size();i++){
            for(int j=0;j<VN_set.get(i).right.size();j++){
                if(Character.isUpperCase(VN_set.get(i).left.charAt(0))&&!Character.isUpperCase(VN_set.get(i).right.get(j).charAt(0)))
                        {
                    insert(VN_set.get(i).left.charAt(0),VN_set.get(i).right.get(j).charAt(0) );
                }
                if((VN_set.get(i).right.get(j).length()>2)&&Character.isUpperCase(VN_set.get(i).left.charAt(0))&&Character.isUpperCase(VN_set.get(i).right.get(j).charAt(0))&&!Character.isUpperCase(VN_set.get(i).right.get(j).charAt(1))){
                    insert(VN_set.get(i).left.charAt(0),VN_set.get(i).right.get(j).charAt(1) );
                }
            }
        }
        while(!stack.isEmpty()){
            String str=(String) stack.pop();//str=(P,a);
            char Q=str.charAt(1);char a=str.charAt(3);
            for(int i=0;i<VN_set.size();i++){
                for(int j=0;j<VN_set.get(i).right.size();j++){
                    if(Character.isUpperCase(VN_set.get(i).left.charAt(0))&&VN_set.get(i).right.get(j).charAt(0)==Q){
                        insert(VN_set.get(i).left.charAt(0), a);
                    }
                }
        }
    }

    for(int i=0;i<F.length;i++){
        System.out.printf("%c :",VN_set.get(i).left.charAt(0));
        for(int j=0;j<F[i].length;j++){         
            if(F[i][j]==true){
                System.out.printf(" %c",VT.get(j));
            }
        }
        System.out.println();
    }
    }

    //构造(非终极符)的lastvt函数//书上91页右下角程序思路
    public static void makelast(){
        Fl=new boolean[VN_set.size()][VT.size()];
        for(int i=0;i<VN_set.size();i++){
            for(int j=0;j<VT.size();j++){               
                Fl[i][j]=false;
            }
        }       

        for(int i=0;i<VN_set.size();i++){
            for(int j=0;j<VN_set.get(i).right.size();j++){
                if(Character.isUpperCase(VN_set.get(i).left.charAt(0))&&!Character.isUpperCase(VN_set.get(i).right.get(j).charAt(VN_set.get(i).right.get(j).length()-1)))
                        {
                    insertl(VN_set.get(i).left.charAt(0),VN_set.get(i).right.get(j).charAt(VN_set.get(i).right.get(j).length()-1) );
                }
                if((VN_set.get(i).right.get(j).length()>2)&&Character.isUpperCase(VN_set.get(i).left.charAt(0))&&Character.isUpperCase(VN_set.get(i).right.get(j).charAt(VN_set.get(i).right.get(j).length()-1))&&!Character.isUpperCase(VN_set.get(i).right.get(j).charAt(VN_set.get(i).right.get(j).length()-2))){
                    insertl(VN_set.get(i).left.charAt(0),VN_set.get(i).right.get(j).charAt(VN_set.get(i).right.get(j).length()-2) );
                }
            }
        }
        while(!stackl.isEmpty()){
            String str=(String)stackl.pop();//str=(P,a);
            char Q=str.charAt(1);char a=str.charAt(3);
            for(int i=0;i<VN_set.size();i++){
                for(int j=0;j<VN_set.get(i).right.size();j++){
                    if(Character.isUpperCase(VN_set.get(i).left.charAt(0))&&VN_set.get(i).right.get(j).charAt(VN_set.get(i).right.get(j).length()-1)==Q){
                        insertl(VN_set.get(i).left.charAt(0), a);
                    }
                }
        }
    }

    for(int i=0;i<Fl.length;i++){
        System.out.printf("%c :",VN_set.get(i).left.charAt(0));
        for(int j=0;j<Fl[i].length;j++){            
            if(Fl[i][j]==true){
                System.out.printf(" %c",VT.get(j));
            }
        }
        System.out.println();
    }
    }
    //构造文法优先表函数//书上92页左上角程序思路
    public static void make_table(){
        table=new char[VT.size()][VT.size()];
        for(int i=0;i<VN_set.size();i++){
            for(int j=0;j<VN_set.get(i).right.size();j++){
                String right=VN_set.get(i).right.get(j);
                for(int t=0;t<VN_set.get(i).right.get(j).length()-1;t++){
                    char c1=right.charAt(t);
                    char c2=right.charAt(t+1);                  
                    if(!Character.isUpperCase(c1)&&!Character.isUpperCase(c2)){
                        table[findindexFromVT(c1)][findindexFromVT(c2)]='=';                        
                    }
                    if((t<(VN_set.get(i).right.get(j).length()-2))
                            &&!Character.isUpperCase(c1)
                            &&Character.isUpperCase(c2)
                            &&!Character.isUpperCase(right.charAt(t+2))){
                        table[findindexFromVT(c1)][findindexFromVT(right.charAt(t+2))]='=';                     
                    }
                    if(!Character.isUpperCase(c1)&&Character.isUpperCase(c2)){
                        for(int i1=0;i1<F[findindexFromVN_set(c2)].length;i1++){
                            if(F[findindexFromVN_set(c2)][i1]==true){
                                table[findindexFromVT(c1)][i1]='<';
                            }

                        }
                    }
                    if(Character.isUpperCase(c1)&&!Character.isUpperCase(c2)){
                        for(int i1=0;i1<Fl[findindexFromVN_set(c1)].length;i1++){
                            if(Fl[findindexFromVN_set(c1)][i1]==true){
                                table[i1][findindexFromVT(c2)]='>';
                            }
                        }
                    }
                }
            }
        }
        System.out.println("*********************算符优先关系表***************************");
        System.out.println("\n--------------------------------------------------------");

        for(int i=-1;i<VT.size();i++){

            for(int j=-1;j<VT.size();j++){
                if(i==-1&&j==-1){
                    System.out.printf("|    |");                
                    continue;
                }               
                if(i==-1){                  
                    System.out.printf("%4c  |",VT.get(j));  
                }else{                  
                    if(j==-1){
                        System.out.printf("|%4c |",VT.get(i));
                        continue;
                    }
                    System.out.printf("%4c  |",table[i][j]);
                }

            }
            System.out.println("\n--------------------------------------------------------");
        }


    }
    //移进规约函数//书上93页右上角程序思路
    public static void move_reduction(String str){//str="i+i#"
        char Q;//用来指向终结符
        int k=0;//一开始让k=0,可以通过stack.get(k);查找到对应位置的元素
        int j=0;//j用来指向优先级小于终结符Q的终结符
        char c; //保存弹出来的字符
        String s="";//用来保存待归约的串
        S.push('#');
        do{ 
            index++;//当前符号后移
            a=str.charAt(index);
        if(findindexFromVT((char)S.peek())!=-1){//判断栈顶是否是终结符
            j=k;
        }else{
            j=k-1;      
        }       
        while(table[findindexFromVT(S.get(j))][findindexFromVT(a)]=='>'){
            currentRelation=table[findindexFromVT(S.get(j))][findindexFromVT(a)];
            do{                 
                Q=S.get(j);//Q指向j当前所指向的终结符  j指向离栈顶最远的且优先关系>当前符号的终结符
                if(findindexFromVT(S.get(j-1))!=-1){
                    j=j-1;

                }else{
                    j=j-2;                          
                }                                                         //j指向优先级小于栈顶终结符Q的终结符则退出
            }while(table[findindexFromVT(S.get(j))][findindexFromVT(Q)]!='<');//
            //归约前打印说明归约
            step++;                     
            System.out.printf("%2s |%-5s%5s%10s%8s",step,printfStatck(),currentRelation,a,residue(str2));
            //把S[j+1]。。。。S[k]规约为某个N 
            //通过出栈，提炼S[k]到S[j+1]到s中
            int key=k;//key从k移动到j
            s="";
            do{
                c=S.pop();
                s=c+s;
                key--;
                }while(key!=j);     

            int flag=0; 
            //把S[j+1]。。。。S[k]规约为某个N 
            //书上93页指出'N'是指那样一个产生式的左部符号，次产生式的右部和S[j+1]。。。S[k]构成如下一一对应的关系：
            //自左至右,终结符对终结符，非终结符对非终结符，而且对应的终结符相同。            

            for(int i=0;i<VN_set.size();i++){
                for(int j1=0;j1<VN_set.get(i).right.size();j1++){
                    char left=VN_set.get(i).left.charAt(0);
                    String right=VN_set.get(i).right.get(j1);                   
                    if(Character.isUpperCase(left)&&right.equals(s)){

                        S.push(left);
                        System.out.println("   归约："+left+"->"+right);
                        s="";//清空
                        flag=1;
                        break;
                    }//长度一样
                    else if(Character.isUpperCase(left)&&check(right,s)){                       
                        S.push(left);
                        System.out.println("   归约："+left+"->"+right);                       
                        s="";//清空
                        flag=1;
                        break;
                    }
                }
                if(flag==1){
                    break;
                }
            }       

        }

        if(table[findindexFromVT(S.get(j))][findindexFromVT(a)]=='<'
                ||table[findindexFromVT(S.get(j))][findindexFromVT(a)]=='='){
                currentRelation=table[findindexFromVT(S.get(j))][findindexFromVT(a)];
                k=k+1;
                step++;
                System.out.printf("%2s |%-5s%5s%10s%8s",step,printfStatck(),currentRelation,a,residue(str2));
                S.push(a);//压栈      
                System.out.printf("%10s","移进：把"+a+"移进");
                System.out.println();

        }else{
            System.out.println("出错了！");
            }

        }while(a!='#');

    }
    //检查两个字符串是否长度相同
    private static boolean check(String right, String s3) {
        if(right.length()!=s3.length()){
            return false;
        }

        // TODO Auto-generated method stub
        for(int i=0;i<right.length();i++){
            if(Character.isUpperCase(right.charAt(i))!=Character.isUpperCase(s3.charAt(i)))
                return false;

        }
        return true;

    }

    **//main方法**
    public static void main(String[] args){
        //初始化used(记录VT的表)赋初值为-1 表示其对应的值没有出现过
        initused();         
        VT.clear();
        String n;//统计文法的个数
        String s = null;//用来暂时性存储当前输入的文法
        Scanner reader=new Scanner(System.in);
            n=reader.nextLine();            
            for(int i=0;i<Integer.valueOf(n);i++){
                s=reader.nextLine();
                //分离当前输入的产生式
                int i1=s.lastIndexOf('-');
                s1=s.substring(0,i1);//产生式左部
                s2=s.substring(i1+2);//产生式右部
                if(!VN_dic.containsKey(s1)){
                    VN_set.add(new WF(s1.toString()));//
                    VN_dic.put(s1.toString(),VN_set.size()-1);//用VN_dic记录非终结符               
                }
                int x=VN_dic.get(s1);//在VN_dic中查找当前输入的产生式左部对应的位置
                VN_set.get(x).insert(s2);//在对应的产生式集合VN_set中保存对应产生式左部的右部
                for(int k=0;k<s2.length();k++){
                    if(!Character.isUpperCase(s2.charAt(k))){
                        if(used[s2.charAt(k)]>-1)//初始化use[][]中的值为-1,如果大于-1则该字符被记录过
                            continue;
                        VT.add(s2.charAt(k));
                        used[s2.charAt(k)]=VT.size()-1;//某vt第一个出现则记为0
                    }
                }

    }
    System.out.println("**********VT集的大小为:****************");
    System.out.println(VT.size());
    System.out.println("*********VT集**************");   
    for(int i=0;i<VT.size();i++){
        System.out.printf("%c ",VT.get(i)); 
        }
    System.out.println();
    for(int i=0;i<VT.size();i++){
        System.out.printf("%d ",used[VT.get(i)]);
    }
    System.out.println();
    System.out.println("************VN集********************");
    for(int i=0;i<VN_set.size();i++){
        System.out.printf("%s ",VN_set.get(i).left);
    }
    System.out.println();
    for(int i=0;i<VN_set.size();i++){
        System.out.printf("%d ",VN_dic.get(VN_set.get(i).left));
    }
    System.out.println();
    System.out.println("**********产生式*****************");
    for(int i=0;i<VN_set.size();i++){
        VN_set.get(i).print();
    }
    System.out.println("***********Firstvt集*********************");
    makefirst();
    System.out.println("***********Lastvt集*********************");
    makelast();
    make_table();
    printstep();
    move_reduction(str2);
    System.out.printf("归约结束！    默认输入串为:"+"'"+"%s"+"'"+" 算符优先分析规约后最后的栈中元素为:"+"'"+"%s"+"'",str2,printfStatck());  
    }   

    //打印展示归约步鄹的格式
    private static void printstep() {
        // TODO Auto-generated method stub      
        System.out.printf("%2s|%-10s%10s%10s%10s%10s","步骤","栈中","优先关系","当前符号","剩余符号","动作");
        System.out.println();
    }
    //初始化use表使表中的值初始化为-1
    private static void initused() {
        // TODO Auto-generated method stub
        for(int i=0;i<used.length;i++){
            used[i]=-1;
        }
    }
    //剩余输入符号
    public static String  residue(String str){      
        String s=str.substring(index+1);
        return s;
    }
    /**
     * 集合遍历方式(输出顺序：从栈底到栈顶)
     * @return 
     */ 
    public static String printfStatck(){        
//      System.out.print("当前栈:");
        String s="";
         for (Character x : S) { 
//             System.out.print(x); 
             s=s+x;
         } 
         return s;   

    }

}

参考资料：
程序设计语言编译原理（第3版）陈火旺 刘春林 谭庆平
参考博客：
地址一：http://blog.csdn.net/qq_24451605/article/details/50096487
地址二：http://blog.csdn.net/github_36601823/article/details/74090399

Eaxker
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
编译原理：算符优先分析法
jianbai_的博客
05-28 8888
编译原理：算符优先分析文法
Apriori 算法分析
清风徐来的博客
05-09 1672
Apriori 算法分析: 利用my_new_apriori.py文件，对杂货店商品进行关联规则挖掘，支持度=0.06，置信度=0.2 使用的数据集： 数据集下载地址： 链接：https://pan.baidu.com/s/14Vgvv5OK-luwTgoEZozbRw 提取码：vvym # -*- coding: utf-8 -*- """ Created on Fri Mar 22 10:21:02 2019 @author: Administrator """ import pandas as p
简单算符优先文法分析程序（编译原理）
12-26
实现算符优先文法分析程序；完成对以下表达式文法的分析程序。 G[E]: E->E+T E->T T->T*F T->F F->(E) F->i
编译原理（自下而上分析——算符优先分析过程）
jerryzhou的博客
05-27 1万+
我们讨论的自下而上分析法是一种“移进-规约”法。大意是：用一个寄存符号的先进后出的栈，把输入符号一个一个地移进到栈里，当栈顶形成某个产生式的一个候选式时，即把栈顶的这一部分替换成（规约成）该产生式的左部符号。 例：有文法G S→a | ^ | (T) T→T,S | S 给出输入串（a,(a,a))的算符优先分析过程。 1、扩展文法 S’ →#S# 2、求FIRSTV...
编译原理：算符优先分析
燕双嘤
04-24 1万+
算符优先分析过程是自上而下的归约过程，但未必是严格的最左归约。也就是说，算符优先分析法不是一种规范归约法。所谓【算符优先分析法】就是定义算符之间的某种优先关系，借助于这种关系寻找“可归约串”进行归约的一种方法。【算符文法】一个文法，如果它的任一产生式的右部都不含两个相继（并列）的非终结符，即不含如下形式的产生式右部： ，则我们称该文法为算符文法。
用算符优先法进行表达式分析
weixin_51526210的博客
01-03 559
用算符优先法进行表达式分析 ## 实验目的 了解用算符优先分析法进行语法分析的方法。 ## 实验内容要求 从键盘输入表达式，利用算符优先分析法求出其值，如输入表达式有错，则给出报错提示。表达式以；结尾。例：以于如下的输入表达式串： 13+5*4；则应给出结果为33。
4.4 算 符 优 先 分 析 法
qq_45180475的博客
08-07 4407
4.4 算 符 优 先 分 析 法 4.4.1 方法概述 所谓算符优先分析法就是依照算术表达式的四则运算过程而设计的一种语法分析方法。 这种分析方法首先要规定运算符之间(确切地说是终结符之间)的优先关系和结合性质,然后借助这种关系,比较相邻运算符的优先级来确定句型的可归约串并进行归约。 下面,以表达式的文法为例,说明采用这种分析法分析符号串 id + id * id 的分析过程。 例如,文法 G [ E ]为 E → E + E | E * E | ( E ) | id 这个文法是一个二义性文法,因而对
编译原理(八) 算符优先分析法(分析过程的算法和C++实现)
llin-黎辰
11-30 1万+
前情提要算符优先分析法(构造算法优先关系表)算法描述算符优先关系主要用于界定右句型的句柄： <标记句柄的左端； =出现在句柄的内部； >标记句柄的右端。 发现句柄的过程： 从左端开始扫描串，直到遇到第一个>为止。 向左扫描，跳过所有的=，直到遇到一个<为止。 句柄包括从上一步遇到的<右部到第一个>左部之间的所有符号，包括介于期间或者两边的非终结符 非终结符的处理： 因为非终结符不能
编译原理：算符优先分析算法的设计与实现（含代码）
热门推荐
俊夫小瞳的博客
11-29 2万+
算符优先分析算法的设计与实现 写在最前面：我的编译原理学的不是很好，不怎么听课，所以我写代码的思路比较简单。简单的思路也就意味着代码很笨重，介意的话请点叉叉。如果有什么指教欢迎评论区留言。 一、实验目的 根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。 通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。 二、 实验内容 输入文法。可以是如下算术表达式的文法（你可以根据需要适当改变）： E→E+T|E-T|T T→T*F|T/F|F F→（E）|i 对给定表达
编译原理实验二——算符优先分析法设计与实现
08-29
用算符优先分析方法设计一个分析解释程序，对输入的赋值语句、输出语句、清除语句进行词法分析、语法分析、表达式求值并存储于指定变量中；若存在错误，提示错误相关信息。
算符优先分析C++源代码.doc
06-17
算符优先分析文法是一种工具，在编译的过程中，隶属于语法分析环节，却又与中间代码的生成息息相关，编译可以分为五个阶段：词法分析、语法分析、语义分析（中间代码的生成）、代码优化、目标代码生成。语法分析是指：在词法分析基础上，将单词符号串转化为语法单位（语法范畴）（短语、子句、句子、程序段、程序），并确定整个输入串是否构成语法上正确的程序。也就是说语法分析是检验输入串的语法是否正确，注意这里的语法正确，只是简单地符合自己定义的规范，而不能检测出运行时错误，比如"X/0"，空指针错误，对象未初始化等错误。在这一个实验中，我将通过算符优先分析文法这一个工具，在语法分析的时候，顺便进行语义分析，也就是识别出语法单位，同时简要的将识别出的中间代码进行计算（目标代码的生成+运行），得到相应的结果，来检验自己设计的正确性。可以说题目虽然叫做算符优先分析文法，其实却是一个贯穿了“词法分析+语法分析+语义分析+中间代码优化+目标代码生成+运行”全过程的一个极具概括性的程序。如果能将这个程序得心应手的完成出来，我相信诸位对编译原理的掌握也算是炉火纯青了。时隔将近两年再来整理自己以前写过的实验报告，还是挺有感慨的，对一件东西感兴趣，原来影响还会如此深远，还记得自己当时连续六个小时全神贯注写出的实验报告，现在看看竟然写了五六十页，核心内容也有三四十页，不觉的感慨当年充满热情的时代慢慢的竟走出许久
编译原理实验三：算符优先分析算法的设计与实现
每天都在梦想退休
12-10 5312
根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式是否正确。通过算符优先分析方法的实现，加深对自下而上语法分析方法的理解。给定一个上下文无关文法，根据算法设计一个程序，求文法中每个非终结符的FirstVT 集和LastVT 集。依据文法和求出的相应FirstVT和 LastVT 集生成算符优先分析表。2、对给定表达式进行分析，输出表达式正确与否的判断。2、根据文法求FIRSTVT集和LASTVT集。5、对给定的表达式，给出准确与否的分析过程。6、给出表达式的计算结果。3、构造算符优先分析表。
实验三 算符优先分析算法的设计与实现，C语言版
costy_dis的博客
12-10 594
根据算符优先分析法，对表达式进行语法分析，使其能够判断一个表达式 是否正确。为了实现计算，对符号栈做了个同步数组，里面存放原始数据，在符号栈进行四则运算或括号归约时，同步数组进行相应的操作，从而实现了算符优先的运算。对一些非法格式进行了出错处理如"+12","(1+2","5)+4","1+()"(2)对给定表达式进行分析，输出表达式正确与否的判断。输入：(1+2)/3+4-(5+6/7);输入：1+2-3+(*4/5) 输出：错误。输入：((1-2)/3+4 输出：错误。
编译原理第五章——自下而上分析——算符优先分析（超全）
最新发布
woshihlf的博客
03-30 4852
算符优先分析、概念辨析-算符文法、算符优先文法、概念辨析-算符优先分析法、直观算符优先分析法、概念辨析-算符文法、算符优先文法、利用优先关系表用直观算符优先分析法分析算数表达式**不考可以跳过**、构造FIRSTVT(P)和LASTVT(P)两个集合**必考！！**、利用FIRSTVT(P)和LASTVT(P)两个集合构造优先关系表**必考！！素短语，优先函数
算符优先分析过程 编译原理
wenmiao_的博客
12-27 1716
算符优先分析过程只考虑算符（终结符）之间的优先关系，分析扫描每个规约式的算符间优先关系。 根据龙书阐述，算符优先分析逐渐淘汰了。orz 但仍然实现之。 示例语法如下： D->#E# E->E+T|T T->T*F|F F->P$F|P P->(E)|i main.cpp #include <iostream> #include...
基于C++设计与实现的算符优先分析器
神仙别闹的自留地
11-14 640
E->E*TF->TT->(E)T->i本次实验基本完成了实验题目的要求，定义了一个文法，求出了每一个非终结符的VT集和LASTVT集，画出了算符优先关系表，并判定出给定的文法是否是算符优先文法。当给定一个 句子时，能够判定是否是文法中的句子，并能够将分析过程打印出来。
算符优先分析的设计与实现
艾克
12-16 3821
1实验目的 构造算符优先分析器，利用它进行语法分析，判断给出的符号串是否为该文法识别的句子，了解算符优先分析方法是严格的从左向右扫描，和自底向上的语法分析方法。 2.实验要求 输入文法G的非终结符、终结符和产生式； （0）判断输入的文法是否为算符文法； （1）输出文法G的所有非终结符的FIRSTVT集； （2）输出文法G的所有非终结符的LASTVT集； （3）构造算符优先分析表； （4）判断是否...
编译原理 实验三 算符优先分析算法的设计与实现（python)
m0_63093530的博客
11-25 535
给定一个上下文无关文法，根据算法设计一个程序，求文法中每个非终结符的FirstVT 集和LastVT 集。if i<= n-2, Xi和Xi+2 是终结符, 但Xi+1 为非终结符 then。依据文法和求出的相应FirstVT和 LastVT 集生成算符优先分析表。if Xi为终结符, Xi+1为非终结符 then。if Xi为非终结符, Xi+1为终结符 then。//非终结符和终结符数组。typedef struct //符号对(P,a)for 对每个非终结符 P和终结符 a do。
算符优先分析法实现编译原理实验
实验任务是利用算符优先分析法将语句转化为等价的基本操作四元式。实验涉及了算符优先顺序的理解和应用，并给出了三个具体的表达式例子进行分析。最后，提供了程序代码，用于验证表达式的正确性，并能读取和比较输入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值