Namespaces
	analysis

	detail

	test

	transform

Data Structures
class	Aggregator
	Defines the aggregator class. More...

class	AlgebraicDataType
	Combination of types using sums and products. More...

class	AllBoundSips
	Goal: Prioritise atoms with all arguments bound. More...

class	Argument
	An abstract class for arguments. More...

struct	ast_visitor_tag
	A tag type required for the is_ast_visitor type trait to identify AstVisitors. More...

class	Atom
	An atom class. More...

class	Attribute
	Attribute class. More...

class	BinaryConstraint
	Binary constraint class. More...

class	BindingStore

class	BooleanConstraint
	Boolean constraint class. More...

class	BranchDeclaration
	Wrapper for the single branch declaration (product type) inside ADT declaration. More...

class	BranchInit
	Initialization of ADT instance. More...

class	Clause
	Intermediate representation of a horn clause. More...

class	Component
	Component class. More...

class	ComponentInit
	Component initialization class. More...

class	ComponentType
	Component type of a component. More...

class	Constant
	Abstract constant class. More...

class	Constraint
	Abstract class for AST constraints. More...

class	Counter
	counter functor (incrementing a value after each invocation) More...

class	DeltaInputSips
	Goal: prioritise (1) all-bound, then (2) deltas, then (3) input, and then (4) left-most. More...

class	DeltaSips
	Goal: prioritise (1) all-bound, then (2) deltas, and then (3) left-most. More...

class	Directive
	a directive has a type (e.g. input/output/printsize/limitsize), qualified relation name, and a key value map for storing parameters of the directive. More...

class	ExecutionOrder
	An execution order for atoms within a clause; one or more execution orders form a plan. More...

class	ExecutionPlan

class	Functor
	Abstract functor class. More...

class	FunctorDeclaration
	User-defined functor declaration. More...

class	InputSips
	Goal: prioritise (1) all-bound, then (2) input, and then (3) left-most. More...

class	IntrinsicFunctor
	Intrinsic Functor class for functors are in-built. More...

class	LeastFreeSips
	Goal: choose the atom with the least number of unbound arguments. More...

class	LeastFreeVarsSips
	Goal: choose the atom with the least amount of unbound variables. More...

class	Literal
	Defines an abstract class for literals in a horn clause. More...

class	MaxBoundSips
	Goal: prioritise (1) all-bound, then (2) max number of bound vars, then (3) left-most. More...

class	MaxRatioSips
	Goal: prioritise max ratio of bound args. More...

class	NaiveSips
	Goal: Prioritise (1) all bound, then (2) atoms with at least one bound argument, then (3) left-most. More...

class	NameComparison
	Comparator for relations. More...

class	Negation
	Negation of an atom negated atom. More...

class	NilConstant
	Defines the nil constant. More...

class	Node
	Abstract class for syntactic elements in an input program. More...

class	NodeMapper
	An abstract class for manipulating AST Nodes by substitution. More...

class	NumericConstant
	Numeric Constant. More...

class	Pragma
	Representation of a global option. More...

class	ProfileUseSips
	Goal: reorder based on the given profiling information Metric: cost(atom_R) = log(\|atom_R\|) * #free/#args. More...

class	Program
	The program class consists of relations, clauses and types. More...

class	ProvenanceNegation
	Subclass of Literal that represents a negated atom, * e.g., !parent(x,y). More...

class	QualifiedName
	Qualified Name class defines fully/partially qualified names to identify objects in components. More...

class	RecordInit
	Defines a record initialization class. More...

class	RecordType
	Record type class for record type declarations. More...

class	Relation
	Defines a relation with a name, attributes, qualifiers, and internal representation. More...

class	SipsMetric
	Class for SIPS cost-metric functions Each subclass represents a different heuristic used for evaluating the cost of choosing an atom next in the schedule. More...

class	StrictSips
	Goal: Always choose the left-most atom. More...

class	StringConstant
	String constant class. More...

class	SubroutineArgument
	Defines the argument class for subrountines. More...

class	SubsetType
	Defines subset type class. More...

class	Term
	Defines an abstract term class used for functors and other constructors. More...

class	TranslationUnit
	Translation unit class for the translation pipeline. More...

class	Type
	An abstract base class for types. More...

class	TypeCast
	Defines a type cast class for expressions. More...

class	UnionType
	The union type class. More...

class	UnnamedVariable
	Unnamed variable class. More...

class	UserDefinedFunctor
	User-Defined functor class. More...

class	Variable
	Named variable class. More...

struct	Visitor
	The generic base type of all AstVisitors realizing the dispatching of visitor calls. More...

Typedefs
using	RelationSet = std::set< const Relation *, NameComparison >
	Relation set. More...

Enumerations
enum	DirectiveType { DirectiveType::input, DirectiveType::output, DirectiveType::printsize, DirectiveType::limitsize }

Functions
Clause *	cloneHead (const Clause *clause)
	Returns a clause which contains head of the given clause. More...

const Relation *	getAtomRelation (const Atom atom, const Program program)
	Returns the relation referenced by the given atom. More...

template<typename T , typename C >
std::vector< T * >	getBodyLiterals (const C &clause)
	Returns literals of a particular type in the body of a clause. More...

std::set< const Relation * >	getBodyRelations (const Clause clause, const Program program)
	Returns the relations referenced in the body of the given clause. More...

size_t	getClauseNum (const Program program, const Clause clause)
	Returns the index of a clause within its relation, ignoring facts. More...

std::vector< Clause * >	getClauses (const Program &program, const QualifiedName &relationName)
	Returns a vector of clauses in the program describing the relation with the given name. More...

std::vector< Clause * >	getClauses (const Program &program, const Relation &rel)
	Returns a vector of clauses in the program describing the given relation. More...

std::vector< Directive * >	getDirectives (const Program &program, const QualifiedName &relationName)

const Relation *	getHeadRelation (const Clause clause, const Program program)
	Returns the relation referenced by the head of the given clause. More...

std::vector< const RecordInit * >	getRecords (const Node &root)
	Obtains a list of all records referenced within the AST rooted by the given root node. More...

Relation *	getRelation (const Program &program, const QualifiedName &name)
	Returns the relation with the given name in the program. More...

std::vector< const Variable * >	getVariables (const Node &root)
	Obtains a list of all variables referenced within the AST rooted by the given root node. More...

bool	hasClauseWithAggregatedRelation (const Relation relation, const Relation aggRelation, const Program program, const Literal &foundLiteral)
	Returns whether the given relation has any clauses which contain an aggregation over of a specific relation. More...

bool	hasClauseWithNegatedRelation (const Relation relation, const Relation negRelation, const Program program, const Literal &foundLiteral)
	Returns whether the given relation has any clauses which contain a negation of a specific relation. More...

bool	isDeltaRelation (const QualifiedName &name)
	Returns whether the given atom is a delta relation. More...

bool	isFact (const Clause &clause)
	Returns whether the given clause is a fact. More...

bool	isProposition (const Atom *atom)
	Returns whether the given atom is a propositon. More...

bool	isRecursiveClause (const Clause &clause)
	Returns whether the given clause is recursive. More...

bool	isRule (const Clause &clause)
	Returns whether the given clause is a rule. More...

template<typename Lambda >
detail::LambdaNodeMapper< Lambda >	makeLambdaAstMapper (const Lambda &lambda)
	Creates a node mapper based on a corresponding lambda expression. More...

void	negateConstraintInPlace (Constraint &constraint)
	Negate an ast constraint. More...

QualifiedName	operator+ (const std::string &name, const QualifiedName &id)

std::ostream &	operator<< (std::ostream &os, DirectiveType e)

std::string	pprint (const Node &node)

void	removeRelation (TranslationUnit &tu, const QualifiedName &name)
	Remove relation and all its clauses from the program. More...

void	removeRelationClauses (TranslationUnit &tu, const QualifiedName &name)
	Removes the set of clauses with the given relation name. More...

void	removeRelationIOs (TranslationUnit &tu, const QualifiedName &name)
	Removes the set of IOs with the given relation name. More...

bool	renameAtoms (Node &node, const std::map< QualifiedName, QualifiedName > &oldToNew)
	Rename all atoms hat appear in a node to a given name. More...

Clause *	reorderAtoms (const Clause *clause, const std::vector< unsigned int > &newOrder)
	Reorders the atoms of a clause to be in the given order. More...

IntrinsicFunctors	validOverloads (const analysis::TypeAnalysis &, const IntrinsicFunctor &)
	Pick valid overloads for a functor, sorted by some measure of "preference". More...

template<typename Lambda , typename R = typename lambda_traits<Lambda>::result_type, typename N = typename lambda_traits<Lambda>::arg0_type>
std::enable_if<!detail::is_ast_visitor< Lambda >::value, void >::type	visitDepthFirst (const Node &root, const Lambda &fun)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given function to each encountered node. More...

template<typename R , typename N >
void	visitDepthFirst (const Node &root, const std::function< R(const N &)> &fun)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given function to each encountered node. More...

template<typename R , typename... Ps, typename... Args>
void	visitDepthFirst (const Node &root, Visitor< R, Ps... > &visitor, Args &... args)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given visitor to each encountered node. More...

template<typename T , typename Lambda >
void	visitDepthFirst (const std::vector< T * > &list, const Lambda &fun)
	A utility function visiting all nodes within a given list of AST root nodes recursively in a depth-first pre-order fashion applying the given function to each encountered node. More...

template<typename T , typename Lambda >
void	visitDepthFirst (const VecOwn< T > &list, const Lambda &fun)
	A utility function visiting all nodes within a given list of AST root nodes recursively in a depth-first pre-order fashion applying the given function to each encountered node. More...

template<typename Lambda , typename R = typename lambda_traits<Lambda>::result_type, typename N = typename lambda_traits<Lambda>::arg0_type>
std::enable_if<!detail::is_ast_visitor< Lambda >::value, void >::type	visitDepthFirstPostOrder (const Node &root, const Lambda &fun)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first post-order fashion applying the given function to each encountered node. More...

template<typename R , typename N >
void	visitDepthFirstPostOrder (const Node &root, const std::function< R(const N &)> &fun)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first post-order fashion applying the given function to each encountered node. More...

template<typename R , typename... Ps, typename... Args>
void	visitDepthFirstPostOrder (const Node &root, Visitor< R, Ps... > &visitor, Args &... args)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first post-order fashion applying the given visitor to each encountered node. More...

template<typename R , typename... Ps, typename... Args>
void	visitDepthFirstPreOrder (const Node &root, Visitor< R, Ps... > &visitor, Args &... args)
	A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given visitor to each encountered node. More...

Typedef Documentation

◆ RelationSet

using souffle::ast::RelationSet = typedef std::set<const Relation*, NameComparison>

Relation set.

Definition at line 180 of file Relation.h.

Enumeration Type Documentation

◆ DirectiveType

enum souffle::ast::DirectiveType

strong

Enumerator
input
output
printsize
limitsize

Definition at line 37 of file Directive.h.

37 : return os << "output";

Function Documentation

◆ cloneHead()

Clause * souffle::ast::cloneHead ( const Clause * clause )

Returns a clause which contains head of the given clause.

Parameters

clause the clause which head to be cloned

Returns: pointer to clause which has head cloned from given clause

Definition at line 254 of file Utils.cpp.

                                                                                     {
     // Find all atom positions
     std::vector<unsigned int> atomPositions;
     std::vector<Literal*> bodyLiterals = clause->getBodyLiterals();
     for (unsigned int i = 0; i < bodyLiterals.size(); i++) {

◆ getAtomRelation()

const Relation * souffle::ast::getAtomRelation	(	const Atom *	atom,
		const Program *	program
	)

Returns the relation referenced by the given atom.

Parameters

atom	the atom
program	the program containing the relations

Returns: relation referenced by the atom

Definition at line 129 of file Utils.cpp.

131 {

Referenced by getBodyRelations(), getHeadRelation(), and souffle::ast::transform::ExecutionPlanChecker::transform().

◆ getBodyLiterals()

template<typename T , typename C >

std::vector<T*> souffle::ast::getBodyLiterals ( const C & clause )

Returns literals of a particular type in the body of a clause.

Parameters

the clause

Returns: vector of body literals of the specified type

Definition at line 87 of file Utils.h.

◆ getBodyRelations()

std::set< const Relation * > souffle::ast::getBodyRelations	(	const Clause *	clause,
		const Program *	program
	)

Returns the relations referenced in the body of the given clause.

Parameters

clause	the clause
program	the program containing the relations

Returns: relation referenced in the clause body

Definition at line 137 of file Utils.cpp.

                          : clause->getHead()->getArguments()) {
         visitDepthFirst(
                 *arg, [&](const Atom& atom) { bodyRelations.insert(getAtomRelation(&atom, program)); });
     }
     return bodyRelations;
 }
  
 size_t getClauseNum(const Program* program, const Clause* clause) {
     // TODO (azreika): This number might change between the provenance transformer and the AST->RAM
     // translation. Might need a better way to assign IDs to clauses... (see PR #1288).
     const Relation* rel = getRelation(*program, clause->getHead()->getQualifiedName());
     assert(rel != nullptr && "clause relation does not exist");

References getAtomRelation(), and visitDepthFirst().

Here is the call graph for this function:

◆ getClauseNum()

size_t souffle::ast::getClauseNum	(	const Program *	program,
		const Clause *	clause
	)

Returns the index of a clause within its relation, ignoring facts.

Used in provenance as a unique ID for clauses within their relations.

Parameters

program	the program
clause	the clause to get the index of

Returns: the index of the clause ignoring facts; 0 for facts

Definition at line 150 of file Utils.cpp.

                          : getClauses(*program, *rel)) {
         bool isFact = cur->getBodyLiterals().empty();
         if (cur == clause) {
             return isFact ? 0 : clauseNum;
         }
  
         if (!isFact) {
             clauseNum++;
         }
     }
  
     fatal("clause does not exist");
 }
  
 bool hasClauseWithNegatedRelation(const Relation* relation, const Relation* negRelation,
         const Program* program, const Literal*& foundLiteral) {
     for (const Clause* cl : getClauses(*program, *relation)) {
         for (const auto* neg : getBodyLiterals<Negation>(*cl)) {
             if (negRelation == getAtomRelation(neg->getAtom(), program)) {

References isFact().

Here is the call graph for this function:

◆ getClauses() [1/2]

std::vector< Clause * > souffle::ast::getClauses	(	const Program &	program,
		const QualifiedName &	relationName
	)

Returns a vector of clauses in the program describing the relation with the given name.

Parameters

program	the program
name	the name of the relation to search for

Returns: vector of clauses describing the relation with the given name

Definition at line 77 of file Utils.cpp.

                                                                            {
     return getClauses(program, rel.getQualifiedName());
 }
  
 std::vector<Directive*> getDirectives(const Program& program, const QualifiedName& relationName) {

Referenced by souffle::ast::transform::getInlinedLiteral(), souffle::ast::transform::MagicSetTransformer::getTriviallyIgnoredRelations(), souffle::ast::transform::MinimiseProgramTransformer::reduceLocallyEquivalentClauses(), souffle::ast::transform::MinimiseProgramTransformer::reduceSingletonRelations(), souffle::ast::transform::RemoveEmptyRelationsTransformer::removeEmptyRelations(), souffle::ast::transform::RemoveRelationCopiesTransformer::removeRelationCopies(), and souffle::ast::transform::ExecutionPlanChecker::transform().

◆ getClauses() [2/2]

std::vector< Clause * > souffle::ast::getClauses	(	const Program &	program,
		const Relation &	rel
	)

Returns a vector of clauses in the program describing the given relation.

Parameters

program	the program
rel	the relation to search for

Returns: vector of clauses describing the given relation

Definition at line 87 of file Utils.cpp.

                         : program.getDirectives()) {
         if (dir->getQualifiedName() == relationName) {
             directives.push_back(dir);

References directives.

◆ getDirectives()

std::vector<Directive*> souffle::ast::getDirectives	(	const Program &	program,
		const QualifiedName &	relationName
	)

Definition at line 91 of file Utils.cpp.

                                                                          {
     return getIf(program.getRelations(), [&](const Relation* r) { return r->getQualifiedName() == name; });
 }
  
 void removeRelation(TranslationUnit& tu, const QualifiedName& name) {

◆ getHeadRelation()

const Relation * souffle::ast::getHeadRelation	(	const Clause *	clause,
		const Program *	program
	)

Returns the relation referenced by the head of the given clause.

Parameters

clause	the clause
program	the program containing the relations

Returns: relation referenced by the clause head

Definition at line 133 of file Utils.cpp.

                          : clause->getBodyLiterals()) {
         visitDepthFirst(
                 *lit, [&](const Atom& atom) { bodyRelations.insert(getAtomRelation(&atom, program)); });

References getAtomRelation(), and visitDepthFirst().

Here is the call graph for this function:

◆ getRecords()

std::vector< const RecordInit * > souffle::ast::getRecords ( const Node & root )

Obtains a list of all records referenced within the AST rooted by the given root node.

Parameters

root	the root of the AST to be searched

Returns: a list of all records referenced within

Definition at line 70 of file Utils.cpp.

                                                                                          {
     std::vector<Clause*> clauses;
     for (Clause* clause : program.getClauses()) {
         if (clause->getHead()->getQualifiedName() == relationName) {
             clauses.push_back(clause);

References clauses, and souffle::ast::Program::getClauses().

Here is the call graph for this function:

◆ getRelation()

Relation * souffle::ast::getRelation	(	const Program &	program,
		const QualifiedName &	name
	)

Returns the relation with the given name in the program.

Parameters

program	the program
name	the name of the relation to search for

Returns: the relation if it exists; nullptr otherwise

Definition at line 101 of file Utils.cpp.

                                                {
         removeRelationClauses(tu, name);
         removeRelationIOs(tu, name);

References removeRelationClauses(), and removeRelationIOs().

Referenced by souffle::ParserDriver::addRelation(), souffle::ast::transform::getInlinedLiteral(), removeRelationIOs(), and souffle::ast::transform::IOAttributesTransformer::transform().

Here is the call graph for this function:

◆ getVariables()

std::vector< const Variable * > souffle::ast::getVariables ( const Node & root )

Obtains a list of all variables referenced within the AST rooted by the given root node.

Parameters

root	the root of the AST to be searched

Returns: a list of all variables referenced within

Definition at line 63 of file Utils.cpp.

                                                           {
     // simply collect the list of all records by visiting all records
     std::vector<const RecordInit*> recs;
     visitDepthFirst(root, [&](const RecordInit& rec) { recs.push_back(&rec); });
     return recs;

References visitDepthFirst().

Here is the call graph for this function:

◆ hasClauseWithAggregatedRelation()

bool souffle::ast::hasClauseWithAggregatedRelation	(	const Relation *	relation,
		const Relation *	aggRelation,
		const Program *	program,
		const Literal *&	foundLiteral
	)

Returns whether the given relation has any clauses which contain an aggregation over of a specific relation.

Parameters

relation	the relation to search the clauses of
aggRelation	the relation to search for in aggregations in clause bodies
program	the program containing the relations
foundLiteral	set to the literal found in an aggregation

Definition at line 184 of file Utils.cpp.

                                                                     {
                     foundLiteral = &atom;
                     hasAgg = true;
                 }
             });
         });
         if (hasAgg) {
             return true;
         }
     }
     return false;
 }
  
 bool isRecursiveClause(const Clause& clause) {
     QualifiedName relationName = clause.getHead()->getQualifiedName();
     bool recursive = false;
     visitDepthFirst(clause.getBodyLiterals(), [&](const Atom& atom) {
         if (atom.getQualifiedName() == relationName) {

◆ hasClauseWithNegatedRelation()

bool souffle::ast::hasClauseWithNegatedRelation	(	const Relation *	relation,
		const Relation *	negRelation,
		const Program *	program,
		const Literal *&	foundLiteral
	)

Returns whether the given relation has any clauses which contain a negation of a specific relation.

Parameters

relation	the relation to search the clauses of
negRelation	the relation to search for negations of in clause bodies
program	the program containing the relations
foundLiteral	set to the negation literal that was found

Definition at line 171 of file Utils.cpp.

                                                               {
     for (const Clause* cl : getClauses(*program, *relation)) {
         bool hasAgg = false;
         visitDepthFirst(*cl, [&](const Aggregator& cur) {

◆ isDeltaRelation()

bool souffle::ast::isDeltaRelation ( const QualifiedName & name )

Returns whether the given atom is a delta relation.

Returns: true iff the atom is a delta relation

Definition at line 246 of file Utils.cpp.

                                         {
     auto* clone = new Clause();
     clone->setSrcLoc(clause->getSrcLoc());
     clone->setHead(souffle::clone(clause->getHead()));
     if (clause->getExecutionPlan() != nullptr) {

◆ isFact()

bool souffle::ast::isFact ( const Clause & clause )

Returns whether the given clause is a fact.

Returns: true iff the clause is a fact

Definition at line 214 of file Utils.cpp.

                                            {
         return false;
     }
  
     // and there are no aggregates
     bool hasAggregatesOrMultiResultFunctor = false;
     visitDepthFirst(*clause.getHead(), [&](const Argument& arg) {
         if (isA<Aggregator>(arg)) {
             hasAggregatesOrMultiResultFunctor = true;
         }
  
         auto* func = as<IntrinsicFunctor>(arg);
         hasAggregatesOrMultiResultFunctor |=
                 (func != nullptr) && analysis::FunctorAnalysis::isMultiResult(*func);
     });
     return !hasAggregatesOrMultiResultFunctor;
 }
  
 bool isRule(const Clause& clause) {
     return (clause.getHead() != nullptr) && !isFact(clause);
 }
  
 bool isProposition(const Atom* atom) {

Referenced by getClauseNum(), and souffle::ast::transform::RemoveRelationCopiesTransformer::removeRelationCopies().

◆ isProposition()

bool souffle::ast::isProposition ( const Atom * atom )

Returns whether the given atom is a propositon.

Returns: true iff the atom has no arguments

Definition at line 242 of file Utils.cpp.

                             {
         return false;
     }

◆ isRecursiveClause()

bool souffle::ast::isRecursiveClause ( const Clause & clause )

Returns whether the given clause is recursive.

Parameters

clause the clause to check

Returns: true iff the clause is recursive

Definition at line 203 of file Utils.cpp.

                                   {
     // there must be a head
     if (clause.getHead() == nullptr) {
         return false;
     }

◆ isRule()

bool souffle::ast::isRule ( const Clause & clause )

Returns whether the given clause is a rule.

Returns: true iff the clause is a rule

Definition at line 238 of file Utils.cpp.

240 {

◆ makeLambdaAstMapper()

template<typename Lambda >

detail::LambdaNodeMapper<Lambda> souffle::ast::makeLambdaAstMapper ( const Lambda & lambda )

Creates a node mapper based on a corresponding lambda expression.

Definition at line 53 of file LambdaNodeMapper.h.

◆ negateConstraintInPlace()

void souffle::ast::negateConstraintInPlace ( Constraint & constraint )

Negate an ast constraint.

Parameters

constraint constraint that will be negated

Definition at line 297 of file Utils.cpp.

                                                                                    {
     struct rename_atoms : public NodeMapper {
         mutable bool changed{false};
         const std::map<QualifiedName, QualifiedName>& oldToNew;
         rename_atoms(const std::map<QualifiedName, QualifiedName>& oldToNew) : oldToNew(oldToNew) {}

Referenced by souffle::RuleBody::toClauseBodies().

◆ operator+()

QualifiedName souffle::ast::operator+	(	const std::string &	name,
		const QualifiedName &	id
	)

inline

Definition at line 105 of file QualifiedName.h.

◆ operator<<()

std::ostream& souffle::ast::operator<<	(	std::ostream &	os,
		DirectiveType	e
	)

inline

Definition at line 40 of file Directive.h.

50 : public Node {

◆ pprint()

std::string souffle::ast::pprint ( const Node & node )

Definition at line 59 of file Utils.cpp.

60 { vars.push_back(&var); });

61 return vars;

◆ removeRelation()

void souffle::ast::removeRelation	(	TranslationUnit &	tu,
		const QualifiedName &	name
	)

Remove relation and all its clauses from the program.

Parameters

tu	the translation unit
name	the name of the relation to delete

Definition at line 105 of file Utils.cpp.

                                                                            {
     Program& program = tu.getProgram();
     const auto& relDetail = *tu.getAnalysis<analysis::RelationDetailCacheAnalysis>();
     for (const auto* clause : relDetail.getClauses(name)) {
         program.removeClause(clause);

Referenced by souffle::ast::transform::RemoveRedundantRelationsTransformer::transform().

◆ removeRelationClauses()

void souffle::ast::removeRelationClauses	(	TranslationUnit &	tu,
		const QualifiedName &	name
	)

Removes the set of clauses with the given relation name.

Parameters

tu	the translation unit
name	the name of the relation to search for

Definition at line 114 of file Utils.cpp.

                                                                        {
     Program& program = tu.getProgram();
     for (const auto* directive : getDirectives(program, name)) {
         program.removeDirective(directive);
     }

Referenced by getRelation().

◆ removeRelationIOs()

void souffle::ast::removeRelationIOs	(	TranslationUnit &	tu,
		const QualifiedName &	name
	)

Removes the set of IOs with the given relation name.

Parameters

tu	the translation unit
name	the name of the relation to search for

Definition at line 122 of file Utils.cpp.

                                                                           {
     return getRelation(*program, atom->getQualifiedName());
 }
  
 const Relation* getHeadRelation(const Clause* clause, const Program* program) {

References souffle::ast::Atom::getQualifiedName(), and getRelation().

Referenced by getRelation().

Here is the call graph for this function:

◆ renameAtoms()

bool souffle::ast::renameAtoms	(	Node &	node,
		const std::map< QualifiedName, QualifiedName > &	oldToNew
	)

Rename all atoms hat appear in a node to a given name.

Parameters

node	node to alter the children of
oldToNew	map from old atom names to new atom names

Returns: true if the node was changed

Definition at line 307 of file Utils.cpp.

                                                               {
                 if (contains(oldToNew, atom->getQualifiedName())) {
                     auto renamedAtom = souffle::clone(atom);
                     renamedAtom->setQualifiedName(oldToNew.at(atom->getQualifiedName()));
                     changed = true;
                     return renamedAtom;
                 }
             }
             return node;
         }
     };
     rename_atoms update(oldToNew);
     node.apply(update);
     return update.changed;
 }
  
 }  // namespace souffle::ast

References souffle::clone(), and souffle::contains().

Here is the call graph for this function:

◆ reorderAtoms()

Clause * souffle::ast::reorderAtoms	(	const Clause *	clause,
		const std::vector< unsigned int > &	newOrder
	)

Reorders the atoms of a clause to be in the given order.

Remaining body literals remain in the same order.

E.g. if atoms are [a,b,c] and given order is [1,2,0], then the final atom order will be [b,c,a].

Parameters

clause	clause to reorder atoms in
newOrder	new order of atoms; atoms[i] = atoms[newOrder[i]]

Definition at line 264 of file Utils.cpp.

                                                             {
         nopOrder.push_back(i);
     }
     assert(std::is_permutation(nopOrder.begin(), nopOrder.end(), newOrder.begin()));
  
     // Create a new clause with the given atom order, leaving the rest unchanged
     Clause* newClause = cloneHead(clause);
     unsigned int currentAtom = 0;
     for (unsigned int currentLiteral = 0; currentLiteral < bodyLiterals.size(); currentLiteral++) {
         Literal* literalToAdd = bodyLiterals[currentLiteral];
         if (isA<Atom>(literalToAdd)) {
             // Atoms should be reordered
             literalToAdd = bodyLiterals[atomPositions[newOrder[currentAtom++]]];
         }
         newClause->addToBody(souffle::clone(literalToAdd));
     }
  
     return newClause;
 }
  
 void negateConstraintInPlace(Constraint& constraint) {
     if (auto* bcstr = dynamic_cast<BooleanConstraint*>(&constraint)) {
         bcstr->set(!bcstr->isTrue());
     } else if (auto* cstr = dynamic_cast<BinaryConstraint*>(&constraint)) {
         cstr->setBaseOperator(souffle::negatedConstraintOp(cstr->getBaseOperator()));

◆ validOverloads()

IntrinsicFunctors souffle::ast::validOverloads	(	const analysis::TypeAnalysis &	,
		const IntrinsicFunctor &
	)

Pick valid overloads for a functor, sorted by some measure of "preference".

◆ visitDepthFirst() [1/5]

template<typename Lambda , typename R = typename lambda_traits<Lambda>::result_type, typename N = typename lambda_traits<Lambda>::arg0_type>

std::enable_if<!detail::is_ast_visitor<Lambda>::value, void>::type souffle::ast::visitDepthFirst	(	const Node &	root,
		const Lambda &	fun
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given function to each encountered node.

Parameters

root	the root of the AST to be visited
fun	the function to be applied
args	a list of extra parameters to be forwarded to the visitor

Definition at line 343 of file Visitor.h.

References visitDepthFirst().

Here is the call graph for this function:

◆ visitDepthFirst() [2/5]

template<typename R , typename N >

void souffle::ast::visitDepthFirst	(	const Node &	root,
		const std::function< R(const N &)> &	fun
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given function to each encountered node.

Parameters

root	the root of the AST to be visited
fun	the function to be applied
args	a list of extra parameters to be forwarded to the visitor

Definition at line 327 of file Visitor.h.

References visitDepthFirst().

Here is the call graph for this function:

◆ visitDepthFirst() [3/5]

template<typename R , typename... Ps, typename... Args>

void souffle::ast::visitDepthFirst	(	const Node &	root,
		Visitor< R, Ps... > &	visitor,
		Args &...	args
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given visitor to each encountered node.

Parameters

root	the root of the AST to be visited
visitor	the visitor to be applied on each node
args	a list of extra parameters to be forwarded to the visitor

Definition at line 273 of file Visitor.h.

278 : public Visitor<void> {

References souffle::ast::detail::LambdaVisitor< R, N >::lambda, souffle::ast::detail::LambdaVisitor< R, N >::LambdaVisitor(), n, and souffle::ast::detail::LambdaVisitor< R, N >::visit().

Here is the call graph for this function:

◆ visitDepthFirst() [4/5]

template<typename T , typename Lambda >

void souffle::ast::visitDepthFirst	(	const std::vector< T * > &	list,
		const Lambda &	fun
	)

A utility function visiting all nodes within a given list of AST root nodes recursively in a depth-first pre-order fashion applying the given function to each encountered node.

Parameters

list	the list of roots of the ASTs to be visited
fun	the function to be applied
args	a list of extra parameters to be forwarded to the visitor

Definition at line 358 of file Visitor.h.

368 {

References visitDepthFirst().

Here is the call graph for this function:

◆ visitDepthFirst() [5/5]

template<typename T , typename Lambda >

void souffle::ast::visitDepthFirst	(	const VecOwn< T > &	list,
		const Lambda &	fun
	)

A utility function visiting all nodes within a given list of AST root nodes recursively in a depth-first pre-order fashion applying the given function to each encountered node.

Parameters

list	the list of roots of the ASTs to be visited
fun	the function to be applied
args	a list of extra parameters to be forwarded to the visitor

Definition at line 374 of file Visitor.h.

References souffle::ast::detail::makeLambdaVisitor().

Here is the call graph for this function:

◆ visitDepthFirstPostOrder() [1/3]

template<typename Lambda , typename R = typename lambda_traits<Lambda>::result_type, typename N = typename lambda_traits<Lambda>::arg0_type>

std::enable_if<!detail::is_ast_visitor<Lambda>::value, void>::type souffle::ast::visitDepthFirstPostOrder	(	const Node &	root,
		const Lambda &	fun
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first post-order fashion applying the given function to each encountered node.

Parameters

root	the root of the AST to be visited
fun	the function to be applied
args	a list of extra parameters to be forwarded to the visitor

Definition at line 406 of file Visitor.h.

◆ visitDepthFirstPostOrder() [2/3]

template<typename R , typename N >

void souffle::ast::visitDepthFirstPostOrder	(	const Node &	root,
		const std::function< R(const N &)> &	fun
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first post-order fashion applying the given function to each encountered node.

Parameters

root	the root of the AST to be visited
fun	the function to be applied
args	a list of extra parameters to be forwarded to the visitor

Definition at line 390 of file Visitor.h.

References visitDepthFirstPostOrder().

Here is the call graph for this function:

◆ visitDepthFirstPostOrder() [3/3]

template<typename R , typename... Ps, typename... Args>

void souffle::ast::visitDepthFirstPostOrder	(	const Node &	root,
		Visitor< R, Ps... > &	visitor,
		Args &...	args
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first post-order fashion applying the given visitor to each encountered node.

Parameters

root	the root of the AST to be visited
visitor	the visitor to be applied on each node
args	a list of extra parameters to be forwarded to the visitor

Definition at line 254 of file Visitor.h.

267 {

Referenced by visitDepthFirstPostOrder().

◆ visitDepthFirstPreOrder()

template<typename R , typename... Ps, typename... Args>

void souffle::ast::visitDepthFirstPreOrder	(	const Node &	root,
		Visitor< R, Ps... > &	visitor,
		Args &...	args
	)

A utility function visiting all nodes within the ast rooted by the given node recursively in a depth-first pre-order fashion applying the given visitor to each encountered node.

Parameters

root	the root of the AST to be visited
visitor	the visitor to be applied on each node
args	a list of extra parameters to be forwarded to the visitor

Definition at line 235 of file Visitor.h.

248 {

Referenced by souffle::ast::Visitor< void >::visitNode().

Namespaces

Data Structures

Typedefs

Enumerations

Functions

Typedef Documentation

◆ RelationSet

Enumeration Type Documentation

◆ DirectiveType

Function Documentation

◆ cloneHead()

◆ getAtomRelation()

◆ getBodyLiterals()

◆ getBodyRelations()

◆ getClauseNum()

◆ getClauses() [1/2]

◆ getClauses() [2/2]

◆ getDirectives()

◆ getHeadRelation()

◆ getRecords()

◆ getRelation()

◆ getVariables()

◆ hasClauseWithAggregatedRelation()

◆ hasClauseWithNegatedRelation()

◆ isDeltaRelation()

◆ isFact()

◆ isProposition()

◆ isRecursiveClause()

◆ isRule()

◆ makeLambdaAstMapper()

◆ negateConstraintInPlace()

◆ operator+()

◆ operator<<()

◆ pprint()

◆ removeRelation()

◆ removeRelationClauses()

◆ removeRelationIOs()

◆ renameAtoms()

◆ reorderAtoms()

◆ validOverloads()

◆ visitDepthFirst() [1/5]

◆ visitDepthFirst() [2/5]

◆ visitDepthFirst() [3/5]

◆ visitDepthFirst() [4/5]

◆ visitDepthFirst() [5/5]

◆ visitDepthFirstPostOrder() [1/3]

◆ visitDepthFirstPostOrder() [2/3]

◆ visitDepthFirstPostOrder() [3/3]

◆ visitDepthFirstPreOrder()