working on Forking/Serializing a z3 Solver #209

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/api/api_solver.cpp

@@ -97,6 +97,19 @@ extern "C" {
         Z3_CATCH_RETURN(0);
     }
 
+    Z3_solver Z3_API Z3_solver_translate(Z3_context c, Z3_solver s, Z3_context target) {
+        Z3_TRY;
+        LOG_Z3_solver_translate(c, s, target);
+        RESET_ERROR_CODE();
+        params_ref const& p = to_solver(s)->m_params; 
+        Z3_solver_ref * sr = alloc(Z3_solver_ref, 0);
+        sr->m_solver = to_solver(s)->m_solver->translate(mk_c(target)->m(), p);
+        mk_c(target)->save_object(sr);
+        Z3_solver r = of_solver(sr);
+        RETURN_Z3(r);
+        Z3_CATCH_RETURN(0);
+    }
+
     Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s) {
         Z3_TRY;
         LOG_Z3_solver_get_help(c, s);

src/api/c++/z3++.h

@@ -1359,9 +1359,13 @@ namespace z3 {
             Z3_solver_inc_ref(ctx(), s);
         }
     public:
+        struct simple {};
+        struct translate {};
         solver(context & c):object(c) { init(Z3_mk_solver(c)); }
+        solver(context & c, simple):object(c) { init(Z3_mk_simple_solver(c)); }
         solver(context & c, Z3_solver s):object(c) { init(s); }
         solver(context & c, char const * logic):object(c) { init(Z3_mk_solver_for_logic(c, c.str_symbol(logic))); }
+        solver(context & c, solver const& src, translate): object(c) { init(Z3_solver_translate(src.ctx(), src, c)); }
         solver(solver const & s):object(s) { init(s.m_solver); }
         ~solver() { Z3_solver_dec_ref(ctx(), m_solver); }
         operator Z3_solver() const { return m_solver; }

src/api/python/z3.py

@@ -6084,6 +6084,19 @@ class Solver(Z3PPObject):
         """Return a formatted string with all added constraints."""
         return obj_to_string(self)
 
+    def translate(self, target):
+        """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`. 
+        
+        >>> c1 = Context()
+        >>> c2 = Context()
+	>>> s1 = Solver(ctx=c1)
+	>>> s2 = s1.translate(c2)
+        """
+        if __debug__:
+            _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
+	solver = Z3_solver_translate(self.ctx.ref(), self.solver, target.ref())
+        return Solver(solver, target)
+    
     def sexpr(self):
         """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
         

src/api/z3_api.h

@@ -7062,6 +7062,14 @@ END_MLAPI_EXCLUDE
     */
     Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t);
 
+    /**
+       \brief Copy a solver \c s from the context \c source to a the context \c target.
+
+       def_API('Z3_solver_translate', SOLVER, (_in(CONTEXT), _in(SOLVER), _in(CONTEXT)))
+    */
+    Z3_solver Z3_API Z3_solver_translate(Z3_context source, Z3_solver s, Z3_context target);
+    
+
     /**
        \brief Return a string describing all solver available parameters.