merge

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

src/api/CMakeLists.txt

@@ -0,0 +1,74 @@
+set(generated_files
+  api_commands.cpp
+  api_log_macros.cpp
+  api_log_macros.h
+)
+
+# Sanity check
+foreach (gen_file ${generated_files})
+  if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${gen_file}")
+    message(FATAL_ERROR "\"${CMAKE_CURRENT_SOURCE_DIR}/${gen_file}\""
+            ${z3_polluted_tree_msg})
+  endif()
+endforeach()
+
+set(full_path_generated_files "")
+foreach (gen_file ${generated_files})
+  list(APPEND full_path_generated_files "${CMAKE_CURRENT_BINARY_DIR}/${gen_file}")
+endforeach()
+
+add_custom_command(OUTPUT ${generated_files}
+  COMMAND "${PYTHON_EXECUTABLE}"
+  "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+  ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+  "--api_output_dir"
+  "${CMAKE_CURRENT_BINARY_DIR}"
+  DEPENDS "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+          ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+          ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+          # FIXME: When update_api.py no longer uses ``mk_util`` drop this dependency
+          "${CMAKE_SOURCE_DIR}/scripts/mk_util.py"
+  COMMENT "Generating ${generated_files}"
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+  VERBATIM
+)
+
+z3_add_component(api
+  SOURCES
+    api_algebraic.cpp
+    api_arith.cpp
+    api_array.cpp
+    api_ast.cpp
+    api_ast_map.cpp
+    api_ast_vector.cpp
+    api_bv.cpp
+    api_config_params.cpp
+    api_context.cpp
+    api_datalog.cpp
+    api_datatype.cpp
+    api_fpa.cpp
+    api_goal.cpp
+    api_interp.cpp
+    api_log.cpp
+    api_model.cpp
+    api_numeral.cpp
+    api_opt.cpp
+    api_params.cpp
+    api_parsers.cpp
+    api_pb.cpp
+    api_polynomial.cpp
+    api_quant.cpp
+    api_rcf.cpp
+    api_seq.cpp
+    api_solver.cpp
+    api_stats.cpp
+    api_tactic.cpp
+    z3_replayer.cpp
+    ${full_path_generated_files}
+  COMPONENT_DEPENDENCIES
+    interp
+    opt
+    portfolio
+    realclosure
+    smtparser
+)

src/api/api_ast.cpp

@@ -558,6 +558,7 @@ extern "C" {
         Z3_TRY;
         LOG_Z3_get_sort(c, a);
         RESET_ERROR_CODE();
+        CHECK_IS_EXPR(a, 0);
         Z3_sort r = of_sort(mk_c(c)->m().get_sort(to_expr(a)));
         RETURN_Z3(r);
         Z3_CATCH_RETURN(0);
@@ -821,9 +822,13 @@ extern "C" {
         RESET_ERROR_CODE();
         std::ostringstream buffer;
         switch (mk_c(c)->get_print_mode()) {
-        case Z3_PRINT_SMTLIB_FULL:
-            buffer << mk_pp(to_ast(a), mk_c(c)->m());
+        case Z3_PRINT_SMTLIB_FULL: {
+            params_ref p;
+            p.set_uint("max_depth", 4294967295u);
+            p.set_uint("min_alias_size", 4294967295u);
+            buffer << mk_pp(to_ast(a), mk_c(c)->m(), p);
             break;
+        }
         case Z3_PRINT_LOW_LEVEL:
             buffer << mk_ll_pp(to_ast(a), mk_c(c)->m());
             break;
@@ -1066,7 +1071,7 @@ extern "C" {
             case OP_BIT2BOOL: return Z3_OP_BIT2BOOL;
             case OP_BSMUL_NO_OVFL: return Z3_OP_BSMUL_NO_OVFL;
             case OP_BUMUL_NO_OVFL: return Z3_OP_BUMUL_NO_OVFL;
-            case OP_BSMUL_NO_UDFL: return Z3_OP_BSMUL_NO_UDFL;                
+            case OP_BSMUL_NO_UDFL: return Z3_OP_BSMUL_NO_UDFL;
             case OP_BSDIV_I: return Z3_OP_BSDIV_I;
             case OP_BUDIV_I: return Z3_OP_BUDIV_I;
             case OP_BSREM_I: return Z3_OP_BSREM_I;

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

@@ -87,7 +87,7 @@ namespace z3 {
     inline std::ostream & operator<<(std::ostream & out, exception const & e) { out << e.msg(); return out; }
 
 #if !defined(Z3_THROW)
-#if __cpp_exceptions || _CPPUNWIND
+#if __cpp_exceptions || _CPPUNWIND || __EXCEPTIONS
 #define Z3_THROW(x) throw x
 #else
 #define Z3_THROW(x) {}
@@ -2796,6 +2796,6 @@ namespace z3 {
 
 /*@}*/
 /*@}*/
-
+#undef Z3_THROW
 #endif
 

src/api/dll/CMakeLists.txt

@@ -0,0 +1,13 @@
+set(api_dll_deps api extra_cmds sat)
+z3_add_component(api_dll
+  SOURCES
+    dll.cpp
+    "${CMAKE_CURRENT_BINARY_DIR}/gparams_register_modules.cpp"
+    "${CMAKE_CURRENT_BINARY_DIR}/install_tactic.cpp"
+    "${CMAKE_CURRENT_BINARY_DIR}/mem_initializer.cpp"
+  COMPONENT_DEPENDENCIES
+    ${api_dll_deps}
+)
+z3_add_install_tactic_rule(${api_dll_deps})
+z3_add_memory_initializer_rule(${api_dll_deps})
+z3_add_gparams_register_modules_rule(${api_dll_deps})

src/api/dotnet/AST.cs

@@ -14,7 +14,7 @@ Author:
     Christoph Wintersteiger (cwinter) 2012-03-16
 
 Notes:
-    
+
 --*/
 
 using System;
@@ -25,7 +25,7 @@ using System.Diagnostics.Contracts;
 namespace Microsoft.Z3
 {
     /// <summary>
-    /// The abstract syntax tree (AST) class. 
+    /// The abstract syntax tree (AST) class.
     /// </summary>
     [ContractVerification(true)]
     public class AST : Z3Object, IComparable
@@ -35,7 +35,7 @@ namespace Microsoft.Z3
         /// </summary>
         /// <param name="a">An AST</param>
         /// <param name="b">An AST</param>
-        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are from the same context 
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are from the same context
         /// and represent the same sort; false otherwise.</returns>
         public static bool operator ==(AST a, AST b)
         {
@@ -51,7 +51,7 @@ namespace Microsoft.Z3
         /// </summary>
         /// <param name="a">An AST</param>
         /// <param name="b">An AST</param>
-        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are not from the same context 
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are not from the same context
         /// or represent different sorts; false otherwise.</returns>
         public static bool operator !=(AST a, AST b)
         {
@@ -120,12 +120,12 @@ namespace Microsoft.Z3
             if (ReferenceEquals(Context, ctx))
                 return this;
             else
-                return new AST(ctx, Native.Z3_translate(Context.nCtx, NativeObject, ctx.nCtx));
+                return Create(ctx, Native.Z3_translate(Context.nCtx, NativeObject, ctx.nCtx));
         }
 
         /// <summary>
         /// The kind of the AST.
-        /// </summary>    
+        /// </summary>
         public Z3_ast_kind ASTKind
         {
             get { return (Z3_ast_kind)Native.Z3_get_ast_kind(Context.nCtx, NativeObject); }
@@ -224,10 +224,10 @@ namespace Microsoft.Z3
             {
                 Native.Z3_dec_ref(ctx.nCtx, obj);
             }
-        };        
+        };
 
         internal override void IncRef(IntPtr o)
-        {            
+        {
             // Console.WriteLine("AST IncRef()");
             if (Context == null || o == IntPtr.Zero)
                 return;

src/api/dotnet/CMakeLists.txt

@@ -0,0 +1,291 @@
+find_package(DotNetToolchain REQUIRED)
+
+# Configure AssemblyInfo.cs
+set(VER_MAJOR "${Z3_VERSION_MAJOR}")
+set(VER_MINOR "${Z3_VERSION_MINOR}")
+set(VER_BUILD "${Z3_VERSION_PATCH}")
+set(VER_REVISION "${Z3_VERSION_TWEAK}")
+set(Z3_DOTNET_ASSEMBLY_INFO_FILE "${CMAKE_CURRENT_BINARY_DIR}/Properties/AssemblyInfo.cs")
+configure_file("Properties/AssemblyInfo.cs.in" "${Z3_DOTNET_ASSEMBLY_INFO_FILE}" @ONLY)
+
+# Generate Native.cs
+set(Z3_DOTNET_NATIVE_FILE "${CMAKE_CURRENT_BINARY_DIR}/Native.cs")
+add_custom_command(OUTPUT "${Z3_DOTNET_NATIVE_FILE}"
+  COMMAND "${PYTHON_EXECUTABLE}"
+    "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "--dotnet-output-dir"
+    "${CMAKE_CURRENT_BINARY_DIR}"
+  DEPENDS
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+    ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+    # FIXME: When update_api.py no longer uses ``mk_util`` drop this dependency
+    "${CMAKE_SOURCE_DIR}/scripts/mk_util.py"
+  COMMENT "Generating ${Z3_DOTNET_NATIVE_FILE}"
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+)
+
+# Generate Enumerations.cs
+set(Z3_DOTNET_CONST_FILE "${CMAKE_CURRENT_BINARY_DIR}/Enumerations.cs")
+add_custom_command(OUTPUT "${Z3_DOTNET_CONST_FILE}"
+  COMMAND "${PYTHON_EXECUTABLE}"
+    "${CMAKE_SOURCE_DIR}/scripts/mk_consts_files.py"
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "--dotnet-output-dir"
+    "${CMAKE_CURRENT_BINARY_DIR}"
+  DEPENDS
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "${CMAKE_SOURCE_DIR}/scripts/mk_consts_files.py"
+    ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+  COMMENT "Generating ${Z3_DOTNET_CONST_FILE}"
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+)
+
+set(Z3_DOTNET_ASSEMBLY_SOURCES_IN_SRC_TREE
+	AlgebraicNum.cs
+	ApplyResult.cs
+	ArithExpr.cs
+	ArithSort.cs
+	ArrayExpr.cs
+	ArraySort.cs
+	AST.cs
+	ASTMap.cs
+	ASTVector.cs
+	BitVecExpr.cs
+	BitVecNum.cs
+	BitVecSort.cs
+	BoolExpr.cs
+	BoolSort.cs
+	Constructor.cs
+	ConstructorList.cs
+	Context.cs
+	DatatypeExpr.cs
+	DatatypeSort.cs
+	Deprecated.cs
+	EnumSort.cs
+	Expr.cs
+	FiniteDomainExpr.cs
+	FiniteDomainNum.cs
+	FiniteDomainSort.cs
+	Fixedpoint.cs
+	FPExpr.cs
+	FPNum.cs
+	FPRMExpr.cs
+	FPRMNum.cs
+	FPRMSort.cs
+	FPSort.cs
+	FuncDecl.cs
+	FuncInterp.cs
+	Global.cs
+	Goal.cs
+	IDecRefQueue.cs
+	InterpolationContext.cs
+	IntExpr.cs
+	IntNum.cs
+	IntSort.cs
+	IntSymbol.cs
+	ListSort.cs
+	Log.cs
+	Model.cs
+	Optimize.cs
+	ParamDescrs.cs
+	Params.cs
+	Pattern.cs
+	Probe.cs
+	Quantifier.cs
+	RatNum.cs
+	RealExpr.cs
+	RealSort.cs
+	ReExpr.cs
+	RelationSort.cs
+	ReSort.cs
+	SeqExpr.cs
+	SeqSort.cs
+	SetSort.cs
+	Solver.cs
+	Sort.cs
+	Statistics.cs
+	Status.cs
+	StringSymbol.cs
+	Symbol.cs
+	Tactic.cs
+	TupleSort.cs
+	UninterpretedSort.cs
+	Version.cs
+	Z3Exception.cs
+	Z3Object.cs
+)
+
+set(Z3_DOTNET_ASSEMBLY_SOURCES "")
+# Make paths to source files absolute
+foreach (csfile ${Z3_DOTNET_ASSEMBLY_SOURCES_IN_SRC_TREE})
+  list(APPEND Z3_DOTNET_ASSEMBLY_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/${csfile}")
+endforeach()
+
+# Add generated files
+list(APPEND Z3_DOTNET_ASSEMBLY_SOURCES
+  "${Z3_DOTNET_CONST_FILE}"
+  "${Z3_DOTNET_NATIVE_FILE}"
+  "${Z3_DOTNET_ASSEMBLY_INFO_FILE}"
+)
+
+# ``csc.exe`` doesn't like UNIX style paths so convert them
+# if necessary first to native paths.
+set(Z3_DOTNET_ASSEMBLY_SOURCES_NATIVE_PATH "")
+foreach (csfile_path ${Z3_DOTNET_ASSEMBLY_SOURCES})
+  file(TO_NATIVE_PATH "${csfile_path}" csfile_path_native)
+  list(APPEND Z3_DOTNET_ASSEMBLY_SOURCES_NATIVE_PATH "${csfile_path_native}")
+endforeach()
+
+set(CSC_FLAGS "")
+if (DOTNET_TOOLCHAIN_IS_WINDOWS)
+  # FIXME: Why use these flags?
+  # Note these flags have been copied from the Python build system.
+  list(APPEND CSC_FLAGS
+    "/noconfig"
+    "/nostdlib+"
+    "/reference:mscorlib.dll"
+  )
+  # FIXME: This flag only works when the working directory of csc.exe is
+  # the directory containing the ``libz3`` target. I can't get this to work
+  # correctly with multi-configuration generators (i.e. Visual Studio) so
+  # just don't set the flag for now.
+  #list(APPEND CSC_FLAGS "/linkresource:$<TARGET_FILE_NAME:libz3>")
+elseif (DOTNET_TOOLCHAIN_IS_MONO)
+  # We need to give the assembly a strong name so that it can be installed
+  # into the GAC.
+  list(APPEND CSC_FLAGS
+    "/keyfile:${CMAKE_CURRENT_SOURCE_DIR}/Microsoft.Z3.snk"
+  )
+else()
+  message(FATAL_ERROR "Unknown .NET toolchain")
+endif()
+
+# Common flags
+list(APPEND CSC_FLAGS
+  "/unsafe+"
+  "/nowarn:1701,1702"
+  "/errorreport:prompt"
+  "/warn:4"
+  "/reference:System.Core.dll"
+  "/reference:System.dll"
+  "/reference:System.Numerics.dll"
+  "/filealign:512" # Why?
+  "/target:library"
+)
+
+# Set the build type flags. The build type for the assembly roughly corresponds
+# with the native code build type.
+list(APPEND CSC_FLAGS
+  # Debug flags, expands to nothing if we aren't doing a debug build
+  "$<$<CONFIG:Debug>:/debug+>"
+  "$<$<CONFIG:Debug>:/debug:full>"
+  "$<$<CONFIG:Debug>:/optimize->"
+  # This has to be quoted otherwise the ``;`` is interpreted as a command separator
+  "$<$<CONFIG:Debug>:\"/define:DEBUG$<SEMICOLON>TRACE\">"
+  # Release flags, expands to nothing if we are doing a debug build
+  "$<$<NOT:$<CONFIG:Debug>>:/optimize+>"
+)
+
+# Mono's gacutil crashes when trying to install an assembly if we set the
+# platform in some cases, so only set it on Windows.  This bug has been
+# reported at https://bugzilla.xamarin.com/show_bug.cgi?id=39955 . However mono
+# ignores the platform of an assembly when running it (
+# http://lists.ximian.com/pipermail/mono-devel-list/2015-November/043370.html )
+# so this shouldn't matter in practice.
+if (DOTNET_TOOLCHAIN_IS_WINDOWS)
+  # Set platform for assembly
+  if ("${TARGET_ARCHITECTURE}" STREQUAL "x86_64")
+    list(APPEND CSC_FLAGS "/platform:x64")
+  elseif ("${TARGET_ARCHITECTURE}" STREQUAL "i686")
+    list(APPEND CSC_FLAGS "/platform:x86")
+  endif()
+endif()
+
+# FIXME: Ideally we should emit files into a configuration specific directory
+# when using multi-configuration generators so that the files generated by each
+# configuration don't clobber each other. Unfortunately the ``get_property()``
+# command only works correctly for single configuration generators so we can't
+# use it. We also can't use ``$<TARGET_FILE_DIR:libz3>`` because the ``OUTPUT``
+# argument to ``add_custom_commands()`` won't accept it.
+# See http://public.kitware.com/pipermail/cmake/2016-March/063101.html
+#
+# For now just output file to the root binary directory like the Python build
+# system does and emit a warning when appropriate.
+if (DEFINED CMAKE_CONFIGURATION_TYPES)
+  # Multi-configuration build (e.g. Visual Studio and Xcode).
+  message(WARNING "You are using a multi-configuration generator. The build rules for"
+    " the \".NET\" bindings currently do not emit files per configuration so previously"
+    " generated files for other configurations will be overwritten.")
+endif()
+
+set(Z3_DOTNET_ASSEMBLY_OUTPUT_DIR "${CMAKE_BINARY_DIR}")
+set(Z3_DOTNET_ASSEMBLY_NAME "Microsoft.Z3.dll")
+set(Z3_DOTNET_ASSEMBLY_DLL "${Z3_DOTNET_ASSEMBLY_OUTPUT_DIR}/${Z3_DOTNET_ASSEMBLY_NAME}")
+# csc.exe doesn't work with UNIX style paths so convert to native path
+file(TO_NATIVE_PATH "${Z3_DOTNET_ASSEMBLY_DLL}" Z3_DOTNET_ASSEMBLY_DLL_NATIVE_PATH)
+set(Z3_DOTNET_ASSEMBLY_DLL_DOC "${Z3_DOTNET_ASSEMBLY_OUTPUT_DIR}/Microsoft.Z3.xml")
+file(TO_NATIVE_PATH "${Z3_DOTNET_ASSEMBLY_DLL_DOC}" Z3_DOTNET_ASSEMBLY_DLL_DOC_NATIVE_PATH)
+add_custom_command(OUTPUT "${Z3_DOTNET_ASSEMBLY_DLL}" "${Z3_DOTNET_ASSEMBLY_DLL_DOC}"
+  COMMAND
+    "${DOTNET_CSC_EXECUTABLE}"
+    ${CSC_FLAGS}
+    "/out:${Z3_DOTNET_ASSEMBLY_DLL_NATIVE_PATH}"
+    "/doc:${Z3_DOTNET_ASSEMBLY_DLL_DOC_NATIVE_PATH}"
+    ${Z3_DOTNET_ASSEMBLY_SOURCES_NATIVE_PATH}
+  DEPENDS
+    ${Z3_DOTNET_ASSEMBLY_SOURCES}
+    libz3
+  WORKING_DIRECTORY "${Z3_DOTNET_ASSEMBLY_OUTPUT_DIR}"
+  COMMENT "Building \"${Z3_DOTNET_ASSEMBLY_DLL}\""
+)
+
+# Convenient top-level target
+add_custom_target(build_z3_dotnet_bindings
+  ALL
+  DEPENDS
+    "${Z3_DOTNET_ASSEMBLY_DLL}"
+)
+
+###############################################################################
+# Install
+###############################################################################
+option(INSTALL_DOTNET_BINDINGS "Install .NET bindings when invoking install target" ON)
+set(GAC_PKG_NAME "Microsoft.Z3.Sharp")
+set(PREFIX "${CMAKE_INSTALL_PREFIX}")
+set(VERSION "${Z3_VERSION}")
+set(Z3_DOTNET_PKGCONFIG_FILE "${CMAKE_CURRENT_BINARY_DIR}/Microsoft.Z3.Sharp.pc")
+configure_file("Microsoft.Z3.Sharp.pc.in" "${Z3_DOTNET_PKGCONFIG_FILE}" @ONLY)
+
+if (DOTNET_TOOLCHAIN_IS_MONO)
+  message(STATUS "Emitting install rules for .NET bindings")
+  # Install pkgconfig file for the assembly. This is needed by Monodevelop
+  # to find the assembly
+  install(FILES "${Z3_DOTNET_PKGCONFIG_FILE}" DESTINATION "${CMAKE_INSTALL_PKGCONFIGDIR}")
+
+  # Configure the install and uninstall scripts.
+  # Note: If multi-configuration generator support is ever fixed then these
+  # scripts will be broken.
+  configure_file(cmake_install_gac.cmake.in cmake_install_gac.cmake @ONLY)
+  configure_file(cmake_uninstall_gac.cmake.in cmake_uninstall_gac.cmake @ONLY)
+
+  # Tell CMake to Invoke a script to install assembly to the GAC during install
+  install(SCRIPT "${CMAKE_CURRENT_BINARY_DIR}/cmake_install_gac.cmake")
+
+  # Add custom target to uninstall the assembly from the GAC
+  add_custom_target(remove_dotnet_dll_from_gac
+    COMMAND "${CMAKE_COMMAND}" "-P" "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall_gac.cmake"
+    COMMENT "Uninstalling ${Z3_DOTNET_ASSEMBLY_NAME} from the GAC"
+    ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+  )
+  add_dependencies(uninstall remove_dotnet_dll_from_gac)
+
+elseif(DOTNET_TOOLCHAIN_IS_WINDOWS)
+  # Don't install Z3_DOTNET_ASSEMBLY_DLL into the gac. Instead just copy into
+  # installation directory.
+  install(FILES "${Z3_DOTNET_ASSEMBLY_DLL}" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+  install(FILES "${Z3_DOTNET_ASSEMBLY_DLL_DOC}" DESTINATION "${CMAKE_INSTALL_LIBDIR}")
+else()
+  message(FATAL_ERROR "Unknown .NET toolchain")
+endif()

src/api/dotnet/Expr.cs

@@ -163,13 +163,7 @@ namespace Microsoft.Z3
         /// <returns>A copy of the term which is associated with <paramref name="ctx"/></returns>
         new public Expr Translate(Context ctx)
         {
-            Contract.Requires(ctx != null);
-            Contract.Ensures(Contract.Result<Expr>() != null);
-
-            if (ReferenceEquals(Context, ctx))
-                return this;
-            else
-                return Expr.Create(ctx, Native.Z3_translate(Context.nCtx, NativeObject, ctx.nCtx));
+            return (Expr)base.Translate(ctx);
         }
 
         /// <summary>
@@ -809,7 +803,62 @@ namespace Microsoft.Z3
         /// Retrieve string corresponding to string constant.
         /// </summary>
         /// <remarks>the expression should be a string constant, (IsString should be true).</remarks>
-        public string String { get { return Native.Z3_get_string(Context.nCtx, NativeObject); } }        
+        public string String { get { return Native.Z3_get_string(Context.nCtx, NativeObject); } }
+
+        /// <summary>
+        /// Check whether expression is a concatentation.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsConcat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_CONCAT; } }
+
+        /// <summary>
+        /// Check whether expression is a prefix.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsPrefix { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_PREFIX; } }
+
+        /// <summary>
+        /// Check whether expression is a suffix.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsSuffix { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_SUFFIX; } }
+
+        /// <summary>
+        /// Check whether expression is a contains.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsContains { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_CONTAINS; } }
+
+        /// <summary>
+        /// Check whether expression is an extract.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsExtract { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_EXTRACT; } }
+
+        /// <summary>
+        /// Check whether expression is a replace.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsReplace { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_REPLACE; } }
+
+        /// <summary>
+        /// Check whether expression is an at.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsAt { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_AT; } }
+
+        /// <summary>
+        /// Check whether expression is a sequence length.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsLength { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_LENGTH; } }
+
+        /// <summary>
+        /// Check whether expression is a sequence index.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+	public bool IsIndex { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_INDEX; } }
+
 
         #endregion
 

src/api/dotnet/FuncDecl.cs

@@ -14,7 +14,7 @@ Author:
     Christoph Wintersteiger (cwinter) 2012-03-16
 
 Notes:
-    
+
 --*/
 
 using System;
@@ -23,7 +23,7 @@ using System.Diagnostics.Contracts;
 namespace Microsoft.Z3
 {
     /// <summary>
-    /// Function declarations. 
+    /// Function declarations.
     /// </summary>
     [ContractVerification(true)]
     public class FuncDecl : AST
@@ -62,7 +62,7 @@ namespace Microsoft.Z3
 
         /// <summary>
         /// A hash code.
-        /// </summary>    
+        /// </summary>
         public override int GetHashCode()
         {
             return base.GetHashCode();
@@ -205,7 +205,7 @@ namespace Microsoft.Z3
         }
 
         /// <summary>
-        /// Function declarations can have Parameters associated with them. 
+        /// Function declarations can have Parameters associated with them.
         /// </summary>
         public class Parameter
         {
@@ -315,6 +315,17 @@ namespace Microsoft.Z3
 #endif
         #endregion
 
+        /// <summary>
+        /// Translates (copies) the function declaration to the Context <paramref name="ctx"/>.
+        /// </summary>
+        /// <param name="ctx">A context</param>
+        /// <returns>A copy of the function declaration which is associated with <paramref name="ctx"/></returns>
+        new public FuncDecl Translate(Context ctx)
+        {
+            return (FuncDecl) base.Translate(ctx);
+        }
+
+
         /// <summary>
         /// Create expression that applies function to arguments.
         /// </summary>
@@ -342,6 +353,5 @@ namespace Microsoft.Z3
             Context.CheckContextMatch<Expr>(args);
             return Expr.Create(Context, this, args);
         }
-
     }
 }

src/api/dotnet/Quantifier.cs

@@ -14,7 +14,7 @@ Author:
     Christoph Wintersteiger (cwinter) 2012-03-19
 
 Notes:
-    
+
 --*/
 
 using System;
@@ -157,6 +157,16 @@ namespace Microsoft.Z3
             }
         }
 
+        /// <summary>
+        /// Translates (copies) the quantifier to the Context <paramref name="ctx"/>.
+        /// </summary>
+        /// <param name="ctx">A context</param>
+        /// <returns>A copy of the quantifier which is associated with <paramref name="ctx"/></returns>
+        new public Quantifier Translate(Context ctx)
+        {
+            return (Quantifier)base.Translate(ctx);
+        }
+
         #region Internal
         [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug
         internal Quantifier(Context ctx, bool isForall, Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null)

src/api/dotnet/Sort.cs

@@ -14,7 +14,7 @@ Author:
     Christoph Wintersteiger (cwinter) 2012-03-15
 
 Notes:
-    
+
 --*/
 
 using System;
@@ -33,7 +33,7 @@ namespace Microsoft.Z3
         /// </summary>
         /// <param name="a">A Sort</param>
         /// <param name="b">A Sort</param>
-        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are from the same context 
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are from the same context
         /// and represent the same sort; false otherwise.</returns>
         public static bool operator ==(Sort a, Sort b)
         {
@@ -49,7 +49,7 @@ namespace Microsoft.Z3
         /// </summary>
         /// <param name="a">A Sort</param>
         /// <param name="b">A Sort</param>
-        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are not from the same context 
+        /// <returns>True if <paramref name="a"/> and <paramref name="b"/> are not from the same context
         /// or represent different sorts; false otherwise.</returns>
         public static bool operator !=(Sort a, Sort b)
         {
@@ -113,10 +113,20 @@ namespace Microsoft.Z3
             return Native.Z3_sort_to_string(Context.nCtx, NativeObject);
         }
 
+        /// <summary>
+        /// Translates (copies) the sort to the Context <paramref name="ctx"/>.
+        /// </summary>
+        /// <param name="ctx">A context</param>
+        /// <returns>A copy of the sort which is associated with <paramref name="ctx"/></returns>
+        new public Sort Translate(Context ctx)
+        {
+            return (Sort)base.Translate(ctx);
+        }
+
         #region Internal
         /// <summary>
         /// Sort constructor
-        /// </summary>        
+        /// </summary>
         internal Sort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); }
 
 #if DEBUG
@@ -154,5 +164,5 @@ namespace Microsoft.Z3
             }
         }
         #endregion
-    }    
+    }
 }

src/api/dotnet/cmake_install_gac.cmake.in

@@ -0,0 +1,18 @@
+# Install assembly to the GAC
+set(GAC_ROOT "$ENV{DESTDIR}@CMAKE_INSTALL_FULL_LIBDIR@")
+execute_process(COMMAND
+  "@DOTNET_GACUTIL_EXECUTABLE@"
+  "-i"
+  "@Z3_DOTNET_ASSEMBLY_DLL@"
+  "-f"
+  "-package" "@GAC_PKG_NAME@"
+  "-root" "${GAC_ROOT}"
+  WORKING_DIRECTORY "@CMAKE_CURRENT_BINARY_DIR@"
+  RESULT_VARIABLE gacutil_exit_code
+)
+
+if ("${gacutil_exit_code}" EQUAL 0)
+  message(STATUS "Installed \"@Z3_DOTNET_ASSEMBLY_DLL@\" to the GAC")
+else()
+  message(FATAL_ERROR "Failed to install \"@Z3_DOTNET_ASSEMBLY_DLL@\" to the GAC")
+endif()

src/api/dotnet/cmake_uninstall_gac.cmake.in

@@ -0,0 +1,20 @@
+# Uninstall assembly from the GAC
+set(GAC_ROOT "$ENV{DESTDIR}@CMAKE_INSTALL_FULL_LIBDIR@")
+execute_process(COMMAND
+  "@DOTNET_GACUTIL_EXECUTABLE@"
+  # Note ``-us`` takes assembly file name rather than
+  # ``-u`` which takes an assembly display name
+  "-us"
+  "@Z3_DOTNET_ASSEMBLY_NAME@"
+  "-f"
+  "-package" "@GAC_PKG_NAME@"
+  "-root" "${GAC_ROOT}"
+  WORKING_DIRECTORY "@CMAKE_CURRENT_BINARY_DIR@"
+  RESULT_VARIABLE gacutil_exit_code
+)
+
+if ("${gacutil_exit_code}" EQUAL 0)
+  message(STATUS "Uninstalled \"@Z3_DOTNET_ASSEMBLY_NAME@\" from the GAC")
+else()
+  message(FATAL_ERROR "Failed to uninstall \"@Z3_DOTNET_ASSEMBLY_NAME@\" from the GAC")
+endif()

src/api/java/AST.java

@@ -87,12 +87,10 @@ public class AST extends Z3Object implements Comparable<AST>
      **/
     public AST translate(Context ctx)
     {
-
         if (getContext() == ctx) {
             return this;
         } else {
-            return new AST(ctx, Native.translate(getContext().nCtx(),
-                getNativeObject(), ctx.nCtx()));
+            return create(ctx, Native.translate(getContext().nCtx(), getNativeObject(), ctx.nCtx()));
         }
     }
 

src/api/java/CMakeLists.txt

@@ -0,0 +1,236 @@
+find_package(Java REQUIRED)
+find_package(JNI REQUIRED)
+include(UseJava)
+
+# Sanity check for dirty source tree
+foreach (file_name "enumerations" "Native.cpp" "Native.java")
+  if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${file_name}")
+    message(FATAL_ERROR "\"${CMAKE_CURRENT_SOURCE_DIR}/${file_name}\""
+            ${z3_polluted_tree_msg})
+  endif()
+endforeach()
+
+set(Z3_JAVA_PACKAGE_NAME "com.microsoft.z3")
+
+# Rule to generate ``Native.java`` and ``Native.cpp``
+set(Z3_JAVA_NATIVE_JAVA "${CMAKE_CURRENT_BINARY_DIR}/Native.java")
+set(Z3_JAVA_NATIVE_CPP "${CMAKE_CURRENT_BINARY_DIR}/Native.cpp")
+add_custom_command(OUTPUT "${Z3_JAVA_NATIVE_JAVA}" "${Z3_JAVA_NATIVE_CPP}"
+  COMMAND "${PYTHON_EXECUTABLE}"
+    "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "--java-output-dir"
+    "${CMAKE_CURRENT_BINARY_DIR}"
+    "--java-package-name"
+    ${Z3_JAVA_PACKAGE_NAME}
+  DEPENDS
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+    ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+    # FIXME: When update_api.py no longer uses ``mk_util`` drop this dependency
+    "${CMAKE_SOURCE_DIR}/scripts/mk_util.py"
+  COMMENT "Generating \"${Z3_JAVA_NATIVE_JAVA}\" and \"${Z3_JAVA_NATIVE_CPP}\""
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+)
+
+# Add rule to build native code that provides a bridge between
+# ``Native.java`` and libz3's interfac3.
+add_library(z3java SHARED ${Z3_JAVA_NATIVE_CPP})
+target_link_libraries(z3java PRIVATE libz3)
+# FIXME:
+# Not sure if using all the flags used by the Z3 components is really necessary
+# here.  At the bare minimum setting _AMD64_ depending on the target is
+# necessary but seeing as the Python build system uses all the flags used for building
+# Z3's components to build ``Native.cpp`` lets do the same for now.
+target_compile_options(z3java PRIVATE ${Z3_COMPONENT_CXX_FLAGS})
+target_compile_definitions(z3java PRIVATE ${Z3_COMPONENT_CXX_DEFINES})
+target_include_directories(z3java PRIVATE
+  "${CMAKE_SOURCE_DIR}/src/api"
+  "${CMAKE_BINARY_DIR}/src/api"
+  ${JNI_INCLUDE_DIRS}
+)
+# FIXME: Should this library have SONAME and VERSION set?
+
+# This prevents CMake from automatically defining ``z3java_EXPORTS``
+set_property(TARGET z3java PROPERTY DEFINE_SYMBOL "")
+
+# Rule to generate the ``com.microsoft.z3.enumerations`` package
+# FIXME: This list of files is fragile
+set(Z3_JAVA_ENUMERATION_PACKAGE_FILES
+  Z3_ast_kind.java
+  Z3_ast_print_mode.java
+  Z3_decl_kind.java
+  Z3_error_code.java
+  Z3_goal_prec.java
+  Z3_lbool.java
+  Z3_param_kind.java
+  Z3_parameter_kind.java
+  Z3_sort_kind.java
+  Z3_symbol_kind.java
+)
+set(Z3_JAVA_ENUMERATION_PACKAGE_FILES_FULL_PATH "")
+foreach (enum_file ${Z3_JAVA_ENUMERATION_PACKAGE_FILES})
+  list(APPEND Z3_JAVA_ENUMERATION_PACKAGE_FILES_FULL_PATH
+    "${CMAKE_CURRENT_BINARY_DIR}/enumerations/${enum_file}"
+  )
+endforeach()
+add_custom_command(OUTPUT ${Z3_JAVA_ENUMERATION_PACKAGE_FILES_FULL_PATH}
+  COMMAND "${PYTHON_EXECUTABLE}"
+    "${CMAKE_SOURCE_DIR}/scripts/mk_consts_files.py"
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "--java-output-dir"
+    "${CMAKE_CURRENT_BINARY_DIR}"
+    "--java-package-name"
+    ${Z3_JAVA_PACKAGE_NAME}
+  DEPENDS
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "${CMAKE_SOURCE_DIR}/scripts/mk_consts_files.py"
+    ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+  COMMENT "Generating ${Z3_JAVA_PACKAGE_NAME}.enumerations package"
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+)
+
+set(Z3_JAVA_JAR_SOURCE_FILES
+  AlgebraicNum.java
+  ApplyResultDecRefQueue.java
+  ApplyResult.java
+  ArithExpr.java
+  ArithSort.java
+  ArrayExpr.java
+  ArraySort.java
+  ASTDecRefQueue.java
+  AST.java
+  AstMapDecRefQueue.java
+  ASTMap.java
+  AstVectorDecRefQueue.java
+  ASTVector.java
+  BitVecExpr.java
+  BitVecNum.java
+  BitVecSort.java
+  BoolExpr.java
+  BoolSort.java
+  ConstructorDecRefQueue.java
+  Constructor.java
+  ConstructorListDecRefQueue.java
+  ConstructorList.java
+  Context.java
+  DatatypeExpr.java
+  DatatypeSort.java
+  EnumSort.java
+  Expr.java
+  FiniteDomainExpr.java
+  FiniteDomainNum.java
+  FiniteDomainSort.java
+  FixedpointDecRefQueue.java
+  Fixedpoint.java
+  FPExpr.java
+  FPNum.java
+  FPRMExpr.java
+  FPRMNum.java
+  FPRMSort.java
+  FPSort.java
+  FuncDecl.java
+  FuncInterpDecRefQueue.java
+  FuncInterpEntryDecRefQueue.java
+  FuncInterp.java
+  Global.java
+  GoalDecRefQueue.java
+  Goal.java
+  IDecRefQueue.java
+  InterpolationContext.java
+  IntExpr.java
+  IntNum.java
+  IntSort.java
+  IntSymbol.java
+  ListSort.java
+  Log.java
+  ModelDecRefQueue.java
+  Model.java
+  OptimizeDecRefQueue.java
+  Optimize.java
+  ParamDescrsDecRefQueue.java
+  ParamDescrs.java
+  ParamsDecRefQueue.java
+  Params.java
+  Pattern.java
+  ProbeDecRefQueue.java
+  Probe.java
+  Quantifier.java
+  RatNum.java
+  RealExpr.java
+  RealSort.java
+  ReExpr.java
+  RelationSort.java
+  ReSort.java
+  SeqExpr.java
+  SeqSort.java
+  SetSort.java
+  SolverDecRefQueue.java
+  Solver.java
+  Sort.java
+  StatisticsDecRefQueue.java
+  Statistics.java
+  Status.java
+  StringSymbol.java
+  Symbol.java
+  TacticDecRefQueue.java
+  Tactic.java
+  TupleSort.java
+  UninterpretedSort.java
+  Version.java
+  Z3Exception.java
+  Z3Object.java
+)
+set(Z3_JAVA_JAR_SOURCE_FILES_FULL_PATH "")
+foreach (java_src_file ${Z3_JAVA_JAR_SOURCE_FILES})
+  list(APPEND Z3_JAVA_JAR_SOURCE_FILES_FULL_PATH "${CMAKE_CURRENT_SOURCE_DIR}/${java_src_file}")
+endforeach()
+# Add generated files to list
+list(APPEND Z3_JAVA_JAR_SOURCE_FILES_FULL_PATH
+  ${Z3_JAVA_NATIVE_JAVA}
+  ${Z3_JAVA_ENUMERATION_PACKAGE_FILES_FULL_PATH}
+)
+
+# Convenient top-level target
+add_custom_target(build_z3_java_bindings
+  ALL
+  DEPENDS
+    z3java
+    z3JavaJar
+)
+
+# Rule to build ``com.microsoft.z3.jar``
+# TODO: Should we set ``CMAKE_JNI_TARGET`` to ``TRUE``?
+add_jar(z3JavaJar
+  SOURCES ${Z3_JAVA_JAR_SOURCE_FILES_FULL_PATH}
+  OUTPUT_NAME ${Z3_JAVA_PACKAGE_NAME}
+  OUTPUT_DIR "${CMAKE_BINARY_DIR}"
+  VERSION "${Z3_VERSION}"
+)
+
+###############################################################################
+# Install
+###############################################################################
+option(INSTALL_JAVA_BINDINGS "Install Java bindings when invoking install target" ON)
+if (INSTALL_JAVA_BINDINGS)
+  # Provide cache variables for the install locations that the user can change.
+  # This defaults to ``/usr/local/java`` which seems to be the location for ``.jar``
+  # files on Linux distributions
+  set(Z3_JAVA_JAR_INSTALLDIR
+    "${CMAKE_INSTALL_DATAROOTDIR}/java"
+    CACHE
+    PATH
+    "Directory to install Z3 Java jar file relative to install prefix"
+  )
+  # FIXME: I don't think this the right installation location
+  set(Z3_JAVA_JNI_LIB_INSTALLDIR
+    "${CMAKE_INSTALL_LIBDIR}"
+    CACHE
+    PATH
+    "Directory to install Z3 Java JNI bridge library relative to install prefix"
+  )
+  install(TARGETS z3java DESTINATION "${Z3_JAVA_JNI_LIB_INSTALLDIR}")
+  # Note: Don't use ``DESTINATION`` here as the version of ``UseJava.cmake`` shipped
+  # with CMake 2.8.12.2 handles that incorrectly.
+  install_jar(z3JavaJar "${Z3_JAVA_JAR_INSTALLDIR}")
+endif()

src/api/java/Context.java

@@ -25,6 +25,12 @@ import java.util.Map;
 
 /**
  * The main interaction with Z3 happens via the Context.
+ * For applications that spawn an unbounded number of contexts, 
+ * the proper use is within a try-with-resources
+ * scope so that the Context object gets garbage collected in
+ * a predictable way. Contexts maintain all data-structures
+ * related to terms and formulas that are created relative
+ * to them. 
  **/
 public class Context implements AutoCloseable {
     private final long m_ctx;

src/api/java/Expr.java

@@ -194,14 +194,7 @@ public class Expr extends AST
      **/
     public Expr translate(Context ctx)
     {
-        if (getContext() == ctx) {
-            return this;
-        } else {
-            return Expr.create(
-                ctx,
-                Native.translate(getContext().nCtx(), getNativeObject(),
-                    ctx.nCtx()));
-        }
+        return (Expr) super.translate(ctx);
     }
 
     /**
@@ -1297,6 +1290,15 @@ public class Expr extends AST
 	return Native.getString(getContext().nCtx(), getNativeObject());
     }
 
+    /**
+     * Check whether expression is a concatenation
+     * @return a boolean
+     */
+    public boolean isConcat() 
+    {
+        return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_SEQ_CONCAT;
+    }
+
     /**
      * Indicates whether the term is a binary equivalence modulo namings.
      * Remarks: This binary predicate is used in proof terms. It captures

src/api/java/Fixedpoint.java

@@ -88,6 +88,7 @@ public class Fixedpoint extends Z3Object
     /**
      * Add rule into the fixedpoint solver.
      *
+     * @param rule implication (Horn clause) representing rule
      * @param name Nullable rule name.
      * @throws Z3Exception
      **/
@@ -178,6 +179,7 @@ public class Fixedpoint extends Z3Object
     /**
      * Update named rule into in the fixedpoint solver.
      *
+     * @param rule implication (Horn clause) representing rule
      * @param name Nullable rule name.
      * @throws Z3Exception
      **/

src/api/java/FuncDecl.java

@@ -1,6 +1,6 @@
 /**
 Copyright (c) 2012-2014 Microsoft Corporation
-   
+
 Module Name:
 
     FuncDecl.java
@@ -12,8 +12,8 @@ Author:
     @author Christoph Wintersteiger (cwinter) 2012-03-15
 
 Notes:
-    
-**/ 
+
+**/
 
 package com.microsoft.z3;
 
@@ -59,6 +59,18 @@ public class FuncDecl extends AST
         return Native.getFuncDeclId(getContext().nCtx(), getNativeObject());
     }
 
+    /**
+     * Translates (copies) the function declaration to the Context {@code ctx}.
+     * @param ctx A context
+     *
+     * @return A copy of the function declaration which is associated with {@code ctx}
+     * @throws Z3Exception on error
+     **/
+    public FuncDecl translate(Context ctx)
+    {
+        return (FuncDecl) super.translate(ctx);
+    }
+
     /**
      * The arity of the function declaration
      **/
@@ -68,7 +80,7 @@ public class FuncDecl extends AST
     }
 
     /**
-     * The size of the domain of the function declaration 
+     * The size of the domain of the function declaration
      * @see #getArity
      **/
     public int getDomainSize()
@@ -324,7 +336,7 @@ public class FuncDecl extends AST
     }
 
     FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range)
-           
+
     {
         super(ctx, Native.mkFuncDecl(ctx.nCtx(), name.getNativeObject(),
                 AST.arrayLength(domain), AST.arrayToNative(domain),
@@ -333,7 +345,7 @@ public class FuncDecl extends AST
     }
 
     FuncDecl(Context ctx, String prefix, Sort[] domain, Sort range)
-           
+
     {
         super(ctx, Native.mkFreshFuncDecl(ctx.nCtx(), prefix,
                 AST.arrayLength(domain), AST.arrayToNative(domain),
@@ -351,7 +363,7 @@ public class FuncDecl extends AST
     }
 
     /**
-     * Create expression that applies function to arguments. 
+     * Create expression that applies function to arguments.
      **/
     public Expr apply(Expr ... args)
     {

src/api/java/Quantifier.java

@@ -145,6 +145,19 @@ public class Quantifier extends BoolExpr
                 .nCtx(), getNativeObject()));
     }
 
+    /**
+     * Translates (copies) the quantifier to the Context {@code ctx}.
+     * 
+     * @param ctx A context
+     * 
+     * @return A copy of the quantifier which is associated with {@code ctx}
+     * @throws Z3Exception on error
+     **/
+    public Quantifier translate(Context ctx)
+    {
+        return (Quantifier) super.translate(ctx);
+    }
+
     /**
      * Create a quantified expression.
      *

src/api/java/Sort.java

@@ -87,6 +87,19 @@ public class Sort extends AST
         return Native.sortToString(getContext().nCtx(), getNativeObject());
     }
 
+    /**
+     * Translates (copies) the sort to the Context {@code ctx}.
+     * 
+     * @param ctx A context
+     * 
+     * @return A copy of the sort which is associated with {@code ctx}
+     * @throws Z3Exception on error
+     **/
+    public Sort translate(Context ctx)
+    {
+        return (Sort) super.translate(ctx);
+    }
+
     /**
      * Sort constructor
      **/

src/api/python/CMakeLists.txt

@@ -0,0 +1,143 @@
+message(STATUS "Emitting rules to build Z3 python bindings")
+###############################################################################
+# Add target to build python bindings for the build directory
+###############################################################################
+# This allows the python bindings to be used directly from the build directory
+set(z3py_files
+  z3/__init__.py
+  z3/z3.py
+  z3/z3num.py
+  z3/z3poly.py
+  z3/z3printer.py
+  z3/z3rcf.py
+  z3test.py
+  z3/z3types.py
+  z3/z3util.py
+)
+
+set(z3py_bindings_build_dest "${CMAKE_BINARY_DIR}/python")
+file(MAKE_DIRECTORY "${z3py_bindings_build_dest}")
+file(MAKE_DIRECTORY "${z3py_bindings_build_dest}/z3")
+
+set(build_z3_python_bindings_target_depends "")
+foreach (z3py_file ${z3py_files})
+  add_custom_command(OUTPUT "${z3py_bindings_build_dest}/${z3py_file}"
+    COMMAND "${CMAKE_COMMAND}" "-E" "copy"
+      "${CMAKE_CURRENT_SOURCE_DIR}/${z3py_file}"
+      "${z3py_bindings_build_dest}/${z3py_file}"
+    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/${z3py_file}"
+    COMMENT "Copying \"${z3py_file}\" to ${z3py_bindings_build_dest}/${z3py_file}"
+  )
+  list(APPEND build_z3_python_bindings_target_depends "${z3py_bindings_build_dest}/${z3py_file}")
+endforeach()
+
+# Generate z3core.py
+add_custom_command(OUTPUT "${z3py_bindings_build_dest}/z3/z3core.py"
+  COMMAND "${PYTHON_EXECUTABLE}"
+    "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "--z3py-output-dir"
+    "${z3py_bindings_build_dest}"
+  DEPENDS
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "${CMAKE_SOURCE_DIR}/scripts/update_api.py"
+    ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+    # FIXME: When update_api.py no longer uses ``mk_util`` drop this dependency
+    "${CMAKE_SOURCE_DIR}/scripts/mk_util.py"
+  COMMENT "Generating z3core.py"
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+)
+list(APPEND build_z3_python_bindings_target_depends "${z3py_bindings_build_dest}/z3/z3core.py")
+
+# Generate z3consts.py
+add_custom_command(OUTPUT "${z3py_bindings_build_dest}/z3/z3consts.py"
+  COMMAND "${PYTHON_EXECUTABLE}"
+    "${CMAKE_SOURCE_DIR}/scripts/mk_consts_files.py"
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "--z3py-output-dir"
+    "${z3py_bindings_build_dest}"
+  DEPENDS
+    ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    "${CMAKE_SOURCE_DIR}/scripts/mk_consts_files.py"
+    ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+  COMMENT "Generating z3consts.py"
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+)
+list(APPEND build_z3_python_bindings_target_depends "${z3py_bindings_build_dest}/z3/z3consts.py")
+
+if (UNIX)
+  set(LINK_COMMAND "create_symlink")
+else()
+  set(LINK_COMMAND "copy")
+endif()
+
+# Link libz3 into the python directory so bindings work out of the box
+add_custom_command(OUTPUT "${z3py_bindings_build_dest}/libz3${CMAKE_SHARED_MODULE_SUFFIX}"
+  COMMAND "${CMAKE_COMMAND}" "-E" "${LINK_COMMAND}"
+    "${CMAKE_BINARY_DIR}/libz3${CMAKE_SHARED_MODULE_SUFFIX}"
+    "${z3py_bindings_build_dest}/libz3${CMAKE_SHARED_MODULE_SUFFIX}"
+  DEPENDS libz3
+  COMMENT "Linking libz3 into python directory"
+)
+
+# Convenient top-level target
+add_custom_target(build_z3_python_bindings
+  ALL
+  DEPENDS
+    ${build_z3_python_bindings_target_depends}
+    "${z3py_bindings_build_dest}/libz3${CMAKE_SHARED_MODULE_SUFFIX}"
+)
+
+###############################################################################
+# Install
+###############################################################################
+option(INSTALL_PYTHON_BINDINGS "Install Python bindings when invoking install target" ON)
+if (INSTALL_PYTHON_BINDINGS)
+  message(STATUS "Emitting rules to install Z3 python bindings")
+  # Try to guess the installation path for the bindings
+  if (NOT DEFINED CMAKE_INSTALL_PYTHON_PKG_DIR)
+    message(STATUS "CMAKE_INSTALL_PYTHON_PKG_DIR not set. Trying to guess")
+    execute_process(
+      COMMAND "${PYTHON_EXECUTABLE}" "-c"
+        "import distutils.sysconfig; print(distutils.sysconfig.get_python_lib())"
+      RESULT_VARIABLE exit_code
+      OUTPUT_VARIABLE CMAKE_INSTALL_PYTHON_PKG_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+
+    if (NOT ("${exit_code}" EQUAL 0))
+      message(FATAL_ERROR "Failed to determine your Python package directory")
+    endif()
+    message(STATUS "Detected Python package directory: \"${CMAKE_INSTALL_PYTHON_PKG_DIR}\"")
+    # Set a cache variable that the user can modify if needed
+    set(CMAKE_INSTALL_PYTHON_PKG_DIR
+      "${CMAKE_INSTALL_PYTHON_PKG_DIR}"
+      CACHE PATH
+      "Path to install python bindings. This can be relative or absolute.")
+    mark_as_advanced(CMAKE_INSTALL_PYTHON_PKG_DIR)
+  else()
+    message(STATUS "CMAKE_INSTALL_PYTHON_PKG_DIR already set (\"${CMAKE_INSTALL_PYTHON_PKG_DIR}\")"
+                   ". Not trying to guess.")
+  endif()
+
+  # Check if path exists under the install prefix if it is absolute. If the
+  # path is relative it will be installed under the install prefix so there
+  # if nothing to check
+  if (IS_ABSOLUTE "${CMAKE_INSTALL_PYTHON_PKG_DIR}")
+    string(FIND "${CMAKE_INSTALL_PYTHON_PKG_DIR}" "${CMAKE_INSTALL_PREFIX}" position)
+    if (NOT ("${position}" EQUAL 0))
+      message(WARNING "The directory to install the python bindings \"${CMAKE_INSTALL_PYTHON_PKG_DIR}\" "
+              "is not under the install prefix \"${CMAKE_INSTALL_PREFIX}\"."
+              " Running the install target may lead to a broken installation. "
+              "To change the install directory modify the CMAKE_INSTALL_PYTHON_PKG_DIR cache variable."
+              )
+    endif()
+  endif()
+  # Using DESTDIR still seems to work even if we use an absolute path
+  message(STATUS "Python bindings will be installed to \"${CMAKE_INSTALL_PYTHON_PKG_DIR}\"")
+  install(FILES ${build_z3_python_bindings_target_depends}
+    DESTINATION "${CMAKE_INSTALL_PYTHON_PKG_DIR}/z3"
+  )
+else()
+  message(STATUS "Not emitting rules to install Z3 python bindings")
+endif()

src/api/python/z3/z3.py

@@ -12,7 +12,7 @@
 Several online tutorials for Z3Py are available at:
 http://rise4fun.com/Z3Py/tutorial/guide
 
-Please send feedback, comments and/or corrections to leonardo@microsoft.com. Your comments are very valuable.
+Please send feedback, comments and/or corrections on the Issue tracker for https://github.com/Z3prover/z3.git. Your comments are very valuable.
 
 Small example:
 
@@ -50,6 +50,7 @@ from fractions import Fraction
 import sys
 import io
 import math
+import copy
 
 if sys.version < '3':
     def _is_int(v):
@@ -288,6 +289,9 @@ class AstRef(Z3PPObject):
         if self.ctx.ref() is not None:
            Z3_dec_ref(self.ctx.ref(), self.as_ast())
 
+    def __deepcopy__(self, memo={}):
+        return _to_ast_ref(self.ast, self.ctx)
+
     def __str__(self):
         return obj_to_string(self)
 
@@ -314,7 +318,7 @@ class AstRef(Z3PPObject):
             raise Z3Exception("Symbolic expressions cannot be cast to concrete Boolean values.")
 
     def sexpr(self):
-        """Return an string representing the AST node in s-expression notation.
+        """Return a string representing the AST node in s-expression notation.
 
         >>> x = Int('x')
         >>> ((x + 1)*x).sexpr()
@@ -4357,6 +4361,11 @@ class Datatype:
         self.name         = name
         self.constructors = []
 
+    def __deepcopy__(self, memo={}):
+        r = Datatype(self.name, self.ctx)
+        r.constructors = copy.deepcopy(self.constructors)
+        return r
+
     def declare_core(self, name, rec_name, *args):
         if __debug__:
             _z3_assert(isinstance(name, str), "String expected")
@@ -4647,11 +4656,17 @@ class ParamsRef:
 
     Consider using the function `args2params` to create instances of this object.
     """
-    def __init__(self, ctx=None):
+    def __init__(self, ctx=None, params=None):
         self.ctx    = _get_ctx(ctx)
-        self.params = Z3_mk_params(self.ctx.ref())
+        if params is None:
+            self.params = Z3_mk_params(self.ctx.ref())
+        else:
+            self.params = params
         Z3_params_inc_ref(self.ctx.ref(), self.params)
 
+    def __deepcopy__(self, memo={}):
+        return ParamsRef(self.ctx, self.params)
+
     def __del__(self):
         if self.ctx.ref() is not None:
            Z3_params_dec_ref(self.ctx.ref(), self.params)
@@ -4711,6 +4726,9 @@ class ParamDescrsRef:
         self.descr  = descr
         Z3_param_descrs_inc_ref(self.ctx.ref(), self.descr)
 
+    def __deepcopy__(self, memo={}):
+        return ParamsDescrsRef(self.descr, self.ctx)
+
     def __del__(self):
         if self.ctx.ref() is not None:
            Z3_param_descrs_dec_ref(self.ctx.ref(), self.descr)
@@ -4772,6 +4790,9 @@ class Goal(Z3PPObject):
             self.goal   = Z3_mk_goal(self.ctx.ref(), models, unsat_cores, proofs)
         Z3_goal_inc_ref(self.ctx.ref(), self.goal)
 
+    def __deepcopy__(self, memo={}):
+        return Goal(False, False, False, self.ctx, self.goal)
+
     def __del__(self):
         if self.goal is not None and self.ctx.ref() is not None:
             Z3_goal_dec_ref(self.ctx.ref(), self.goal)
@@ -5034,6 +5055,9 @@ class AstVector(Z3PPObject):
             self.ctx    = ctx
         Z3_ast_vector_inc_ref(self.ctx.ref(), self.vector)
 
+    def __deepcopy__(self, memo={}):
+        return AstVector(self.vector, self.ctx)
+
     def __del__(self):
         if self.vector is not None and self.ctx.ref() is not None:
             Z3_ast_vector_dec_ref(self.ctx.ref(), self.vector)
@@ -5169,6 +5193,9 @@ class AstMap:
             self.ctx    = ctx
         Z3_ast_map_inc_ref(self.ctx.ref(), self.map)
 
+    def __deepcopy__(self, memo={}):
+        return AstMap(self.map, self.ctx)
+
     def __del__(self):
         if self.map is not None and self.ctx.ref() is not None:
             Z3_ast_map_dec_ref(self.ctx.ref(), self.map)
@@ -5284,6 +5311,9 @@ class FuncEntry:
         self.ctx   = ctx
         Z3_func_entry_inc_ref(self.ctx.ref(), self.entry)
 
+    def __deepcopy__(self, memo={}):
+        return FuncEntry(self.entry, self.ctx)
+
     def __del__(self):
         if self.ctx.ref() is not None:
            Z3_func_entry_dec_ref(self.ctx.ref(), self.entry)
@@ -5390,6 +5420,9 @@ class FuncInterp(Z3PPObject):
         if self.f is not None:
             Z3_func_interp_inc_ref(self.ctx.ref(), self.f)
 
+    def __deepcopy__(self, memo={}):
+        return FuncInterp(self.f, self.ctx)
+
     def __del__(self):
         if self.f is not None and self.ctx.ref() is not None:
             Z3_func_interp_dec_ref(self.ctx.ref(), self.f)
@@ -5500,6 +5533,9 @@ class ModelRef(Z3PPObject):
         self.ctx   = ctx
         Z3_model_inc_ref(self.ctx.ref(), self.model)
 
+    def __deepcopy__(self, memo={}):
+        return ModelRef(self.m, self.ctx)
+
     def __del__(self):
         if self.ctx.ref() is not None:
            Z3_model_dec_ref(self.ctx.ref(), self.model)
@@ -5776,6 +5812,9 @@ class Statistics:
         self.ctx   = ctx
         Z3_stats_inc_ref(self.ctx.ref(), self.stats)
 
+    def __deepcopy__(self, memo={}):
+        return Statistics(self.stats, self.ctx)
+
     def __del__(self):
         if self.ctx.ref() is not None:
            Z3_stats_dec_ref(self.ctx.ref(), self.stats)
@@ -5910,6 +5949,9 @@ class CheckSatResult:
     def __init__(self, r):
         self.r = r
 
+    def __deepcopy__(self, memo={}):
+        return CheckSatResult(self.r)
+
     def __eq__(self, other):
         return isinstance(other, CheckSatResult) and self.r == other.r
 
@@ -5949,6 +5991,9 @@ class Solver(Z3PPObject):
             self.solver = solver
         Z3_solver_inc_ref(self.ctx.ref(), self.solver)
 
+    def __deepcopy__(self, memo={}):
+        return Solver(self.solver, self.ctx)
+
     def __del__(self):
         if self.solver is not None and self.ctx.ref() is not None:
             Z3_solver_dec_ref(self.ctx.ref(), self.solver)
@@ -6009,6 +6054,24 @@ class Solver(Z3PPObject):
         """
         Z3_solver_pop(self.ctx.ref(), self.solver, num)
 
+    def num_scopes(self):
+        """Return the current number of backtracking points.
+
+        >>> s = Solver()
+        >>> s.num_scopes()
+        0L
+        >>> s.push()
+        >>> s.num_scopes()
+        1L
+        >>> s.push()
+        >>> s.num_scopes()
+        2L
+        >>> s.pop()
+        >>> s.num_scopes()
+        1L
+        """
+        return Z3_solver_get_num_scopes(self.ctx.ref(), self.solver)
+
     def reset(self):
         """Remove all asserted constraints and backtracking points created using `push()`.
 
@@ -6384,6 +6447,9 @@ class Fixedpoint(Z3PPObject):
         Z3_fixedpoint_inc_ref(self.ctx.ref(), self.fixedpoint)
         self.vars = []
 
+    def __deepcopy__(self, memo={}):
+        return FixedPoint(self.fixedpoint, self.ctx)
+
     def __del__(self):
         if self.fixedpoint is not None and self.ctx.ref() is not None:
             Z3_fixedpoint_dec_ref(self.ctx.ref(), self.fixedpoint)
@@ -6758,6 +6824,9 @@ class Optimize(Z3PPObject):
         self.optimize = Z3_mk_optimize(self.ctx.ref())
         Z3_optimize_inc_ref(self.ctx.ref(), self.optimize)
 
+    def __deepcopy__(self, memo={}):
+        return Optimize(self.optimize, self.ctx)
+
     def __del__(self):
         if self.optimize is not None and self.ctx.ref() is not None:
             Z3_optimize_dec_ref(self.ctx.ref(), self.optimize)
@@ -6910,6 +6979,9 @@ class ApplyResult(Z3PPObject):
         self.ctx    = ctx
         Z3_apply_result_inc_ref(self.ctx.ref(), self.result)
 
+    def __deepcopy__(self, memo={}):
+        return ApplyResult(self.result, self.ctx)
+
     def __del__(self):
         if self.ctx.ref() is not None:
             Z3_apply_result_dec_ref(self.ctx.ref(), self.result)
@@ -7038,6 +7110,9 @@ class Tactic:
                 raise Z3Exception("unknown tactic '%s'" % tactic)
         Z3_tactic_inc_ref(self.ctx.ref(), self.tactic)
 
+    def __deepcopy__(self, memo={}):
+        return Tactic(self.tactic, self.ctx)
+
     def __del__(self):
         if self.tactic is not None and self.ctx.ref() is not None:
             Z3_tactic_dec_ref(self.ctx.ref(), self.tactic)
@@ -7310,6 +7385,9 @@ class Probe:
                 raise Z3Exception("unknown probe '%s'" % probe)
         Z3_probe_inc_ref(self.ctx.ref(), self.probe)
 
+    def __deepcopy__(self, memo={}):
+        return Probe(self.probe, self.ctx)
+
     def __del__(self):
         if self.probe is not None and self.ctx.ref() is not None:
             Z3_probe_dec_ref(self.ctx.ref(), self.probe)

src/api/z3_api.h

@@ -48,6 +48,7 @@ DEFINE_TYPE(Z3_rcf_num);
 /*@{*/
 
 /** @name Types
+    @{
 
    Most of the types in the C API are opaque pointers.
 
@@ -395,6 +396,33 @@ typedef enum
        The meaning is given by the equivalence
        (xor3 l1 l2 l3) <=> (xor (xor l1 l2) l3)
 
+   - Z3_OP_BSMUL_NO_OVFL: a predicate to check that bit-wise signed multiplication does not overflow.
+     Signed multiplication overflows if the operands have the same sign and the result of multiplication 
+     does not fit within the available bits. \sa Z3_mk_bvmul_no_overflow.
+
+   - Z3_OP_BUMUL_NO_OVFL: check that bit-wise unsigned multiplication does not overflow.
+     Unsigned multiplication overflows if the result does not fit within the available bits.
+     \sa Z3_mk_bvmul_no_overflow.
+    
+   - Z3_OP_BSMUL_NO_UDFL: check that bit-wise signed multiplication does not underflow.
+     Signed multiplication underflows if the operands have opposite signs and the result of multiplication
+     does not fit within the avaialble bits. Z3_mk_bvmul_no_underflow.
+    
+   - Z3_OP_BSDIV_I: Binary signed division. 
+     It has the same semantics as Z3_OP_BSDIV, but created in a context where the second operand can be assumed to be non-zero.
+
+   - Z3_OP_BUDIV_I: Binary unsigned division.
+     It has the same semantics as Z3_OP_BUDIV, but created in a context where the second operand can be assumed to be non-zero.
+    
+   - Z3_OP_BSREM_I: Binary signed remainder.
+     It has the same semantics as Z3_OP_BSREM, but created in a context where the second operand can be assumed to be non-zero.
+
+   - Z3_OP_BUREM_I: Binary unsigned remainder.
+     It has the same semantics as Z3_OP_BUREM, but created in a context where the second operand can be assumed to be non-zero.
+
+   - Z3_OP_BSMOD_I: Binary signed modulus.
+     It has the same semantics as Z3_OP_BSMOD, but created in a context where the second operand can be assumed to be non-zero.
+
    - Z3_OP_PR_UNDEF: Undef/Null proof object.
 
    - Z3_OP_PR_TRUE: Proof for the expression 'true'.
@@ -5238,7 +5266,6 @@ extern "C" {
        def_API('Z3_get_error_msg', STRING, (_in(CONTEXT), _in(ERROR_CODE)))
     */
     Z3_string Z3_API Z3_get_error_msg(Z3_context c, Z3_error_code err);
-    /*@}*/
 
     /**
        \brief Return a string describing the given error code.
@@ -5349,6 +5376,13 @@ extern "C" {
 
     /**
        \brief Add a new formula \c a to the given goal.
+        The formula is split according to the following procedure that is applied
+        until a fixed-point:
+           Conjunctions are split into separate formulas.
+           Negations are distributed over disjunctions, resulting in separate formulas.
+        If the goal is \c false, adding new formulas is a no-op.
+        If the formula \c a is \c true, then nothing is added.
+        If the formula \c a is \c false, then the entire goal is replaced by the formula \c false.
 
        def_API('Z3_goal_assert', VOID, (_in(CONTEXT), _in(GOAL), _in(AST)))
     */
@@ -5791,9 +5825,35 @@ extern "C" {
     /** @name Solvers*/
     /*@{*/
     /**
-       \brief Create a new (incremental) solver. This solver also uses a
-       set of builtin tactics for handling the first check-sat command, and
-       check-sat commands that take more than a given number of milliseconds to be solved.
+       \brief Create a new solver. This solver is a "combined solver" (see
+       combined_solver module) that internally uses a non-incremental (solver1) and an
+       incremental solver (solver2). This combined solver changes its behaviour based
+       on how it is used and how its parameters are set.
+
+       If the solver is used in a non incremental way (i.e. no calls to
+       `Z3_solver_push()` or `Z3_solver_pop()`, and no calls to
+       `Z3_solver_assert()` or `Z3_solver_assert_and_track()` after checking
+       satisfiability without an intervening `Z3_solver_reset()`) then solver1
+       will be used. This solver will apply Z3's "default" tactic.
+
+       The "default" tactic will attempt to probe the logic used by the
+       assertions and will apply a specialized tactic if one is supported.
+       Otherwise the general `(and-then simplify smt)` tactic will be used.
+
+       If the solver is used in an incremental way then the combined solver
+       will switch to using solver2 (which behaves similarly to the general
+       "smt" tactic).
+
+       Note however it is possible to set the `solver2_timeout`,
+       `solver2_unknown`, and `ignore_solver1` parameters of the combined
+       solver to change its behaviour.
+
+       The function #Z3_solver_get_model retrieves a model if the
+       assertions is satisfiable (i.e., the result is \c
+       Z3_L_TRUE) and model construction is enabled.
+       The function #Z3_solver_get_model can also be used even
+       if the result is \c Z3_L_UNDEF, but the returned model
+       is not guaranteed to satisfy quantified assertions.
 
        \remark User must use #Z3_solver_inc_ref and #Z3_solver_dec_ref to manage solver objects.
        Even if the context was created using #Z3_mk_context instead of #Z3_mk_context_rc.
@@ -5803,7 +5863,17 @@ extern "C" {
     Z3_solver Z3_API Z3_mk_solver(Z3_context c);
 
     /**
-       \brief Create a new (incremental) solver.
+       \brief Create a new incremental solver.
+
+       This is equivalent to applying the "smt" tactic.
+
+       Unlike `Z3_mk_solver()` this solver
+         - Does not attempt to apply any logic specific tactics.
+         - Does not change its behaviour based on whether it used
+           incrementally/non-incrementally.
+
+       Note that these differences can result in very different performance
+       compared to `Z3_mk_solver()`.
 
        The function #Z3_solver_get_model retrieves a model if the
        assertions is satisfiable (i.e., the result is \c

src/api/z3_optimization.h

@@ -75,7 +75,7 @@ extern "C" {
        \brief Add a maximization constraint.
        \param c - context
        \param o - optimization context
-       \param a - arithmetical term
+       \param t - arithmetical term
        def_API('Z3_optimize_maximize', UINT, (_in(CONTEXT), _in(OPTIMIZE), _in(AST)))
     */
     unsigned Z3_API Z3_optimize_maximize(Z3_context c, Z3_optimize o, Z3_ast t);
@@ -84,7 +84,7 @@ extern "C" {
        \brief Add a minimization constraint.
        \param c - context
        \param o - optimization context
-       \param a - arithmetical term
+       \param t - arithmetical term
 
        def_API('Z3_optimize_minimize', UINT, (_in(CONTEXT), _in(OPTIMIZE), _in(AST)))
     */