SVF::CFLGraphBuilder Class Reference

#include <CFLGraphBuilder.h>

Inheritance diagram for SVF::CFLGraphBuilder:

Public Member Functions
template<class N , class E >
CFLGraph *	build (GenericGraph< N, E > *graph, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
CFLGraph *	build (std::string fileName, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from external file.
Map< std::string, Kind > &	getLabelToKindMap ()
	Returns a reference to the map that associates string labels with their corresponding Kind.
Map< Kind, std::string > &	getKindToLabelMap ()
	Returns a reference to the map that associates Kinds with their corresponding string labels.
Map< CFGrammar::Kind, Set< CFGrammar::Attribute > > &	getKindToAttrsMap ()
	Returns a reference to the map that associates Kinds with their corresponding attributes.

Protected Types
typedef CFGrammar::Kind	Kind
typedef CFGrammar::Symbol	Symbol

Protected Member Functions
void	addAttribute (CFGrammar::Kind kind, CFGrammar::Attribute attribute)
	Method to add an attribute to a specific kind.
void	buildlabelToKindMap (GrammarBase *grammar)
	build label and kind connect from the grammar
CFLNode *	addGNode (u32_t NodeID)
	add src and dst node from file
CFLGraph *	buildFromText (std::string fileName, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from a Text file.
CFLGraph *	buildFromDot (std::string filename, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from a Dot file.
CFLGraph *	buildFromJson (std::string filename, GrammarBase *grammar, BuildDirection direction=BuildDirection::plain)
	Method to build a CFL graph from a Json file.

Protected Attributes
Map< std::string, Kind >	labelToKindMap
	Maps to maintain mapping between labels and kinds.
Map< Kind, std::string >	kindToLabelMap
Map< CFGrammar::Kind, Set< CFGrammar::Attribute > >	kindToAttrsMap
	Map to maintain attributes associated with each kind.
Kind	current
CFLGraph *	cflGraph

Detailed Description

CFLGraphBuilder class is responsible for building CFL (Context-Free Language) graphs from text files, dot files, json file or from memory graph.

Definition at line 51 of file CFLGraphBuilder.h.

Member Typedef Documentation

Kind

typedef CFGrammar::Kind SVF::CFLGraphBuilder::Kind

protected

Define Kind(Not contain attribute) and Symbol(May contain attribute) as types derived from CFGrammar to numerically represent label

Definition at line 56 of file CFLGraphBuilder.h.

Symbol

typedef CFGrammar::Symbol SVF::CFLGraphBuilder::Symbol

protected

Definition at line 57 of file CFLGraphBuilder.h.

Member Function Documentation

addAttribute()

void SVF::CFLGraphBuilder::addAttribute ( CFGrammar::Kind  kind, CFGrammar::Attribute  attribute  )

protected

Method to add an attribute to a specific kind.

Add attribute to kindToAttribute Map.

Definition at line 36 of file CFLGraphBuilder.cpp.

{
    if (kindToAttrsMap.find(kind) == kindToAttrsMap.end())
    {
        Set<CFGrammar::Attribute> attrs{attribute};
        kindToAttrsMap.insert(make_pair(kind, attrs));
    }
    else
    {
        if (kindToAttrsMap[kind].find(attribute) == kindToAttrsMap[kind].end())
        {
            kindToAttrsMap[kind].insert(attribute);
        }
    }
}

addGNode()

CFLNode * SVF::CFLGraphBuilder::addGNode ( u32_t  NodeID )

protected

add src and dst node from file

Definition at line 81 of file CFLGraphBuilder.cpp.

{
    CFLNode* cflNode;
    if (cflGraph->hasGNode(NodeID)==false)
    {
        cflNode = new CFLNode(NodeID);
        cflGraph->addCFLNode(NodeID, cflNode);
    }
    else
    {
        cflNode = cflGraph->getGNode(NodeID);
    }
    return cflNode;
}

build() [1/2]

template<class N , class E >

CFLGraph * SVF::CFLGraphBuilder::build	(	GenericGraph< N, E > *	graph,
		GrammarBase *	grammar,
		BuildDirection	direction = BuildDirection::plain
	)

Method to build a CFL 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

Definition at line 100 of file CFLGraphBuilder.cpp.

{
    cflGraph = new CFLGraph(grammar->getStartKind());
    // buildlabelToKindMap(grammar);
    for(auto it = graph->begin(); it!= graph->end(); it++)
    {
        CFLNode* node = new CFLNode((*it).first);
        cflGraph->addCFLNode((*it).first, node);
    }
    for(auto it = graph->begin(); it!= graph->end(); it++)
    {
        N* node = (*it).second;
        for(E* edge : node->getOutEdges())
        {
            CFGrammar::Kind edgeLabel = edge->getEdgeKind();
            cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
            if (direction == BuildDirection::bidirection)
            {
                std::string label = grammar->kindToStr(edge);
                label.append("bar");
                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), grammar->strToKind(label));
            }
        }
    }
    return cflGraph;
}

build() [2/2]

CFLGraph * SVF::CFLGraphBuilder::build	(	std::string	fileName,
		GrammarBase *	grammar,
		BuildDirection	direction = BuildDirection::plain
	)

Method to build a CFL graph from external file.

Definition at line 127 of file CFLGraphBuilder.cpp.

{
    bool isDot = (fileName.rfind(".dot") == fileName.length() - std::string(".dot").length());
    if (isDot)
        return buildFromDot(fileName, grammar, direction);
 
    bool isJson = (fileName.rfind(".json") == fileName.length() - std::string(".json").length());
    if (isJson)
        return buildFromJson(fileName, grammar, direction);
 
    return buildFromText(fileName, grammar, direction);
}

buildFromDot()

CFLGraph * SVF::CFLGraphBuilder::buildFromDot ( std::string  filename, GrammarBase *  grammar, BuildDirection  direction = BuildDirection::plain  )

protected

Method to build a CFL graph from a Dot file.

Definition at line 195 of file CFLGraphBuilder.cpp.

{
    buildlabelToKindMap(grammar);
    cflGraph = new CFLGraph(grammar->getStartKind());
    std::string lineString;
    std::ifstream inputFile(fileName);
    std::cout << "Building CFL Graph from dot file: " << fileName << "..\n";
    std::cout << std::boolalpha;
 
    u32_t lineNum = 0;
    current = labelToKindMap.size();
 
    while (getline(inputFile, lineString))
    {
        lineNum += 1;
 
        // Find "Node" prefixes and "->"
        size_t srcStart = lineString.find("Node");
        if (srcStart == std::string::npos) continue;
 
        size_t srcEnd = lineString.find(" ", srcStart);
        if (srcEnd == std::string::npos) continue;
 
        size_t arrowPos = lineString.find("->", srcEnd);
        if (arrowPos == std::string::npos) continue;
 
        size_t dstStart = lineString.find("Node", arrowPos);
        if (dstStart == std::string::npos) continue;
 
        size_t dstEnd = lineString.find(" ", dstStart);
        if (dstEnd == std::string::npos) continue;
 
        size_t labelStart = lineString.find("label=", dstEnd);
        if (labelStart == std::string::npos) continue;
 
        labelStart += 6; // Move past "label=" to the start of the label
        size_t labelEnd = lineString.find_first_of("]", labelStart);
        if (labelEnd == std::string::npos) continue;
 
        // Extract the source ID, destination ID, and label
        std::string srcIDStr = lineString.substr(srcStart + 4, srcEnd - (srcStart + 4));
        std::string dstIDStr = lineString.substr(dstStart + 4, dstEnd - (dstStart + 4));
        std::string label = lineString.substr(labelStart, labelEnd - labelStart);
 
        // Convert source and destination IDs from hexadecimal
        u32_t srcID = std::stoul(srcIDStr, nullptr, 16);
        u32_t dstID = std::stoul(dstIDStr, nullptr, 16);
 
        CFLNode *src = addGNode(srcID);
        CFLNode *dst = addGNode(dstID);
 
        if (labelToKindMap.find(label) != labelToKindMap.end())
        {
            cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
        }
        else
        {
            if (Options::FlexSymMap() == true)
            {
                labelToKindMap.insert({label, current++});
                cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
            }
            else
            {
                std::string msg = "In line " + std::to_string(lineNum) +
                                  " sym cannot be found in grammar. Please correct the input dot or set --flexsymmap.";
                SVFUtil::errMsg(msg);
                std::cout << msg;
                abort();
            }
        }
    }
 
    inputFile.close();
    return cflGraph;
}

buildFromJson()

CFLGraph * SVF::CFLGraphBuilder::buildFromJson ( std::string  filename, GrammarBase *  grammar, BuildDirection  direction = BuildDirection::plain  )

protected

Method to build a CFL graph from a Json file.

Definition at line 273 of file CFLGraphBuilder.cpp.

{
    cflGraph = new CFLGraph(grammar->getStartKind());
    return cflGraph;
}

buildFromText()

CFLGraph * SVF::CFLGraphBuilder::buildFromText ( std::string  fileName, GrammarBase *  grammar, BuildDirection  direction = BuildDirection::plain  )

protected

Method to build a CFL graph from a Text file.

Definition at line 141 of file CFLGraphBuilder.cpp.

{
    buildlabelToKindMap(grammar);
    cflGraph = new CFLGraph(grammar->getStartKind());
 
    std::cout << "Building CFL Graph from text file: " << fileName << "..\n";
    std::string lineString;
    std::ifstream inputFile(fileName);
 
    if (!inputFile.is_open())
    {
        SVFUtil::errs()  << "Error opening " << fileName << std::endl;
        abort();
    }
 
    std::string line;
    current = labelToKindMap.size();
    u32_t lineNum = 0 ;
 
    while (getline(inputFile, line))
    {
        std::vector<std::string> vec = SVFUtil::split(line, '\t');
        if (vec.empty())
            continue;
        lineNum += 1;
        NodeID srcID = std::stoi(vec[0]);
        NodeID dstID = std::stoi(vec[1]);
        CFLNode *src = addGNode(srcID);
        CFLNode *dst = addGNode(dstID);
        std::string label = vec[2];
        if (labelToKindMap.find(label) != labelToKindMap.end())
            cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
        else
        {
            if(Options::FlexSymMap() == true)
            {
                labelToKindMap.insert({label, current++});
                cflGraph->addCFLEdge(src, dst, labelToKindMap[label]);
            }
            else
            {
                std::string msg = "In line " + std::to_string(lineNum) +
                                  " sym can not find in grammar, please correct the input dot or set --flexsymmap.";
                SVFUtil::errMsg(msg);
                std::cout << msg;
                abort();
            }
        }
    }
 
    inputFile.close();
    return cflGraph;
}

buildlabelToKindMap()

void SVF::CFLGraphBuilder::buildlabelToKindMap ( GrammarBase *  grammar )

protected

build label and kind connect from the grammar

Definition at line 53 of file CFLGraphBuilder.cpp.

{
    for(auto pairV : grammar->getTerminals())
    {
        if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
        {
            labelToKindMap.insert(pairV);
        }
        if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
        {
            kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
        }
    }
 
    for(auto pairV : grammar->getNonterminals())
    {
        if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
        {
            labelToKindMap.insert(pairV);
        }
        if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
        {
            kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
        }
    }
}

getKindToAttrsMap()

Map< CFGrammar::Kind, Set< CFGrammar::Attribute > > & SVF::CFLGraphBuilder::getKindToAttrsMap ( )

inline

Returns a reference to the map that associates Kinds with their corresponding attributes.

Definition at line 112 of file CFLGraphBuilder.h.

    {
        return this->kindToAttrsMap;
    }

getKindToLabelMap()

Map< Kind, std::string > & SVF::CFLGraphBuilder::getKindToLabelMap ( )

inline

Returns a reference to the map that associates Kinds with their corresponding string labels.

Definition at line 106 of file CFLGraphBuilder.h.

    {
        return this->kindToLabelMap;
    }

getLabelToKindMap()

Map< std::string, Kind > & SVF::CFLGraphBuilder::getLabelToKindMap ( )

inline

Returns a reference to the map that associates string labels with their corresponding Kind.

Getter methods for accessing class variables

Definition at line 100 of file CFLGraphBuilder.h.

    {
        return this->labelToKindMap;
    }

Member Data Documentation

cflGraph

CFLGraph* SVF::CFLGraphBuilder::cflGraph

protected

Definition at line 67 of file CFLGraphBuilder.h.

current

Kind SVF::CFLGraphBuilder::current

protected

Definition at line 66 of file CFLGraphBuilder.h.

kindToAttrsMap

Map<CFGrammar::Kind, Set<CFGrammar::Attribute> > SVF::CFLGraphBuilder::kindToAttrsMap

protected

Map to maintain attributes associated with each kind.

Definition at line 64 of file CFLGraphBuilder.h.

kindToLabelMap

Map<Kind, std::string> SVF::CFLGraphBuilder::kindToLabelMap

protected

Definition at line 61 of file CFLGraphBuilder.h.

labelToKindMap

Map<std::string, Kind> SVF::CFLGraphBuilder::labelToKindMap

protected

Maps to maintain mapping between labels and kinds.

Definition at line 60 of file CFLGraphBuilder.h.

---

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

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