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

#include <Program.h>

Inheritance diagram for souffle::ast::Program:

Collaboration diagram for souffle::ast::Program:

Public Member Functions
void	addClause (Own< Clause > clause)
	Add a clause. More...

void	addDirective (Own< Directive > directive)
	Add relation directive. More...

void	addRelation (Own< Relation > relation)

void	addType (Own< Type > type)
	Add a type declaration. More...

void	apply (const NodeMapper &map) override
	Apply the mapper to all child nodes. More...

void	clearComponents ()
	Remove components and components' instantiations. More...

Program *	clone () const override
	Create a clone (i.e. More...

std::vector< const Node * >	getChildNodes () const override
	Obtain a list of all embedded AST child nodes. More...

std::vector< Clause * >	getClauses () const
	Return clauses. More...

std::vector< ComponentInit * >	getComponentInstantiations () const
	Return component instantiation. More...

std::vector< Component * >	getComponents () const
	Return components. More...

std::vector< Directive * >	getDirectives () const
	Return relation directives. More...

std::vector< FunctorDeclaration * >	getFunctorDeclarations () const
	Return functor declarations. More...

const VecOwn< Pragma > &	getPragmaDirectives () const
	Return pragma directives. More...

std::vector< Relation * >	getRelations () const
	Return relations. More...

std::vector< Type * >	getTypes () const
	Return types. More...

bool	removeClause (const Clause *clause)
	Remove a clause. More...

bool	removeDirective (const Directive *directive)
	Remove a directive. More...

bool	removeRelationDecl (const QualifiedName &name)
	Remove relation. More...

void	setClauses (VecOwn< Clause > newClauses)
	Set clauses. More...

Public Member Functions inherited from souffle::ast::Node
std::string	extloc () const
	Return source location of the syntactic element. More...

const SrcLocation &	getSrcLoc () const
	Return source location of the Node. More...

	Node (SrcLocation loc={})

bool	operator!= (const Node &other) const
	Inequality check for two AST nodes. More...

bool	operator== (const Node &other) const
	Equivalence check for two AST nodes. More...

void	setSrcLoc (SrcLocation l)
	Set source location for the Node. More...

virtual	~Node ()=default

Protected Member Functions
void	addComponent (Own< Component > component)
	Add component. More...

void	addFunctorDeclaration (Own< FunctorDeclaration > functor)

void	addInstantiation (Own< ComponentInit > instantiation)
	Add component instantiation. More...

void	addPragma (Own< Pragma > pragma)

bool	equal (const Node &node) const override
	Abstract equality check for two AST nodes. More...

void	print (std::ostream &os) const override
	Output to a given output stream. More...

Protected Attributes
VecOwn< Clause >	clauses
	Program clauses. More...

VecOwn< Component >	components
	Component definitions. More...

VecOwn< Directive >	directives
	Directives. More...

VecOwn< FunctorDeclaration >	functors
	External Functors. More...

VecOwn< ComponentInit >	instantiations
	Component instantiations. More...

VecOwn< Pragma >	pragmas
	Pragmas. More...

VecOwn< Relation >	relations
	Program relations. More...

VecOwn< Type >	types
	Program types More...

Friends
class	souffle::ParserDriver

Detailed Description

The program class consists of relations, clauses and types.

Definition at line 52 of file Program.h.

Member Function Documentation

◆ addClause()

void souffle::ast::Program::addClause ( Own< Clause > clause )

Add a clause.

Definition at line 62 of file Program.cpp.

                              {
             clauses.erase(it);
             return true;
         }
     }

References clauses.

Referenced by souffle::ParserDriver::addClause().

◆ addComponent()

void souffle::ast::Program::addComponent ( Own< Component > component )

inlineprotected

Add component.

Definition at line 248 of file Program.h.

                                                 {
         assert(component && "NULL component");
         components.push_back(std::move(component));
     }

References components.

Referenced by souffle::ParserDriver::addComponent().

◆ addDirective()

void souffle::ast::Program::addDirective ( Own< Directive > directive )

inline

Add relation directive.

Definition at line 80 of file Program.h.

                                                 {
         assert(directive && "NULL directive");
         directives.push_back(std::move(directive));
     }

References directives.

Referenced by souffle::ParserDriver::addDirective().

◆ addFunctorDeclaration()

void souffle::ast::Program::addFunctorDeclaration ( Own< FunctorDeclaration > functor )

protected

Definition at line 100 of file Program.cpp.

Referenced by souffle::ParserDriver::addFunctorDeclaration().

◆ addInstantiation()

void souffle::ast::Program::addInstantiation ( Own< ComponentInit > instantiation )

inlineprotected

Add component instantiation.

Definition at line 254 of file Program.h.

                                                             {
         assert(instantiation && "NULL instantiation");
         instantiations.push_back(std::move(instantiation));
     }

References instantiations.

Referenced by souffle::ParserDriver::addInstantiation().

◆ addPragma()

void souffle::ast::Program::addPragma ( Own< Pragma > pragma )

protected

Definition at line 95 of file Program.cpp.

Referenced by souffle::ParserDriver::addPragma().

◆ addRelation()

void souffle::ast::Program::addRelation ( Own< Relation > relation )

Definition at line 43 of file Program.cpp.

                                                           {
     for (auto it = relations.begin(); it != relations.end(); it++) {
         const auto& rel = *it;
         if (rel->getQualifiedName() == name) {
             relations.erase(it);
             return true;
         }

References rel(), and relations.

Referenced by souffle::ParserDriver::addRelation().

Here is the call graph for this function:

◆ addType()

void souffle::ast::Program::addType ( Own< Type > type )

Add a type declaration.

Definition at line 88 of file Program.cpp.

92 {

93 auto* existingFunctorDecl = getIf(getFunctorDeclarations(),

Referenced by souffle::ParserDriver::addType().

◆ apply()

void souffle::ast::Program::apply ( const NodeMapper & )

inlineoverridevirtual

Apply the mapper to all child nodes.

Reimplemented from souffle::ast::Node.

Definition at line 139 of file Program.h.

                                                {
         for (auto& cur : pragmas) {
             cur = map(std::move(cur));
         }
         for (auto& cur : components) {
             cur = map(std::move(cur));
         }
         for (auto& cur : instantiations) {
             cur = map(std::move(cur));
         }
         for (auto& cur : functors) {
             cur = map(std::move(cur));
         }
         for (auto& cur : types) {
             cur = map(std::move(cur));
         }
         for (auto& cur : relations) {
             cur = map(std::move(cur));
         }
         for (auto& cur : clauses) {
             cur = map(std::move(cur));
         }
         for (auto& cur : directives) {
             cur = map(std::move(cur));
         }
     }

References clauses, components, directives, functors, instantiations, souffle::map(), pragmas, relations, and types.

Here is the call graph for this function:

◆ clearComponents()

void souffle::ast::Program::clearComponents ( )

Remove components and components' instantiations.

Definition at line 107 of file Program.cpp.

◆ clone()

Program* souffle::ast::Program::clone ( ) const

inlineoverridevirtual

Create a clone (i.e.

deep copy) of this node

Implements souffle::ast::Node.

Definition at line 126 of file Program.h.

                                     {
         auto res = new Program();
         res->pragmas = souffle::clone(pragmas);
         res->components = souffle::clone(components);
         res->instantiations = souffle::clone(instantiations);
         res->types = souffle::clone(types);
         res->functors = souffle::clone(functors);
         res->relations = souffle::clone(relations);
         res->clauses = souffle::clone(clauses);
         res->directives = souffle::clone(directives);
         return res;
     }

References clauses, souffle::clone(), components, directives, functors, instantiations, pragmas, relations, and types.

Here is the call graph for this function:

◆ equal()

bool souffle::ast::Program::equal ( const Node & ) const

inlineoverrideprotectedvirtual

Abstract equality check for two AST nodes.

Reimplemented from souffle::ast::Node.

Definition at line 211 of file Program.h.

                                                 {
         const auto& other = static_cast<const Program&>(node);
         if (!equal_targets(pragmas, other.pragmas)) {
             return false;
         }
         if (!equal_targets(components, other.components)) {
             return false;
         }
         if (!equal_targets(instantiations, other.instantiations)) {
             return false;
         }
         if (!equal_targets(functors, other.functors)) {
             return false;
         }
         if (!equal_targets(types, other.types)) {
             return false;
         }
         if (!equal_targets(relations, other.relations)) {
             return false;
         }
         if (!equal_targets(clauses, other.clauses)) {
             return false;
         }
         if (!equal_targets(directives, other.directives)) {
             return false;
         }
         return true;
     }

References clauses, components, directives, souffle::equal_targets(), functors, instantiations, pragmas, relations, and types.

Here is the call graph for this function:

◆ getChildNodes()

std::vector<const Node*> souffle::ast::Program::getChildNodes ( ) const

inlineoverridevirtual

Obtain a list of all embedded AST child nodes.

Reimplemented from souffle::ast::Node.

Definition at line 166 of file Program.h.

                                                           {
         std::vector<const Node*> res;
         for (const auto& cur : pragmas) {
             res.push_back(cur.get());
         }
         for (const auto& cur : components) {
             res.push_back(cur.get());
         }
         for (const auto& cur : instantiations) {
             res.push_back(cur.get());
         }
         for (const auto& cur : functors) {
             res.push_back(cur.get());
         }
         for (const auto& cur : types) {
             res.push_back(cur.get());
         }
         for (const auto& cur : relations) {
             res.push_back(cur.get());
         }
         for (const auto& cur : clauses) {
             res.push_back(cur.get());
         }
         for (const auto& cur : directives) {
             res.push_back(cur.get());
         }
         return res;
     }

References clauses, components, directives, functors, instantiations, pragmas, relations, and types.

◆ getClauses()

std::vector<Clause*> souffle::ast::Program::getClauses ( ) const

inline

Return clauses.

Definition at line 65 of file Program.h.

                                           {
         return toPtrVector(clauses);
     }

References clauses, and souffle::toPtrVector().

Referenced by souffle::ast::getRecords().

Here is the call graph for this function:

◆ getComponentInstantiations()

std::vector<ComponentInit*> souffle::ast::Program::getComponentInstantiations ( ) const

inline

Return component instantiation.

Definition at line 119 of file Program.h.

                                                                  {
         return toPtrVector(instantiations);
     }

References instantiations, and souffle::toPtrVector().

Here is the call graph for this function:

◆ getComponents()

std::vector<Component*> souffle::ast::Program::getComponents ( ) const

inline

Return components.

Definition at line 114 of file Program.h.

                                                 {
         return toPtrVector(components);
     }

References components, and souffle::toPtrVector().

Here is the call graph for this function:

◆ getDirectives()

std::vector<Directive*> souffle::ast::Program::getDirectives ( ) const

inline

Return relation directives.

Definition at line 75 of file Program.h.

                                                 {
         return toPtrVector(directives);
     }

References directives, and souffle::toPtrVector().

Referenced by souffle::ParserDriver::addDirective(), and souffle::ast::transform::IODefaultsTransformer::transform().

Here is the call graph for this function:

◆ getFunctorDeclarations()

std::vector<FunctorDeclaration*> souffle::ast::Program::getFunctorDeclarations ( ) const

inline

Return functor declarations.

Definition at line 70 of file Program.h.

                                                                   {
         return toPtrVector(functors);
     }

References functors, and souffle::toPtrVector().

Referenced by souffle::ParserDriver::addFunctorDeclaration().

Here is the call graph for this function:

◆ getPragmaDirectives()

const VecOwn<Pragma>& souffle::ast::Program::getPragmaDirectives ( ) const

inline

Return pragma directives.

Definition at line 86 of file Program.h.

                                                       {
         return pragmas;
     }

References pragmas.

◆ getRelations()

std::vector<Relation*> souffle::ast::Program::getRelations ( ) const

inline

Return relations.

Definition at line 60 of file Program.h.

                                               {
         return toPtrVector(relations);
     }

References relations, and souffle::toPtrVector().

Referenced by souffle::ast::transform::SemanticCheckerImpl::SemanticCheckerImpl(), and souffle::ast::transform::test::TEST().

Here is the call graph for this function:

◆ getTypes()

std::vector<Type*> souffle::ast::Program::getTypes ( ) const

inline

Return types.

Definition at line 55 of file Program.h.

                                       {
         return toPtrVector(types);
     }

References souffle::toPtrVector(), and types.

Referenced by souffle::ParserDriver::addType().

Here is the call graph for this function:

◆ print()

void souffle::ast::Program::print ( std::ostream & os ) const

inlineoverrideprotectedvirtual

Output to a given output stream.

Implements souffle::ast::Node.

Definition at line 196 of file Program.h.

                                               {
         auto show = [&](auto&& xs, char const* sep = "\n") {
             if (!xs.empty()) os << join(xs, sep) << "\n";
         };
  
         show(pragmas, "\n\n");
         show(components);
         show(instantiations);
         show(types);
         show(functors);
         show(relations);
         show(clauses, "\n\n");
         show(directives, "\n\n");
     }

References clauses, components, directives, functors, instantiations, souffle::join(), pragmas, relations, and types.

Here is the call graph for this function:

◆ removeClause()

bool souffle::ast::Program::removeClause ( const Clause * clause )

Remove a clause.

Definition at line 68 of file Program.cpp.

                                                         {
     for (auto it = directives.begin(); it != directives.end(); it++) {
         if (**it == *directive) {
             directives.erase(it);
             return true;
         }
     }

◆ removeDirective()

bool souffle::ast::Program::removeDirective ( const Directive * directive )

Remove a directive.

Definition at line 78 of file Program.cpp.

                                     {
     auto* existingType = getIf(getTypes(),
             [&](const Type* current) { return current->getQualifiedName() == type->getQualifiedName(); });
     assert(existingType == nullptr && "Redefinition of type!");
     types.push_back(std::move(type));
 }
  

◆ removeRelationDecl()

bool souffle::ast::Program::removeRelationDecl ( const QualifiedName & name )

Remove relation.

Definition at line 51 of file Program.cpp.

                                           {
     assert(clause != nullptr && "Undefined clause");
     assert(clause->getHead() != nullptr && "Undefined head of the clause");
     clauses.push_back(std::move(clause));
 }
  
 bool Program::removeClause(const Clause* clause) {

◆ setClauses()

void souffle::ast::Program::setClauses ( VecOwn< Clause > newClauses )

inline

Set clauses.

Definition at line 97 of file Program.h.

                                                {
         clauses = std::move(newClauses);
     }

References clauses.

Friends And Related Function Documentation

◆ souffle::ParserDriver

friend class souffle::ParserDriver

friend

Definition at line 241 of file Program.h.

Field Documentation

◆ clauses

VecOwn<Clause> souffle::ast::Program::clauses

protected

Program clauses.

Definition at line 269 of file Program.h.

Referenced by addClause(), apply(), clone(), equal(), getChildNodes(), getClauses(), print(), and setClauses().

◆ components

VecOwn<Component> souffle::ast::Program::components

protected

Component definitions.

Definition at line 275 of file Program.h.

Referenced by addComponent(), apply(), clone(), equal(), getChildNodes(), getComponents(), and print().

◆ directives

VecOwn<Directive> souffle::ast::Program::directives

protected

Directives.

Definition at line 272 of file Program.h.

Referenced by addDirective(), apply(), clone(), equal(), getChildNodes(), getDirectives(), and print().

◆ functors

VecOwn<FunctorDeclaration> souffle::ast::Program::functors

protected

External Functors.

Definition at line 266 of file Program.h.

Referenced by apply(), clone(), equal(), getChildNodes(), getFunctorDeclarations(), and print().

◆ instantiations

VecOwn<ComponentInit> souffle::ast::Program::instantiations

protected

Component instantiations.

Definition at line 278 of file Program.h.

Referenced by addInstantiation(), apply(), clone(), equal(), getChildNodes(), getComponentInstantiations(), and print().

◆ pragmas

VecOwn<Pragma> souffle::ast::Program::pragmas

protected

Pragmas.

Definition at line 281 of file Program.h.

Referenced by apply(), clone(), equal(), getChildNodes(), getPragmaDirectives(), and print().

◆ relations

VecOwn<Relation> souffle::ast::Program::relations

protected

Program relations.

Definition at line 263 of file Program.h.

Referenced by addRelation(), apply(), clone(), equal(), getChildNodes(), getRelations(), and print().

◆ types

VecOwn<Type> souffle::ast::Program::types

protected

Program types

Definition at line 260 of file Program.h.

Referenced by apply(), clone(), equal(), getChildNodes(), getTypes(), and print().

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

ast/Program.h
ast/Program.cpp

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Function Documentation

◆ addClause()

◆ addComponent()

◆ addDirective()

◆ addFunctorDeclaration()

◆ addInstantiation()

◆ addPragma()

◆ addRelation()

◆ addType()

◆ apply()

◆ clearComponents()

◆ clone()

◆ equal()

◆ getChildNodes()

◆ getClauses()

◆ getComponentInstantiations()

◆ getComponents()

◆ getDirectives()

◆ getFunctorDeclarations()

◆ getPragmaDirectives()

◆ getRelations()

◆ getTypes()

◆ print()

◆ removeClause()

◆ removeDirective()

◆ removeRelationDecl()

◆ setClauses()

Friends And Related Function Documentation

◆ souffle::ParserDriver

Field Documentation

◆ clauses

◆ components

◆ directives

◆ functors

◆ instantiations

◆ pragmas

◆ relations

◆ types