精华内容
下载资源
问答
  • 编译原理上机,C++实现产生式的firstfollow集合,内含注释,按照文字类的求解方法转换成代码,清晰易懂。
  • C语音代码。实现功能:1....2.每个非终结符FIRST 集FOLLOW集和SELECT集模块。3.预测分析表的构建模块。4.文法的检验及消除左公因子和左递归模块。5.对输入终结符串的判断,是否为LL1文法,并进一步分析。
  • 输入任意的上下文无关文法,输出所输入的上下文无关文法一切非终结符的first集合和follow集合
  • 编译原理求FIRST集合FOLLOW集,超简单

    千次阅读 多人点赞 2020-12-03 19:16:13
    谁的FIRST集,要找谁在左侧的产生式,拿书上的例子来说(编译原理,陈火旺,第三版) E->TE' E'->+TE'|@ T->FT' T'->*FT'|@ F->(E)|i 然后要看产生式右侧, 1、若产生式右侧以终结符开头,就把这...

    看了好多求FIRST集和FOLLOW集的方法,这里是自己总结的,也是认为最实用的办法

    FIRST集

    求谁的FIRST集,要找谁在左侧的产生式,拿书上的例子来说(编译原理,陈火旺,第三版),其中@为空的意思

    E->TE'
    E'->+TE'|@
    T->FT'
    T'->*FT'|@
    F->(E)|i
    

    然后要看产生式右侧,
    1、若产生式右侧以终结符开头,就把这个终结符放入X的FIRST集中
    比如:F->(E)|i
    因为“(”和“i”都为终结符,所以FIRST(F)={(,i}。
    同理FIRST(E’)={+,@},FIRST(T’)={*,@}。
    2、若产生式右侧以其他非终结符开头(X->YZ),就把这个非终结符(Y)的FIRST集放入X的FIRST集中,如果Y的FIRST集中有空,就把它下一个非终结符(Z)的FIRST集放入X的FIRST集中,循环直到终结符或结束。
    比如:E->TE’和T->FT’,先说第一个,
    由于E->TE’,所以我们要把FIRST(T)放入FIRST(E)中,由于FIRST(T)不知道,所以先去求FIRST(T)。
    由于T->FT’,所以我们要把FIRST(F)放入FIRST(T)中,所以FIRST(T)={(,i},所以FIRSTt(E)={(,i}。

    FOLLOW集

    求谁的FOLLOW集,要找谁在右侧的产生式,还是这个例子

    E->TE'
    E'->+TE'|@
    T->FT'
    T'->*FT'|@
    F->(E)|i
    

    1、若X为文法的开始符号,那么#属于FOLLOW(X)。
    2、其实所有产生式都可以看做是E->yXz形式,其中X为所求非终结符,y、z可以是终结符,可以是非终结符,也可以是空。
    3、把FIRST(z)的非空元素加入FOLLOW(X)中。
    4、如果z->空或z为空,就把FOLLOW(E)加入到FOLLOW(X)中
    5、重复上述步骤至FOLLOW集不在增大
    6、FOLLOW集中没有@,遇到@请自动忽略
    (1)比如先求FOLLOW(E),发现在产生式F->(E)|i中可求,且E为文法开始符号,所以FOLLOW(E)=FIRST())={),#}。
    (2)求FOLLOW(E’),发现在产生式E->TE’ 和E’->+TE’|@中可求,由E->TE’可得FOLLOW(E’)包含FOLLOW(E),由E’->+TE’|@可得FOLLOW(E’)包含FOLLOW(E’),所以FOLLOW(E’)={),#}。
    (3)求FOLLOW(T),由产生式E->TE’和E’->+TE’|@得,FOLLOW(T)包含FIRST(E’),由产生式E’->+TE’|@可知E’->@,所以FOLLOW(T)包含FOLLOW(E’),所以FOLLOW(T)={+,),#}。
    (4)求FOLLOW(T’),由产生式T->FT’可得,FOLLOW(T’)包含FOLLOW(T),所以FOLLOW(T’)={+,),#}。
    (5)求FOLLOW(F),由产生式T->FT’可得,FOLLOW(F)包含FIRST(T’),由产生式T’->*FT’|@可知T’->@,所以FOLLOW(F)包含FOLLOW(T’),所以FOLLOW(F)={+,),#,*}。

    展开全文
  • 下面是这部分的代码,我贴一部分,剩下的等我把follow集实现再写一篇博文来给大家看! 请给我点赞谢谢~!!! 实现得非常简洁明了(自夸) 你可以看下注释,写的非常清楚啦!!! package parse2; import java.u...

    哈哈,经历了千辛万苦,我!终于!写出来了!
    其实总体说来也不难,但是我比较傻,想来想去都想不通,现在终于写出来了,请大家分享一下我的快乐~~~~~~哈哈哈!!
    下面是这部分的代码,我贴一部分,剩下的等我把求follow集实现再写一篇博文来给大家看!
    请给我点赞谢谢~!!!
    实现得非常简洁明了(自夸)
    你可以看下注释,写的非常清楚啦!!!

    package parse2;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import parse2.Production;
    
    public class FirstFollow {
      List<Production> proList = new ArrayList<Production>();
    
    
    
      public FirstFollow(ProductionList productionList) {
        proList = productionList.getProductions();
      }
    
      /**
       * 判断是不是终结符,如果左边没这个作为开头的,那就是终结符了。
       * @param str
       * @return
       */
      public boolean isVariable(String str) {
        for (Iterator<Production> iterator = proList.iterator(); iterator
            .hasNext();) {
          Production production = (Production) iterator.next();
          if (production.getLeft().equals(str)) {
            // 一旦找到左边有等于str的字符,就说明str不算终结符,返回真:是变量
            return true;
          }
        }
        return false;
      }
    
    
      /**
       * 判断是不是空产生式集
       * @param str
       * @return
       */
      public boolean isEmpty(String str) {
        for (Iterator<Production> iterator = proList.iterator(); iterator
            .hasNext();) {
          Production production = (Production) iterator.next();
          if (production.getLeft().equals(str)) {
            for (int i = 0; i < production.getRight().length; i++) {
              // System.out.println(production.getRight()[i]);
              if (production.getRight()[i].equals("null")) {
                return true;
              }
            }
          }
        }
        return false;
      }
    
      /**
       * 返回包含这个左部的产生式集合,
       * @param B
       * @param productions
       * @return
       */
      public List<Production> findLeft(String B) {
        List<Production> list = new ArrayList<>();
        for (Iterator<Production> iterator = proList.iterator(); iterator
            .hasNext();) {
          Production production = (Production) iterator.next();
          // System.out.println(production.getLeft());
          if (production.getLeft().equals(B)) {
            list.add(production);
          }
        }
        return list;
      }
    
      /**
       * 获取非终结符号的产生式的first集合X->Y1Y2Y3Y4Y5……这样的,
       * @param str X
       * @return
       */
      public List<String> getFirstItem(Production production) {
        List<String> list = new ArrayList<>();// 获取包含这个str左部的产生式
        // 遍历这个产生式的每一项,其中每个产生式的每一项也需要遍历。
        for (int i = 0; i < production.getRight().length; i++) {
          if (!production.getLeft().equals(production.getRight()[i])) {
            list.addAll(getFirst(production.getRight()[i]));
            System.out.println(production.getRight()[i]);
          } // 没有左递归
          if (!isEmpty(production.getRight()[i])) {
            // 这个项里没有包含空产生式的话,就继续求解,否则结束。
            return list;
          }
    
        }
        /* List<Production> findList = findLeft(str);
        
        for (Iterator<Production> iterator = findList.iterator(); iterator
            .hasNext();) {
          Production production = (Production) iterator.next();
          for (int i = 0; i < production.getRight().length; i++) {
            System.out.println(production.getRight()[i]);
            list.addAll(getFirst(production.getRight()[i]));
            if (!isEmpty(production.getRight()[i])) {
              return list;
            }
          }
        }*/
        return list;
      }
    
      /**
       * 判断是不是空产生式集
       * @param strings
       * @return
       */
      public boolean isEmpty(String[] strings) {
        for (int i = 0; i < strings.length; i++) {
          if (strings[i].equals("null")) {
            return true;
          }
        }
        return false;
      }
    
    
      /**
       * 获取first集合
       * @param str
       * @return
       */
      public List<String> getFirst(String str) {
        List<String> list = new ArrayList<>();
        List<Production> productions = findLeft(str);
        System.out.println(productions);
        for (Iterator<Production> iterator = productions.iterator(); iterator
            .hasNext();) {
          Production production = (Production) iterator.next();
          if (isEmpty(production.getRight())) {
            System.out.println("-------------------null------------------");
            // 检查X->null是否成立
            list.add("null");
          } else if (!isVariable(production.getRight()[0])
              && !isEmpty(production.getRight())) {
            // 是终结符的话就直接加入。
            System.out.println("-------------------vict------------------");
            list.add(production.getRight()[0]);
          } else {
            System.out.println("-------------------set------------------");
            list.addAll(getFirstItem(production));
          }
        }
        return list;
      }
    
      public static void main(String[] args) {
        ProductionList productionSet = new ProductionList();
        System.out.println(productionSet.toString());
        FirstFollow firstFollow = new FirstFollow(productionSet);
        System.out.println(firstFollow.getFirst("T'"));;
      }
    }
    
    

    效果示意:
    我用的产生式如下:
    龙书(紫色第二版)P140的例子文法,当然其他的文法也不在话下~~
    另外注意,左递归不消除的话可能会导致循环哦!!!

    E -> T E'
    E' -> + T E'|null
    T -> F T'
    T' -> * F T'|null
    F -> ( E )|id
    
    

    代码运行结果:这里的null表示空~!
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    现在的心情非常激动~~!

    展开全文
  • 编译原理求first集合

    2013-07-23 08:59:24
    里面是编译原理课上所讲的求first的集合的源代码,使用C++编写的
  • 语言为C++,使用了set,map容器,输入格式:S -> Aa | g | e,支持多‘|’ 符号,采用文件输入
  • 编译原理 求first集与follow集 c++ 题目: 输入任意的上下文无关文法,输出所输入的上下文无关文法一切非终结符的first集合和follow集合
  • ( 编译原理JAVA求First集Follow集
  • 编译原理求FIRST

    2019-05-13 23:46:26
    Vt是终结符集,Vn是非终结符集,P为产生式集,S为开始的非终结符。(书上一般大写的是非终结...FIRST(a)={a|a=>*ab,a∈VT, a,b∈V*} 若a=>*ε则规定ε∈FIRST (a)。称FIRST(a)为a的开始符号集或首符号集。 ...

    Vt是终结符集,Vn是非终结符集,P为产生式集,S为开始的非终结符。(书上一般大写的是非终结符,小写是终结符

    以下的定义可直接不看,书上太抽象,又啰嗦,直接看红字。

    定义:设G=(Vt,Vn,P,S)是上下文无关文法。

    FIRST(a)={a|a=>*ab,a∈VT, a,b∈V*}

    若a=>*ε则规定ε∈FIRST (a)。称FIRST(a)为a的开始符号集或首符号集。

    First(a)集就是求从a出发推导出所有开头的 终结符 构成的集合。

    S => aB     B => b     那么First(S)  = {a};因为B只能推出终结符 b ,S => ab,所以它的首个开始符号为{a}

    考虑以下情况,

    S => AB

    A => a

    A => ε

    B => b

    b => ε      那么此时First(S) = {a,b,ε},因为A有可能推出 {a,ε} ,当推出ε时,导致 S => B,此时B又可以推出 {b,ε} ,所以最终

    First(S) = {a,b,ε}


     正式计算First集的语言描述如下:

     

    1. 若 X∈Vt,则FIRST(X)={X}。
    2. 若X∈Vn,且有产生式 X→a……(a∈Vt),则 a ∈ First(X)。
    3. 若X∈Vn,X => ε ,则 ε ∈ First(X)。
    4. 设G中有形如X→Y1…Yk的产生式,其中 X,Y1…Yk∈Vn,且 Y1…Yi-1 均能 =>*ε(1≤i≤k),则FIRST(Y1)-{ε},…, FIRST(Yi-1)-{ε},FIRST(Yi) 都包含在FIRST(X)中。
    5. 若对一切1≤i≤k,均有ε∈FIRST(Yi),则将ε符号加进FIRST(X)。

    简单来说,

    (1)如果是求的是终结符的First的集,那结果就是它本身;

    (2)如果求非终结符的First集,就看它的产生式的首个符号是不是终结符,

            (2.1)如果是该符号就是所求First集的一员;

            (2.2)如果不是,那它就是非终结符,记为K,递归(2)重复上述步骤(非终结符推出空串的情况先不考虑);

    (3)如果(2)中的 K 能推出 ε ,那么 ε 也要加入First集中。

     

     

    展开全文
  • 代码链接:https://pan.baidu.com/s/1VNdrSMXaKu3HI0UQ_TInUQ 提取码:b1qz 使用教程 解压后打开文件夹,直接用Dev c++运行LL1,如图: 即可实现。 一分钱都不要啊, 比那些要C币的都好,点个赞呗亲们!!! ...

    DEV C++ 项目实现 不会建项目的看这个——>如何创建项目


    代码链接:https://pan.baidu.com/s/1VNdrSMXaKu3HI0UQ_TInUQ

    提取码:b1qz


    使用教程

    解压后打开文件夹,直接用Dev c++运行LL1,如图:
    在这里插入图片描述

    即可实现。


    一分钱都不要呀, 比需要C币下载的资源都好,点个赞呗!

    展开全文
  • 编译原理之NULL集、first、follow集C语言实现,实现中句子的转换符号由‘#’代替,数组默认由‘*’作为结束符
  • 能够根据用户给定的任意...改写文法为等价的LL(1)文法,消除左递归,消除左因子,每个非终结符的First集合和Follow集合,构造预测分析表,输入测试句式,给出判定结果,并说明判定依据。 参见博客代码介绍,功能全面。
  • 编译原理求FIRST集、FOLLOW集和SELECT集

    万次阅读 多人点赞 2019-07-02 15:29:50
    觉得解释比较不错。 所有大写字母代表非终结符,小写字母代表终结符,省略号代表未知数目(可能为0)的不确定类型的文法符号。 First集合: First集合顾名思义就是一个文法符号串所...求First集合可分如下几...
  • 最近在学习微机原理,里面涉及到编译优化的问题,又去重新看了看龙书的语法分析部分。之前学习的时候只是知道first和follow集合怎么计算,但是没有很明白背后的原理。想起轮子哥的一句话:要理解一个东西最好的办法...
  • 编译原理求First集和Follow集

    千次阅读 2018-10-25 22:16:04
    #输入文法求First集和Follow集 #要求大写字母表示非终结符,小写字母表示终结符 #最后一个产生式以$结尾或者输入$表示输入结束 #默认第一个产生式的→左边为起始符号 def inputGrammer(): #接收文法输入的函数 ...
  • 编译原理实验 first、follow、select集合的求解,经测试正确,c语言编写
  • 编译原理------C++实现求First集和Follow集

    千次阅读 多人点赞 2019-12-06 20:39:54
    First集算法描述 1.若X->a…,则将终结符a放入First(X)中 2.若X->ε,则将ε放入First(X)中 3.若有X->Y1Y2Y3…Yk,则 (1)把First(Y1)去掉 ε后加入First(X) (2)如果First(Y1)包含ε,则...
  • 本次上传的是编译原理语法分析LL1文法程序部分,耗费了我2个星期的时间,真的是煞费苦心。里面增加了很多注释,大家应该能够看懂,有需要的朋友赶紧下载吧!希望对大家有所帮助!!!
  • 编译原理 求解first集和follow集步骤(附例子)

    万次阅读 多人点赞 2020-03-14 21:07:41
    First集 定义:对于任意文法符号串α ,FIRST(α)是可从α推导得到的串的首符号的集合 如果αε,则ε也在FIRST(α)中( 即α可空) FIRST(α)={t|α-->...tβ,求FIRST(α) ①如果首符号t...
  • 编译原理实验报告实验内容: 1.出每个非终结符的FIRST集合 2.出每个产生式右部的FIRST集合 3.出每个非终结符的Follow集合 实验环境: Visual Studio2010 实验目的: 让同学们掌握FIRST集合和FOLLOW集合的法...
  • S→ABS→bCA→εA→bB→εB→aDC→ADC→bD→aSD→c他的first,follow,selectFirst(S) =(First(A)-{ε})∪(First (B)-{ε}) ∪{ε}∪{b} ={a,b,ε}因为A的first有ε,B的first有ε,S-&gt;AB,所以是First(A)-{...
  • 编译原理 —— FIRST

    千次阅读 2019-02-05 18:24:41
    给定一个文法符号串α,α的串首终结符集 FIRST(a) 被定义为可以从a推导出的所有串首终结符构成的集合。 如果 α=&amp;amp;amp;amp;amp;amp;amp;amp;gt;∗εα=&amp;amp;amp;amp;amp;amp;amp;amp;gt;^*ε...
  • 编译原理FIRST集与FOLLOW集

    千次阅读 2018-12-13 20:06:28
    编译原理FIRST集与FOLLOW集 一、First集合 定义: First集合是对产生式右部的字符串而言的,取的是非终结符VT(或终结符、空字符、文法符号串)的开始符号集合,集合中包含的是由左部非终结符VT推导得到的...
  • 实验一:状态转换图 输入一串数据,利用状态转换图程序出“关键字,标识符,整数,运算符,实数”。 实验二:DFA扫描 打开一个编写好的源...输入一个不含左递归的文法,由此程序出该文法的first集和follow集。
  • 编译原理FIRST集合和FOLLOW集合

    千次阅读 多人点赞 2020-06-07 05:03:28
    FIRST集合 定义:可从α推导得到的串的首符号的集合,其中α是任意的文法符号串。 规则:计算文法符号 X 的 FIRST(X),不断运用以下规则直到没有新终结符号或 ε可以被加入为止 : (1)如果 X 是一个终结符号...
  • 编译原理FIRST集和FOLLOW集的法以及构建LL(1)分析表

    万次阅读 多人点赞 2019-07-01 10:57:57
    文章目录FIRST集的法FOLLOW集的计算生成预期分析表算法例题 FIRST集的FIRST集是一个文法符号串所可能推导出的符号串的第一个终结符的集合 对于文法G的任一符号串α\alphaα = x1x2…xnx_{1}x_{2} \ldots x_{n...
  • 该资源为2016级哈工程计算机专业的编译原理课程设计的代码与实验报告。其中共选择了以下实验: 1实验环境的使用 2使用Lex自动生成扫描程序 3消除左递归(无替换) 4 提取左因子 5 First集合 6 Follow集合

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,166
精华内容 21,266
关键字:

编译原理求first代码