Use nullptr.

src/opt/maxres.cpp

@@ -243,7 +243,7 @@ public:
             case l_true: 
                 get_current_correction_set(cs);
                 if (cs.empty()) {
-                    m_found_feasible_optimum = m_model.get() != 0;
+                    m_found_feasible_optimum = m_model.get() != nullptr;
                     m_lower = m_upper;
                 }
                 else {
@@ -443,7 +443,7 @@ public:
         rational w = split_core(corr_set);
         cs_max_resolve(corr_set, w);       
         IF_VERBOSE(2, verbose_stream() << "(opt.maxres.correction-set " << corr_set.size() << ")\n";);
-        m_csmodel = 0;
+        m_csmodel = nullptr;
         m_correction_set_size = 0;
     }
 
@@ -488,7 +488,7 @@ public:
     }
     
     void process_unsat(exprs const& core) {
-        IF_VERBOSE(3, verbose_stream() << "(maxres cs model valid: " << (m_csmodel.get() != 0) << " cs size:" << m_correction_set_size << " core: " << core.size() << ")\n";);
+        IF_VERBOSE(3, verbose_stream() << "(maxres cs model valid: " << (m_csmodel.get() != nullptr) << " cs size:" << m_correction_set_size << " core: " << core.size() << ")\n";);
         expr_ref fml(m);
         remove_core(core);
         SASSERT(!core.empty());
@@ -524,7 +524,7 @@ public:
         if (m_c.sat_enabled()) {
             // SAT solver core extracts some model 
             // during unsat core computation.
-            mdl = 0;
+            mdl = nullptr;
             s().get_model(mdl);
         }
         else {
@@ -533,7 +533,7 @@ public:
         if (mdl.get() && w < m_upper) {
             update_assignment(mdl.get());
         }
-        return 0 != mdl.get();
+        return nullptr != mdl.get();
     }
 
     lbool minimize_core(exprs& core) {
@@ -820,7 +820,7 @@ public:
         m_found_feasible_optimum = false;
         m_last_index = 0;
         add_upper_bound_block();
-        m_csmodel = 0;
+        m_csmodel = nullptr;
         m_correction_set_size = 0;
         return l_true;
     }
@@ -844,7 +844,7 @@ public:
             smt_solver->assert_expr(s().get_assertion(i));
         }
         smt_solver->assert_expr(core);
-        lbool is_sat = smt_solver->check_sat(0, 0);
+        lbool is_sat = smt_solver->check_sat(0, nullptr);
         if (is_sat == l_true) {
             IF_VERBOSE(0, verbose_stream() << "not a core\n";);
         }        
@@ -864,7 +864,7 @@ public:
             }
             smt_solver->assert_expr(n);
         }
-        lbool is_sat = smt_solver->check_sat(0, 0);
+        lbool is_sat = smt_solver->check_sat(0, nullptr);
         if (is_sat == l_false) {
             IF_VERBOSE(0, verbose_stream() << "assignment is infeasible\n";);
         }

src/opt/maxsmt.cpp

@@ -116,7 +116,7 @@ namespace opt {
             return dynamic_cast<smt::theory_wmaxsat*>(th);
         }
         else {
-            return 0;
+            return nullptr;
         }
     }
 
@@ -228,7 +228,7 @@ namespace opt {
 
     lbool maxsmt::operator()() {
         lbool is_sat = l_undef;
-        m_msolver = 0;
+        m_msolver = nullptr;
         symbol const& maxsat_engine = m_c.maxsat_engine();
         IF_VERBOSE(1, verbose_stream() << "(maxsmt)\n";);
         TRACE("opt", tout << "maxsmt\n";

src/opt/opt_cmds.cpp

@@ -52,7 +52,7 @@ public:
     assert_soft_cmd(opt::context* opt):
         parametric_cmd("assert-soft"),
         m_idx(0),
-        m_formula(0),
+        m_formula(nullptr),
         m_opt(opt)
     {}
 
@@ -61,7 +61,7 @@ public:
 
     virtual void reset(cmd_context & ctx) { 
         m_idx = 0; 
-        m_formula = 0;
+        m_formula = nullptr;
     }
 
     virtual char const * get_usage() const { return "<formula> [:weight <rational-weight>] [:id <symbol>]"; }

src/opt/opt_cmds.h

@@ -23,7 +23,7 @@ Notes:
 
 class cmd_context;
 
-void install_opt_cmds(cmd_context & ctx, opt::context* opt = 0);
+void install_opt_cmds(cmd_context & ctx, opt::context* opt = nullptr);
 
 
 #endif

src/opt/opt_context.cpp

@@ -121,7 +121,7 @@ namespace opt {
         m_arith(m),
         m_bv(m),
         m_hard_constraints(m),
-        m_solver(0),
+        m_solver(nullptr),
         m_pareto1(false),
         m_box_index(UINT_MAX),
         m_optsmt(m),
@@ -274,7 +274,7 @@ namespace opt {
         s.assert_expr(m_hard_constraints);
         display_benchmark();
         IF_VERBOSE(1, verbose_stream() << "(optimize:check-sat)\n";);
-        lbool is_sat = s.check_sat(0,0);
+        lbool is_sat = s.check_sat(0,nullptr);
         TRACE("opt", tout << "initial search result: " << is_sat << "\n";
               s.display(tout););
         if (is_sat != l_false) {
@@ -435,7 +435,7 @@ namespace opt {
             return l_true;
         }
         if (m_box_index < m_objectives.size()) {
-            m_model = 0;
+            m_model = nullptr;
             ++m_box_index;
             return l_undef;
         }
@@ -553,7 +553,7 @@ namespace opt {
         }
         lbool is_sat = (*(m_pareto.get()))();
         if (is_sat != l_true) {
-            set_pareto(0);
+            set_pareto(nullptr);
         }
         if (is_sat == l_true) {
             yield();
@@ -925,7 +925,7 @@ namespace opt {
         func_decl* f = m.mk_fresh_func_decl(name,"", domain.size(), domain.c_ptr(), m.mk_bool_sort());
         m_objective_fns.insert(f, index);
         m_objective_refs.push_back(f);
-        m_objective_orig.insert(f, sz > 0 ? args[0] : 0);        
+        m_objective_orig.insert(f, sz > 0 ? args[0] : nullptr);
         return m.mk_app(f, sz, args);
     }
 
@@ -968,7 +968,7 @@ namespace opt {
                 }
                 mk_atomic(terms);
                 SASSERT(obj.m_id == id);
-                obj.m_term = orig_term?to_app(orig_term):0;
+                obj.m_term = orig_term?to_app(orig_term):nullptr;
                 obj.m_terms.reset();
                 obj.m_terms.append(terms);
                 obj.m_weights.reset();
@@ -1384,7 +1384,7 @@ namespace opt {
     }
 
     void context::clear_state() {
-        set_pareto(0);        
+        set_pareto(nullptr);
         m_box_index = UINT_MAX;
         m_model.reset();
     }

src/opt/opt_context.h

@@ -191,14 +191,14 @@ namespace opt {
         void get_box_model(model_ref& _m, unsigned index) override;
         void fix_model(model_ref& _m) override;
         void collect_statistics(statistics& stats) const override;
-        proof* get_proof() override { return 0; }
+        proof* get_proof() override { return nullptr; }
         void get_labels(svector<symbol> & r) override;
         void get_unsat_core(ptr_vector<expr> & r) override;
         std::string reason_unknown() const override;
         void set_reason_unknown(char const* msg) override { m_unknown = msg; }
 
         void display_assignment(std::ostream& out) override;
-        bool is_pareto() override { return m_pareto.get() != 0; }
+        bool is_pareto() override { return m_pareto.get() != nullptr; }
         void set_logic(symbol const& s) override { m_logic = s; }
         void set_clausal(bool f) { m_is_clausal = f; }
 
@@ -223,7 +223,7 @@ namespace opt {
 
         smt::context& smt_context() override { return m_opt_solver->get_context(); }
         filter_model_converter& fm() override { return m_fm; }
-        bool sat_enabled() const override { return 0 != m_sat_solver.get(); }
+        bool sat_enabled() const override { return nullptr != m_sat_solver.get(); }
         solver& get_solver() override;
         ast_manager& get_manager() const override { return this->m; }
         params_ref& params() override { return m_params; }

src/opt/opt_pareto.cpp

@@ -29,7 +29,7 @@ namespace opt {
    
     lbool gia_pareto::operator()() {
         expr_ref fml(m);
-        lbool is_sat = m_solver->check_sat(0, 0);
+        lbool is_sat = m_solver->check_sat(0, nullptr);
         if (is_sat == l_true) {
             {
                 solver::scoped_push _s(*m_solver.get());
@@ -45,7 +45,7 @@ namespace opt {
                                model_smt2_pp(verbose_stream() << "new model:\n", m, *mdl, 0););
                     // TBD: we can also use local search to tune solution coordinate-wise.
                     mk_dominates();
-                    is_sat = m_solver->check_sat(0, 0);
+                    is_sat = m_solver->check_sat(0, nullptr);
                 }
             }
             if (is_sat == l_undef) {
@@ -91,7 +91,7 @@ namespace opt {
 
     lbool oia_pareto::operator()() {
         solver::scoped_push _s(*m_solver.get());
-        lbool is_sat = m_solver->check_sat(0, 0);
+        lbool is_sat = m_solver->check_sat(0, nullptr);
         if (m.canceled()) {
             is_sat = l_undef;
         }

src/opt/opt_solver.cpp

@@ -69,7 +69,7 @@ namespace opt {
 
     solver* opt_solver::translate(ast_manager& m, params_ref const& p) {
         UNREACHABLE();
-        return 0;
+        return nullptr;
     }
 
     void opt_solver::collect_param_descrs(param_descrs & r) {
@@ -261,7 +261,7 @@ namespace opt {
         expr_ref ge = mk_ge(i, val);
         TRACE("opt", tout << ge << "\n";);
         assert_expr(ge);
-        lbool is_sat = m_context.check(0, 0);
+        lbool is_sat = m_context.check(0, nullptr);
         is_sat = adjust_result(is_sat);
         if (is_sat == l_true) {
             set_model(i);
@@ -316,7 +316,7 @@ namespace opt {
     void opt_solver::get_labels(svector<symbol> & r) {
         r.reset();
         buffer<symbol> tmp;
-        m_context.get_relevant_labels(0, tmp);
+        m_context.get_relevant_labels(nullptr, tmp);
         r.append(tmp.size(), tmp.c_ptr());
     }
         
@@ -340,7 +340,7 @@ namespace opt {
         m_objective_values.push_back(inf_eps(rational(-1), inf_rational()));
         m_objective_terms.push_back(term);
         m_valid_objectives.push_back(true);
-        m_models.push_back(0);
+        m_models.push_back(nullptr);
         return v;
     }
     

src/opt/optsmt.cpp

@@ -112,7 +112,7 @@ namespace opt {
         while (!m.canceled()) {
             SASSERT(delta_per_step.is_int());
             SASSERT(delta_per_step.is_pos());
-            is_sat = m_s->check_sat(0, 0);
+            is_sat = m_s->check_sat(0, nullptr);
             if (is_sat == l_true) {                
                 bound = update_lower();
                 if (!get_max_delta(lower, delta_index)) {
@@ -188,7 +188,7 @@ namespace opt {
         while (!m.canceled()) {
             SASSERT(delta_per_step.is_int());
             SASSERT(delta_per_step.is_pos());
-            is_sat = m_s->check_sat(0, 0);
+            is_sat = m_s->check_sat(0, nullptr);
             if (is_sat == l_true) {                
                 m_s->maximize_objective(obj_index, bound);
                 m_s->get_model(m_model);
@@ -416,7 +416,7 @@ namespace opt {
                 bounds.push_back(bound);
             }
             else {
-                bounds.push_back(0);
+                bounds.push_back(nullptr);
                 mid.push_back(inf_eps());
             }
         }
@@ -429,7 +429,7 @@ namespace opt {
                 case l_true:
                     IF_VERBOSE(2, verbose_stream() << "(optsmt lower bound for v" << m_vars[i] << " := " << m_upper[i] << ")\n";);
                     m_lower[i] = mid[i];
-                    th.enable_record_conflict(0);
+                    th.enable_record_conflict(nullptr);
                     m_s->assert_expr(update_lower());
                     break;
                 case l_false:
@@ -444,10 +444,10 @@ namespace opt {
                     }
                     break;
                 default:
-                    th.enable_record_conflict(0);
+                    th.enable_record_conflict(nullptr);
                     return l_undef;
                 }
-                th.enable_record_conflict(0);
+                th.enable_record_conflict(nullptr);
                 progress = true;
             }
         }
@@ -505,7 +505,7 @@ namespace opt {
             commit_assignment(i);
         }
         while (is_sat == l_true && !m.canceled()) {
-            is_sat = m_s->check_sat(0, 0); 
+            is_sat = m_s->check_sat(0, nullptr);
             if (is_sat != l_true) break;
             
             m_s->maximize_objective(obj_index, bound);
@@ -599,7 +599,7 @@ namespace opt {
         m_lower.push_back(inf_eps(rational(-1),inf_rational(0)));
         m_upper.push_back(inf_eps(rational(1), inf_rational(0)));
         m_lower_fmls.push_back(m.mk_true());
-        m_models.push_back(0);
+        m_models.push_back(nullptr);
         return m_objs.size()-1;
     }
 
@@ -615,7 +615,7 @@ namespace opt {
         m_vars.reset();
         m_model.reset();
         m_lower_fmls.reset();
-        m_s = 0;
+        m_s = nullptr;
     }
 }
 

src/opt/optsmt.h

@@ -41,7 +41,7 @@ namespace opt {
         sref_vector<model> m_models;
     public:
         optsmt(ast_manager& m): 
-            m(m), m_s(0), m_objs(m), m_lower_fmls(m) {}
+            m(m), m_s(nullptr), m_objs(m), m_lower_fmls(m) {}
 
         void setup(opt_solver& solver);
 

src/opt/sortmax.cpp

@@ -89,7 +89,7 @@ namespace opt {
             while (l_true == is_sat && first < out.size() && m_lower < m_upper) {
                 trace_bounds("sortmax");
                 s().assert_expr(out[first]);
-                is_sat = s().check_sat(0, 0);
+                is_sat = s().check_sat(0, nullptr);
                 TRACE("opt", tout << is_sat << "\n"; s().display(tout); tout << "\n";);
                 if (m.canceled()) {
                     is_sat = l_undef;

src/opt/wmax.cpp

@@ -80,7 +80,7 @@ namespace opt {
             while (!m.canceled() && m_lower < m_upper) {
                 //mk_assumptions(asms);
                 //is_sat = s().preferred_sat(asms, cores);
-                is_sat = s().check_sat(0, 0);
+                is_sat = s().check_sat(0, nullptr);
                 if (m.canceled()) {
                     is_sat = l_undef;
                 }
@@ -162,7 +162,7 @@ namespace opt {
         void verify_core(expr_ref_vector const& core) {
             s().push();
             s().assert_expr(core);
-            VERIFY(l_false == s().check_sat(0, 0));          
+            VERIFY(l_false == s().check_sat(0, nullptr));
             s().pop(1);
         }
 
@@ -216,7 +216,7 @@ namespace opt {
         rational remove_negations(smt::theory_wmaxsat& th, expr_ref_vector const& core, ptr_vector<expr>& keys, vector<rational>& weights) {
             rational min_weight(-1);
             for (unsigned i = 0; i < core.size(); ++i) {
-                expr* e = 0;
+                expr* e = nullptr;
                 VERIFY(m.is_not(core[i], e));
                 keys.push_back(m_keys[e]);
                 rational weight = m_weights[e];