[cp] SLR分析表的生成 以及分析程序 (2)

最新推荐文章于 2024-02-08 10:27:22 发布
最新推荐文章于 2024-02-08 10:27:22 发布
阅读量2k 收藏
点赞数
分类专栏： compile tech 文章标签： iterator terminal string class c im
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ihavenoidea/article/details/411318
版权

1.      First,Follow 集的生成

由于之前我已经完成了 LL1语法器的生成。这里仅是借鉴了之前的代码。下面是类的声明和部分实现

/************************************************************************/

/* Author            :      陈正

/* Time                 :      2005/06/23

/* Desc                 :     计算文法的 First 集                                                                   

/************************************************************************/

 

#include "TypeDefine.h"

#include "Grammar.h"

 

#include <hash_map>

#include <deque>

using namespace std;

class First

{

public:

  typedef Grammar::TypeProductionItem           TypeProductionItem;

  typedef Grammar::TypeProduction             TypeProduction     ;

  typedef Grammar::TypeProductionList           TypeProductionList;

 

  typedef CustomCollection<Index >                 TypeFirstCollection;

  typedef deque<TypeFirstCollection >            TypeFirstListCollection;

public:

  First(const Grammar& grammar);

  ~First(void);

 

  /*

   * [计算规则的First集]

   * */

  void      Calculate_First();

 

  /*

   * [返回First集]

   * */

const TypeFirstCollection&      GetFirst(const Index& index)const;

  TypeFirstCollection&            GetFirst(const TypeProductionItem&

                        grammar,TypeFirstCollection& outC)const;

  TypeFirstCollection&            GetFirst(const TypeProductionItem::const_iterator begin,           const TypeProductionItem::const_iterator end,

                                                    TypeFirstCollection& outC)const;

  /* —— 2005/06/24 ——

   * [以字符串形式表示]

   * */

  string      ToString();

protected:

  /*

   * [计算First]

   * */

  TypeFirstCollection& Calculate_First(const TypeProductionItem& pro_itm, TypeFirstCollection& firstC);

  TypeFirstCollection& Calculate_First(TypeProductionItem::const_iterator begin,

                                                    TypeProductionItem::const_iterator end,

                                                    TypeFirstCollection& firstC);

  TypeFirstCollection& Calculate_First(const TypeProduction& production, TypeFirstCollection& firstC);

  TypeFirstCollection& Calculate_First(const Index& index, TypeFirstCollection& firstC);

  TypeFirstCollection& Calculate_First(

        TypeProductionItem::const_iterator begin,

        TypeProductionItem::const_iterator end,

        TypeFirstCollection& firstC)const;

protected:

  const Grammar&                                     m_grammar;

  map<Index,bool>                                      m_has_calculated;

  TypeFirstListCollection                          m_first_of_nonterminal;

  TypeFirstListCollection                          m_first_of_terminal;

};

 

 

/************************************************************************/

/* Author      :     陈正

/* Time           :      2005/06/23

/* Desc           :      计算 follow 集                                                                   

/************************************************************************/

#include "Grammar.h"

#include "First.h"

#include "CustomCollection.h"

 

#include <deque>

using namespace std;

 

class Follow

{

public:

  typedef Grammar::TypeProductionItem           TypeProductionItem;

  typedef Grammar::TypeProduction             TypeProduction     ;

  typedef Grammar::TypeProductionList           TypeProductionList;

 

  typedef CustomCollection<Index >                  TypeFollowCollection;

  typedef deque<TypeFollowCollection >           TypeFollowListCollection;

public:

  Follow(const First& _first,const Grammar      &_grammar);

  ~Follow(void);

 

public:

  /*

   * [计算规则的Follow集]

   * */

  void      Calculate_Follow();

 

  /*

   * [返回某个非终结符的 Follow 集]

   * */

  const TypeFollowCollection&      GetFollow(int vn_index)const;

 

  /* —— 2005/06/24 ——

   * [字符串显示]

   * */

  string ToString()const;

protected:

  /*

   * [根据课本第2个规则计算Follow集]

   * */

  TypeFollowCollection&      Calculate_Follow_2nd_rules(const Index& vn_index,TypeFollowCollection& outC);

  /*

   * [根据第3个规则计算，注意必须先根据第2个规则计算后才能调用此函数]

   * */

  TypeFollowCollection&      Calculate_Follow_3rd_rules(const Index& vn_index,TypeFollowCollection& outC);

protected:

  const First&                                 m_first;

  const Grammar&                               m_grammar;

  TypeFollowListCollection                    m_follow_of_nonterminal;

  deque<CustomCollection<Index> >             m_helper;          // [在根据第三个条件求Follow集时辅助]

  bool                                         m_has_calculated;

};

 

部分实现:

 

/*————————————————————————————————————————————/

 * Desc:      计算规则的First集     

 * Parm                                                       

/————————————————————————————————————————————*/

void      First::Calculate_First()

{

  /*

   * [初始化first集大小]

   **/

  m_first_of_nonterminal.resize( m_grammar.get_str_nonterminals().size() );

  m_first_of_terminal.resize(m_grammar.get_str_terminals().size());

 

  /*

   * [终结符的first集等于本身]

   **/

  for( unsigned int i=0; i < m_grammar.get_str_terminals().size(); i++)

  {

        this->m_first_of_terminal[i].Add( Index(i,true) );

        this->m_has_calculated[ Index(i,true) ] = true;

  }

 

  /*

   * [计算非终结符的first集]

   **/

  for( unsigned int i=0; i<m_grammar.get_str_nonterminals().size(); i++)

  {

        Calculate_First( Index(i,false), this->m_first_of_nonterminal[i]);

  }

}

 

/*————————————————————————————————————————————/

 * Desc:      根据(下标对应的规则|规则)计算First     

 * Parm                                                       

/————————————————————————————————————————————*/

First::TypeFirstCollection& First::Calculate_First(const TypeProduction& production, TypeFirstCollection& firstC)

{

  for(unsigned int i=0; i < production.size(); i++)

  {

        const TypeProductionItem& pro_item = production[i];

        assert(! pro_item.empty() );

        Calculate_First(pro_item,firstC);

  }

  return firstC;

}

First::TypeFirstCollection& First::Calculate_First(const TypeProductionItem& pro_item, TypeFirstCollection& firstC)

{

  return Calculate_First(pro_item.begin(),pro_item.end(),firstC);

}

First::TypeFirstCollection& First::Calculate_First(const Index& index, TypeFirstCollection& firstC)

{

  /*

   * [判断是否已经计算]

   **/

  if(m_has_calculated[index])

  {

        firstC = m_first_of_nonterminal[index];

        return firstC;

  }

  m_has_calculated[index] = true;

  Calculate_First(m_grammar.get_production(index.index),firstC);

 

  return firstC;

}

First::TypeFirstCollection& First::Calculate_First(

        TypeProductionItem::const_iterator begin,

        TypeProductionItem::const_iterator end,

        TypeFirstCollection& firstC)

{

  /*

   * [(1) 如果第一个字符是终结符]

   * */

  if(begin->is_terminal())

  {

        TypeFirstCollection tmp_c = ( m_first_of_terminal[ (*begin) ] );

        firstC += tmp_c;

        return firstC;

  }

 

  /*

   * [如果第一个字符不是终结符]

   * [(1) 把产生式最左边的非终符的 First 集 去掉空字 加到当前First集合]

   * */

  Calculate_First( *begin , m_first_of_nonterminal[ (*begin) ]) ;

  {

        TypeFirstCollection tmp_c = m_first_of_nonterminal[ (*begin) ];

        tmp_c -= m_grammar.get_index_of_emptyletter();

        firstC += ( tmp_c );

  }

 

  /*

   * [(2) 如果产生式是这样的类型 X->Y1 Y2 Y3 …… Yk,并且从第1个到第j个的First集中包含空字]

   * [  则把第 j+1 个的First集去掉空字加到当前First中，特别的如果所有的都包含空字，则把空字加到当前First中]

   * */

  bool exist_emptyletter = true;

  for(int i=0; begin != end ; begin ++, i++ )

  {

        Calculate_First( *begin , m_first_of_nonterminal[ (*begin) ]) ;

       // [update      6/30/2005]

        if(m_first_of_nonterminal[ (*begin) ].Exist(m_grammar.get_index_of_emptyletter()))

       {

             TypeProductionItem::const_iterator next = begin;

             next ++;

             if(next == end)

                   break;

             TypeFirstCollection tmp_c =  m_first_of_nonterminal[ (*next) ];

             tmp_c -= m_grammar.get_index_of_emptyletter();

             firstC += ( tmp_c );

       }

        else

       {

             exist_emptyletter = false;

             break;

       }

  }

  /*

   * [如果所有的都包含空字 则加入空字]

   * */

  if(exist_emptyletter)

  {

        firstC += (m_grammar.get_index_of_emptyletter());

  }

  return firstC;

}

 

/*————————————————————————————————————————————/

 * Desc:      根据第2个规则计算Follow集     

 * Parm                                                       

/————————————————————————————————————————————*/

Follow::TypeFollowCollection&      Follow::Calculate_Follow_2nd_rules(const       Index& vn_index,

TypeFollowCollection& followC)

{

  const TypeProduction &production = m_grammar.get_production(vn_index);

  for(unsigned int itm_index=0; itm_index<production.size(); itm_index++)

  {

        const TypeProductionItem &production_itm = production[itm_index];

 

       /*

        * [判断（2）条件，如果满足 A->a B b，则把First(b)-空字放到Follow(B)中]

        **/

        for(unsigned int id_index = 0; id_index < production_itm.size() - 1/*因为最后一个不满足*/;                        id_index ++ )

       {

             /*

              * [如果为非终结符，才计算Follow集]

              **/

             Index cur_vn_index      = production_itm[id_index];

             Index next_vn_index      = production_itm[id_index + 1];

             if( !cur_vn_index.is_terminal() && !(cur_vn_index == next_vn_index))

             {

                   First::TypeFirstCollection tmp_firstC ;

                        m_first.GetFirst( production_itm.begin()+id_index+1, production_itm.end() ,                                      tmp_firstC);

                  /*

                   * [除去空字，加到Follow集中]

                   **/

                   tmp_firstC -= m_grammar.get_index_of_emptyletter();

                   m_follow_of_nonterminal[cur_vn_index ] += (tmp_firstC);

             }

       }

  }

  return followC;

}

/*————————————————————————————————————————————/

 * Desc:      根据第3个规则计算     

 * Parm                                                        

/————————————————————————————————————————————*/

Follow::TypeFollowCollection&      Follow::Calculate_Follow_3rd_rules(const Index& vn_index,

                                                   TypeFollowCollection& followC)

{

  const TypeProduction &production = m_grammar.get_production(vn_index);

  for(unsigned int itm_index=0; itm_index<production.size(); itm_index++)

  {

        const TypeProductionItem &production_itm = production[itm_index];

 

       /*

        * [判断（3）条件，如果满足 A-> a B 或者A->a B b,b=>空字，则把Follow(A)加到Follow(B)中]

        **/

 

       /*

        * [A->BCdDE  则最后一个直接把Follow(A)加到Follow(E)中，其他的比如D，先判断E是否有空字产生式]

        * [如果有才把Follow(A)加到Follow(D)中，当遇到一个不属于此情况跳出循环]

        **/

        Index last_vn_index =  production_itm.back();

        if( !last_vn_index.is_terminal()                 // [非终结符条件]

             && !(last_vn_index == vn_index)        // [不是同一个非终结符]

             )

       {

 

             /*

              * [记录该非终结符的变化会影响到的其他非终结符的下标]

              **/

             m_helper[vn_index].Add(last_vn_index);

 

             m_follow_of_nonterminal[ last_vn_index ] += ( followC);

 

             /*

              * [更新所有会受last_vn_index下标所表示的非终结符影响的其他非终结符的Follow集合]

              **/

             for(unsigned int updateindex = 0;

                   updateindex < m_helper[last_vn_index].size();

                   updateindex++)

             {

                   Index update_vn_index =

                              m_helper[last_vn_index].GetElement(updateindex);

                   m_follow_of_nonterminal[update_vn_index] += ( followC );

             }

       }

        for(int id_index = (int)production_itm.size() - 2; id_index >= 0; id_index --)

       {

             /*

              * [如果为非终结符，才计算Follow集]

              **/

             Index cur_vn_index = production_itm[id_index];

             if(!cur_vn_index.is_terminal())

             {

                   First::TypeFirstCollection tmp_firstC ;

                        m_first.GetFirst(production_itm.begin()+id_index+1,                                                               production_itm.end(),tmp_firstC);

                   if( cur_vn_index != vn_index  && 

                         tmp_firstC.Exist(m_grammar.get_index_of_emptyletter())

                        )

                  {

                        /*

                         * [记录被影响的终结符号下标——解释同上]

                         **/

                        m_helper[vn_index].Add(cur_vn_index);

 

                        m_follow_of_nonterminal[cur_vn_index] += ( followC );

 

                        /*

                         * [解释同上]

                         **/

                        for( unsigned int updateindex = 0;

                              updateindex < m_helper[cur_vn_index].size();

                        updateindex++)

                        {

                              Index update_vn_index =

                              m_helper[cur_vn_index].GetElement(updateindex);

                              m_follow_of_nonterminal[update_vn_index] += ( followC );

                        }

                  }

             }

       }

  }

  return followC;

}

 

ihavenoidea
关注
专栏目录
实验四：SLR（1）分析生成器
chaichai126的博客
01-04 1858
浴帘求你了让我过
GCC源码分析（二）——前端
SonicLing的专栏
08-21 1万+
从这一篇开始，我们将从源代码的角度来分析GCC如何完成对C语言源文件的处理。GCC的内部构架在GCC Internals（搜“gccint.pdf”，或者见[1]）里已经讲述得很详细了，但是如果你只看了gccint就来看代码，还是觉得一头雾水，无法下手，因为你很难把gccint所讲的概念同gcc代码里真实的数据结构联系起来。那么这也是我把我这半年的分析经理写下来的原因，大家可以参照gccint来看
构造LR（0）分析表和SLR(1)分析表
weixin_69884785的博客
12-26 3964
构造LR（0）分析表和SLR(1)分析表 1.构造LR(0)分析表 2.构造SLR(1)分析表 LR（0）和SLR（1）的联系
《编译原理》：基于SLR（1）的语义分析
weixin_61248653的博客
01-22 774
《编译原理》：基于SLR（1）的语义分析
使用c/c++实现SLR(1)语法分析器
qq_44753451的博客
11-13 1万+
使用c/c++实现SLR1语法分析器一、前言二、具体实现1、结构体介绍analysis_table_cell.hcollection.hitem.hprodection_rule.hstate.hsymbol.h和word.h3、重要结构介绍3、重要函数介绍CLOSURE()GOTO()getCanonicalCollection()FIRSTFOLLOW构建分析表语法分析三、用法四、测试结果五、后记 一、前言   这次课程实验要求实现一个SLR(1)语法分析器，所以自己抽空用c++写了一个，当然我也没用什
SLR（1）语法分析程序的实现
m0_62806440的博客
12-23 1661
【代码】SLR（1）语法分析程序的实现。
多层雾计算中的物联网应用程序放置以减少延迟
⃝可在www.sciencedirect.com在线获取ScienceDirectICTExpress 8（2022）166www.elsevier.com/locate/icte在多层雾计算框架中放置物联网应用程序以最大限度地减少延迟Prasenjit ...接受日期：2021年6月16日2021年7月2
清华版<<编译原理(第2版)>>学习课件
01-11
该章可能详细解释了LR(0)，LALR和SLR等不同类型的LR分析器，并通过实例展示了如何生成和使用分析表。 "讲义_自顶向下语法分析.ppt"可能涵盖了自顶向下的语法分析方法，如LL(1)分析。自顶向下分析是从输入串的开始...
VS2013 IDE C#生成CodeMap
热门推荐
Raining_Snowman的专栏
07-28 6万+
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleTest { class Program { private delegate void pIndex(int n); priv
HTK英文大词汇连续语音识别
liuyanfeier的专栏
01-06 2889
最近实习，跑了一下htk book里面的前三章描述的例子。当然不是完全htk book里面的步骤，因为我有的数据集什么的都不一样。目标也不是一个小的语音拨号系统，而是英文的语音识别。当然了，最终结果出来了之后很低，还有很多过程要走。语音识别，肯定不是我这样小打小闹就可以的。本文就主要记录我在训练过程中的步骤以及遇到的一些error。一.已有文件 目前已经准备好的文件有一系列的flac文件还有字典t
SLR(1).rar_SLR(1) 表 C++_SLR(1)文法C++_SLR(1)的GOTO_action表和goto表_sl
09-20
SLR(1)分析表分析法，给出一个分析表含action和goto表，然后对给出的语句进行语法分析，规约判断！
SLR语法分析器_.slr文件_SLR语法分析器（C语言实现）_
10-02
使用C语言实现了SLR语法分析，需要的输入文件和代码都在压缩包中
[cp] SLR分析表的生成 以及分析程序(3)
kava
07-03 2685
1.      SLR分析表的生成仅列出定义及部分实现 /************************************************************************//* Author      :     陈正/* Time           :      2005/06/24/* Desc           :      分析表            
编译原理13：SLR（1）分析表、LR（1）分析表
weixin_51633776的博客
11-27 7076
编译原理13：SLR（1）分析表、LR（1）分析表
编译原理实验3——自下而上的SLR1语法分析实现（包含画DFA转换图、建表、查表）
最新发布
半岛铁盒里
02-08 1412
自下而上的SLR1语法分析python实现，包含DFA转换图、建表、查表等
SLR分析算法c语言实现,实验五 SLR语法分析器.doc
weixin_35884854的博客
05-25 1308
实验五 SLR语法分析器《编译原理》实验报告实验序号： 　　05　　　　　　实验项目名称： SLR语法分析器学　　号姓　　名专业、班实验地点指导教师实验时间一、实验目的及要求利用SLR文法的原理，掌握非递归预测分析的编程方法。二、实验设备(环境)及要求确定开发工具，如TC、VC、VC++、Delphi等；花一周时间熟悉开发工具。花一周时间确定被处理的语言的语法特点(初步确定，也可使用现成语言如P...
编译原理本科课程 专题5 基于 SLR(1)分析的语义分析及中间代码生成程序设计
2301_76616273的博客
02-04 853
本程序由C/C++编写，实现了赋值语句语法制导生成四元式，并完成了语法分析和语义分析过程。 以专题 1 词法分析程序的输出为语法分析的输入，完成以下描述赋值语句 SLR(1)文法的语义分析及中间代码四元式的过程，实现编译器前端。 G[S]: S→V=E E→E+T∣E-T∣T T→T*F∣T/F∣F F→(E)∣i V→i
编译原理——语法分析器（SLR）
realstarstarli的博客
06-18 6624
编译原理——语法分析器（SLR） 识别语法结构： 变量声明（不含变量初始化） if单条件分支语句以及if else 双条件分支语句 for循环和while循环语句 赋值语句 ，四则运算，逻辑判断复合语句 函数声明 函数调用 文法 //其中$作为标识符判断 @常数值判断 Z->S S->while(E)S S->E;S S->;S S->for(E;E;E)S S->CM;S S->C$(W){SreturnE;}S S->$(H);S M->M,$
编译原理——SLR（1）语法分析器（C/C++代码实现）
qq_58773908的博客
01-05 8699
实现LR语法分析器,执行过程举例：分析id+id*id，根据PPT上的预测分析表，输入id+id*id#，分析出栈和输出的内容。 文法：E'->E，E->E+T， E->T，T->T*F，T->F，F->(E)，F->id
SLR(1)语法分析器实现与程序示例
本文档介绍了作者自行编写的简单SLR(1)语法分析程序。SLR(1)是用于解析上下文无关文法的分析技术，它在编译原理中扮演着关键角色，用于构造高效且可靠的词法分析和语法分析阶段。该程序的核心目标是设计一个能够识别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值