souffle::ast::transform::ProvenanceTransformer Class Reference

Transformation pass to add provenance information. More...

#include <Provenance.h>

Inheritance diagram for souffle::ast::transform::ProvenanceTransformer:

Collaboration diagram for souffle::ast::transform::ProvenanceTransformer:

Public Member Functions
ProvenanceTransformer *	clone () const override
std::string	getName () const override
Public Member Functions inherited from souffle::ast::transform::Transformer
bool	apply (TranslationUnit &translationUnit)
virtual	~Transformer ()=default

Private Member Functions
bool	transform (TranslationUnit &translationUnit) override
bool	transformMaxHeight (TranslationUnit &translationUnit)

Detailed Description

Transformation pass to add provenance information.

Definition at line 34 of file Provenance.h.

Member Function Documentation

clone()

ProvenanceTransformer* souffle::ast::transform::ProvenanceTransformer::clone ( ) const

inlineoverridevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 46 of file Provenance.h.

getName()

std::string souffle::ast::transform::ProvenanceTransformer::getName ( ) const

inlineoverridevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 42 of file Provenance.h.

transform()

bool souffle::ast::transform::ProvenanceTransformer::transform ( TranslationUnit &  translationUnit )

overrideprivatevirtual

Implements souffle::ast::transform::Transformer.

Definition at line 355 of file Provenance.cpp.

transformMaxHeight()

bool souffle::ast::transform::ProvenanceTransformer::transformMaxHeight ( TranslationUnit &  translationUnit )

private

Definition at line 273 of file Provenance.cpp.

                       : program.getRelations()) {
        // generate info relations for each clause
        // do this before all other transformations so that we record
        // the original rule without any instrumentation
        for (auto clause : getClauses(program, *relation)) {
            if (!isFact(*clause)) {
                // add info relation
                program.addRelation(
                        makeInfoRelation(*clause, getClauseNum(&program, clause), translationUnit));
            }
        }
 
        relation->addAttribute(mk<Attribute>(std::string("@rule_number"), QualifiedName("number")));
        relation->addAttribute(mk<Attribute>(std::string("@level_number"), QualifiedName("number")));
 
        for (auto clause : getClauses(program, *relation)) {
            size_t clauseNum = getClauseNum(&program, clause);
 
            // mapper to add two provenance columns to atoms
            struct M : public NodeMapper {
                using NodeMapper::operator();
 
                Own<Node> operator()(Own<Node> node) const override {
                    // add provenance columns
                    if (auto atom = dynamic_cast<Atom*>(node.get())) {
                        atom->addArgument(mk<UnnamedVariable>());
                        atom->addArgument(mk<UnnamedVariable>());
                    } else if (auto neg = dynamic_cast<Negation*>(node.get())) {
                        auto atom = neg->getAtom();
                        atom->addArgument(mk<UnnamedVariable>());
                        atom->addArgument(mk<UnnamedVariable>());
                    }
 
                    // otherwise - apply mapper recursively
                    node->apply(*this);
                    return node;
                }
            };
 
            // add unnamed vars to each atom nested in arguments of head
            clause->getHead()->apply(M());
 
            // if fact, level number is 0
            if (isFact(*clause)) {
                clause->getHead()->addArgument(mk<NumericConstant>(0));
                clause->getHead()->addArgument(mk<NumericConstant>(0));
            } else {
                std::vector<Argument*> bodyLevels;
 
                for (size_t i = 0; i < clause->getBodyLiterals().size(); i++) {
                    auto lit = clause->getBodyLiterals()[i];
 
                    // add unnamed vars to each atom nested in arguments of lit
                    lit->apply(M());
 
                    // add two provenance columns to lit; first is rule num, second is level num
                    if (auto atom = dynamic_cast<Atom*>(lit)) {
                        atom->addArgument(mk<UnnamedVariable>());
                        atom->addArgument(mk<ast::Variable>("@level_num_" + std::to_string(i)));
                        bodyLevels.push_back(new ast::Variable("@level_num_" + std::to_string(i)));
                    }
                }
 
                // add two provenance columns to head lit
                clause->getHead()->addArgument(mk<NumericConstant>(clauseNum));
                clause->getHead()->addArgument(getNextLevelNumber(bodyLevels));
            }
        }
    }
    return true;
}
 
bool ProvenanceTransformer::transform(TranslationUnit& translationUnit) {
    return ProvenanceTransformer::transformMaxHeight(translationUnit);
}
 
}  // namespace souffle::ast::transform

---

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

• ast/transform/Provenance.h
• ast/transform/Provenance.cpp