Notes-4:C++练习之LL(1)语法分析

目标在于解释书本上的LL(1)语法分析过程(没有实用价值),不包括符合LL(1)语法检测(这个也可从生成的表中看出来),有FIRST,FOLLOW集的求得和表格的生成.程序中的类可被生成的代码使用,只需求写一个bnf语法(不支持扩展格式)的文本做为参数传递给这个程序,就能生成分析该bnf的程序.

代码是在Visual Studio里调试的,如果不是,把#include "stdafx.h"注释掉.

看代码先从demo.cpp看起,再了解几个类Cfactor,Cfactors,Crule和几个生成表过程就可以.

动手写代码能更好的理解书上的讲解,不再只是简单的一要做什么二要做什么.更形象的理解CFG和下推自动机的关系,不再是一两句.想想当年学的时候几乎是背下来的,没理解好.

如果有什么错误请指出!^^

如果能够帮助你,请帮顶!^^

 

LL1.h

//============================================================================ // Name : first.cpp // Author : Loon // Version : 0.5 // Copyright : Loon product // Description : BNF Analyse //============================================================================ #ifndef LL1_H_ #define LL1_H_ /* *------------------------------------------------------------------------- */ //#define NOTANSI #define NOTUNIX #ifdef NOTANSI #define _GLIBCXX_USE_WCHAR_T 1 #define _GLIBCXX_USE_WSTRING 1 #endif /* *------------------------------------------------------------------------- */ #include <stdarg.h> #include <string> #include <iostream> #include <vector> #include <stack> #include <sstream> #include <algorithm> #include <map> #include <fstream> using namespace std; /* * support wchar_t and char * ------------------------------------------------------------------------ */ #ifdef NOTANSI typedef std::wstring String; typedef String token_t; #define TOKEN L #define CONST_TEXT(x) L##x #define gcout std::wcout #define gcin std::wcin typedef wchar_t CHAR; typedef std::wostream gostream; typedef std::wistream gistream; #else typedef std::string String; typedef String token_t; #define TOKEN #define CONST_TEXT(x) x #define gcout std::cout #define gcin std::cin typedef char CHAR; typedef std::ostream gostream; typedef std::istream gistream; #endif typedef basic_stringstream<CHAR, char_traits<CHAR>, allocator<CHAR> > Stringstream; typedef basic_ofstream<CHAR, char_traits<CHAR> > Ofstream; /* *------------------------------------------------------------------------- */ /* * syntax ::= { rule } * rule ::= identifier "::=" expression * expression ::= term { "|" term } * term ::= factor { factor } * factor ::= identifier | * quoted_symbol | * "(" expression ")" | * "[" expression "]" | * "{" expression "}" * identifier ::= letter { letter | digit } * quoted_symbol ::= """ { any_character } """ * *------------------------------------------------------------------------- *------------------------------------------------------------------------- Start ::= RuleS_3 Start ::= PStart Start ::= {Enter}Start Start ::= {empty} S_3 ::= {Enter}Start S_3 ::= {empty} Rule ::= IW::=E E ::= TC C ::= {stick}E C ::= {empty} T ::= WF G ::= PG G ::= IG_2 G ::= QG G ::= ZG G ::= {empty} G_2 ::= QG G_2 ::= ZG G_2 ::= PG G_2 ::= {empty} F ::= IG_2 F ::= QG F ::= ZG Z ::= {K} K ::= literal K ::= digit K ::= empty K ::= anynotmark K ::= Enter K ::= mark K ::= stick Q ::= {mark}Any{mark} Any ::= {anynotmark}Any_1 Any_1 ::= Any Any_1 ::= {empty} M ::= {mark} I ::= {literal}H H ::= {literal}H H ::= {digit}H H ::= {empty} L ::= {literal} D ::= {digit} P ::= P ::= W ::= W W ::= W W ::= {empty} *------------------------------------------------------------------------- */ struct const_charactor{ static const CHAR cc_empty = (CHAR)0x00; static const CHAR cc_over = (CHAR)0x01; }; typedef unsigned short flag_T; typedef flag_T fflag_T; typedef flag_T rp_flag_T; struct rp_flag { static const rp_flag_T rp_flag_none = 0x0000; static const rp_flag_T rp_flag_getFIRST = 0x0001; static const rp_flag_T rp_flag_getFOLLOW = 0x0002; static const rp_flag_T rp_flag_getProductEmpty = 0x003; }; struct fflag{ static const fflag_T fflag_strfactor = 0x0000; static const fflag_T fflag_rulePtr = 0x0002; static const fflag_T fflag_function = 0x0003; static const fflag_T fflag_char = 0x0004; //static const fflag_T fflag_grm_selffactor = 0x1001; }; static const flag_T flag_grm_base = 0x0010; static const flag_T flag_grm_none = 0x0000; static const flag_T flag_grm_clearstronenter = 0x0001; /* *------------------------------------------------------------------------- */ struct aflag { static const flag_T aflag_enter = 0x0001; static const flag_T aflag_leave = 0x0002; }; //typedef void (*factors_pfn_action)(flag_T af, const CHAR ch, std::size_t ost); /* *------------------------------------------------------------------------- */ typedef bool (*factor_pfn_IsOne)(const CHAR ch); typedef gostream& (*factor_pfn_Print)(gostream&); class Cfactor_function { public: factor_pfn_IsOne pfn1; factor_pfn_Print pfn2; Cfactor_function(factor_pfn_IsOne p1, factor_pfn_Print p2) : pfn1(p1), pfn2(p2) { } }; typedef Cfactor_function *Pfactor_function; class Crule; typedef Crule* Prule; /* *------------------------------------------------------------------------- */ class Cfactor { public: fflag_T flag; flag_T flaggrm; String strfactor; union { Pfactor_function pfn; Prule prule; }; Cfactor(const String& t) : flag(fflag::fflag_strfactor), strfactor(t), pfn(0){} Cfactor(Prule p) : flag(fflag::fflag_rulePtr), prule(p){} Cfactor(Pfactor_function p) : flag(fflag::fflag_function), pfn(p){} Cfactor(fflag_T f) : flag(f), pfn(0){} bool operator==(const Cfactor& r) const { bool bret = (flag == r.flag); if (bret) { switch(flag) { case fflag::fflag_strfactor: bret = bret && (strfactor == r.strfactor); break; case fflag::fflag_function: bret = bret && (pfn == r.pfn); break; case fflag::fflag_rulePtr: bret = bret && (prule == r.prule); break; } } return bret; } bool operator!=(const Cfactor& r) const { return !((*this) == r); } protected: Cfactor(){}; }; gostream& operator <<(gostream& os, const Cfactor& f); typedef Cfactor *Pfactor; /* *------------------------------------------------------------------------- */ class CVts; typedef CVts* PVts; /* *------------------------------------------------------------------------- */ class setGf { public: flag_T flag; setGf(flag_T f):flag(f){} }; class Cfactors: public vector<Cfactor> { public: //Cfactors(std::size_t num, ...) // : bProductEmpty(false), pFIRST(0), lastGrmflag(flag_grm_none) //{ // if (num > 0) // { // va_list ap; // std::size_t n = num; // va_start(ap, num); // while (n-- > 0) // { // push_back(va_arg(ap, Pfactor)); // } // va_end(ap); // } //} Cfactors() : bProductEmpty(false), pFIRST(0), lastGrmflag(flag_grm_none){} virtual ~Cfactors(); void CreateFIRST(); bool bProductEmpty; // Vn ::= abc, abc ::= {empty} PVts pFIRST; // FIRST(abc) flag_T lastGrmflag; Cfactors& operator << (Cfactor& f) { if (flag_grm_none != lastGrmflag) f.flaggrm = lastGrmflag; push_back(f); // pointer to factor object lastGrmflag = flag_grm_none; return (*this); } Cfactors& operator << (const setGf& st) { lastGrmflag = st.flag; return (*this); } //factors_pfn_action pfnOnAction; //void Action(flag_T af, std::size_t oif, CHAR ch, std::size_t ost) //{ // if (0!=pfnOnAction) (*pfnOnAction)(af, oif, ch, ost); //} }; gostream& operator <<(gostream& os, const Cfactors& f); typedef Cfactors *Pfactors; class Cfactorscode { public: const Cfactors &ref_factors; Cfactorscode(const Cfactors& factors) : ref_factors(factors){}; }; gostream& operator <<(gostream& os, const Cfactorscode& fs); /* *------------------------------------------------------------------------- */ class Ctm { public: fflag_T flag; union{ CHAR firstChar; Prule prule; Pfactor_function pfn; }; Ctm(CHAR ch):flag(fflag::fflag_char),firstChar(ch){} Ctm(Prule p):flag(fflag::fflag_rulePtr),prule(p){} Ctm(const Cfactor& f) { _init(&f); } Ctm(const Cfactor* p){ _init(p); } void _init(const Cfactor* p) { switch (p->flag) { case fflag::fflag_strfactor: flag = fflag::fflag_char; firstChar = p->strfactor[0]; // str must not empty break; case fflag::fflag_function: flag = fflag::fflag_function; pfn = p->pfn; break; case fflag::fflag_rulePtr: // use when get FOLLOW flag = fflag::fflag_rulePtr; prule = p->prule; break; } } bool operator==(const Ctm& r) const { return (flag==r.flag) && ((void*)prule==(void*)r.prule); } bool operator==(Prule p) const { return (flag==fflag::fflag_rulePtr) && (prule==p); } bool match(CHAR ch) const { switch (flag) { case fflag::fflag_char: return ch == firstChar; break; case fflag::fflag_function: return (*pfn->pfn1)(ch); break; // case fflag::fflag_rulePtr: } return false; } protected: Ctm(); }; typedef Ctm *Ptm; typedef vector<Ctm> Ctms; gostream& operator <<(gostream& os, const Ctm& tm); class CVts : public Ctms { public: void operator+=(const CVts& vts); void operator+=(const Pfactor p) { this->operator +=(Ctm(p));} void operator+=(const Cfactor& f) { this->operator +=(Ctm(&f)); } void operator+=(const Ctm& p) { if (find(begin(), end(), p) == end()) push_back(p); } }; gostream& operator <<(gostream& os, const CVts& vts); /* *------------------------------------------------------------------------- */ class Crule: public vector<Cfactors> { public: typedef vector<Pfactors> parent_T; Crule(const String &n, std::size_t sz=0) : name(n) // , factors(this) , selffactor(this) // used only pointer not member of this , pselffactor(&selffactor) { resize(sz); } //void setProduces(std::size_t num, ...) //{ // if (num > 0) // { // va_list ap; // std::size_t n = num; // va_start(ap, num); // while (n-- > 0) // { // push_back(va_arg(ap, Pfactors)); // } // va_end(ap); // } //} //class _I_factors //{ //public: // Crule *prule; // _I_factors(Crule* p):prule(p){}; // Cfactors& operator[](std::size_t index){ return (*(*prule)[index]);} //}factors; bool IsProduceEmpty(); void getFIRST(); void getFOLLOW(); Cfactor selffactor; Pfactor pselffactor; String name; CVts FIRST; CVts FOLLOW; rp_flag_T prcflag; protected: Crule(); }; typedef Crule* Prule; gostream& operator<<(gostream& os, const Crule& r); /* *------------------------------------------------------------------------- * _Func_Functions *------------------------------------------------------------------------- */ struct _Func_PrintRule { gostream& ref_os; _Func_PrintRule(gostream& os):ref_os(os){}; void operator()(Prule pr) { ref_os << (*pr); } }; struct _Func_PrintFIRST { gostream& ref_os; _Func_PrintFIRST(gostream& os):ref_os(os){}; void operator()(Prule pr) { ref_os << pr->name << CONST_TEXT("(") << pr->FIRST << CONST_TEXT(")/n"); } }; struct _Func_PrintFOLLOW { gostream& ref_os; _Func_PrintFOLLOW(gostream& os):ref_os(os){}; void operator()(Prule pr) { ref_os << pr->name << CONST_TEXT("(") << pr->FOLLOW << CONST_TEXT(")/n"); } }; struct _Func_PrintCode_rule { gostream& ref_os; _Func_PrintCode_rule(gostream& os):ref_os(os){}; void operator()(Prule pr) { ref_os << CONST_TEXT("Crule ") << pr->name << CONST_TEXT("(CONST_TEXT(/"") << pr->name << CONST_TEXT("/"), ") << pr->size() << CONST_TEXT(");/n"); } }; struct _Func_PrintCode_factors { gostream& ref_os; _Func_PrintCode_factors(gostream& os):ref_os(os){}; void operator()(Prule pr) { std::size_t szfactors = pr->size(); for(std::size_t i=0; i<szfactors; ++i) { ref_os << pr->name << CONST_TEXT("[") << i << CONST_TEXT("]") << Cfactorscode((*pr)[i]) << CONST_TEXT(";/n"); } } }; struct _Func_ClearrpFlag { rp_flag_T flag; _Func_ClearrpFlag(rp_flag_T f):flag(f){}; void operator()(Prule pr) { pr->prcflag = flag; } }; struct _Pr_IsPrule { bool operator()(const Ctm& tm) const { return (fflag::fflag_rulePtr == tm.flag); } }; /* *------------------------------------------------------------------------- */ class CVn: public vector<Prule> { public: bool bReleaseOnDelete; CVn(bool del) : bReleaseOnDelete(del){} CVn(): bReleaseOnDelete(false){} CVn(std::size_t num, ...) : bReleaseOnDelete(false) { if (num > 0) { va_list ap; std::size_t n = num; va_start(ap, num); while (n-- > 0) { push_back(reinterpret_cast<Prule>(va_arg(ap, Prule))); } va_end(ap); } } virtual ~CVn(); CVn& operator <<(Prule p){ push_back(p); return (*this);} CVn& operator <<(Crule& r){ push_back(&r); return (*this); } Crule* findPrule(const String& word); gostream& PrintRules(gostream& os) { return PrintRules(os, begin(), end()); } gostream& PrintRules(gostream& os, CVn::const_iterator& _b, CVn::const_iterator& _e) { for_each(_b, _e, _Func_PrintRule(os)); return os; } gostream& PrintFIRST(gostream& os) { return PrintFIRST(os, begin(), end()); } gostream& PrintFIRST(gostream& os, CVn::const_iterator& _b, CVn::const_iterator& _e) { for_each(_b, _e, _Func_PrintFIRST(os)); return os; } gostream& PrintFOLLOW(gostream& os) { return PrintFOLLOW(os, begin(), end()); } gostream& PrintFOLLOW(gostream& os, CVn::const_iterator& _b, CVn::const_iterator& _e) { for_each(_b, _e, _Func_PrintFOLLOW(os)); return os; } gostream& PrintCode(gostream& os, CVn::const_iterator& _b, CVn::const_iterator& _e); }; /* *------------------------------------------------------------------------- */ /* *------------------------------------------------------------------------- */ struct Cmte { Pfactor n; Ctm t; Pfactors p; Cmte(Pfactor _n, Ctm& _t, Pfactors _p) : n(_n), t(_t), p(_p){} }; typedef vector<Cmte> Cmtbldata; class Cmtable : public Cmtbldata { public: void setup(const CVn& Vn); Pfactors findfactors(const Cfactor& f, CHAR ch, std::size_t& offset); }; gostream& operator<<(gostream& os, const Cmtable& m); /* *------------------------------------------------------------------------- */ struct CStackData : public Cfactor { typedef std::size_t op_flag_T; struct op_flag { static const op_flag_T opf_push = -1; //static const op_flag_T opf_pop = 0x1; }; std::size_t strfactor_cur; // index match std::size_t op; // flag push or pop std::size_t offset_vn; // Vn ::= abc, this==b std::size_t offset_factor; CStackData(const Cfactor& factor, op_flag_T f, std::size_t ovn, std::size_t of=1/* start with 1*/) : strfactor_cur(0), op(f), offset_vn(ovn), offset_factor(of) { *reinterpret_cast<Pfactor>(this) = factor; } protected: CStackData(); }; typedef vector<CStackData> CStack; class CAStack : public CStack { public: typedef unsigned short match_flag_T; struct match_flag { static const match_flag_T mf_none = 0x0000; static const match_flag_T mf_over = 0x0001; static const match_flag_T mf_vt = 0x0002; static const match_flag_T mf_vn = 0x0003; static const match_flag_T mf_error = 0x0004; }; CAStack(Cmtable* p):pmtable(p), mflast(match_flag::mf_none){} CAStack& Analyse(CHAR ch); match_flag_T mflast; Cmtable* pmtable; CStack::value_type& top(){return *(this->end()-1);}; void pop(){ pop_back(); /*this->erase(end()-1);*/}; void push(CStack::value_type& d){ push_back(d); }; protected: CAStack(); }; /* *------------------------------------------------------------------------- */ bool IsAlpha(const CHAR ch); bool IsDigit(const CHAR ch); bool IsLiteral(const CHAR ch); bool IsStick(const CHAR ch); bool IsEmpty(const CHAR ch); bool IsOver(const CHAR ch); bool IsMark(const CHAR ch); bool IsAnyNotMark(const CHAR ch); bool IsEnter(const CHAR ch); gostream& PrintAlpha(gostream&); gostream& PrintDigit(gostream&); gostream& PrintLiteral(gostream&); gostream& PrintStick(gostream&); gostream& PrintEmpty(gostream&); gostream& PrintOver(gostream&); gostream& PrintMark(gostream&); gostream& PrintAnyNotMark(gostream&); gostream& PrintEnter(gostream&); /* *------------------------------------------------------------------------- */ void getVnProduceEmpty(const CVn&, CVn&); void getVnFIRST(CVn& Vn); void getVnFOLLOW(CVn& Vn); bool analyse(gistream& stream, CAStack& Stack); void GmmAction(flag_T af, std::size_t offset_vn, const CHAR ch, std::size_t offset_factor); void GmmAction2(flag_T af, CStack::value_type&); /* *------------------------------------------------------------------------- */ extern Cfactor_function fn_alpha; extern Cfactor_function fn_digit; extern Cfactor_function fn_literal; extern Cfactor_function fn_stick; extern Cfactor_function fn_empty; extern Cfactor_function fn_mark; extern Cfactor_function fn_anynotmark; extern Cfactor_function fn_enter; extern Cfactor factor_alpha; extern Cfactor factor_digit; extern Cfactor factor_literal; extern Cfactor factor_stick; extern Cfactor factor_empty; extern Cfactor factor_over; extern Cfactor factor_mark; extern Cfactor factor_anynotmark; extern Cfactor factor_enter; extern Cfactor factor_space; extern Cfactor factor_tab; extern Cfactor factor_produce; extern Cfactor factor_lbracket; extern Cfactor factor_rbracket; extern Cfactor factor_K_literal; extern Cfactor factor_K_digit; extern Cfactor factor_K_empty; extern Cfactor factor_K_anynotmark; extern Cfactor factor_K_enter; extern Cfactor factor_K_mark; extern Cfactor factor_K_stick; /* *------------------------------------------------------------------------- */ typedef map<String, Pfactor> mapkey_T; Cfactor& KeywordTofactor(const String kw); typedef map<Cfactor_function*, String> mapkeyfs_T; String& KeyfactorToString(Cfactor_function* pff, String& s); /* *------------------------------------------------------------------------- */ extern Ctm tm_empty; extern CVn VnPE; extern String gWord; extern Cmtable Table; extern CAStack Stack; extern mapkey_T gMks; extern mapkeyfs_T gMsk; /* *------------------------------------------------------------------------- */ #endif /* LL1_H_ */

LL1.cpp

#include "stdafx.h" //============================================================================ // Name : first.cpp // Author : Loon // Version : 0.5 // Copyright : Loon product // Description : BNF Analyse //============================================================================ #include "LL1.h" /* *------------------------------------------------------------------------- */ #ifdef NOTANSI std::locale gloc("Chinese-simplified"); struct xcout { xcout() { gcout.imbue(gloc); } } aXCOUT; #endif /* *------------------------------------------------------------------------- * operator << functions *------------------------------------------------------------------------- */ gostream& operator <<(gostream& os, const Cfactor& f) { switch (f.flag) { case fflag::fflag_function: f.pfn->pfn2(os); break; case fflag::fflag_strfactor: os << CONST_TEXT("/"") << f.strfactor << CONST_TEXT("/""); break; case fflag::fflag_rulePtr: os << f.prule->name; break; //case fflag::fflag_grm_selffactor: // os << CONST_TEXT("$fflag_grm_selffactor"); // break; } return os; } gostream& operator <<(gostream& os, const Cfactors& fs) { std::size_t factor_count = fs.size(); for (std::size_t i = 0; i < factor_count; ++i) { os << fs[i] << CONST_TEXT(" "); } return os; } gostream& operator <<(gostream& os, const Cfactorscode& fs) { std::size_t factor_count = fs.ref_factors.size(); for (std::size_t i = 0; i < factor_count; ++i) { const Cfactor& factor = fs.ref_factors[i]; switch(factor.flag) { case fflag::fflag_rulePtr: os << CONST_TEXT(" << ") << factor.prule->name << CONST_TEXT(".selffactor"); break; case fflag::fflag_strfactor: os << CONST_TEXT(" << Cfactor(/"") << factor.strfactor << CONST_TEXT("/")"); break; case fflag::fflag_function: String s; KeyfactorToString(factor.pfn, s); os << CONST_TEXT(" << ") << s; break; } } return os; } gostream& operator<<(gostream& os, const Crule& r) { std::size_t factors_count = r.size(); for (std::size_t i = 0; i < factors_count; ++i) { os << r.name << CONST_TEXT(" ::= ") << r[i] << CONST_TEXT("/n"); } os << std::endl; return os; } gostream& operator <<(gostream& os, const Ctm& tm) { switch(tm.flag) { case fflag::fflag_char: os << "/'" << tm.firstChar << "/'"; break; case fflag::fflag_function: tm.pfn->pfn2(os); break; case fflag::fflag_rulePtr: os << tm.prule->name; break; } return os; } gostream& operator <<(gostream& os, const CVts& vts) { copy(vts.begin(), vts.end(), ostream_iterator<Ctm>(os, ",")); return os; } gostream& operator <<(gostream& os, const Cmtable& m) { struct _Func_PrintCmte { gostream& ref_os; _Func_PrintCmte(gostream& os):ref_os(os){} void operator()(const Cmte& mte) const { ref_os << CONST_TEXT(" N:") << *mte.n << CONST_TEXT(" T:") << mte.t << CONST_TEXT(" P:") << *mte.p << std::endl; } }; for_each(m.begin(), m.end(), _Func_PrintCmte(os)); return os; } /* *------------------------------------------------------------------------- * class function *------------------------------------------------------------------------- */ Cfactors::~Cfactors(){ delete pFIRST; } void Cfactors::CreateFIRST(){ if (0 == pFIRST) pFIRST = new CVts; } void Crule::getFIRST() { prcflag &= rp_flag::rp_flag_getFIRST; // if P::={empty} if (IsProduceEmpty()) FIRST += tm_empty; // every P::=abc std::size_t szfactors = size(); for(std::size_t ifactors=0;ifactors<szfactors;++ifactors) { Cfactors &factors = (*this)[ifactors]; factors.CreateFIRST(); std::size_t szfactor = factors.size(); std::size_t ifactor=0; bool bloop = true; Cfactor* pfactor = &factors[ifactor]; while(bloop) { // abc switch (pfactor->flag) { case fflag::fflag_function: case fflag::fflag_strfactor: FIRST += pfactor; *factors.pFIRST += pfactor; // add to P FIRST if ((factor_empty == *pfactor) && (1==szfactor)) // p ::= {empty} { factors.bProductEmpty = true; } bloop = false; break; case fflag::fflag_rulePtr: pfactor->prule->getFIRST(); FIRST += pfactor->prule->FIRST; *factors.pFIRST += pfactor->prule->FIRST; // add to P FIRST if (pfactor->prule->IsProduceEmpty()) { while(ifactor<szfactor){ if ((fflag::fflag_rulePtr == pfactor->flag) && (pfactor->prule->IsProduceEmpty())) { ++ifactor; if (ifactor<szfactor) pfactor = &factors[ifactor]; }else break; } // abc ::= {empty} if (ifactor >= szfactor) { FIRST += tm_empty; *factors.pFIRST += tm_empty; // add to P FIRST factors.bProductEmpty = true; // P ::= {empty} bloop = false; } else { // abc ::= {empty}{empty}cxx if ((fflag::fflag_rulePtr == pfactor->flag) && (pfactor->prule != this)) { pfactor->prule->getFIRST(); FIRST += pfactor->prule->FIRST; *factors.pFIRST += pfactor->prule->FIRST; } // gcout << factors << FIRST << std::endl; } }else bloop = false; break; } } } } void Crule::getFOLLOW() { std::size_t szfactors = size(); for(std::size_t ifactors=0;ifactors<szfactors;++ifactors) { Cfactors &factors = (*this)[ifactors]; std::size_t szfactor = factors.size(); std::size_t ifactor=0; Pfactor pfactor=0; for(;ifactor<szfactor;++ifactor) { pfactor = &factors[ifactor]; if (fflag::fflag_rulePtr == pfactor->flag) // is Vn { if (ifactor == szfactor-1) // A ::= aB { if (this != pfactor->prule) pfactor->prule->FOLLOW += Ctm(this); // not A ::=aA } else { Pfactor nextfactor = &factors[ifactor+1]; if (fflag::fflag_rulePtr == nextfactor->flag) // ..BCxx.. { pfactor->prule->FOLLOW += nextfactor->prule->FIRST; // .. FIRST(Cxx) std::size_t iC=ifactor+1; for(;iC<szfactor;++iC) // if end loop then ..BC... have C... ::= {empty} { nextfactor = &factors[iC]; if (fflag::fflag_rulePtr == nextfactor->flag) { if (!nextfactor->prule->IsProduceEmpty()) break; // ..BCxx , Cxx cant not Product {empty} } else { if ((*nextfactor) != factor_empty) break; } } // A ::= ..BCxx, Cxx ::= {empty} if (iC == szfactor) { if (this != pfactor->prule) pfactor->prule->FOLLOW += Ctm(this); // not A ::=aA } else { if (fflag::fflag_rulePtr == nextfactor->flag) { pfactor->prule->FOLLOW += nextfactor->prule->FIRST; } else { pfactor->prule->FOLLOW += Ctm(nextfactor); } } } else { pfactor->prule->FOLLOW += Ctm(nextfactor); // ..Ba... } } } } } } bool Crule::IsProduceEmpty() { return find(VnPE.begin(), VnPE.end(), this) != VnPE.end(); } Crule* CVn::findPrule(const String& word) { struct _Pr_find { const String& ref_word; _Pr_find(const String& w):ref_word(w){} bool operator()(Prule p) const { return (p->name == ref_word); } }; CVn::iterator iter = find_if(begin(), end(), _Pr_find(word)); if (iter != end()) return reinterpret_cast<Prule>(*iter); else return reinterpret_cast<Prule>(0); } CVn::~CVn() { if (bReleaseOnDelete) { struct _Func_del{void operator()(Prule p){delete p;}}; for_each(begin(), end(), _Func_del()); } } gostream& CVn::PrintCode(gostream& os, CVn::const_iterator& _b, CVn::const_iterator& _e) { for_each(_b, _e, _Func_PrintCode_rule(os)); for_each(_b, _e, _Func_PrintCode_factors(os)); if (_b != _e) { os << CONST_TEXT("CVn Vn;/n"); os << CONST_TEXT("Vn"); CVn::const_iterator iter_prule = _b; for(; iter_prule!=_e; ++iter_prule) { os << CONST_TEXT(" << ") << (*iter_prule)->name; } os << CONST_TEXT(";/n"); os << CONST_TEXT("gcout << CONST_TEXT(/"**********************Product//n/");/n"); os << CONST_TEXT("Vn.PrintRules(gcout);/n"); os << CONST_TEXT("getVnProduceEmpty(Vn, VnPE);/n"); os << CONST_TEXT("getVnFIRST(Vn);/n"); os << CONST_TEXT("gcout << CONST_TEXT(/"**********************first//n/");/n"); os << CONST_TEXT("Vn.PrintFIRST(gcout);/n"); os << (*_b)->name << CONST_TEXT(".FOLLOW += &factor_over; // start Vn/n"); os << CONST_TEXT("getVnFOLLOW(Vn);/n"); os << CONST_TEXT("gcout << CONST_TEXT(/"**********************follow//n/");/n"); os << CONST_TEXT("Vn.PrintFOLLOW(gcout);/n"); os << CONST_TEXT("Table.setup(Vn);/n"); os << CONST_TEXT("gcout << CONST_TEXT(/"**********************table//n/");/n"); os << CONST_TEXT("gcout << Table;/n"); os << CONST_TEXT("Stack.push(CStackData(factor_over, CStackData::op_flag::opf_push, 0));/n"); os << CONST_TEXT("Stack.push(CStackData(") << (*_b)->name << CONST_TEXT(".selffactor, CStackData::op_flag::opf_push, 0));/n"); os << CONST_TEXT("bool bret = analyse(gcin, Stack);/n"); os << CONST_TEXT("if (bret)/n"); os << CONST_TEXT("{/n"); os << CONST_TEXT(" gcout << CONST_TEXT(/"//nFinish//n/");/n"); os << CONST_TEXT(" gcout << gTable;/n"); os << CONST_TEXT(" AnaGTable();/n"); //os << CONST_TEXT("gBNF.PrintRules(gcout) << std::endl;/n"); //os << CONST_TEXT("Ofstream of(CONST_TEXT(/"../sld/result.txt/"));/n"); //os << CONST_TEXT("gBNF.PrintCode(of, gBNF.begin(), gBNF.end());/n"); //os << CONST_TEXT("of.flush();/n"); //os << CONST_TEXT("of.close();/n"); os << CONST_TEXT("}/n"); os << CONST_TEXT("else gcout << CONST_TEXT(/"//nFail//n/");/n"); os << CONST_TEXT("gcout << std::endl;/n"); } return os; } struct _Func_AddToVts { CVts& vts; _Func_AddToVts(CVts& v):vts(v){} void operator()(const Ctm& tm) { if (tm==tm_empty) return; vts += tm; } }; void CVts::operator +=(const CVts &vts) { for_each(vts.begin(), vts.end(), _Func_AddToVts(*this)); } void Cmtable::setup(const CVn& Vn) { std::size_t szVn = Vn.size(); for(std::size_t iVn=0; iVn<szVn; ++iVn) { Crule &rule = *Vn[iVn]; std::size_t szfactors = rule.size(); for(std::size_t ifactors=0; ifactors<szfactors; ++ifactors) { Pfactors pfactors = &rule[ifactors]; std::size_t szFIRST = pfactors->pFIRST->size(); for(std::size_t iFIRST=0; iFIRST<szFIRST; ++iFIRST) { push_back(Cmte(rule.pselffactor, (*(pfactors->pFIRST))[iFIRST], pfactors)); } if (pfactors->bProductEmpty) { std::size_t szFOLLOW = rule.FOLLOW.size(); for(std::size_t iFOLLOW=0; iFOLLOW<szFOLLOW; ++iFOLLOW) { push_back(Cmte(rule.pselffactor, (rule.FOLLOW)[iFOLLOW], pfactors)); } } } } } Pfactors Cmtable::findfactors(const Cfactor& f, CHAR ch, std::size_t& offset) { struct _Pr_find{ const Cfactor& ref_f; CHAR ch; _Pr_find(const Cfactor&f, CHAR c) : ref_f(f), ch(c){} bool operator()(const Cmte& mte) const { return (ref_f == *mte.n) && (mte.t.match(ch)); } }; Pfactors ret=0; Cmtbldata::iterator iterfind = find_if(begin(), end(), _Pr_find(f, ch)); if (iterfind != end()) { ret = iterfind->p; offset = iterfind - begin(); } return ret; } CAStack& CAStack::Analyse(CHAR ch) { while (CStackData::op_flag::opf_push != top().op) { CStack::value_type &CHECKTOP = top(); //GmmAction(aflag::aflag_leave, CHECKTOP.op, ch, CHECKTOP.offset_factor); GmmAction2(aflag::aflag_leave, CHECKTOP); pop(); } CStack::value_type &TOP = top(); bool bError = false; switch (TOP.flag) { case fflag::fflag_function: if ((*TOP.pfn->pfn1)(ch)){ pop(); gWord += ch; } else bError = true; mflast = match_flag::mf_vt; break; case fflag::fflag_strfactor: gWord += ch; bError = (ch != TOP.strfactor[TOP.strfactor_cur++]); //gcout << CONST_TEXT("/t2@"); if (!bError && (TOP.strfactor_cur==1)) { //GmmAction(aflag::aflag_enter, TOP.offset_vn, ch, TOP.offset_factor); GmmAction2(aflag::aflag_enter, TOP); } if (TOP.strfactor_cur >= TOP.strfactor.size()) { //GmmAction(aflag::aflag_leave, TOP.offset_vn, ch, TOP.offset_factor); GmmAction2(aflag::aflag_leave, TOP); pop(); } mflast = match_flag::mf_vt; break; case fflag::fflag_rulePtr: Pfactors rel = pmtable->findfactors(TOP, ch, TOP.op); bError = (0==rel); std::size_t pushcount = TOP.op; std::size_t op = TOP.op; // after push, TOP maybe invalid std::size_t offset_factor = TOP.offset_factor; std::size_t offset_top = size()-1; if (!bError) { struct _Func_push { CAStack* pstack; std::size_t &ref_pushcount; std::size_t top_offset; _Func_push(CAStack *stack, std::size_t& pushcnt) : pstack(stack), ref_pushcount(pushcnt),top_offset(pushcnt) { ref_pushcount = 0; } void operator()(const Cfactor& factor) { if (factor_empty != factor) { ++ref_pushcount; CStackData data(factor, CStackData::op_flag::opf_push, top_offset, ref_pushcount); data.op = CStackData::op_flag::opf_push; pstack->push(data); } } }; //gcout << TOP.prule->name << CONST_TEXT("::=") << *rel << CONST_TEXT(" ===> "); //pop(); // pop Vn //gcout << TOP.prule->name << "<>" << TOP.op << std::endl; for_each(rel->rbegin(), rel->rend(), _Func_push(this, pushcount)); if (0 != pushcount) { //gcout << CONST_TEXT("/t1@"); //GmmAction(aflag::aflag_enter, op, ch, offset_factor); GmmAction2(aflag::aflag_enter, (*this)[offset_top]); } // else leave, will pop mflast = match_flag::mf_vn; } break; // case fflag::fflag_char: run to here is impossible } if (bError) mflast = match_flag::mf_error; return *this; } /* *------------------------------------------------------------------------- * factor function *------------------------------------------------------------------------- */ bool IsAlpha(const CHAR ch) { static const String a = CONST_TEXT("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); return (a.find(ch, 0) != String::npos); } bool IsDigit(const CHAR ch) { static const String a = CONST_TEXT("0123456789"); return (a.find(ch, 0) != String::npos); } bool IsLiteral(const CHAR ch){ return IsAlpha(ch) || (CONST_TEXT('_') == ch); } bool IsStick(const CHAR ch){ return CONST_TEXT('|') == ch; } bool IsEmpty(const CHAR ch){ return const_charactor::cc_empty == ch; } bool IsOver(const CHAR ch){ return const_charactor::cc_over == ch; } bool IsMark(const CHAR ch) { return CONST_TEXT('/"') == ch; } bool IsAnyNotMark(const CHAR ch){ return !IsMark(ch); } bool IsEnter(const CHAR ch){ return CONST_TEXT('/n') == ch; } gostream& PrintAlpha(gostream& os){ return os << CONST_TEXT("{alpha}");} gostream& PrintDigit(gostream& os){ return os << CONST_TEXT("{digit}");} gostream& PrintLiteral(gostream& os){ return os << CONST_TEXT("{literal}");} gostream& PrintStick(gostream& os){ return os << CONST_TEXT("{stick}");} gostream& PrintEmpty(gostream& os){ return os << CONST_TEXT("{empty}");} gostream& PrintOver(gostream& os){ return os << CONST_TEXT("{over}");} gostream& PrintMark(gostream& os){ return os << CONST_TEXT("{mark}");} gostream& PrintAnyNotMark(gostream& os){ return os << CONST_TEXT("{anynotmark}");} gostream& PrintEnter(gostream& os){ return os << CONST_TEXT("{Enter}");} /* *------------------------------------------------------------------------- * global function *------------------------------------------------------------------------- */ void getVnProduceEmpty(const CVn& Vn, CVn& VnPE) { struct __checkinfo { Prule prule; Pfactors pfactors; std::size_t szfactor; std::size_t ifactor; __checkinfo(Prule p, Pfactors pf, std::size_t i, std::size_t j) : prule(p), pfactors(pf), szfactor(i), ifactor(j){} bool operator==(Prule p) { return prule == p; } }; typedef vector<__checkinfo> CIS_T; struct _Func_CopyPtoCheckInfo { CIS_T &ref_cis; _Func_CopyPtoCheckInfo(CIS_T& cis):ref_cis(cis){} void operator()(Prule prule) { std::size_t szfactors = prule->size(); Crule &rule=(*prule); for(std::size_t ifactors=0;ifactors<szfactors;++ifactors) { ref_cis.push_back(__checkinfo(&rule, &rule[ifactors], rule[ifactors].size(), 0)); } } }; struct _Pr_IsChecked { bool operator()(const __checkinfo& ci) const { return (rp_flag::rp_flag_getFOLLOW == ci.prule->prcflag); } }; struct _Func_Check { CIS_T &ref_cis; CVn &ref_VnPE; _Func_Check(CIS_T &cis, CVn& VnPE) : ref_cis(cis), ref_VnPE(VnPE){} void operator()(__checkinfo& ci) { if (find(ref_VnPE.begin(), ref_VnPE.end(), ci.prule)==ref_VnPE.end()) { bool bbreak = false; while ((ci.ifactor < ci.szfactor) && !bbreak) { switch((*ci.pfactors)[ci.ifactor].flag) { case fflag::fflag_strfactor: goto LB_REMOVE; break; case fflag::fflag_function: if (factor_empty != (*ci.pfactors)[ci.ifactor]) goto LB_REMOVE; else ++ci.ifactor; break; case fflag::fflag_rulePtr: if (find(ref_VnPE.begin(), ref_VnPE.end(), (*ci.pfactors)[ci.ifactor].prule)==ref_VnPE.end()) { if (find(ref_cis.begin(), ref_cis.end(), (*ci.pfactors)[ci.ifactor].prule) == ref_cis.end()) goto LB_REMOVE; else bbreak = true; } else ++ci.ifactor; break; } } if (ci.ifactor >= ci.szfactor) { ref_VnPE.push_back(ci.prule); gcout << ci.prule->name << CONST_TEXT("/n"); goto LB_REMOVE; } else { return; } } LB_REMOVE: ci.prule->prcflag &= rp_flag::rp_flag_getFOLLOW; // mark, will be remove } }; VnPE.clear(); // clear VnPE for_each(Vn.begin(), Vn.end(), _Func_ClearrpFlag(rp_flag::rp_flag_none)); CIS_T cis; for_each(Vn.begin(), Vn.end(), _Func_CopyPtoCheckInfo(cis)); // copy all factors to cis size_t szRemain=0; size_t szLastRemain=cis.size(); // remain factors to check while(true) { for_each(cis.begin(), cis.end(), _Func_Check(cis, VnPE)); cis.erase(remove_if(cis.begin(), cis.end(), _Pr_IsChecked()), cis.end()); szRemain = cis.size(); if (szRemain == szLastRemain) break; szLastRemain = szRemain; } } void getVnFIRST(CVn& Vn) { for_each(Vn.begin(), Vn.end(), _Func_ClearrpFlag(rp_flag::rp_flag_none)); std::size_t szVn = Vn.size(); for(std::size_t sz=0;sz<szVn;++sz) { if ((Vn[sz]->prcflag & rp_flag::rp_flag_getFIRST) == 0) { Vn[sz]->getFIRST(); } } } void getVnFOLLOW(CVn& Vn) { struct _Func_P{ CVn& ref_R; CVn& ref_E; _Func_P(CVn& R, CVn& E):ref_R(R),ref_E(E){} void operator()(Prule pr){ CVts::iterator pR = find_if(pr->FOLLOW.begin(), pr->FOLLOW.end(), _Pr_IsPrule()); if (pR == pr->FOLLOW.end()) { // 拥有纯的终结符集合 ref_E.push_back(pr); // 标识它,将在下一轮中被从ref_R(待处理集)中移除 pr->prcflag |= rp_flag::rp_flag_getFOLLOW; } else { CVn::iterator pE = find(ref_E.begin(), ref_E.end(), (pR)->prule); if (pE == ref_E.end()) { // 如果所指向的终结符集合不纯 if (pR->prule != pr) { // 如果不是指向本身,用不纯的终结符集合代替 CVn::iterator pN = find(ref_R.begin(), ref_R.end(), (pR)->prule); pr->FOLLOW.erase(pR); // <---Vn if (pN != ref_R.end()) { // 应该能找到,找不到就麻烦了 pr->FOLLOW += (*pN)->FOLLOW; } }else pr->FOLLOW.erase(pR); // <---Vn } else { pr->FOLLOW.erase(pR); // <---Vn pr->FOLLOW += (*pE)->FOLLOW; } } } }; struct _Pr_flag_getFOLLOW{ bool operator()(Prule pr){ return ((pr->prcflag & rp_flag::rp_flag_getFOLLOW) == rp_flag::rp_flag_getFOLLOW); } }; for_each(Vn.begin(), Vn.end(), _Func_ClearrpFlag(rp_flag::rp_flag_none)); CVn R, E; std::size_t szVn = Vn.size(); for(std::size_t sz=0;sz<szVn;++sz) { Vn[sz]->getFOLLOW(); } R.assign(Vn.begin(), Vn.end()); while(R.size()) { for_each(R.begin(), R.end(), _Func_P(R, E)); R.erase(remove_if(R.begin(), R.end(), _Pr_flag_getFOLLOW()), R.end()); //R.PrintFOLLOW(gcout); //gcin.get(); } for_each(Vn.begin(), Vn.end(), _Func_ClearrpFlag(rp_flag::rp_flag_none)); } bool analyse(gistream& stream, CAStack& Stack) { CHAR ch; String Astr; while(ch = stream.get()) { if (stream.eof()) ch = const_charactor::cc_over; else Astr += ch; //gcout << CONST_TEXT("[") <<Astr << CONST_TEXT("]/n"); bool bVn = true; bool bError = false; while(bVn) { Stack.Analyse(ch); switch (Stack.mflast) { //case CAStack::match_flag::mf_vn: // break; case CAStack::match_flag::mf_vt: bVn = false; break; case CAStack::match_flag::mf_error: gcout << CONST_TEXT("/nERROR!!!/n"); bVn = false; bError = true; } copy(Stack.begin(), Stack.end(), ostream_iterator<CStackData>(gcout, ",")); gcout << std::endl; } if (bError) break; if (ch == const_charactor::cc_over) break; } return ((ch == const_charactor::cc_over) && (Stack.size()==0)); }

LL1init.cpp

#include "stdafx.h" //============================================================================ // Name : first.cpp // Author : Loon // Version : 0.5 // Copyright : Loon product // Description : BNF Analyse //============================================================================ #include "LL1.h" /* *------------------------------------------------------------------------- */ Cfactor_function fn_alpha(IsAlpha, PrintAlpha); Cfactor_function fn_digit(IsDigit, PrintDigit); Cfactor_function fn_literal(IsLiteral, PrintLiteral); Cfactor_function fn_stick(IsStick, PrintStick); Cfactor_function fn_empty(IsEmpty, PrintEmpty); Cfactor_function fn_over(IsOver, PrintOver); Cfactor_function fn_mark(IsMark, PrintMark); Cfactor_function fn_anynotmark(IsAnyNotMark, PrintAnyNotMark); Cfactor_function fn_enter(IsEnter, PrintEnter); /* *------------------------------------------------------------------------- */ Cfactor factor_alpha(&fn_alpha); Cfactor factor_digit(&fn_digit); Cfactor factor_literal(&fn_literal); Cfactor factor_stick(&fn_stick); Cfactor factor_empty(&fn_empty); Cfactor factor_over(&fn_over); Cfactor factor_mark(&fn_mark); Cfactor factor_anynotmark(&fn_anynotmark); Cfactor factor_enter(&fn_enter); Cfactor factor_space(CONST_TEXT(" ")); Cfactor factor_tab(CONST_TEXT(" ")); Cfactor factor_produce(CONST_TEXT("::=")); Cfactor factor_lbracket(CONST_TEXT("{")); Cfactor factor_rbracket(CONST_TEXT("}")); Cfactor factor_K_literal(CONST_TEXT("literal")); Cfactor factor_K_digit(CONST_TEXT("digit")); Cfactor factor_K_empty(CONST_TEXT("empty")); Cfactor factor_K_anynotmark(CONST_TEXT("anynotmark")); Cfactor factor_K_enter(CONST_TEXT("Enter")); Cfactor factor_K_mark(CONST_TEXT("mark")); Cfactor factor_K_stick(CONST_TEXT("stick")); /* *------------------------------------------------------------------------- */ Cfactor& KeywordTofactor(const String kw) { return (*gMks[kw]); // must have found } String& KeyfactorToString(Cfactor_function* pff, String& s) { s = gMsk[pff]; return s; } /* *------------------------------------------------------------------------- */ Ctm tm_empty(&factor_empty); CVn VnPE; String gWord; Cmtable Table; CAStack Stack(&Table); mapkey_T gMks; mapkeyfs_T gMsk; struct _init_keywordmap { _init_keywordmap() { gMks[CONST_TEXT("literal")] = &factor_literal; gMks[CONST_TEXT("digit")] = &factor_digit; gMks[CONST_TEXT("empty")] = &factor_empty; gMks[CONST_TEXT("anynotmark")] = &factor_anynotmark; gMks[CONST_TEXT("Enter")] = &factor_enter; gMks[CONST_TEXT("mark")] = &factor_mark; gMks[CONST_TEXT("stick")] = &factor_stick; gMsk[&fn_alpha] = String(CONST_TEXT("factor_alpha")); gMsk[&fn_digit] = String(CONST_TEXT("factor_digit")); gMsk[&fn_literal] = String(CONST_TEXT("factor_literal")); gMsk[&fn_stick] = String(CONST_TEXT("factor_stick")); gMsk[&fn_empty] = String(CONST_TEXT("factor_empty")); gMsk[&fn_over] = String(CONST_TEXT("factor_over")); gMsk[&fn_mark] = String(CONST_TEXT("factor_mark")); gMsk[&fn_anynotmark] = String(CONST_TEXT("factor_anynotmark")); gMsk[&fn_enter] = String(CONST_TEXT("factor_enter")); } }_init_keywordmap_gobj; /* *------------------------------------------------------------------------- */

demo.cpp

#include "stdafx.h" //============================================================================ // Name : first.cpp // Author : Loon // Version : 0.5 // Copyright : Loon product // Description : BNF Analyse //============================================================================ #include "LL1.h" //before iostream include #include "bnfG.h" int _tmain(int argc, _TCHAR* argv[]) { gcout << CONST_TEXT("===============BNF语法分析===============/n") << CONST_TEXT("Author: Loon, version 0.5 20090220/n") << CONST_TEXT("==========================================/n"); /* * W→" "W * W→" "W * W→ε */ Crule W(CONST_TEXT("W"), 3); W[0] << factor_space << W.selffactor; W[1] << factor_tab << W.selffactor; W[2] << factor_empty; /* * P→' ' * P→' ' */ Crule P(CONST_TEXT("P"), 2); P[0] << factor_space; P[1] << factor_tab; /* * M→""" */ Crule M(CONST_TEXT("M"), 1); M[0] << factor_mark; /* * D→"0".."9" */ Crule D(CONST_TEXT("D"), 1); D[0] << factor_digit; /* * L→"_""a".."z""A".."Z" */ Crule L(CONST_TEXT("L"), 1); L[0] << factor_literal; /* * H→LH * H→DH * H→ε */ /* * I→LH */ Crule H(CONST_TEXT("H"), 3); Crule I(CONST_TEXT("I"), 1); H[0] << factor_literal << H.selffactor; H[1] << factor_digit << H.selffactor; H[2] << factor_empty; I[0] << factor_literal << H.selffactor; /* * K→literal | digit | empty | anynotmark | enter | mark */ Crule K(CONST_TEXT("K"), 7); K[0] << factor_K_literal; K[1] << factor_K_digit; K[2] << factor_K_empty; K[3] << factor_K_anynotmark; K[4] << factor_K_enter; K[5] << factor_K_mark; K[6] << factor_K_stick; /* * A→{anynotmark}A_1 * A_1→A|ε */ Crule A(CONST_TEXT("Any"), 1); Crule A_1(CONST_TEXT("Any_1"), 2); A[0] << factor_anynotmark << A_1.selffactor; A_1[0] << A.selffactor; A_1[1] << factor_empty; /* * Q→MAM */ Crule Q(CONST_TEXT("Q"), 1); Q[0] << factor_mark << setGf(flag_grm_string) << A.selffactor << factor_mark; /* * Z→{K} */ Crule Z(CONST_TEXT("Z"), 1); Z[0] << factor_lbracket << setGf(flag_grm_keyword) << K.selffactor << factor_rbracket; /* * F→IG_2 * F→QG * F→ZG */ /* * G→PG * G→QG * G→ZG * G→IG_2 * G→ε */ /* * G_2→QG * G_2→ZG * G_2→PG * G_2→ε */ /* * T→WF */ Crule F(CONST_TEXT("F"), 3); Crule G(CONST_TEXT("G"), 5); Crule G_2(CONST_TEXT("G_2"), 4); Crule T(CONST_TEXT("T"), 1); F[0] << setGf(flag_grm_factor) << I.selffactor << G_2.selffactor; F[1] << Q.selffactor << G.selffactor; F[2] << Z.selffactor << G.selffactor; G[0] << P.selffactor << G.selffactor; G[1] << I.selffactor << G_2.selffactor; G[2] << Q.selffactor << G.selffactor; G[3] << Z.selffactor << G.selffactor; G[4] << factor_empty; G_2[0] << Q.selffactor << G.selffactor; G_2[1] << Z.selffactor << G.selffactor; G_2[2] << P.selffactor << G.selffactor; G_2[3] << factor_empty; T[0] << W.selffactor << F.selffactor; /* * C→"|"E * C→ε */ /* * E→TC */ Crule C(CONST_TEXT("C"), 2); Crule E(CONST_TEXT("E"), 1); C[0] << factor_stick << E.selffactor; C[1] << factor_empty; E[0] << T.selffactor << setGf(flag_grm_newfactors) << C.selffactor; /* * Rule→IW"::="E */ Crule R(CONST_TEXT("Rule"), 1); R[0] << setGf(flag_grm_vn_name) << I.selffactor << W.selffactor << factor_produce << E.selffactor; /* * S_3→{enter}Start * S_3→ε */ /* * Start→RS_3 * Start→PStart * Start→NStart * Start→ε */ Crule S(CONST_TEXT("Start"), 4); Crule S_3(CONST_TEXT("S_3"), 2); S[0] << R.selffactor << S_3.selffactor; S[1] << P.selffactor << S.selffactor; S[2] << factor_enter << S.selffactor; S[3] << factor_empty; S_3[0] << factor_enter << S.selffactor; S_3[1] << factor_empty; /* * Vn集合定义 */ //CVn Vn(21, &S, &S_3, &R, &E, &C, &T, &G, &G_2, &F, &Z, &K, &Q, // &A, &A_1, &M, &I, &H, &L, &D, &P, &W); CVn Vn; Vn << S << S_3 << R << E << C << T << G << G_2 << F << Z << K << Q << A << A_1 << M << I << H << L << D << P << W; gcout << CONST_TEXT("**********************Product/n"); Vn.PrintRules(gcout); getVnProduceEmpty(Vn, VnPE); getVnFIRST(Vn); gcout << CONST_TEXT("**********************first/n"); Vn.PrintFIRST(gcout); S.FOLLOW += &factor_over; // start Vn getVnFOLLOW(Vn); gcout << CONST_TEXT("**********************follow/n"); Vn.PrintFOLLOW(gcout); Table.setup(Vn); gcout << CONST_TEXT("**********************table/n"); gcout << Table; Stack.push(CStackData(factor_over, CStackData::op_flag::opf_push, 0)); Stack.push(CStackData(S.selffactor, CStackData::op_flag::opf_push, 0)); //String test(CONST_TEXT("A ::= {literal}H|/"_/"H/nH ::={literal}H|{digit}H|{empty}")); //Stringstream ss(test); //bool bret = analyse(ss, Stack); bool bret = analyse(gcin, Stack); if (bret) { gcout << CONST_TEXT("/nFinish/n"); gcout << gTable; AnaGTable(); gBNF.PrintRules(gcout) << std::endl; Ofstream of(CONST_TEXT("../sld/CPPCode.txt")); gBNF.PrintCode(of, gBNF.begin(), gBNF.end()); of.flush(); of.close(); } else gcout << CONST_TEXT("/nFail/n"); gcout << std::endl; #ifdef NOTUNIX std::system("pause"); #else gcin.get(); #endif return 0; }

bnfG.h

//============================================================================ // Name : first.cpp // Author : Loon // Version : 0.5 // Copyright : Loon product // Description : BNF Analyse //============================================================================ #ifndef bnfG_H_ #define bnfG_H_ #include "LL1.h" /* *------------------------------------------------------------------------- */ typedef struct grm_word_info { flag_T flag; String word; grm_word_info(flag_T f, const String& s) : flag(f), word(s){} }gwi_T; typedef vector<gwi_T> gwis_T; class Cgtable : public gwis_T { public: Cgtable(); virtual ~Cgtable(); void operator +=(const grm_word_info& gwi) { push_back(gwi); } }; gostream& operator<<(gostream& os, const Cgtable& t); /* *------------------------------------------------------------------------- */ static const flag_T flag_grm_vn_name = flag_grm_base + 1; static const flag_T flag_grm_factor = flag_grm_base + 2; static const flag_T flag_grm_keyword = flag_grm_base + 3; static const flag_T flag_grm_string = flag_grm_base + 4; static const flag_T flag_grm_newfactors = flag_grm_base + 5; /* *------------------------------------------------------------------------- */ extern Cgtable gTable; extern CVn gBNF; void AnaGTable(); #endif

bnfG.cpp

#include "stdafx.h" //============================================================================ // Name : first.cpp // Author : Loon // Version : 0.5 // Copyright : Loon product // Description : BNF Analyse //============================================================================ #include "bnfG.h" /* *------------------------------------------------------------------------- * global object *------------------------------------------------------------------------- */ Cgtable gTable; CVn gBNF(true); /* *------------------------------------------------------------------------- */ Cgtable::Cgtable() {} Cgtable::~Cgtable() { } gostream& operator<<(gostream& os, const Cgtable& t) { struct _Func_print{ gostream& ref_os; _Func_print(gostream& os) : ref_os(os){}; void operator()(const gwi_T& wi) { ref_os << CONST_TEXT("(") << wi.flag << CONST_TEXT(",") << wi.word << CONST_TEXT(")") << std::endl; } }; for_each(t.begin(), t.end(), _Func_print(os)); return os; } /* *------------------------------------------------------------------------- * analyse action *------------------------------------------------------------------------- */ void GmmAction(flag_T af, std::size_t offset_vn, const CHAR, std::size_t offset_factor) { Cmte &mte = Table[offset_vn]; switch (af) { case aflag::aflag_enter: gWord.clear(); gcout << CONST_TEXT("Enter"); //if ((mte.n->prule->name == CONST_TEXT("Rule")) && (offset_factor == 4)) // gcout << CONST_TEXT("/nStart Vn/n"); break; case aflag::aflag_leave: //gcout << CONST_TEXT("Leave"); //if ((mte.n->prule->name == CONST_TEXT("Rule")) && (offset_factor == 4)) // gcout << CONST_TEXT("/nFind Vn") << gWord << std::endl; gWord.clear(); break; } gcout << offset_factor << CONST_TEXT(": ") << mte.n->prule->name << CONST_TEXT("==>") << (*mte.p) << std::endl; //if (mte.n->prule->name == CONST_TEXT("C")) // gcout << CONST_TEXT("/nFIND C/n"); } void GmmAction2(flag_T af, CStack::value_type& sd) { switch (af) { case aflag::aflag_enter: switch (sd.flaggrm) { case flag_grm_vn_name: case flag_grm_keyword: case flag_grm_string: case flag_grm_factor: gWord.clear(); break; case flag_grm_newfactors: gTable += grm_word_info(sd.flaggrm, CONST_TEXT("")); } break; case aflag::aflag_leave: switch (sd.flaggrm) { case flag_grm_vn_name: case flag_grm_keyword: case flag_grm_string: case flag_grm_factor: gTable += grm_word_info(sd.flaggrm, gWord); break; } break; } } void AnaGTable() { Prule plastrule = 0; Pfactors plastfactors = 0; Cgtable::iterator iter_gwis = gTable.begin(); for (; iter_gwis!=gTable.end(); ++iter_gwis) { switch(iter_gwis->flag) { case flag_grm_vn_name: { // rule name Prule prule=gBNF.findPrule(iter_gwis->word); if (0==prule) { prule = new Crule(iter_gwis->word, 1); gBNF << prule; plastrule = prule; plastfactors = &plastrule->operator [](0); // first one } else { plastrule = prule; if (plastrule->size() == 0) { plastrule->resize(1); plastfactors = &plastrule->operator [](0); } else { plastrule->resize(plastrule->size()+1); plastfactors = &(*plastrule)[plastrule->size()-1]; } } break; } case flag_grm_factor: { // rule name reference Prule prule=gBNF.findPrule(iter_gwis->word); if (0!=prule) { *plastfactors << prule->selffactor; } else { // new rule prule = new Crule(iter_gwis->word); gBNF << prule; *plastfactors << prule->selffactor; // not complete } break; } case flag_grm_keyword: { // keyword factor function *plastfactors << KeywordTofactor(iter_gwis->word); break; } case flag_grm_string: { // normal string *plastfactors << Cfactor(iter_gwis->word); break; } case flag_grm_newfactors: { // new factors plastrule->resize(plastrule->size()+1); plastfactors = &(*plastrule)[plastrule->size()-1]; } } } }