SVF::GrammarBuilder Class Reference

#include <GrammarBuilder.h>

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

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

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 140 of file GrammarBuilder.cpp.

{
    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)
    {
        // Find the position of the '->' delimiter
        if ((pos = wordProd.find(delimiter1)) != std::string::npos)
        {
            // Extract and strip RHS (right-hand side) and LHS (left-hand side)
            std::string RHS = stripSpace(wordProd.substr(0, pos));
            std::string LHS = stripSpace(wordProd.substr(pos + delimiter1.size()));
 
            // Insert RHS symbol into grammar
            GrammarBase::Symbol RHSSymbol = grammar->insertSymbol(RHS);
            prod.push_back(RHSSymbol);
 
            // Ensure RHS symbol exists in raw productions
            if (grammar->getRawProductions().find(RHSSymbol) == grammar->getRawProductions().end())
            {
                grammar->getRawProductions().insert({RHSSymbol, {}});
            }
 
            // Parse LHS string into symbols
            while ((pos = LHS.find(delimiter)) != std::string::npos)
            {
                // Extract each word before the space
                word = stripSpace(LHS.substr(0, pos));
                LHS.erase(0, pos + delimiter.length());
 
                // Insert symbol into production
                prod.push_back(grammar->insertSymbol(word));
            }
 
            // Insert the remaining word (if any) into the production
            if (!LHS.empty())
            {
                prod.push_back(grammar->insertSymbol(stripSpace(LHS)));
            }
 
            // Add the production to raw productions
            grammar->getRawProductions().at(RHSSymbol).insert(prod);
 
            // Clear the production for the next iteration
            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 109 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 38 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);
        }
        else if (lineNum == 3)
        {
            // Trim leading and trailing whitespace
            size_t start = lineString.find_first_not_of(WHITESPACE);
            size_t end = lineString.find_last_not_of(WHITESPACE);
            if (start != std::string::npos && end != std::string::npos)
            {
                symbolString = lineString.substr(start, end - start + 1);
            }
        }
 
        // Append line to `lines` with whitespace trimmed
        size_t start = lineString.find_first_not_of(WHITESPACE);
        size_t end = lineString.find_last_not_of(WHITESPACE);
        if (start != std::string::npos && end != std::string::npos)
        {
            lines.append(lineString.substr(start, end - start + 1));
        }
 
        lineNum++;
    }
 
    // Extract "Productions:" part from `lines` manually
    size_t productionsPos = lines.find("Productions:");
    if (productionsPos != std::string::npos)
    {
        lines = lines.substr(productionsPos + std::string("Productions:").length());
    }
 
    // Parse `symbolString` to insert symbols
    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); // Remove the processed part
        grammar->insertSymbol(sString);
    }
    // Insert the remaining symbol
    grammar->insertSymbol(symbolString);
 
    // Set the start kind and add the epsilon terminal
    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 125 of file GrammarBuilder.cpp.

{
    // Remove leading spaces
    size_t start = s.find_first_not_of(" ");
    if (start == std::string::npos)
    {
        return ""; // Return an empty string if no non-space character is found
    }
 
    // Remove trailing spaces
    size_t end = s.find_last_not_of(" ");
    return s.substr(start, end - start + 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