svf-tools 1.0.730 → 1.0.732

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);
     }
 }
 

package/svf/lib/CFL/CFLAlias.cpp

@@ -191,6 +191,9 @@ void CFLAlias::initialize()
 {
     stat = new CFLStat(this);
 
+    // Parameter Checking
+    checkParameter();
+
     // Build CFL Grammar
     buildCFLGrammar();
 

package/svf/lib/CFL/CFLBase.cpp

@@ -46,6 +46,21 @@ double CFLBase::numOfStartEdges = 0;
 double CFLBase::numOfIteration = 1;
 double CFLBase::numOfChecks = 1;
 
+void CFLBase::checkParameter()
+{
+    // Check for valid grammar file before parsing other options
+    std::string filename = Options::GrammarFilename();
+    bool cflfile = (filename.rfind("CFLGrammar.txt") == filename.length() - std::string("CFLGrammar.txt").length());
+    bool pegfile = (filename.rfind("PEGGrammar.txt") == filename.length() - std::string("PEGGrammar.txt").length());
+    if (!Options::Customized()  && !(cflfile || pegfile))
+    {
+        SVFUtil::errs() << "Invalid alias grammar file: " << Options::GrammarFilename() << "\n"
+                        << "Please use a file that ends with either 'CFLGrammar.txt' or 'PEGGrammar.txt', "
+                        << "or use the -customized flag to allow custom grammar files.\n";
+        assert(false && "grammar loading failed!");  // exit with error
+    }
+}
+
 void CFLBase::buildCFLGrammar()
 {
     // Start building grammar
@@ -76,8 +91,14 @@ void CFLBase::buildCFLGraph()
         delete consCG;
     }
     else
-        graph = cflGraphBuilder.buildFromDot(Options::CFLGraph(), grammarBase);
-
+    {
+        std::string fileName = Options::CFLGraph();
+        bool dotfile = (fileName.rfind(".dot") == fileName.length() - std::string("dot").length());
+        if (dotfile)
+            graph = cflGraphBuilder.buildFromDot(Options::CFLGraph(), grammarBase);
+        else
+            graph = cflGraphBuilder.buildFromTextFile(Options::CFLGraph(), grammarBase);
+    }
     // Check CFL Graph and Grammar are accordance with grammar
     CFLGramGraphChecker cflChecker = CFLGramGraphChecker();
     cflChecker.check(grammarBase, &cflGraphBuilder, graph);

package/svf/lib/CFL/CFLGrammar.cpp

@@ -42,9 +42,9 @@ void GrammarBase::setRawProductions(SymbolMap<Symbol, Productions>& rawProductio
     this->rawProductions = rawProductions;
 }
 
-void GrammarBase::setKind2AttrsMap(const Map<Kind,  Set<Attribute>>& kind2AttrsMap)
+void GrammarBase::setKindToAttrsMap(const Map<Kind,  Set<Attribute>>& kindToAttrsMap)
 {
-    this->kind2AttrsMap = kind2AttrsMap;
+    this->kindToAttrsMap = kindToAttrsMap;
 }
 
 void GrammarBase::setAttributeKinds(const Set<Kind>& attributeKinds)
@@ -52,7 +52,7 @@ void GrammarBase::setAttributeKinds(const Set<Kind>& attributeKinds)
     this->attributeKinds = attributeKinds;
 }
 
-GrammarBase::Kind GrammarBase::str2Kind(std::string str) const
+GrammarBase::Kind GrammarBase::strToKind(std::string str) const
 {
 
     auto tit = terminals.find(str);
@@ -71,12 +71,12 @@ GrammarBase::Kind GrammarBase::str2Kind(std::string str) const
     abort();
 }
 
-GrammarBase::Symbol GrammarBase::str2Symbol(const std::string str) const
+GrammarBase::Symbol GrammarBase::strToSymbol(const std::string str) const
 {
     Symbol symbol;
     std::string attributeStr = extractAttributeStrFromSymbolStr(str);
     std::string kindStr = extractKindStrFromSymbolStr(str);
-    symbol.kind = str2Kind(kindStr);
+    symbol.kind = strToKind(kindStr);
 
     if ( attributeStr == "") return symbol;
 
@@ -100,7 +100,7 @@ GrammarBase::Symbol GrammarBase::str2Symbol(const std::string str) const
     return symbol;
 }
 
-std::string GrammarBase::kind2Str(Kind kind) const
+std::string GrammarBase::kindToStr(Kind kind) const
 {
 
     std::string key = "";
@@ -136,7 +136,7 @@ std::string GrammarBase::kind2Str(Kind kind) const
     return "";
 }
 
-std::string GrammarBase::sym2StrDump(Symbol sym) const
+std::string GrammarBase::symToStrDump(Symbol sym) const
 {
     Kind kind = sym.kind;
     Attribute attribute = sym.attribute;
@@ -184,7 +184,7 @@ GrammarBase::Kind GrammarBase::insertTerminalKind(std::string kindStr)
     }
     else
     {
-        kind = str2Kind(kindStr);
+        kind = strToKind(kindStr);
     }
     return kind;
 }
@@ -199,7 +199,7 @@ inline GrammarBase::Kind GrammarBase::insertNonterminalKind(std::string const ki
     }
     else
     {
-        kind = str2Kind(kindStr);
+        kind = strToKind(kindStr);
     }
     return kind;
 }
@@ -318,7 +318,7 @@ GrammarBase::Symbol GrammarBase::insertEBNFSigns(std::string symbolStr)
     }
     else
     {
-        sign = str2Kind(symbolStr);
+        sign = strToKind(symbolStr);
     }
     return sign;
 
@@ -327,14 +327,14 @@ GrammarBase::Symbol GrammarBase::insertEBNFSigns(std::string symbolStr)
 void GrammarBase::insertAttribute(Kind kind, Attribute attribute)
 {
     attributeKinds.insert(kind);
-    if (kind2AttrsMap.find(kind)!= kind2AttrsMap.end())
+    if (kindToAttrsMap.find(kind)!= kindToAttrsMap.end())
     {
-        kind2AttrsMap[kind].insert(attribute);
+        kindToAttrsMap[kind].insert(attribute);
     }
     else
     {
         Set<CFLGrammar::Attribute> attrs {attribute};
-        kind2AttrsMap.insert(make_pair(kind, attrs));
+        kindToAttrsMap.insert(make_pair(kind, attrs));
     }
 }
 
@@ -352,7 +352,7 @@ void CFLGrammar::dump(std::string fileName) const
 {
     std::ofstream gramFile(fileName);
     gramFile << "Start Kind:\n";
-    gramFile << '\t' << kind2Str(startKind) << '(' << startKind << ')' << ' ' << "\n\n";
+    gramFile << '\t' << kindToStr(startKind) << '(' << startKind << ')' << ' ' << "\n\n";
 
     gramFile << "Epsilon Production:\n";
     std::vector<std::string> strV;
@@ -365,7 +365,7 @@ void CFLGrammar::dump(std::string fileName) const
             {
                 ss << "-> ";
             }
-            ss << sym2StrDump(sym) << '(' << sym.kind << ')' << ' ';
+            ss << symToStrDump(sym) << '(' << sym.kind << ')' << ' ';
         }
         strV.insert(strV.begin(), ss.str());
     }
@@ -380,7 +380,7 @@ void CFLGrammar::dump(std::string fileName) const
 
     gramFile << "Single Production:\n";
     strV = {};
-    for (auto symProPair: singleRHS2Prods)
+    for (auto symProPair: singleRHSToProds)
     {
         for (auto pro: symProPair.second)
         {
@@ -393,7 +393,7 @@ void CFLGrammar::dump(std::string fileName) const
                 {
                     ss << "-> ";
                 }
-                ss << sym2StrDump(sym) << '(' << sym.kind << ')' << ' ';
+                ss << symToStrDump(sym) << '(' << sym.kind << ')' << ' ';
             }
             strV.insert(strV.begin(), ss.str());
         }
@@ -409,7 +409,7 @@ void CFLGrammar::dump(std::string fileName) const
 
     gramFile << "Binary Production:\n";
     strV = {};
-    for (auto symProPair: firstRHS2Prods)
+    for (auto symProPair: firstRHSToProds)
     {
         for (auto pro: symProPair.second)
         {
@@ -423,7 +423,7 @@ void CFLGrammar::dump(std::string fileName) const
                 {
                     ss << "-> ";
                 }
-                ss << sym2StrDump(sym) << '(' << sym.kind << ')' << ' ';
+                ss << symToStrDump(sym) << '(' << sym.kind << ')' << ' ';
             }
             strV.insert(strV.begin(), ss.str());
         }