Statistics-printing problem, limited to certain benchmarks).
Mark some unlabeled header files "cvc4_private.h".
Other minor cleanup.
(this commit was certified error- and warning-free by the test-and-commit script.)
%include "util/integer.i"
%include "util/rational.i"
-%include "util/stats.i"
+%include "util/statistics.i"
%include "util/exception.i"
%include "util/language.i"
%include "options/options.i"
** Decision engine
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__DECISION__DECISION_ENGINE_H
#define __CVC4__DECISION__DECISION_ENGINE_H
** Decision strategy
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__DECISION__DECISION_STRATEGY_H
#define __CVC4__DECISION__DECISION_STRATEGY_H
class DecisionStrategy {
protected:
- DecisionEngine* d_decisionEngine;
+ DecisionEngine* d_decisionEngine;
public:
DecisionStrategy(DecisionEngine* de, context::Context *c) :
d_decisionEngine(de) {
** It needs access to the simplified but non-clausal formula.
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__DECISION__JUSTIFICATION_HEURISTIC
#define __CVC4__DECISION__JUSTIFICATION_HEURISTIC
** path from the root to the node go through a justified node.
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__DECISION__RELEVANCY
#define __CVC4__DECISION__RELEVANCY
s_totalTime.stop();
+ // Set the global executor pointer to NULL first. If we get a
+ // signal while dumping statistics, we don't want to try again.
+ pExecutor = NULL;
if(opts[options::statistics]) {
cmdExecutor.flushStatistics(*opts[options::err]);
}
- pExecutor = NULL;
return returnValue;
}
** \todo document this file
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__BASE_OPTIONS_HANDLERS_H
#define __CVC4__BASE_OPTIONS_HANDLERS_H
** Contains code for handling command-line options
**/
+#include "cvc4_public.h"
+
#ifndef __CVC4__OPTIONS__${module_id}_H
#define __CVC4__OPTIONS__${module_id}_H
#include "options/options.h"
${module_includes}
-#line 26 "${template}"
+#line 28 "${template}"
${module_optionholder_spec}
-#line 30 "${template}"
+#line 32 "${template}"
namespace CVC4 {
${module_decls}
-#line 38 "${template}"
+#line 40 "${template}"
}/* CVC4::options namespace */
${module_specializations}
-#line 44 "${template}"
+#line 46 "${template}"
namespace options {
${module_inlines}
-#line 50 "${template}"
+#line 52 "${template}"
}/* CVC4::options namespace */
expect_arg_long=required_argument
arg="$(echo "$option" | sed 's,[^=]*=\(.*\),\1,')"
option="$(echo "$option" | sed 's,--,,;s,=.*,,')"
- echo "warning: not yet handling long-option alias =$arg" >&2
else
expect_arg_long=no_argument
arg=
expect_arg=:
arg="$(echo "$option" | sed 's,[^=]*=,,')"
option="$(echo "$option" | sed 's,-\(.\)=.*,\1,')"
- echo "warning: not yet handling short-option alias =$arg" >&2
else
expect_arg=
arg=
**
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__CNF_PROOF_H
#define __CVC4__CNF_PROOF_H
** Proof manager
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__PROOF__PROOF_H
#define __CVC4__PROOF__PROOF_H
# define PROOF_ON() false
#endif /* CVC4_PROOF */
-
-
#endif /* __CVC4__PROOF__PROOF_H */
**
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__PROOF_MANAGER_H
#define __CVC4__PROOF_MANAGER_H
// forward declarations
namespace Minisat {
-class Solver;
+ class Solver;
}
namespace CVC4 {
+
namespace prop {
-class CnfStream;
+ class CnfStream;
}
+
class Proof;
class SatProof;
class CnfProof;
enum ProofFormat {
LFSC,
NATIVE
-};
+};/* enum ProofFormat */
class ProofManager {
SatProof* d_satProof;
static SatProof* getSatProof();
static CnfProof* getCnfProof();
-};
+};/* class ProofManager */
+
+}/* CVC4 namespace */
-} /* CVC4 namespace*/
#endif /* __CVC4__PROOF_MANAGER_H */
** Resolution proof
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__SAT__PROOF_H
#define __CVC4__SAT__PROOF_H
#include <ext/hash_map>
#include <ext/hash_set>
#include <sstream>
+
namespace Minisat {
-class Solver;
-typedef uint32_t CRef;
-}
+ class Solver;
+ typedef uint32_t CRef;
+}/* Minisat namespace */
#include "prop/minisat/core/SolverTypes.h"
#include "util/proof.h"
namespace std {
-using namespace __gnu_cxx;
-}
+ using namespace __gnu_cxx;
+}/* std namespace */
namespace CVC4 {
+
/**
* Helper debugging functions
- *
*/
void printDebug(::Minisat::Lit l);
void printDebug(::Minisat::Clause& c);
id(i),
sign(s)
{}
-};
+};/* struct ResStep */
typedef std::vector< ResStep > ResSteps;
typedef std::set < ::Minisat::Lit> LitSet;
ClauseId getStart() { return d_start; }
ResSteps& getSteps() { return d_steps; }
LitSet* getRedundant() { return d_redundantLits; }
-};
-
+};/* class ResChain */
typedef std::hash_map < ClauseId, ::Minisat::CRef > IdClauseMap;
typedef std::hash_map < ::Minisat::CRef, ClauseId > ClauseIdMap;
public:
ProofProxy(SatProof* pf);
void updateCRef(::Minisat::CRef oldref, ::Minisat::CRef newref);
-};
+};/* class ProofProxy */
class SatProof : public Proof {
protected:
void storeUnitResolution(::Minisat::Lit lit);
ProofProxy* getProxy() {return d_proxy; }
-};
+};/* class SatProof */
class LFSCSatProof: public SatProof {
private:
d_seenInput()
{}
virtual void toStream(std::ostream& out);
-};
+};/* class LFSCSatProof */
-}
+}/* CVC4 namespace */
-#endif
+#endif /* __CVC4__SAT__PROOF_H */
** \todo document this file
**/
+#include "cvc4_private.h"
+
#include "smt/smt_engine.h"
#include "util/tls.h"
#include "util/Assert.h"
** Algebraic solver.
**/
+#include "cvc4_private.h"
+
#pragma once
#include "theory/bv/bv_subtheory.h"
#pragma once
+#include "cvc4_private.h"
+
#include "theory/bv/bv_subtheory.h"
namespace CVC4 {
** \todo document this file
**/
+#include "cvc4_private.h"
+
#ifndef __CVC4__THEORY__REWRITERULES__THEORY_REWRITERULES_PARAMS_H
#define __CVC4__THEORY__REWRITERULES__THEORY_REWRITERULES_PARAMS_H
**
**/
+#include "cvc4_private.h"
-#ifndef __CVC4__REWRITERULES_H
-#define __CVC4__REWRITERULES_H
+#ifndef __CVC4__THEORY__REWRITERULES__THEORY_REWRITERULES_PREPROCESS_H
+#define __CVC4__THEORY__REWRITERULES__THEORY_REWRITERULES_PREPROCESS_H
#include <vector>
#include <ext/hash_set>
namespace theory {
namespace rewriterules {
-namespace rewriter{
+namespace rewriter {
typedef Node TMPNode;
typedef std::vector<Node> Subst;
/** match the node and add in Vars the found variables */
virtual Node run(TMPNode node) = 0;
virtual bool add(TMPNode pattern, TMPNode body, Subst & pvars, Subst & vars) = 0;
- };
+ };/* struct Step */
struct FinalStep : Step {
Node body;
subst.begin(), subst.end());
}
- };
+ };/* struct FinalStep */
typedef std::hash_map< Node, int, NodeHashFunction > PVars;
return false;
}
- };
+ };/* struct Pattern */
struct Args : Step {
void clear(){
d_matches.clear();
}
- };
+ };/* struct Args */
class RRPpRewrite : public uf::TheoryUF::PpRewrite {
Args d_pattern;
return d_pattern.add(pattern,body,pvars,vars);
}
-};
+};/* class RRPpRewrite */
-}
+}/* CVC4::theory::rewriterules::rewriter namespace */
-}
-}
-}
-#endif /* __CVC4__REWRITERULES_H */
+}/* CVC4::theory::rewriterules namespace */
+}/* CVC4::theory namespace */
+}/* CVC4 namespace */
+
+#endif /* __CVC4__THEORY__REWRITERULES__THEORY_REWRITERULES_PREPROCESS_H */
inline SExpr mkSExpr(const double& x) {
// roundabout way to get a Rational from a double
std::stringstream ss;
- ss << std::fixed << x;
+ ss << std::fixed << std::setprecision(8) << x;
return Rational::fromDecimal(ss.str());
}
SExpr getValue() const {
std::stringstream ss;
- ss << d_data;
+ ss << std::fixed << std::setprecision(8) << d_data;
return SExpr(Rational::fromDecimal(ss.str()));
}
SExpr getValue() const {
std::stringstream ss;
- ss << std::fixed << d_data;
+ ss << std::fixed << std::setprecision(8) << d_data;
return SExpr(Rational::fromDecimal(ss.str()));
}