command.h
Go to the documentation of this file.
/********************* */
#include "cvc4_public.h"
#ifndef __CVC4__COMMAND_H
#define __CVC4__COMMAND_H
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include "expr/expr.h"
#include "expr/type.h"
#include "expr/variable_type_map.h"
#include "util/result.h"
#include "util/sexpr.h"
#include "util/datatype.h"
#include "util/proof.h"
namespace CVC4 {
class SmtEngine;
class Command;
class CommandStatus;
class Model;
std::ostream& operator<<(std::ostream&, const Command&) throw() CVC4_PUBLIC;
std::ostream& operator<<(std::ostream&, const Command*) throw() CVC4_PUBLIC;
std::ostream& operator<<(std::ostream&, const CommandStatus&) throw() CVC4_PUBLIC;
std::ostream& operator<<(std::ostream&, const CommandStatus*) throw() CVC4_PUBLIC;
enum BenchmarkStatus {
SMT_SATISFIABLE,
SMT_UNSATISFIABLE,
SMT_UNKNOWN
};/* enum BenchmarkStatus */
std::ostream& operator<<(std::ostream& out,
BenchmarkStatus status) throw() CVC4_PUBLIC;
class CVC4_PUBLIC CommandPrintSuccess {
static const int s_iosIndex;
static const int s_defaultPrintSuccess = false;
bool d_printSuccess;
public:
CommandPrintSuccess(bool printSuccess) throw() : d_printSuccess(printSuccess) {}
inline void applyPrintSuccess(std::ostream& out) throw() {
out.iword(s_iosIndex) = d_printSuccess;
}
static inline bool getPrintSuccess(std::ostream& out) throw() {
return out.iword(s_iosIndex);
}
static inline void setPrintSuccess(std::ostream& out, bool printSuccess) throw() {
out.iword(s_iosIndex) = printSuccess;
}
class Scope {
std::ostream& d_out;
bool d_oldPrintSuccess;
public:
inline Scope(std::ostream& out, bool printSuccess) throw() :
d_out(out),
d_oldPrintSuccess(CommandPrintSuccess::getPrintSuccess(out)) {
CommandPrintSuccess::setPrintSuccess(out, printSuccess);
}
inline ~Scope() throw() {
CommandPrintSuccess::setPrintSuccess(d_out, d_oldPrintSuccess);
}
};/* class CommandPrintSuccess::Scope */
};/* class CommandPrintSuccess */
inline std::ostream& operator<<(std::ostream& out, CommandPrintSuccess cps) throw() CVC4_PUBLIC;
inline std::ostream& operator<<(std::ostream& out, CommandPrintSuccess cps) throw() {
cps.applyPrintSuccess(out);
return out;
}
class CVC4_PUBLIC CommandStatus {
protected:
// shouldn't construct a CommandStatus (use a derived class)
CommandStatus() throw() {}
public:
virtual ~CommandStatus() throw() {}
void toStream(std::ostream& out,
OutputLanguage language = language::output::LANG_AUTO) const throw();
virtual CommandStatus& clone() const = 0;
};/* class CommandStatus */
class CVC4_PUBLIC CommandSuccess : public CommandStatus {
static const CommandSuccess* s_instance;
public:
static const CommandSuccess* instance() throw() { return s_instance; }
CommandStatus& clone() const { return const_cast< CommandSuccess&>(*this); }
};/* class CommandSuccess */
class CVC4_PUBLIC CommandUnsupported : public CommandStatus {
public:
CommandStatus& clone() const { return *new CommandUnsupported(*this); }
};/* class CommandSuccess */
class CVC4_PUBLIC CommandFailure : public CommandStatus {
std::string d_message;
public:
CommandFailure(std::string message) throw() : d_message(message) {}
CommandFailure& clone() const { return *new CommandFailure(*this); }
~CommandFailure() throw() {}
std::string getMessage() const throw() { return d_message; }
};/* class CommandFailure */
class CVC4_PUBLIC Command {
protected:
const CommandStatus* d_commandStatus;
bool d_muted;
public:
typedef CommandPrintSuccess printsuccess;
Command() throw();
Command(const Command& cmd);
virtual ~Command() throw();
virtual void invoke(SmtEngine* smtEngine) throw() = 0;
virtual void invoke(SmtEngine* smtEngine, std::ostream& out) throw();
virtual void toStream(std::ostream& out, int toDepth = -1, bool types = false, size_t dag = 1,
OutputLanguage language = language::output::LANG_AUTO) const throw();
std::string toString() const throw();
virtual std::string getCommandName() const throw() = 0;
void setMuted(bool muted) throw() { d_muted = muted; }
bool isMuted() throw() { return d_muted; }
bool ok() const throw();
bool fail() const throw();
const CommandStatus* getCommandStatus() const throw() { return d_commandStatus; }
virtual void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
virtual Command* exportTo(ExprManager* exprManager,
ExprManagerMapCollection& variableMap) = 0;
virtual Command* clone() const = 0;
protected:
class ExportTransformer {
ExprManager* d_exprManager;
ExprManagerMapCollection& d_variableMap;
public:
ExportTransformer(ExprManager* exprManager, ExprManagerMapCollection& variableMap) :
d_exprManager(exprManager),
d_variableMap(variableMap) {
}
Expr operator()(Expr e) {
return e.exportTo(d_exprManager, d_variableMap);
}
Type operator()(Type t) {
return t.exportTo(d_exprManager, d_variableMap);
}
};/* class Command::ExportTransformer */
};/* class Command */
class CVC4_PUBLIC EmptyCommand : public Command {
protected:
std::string d_name;
public:
EmptyCommand(std::string name = "") throw();
~EmptyCommand() throw() {}
std::string getName() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class EmptyCommand */
class CVC4_PUBLIC EchoCommand : public Command {
protected:
std::string d_output;
public:
EchoCommand(std::string output = "") throw();
~EchoCommand() throw() {}
std::string getOutput() const throw();
void invoke(SmtEngine* smtEngine) throw();
void invoke(SmtEngine* smtEngine, std::ostream& out) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class EchoCommand */
class CVC4_PUBLIC AssertCommand : public Command {
protected:
Expr d_expr;
public:
AssertCommand(const Expr& e) throw();
~AssertCommand() throw() {}
Expr getExpr() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class AssertCommand */
class CVC4_PUBLIC PushCommand : public Command {
public:
~PushCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class PushCommand */
class CVC4_PUBLIC PopCommand : public Command {
public:
~PopCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class PopCommand */
class CVC4_PUBLIC DeclarationDefinitionCommand : public Command {
protected:
std::string d_symbol;
public:
DeclarationDefinitionCommand(const std::string& id) throw();
~DeclarationDefinitionCommand() throw() {}
virtual void invoke(SmtEngine* smtEngine) throw() = 0;
std::string getSymbol() const throw();
};/* class DeclarationDefinitionCommand */
class CVC4_PUBLIC DeclareFunctionCommand : public DeclarationDefinitionCommand {
protected:
Expr d_func;
Type d_type;
bool d_printInModel;
bool d_printInModelSetByUser;
public:
DeclareFunctionCommand(const std::string& id, Expr func, Type type) throw();
~DeclareFunctionCommand() throw() {}
Expr getFunction() const throw();
Type getType() const throw();
bool getPrintInModel() const throw();
bool getPrintInModelSetByUser() const throw();
void setPrintInModel( bool p );
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class DeclareFunctionCommand */
class CVC4_PUBLIC DeclareTypeCommand : public DeclarationDefinitionCommand {
protected:
size_t d_arity;
Type d_type;
public:
DeclareTypeCommand(const std::string& id, size_t arity, Type t) throw();
~DeclareTypeCommand() throw() {}
size_t getArity() const throw();
Type getType() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class DeclareTypeCommand */
class CVC4_PUBLIC DefineTypeCommand : public DeclarationDefinitionCommand {
protected:
std::vector<Type> d_params;
Type d_type;
public:
DefineTypeCommand(const std::string& id, Type t) throw();
DefineTypeCommand(const std::string& id, const std::vector<Type>& params, Type t) throw();
~DefineTypeCommand() throw() {}
const std::vector<Type>& getParameters() const throw();
Type getType() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class DefineTypeCommand */
class CVC4_PUBLIC DefineFunctionCommand : public DeclarationDefinitionCommand {
protected:
Expr d_func;
std::vector<Expr> d_formals;
Expr d_formula;
public:
DefineFunctionCommand(const std::string& id, Expr func, Expr formula) throw();
DefineFunctionCommand(const std::string& id, Expr func,
const std::vector<Expr>& formals, Expr formula) throw();
~DefineFunctionCommand() throw() {}
Expr getFunction() const throw();
const std::vector<Expr>& getFormals() const throw();
Expr getFormula() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class DefineFunctionCommand */
class CVC4_PUBLIC DefineNamedFunctionCommand : public DefineFunctionCommand {
public:
DefineNamedFunctionCommand(const std::string& id, Expr func,
const std::vector<Expr>& formals, Expr formula) throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
};/* class DefineNamedFunctionCommand */
class CVC4_PUBLIC SetUserAttributeCommand : public Command {
protected:
std::string d_attr;
Expr d_expr;
//std::vector<Expr> d_expr_values;
//std::string d_str_value;
public:
SetUserAttributeCommand( const std::string& attr, Expr expr ) throw();
//SetUserAttributeCommand( const std::string& id, Expr expr, std::vector<Expr>& values ) throw();
//SetUserAttributeCommand( const std::string& id, Expr expr, std::string& value ) throw();
~SetUserAttributeCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class SetUserAttributeCommand */
class CVC4_PUBLIC CheckSatCommand : public Command {
protected:
Expr d_expr;
Result d_result;
public:
CheckSatCommand() throw();
CheckSatCommand(const Expr& expr) throw();
~CheckSatCommand() throw() {}
Expr getExpr() const throw();
void invoke(SmtEngine* smtEngine) throw();
Result getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class CheckSatCommand */
class CVC4_PUBLIC QueryCommand : public Command {
protected:
Expr d_expr;
Result d_result;
public:
QueryCommand(const Expr& e) throw();
~QueryCommand() throw() {}
Expr getExpr() const throw();
void invoke(SmtEngine* smtEngine) throw();
Result getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class QueryCommand */
// this is TRANSFORM in the CVC presentation language
class CVC4_PUBLIC SimplifyCommand : public Command {
protected:
Expr d_term;
Expr d_result;
public:
SimplifyCommand(Expr term) throw();
~SimplifyCommand() throw() {}
Expr getTerm() const throw();
void invoke(SmtEngine* smtEngine) throw();
Expr getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class SimplifyCommand */
class CVC4_PUBLIC ExpandDefinitionsCommand : public Command {
protected:
Expr d_term;
Expr d_result;
public:
ExpandDefinitionsCommand(Expr term) throw();
~ExpandDefinitionsCommand() throw() {}
Expr getTerm() const throw();
void invoke(SmtEngine* smtEngine) throw();
Expr getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class ExpandDefinitionsCommand */
class CVC4_PUBLIC GetValueCommand : public Command {
protected:
std::vector<Expr> d_terms;
Expr d_result;
public:
GetValueCommand(Expr term) throw();
GetValueCommand(const std::vector<Expr>& terms) throw();
~GetValueCommand() throw() {}
const std::vector<Expr>& getTerms() const throw();
void invoke(SmtEngine* smtEngine) throw();
Expr getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetValueCommand */
class CVC4_PUBLIC GetAssignmentCommand : public Command {
protected:
SExpr d_result;
public:
GetAssignmentCommand() throw();
~GetAssignmentCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
SExpr getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetAssignmentCommand */
class CVC4_PUBLIC GetModelCommand : public Command {
protected:
Model* d_result;
SmtEngine* d_smtEngine;
public:
GetModelCommand() throw();
~GetModelCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
// Model is private to the library -- for now
//Model* getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetModelCommand */
class CVC4_PUBLIC GetProofCommand : public Command {
protected:
Proof* d_result;
public:
GetProofCommand() throw();
~GetProofCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
Proof* getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetProofCommand */
class CVC4_PUBLIC GetInstantiationsCommand : public Command {
protected:
//Instantiations* d_result;
SmtEngine* d_smtEngine;
public:
GetInstantiationsCommand() throw();
~GetInstantiationsCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
//Instantiations* getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetInstantiationsCommand */
class CVC4_PUBLIC GetUnsatCoreCommand : public Command {
protected:
//UnsatCore* d_result;
public:
GetUnsatCoreCommand() throw();
~GetUnsatCoreCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetUnsatCoreCommand */
class CVC4_PUBLIC GetAssertionsCommand : public Command {
protected:
std::string d_result;
public:
GetAssertionsCommand() throw();
~GetAssertionsCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
std::string getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetAssertionsCommand */
class CVC4_PUBLIC SetBenchmarkStatusCommand : public Command {
protected:
BenchmarkStatus d_status;
public:
SetBenchmarkStatusCommand(BenchmarkStatus status) throw();
~SetBenchmarkStatusCommand() throw() {}
BenchmarkStatus getStatus() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class SetBenchmarkStatusCommand */
class CVC4_PUBLIC SetBenchmarkLogicCommand : public Command {
protected:
std::string d_logic;
public:
SetBenchmarkLogicCommand(std::string logic) throw();
~SetBenchmarkLogicCommand() throw() {}
std::string getLogic() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class SetBenchmarkLogicCommand */
class CVC4_PUBLIC SetInfoCommand : public Command {
protected:
std::string d_flag;
SExpr d_sexpr;
public:
SetInfoCommand(std::string flag, const SExpr& sexpr) throw();
~SetInfoCommand() throw() {}
std::string getFlag() const throw();
SExpr getSExpr() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class SetInfoCommand */
class CVC4_PUBLIC GetInfoCommand : public Command {
protected:
std::string d_flag;
std::string d_result;
public:
GetInfoCommand(std::string flag) throw();
~GetInfoCommand() throw() {}
std::string getFlag() const throw();
void invoke(SmtEngine* smtEngine) throw();
std::string getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetInfoCommand */
class CVC4_PUBLIC SetOptionCommand : public Command {
protected:
std::string d_flag;
SExpr d_sexpr;
public:
SetOptionCommand(std::string flag, const SExpr& sexpr) throw();
~SetOptionCommand() throw() {}
std::string getFlag() const throw();
SExpr getSExpr() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class SetOptionCommand */
class CVC4_PUBLIC GetOptionCommand : public Command {
protected:
std::string d_flag;
std::string d_result;
public:
GetOptionCommand(std::string flag) throw();
~GetOptionCommand() throw() {}
std::string getFlag() const throw();
void invoke(SmtEngine* smtEngine) throw();
std::string getResult() const throw();
void printResult(std::ostream& out, uint32_t verbosity = 2) const throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class GetOptionCommand */
class CVC4_PUBLIC DatatypeDeclarationCommand : public Command {
private:
std::vector<DatatypeType> d_datatypes;
public:
DatatypeDeclarationCommand(const DatatypeType& datatype) throw();
~DatatypeDeclarationCommand() throw() {}
DatatypeDeclarationCommand(const std::vector<DatatypeType>& datatypes) throw();
const std::vector<DatatypeType>& getDatatypes() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class DatatypeDeclarationCommand */
class CVC4_PUBLIC RewriteRuleCommand : public Command {
public:
typedef std::vector< std::vector< Expr > > Triggers;
protected:
typedef std::vector< Expr > VExpr;
VExpr d_vars;
VExpr d_guards;
Expr d_head;
Expr d_body;
Triggers d_triggers;
public:
RewriteRuleCommand(const std::vector<Expr>& vars,
const std::vector<Expr>& guards,
Expr head,
Expr body,
const Triggers& d_triggers) throw();
RewriteRuleCommand(const std::vector<Expr>& vars,
Expr head,
Expr body) throw();
~RewriteRuleCommand() throw() {}
const std::vector<Expr>& getVars() const throw();
const std::vector<Expr>& getGuards() const throw();
Expr getHead() const throw();
Expr getBody() const throw();
const Triggers& getTriggers() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class RewriteRuleCommand */
class CVC4_PUBLIC PropagateRuleCommand : public Command {
public:
typedef std::vector< std::vector< Expr > > Triggers;
protected:
typedef std::vector< Expr > VExpr;
VExpr d_vars;
VExpr d_guards;
VExpr d_heads;
Expr d_body;
Triggers d_triggers;
bool d_deduction;
public:
PropagateRuleCommand(const std::vector<Expr>& vars,
const std::vector<Expr>& guards,
const std::vector<Expr>& heads,
Expr body,
const Triggers& d_triggers,
/* true if we want a deduction rule */
bool d_deduction = false) throw();
PropagateRuleCommand(const std::vector<Expr>& vars,
const std::vector<Expr>& heads,
Expr body,
bool d_deduction = false) throw();
~PropagateRuleCommand() throw() {}
const std::vector<Expr>& getVars() const throw();
const std::vector<Expr>& getGuards() const throw();
const std::vector<Expr>& getHeads() const throw();
Expr getBody() const throw();
const Triggers& getTriggers() const throw();
bool isDeduction() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class PropagateRuleCommand */
class CVC4_PUBLIC QuitCommand : public Command {
public:
QuitCommand() throw();
~QuitCommand() throw() {}
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class QuitCommand */
class CVC4_PUBLIC CommentCommand : public Command {
std::string d_comment;
public:
CommentCommand(std::string comment) throw();
~CommentCommand() throw() {}
std::string getComment() const throw();
void invoke(SmtEngine* smtEngine) throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class CommentCommand */
class CVC4_PUBLIC CommandSequence : public Command {
private:
std::vector<Command*> d_commandSequence;
unsigned int d_index;
public:
CommandSequence() throw();
~CommandSequence() throw();
void addCommand(Command* cmd) throw();
void clear() throw();
void invoke(SmtEngine* smtEngine) throw();
void invoke(SmtEngine* smtEngine, std::ostream& out) throw();
typedef std::vector<Command*>::iterator iterator;
typedef std::vector<Command*>::const_iterator const_iterator;
const_iterator begin() const throw();
const_iterator end() const throw();
iterator begin() throw();
iterator end() throw();
Command* exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap);
Command* clone() const;
std::string getCommandName() const throw();
};/* class CommandSequence */
class CVC4_PUBLIC DeclarationSequence : public CommandSequence {
public:
~DeclarationSequence() throw() {}
};/* class DeclarationSequence */
}/* CVC4 namespace */
#endif /* __CVC4__COMMAND_H */
CVC4::AssertCommand
Definition command.h:309
CVC4::AssertCommand::getExpr
Expr getExpr() const
CVC4::AssertCommand::AssertCommand
AssertCommand(const Expr &e)
CVC4::AssertCommand::d_expr
Expr d_expr
Definition command.h:311
CVC4::AssertCommand::~AssertCommand
~AssertCommand()
Definition command.h:314
CVC4::CheckSatCommand
Definition command.h:456
CVC4::CheckSatCommand::d_result
Result d_result
Definition command.h:459
CVC4::CheckSatCommand::d_expr
Expr d_expr
Definition command.h:458
CVC4::CheckSatCommand::getExpr
Expr getExpr() const
CVC4::CheckSatCommand::CheckSatCommand
CheckSatCommand()
CVC4::CommandFailure
Definition command.h:175
CVC4::CommandFailure::~CommandFailure
~CommandFailure()
Definition command.h:180
CVC4::CommandFailure::CommandFailure
CommandFailure(std::string message)
Definition command.h:178
CVC4::CommandFailure::clone
CommandFailure & clone() const
Definition command.h:179
CVC4::CommandFailure::getMessage
std::string getMessage() const
Definition command.h:181
CVC4::CommandPrintSuccess::Scope
Set the print-success state on the output stream for the current stack scope.
Definition command.h:117
CVC4::CommandPrintSuccess::Scope::Scope
Scope(std::ostream &out, bool printSuccess)
Definition command.h:123
CVC4::CommandPrintSuccess::Scope::~Scope
~Scope()
Definition command.h:129
CVC4::CommandPrintSuccess
IOStream manipulator to print success messages or not.
Definition command.h:76
CVC4::CommandPrintSuccess::CommandPrintSuccess
CommandPrintSuccess(bool printSuccess)
Construct a CommandPrintSuccess with the given setting.
Definition command.h:97
CVC4::CommandPrintSuccess::applyPrintSuccess
void applyPrintSuccess(std::ostream &out)
Definition command.h:99
CVC4::CommandPrintSuccess::setPrintSuccess
static void setPrintSuccess(std::ostream &out, bool printSuccess)
Definition command.h:107
CVC4::CommandPrintSuccess::getPrintSuccess
static bool getPrintSuccess(std::ostream &out)
Definition command.h:103
CVC4::CommandSequence
Definition command.h:817
CVC4::CommandSequence::const_iterator
std::vector< Command * >::const_iterator const_iterator
Definition command.h:834
CVC4::CommandSequence::CommandSequence
CommandSequence()
CVC4::CommandSequence::iterator
std::vector< Command * >::iterator iterator
Definition command.h:833
CVC4::CommandStatus
Definition command.h:152
CVC4::CommandStatus::toStream
void toStream(std::ostream &out, OutputLanguage language=language::output::LANG_AUTO) const
CVC4::CommandStatus::~CommandStatus
virtual ~CommandStatus()
Definition command.h:157
CVC4::CommandStatus::CommandStatus
CommandStatus()
Definition command.h:155
CVC4::CommandStatus::clone
virtual CommandStatus & clone() const =0
CVC4::CommandSuccess
Definition command.h:163
CVC4::CommandSuccess::clone
CommandStatus & clone() const
Definition command.h:167
CVC4::CommandSuccess::instance
static const CommandSuccess * instance()
Definition command.h:166
CVC4::CommandUnsupported
Definition command.h:170
CVC4::CommandUnsupported::clone
CommandStatus & clone() const
Definition command.h:172
CVC4::Command::ExportTransformer
Definition command.h:261
CVC4::Command::ExportTransformer::operator()
Type operator()(Type t)
Definition command.h:272
CVC4::Command::ExportTransformer::ExportTransformer
ExportTransformer(ExprManager *exprManager, ExprManagerMapCollection &variableMap)
Definition command.h:265
CVC4::Command::ExportTransformer::operator()
Expr operator()(Expr e)
Definition command.h:269
CVC4::Command
Definition command.h:184
CVC4::Command::ok
bool ok() const
Either the command hasn't run yet, or it completed successfully (CommandSuccess, not CommandUnsupport...
CVC4::Command::printsuccess
CommandPrintSuccess printsuccess
Definition command.h:203
CVC4::Command::Command
Command()
CVC4::Command::d_commandStatus
const CommandStatus * d_commandStatus
This field contains a command status if the command has been invoked, or NULL if it has not.
Definition command.h:194
CVC4::Command::isMuted
bool isMuted()
Determine whether this Command will print a success message.
Definition command.h:228
CVC4::Command::d_muted
bool d_muted
True if this command is "muted"—i.e., don't print "success" on successful execution.
Definition command.h:200
CVC4::Command::printResult
virtual void printResult(std::ostream &out, uint32_t verbosity=2) const
CVC4::CommentCommand
Definition command.h:805
CVC4::CommentCommand::~CommentCommand
~CommentCommand()
Definition command.h:809
CVC4::CommentCommand::CommentCommand
CommentCommand(std::string comment)
CVC4::CommentCommand::getComment
std::string getComment() const
CVC4::DatatypeDeclarationCommand
Definition command.h:713
CVC4::DatatypeDeclarationCommand::~DatatypeDeclarationCommand
~DatatypeDeclarationCommand()
Definition command.h:718
CVC4::DatatypeDeclarationCommand::getDatatypes
const std::vector< DatatypeType > & getDatatypes() const
CVC4::DatatypeDeclarationCommand::DatatypeDeclarationCommand
DatatypeDeclarationCommand(const std::vector< DatatypeType > &datatypes)
CVC4::DatatypeDeclarationCommand::DatatypeDeclarationCommand
DatatypeDeclarationCommand(const DatatypeType &datatype)
CVC4::DatatypeType
Class encapsulating the datatype type.
Definition type.h:615
CVC4::DeclarationDefinitionCommand
Definition command.h:340
CVC4::DeclarationDefinitionCommand::~DeclarationDefinitionCommand
~DeclarationDefinitionCommand()
Definition command.h:345
CVC4::DeclarationDefinitionCommand::DeclarationDefinitionCommand
DeclarationDefinitionCommand(const std::string &id)
CVC4::DeclarationDefinitionCommand::getSymbol
std::string getSymbol() const
CVC4::DeclarationDefinitionCommand::invoke
virtual void invoke(SmtEngine *smtEngine)=0
CVC4::DeclarationDefinitionCommand::d_symbol
std::string d_symbol
Definition command.h:342
CVC4::DeclarationSequence
Definition command.h:847
CVC4::DeclarationSequence::~DeclarationSequence
~DeclarationSequence()
Definition command.h:849
CVC4::DeclareFunctionCommand
Definition command.h:350
CVC4::DeclareFunctionCommand::d_printInModelSetByUser
bool d_printInModelSetByUser
Definition command.h:355
CVC4::DeclareFunctionCommand::DeclareFunctionCommand
DeclareFunctionCommand(const std::string &id, Expr func, Type type)
CVC4::DeclareFunctionCommand::getFunction
Expr getFunction() const
CVC4::DeclareFunctionCommand::d_type
Type d_type
Definition command.h:353
CVC4::DeclareFunctionCommand::~DeclareFunctionCommand
~DeclareFunctionCommand()
Definition command.h:358
CVC4::DeclareFunctionCommand::d_func
Expr d_func
Definition command.h:352
CVC4::DeclareFunctionCommand::d_printInModel
bool d_printInModel
Definition command.h:354
CVC4::DeclareTypeCommand
Definition command.h:370
CVC4::DeclareTypeCommand::d_arity
size_t d_arity
Definition command.h:372
CVC4::DeclareTypeCommand::~DeclareTypeCommand
~DeclareTypeCommand()
Definition command.h:376
CVC4::DeclareTypeCommand::getArity
size_t getArity() const
CVC4::DeclareTypeCommand::DeclareTypeCommand
DeclareTypeCommand(const std::string &id, size_t arity, Type t)
CVC4::DeclareTypeCommand::d_type
Type d_type
Definition command.h:373
CVC4::DefineFunctionCommand
Definition command.h:401
CVC4::DefineFunctionCommand::d_formula
Expr d_formula
Definition command.h:405
CVC4::DefineFunctionCommand::d_func
Expr d_func
Definition command.h:403
CVC4::DefineFunctionCommand::getFunction
Expr getFunction() const
CVC4::DefineFunctionCommand::DefineFunctionCommand
DefineFunctionCommand(const std::string &id, Expr func, const std::vector< Expr > &formals, Expr formula)
CVC4::DefineFunctionCommand::DefineFunctionCommand
DefineFunctionCommand(const std::string &id, Expr func, Expr formula)
CVC4::DefineFunctionCommand::~DefineFunctionCommand
~DefineFunctionCommand()
Definition command.h:410
CVC4::DefineFunctionCommand::d_formals
std::vector< Expr > d_formals
Definition command.h:404
CVC4::DefineNamedFunctionCommand
This differs from DefineFunctionCommand only in that it instructs the SmtEngine to "remember" this fu...
Definition command.h:425
CVC4::DefineNamedFunctionCommand::exportTo
Command * exportTo(ExprManager *exprManager, ExprManagerMapCollection &variableMap)
Maps this Command into one for a different ExprManager, using variableMap for the translation and ext...
CVC4::DefineNamedFunctionCommand::DefineNamedFunctionCommand
DefineNamedFunctionCommand(const std::string &id, Expr func, const std::vector< Expr > &formals, Expr formula)
CVC4::DefineNamedFunctionCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::DefineNamedFunctionCommand::clone
Command * clone() const
Clone this Command (make a shallow copy).
CVC4::DefineTypeCommand
Definition command.h:385
CVC4::DefineTypeCommand::d_type
Type d_type
Definition command.h:388
CVC4::DefineTypeCommand::d_params
std::vector< Type > d_params
Definition command.h:387
CVC4::DefineTypeCommand::getParameters
const std::vector< Type > & getParameters() const
CVC4::DefineTypeCommand::~DefineTypeCommand
~DefineTypeCommand()
Definition command.h:392
CVC4::DefineTypeCommand::DefineTypeCommand
DefineTypeCommand(const std::string &id, Type t)
CVC4::DefineTypeCommand::DefineTypeCommand
DefineTypeCommand(const std::string &id, const std::vector< Type > &params, Type t)
CVC4::EchoCommand
Definition command.h:295
CVC4::EchoCommand::EchoCommand
EchoCommand(std::string output="")
CVC4::EchoCommand::getOutput
std::string getOutput() const
CVC4::EchoCommand::d_output
std::string d_output
Definition command.h:297
CVC4::EmptyCommand
EmptyCommands are the residue of a command after the parser handles them (and there's nothing left to...
Definition command.h:282
CVC4::EmptyCommand::getName
std::string getName() const
CVC4::EmptyCommand::EmptyCommand
EmptyCommand(std::string name="")
CVC4::EmptyCommand::d_name
std::string d_name
Definition command.h:284
CVC4::ExpandDefinitionsCommand
Definition command.h:506
CVC4::ExpandDefinitionsCommand::~ExpandDefinitionsCommand
~ExpandDefinitionsCommand()
Definition command.h:512
CVC4::ExpandDefinitionsCommand::getTerm
Expr getTerm() const
CVC4::ExpandDefinitionsCommand::d_term
Expr d_term
Definition command.h:508
CVC4::ExpandDefinitionsCommand::d_result
Expr d_result
Definition command.h:509
CVC4::ExpandDefinitionsCommand::ExpandDefinitionsCommand
ExpandDefinitionsCommand(Expr term)
CVC4::ExprManager
Definition expr_manager.h:124
CVC4::Expr
Class encapsulating CVC4 expressions and methods for constructing new expressions.
Definition expr.h:227
CVC4::Expr::exportTo
Expr exportTo(ExprManager *exprManager, ExprManagerMapCollection &variableMap, uint32_t flags=0) const
Maps this Expr into one for a different ExprManager, using variableMap for the translation and extend...
CVC4::GetAssertionsCommand
Definition command.h:611
CVC4::GetAssertionsCommand::GetAssertionsCommand
GetAssertionsCommand()
CVC4::GetAssertionsCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::GetAssertionsCommand::getResult
std::string getResult() const
CVC4::GetAssertionsCommand::d_result
std::string d_result
Definition command.h:613
CVC4::GetAssignmentCommand
Definition command.h:539
CVC4::GetAssignmentCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::GetAssignmentCommand::getResult
SExpr getResult() const
CVC4::GetAssignmentCommand::GetAssignmentCommand
GetAssignmentCommand()
CVC4::GetAssignmentCommand::d_result
SExpr d_result
Definition command.h:541
CVC4::GetInfoCommand
Definition command.h:666
CVC4::GetInfoCommand::getFlag
std::string getFlag() const
CVC4::GetInfoCommand::d_result
std::string d_result
Definition command.h:669
CVC4::GetInfoCommand::GetInfoCommand
GetInfoCommand(std::string flag)
CVC4::GetInfoCommand::~GetInfoCommand
~GetInfoCommand()
Definition command.h:672
CVC4::GetInfoCommand::d_flag
std::string d_flag
Definition command.h:668
CVC4::GetInstantiationsCommand
Definition command.h:583
CVC4::GetInstantiationsCommand::GetInstantiationsCommand
GetInstantiationsCommand()
CVC4::GetInstantiationsCommand::d_smtEngine
SmtEngine * d_smtEngine
Definition command.h:586
CVC4::GetInstantiationsCommand::printResult
void printResult(std::ostream &out, uint32_t verbosity=2) const
CVC4::GetInstantiationsCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::GetModelCommand
Definition command.h:553
CVC4::GetModelCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::GetModelCommand::GetModelCommand
GetModelCommand()
CVC4::GetModelCommand::d_result
Model * d_result
Definition command.h:555
CVC4::GetModelCommand::d_smtEngine
SmtEngine * d_smtEngine
Definition command.h:556
CVC4::GetModelCommand::printResult
void printResult(std::ostream &out, uint32_t verbosity=2) const
CVC4::GetOptionCommand
Definition command.h:697
CVC4::GetOptionCommand::GetOptionCommand
GetOptionCommand(std::string flag)
CVC4::GetOptionCommand::d_result
std::string d_result
Definition command.h:700
CVC4::GetOptionCommand::~GetOptionCommand
~GetOptionCommand()
Definition command.h:703
CVC4::GetOptionCommand::d_flag
std::string d_flag
Definition command.h:699
CVC4::GetOptionCommand::getFlag
std::string getFlag() const
CVC4::GetProofCommand
Definition command.h:569
CVC4::GetProofCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::GetProofCommand::getResult
Proof * getResult() const
CVC4::GetProofCommand::d_result
Proof * d_result
Definition command.h:571
CVC4::GetProofCommand::GetProofCommand
GetProofCommand()
CVC4::GetUnsatCoreCommand
Definition command.h:598
CVC4::GetUnsatCoreCommand::GetUnsatCoreCommand
GetUnsatCoreCommand()
CVC4::GetUnsatCoreCommand::printResult
void printResult(std::ostream &out, uint32_t verbosity=2) const
CVC4::GetUnsatCoreCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::GetValueCommand
Definition command.h:522
CVC4::GetValueCommand::getTerms
const std::vector< Expr > & getTerms() const
CVC4::GetValueCommand::~GetValueCommand
~GetValueCommand()
Definition command.h:529
CVC4::GetValueCommand::d_result
Expr d_result
Definition command.h:525
CVC4::GetValueCommand::d_terms
std::vector< Expr > d_terms
Definition command.h:524
CVC4::GetValueCommand::GetValueCommand
GetValueCommand(const std::vector< Expr > &terms)
CVC4::GetValueCommand::GetValueCommand
GetValueCommand(Expr term)
CVC4::PopCommand
Definition command.h:331
CVC4::PopCommand::clone
Command * clone() const
Clone this Command (make a shallow copy).
CVC4::PopCommand::getCommandName
std::string getCommandName() const
CVC4::PopCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::PopCommand::~PopCommand
~PopCommand()
Definition command.h:333
CVC4::PopCommand::exportTo
Command * exportTo(ExprManager *exprManager, ExprManagerMapCollection &variableMap)
Maps this Command into one for a different ExprManager, using variableMap for the translation and ext...
CVC4::Proof
Definition proof.h:27
CVC4::PropagateRuleCommand
Definition command.h:758
CVC4::PropagateRuleCommand::d_triggers
Triggers d_triggers
Definition command.h:767
CVC4::PropagateRuleCommand::d_guards
VExpr d_guards
Definition command.h:764
CVC4::PropagateRuleCommand::getVars
const std::vector< Expr > & getVars() const
CVC4::PropagateRuleCommand::PropagateRuleCommand
PropagateRuleCommand(const std::vector< Expr > &vars, const std::vector< Expr > &guards, const std::vector< Expr > &heads, Expr body, const Triggers &d_triggers, bool d_deduction=false)
CVC4::PropagateRuleCommand::VExpr
std::vector< Expr > VExpr
Definition command.h:762
CVC4::PropagateRuleCommand::d_vars
VExpr d_vars
Definition command.h:763
CVC4::PropagateRuleCommand::Triggers
std::vector< std::vector< Expr > > Triggers
Definition command.h:760
CVC4::PropagateRuleCommand::d_heads
VExpr d_heads
Definition command.h:765
CVC4::PropagateRuleCommand::d_body
Expr d_body
Definition command.h:766
CVC4::PropagateRuleCommand::d_deduction
bool d_deduction
Definition command.h:768
CVC4::PushCommand
Definition command.h:322
CVC4::PushCommand::clone
Command * clone() const
Clone this Command (make a shallow copy).
CVC4::PushCommand::~PushCommand
~PushCommand()
Definition command.h:324
CVC4::PushCommand::getCommandName
std::string getCommandName() const
CVC4::PushCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::PushCommand::exportTo
Command * exportTo(ExprManager *exprManager, ExprManagerMapCollection &variableMap)
Maps this Command into one for a different ExprManager, using variableMap for the translation and ext...
CVC4::QueryCommand
Definition command.h:473
CVC4::QueryCommand::d_expr
Expr d_expr
Definition command.h:475
CVC4::QueryCommand::~QueryCommand
~QueryCommand()
Definition command.h:479
CVC4::QueryCommand::QueryCommand
QueryCommand(const Expr &e)
CVC4::QueryCommand::d_result
Result d_result
Definition command.h:476
CVC4::QueryCommand::getExpr
Expr getExpr() const
CVC4::QuitCommand
Definition command.h:795
CVC4::QuitCommand::clone
Command * clone() const
Clone this Command (make a shallow copy).
CVC4::QuitCommand::QuitCommand
QuitCommand()
CVC4::QuitCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::QuitCommand::getCommandName
std::string getCommandName() const
CVC4::QuitCommand::exportTo
Command * exportTo(ExprManager *exprManager, ExprManagerMapCollection &variableMap)
Maps this Command into one for a different ExprManager, using variableMap for the translation and ext...
CVC4::Result
Three-valued SMT result, with optional explanation.
Definition result.h:36
CVC4::RewriteRuleCommand
Definition command.h:727
CVC4::RewriteRuleCommand::RewriteRuleCommand
RewriteRuleCommand(const std::vector< Expr > &vars, const std::vector< Expr > &guards, Expr head, Expr body, const Triggers &d_triggers)
CVC4::RewriteRuleCommand::d_vars
VExpr d_vars
Definition command.h:732
CVC4::RewriteRuleCommand::d_triggers
Triggers d_triggers
Definition command.h:736
CVC4::RewriteRuleCommand::VExpr
std::vector< Expr > VExpr
Definition command.h:731
CVC4::RewriteRuleCommand::getVars
const std::vector< Expr > & getVars() const
CVC4::RewriteRuleCommand::d_body
Expr d_body
Definition command.h:735
CVC4::RewriteRuleCommand::~RewriteRuleCommand
~RewriteRuleCommand()
Definition command.h:746
CVC4::RewriteRuleCommand::d_head
Expr d_head
Definition command.h:734
CVC4::RewriteRuleCommand::d_guards
VExpr d_guards
Definition command.h:733
CVC4::RewriteRuleCommand::Triggers
std::vector< std::vector< Expr > > Triggers
Definition command.h:729
CVC4::RewriteRuleCommand::RewriteRuleCommand
RewriteRuleCommand(const std::vector< Expr > &vars, Expr head, Expr body)
CVC4::SExpr
A simple S-expression.
Definition sexpr.h:51
CVC4::SetBenchmarkLogicCommand
Definition command.h:638
CVC4::SetBenchmarkLogicCommand::getLogic
std::string getLogic() const
CVC4::SetBenchmarkLogicCommand::~SetBenchmarkLogicCommand
~SetBenchmarkLogicCommand()
Definition command.h:643
CVC4::SetBenchmarkLogicCommand::SetBenchmarkLogicCommand
SetBenchmarkLogicCommand(std::string logic)
CVC4::SetBenchmarkLogicCommand::d_logic
std::string d_logic
Definition command.h:640
CVC4::SetBenchmarkStatusCommand
Definition command.h:625
CVC4::SetBenchmarkStatusCommand::getStatus
BenchmarkStatus getStatus() const
CVC4::SetBenchmarkStatusCommand::~SetBenchmarkStatusCommand
~SetBenchmarkStatusCommand()
Definition command.h:630
CVC4::SetBenchmarkStatusCommand::d_status
BenchmarkStatus d_status
Definition command.h:627
CVC4::SetBenchmarkStatusCommand::SetBenchmarkStatusCommand
SetBenchmarkStatusCommand(BenchmarkStatus status)
CVC4::SetInfoCommand
Definition command.h:651
CVC4::SetInfoCommand::SetInfoCommand
SetInfoCommand(std::string flag, const SExpr &sexpr)
CVC4::SetInfoCommand::~SetInfoCommand
~SetInfoCommand()
Definition command.h:657
CVC4::SetInfoCommand::getFlag
std::string getFlag() const
CVC4::SetInfoCommand::d_flag
std::string d_flag
Definition command.h:653
CVC4::SetInfoCommand::d_sexpr
SExpr d_sexpr
Definition command.h:654
CVC4::SetOptionCommand
Definition command.h:682
CVC4::SetOptionCommand::d_sexpr
SExpr d_sexpr
Definition command.h:685
CVC4::SetOptionCommand::~SetOptionCommand
~SetOptionCommand()
Definition command.h:688
CVC4::SetOptionCommand::SetOptionCommand
SetOptionCommand(std::string flag, const SExpr &sexpr)
CVC4::SetOptionCommand::getFlag
std::string getFlag() const
CVC4::SetOptionCommand::d_flag
std::string d_flag
Definition command.h:684
CVC4::SetUserAttributeCommand
The command when an attribute is set by a user.
Definition command.h:438
CVC4::SetUserAttributeCommand::~SetUserAttributeCommand
~SetUserAttributeCommand()
Definition command.h:448
CVC4::SetUserAttributeCommand::exportTo
Command * exportTo(ExprManager *exprManager, ExprManagerMapCollection &variableMap)
Maps this Command into one for a different ExprManager, using variableMap for the translation and ext...
CVC4::SetUserAttributeCommand::getCommandName
std::string getCommandName() const
CVC4::SetUserAttributeCommand::clone
Command * clone() const
Clone this Command (make a shallow copy).
CVC4::SetUserAttributeCommand::d_attr
std::string d_attr
Definition command.h:440
CVC4::SetUserAttributeCommand::d_expr
Expr d_expr
Definition command.h:441
CVC4::SetUserAttributeCommand::SetUserAttributeCommand
SetUserAttributeCommand(const std::string &attr, Expr expr)
CVC4::SetUserAttributeCommand::invoke
void invoke(SmtEngine *smtEngine)
CVC4::SimplifyCommand
Definition command.h:490
CVC4::SimplifyCommand::d_term
Expr d_term
Definition command.h:492
CVC4::SimplifyCommand::getTerm
Expr getTerm() const
CVC4::SimplifyCommand::SimplifyCommand
SimplifyCommand(Expr term)
CVC4::SimplifyCommand::d_result
Expr d_result
Definition command.h:493
CVC4::SimplifyCommand::~SimplifyCommand
~SimplifyCommand()
Definition command.h:496
CVC4::SmtEngine
Definition smt_engine.h:113
CVC4::Type
Class encapsulating CVC4 expression types.
Definition type.h:89
CVC4::Type::exportTo
Type exportTo(ExprManager *exprManager, ExprManagerMapCollection &vmap) const
Exports this type into a different ExprManager.
cvc4_public.h
Macros that should be defined everywhere during the building of the libraries and driver binary,...
CVC4_PUBLIC
#define CVC4_PUBLIC
Definition cvc4_public.h:30
datatype.h
A class representing a Datatype definition.
expr.h
CVC4::language::output::Language
Language
Definition language.h:95
CVC4
Definition expr.h:106
CVC4::BenchmarkStatus
BenchmarkStatus
The status an SMT benchmark can have.
Definition command.h:52
CVC4::SMT_UNKNOWN
@ SMT_UNKNOWN
The status of the benchmark is unknown.
Definition command.h:58
CVC4::SMT_SATISFIABLE
@ SMT_SATISFIABLE
Benchmark is satisfiable.
Definition command.h:54
CVC4::SMT_UNSATISFIABLE
@ SMT_UNSATISFIABLE
Benchmark is unsatisfiable.
Definition command.h:56
CVC4::operator<<
std::ostream & operator<<(std::ostream &out, const TypeCheckingException &e)
std
STL namespace.
proof.h
[[ Add one-line brief description here ]]
result.h
Encapsulation of the result of a query.
sexpr.h
Simple representation of S-expressions.
CVC4::ExprManagerMapCollection
Definition variable_type_map.h:54
type.h
Interface for expression types.
variable_type_map.h
[[ Add one-line brief description here ]]