svf-tools 1.0.731 → 1.0.732

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.731",
+  "version": "1.0.732",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/CFL/CFGNormalizer.h

@@ -56,7 +56,7 @@ public:
     CFLGrammar* normalize(GrammarBase *generalGrammar);
 
     /// Expand every variable attribute in rawProductions of grammarbase
-    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttrsMap);
+    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kindToAttrsMap);
 
 private:
     /// Add nonterminal to tranfer long rules to binary rules

package/svf/include/CFL/CFLAlias.h

@@ -112,8 +112,8 @@ public:
         {
             return false;
         }
-        CFLGrammar::Kind copyKind = grammar->str2Kind("copy");
-        CFLGrammar::Kind copybarKind = grammar->str2Kind("copybar");
+        CFLGrammar::Kind copyKind = grammar->strToKind("copy");
+        CFLGrammar::Kind copybarKind = grammar->strToKind("copybar");
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(src),graph->getGNode(dst), copyKind));
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(dst),graph->getGNode(src), copybarKind));
         return true;

package/svf/include/CFL/CFLBase.h

@@ -61,6 +61,9 @@ public:
         delete grammarBase;
     }
 
+    /// Parameter Checking
+    virtual void checkParameter();
+
     /// Build Grammar from text file
     virtual void buildCFLGrammar();
 

package/svf/include/CFL/CFLGramGraphChecker.h

@@ -42,29 +42,29 @@ public:
         /// Check all kinds in grammar in graphBuilder with the same label
         for(auto pairV : grammar->getTerminals())
         {
-            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
+            if (graphBuilder->getLabelToKindMap().find(pairV.first) != graphBuilder->getLabelToKindMap().end())
             {
-                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
-                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+                assert(graphBuilder->getLabelToKindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKindToLabelMap()[pairV.second] == pairV.first);
             }
         }
 
         for(auto pairV : grammar->getNonterminals())
         {
-            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
+            if (graphBuilder->getLabelToKindMap().find(pairV.first) != graphBuilder->getLabelToKindMap().end())
             {
-                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
-                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+                assert(graphBuilder->getLabelToKindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKindToLabelMap()[pairV.second] == pairV.first);
             }
             else
             {
-                graphBuilder->getLabel2KindMap().insert(std::make_pair (pairV.first,pairV.second));
-                graphBuilder->getKind2LabelMap().insert(std::make_pair (pairV.second, pairV.first));
+                graphBuilder->getLabelToKindMap().insert(std::make_pair (pairV.first,pairV.second));
+                graphBuilder->getKindToLabelMap().insert(std::make_pair (pairV.second, pairV.first));
             }
         }
 
-        /// Get Kind2Attrs Map from Graph to Grammar
-        grammar->setKind2AttrsMap(graphBuilder->getKind2AttrsMap());
+        /// Get KindToAttrs Map from Graph to Grammar
+        grammar->setKindToAttrsMap(graphBuilder->getKindToAttrsMap());
         graph->startKind = grammar->getStartKind();
     }
 };

package/svf/include/CFL/CFLGrammar.h

@@ -192,9 +192,9 @@ public:
         return this->rawProductions;
     }
 
-    inline const Map<Kind,  Set<Attribute>>& getKind2AttrsMap() const
+    inline const Map<Kind,  Set<Attribute>>& getKindToAttrsMap() const
     {
-        return this->kind2AttrsMap;
+        return this->kindToAttrsMap;
     }
 
     inline Kind getTotalKind()
@@ -223,17 +223,17 @@ public:
 
     void setRawProductions(SymbolMap<Symbol, Productions>& rawProductions);
 
-    void setKind2AttrsMap(const Map<Kind,  Set<Attribute>>& kind2AttrsMap);
+    void setKindToAttrsMap(const Map<Kind,  Set<Attribute>>& kindToAttrsMap);
 
     void setAttributeKinds(const Set<Kind>& attributeKind);
 
-    Kind str2Kind(std::string str) const;
+    Kind strToKind(std::string str) const;
 
-    Symbol str2Symbol(const std::string str) const;
+    Symbol strToSymbol(const std::string str) const;
 
-    std::string kind2Str(Kind kind) const;
+    std::string kindToStr(Kind kind) const;
 
-    std::string sym2StrDump(Symbol sym) const;
+    std::string symToStrDump(Symbol sym) const;
 
     Symbol getSymbol(const Production& prod, u32_t pos)
     {
@@ -282,7 +282,7 @@ private:
     Map<std::string, Kind> terminals;
     Map<std::string, Kind> EBNFSigns; /// Map contains Signs' String and associated Symbols
     Set<Kind> attributeKinds;
-    Map<Kind,  Set<Attribute>> kind2AttrsMap;
+    Map<Kind,  Set<Attribute>> kindToAttrsMap;
     SymbolMap<Symbol, Productions> rawProductions;
     u32_t totalKind;
 };
@@ -310,57 +310,57 @@ public:
         return epsilonProds;
     }
 
-    SymbolMap<Symbol, Productions>& getSingleRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSingleRHSToProds()
     {
-        return singleRHS2Prods;
+        return singleRHSToProds;
     }
 
-    SymbolMap<Symbol, Productions>& getFirstRHS2Prods()
+    SymbolMap<Symbol, Productions>& getFirstRHSToProds()
     {
-        return firstRHS2Prods;
+        return firstRHSToProds;
     }
 
-    SymbolMap<Symbol, Productions>& getSecondRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSecondRHSToProds()
     {
-        return secondRHS2Prods;
+        return secondRHSToProds;
     }
 
     const bool hasProdsFromFirstRHS(const Symbol sym) const
     {
-        auto it = firstRHS2Prods.find(sym);
-        return it!=firstRHS2Prods.end();
+        auto it = firstRHSToProds.find(sym);
+        return it!=firstRHSToProds.end();
     }
 
     const bool hasProdsFromSingleRHS(const Symbol sym) const
     {
-        auto it = singleRHS2Prods.find(sym);
-        return it!=singleRHS2Prods.end();
+        auto it = singleRHSToProds.find(sym);
+        return it!=singleRHSToProds.end();
     }
 
     const bool hasProdsFromSecondRHS(const Symbol sym) const
     {
-        auto it = secondRHS2Prods.find(sym);
-        return it!=secondRHS2Prods.end();
+        auto it = secondRHSToProds.find(sym);
+        return it!=secondRHSToProds.end();
     }
 
     const Productions& getProdsFromSingleRHS(const Symbol sym) const
     {
-        auto it = singleRHS2Prods.find(sym);
-        assert(it!=singleRHS2Prods.end() && "production (X -> sym) not found for sym!!");
+        auto it = singleRHSToProds.find(sym);
+        assert(it!=singleRHSToProds.end() && "production (X -> sym) not found for sym!!");
         return it->second;
     }
 
     const Productions& getProdsFromFirstRHS(const Symbol sym) const
     {
-        auto it = firstRHS2Prods.find(sym);
-        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y ) not found for sym!!");
+        auto it = firstRHSToProds.find(sym);
+        assert(it!=firstRHSToProds.end() && "production (X -> sym Y ) not found for sym!!");
         return it->second;
     }
 
     const Productions& getProdsFromSecondRHS(const Symbol sym) const
     {
-        auto it = secondRHS2Prods.find(sym);
-        assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
+        auto it = secondRHSToProds.find(sym);
+        assert(it!=secondRHSToProds.end() && "production (X -> Y sym) not found for sym!!");
         return it->second;
     }
 
@@ -392,9 +392,9 @@ public:
 
 private:
     SymbolSet<Production> epsilonProds;
-    SymbolMap<Symbol, Productions> singleRHS2Prods;
-    SymbolMap<Symbol, Productions> firstRHS2Prods;
-    SymbolMap<Symbol, Productions> secondRHS2Prods;
+    SymbolMap<Symbol, Productions> singleRHSToProds;
+    SymbolMap<Symbol, Productions> firstRHSToProds;
+    SymbolMap<Symbol, Productions> secondRHSToProds;
     u32_t newTerminalSubscript;
 };
 

package/svf/include/CFL/CFLGraphBuilder.h

@@ -37,27 +37,40 @@
 namespace SVF
 {
 
-/*!
- * Build CFLGraph from memory graph or dot form
-
+/**
+ * CFLGraphBuilder class is responsible for building CFL (Context-Free Language) graphs
+ * from text files or dot files or from memory graph.
  */
-
 class CFLGraphBuilder
 {
 protected:
+    /// Define Kind(Not contain attribute) and Symbol(May contain attribute) as types derived from CFLGrammar
+    /// to numerically represent label
     typedef CFLGrammar::Kind Kind;
     typedef CFLGrammar::Symbol Symbol;
-    Map<std::string, Kind> label2KindMap;
-    Map<Kind, std::string> kind2LabelMap;
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kind2AttrsMap;
-    bool externMap;
+
+    /// Maps to maintain mapping between labels and kinds
+    Map<std::string, Kind> labelToKindMap;
+    Map<Kind, std::string> kindToLabelMap;
+
+    /// Map to maintain attributes associated with each kind
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kindToAttrsMap;
+
     Kind current;
+    CFLGraph *cflGraph;
 
-public:
-    /// add attribute to kind2Attribute Map
+    /// Method to add an attribute to a specific kind
     void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute);
 
-    /// Build graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// build label and kind connect from the grammar
+    void buildlabelToKindMap(GrammarBase *grammar);
+
+    /// add src and dst node from file
+    CFLNode* addGNode(u32_t NodeID);
+
+public:
+    /// Method to build a CFL graph by copying nodes and edges from any graph
+    /// inherited from GenericGraph
     template<class N, class E>
     void build(GenericGraph<N,E>* graph, CFLGraph* cflGraph)
     {
@@ -76,32 +89,32 @@ public:
         }
     }
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// Method to build a bidirectional CFL graph by copying nodes and edges
+    /// from any graph inherited from GenericGraph
     template<class N, class E>
     CFLGraph* buildBigraph(GenericGraph<N,E>* graph, Kind startKind, GrammarBase *grammar)
     {
         CFLGraph *cflGraph = new CFLGraph(startKind);
-        externMap = true;
         for(auto pairV : grammar->getTerminals())
         {
-            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
             {
-                label2KindMap.insert(pairV);
+                labelToKindMap.insert(pairV);
             }
-            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
             {
-                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
             }
         }
         for(auto pairV : grammar->getNonterminals())
         {
-            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
             {
-                label2KindMap.insert(pairV);
+                labelToKindMap.insert(pairV);
             }
-            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
             {
-                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
             }
         }
         for(auto it = graph->begin(); it!= graph->end(); it++)
@@ -116,78 +129,89 @@ public:
             {
                 CFLGrammar::Kind edgeLabel = edge->getEdgeKind();
                 cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                std::string key = kind2LabelMap[edge->getEdgeKind()];
+                std::string key = kindToLabelMap[edge->getEdgeKind()];
                 key.append("bar");
-                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), labelToKindMap[key]);
             }
         }
         return cflGraph;
     }
 
-    /// Build graph from file
-    void build(std::string filename, CFLGraph* cflGraph);
-
-    /// Build graph from Dot
+    /// Method to build a CFL graph from a Dot file
     CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar);
 
-    Map<std::string, Kind>& getLabel2KindMap()
+    /// Method to build a CFL graph from a Text file
+    CFLGraph* buildFromTextFile(std::string fileName, GrammarBase *grammar);
+
+    /// @{
+    /// Getter methods for accessing class variables
+
+    /// Returns a reference to the map that associates string labels with their corresponding Kind
+    Map<std::string, Kind>& getLabelToKindMap()
     {
-        return this->label2KindMap;
+        return this->labelToKindMap;
     }
 
-    Map<Kind, std::string>& getKind2LabelMap()
+    /// Returns a reference to the map that associates Kinds with their corresponding string labels
+    Map<Kind, std::string>& getKindToLabelMap()
     {
-        return this->kind2LabelMap;
+        return this->kindToLabelMap;
     }
 
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKind2AttrsMap()
+    /// Returns a reference to the map that associates Kinds with their corresponding attributes
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKindToAttrsMap()
     {
-        return this->kind2AttrsMap;
+        return this->kindToAttrsMap;
     }
 
-
+    /// @}
 };
 
+/// AliasCFLGraphBuilder: a CFLGraphBuilder specialized for handling aliasing
 class AliasCFLGraphBuilder : public CFLGraphBuilder
 {
 public:
-    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from GenericGraph
     CFLGraph* buildBigraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar);
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
-    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    /// Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph
+    /// Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph
     CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
 
 private:
+    /// Connects VGep (Variable GEP)
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
-    /// Handle edge except for the GEP
+    /// Handles edges, with the exception of the GEP
     void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
 
-    /// Add Bidirectional GEP edge with attribute
+    /// Adds bidirectional GEP edges with attributes
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
 };
 
+/// VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow
 class VFCFLGraphBuilder : public CFLGraphBuilder
 {
 public:
-    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from SVFG
     CFLGraph* buildBigraph(SVFG *graph, Kind startKind, GrammarBase *grammar);
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
-    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    /// Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph
+    /// Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph
     CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
 
 private:
+    /// Connects VGep (Variable GEP)
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
-    /// Handle edge except for the GEP
+    /// Handles edges, with the exception of the GEP
     void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
 
-    /// Add Bidirectional GEP edge with attribute
+    /// Adds bidirectional GEP edges with attributes
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
 };
 
+
 }// SVF
 
 #endif /* INCLUDE_CFL_CFLGRAPHBUILDER_H_*/

package/svf/include/CFL/CFLVF.h

@@ -46,6 +46,9 @@ public:
     {
     }
 
+    /// Parameter Checking
+    virtual void checkParameter();
+
     /// Initialize the grammar, graph, solver
     virtual void initialize();
 

package/svf/include/Util/Options.h

@@ -266,6 +266,7 @@ public:
     static const Option<bool>  CFLSVFG;
     static const Option<bool> POCRAlias;
     static const Option<bool> POCRHybrid;
+    static const Option<bool> Customized;
 
     // Loop Analysis
     static const Option<bool> LoopAnalysis;

package/svf/include/Util/SVFUtil.h

@@ -215,17 +215,24 @@ inline CallSite getSVFCallSite(const SVFValue* value)
 }
 
 /// Split into two substrings around the first occurrence of a separator string.
-inline std::vector<std::string> split(const std::string& s, char seperator)
+inline std::vector<std::string> split(const std::string& s, char separator)
 {
     std::vector<std::string> output;
     std::string::size_type prev_pos = 0, pos = 0;
-    while((pos = s.find(seperator, pos)) != std::string::npos)
+    while ((pos = s.find(separator, pos)) != std::string::npos)
     {
-        std::string substring( s.substr(prev_pos, pos-prev_pos) );
-        output.push_back(substring);
+        std::string substring(s.substr(prev_pos, pos - prev_pos));
+        if (!substring.empty())
+        {
+            output.push_back(substring);
+        }
         prev_pos = ++pos;
     }
-    output.push_back(s.substr(prev_pos, pos-prev_pos));
+    std::string lastSubstring(s.substr(prev_pos, pos - prev_pos));
+    if (!lastSubstring.empty())
+    {
+        output.push_back(lastSubstring);
+    }
     return output;
 }
 

package/svf/lib/CFL/CFGNormalizer.cpp

@@ -48,21 +48,21 @@ CFLGrammar* CFGNormalizer::normalize(GrammarBase *generalGrammar)
     grammar->setEBNFSigns(generalGrammar->getEBNFSigns());
     grammar->setTotalKind(generalGrammar->getTotalKind());
     grammar->setAttributeKinds(generalGrammar->getAttrSyms());
-    grammar->setKind2AttrsMap(generalGrammar->getKind2AttrsMap());
+    grammar->setKindToAttrsMap(generalGrammar->getKindToAttrsMap());
     grammar->setRawProductions(generalGrammar->getRawProductions());
     barReplace(grammar);
     ebnfSignReplace('*', grammar);
     ebnfSignReplace('?', grammar);
     ebnf_bin(grammar);
-    fillAttribute(grammar, grammar->getKind2AttrsMap());
+    fillAttribute(grammar, grammar->getKindToAttrsMap());
     return grammar;
 }
 
 
-CFLGrammar* CFGNormalizer::fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttrsMap)
+CFLGrammar* CFGNormalizer::fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kindToAttrsMap)
 {
     NodeSet nodeSet = {};
-    for (auto pair: kind2AttrsMap)
+    for (auto pair: kindToAttrsMap)
     {
         for (auto attri: pair.second)
         {
@@ -245,7 +245,7 @@ void CFGNormalizer::getFilledProductions(GrammarBase::Production &prod, const No
             normalProds.insert(currentProduction);
             continue;
         }
-        //*(kind2AttriMap.find(baseKind));
+        //*(kindToAttriMap.find(baseKind));
         //for (auto attribute : nodeSet.second)
         for (auto attribute : nodeSet)
         {
@@ -284,7 +284,7 @@ int CFGNormalizer::ebnfBracketMatch(GrammarBase::Production &prod, int i, CFLGra
     int index = i;
     while (index >= 0)
     {
-        if (grammar->kind2Str(prod[index].kind) == "(")
+        if (grammar->kindToStr(prod[index].kind) == "(")
         {
             return index;
         }
@@ -305,7 +305,7 @@ void CFGNormalizer::barReplace(CFLGrammar *grammar)
             size_t j = 1;
             while (i < ebnfProduction.size())
             {
-                if (grammar->kind2Str(ebnfProduction[i].kind) == "|")
+                if (grammar->kindToStr(ebnfProduction[i].kind) == "|")
                 {
                     GrammarBase::Production tempPro(ebnfProduction.begin()+j, ebnfProduction.begin()+i);
                     tempPro.insert(tempPro.begin(), symbolToProductionsPair.first );
@@ -339,11 +339,11 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
             while (i < ebnfProduction.size())
             {
                 s32_t signGroupStart = -1;
-                if (grammar->kind2Str(ebnfProduction[i].kind) == std::string(1, sign))
+                if (grammar->kindToStr(ebnfProduction[i].kind) == std::string(1, sign))
                 {
                     /// If sign assoicate wihout group e.i with single symble
                     assert(i != 1 && "sign in grammar associate with no symbol");
-                    if (grammar->kind2Str(ebnfProduction[i - 1].kind) != std::string(1, ')'))
+                    if (grammar->kindToStr(ebnfProduction[i - 1].kind) != std::string(1, ')'))
                     {
                         signGroupStart = i - 1;
                     }
@@ -355,20 +355,20 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
                     std::string groupString = "";
                     for (size_t j = signGroupStart; j < i; j++)
                     {
-                        groupString.append(grammar->kind2Str(ebnfProduction[j].kind));
+                        groupString.append(grammar->kindToStr(ebnfProduction[j].kind));
                         groupString.append(" ");
                     }
-                    groupString.append(grammar->kind2Str(ebnfProduction[i].kind));
+                    groupString.append(grammar->kindToStr(ebnfProduction[i].kind));
                     if (newProductions.find(groupString) != newProductions.end())
                     {
                         productions.erase(ebnfProduction);
                         ebnfProduction.erase(ebnfProduction.begin() + signGroupStart, ebnfProduction.begin() + i + 1);
-                        ebnfProduction.insert(ebnfProduction.begin() + signGroupStart, grammar->str2Symbol(newProductions[groupString]));
+                        ebnfProduction.insert(ebnfProduction.begin() + signGroupStart, grammar->strToSymbol(newProductions[groupString]));
                         productions.insert(ebnfProduction);
                     }
                     else if ( (signGroupStart == 1) && (i == ebnfProduction.size() -1))
                     {
-                        newProductions[groupString] = grammar->kind2Str(ebnfProduction[0].kind);
+                        newProductions[groupString] = grammar->kindToStr(ebnfProduction[0].kind);
                         productions.erase(ebnfProduction);
                         ebnfProduction.erase(ebnfProduction.begin() + signGroupStart, ebnfProduction.begin() + i + 1);
 
@@ -398,10 +398,10 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
     {
         /// For Both * and ? need to insert epsilon rule
         std::string new_nonterminal = rep.second;
-        GrammarBase::Production temp_list = {grammar->str2Symbol(new_nonterminal), grammar->str2Symbol("epsilon")};
-        grammar->getRawProductions()[grammar->str2Symbol(new_nonterminal)].insert(temp_list);
+        GrammarBase::Production temp_list = {grammar->strToSymbol(new_nonterminal), grammar->strToSymbol("epsilon")};
+        grammar->getRawProductions()[grammar->strToSymbol(new_nonterminal)].insert(temp_list);
         /// insert second rule for '*' X -> X E for '+' X -> E
-        temp_list = {grammar->str2Symbol(new_nonterminal)};
+        temp_list = {grammar->strToSymbol(new_nonterminal)};
         if (sign == '*' || sign == '?')
         {
             /// Insert Back the Group
@@ -412,18 +412,18 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
             {
                 for (auto &word : normalProd)
                 {
-                    if (word != grammar->str2Symbol("*")  && word != grammar->str2Symbol("(") && word != grammar->str2Symbol(")"))
+                    if (word != grammar->strToSymbol("*")  && word != grammar->strToSymbol("(") && word != grammar->strToSymbol(")"))
                     {
                         withoutSign.push_back(word);
                     }
                 }
-                withoutSign.push_back(grammar->str2Symbol(rep.second));
+                withoutSign.push_back(grammar->strToSymbol(rep.second));
             }
             if (sign == '?')
             {
                 for (auto &word : normalProd)
                 {
-                    if (word != grammar->str2Symbol("?")  && word != grammar->str2Symbol("(") && word != grammar->str2Symbol(")"))
+                    if (word != grammar->strToSymbol("?")  && word != grammar->strToSymbol("(") && word != grammar->strToSymbol(")"))
                     {
                         withoutSign.push_back(word);
                     }
@@ -431,7 +431,7 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
             }
             temp_list.insert(temp_list.end(), withoutSign.begin(), withoutSign.end());
         }
-        grammar->getRawProductions()[grammar->str2Symbol(new_nonterminal)].insert(temp_list);
+        grammar->getRawProductions()[grammar->strToSymbol(new_nonterminal)].insert(temp_list);
     }
 }
 
@@ -449,9 +449,9 @@ void CFGNormalizer::strTrans(std::string LHS, CFLGrammar *grammar, GrammarBase::
     {
         word = LHS.substr(0, pos);
         LHS.erase(0, pos + delimiter.length());
-        normalProd.push_back(grammar->str2Symbol(word));
+        normalProd.push_back(grammar->strToSymbol(word));
     }
-    normalProd.push_back(grammar->str2Symbol(LHS));
+    normalProd.push_back(grammar->strToSymbol(LHS));
 }
 
 GrammarBase::Symbol CFGNormalizer::check_head(GrammarBase::SymbolMap<GrammarBase::Symbol, GrammarBase::Productions> &grammar, GrammarBase::Production &rule)
@@ -475,7 +475,7 @@ void CFGNormalizer::insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Product
 {
     if (prod.size() == 2)
     {
-        if ((std::find(prod.begin(), prod.end(), grammar->str2Kind("epsilon")) != prod.end()))
+        if ((std::find(prod.begin(), prod.end(), grammar->strToKind("epsilon")) != prod.end()))
         {
             if (std::find(grammar->getEpsilonProds().begin(), grammar->getEpsilonProds().end(), prod) == grammar->getEpsilonProds().end())
             {
@@ -484,13 +484,13 @@ void CFGNormalizer::insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Product
         }
         else
         {
-            grammar->getSingleRHS2Prods()[prod[1]].insert(prod);
+            grammar->getSingleRHSToProds()[prod[1]].insert(prod);
         }
     }
     if (prod.size() == 3)
     {
-        grammar->getFirstRHS2Prods()[prod[1]].insert(prod);
-        grammar->getSecondRHS2Prods()[prod[2]].insert(prod);
+        grammar->getFirstRHSToProds()[prod[1]].insert(prod);
+        grammar->getSecondRHSToProds()[prod[2]].insert(prod);
     }
 }