souffle::ast::analysis::NormalisedClause Class Reference

#include <ClauseNormalisation.h>

Collaboration diagram for souffle::ast::analysis::NormalisedClause:

Data Structures
struct	NormalisedClauseElement

Public Member Functions
const std::set< std::string > &	getConstants () const
const std::vector< NormalisedClauseElement > &	getElements () const
const std::set< std::string > &	getVariables () const
bool	isFullyNormalised () const
	NormalisedClause ()=default
	NormalisedClause (const Clause *clause)

Private Member Functions
void	addClauseAtom (const std::string &qualifier, const std::string &scopeID, const Atom *atom)
	Parse an atom with a preset name qualifier into the element list. More...
void	addClauseBodyLiteral (const std::string &scopeID, const Literal *lit)
	Parse a body literal into the element list. More...
std::string	normaliseArgument (const Argument *arg)
	Return a normalised string repr of an argument. More...

Private Attributes
size_t	aggrScopeCount {0}
std::vector< NormalisedClauseElement >	clauseElements {}
std::set< std::string >	constants {}
bool	fullyNormalised {true}
std::set< std::string >	variables {}

Detailed Description

Definition at line 46 of file ClauseNormalisation.h.

Constructor & Destructor Documentation

NormalisedClause() [1/2]

souffle::ast::analysis::NormalisedClause::NormalisedClause ( )

default

NormalisedClause() [2/2]

souffle::ast::analysis::NormalisedClause::NormalisedClause

(

const Clause *

clause

)

Definition at line 51 of file ClauseNormalisation.cpp.

                             {.name = name, .params = headVars});
 
    // body
    for (const auto* lit : clause->getBodyLiterals()) {
        addClauseBodyLiteral("@min:scope:0", lit);
    }
}
 
void NormalisedClause::addClauseAtom(
        const std::string& qualifier, const std::string& scopeID, const Atom* atom) {
    QualifiedName name(atom->getQualifiedName());
    name.prepend(qualifier);
 

Member Function Documentation

addClauseAtom()

void souffle::ast::analysis::NormalisedClause::addClauseAtom ( const std::string &  qualifier, const std::string &  scopeID, const Atom *  atom  )

private

Parse an atom with a preset name qualifier into the element list.

Definition at line 66 of file ClauseNormalisation.cpp.

                         : atom->getArguments()) {
        vars.push_back(normaliseArgument(arg));
    }
    clauseElements.push_back({.name = name, .params = vars});
}
 
void NormalisedClause::addClauseBodyLiteral(const std::string& scopeID, const Literal* lit) {
    if (const auto* atom = dynamic_cast<const Atom*>(lit)) {
        addClauseAtom("@min:atom", scopeID, atom);
    } else if (const auto* neg = dynamic_cast<const Negation*>(lit)) {
        addClauseAtom("@min:neg", scopeID, neg->getAtom());

References normaliseArgument().

Here is the call graph for this function:

addClauseBodyLiteral()

void souffle::ast::analysis::NormalisedClause::addClauseBodyLiteral ( const std::string &  scopeID, const Literal *  lit  )

private

Parse a body literal into the element list.

Definition at line 79 of file ClauseNormalisation.cpp.

                          :operator");
        std::vector<std::string> vars;
        vars.push_back(scopeID);
        vars.push_back(normaliseArgument(bc->getLHS()));
        vars.push_back(normaliseArgument(bc->getRHS()));
        clauseElements.push_back({.name = name, .params = vars});
    } else {
        assert(lit != nullptr && "unexpected nullptr lit");
        fullyNormalised = false;
        std::stringstream qualifier;
        qualifier << "@min:unhandled:lit:" << scopeID;
        QualifiedName name(toString(*lit));
        name.prepend(qualifier.str());
        clauseElements.push_back({.name = name, .params = std::vector<std::string>()});
    }
}
 
std::string NormalisedClause::normaliseArgument(const Argument* arg) {
    if (auto* stringCst = dynamic_cast<const StringConstant*>(arg)) {
        std::stringstream name;
        name << "@min:cst:str" << *stringCst;
        constants.insert(name.str());

getConstants()

const std::set<std::string>& souffle::ast::analysis::NormalisedClause::getConstants ( ) const

inline

Definition at line 65 of file ClauseNormalisation.h.

       :
    bool fullyNormalised{true};

getElements()

const std::vector<NormalisedClauseElement>& souffle::ast::analysis::NormalisedClause::getElements ( ) const

inline

Definition at line 69 of file ClauseNormalisation.h.

                               {};
    std::set<std::string> constants{};
    std::vector<NormalisedClauseElement> clauseElements{};

getVariables()

const std::set<std::string>& souffle::ast::analysis::NormalisedClause::getVariables ( ) const

inline

Definition at line 61 of file ClauseNormalisation.h.

                                                                  {
        return clauseElements;

References clauseElements.

isFullyNormalised()

bool souffle::ast::analysis::NormalisedClause::isFullyNormalised ( ) const

inline

Definition at line 57 of file ClauseNormalisation.h.

                                                  {
        return constants;

References constants.

normaliseArgument()

std::string souffle::ast::analysis::NormalisedClause::normaliseArgument ( const Argument *  arg )

private

Return a normalised string repr of an argument.

Definition at line 103 of file ClauseNormalisation.cpp.

                                                                             {
        std::stringstream name;
        name << "@min:cst:num:" << *numericCst;
        constants.insert(name.str());
        return name.str();
    } else if (isA<NilConstant>(arg)) {
        constants.insert("@min:cst:nil");
        return "@min:cst:nil";
    } else if (auto* var = dynamic_cast<const ast::Variable*>(arg)) {
        auto name = var->getName();
        variables.insert(name);
        return name;
    } else if (dynamic_cast<const UnnamedVariable*>(arg)) {
        static size_t countUnnamed = 0;
        std::stringstream name;
        name << "@min:unnamed:" << countUnnamed++;
        variables.insert(name.str());
        return name.str();
    } else if (auto* aggr = dynamic_cast<const Aggregator*>(arg)) {
        // Set the scope to uniquely identify the aggregator
        std::stringstream scopeID;
        scopeID << "@min:scope:" << ++aggrScopeCount;
        variables.insert(scopeID.str());
 
        // Set the type signature of this aggregator
        std::stringstream aggrTypeSignature;
        aggrTypeSignature << "@min:aggrtype";
        std::vector<std::string> aggrTypeSignatureComponents;
 
        // - the operator is fixed and cannot be changed
        aggrTypeSignature << ":" << aggr->getBaseOperator();
 
        // - the scope can be remapped as a variable
        aggrTypeSignatureComponents.push_back(scopeID.str());
 
        // - the normalised target expression can be remapped as a variable
        if (aggr->getTargetExpression() != nullptr) {
            std::string normalisedExpr = normaliseArgument(aggr->getTargetExpression());
            aggrTypeSignatureComponents.push_back(normalisedExpr);
        }
 
        // Type signature is its own special atom
        clauseElements.push_back({.name = aggrTypeSignature.str(), .params = aggrTypeSignatureComponents});
 
        // Add each contained normalised clause literal, tying it with the new scope ID
        for (const auto* literal : aggr->getBodyLiterals()) {
            addClauseBodyLiteral(scopeID.str(), literal);
        }
 
        // Aggregator identified by the scope ID
        return scopeID.str();
    } else {
        fullyNormalised = false;
        return "@min:unhandled:arg";
    }
}
 
void ClauseNormalisationAnalysis::run(const TranslationUnit& translationUnit) {
    const auto& program = translationUnit.getProgram();
    for (const auto* clause : program.getClauses()) {
        assert(!contains(normalisations, clause) && "clause already processed");
        normalisations[clause] = NormalisedClause(clause);

Referenced by addClauseAtom().

Field Documentation

aggrScopeCount

size_t souffle::ast::analysis::NormalisedClause::aggrScopeCount {0}

private

Definition at line 75 of file ClauseNormalisation.h.

clauseElements

std::vector<NormalisedClauseElement> souffle::ast::analysis::NormalisedClause::clauseElements {}

private

Definition at line 78 of file ClauseNormalisation.h.

Referenced by getVariables().

constants

std::set<std::string> souffle::ast::analysis::NormalisedClause::constants {}

private

Definition at line 77 of file ClauseNormalisation.h.

Referenced by isFullyNormalised().

fullyNormalised

bool souffle::ast::analysis::NormalisedClause::fullyNormalised {true}

private

Definition at line 74 of file ClauseNormalisation.h.

variables

std::set<std::string> souffle::ast::analysis::NormalisedClause::variables {}

private

Definition at line 76 of file ClauseNormalisation.h.

---

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

• ast/analysis/ClauseNormalisation.h
• ast/analysis/ClauseNormalisation.cpp