SVF::GrammarBuilder Class Reference

#include <GrammarBuilder.h>

Public Member Functions
	GrammarBuilder (std::string fileName)
GrammarBase *	build () const
	Build grammarBase from fileName. More...
GrammarBase *	build (Map< std::string, SVF::GrammarBase::Symbol > &preMap) const
	Build grammarBase from fileName with preset str2KindMap. More...

Private Member Functions
const std::string	parseProductionsString () const
	Parse start symbol and production from file string. More...
const std::vector< std::string >	loadWordProductions () const
	Parse whole production string to production vector. More...
const std::string	stripSpace (std::string s) const
	Strip front and tail space. More...

Private Attributes
std::string	fileName
GrammarBase *	grammar

Detailed Description

Build Grammar from a user specified grammar text

Symbol Format: <kind> [bar] [ _alpha | _number ] kind: any nonspace string start with alphabet, epsilon stand for empty string bar: stand for reverse edge alpha: any single alpha number: any number start with capital: nonterminal start with noncapital: terminal

Production Format: <symbol> -> <symbol> *; LHS and RHS, Separate by '->', symbol separate by ' ', end by ';' support '*', '?', '(', ')'

Input Format: Start: M // Specify Start Symbol in Second Line Terminal: Addr Copy Store Load Gep Vgep // Specify the order of terminal Addr->0, Copy->1 .. Productions: // Each Symbol separate by 'Space', production end with ';' M -> V d; // Terminal in NonCapital M -> dbar V d; // NonTerminal in Capital V -> M abar M a M; // LHS and RHS, Separate by '->' V -> ( M ? abar ) * M ? ( a M ? ) *; // Support '(' ')' '?' '*' four regular expression sign Gep_j -> Gep_i F vgep; // Support variable attribute with variable attribute Gep_1 -> Gep_2; // Support fix number attribute

Definition at line 70 of file GrammarBuilder.h.

Constructor & Destructor Documentation

GrammarBuilder()

SVF::GrammarBuilder::GrammarBuilder ( std::string  fileName )

inline

Definition at line 86 of file GrammarBuilder.h.

                                      : fileName(fileName), grammar(nullptr)
    {
        grammar = new GrammarBase();
    };

Member Function Documentation

build() [1/2]

GrammarBase * SVF::GrammarBuilder::build

(

)

const

Build grammarBase from fileName.

build grammarbase from textfile

Definition at line 115 of file GrammarBuilder.cpp.

{
    std::smatch matches;
    std::string delimiter = " ";
    std::string delimiter1 = "->";
    std::string word = "";
    size_t pos;
    GrammarBase::Production prod;
    std::vector<std::string> wordProdVec = loadWordProductions();
 
    for (auto wordProd : wordProdVec)
    {
        if ((pos = wordProd.find(delimiter1)) != std::string::npos)
        {
            std::string RHS = stripSpace(wordProd.substr(0, pos));
            std::string LHS = wordProd.substr(pos + delimiter1.size(), wordProd.size() - 1);
            GrammarBase::Symbol RHSSymbol = grammar->insertSymbol(RHS);
            prod.push_back(RHSSymbol);
            if (grammar->getRawProductions().find(RHSSymbol) == grammar->getRawProductions().end())  grammar->getRawProductions().insert({RHSSymbol, {}});
            std::regex LHSRegEx("\\s*(.*)");
            std::regex_search(LHS, matches, LHSRegEx);
            LHS = matches.str(1);
            while ((pos = LHS.find(delimiter)) != std::string::npos)
            {
                word = LHS.substr(0, pos);
                LHS.erase(0, pos + delimiter.length()); //Capital is Nonterminal, Otherwise is terminal
                prod.push_back(grammar->insertSymbol(word));
            }
            prod.push_back(grammar->insertSymbol(LHS));
            grammar->getRawProductions().at(RHSSymbol).insert(prod);
            prod = {};
        }
    }
 
    return grammar;
};

build() [2/2]

GrammarBase* SVF::GrammarBuilder::build

(

Map< std::string, SVF::GrammarBase::Symbol > &

preMap

)

const

Build grammarBase from fileName with preset str2KindMap.

loadWordProductions()

const std::vector< std::string > SVF::GrammarBuilder::loadWordProductions ( ) const

inlineprivate

Parse whole production string to production vector.

Definition at line 89 of file GrammarBuilder.cpp.

{
    size_t pos = 0;
    std::string lines = parseProductionsString();
    std::string word = "";
    std::vector<std::string> wordProds;
    std::string delimiter = ";";
    while ((pos = lines.find(";")) != std::string::npos)
    {
        word = lines.substr(0, pos);
        wordProds.push_back(word);
        lines.erase(0, pos + delimiter.length());
    }
    return wordProds;
}

parseProductionsString()

const std::string SVF::GrammarBuilder::parseProductionsString ( ) const

inlineprivate

Parse start symbol and production from file string.

Definition at line 39 of file GrammarBuilder.cpp.

{
    std::ifstream textFile(fileName);
    if (!textFile.is_open())
    {
        std::cerr << "Can't open CFL grammar file `" << fileName << "`" << std::endl;
        abort();
    }
    std::string lineString;
    std::string lines = "";
    std::string startString;
    std::string symbolString;
    const std::string WHITESPACE = " \n\r\t\f\v";
    int lineNum = 0;
    while (getline(textFile, lineString))
    {
        if(lineNum == 1)
        {
            startString = stripSpace(lineString);
        }
        if(lineNum == 3)
        {
            symbolString = lineString.substr(lineString.find_first_not_of(WHITESPACE), lineString.find_last_not_of(WHITESPACE)+1);
        }
 
        lines.append(lineString.substr(lineString.find_first_not_of(WHITESPACE), lineString.find_last_not_of(WHITESPACE)+1));
        lineNum++;
    }
 
    std::regex reg("Start:([\\s\\S]*)Terminal:(.*)Productions:([\\s\\S]*)");
    std::smatch matches;
    if (std::regex_search(lines, matches, reg))
    {
        lines = matches.str(3);
    }
    std::string sString;
    size_t pos = 0;
    while ((pos = symbolString.find(" ")) != std::string::npos)
    {
        sString = stripSpace(symbolString.substr(0, pos));
        symbolString.erase(0, pos + 1); //Capital is Nonterminal, Otherwise is terminal
        grammar->insertSymbol(sString);
    }
    grammar->insertSymbol(symbolString);
    grammar->setStartKind(grammar->insertSymbol(startString));
    grammar->insertTerminalKind("epsilon");
 
    return lines;
}

stripSpace()

const std::string SVF::GrammarBuilder::stripSpace ( std::string  s ) const

inlineprivate

Strip front and tail space.

Definition at line 105 of file GrammarBuilder.cpp.

{
    std::smatch matches;
    std::regex stripReg("\\s*(\\S*)\\s*");
    std::regex_search(s, matches, stripReg);
    return matches.str(1);
}

Member Data Documentation

fileName

std::string SVF::GrammarBuilder::fileName

private

Definition at line 73 of file GrammarBuilder.h.

grammar

GrammarBase* SVF::GrammarBuilder::grammar

private

Definition at line 74 of file GrammarBuilder.h.

---

The documentation for this class was generated from the following files:

• /home/runner/work/SVF/SVF/svf/include/CFL/GrammarBuilder.h
• /home/runner/work/SVF/SVF/svf/lib/CFL/GrammarBuilder.cpp