Merge branch 'master' of https://github.com/wintersteiger/z3

src/CMakeLists.txt

@@ -0,0 +1,261 @@
+################################################################################
+# API header files
+################################################################################
+# This lists the API header files that are scanned by
+# some of the build rules to generate some files needed
+# by the build
+set(Z3_API_HEADER_FILES_TO_SCAN
+  z3_api.h
+  z3_ast_containers.h
+  z3_algebraic.h
+  z3_polynomial.h
+  z3_rcf.h
+  z3_fixedpoint.h
+  z3_optimization.h
+  z3_interp.h
+  z3_fpa.h
+)
+set(Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN "")
+foreach (header_file ${Z3_API_HEADER_FILES_TO_SCAN})
+  set(full_path_api_header_file "${CMAKE_CURRENT_SOURCE_DIR}/api/${header_file}")
+  list(APPEND Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN "${full_path_api_header_file}")
+  if (NOT EXISTS "${full_path_api_header_file}")
+    message(FATAL_ERROR "API header file \"${full_path_api_header_file}\" does not exist")
+  endif()
+endforeach()
+
+################################################################################
+# Traverse directories each adding a Z3 component
+################################################################################
+# I'm duplicating the order in ``mk_project.py`` for now to help us keep
+# the build systems in sync.
+#
+# The components in these directory explicitly declare their dependencies so
+# you may be able to re-order some of these directories but an error will be
+# raised if you try to declare a component is dependent on another component
+# that has not yet been declared.
+add_subdirectory(util)
+add_subdirectory(util/lp)
+add_subdirectory(math/polynomial)
+add_subdirectory(sat)
+add_subdirectory(nlsat)
+add_subdirectory(math/hilbert)
+add_subdirectory(math/simplex)
+add_subdirectory(math/automata)
+add_subdirectory(math/interval)
+add_subdirectory(math/realclosure)
+add_subdirectory(math/subpaving)
+add_subdirectory(ast)
+add_subdirectory(ast/rewriter)
+add_subdirectory(ast/normal_forms)
+add_subdirectory(model)
+add_subdirectory(tactic)
+add_subdirectory(ast/substitution)
+add_subdirectory(parsers/util)
+add_subdirectory(math/grobner)
+add_subdirectory(math/euclid)
+add_subdirectory(tactic/core)
+add_subdirectory(sat/tactic)
+add_subdirectory(tactic/arith)
+add_subdirectory(nlsat/tactic)
+add_subdirectory(math/subpaving/tactic)
+add_subdirectory(tactic/aig)
+add_subdirectory(solver)
+add_subdirectory(ackermannization)
+add_subdirectory(interp)
+add_subdirectory(cmd_context)
+add_subdirectory(cmd_context/extra_cmds)
+add_subdirectory(parsers/smt2)
+add_subdirectory(ast/proof_checker)
+## Simplifier module will be deleted in the future.
+## It has been replaced with rewriter component.
+add_subdirectory(ast/simplifier)
+add_subdirectory(ast/fpa)
+add_subdirectory(ast/macros)
+add_subdirectory(ast/pattern)
+add_subdirectory(ast/rewriter/bit_blaster)
+add_subdirectory(smt/params)
+add_subdirectory(smt/proto_model)
+add_subdirectory(smt)
+add_subdirectory(tactic/bv)
+add_subdirectory(smt/tactic)
+add_subdirectory(tactic/sls)
+add_subdirectory(qe)
+add_subdirectory(duality)
+add_subdirectory(muz/base)
+add_subdirectory(muz/dataflow)
+add_subdirectory(muz/transforms)
+add_subdirectory(muz/rel)
+add_subdirectory(muz/pdr)
+add_subdirectory(muz/clp)
+add_subdirectory(muz/tab)
+add_subdirectory(muz/bmc)
+add_subdirectory(muz/ddnf)
+add_subdirectory(muz/duality)
+add_subdirectory(muz/fp)
+add_subdirectory(tactic/nlsat_smt)
+add_subdirectory(tactic/ufbv)
+add_subdirectory(sat/sat_solver)
+add_subdirectory(tactic/smtlogics)
+add_subdirectory(tactic/fpa)
+add_subdirectory(tactic/portfolio)
+add_subdirectory(parsers/smt)
+add_subdirectory(opt)
+add_subdirectory(api)
+add_subdirectory(api/dll)
+
+################################################################################
+# libz3
+################################################################################
+get_property(Z3_LIBZ3_COMPONENTS_LIST GLOBAL PROPERTY Z3_LIBZ3_COMPONENTS)
+set (object_files "")
+foreach (component ${Z3_LIBZ3_COMPONENTS_LIST})
+  list(APPEND object_files $<TARGET_OBJECTS:${component}>)
+endforeach()
+if (BUILD_LIBZ3_SHARED)
+  set(lib_type "SHARED")
+else()
+  set(lib_type "STATIC")
+endif()
+add_library(libz3 ${lib_type} ${object_files})
+set_target_properties(libz3 PROPERTIES
+  # VERSION determines the version in the filename of the shared library.
+  # SOVERSION determines the value of the DT_SONAME field on ELF platforms.
+  # On ELF platforms the final compiled filename will be libz3.so.W.X.Y.Z
+  # but symlinks will be made to this file from libz3.so and also from
+  # libz3.so.W.X.
+  # This indicates that no breaking API changes will be made within a single
+  # minor version.
+  VERSION ${Z3_VERSION}
+  SOVERSION ${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR})
+
+if (NOT MSVC)
+  # On UNIX like platforms if we don't change the OUTPUT_NAME
+  # the library gets a name like ``liblibz3.so`` so we change it
+  # here. We don't do a rename with MSVC because we get file naming
+  # conflicts (the z3 executable also has this OUTPUT_NAME) with
+  # ``.ilk``, ``.pdb``, ``.lib`` and ``.exp`` files sharing the same
+  # prefix.
+  set_target_properties(libz3 PROPERTIES OUTPUT_NAME z3)
+endif()
+
+# The `PRIVATE` usage requirement is specified so that when building Z3 as a
+# shared library the dependent libraries are specified on the link command line
+# so that if those are also shared libraries they are referenced by `libz3.so`.
+target_link_libraries(libz3 PRIVATE ${Z3_DEPENDENT_LIBS})
+
+# This is currently only for the OpenMP flags. It needs to be set
+# via `target_link_libraries()` rather than `z3_append_linker_flag_list_to_target()`
+# because when building the `libz3` as a static library when the target is exported
+# the link dependencies need to be exported too.
+foreach (flag_name ${Z3_DEPENDENT_EXTRA_CXX_LINK_FLAGS})
+  target_link_libraries(libz3 PRIVATE ${flag_name})
+endforeach()
+
+# Declare which header file are the public header files of libz3
+# these will automatically installed when the libz3 target is installed
+set (libz3_public_headers
+  z3_algebraic.h
+  z3_api.h
+  z3_ast_containers.h
+  z3_fixedpoint.h
+  z3_fpa.h
+  z3.h
+  c++/z3++.h
+  z3_interp.h
+  z3_macros.h
+  z3_optimization.h
+  z3_polynomial.h
+  z3_rcf.h
+  z3_v1.h
+)
+foreach (header ${libz3_public_headers})
+  set_property(TARGET libz3 APPEND PROPERTY
+    PUBLIC_HEADER "${CMAKE_SOURCE_DIR}/src/api/${header}")
+endforeach()
+
+install(TARGETS libz3
+  EXPORT Z3_EXPORTED_TARGETS
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}" # On Windows this installs ``libz3.lib`` which CMake calls the "corresponding import library". Do we want this installed?
+  RUNTIME DESTINATION "${CMAKE_INSTALL_LIBDIR}" # For Windows. DLLs are runtime targets for CMake
+  PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+
+if (MSVC)
+  # Handle settings dll exports when using MSVC
+  # FIXME: This seems unnecessarily complicated but I'm doing
+  # this because this is what the python build system does.
+  # CMake has a much more elegant (see ``GenerateExportHeader.cmake``)
+  # way of handling this.
+  set(dll_module_exports_file "${CMAKE_CURRENT_BINARY_DIR}/api_dll.def")
+  add_custom_command(OUTPUT "${dll_module_exports_file}"
+    COMMAND
+      "${PYTHON_EXECUTABLE}"
+      "${CMAKE_SOURCE_DIR}/scripts/mk_def_file.py"
+      "${dll_module_exports_file}"
+      "libz3"
+      ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    DEPENDS
+      "${CMAKE_SOURCE_DIR}/scripts/mk_def_file.py"
+      ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+      ${Z3_FULL_PATH_API_HEADER_FILES_TO_SCAN}
+    COMMENT "Generating \"${dll_module_exports_file}\""
+    ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+    VERBATIM
+  )
+  add_custom_target(libz3_extra_depends
+    DEPENDS "${dll_module_exports_file}"
+  )
+  add_dependencies(libz3 libz3_extra_depends)
+  z3_append_linker_flag_list_to_target(libz3 "/DEF:${dll_module_exports_file}")
+endif()
+
+################################################################################
+# Z3 executable
+################################################################################
+add_subdirectory(shell)
+
+################################################################################
+# z3-test
+################################################################################
+add_subdirectory(test)
+
+
+################################################################################
+# Z3 API bindings
+################################################################################
+option(BUILD_PYTHON_BINDINGS "Build Python bindings for Z3" OFF)
+if (BUILD_PYTHON_BINDINGS)
+  if (NOT BUILD_LIBZ3_SHARED)
+    message(FATAL_ERROR "The python bindings will not work with a static libz3. "
+            "You either need to disable BUILD_PYTHON_BINDINGS or enable BUILD_LIBZ3_SHARED")
+  endif()
+  add_subdirectory(api/python)
+endif()
+
+################################################################################
+# .NET bindings
+################################################################################
+option(BUILD_DOTNET_BINDINGS "Build .NET bindings for Z3" OFF)
+if (BUILD_DOTNET_BINDINGS)
+  if (NOT BUILD_LIBZ3_SHARED)
+    message(FATAL_ERROR "The .NET bindings will not work with a static libz3. "
+      "You either need to disable BUILD_DOTNET_BINDINGS or enable BUILD_LIBZ3_SHARED")
+  endif()
+  add_subdirectory(api/dotnet)
+endif()
+
+################################################################################
+# Java bindings
+################################################################################
+option(BUILD_JAVA_BINDINGS "Build Java bindings for Z3" OFF)
+if (BUILD_JAVA_BINDINGS)
+  if (NOT BUILD_LIBZ3_SHARED)
+    message(FATAL_ERROR "The Java bindings will not work with a static libz3. "
+      "You either need to disable BUILD_JAVA_BINDINGS or enable BUILD_LIBZ3_SHARED")
+  endif()
+  add_subdirectory(api/java)
+endif()
+
+# TODO: Implement support for other bindigns

src/ackermannization/CMakeLists.txt

@@ -0,0 +1,20 @@
+z3_add_component(ackermannization
+  SOURCES
+    ackermannize_bv_model_converter.cpp
+    ackermannize_bv_tactic.cpp
+    ackr_bound_probe.cpp
+    ackr_helper.cpp
+    ackr_model_converter.cpp
+    lackr.cpp
+    lackr_model_constructor.cpp
+    lackr_model_converter_lazy.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+    model
+    rewriter
+    solver
+    tactic
+  PYG_FILES
+    ackermannization_params.pyg
+    ackermannize_bv_tactic_params.pyg
+)

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_files}\""
+            ${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;
@@ -1124,6 +1129,20 @@ extern "C" {
             case OP_SEQ_TO_RE: return Z3_OP_SEQ_TO_RE;
             case OP_SEQ_IN_RE: return Z3_OP_SEQ_IN_RE;
 
+            case _OP_STRING_STRREPL: return Z3_OP_SEQ_REPLACE;
+            case _OP_STRING_CONCAT: return Z3_OP_SEQ_CONCAT;
+            case _OP_STRING_LENGTH: return Z3_OP_SEQ_LENGTH;
+            case _OP_STRING_STRCTN: return Z3_OP_SEQ_CONTAINS;
+            case _OP_STRING_PREFIX: return Z3_OP_SEQ_PREFIX;
+            case _OP_STRING_SUFFIX: return Z3_OP_SEQ_SUFFIX;
+            case _OP_STRING_IN_REGEXP: return Z3_OP_SEQ_IN_RE;
+            case _OP_STRING_TO_REGEXP: return Z3_OP_SEQ_TO_RE;
+            case _OP_STRING_CHARAT: return Z3_OP_SEQ_AT;
+            case _OP_STRING_SUBSTR: return Z3_OP_SEQ_EXTRACT;
+            case _OP_STRING_STRIDOF: return Z3_OP_SEQ_INDEX;
+            case _OP_REGEXP_EMPTY: return Z3_OP_RE_EMPTY_SET;
+            case _OP_REGEXP_FULL: return Z3_OP_RE_FULL_SET;
+
             case OP_STRING_STOI: return Z3_OP_STR_TO_INT;
             case OP_STRING_ITOS: return Z3_OP_INT_TO_STR;
 

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>
@@ -797,6 +791,77 @@ namespace Microsoft.Z3
         public bool IsLabelLit { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LABEL_LIT; } }
         #endregion
 
+        #region Sequences and Strings
+
+        /// <summary>
+        /// Check whether expression is a string constant.
+        /// </summary>
+        /// <returns>a Boolean</returns>
+        public bool IsString  { get { return IsApp && 0 != Native.Z3_is_string(Context.nCtx, NativeObject); } }
+
+        /// <summary>
+        /// 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); } }
+
+        /// <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
+
         #region Proof Terms
         /// <summary>
         /// Indicates whether the term is a binary equivalence modulo namings.

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/Model.cs

@@ -19,6 +19,7 @@ Notes:
 
 using System;
 using System.Diagnostics.Contracts;
+using System.Collections.Generic;
 
 namespace Microsoft.Z3
 {
@@ -131,6 +132,24 @@ namespace Microsoft.Z3
             }
         }
 
+        /// <summary>
+        /// Enumerate constants in model.
+        /// </summary>
+        public IEnumerable<KeyValuePair<FuncDecl, Expr>> Consts
+        {
+            get
+            {
+                uint nc = NumConsts;
+                for (uint i = 0; i < nc; ++i)
+                {
+                    var f = new FuncDecl(Context, Native.Z3_model_get_const_decl(Context.nCtx, NativeObject, i));
+                    IntPtr n = Native.Z3_model_get_const_interp(Context.nCtx, NativeObject, f.NativeObject);
+                    if (n == IntPtr.Zero) continue;
+                    yield return new KeyValuePair<FuncDecl, Expr>(f, Expr.Create(Context, n));
+                }
+            }
+        }
+
         /// <summary>
         /// The number of function interpretations in the model.
         /// </summary>

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/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);
     }
 
     /**
@@ -1277,6 +1270,35 @@ public class Expr extends AST
         return isApp() && getFuncDecl().getDeclKind() == Z3_decl_kind.Z3_OP_LABEL_LIT;
     }
 
+    /**
+     * Check whether expression is a string constant.
+     * @return a boolean
+     */
+    public boolean isString() 
+    {
+        return isApp() && Native.isString(getContext().nCtx(), getNativeObject());
+    }
+
+    /**
+     * Retrieve string corresponding to string constant.
+     * Remark: the expression should be a string constant, (isString() should return true).
+     * @throws Z3Exception on error
+     * @return a string
+     */
+    public String getString()
+    {
+	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/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

@@ -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)
@@ -6369,6 +6414,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)
@@ -6743,6 +6791,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)
@@ -6895,6 +6946,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)
@@ -7023,6 +7077,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)
@@ -7295,6 +7352,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.
 
@@ -5238,7 +5239,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 +5349,10 @@ extern "C" {
 
     /**
        \brief Add a new formula \c a to the given goal.
+        Conjunctions are split into 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 +5795,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 +5833,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)))
     */

src/ast/CMakeLists.txt

@@ -0,0 +1,48 @@
+z3_add_component(ast
+  SOURCES
+    act_cache.cpp
+    arith_decl_plugin.cpp
+    array_decl_plugin.cpp
+    ast.cpp
+    ast_ll_pp.cpp
+    ast_lt.cpp
+    ast_pp_util.cpp
+    ast_printer.cpp
+    ast_smt2_pp.cpp
+    ast_smt_pp.cpp
+    ast_translation.cpp
+    ast_util.cpp
+    bv_decl_plugin.cpp
+    datatype_decl_plugin.cpp
+    decl_collector.cpp
+    dl_decl_plugin.cpp
+    expr2polynomial.cpp
+    expr2var.cpp
+    expr_abstract.cpp
+    expr_functors.cpp
+    expr_map.cpp
+    expr_stat.cpp
+    expr_substitution.cpp
+    for_each_ast.cpp
+    for_each_expr.cpp
+    format.cpp
+    fpa_decl_plugin.cpp
+    func_decl_dependencies.cpp
+    has_free_vars.cpp
+    macro_substitution.cpp
+    num_occurs.cpp
+    occurs.cpp
+    pb_decl_plugin.cpp
+    pp.cpp
+    reg_decl_plugins.cpp
+    seq_decl_plugin.cpp
+    shared_occs.cpp
+    static_features.cpp
+    used_vars.cpp
+    well_sorted.cpp
+  COMPONENT_DEPENDENCIES
+    polynomial
+    util # Unnecessary? polynomial already depends on util
+  PYG_FILES
+    pp_params.pyg
+)

src/ast/ast.h

@@ -2082,6 +2082,7 @@ public:
 
     bool is_undef_proof(expr const * e) const { return e == m_undef_proof; }
     bool is_asserted(expr const * e) const { return is_app_of(e, m_basic_family_id, PR_ASSERTED); }
+    bool is_hypothesis (expr const *e) const {return is_app_of (e, m_basic_family_id, PR_HYPOTHESIS);}
     bool is_goal(expr const * e) const { return is_app_of(e, m_basic_family_id, PR_GOAL); }
     bool is_modus_ponens(expr const * e) const { return is_app_of(e, m_basic_family_id, PR_MODUS_PONENS); }
     bool is_reflexivity(expr const * e) const { return is_app_of(e, m_basic_family_id, PR_REFLEXIVITY); }
@@ -2112,6 +2113,7 @@ public:
     bool is_skolemize(expr const * e) const { return is_app_of(e, m_basic_family_id, PR_SKOLEMIZE); }
 
     MATCH_UNARY(is_asserted);
+    MATCH_UNARY(is_hypothesis);
     MATCH_UNARY(is_lemma);
 
     bool has_fact(proof const * p) const {

src/ast/ast_smt2_pp.cpp

@@ -557,7 +557,14 @@ class smt2_printer {
         format * f;
         if (v->get_idx() < m_var_names.size()) {
             symbol s = m_var_names[m_var_names.size() - v->get_idx() - 1];
-            f = mk_string(m(), s.str().c_str());
+            std::string vname;
+            if (is_smt2_quoted_symbol (s)) {
+                vname = mk_smt2_quoted_symbol (s);
+            }
+            else {
+                vname = s.str();
+            }
+            f = mk_string(m(), vname.c_str ());
         }
         else {
             // fallback... it is not supposed to happen when the printer is correctly used.
@@ -884,7 +891,14 @@ class smt2_printer {
         symbol * it = m_var_names.end() - num_decls;
         for (unsigned i = 0; i < num_decls; i++, it++) {
             format * fs[1] = { m_env.pp_sort(q->get_decl_sort(i)) };
-            buf.push_back(mk_seq1<format**,f2f>(m(), fs, fs+1, f2f(), it->str().c_str()));
+            std::string var_name;
+            if (is_smt2_quoted_symbol (*it)) {
+                var_name = mk_smt2_quoted_symbol (*it);
+            }
+            else {
+              var_name = it->str ();\
+            }
+            buf.push_back(mk_seq1<format**,f2f>(m(), fs, fs+1, f2f(), var_name.c_str ()));
         }
         return mk_seq5(m(), buf.begin(), buf.end(), f2f());
     }

src/ast/expr_map.h

@@ -35,6 +35,13 @@ class expr_map {
     obj_map<expr, expr*>  m_expr2expr;
     obj_map<expr, proof*> m_expr2pr;
 public:
+    typedef obj_map<expr, expr*> Map;
+    typedef Map::iterator iterator;
+    typedef Map::key key;
+    typedef Map::value value;
+    typedef Map::data data;
+    typedef Map::entry entry;
+
     expr_map(ast_manager & m);
     expr_map(ast_manager & m, bool store_proofs);
     ~expr_map();
@@ -44,6 +51,8 @@ public:
     void erase(expr * k);
     void reset();
     void flush();
+    iterator begin () const { return m_expr2expr.begin (); }
+    iterator end () const {return m_expr2expr.end (); }
     void set_store_proofs(bool f) { 
         if (m_store_proofs != f) flush();
         m_store_proofs = f; 

src/ast/fpa/CMakeLists.txt

@@ -0,0 +1,13 @@
+z3_add_component(fpa
+  SOURCES
+    bv2fpa_converter.cpp
+    fpa2bv_converter.cpp
+    fpa2bv_rewriter.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+    simplifier
+    model
+    util
+  PYG_FILES
+    fpa2bv_rewriter_params.pyg
+)

src/ast/macros/CMakeLists.txt

@@ -0,0 +1,9 @@
+z3_add_component(macros
+  SOURCES
+    macro_finder.cpp
+    macro_manager.cpp
+    macro_util.cpp
+    quasi_macros.cpp
+  COMPONENT_DEPENDENCIES
+    simplifier
+)

src/ast/normal_forms/CMakeLists.txt

@@ -0,0 +1,11 @@
+z3_add_component(normal_forms
+  SOURCES
+    defined_names.cpp
+    name_exprs.cpp
+    nnf.cpp
+    pull_quant.cpp
+  COMPONENT_DEPENDENCIES
+    rewriter
+  PYG_FILES
+    nnf_params.pyg
+)

src/ast/pattern/CMakeLists.txt

@@ -0,0 +1,36 @@
+# If this code for adding the rule to generate the database file is ever needed
+# for other components then we should refactor this code into
+# z3_add_component()
+if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/database.h")
+  message(FATAL_ERROR "The generated file \"database.h\""
+          ${z3_polluted_tree_msg})
+endif()
+
+add_custom_command(OUTPUT "database.h"
+  COMMAND "${PYTHON_EXECUTABLE}"
+          "${CMAKE_SOURCE_DIR}/scripts/mk_pat_db.py"
+          "${CMAKE_CURRENT_SOURCE_DIR}/database.smt2"
+          "${CMAKE_CURRENT_BINARY_DIR}/database.h"
+  MAIN_DEPENDENCY "${CMAKE_CURRENT_SOURCE_DIR}/database.smt2"
+  DEPENDS "${CMAKE_SOURCE_DIR}/scripts/mk_pat_db.py"
+          ${Z3_GENERATED_FILE_EXTRA_DEPENDENCIES}
+  COMMENT "Generating \"database.h\""
+  ${ADD_CUSTOM_COMMAND_USES_TERMINAL_ARG}
+  VERBATIM
+)
+
+z3_add_component(pattern
+  SOURCES
+    expr_pattern_match.cpp
+    pattern_inference.cpp
+    pattern_inference_params.cpp
+    # Let CMake know this target depends on this generated
+    # header file
+    ${CMAKE_CURRENT_BINARY_DIR}/database.h
+  COMPONENT_DEPENDENCIES
+    normal_forms
+    simplifier
+    smt2parser
+  PYG_FILES
+    pattern_inference_params_helper.pyg
+)

src/ast/proof_checker/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(proof_checker
+  SOURCES
+    proof_checker.cpp
+  COMPONENT_DEPENDENCIES
+    rewriter
+)

src/ast/rewriter/CMakeLists.txt

@@ -0,0 +1,41 @@
+z3_add_component(rewriter
+  SOURCES
+    arith_rewriter.cpp
+    array_rewriter.cpp
+    ast_counter.cpp
+    bool_rewriter.cpp
+    bv_bounds.cpp
+    bv_rewriter.cpp
+    datatype_rewriter.cpp
+    der.cpp
+    distribute_forall.cpp
+    dl_rewriter.cpp
+    enum2bv_rewriter.cpp
+    expr_replacer.cpp
+    expr_safe_replace.cpp
+    factor_rewriter.cpp
+    fpa_rewriter.cpp
+    label_rewriter.cpp
+    mk_simplified_app.cpp
+    pb_rewriter.cpp
+    pb2bv_rewriter.cpp
+    quant_hoist.cpp
+    rewriter.cpp
+    seq_rewriter.cpp
+    th_rewriter.cpp
+    var_subst.cpp
+    bv_trailing.cpp
+    mk_extract_proc.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+    automata
+    polynomial
+  PYG_FILES
+    arith_rewriter_params.pyg
+    array_rewriter_params.pyg
+    bool_rewriter_params.pyg
+    bv_rewriter_params.pyg
+    fpa_rewriter_params.pyg
+    poly_rewriter_params.pyg
+    rewriter_params.pyg
+)

src/ast/rewriter/bit_blaster/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(bit_blaster
+  SOURCES
+    bit_blaster.cpp
+    bit_blaster_rewriter.cpp
+  COMPONENT_DEPENDENCIES
+    rewriter
+    simplifier
+)

src/ast/simplifier/CMakeLists.txt

@@ -0,0 +1,29 @@
+z3_add_component(simplifier
+  SOURCES
+    arith_simplifier_params.cpp
+    arith_simplifier_plugin.cpp
+    array_simplifier_params.cpp
+    array_simplifier_plugin.cpp
+    basic_simplifier_plugin.cpp
+    bit2int.cpp
+    bv_elim.cpp
+    bv_simplifier_params.cpp
+    bv_simplifier_plugin.cpp
+    datatype_simplifier_plugin.cpp
+    elim_bounds.cpp
+    fpa_simplifier_plugin.cpp
+    inj_axiom.cpp
+    maximise_ac_sharing.cpp
+    poly_simplifier_plugin.cpp
+    pull_ite_tree.cpp
+    push_app_ite.cpp
+    seq_simplifier_plugin.cpp
+    simplifier.cpp
+    simplifier_plugin.cpp
+  COMPONENT_DEPENDENCIES
+    rewriter
+  PYG_FILES
+    arith_simplifier_params_helper.pyg
+    array_simplifier_params_helper.pyg
+    bv_simplifier_params_helper.pyg
+)

src/ast/substitution/CMakeLists.txt

@@ -0,0 +1,10 @@
+z3_add_component(substitution
+  SOURCES
+    matcher.cpp
+    substitution.cpp
+    substitution_tree.cpp
+    unifier.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+    rewriter
+)

src/cmd_context/CMakeLists.txt

@@ -0,0 +1,21 @@
+z3_add_component(cmd_context
+  SOURCES
+    basic_cmds.cpp
+    check_logic.cpp
+    cmd_context.cpp
+    cmd_context_to_goal.cpp
+    cmd_util.cpp
+    context_params.cpp
+    echo_tactic.cpp
+    eval_cmd.cpp
+    interpolant_cmds.cpp
+    parametric_cmd.cpp
+    pdecl.cpp
+    simplify_cmd.cpp
+    tactic_cmds.cpp
+    tactic_manager.cpp
+  COMPONENT_DEPENDENCIES
+    interp
+    rewriter
+    solver
+)

src/cmd_context/basic_cmds.cpp

@@ -39,7 +39,7 @@ class help_cmd : public cmd {
         ctx.regular_stream() << " (" << s;
         if (usage)
             ctx.regular_stream() << " " << escaped(usage, true) << ")\n";
-        else 
+        else
             ctx.regular_stream() << ")\n";
         if (descr) {
             ctx.regular_stream() << "    " << escaped(descr, true, 4) << "\n";
@@ -62,7 +62,7 @@ public:
         }
         m_cmds.push_back(s);
     }
-    
+
     typedef std::pair<symbol, cmd*> named_cmd;
     struct named_cmd_lt {
         bool operator()(named_cmd const & c1, named_cmd const & c2) const { return c1.first.str() < c2.first.str(); }
@@ -104,14 +104,14 @@ class get_model_cmd : public cmd {
     unsigned m_index;
 public:
     get_model_cmd(): cmd("get-model"), m_index(0) {}
-    virtual char const * get_usage() const { return "[<index of box objective>]"; }   
-    virtual char const * get_descr(cmd_context & ctx) const { 
-        return "retrieve model for the last check-sat command.\nSupply optional index if retrieving a model corresponding to a box optimization objective"; 
+    virtual char const * get_usage() const { return "[<index of box objective>]"; }
+    virtual char const * get_descr(cmd_context & ctx) const {
+        return "retrieve model for the last check-sat command.\nSupply optional index if retrieving a model corresponding to a box optimization objective";
     }
-    virtual unsigned get_arity() const { return VAR_ARITY; } 
+    virtual unsigned get_arity() const { return VAR_ARITY; }
     virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_UINT; }
-    virtual void set_next_arg(cmd_context & ctx, unsigned index) { m_index = index; }                           
-    virtual void execute(cmd_context & ctx) { 
+    virtual void set_next_arg(cmd_context & ctx, unsigned index) { m_index = index; }
+    virtual void execute(cmd_context & ctx) {
         if (!ctx.is_model_available() || ctx.get_check_sat_result() == 0)
             throw cmd_exception("model is not available");
         model_ref m;
@@ -122,7 +122,7 @@ public:
             ctx.get_check_sat_result()->get_model(m);
         }
         ctx.display_model(m);
-    }                    
+    }
     virtual void reset(cmd_context& ctx) {
         m_index = 0;
     }
@@ -149,7 +149,14 @@ ATOMIC_CMD(get_assignment_cmd, "get-assignment", "retrieve assignment", {
                     first = false;
                 else
                     ctx.regular_stream() << " ";
-                ctx.regular_stream() << "(" << name << " " << (ctx.m().is_true(val) ? "true" : "false") << ")";
+                ctx.regular_stream() << "(";
+                if (is_smt2_quoted_symbol(name)) {
+                    ctx.regular_stream() << mk_smt2_quoted_symbol(name);
+                }
+                else {
+                    ctx.regular_stream() << name;
+                }
+                ctx.regular_stream() << " " << (ctx.m().is_true(val) ? "true" : "false") << ")";
             }
         }
     }
@@ -160,11 +167,11 @@ class cmd_is_declared : public ast_smt_pp::is_declared {
     cmd_context& m_ctx;
 public:
     cmd_is_declared(cmd_context& ctx): m_ctx(ctx) {}
-    
-    virtual bool operator()(func_decl* d) const { 
+
+    virtual bool operator()(func_decl* d) const {
         return m_ctx.is_func_decl(d->get_name());
     }
-    virtual bool operator()(sort* s) const { 
+    virtual bool operator()(sort* s) const {
         return m_ctx.is_sort_decl(s->get_name());
     }
 };
@@ -182,13 +189,13 @@ ATOMIC_CMD(get_proof_cmd, "get-proof", "retrieve proof", {
     if (ctx.well_sorted_check_enabled() && !is_well_sorted(ctx.m(), pr)) {
         throw cmd_exception("proof is not well sorted");
     }
-    
+
     pp_params params;
     if (params.pretty_proof()) {
         ctx.regular_stream() << mk_pp(pr, ctx.m()) << std::endl;
     }
     else {
-        // TODO: reimplement a new SMT2 pretty printer 
+        // TODO: reimplement a new SMT2 pretty printer
         ast_smt_pp pp(ctx.m());
         cmd_is_declared isd(ctx);
         pp.set_is_declared(&isd);
@@ -198,20 +205,21 @@ ATOMIC_CMD(get_proof_cmd, "get-proof", "retrieve proof", {
     }
 });
 
-#define PRINT_CORE()                                            \
-    ptr_vector<expr> core;                                      \
-    ctx.get_check_sat_result()->get_unsat_core(core);           \
-    ctx.regular_stream() << "(";                                \
-    ptr_vector<expr>::const_iterator it  = core.begin();        \
-    ptr_vector<expr>::const_iterator end = core.end();          \
-    for (bool first = true; it != end; ++it) {                  \
-    if (first)                                                  \
-        first = false;                                          \
-    else                                                        \
-        ctx.regular_stream() << " ";                            \
-    ctx.regular_stream() << mk_ismt2_pp(*it, ctx.m());          \
-    }                                                           \
-    ctx.regular_stream() << ")" << std::endl;                   \
+static void print_core(cmd_context& ctx) {
+    ptr_vector<expr> core;
+    ctx.get_check_sat_result()->get_unsat_core(core);
+    ctx.regular_stream() << "(";
+    ptr_vector<expr>::const_iterator it  = core.begin();
+    ptr_vector<expr>::const_iterator end = core.end();
+    for (bool first = true; it != end; ++it) {
+    if (first)
+        first = false;
+    else
+        ctx.regular_stream() << " ";
+    ctx.regular_stream() << mk_ismt2_pp(*it, ctx.m());
+    }
+    ctx.regular_stream() << ")" << std::endl;
+}
 
 ATOMIC_CMD(get_unsat_core_cmd, "get-unsat-core", "retrieve unsat core", {
         if (!ctx.produce_unsat_cores())
@@ -219,7 +227,7 @@ ATOMIC_CMD(get_unsat_core_cmd, "get-unsat-core", "retrieve unsat core", {
         if (!ctx.has_manager() ||
             ctx.cs_state() != cmd_context::css_unsat)
             throw cmd_exception("unsat core is not available");
-        PRINT_CORE();
+        print_core(ctx);
     });
 
 ATOMIC_CMD(get_unsat_assumptions_cmd, "get-unsat-assumptions", "retrieve subset of assumptions sufficient for unsatisfiability", {
@@ -228,7 +236,7 @@ ATOMIC_CMD(get_unsat_assumptions_cmd, "get-unsat-assumptions", "retrieve subset
         if (!ctx.has_manager() || ctx.cs_state() != cmd_context::css_unsat) {
             throw cmd_exception("unsat assumptions is not available");
         }
-        PRINT_CORE();
+        print_core(ctx);
     });
 
 
@@ -250,9 +258,9 @@ ATOMIC_CMD(get_assertions_cmd, "get-assertions", "retrieve asserted terms when i
 
 
 
-ATOMIC_CMD(reset_assertions_cmd, "reset-assertions", "reset all asserted formulas (but retain definitions and declarations)", ctx.reset_assertions(););
+ATOMIC_CMD(reset_assertions_cmd, "reset-assertions", "reset all asserted formulas (but retain definitions and declarations)", ctx.reset_assertions(); ctx.print_success(););
 
-UNARY_CMD(set_logic_cmd, "set-logic", "<symbol>", "set the background logic.", CPK_SYMBOL, symbol const &, 
+UNARY_CMD(set_logic_cmd, "set-logic", "<symbol>", "set the background logic.", CPK_SYMBOL, symbol const &,
           if (ctx.set_logic(arg))
               ctx.print_success();
           else {
@@ -261,12 +269,14 @@ UNARY_CMD(set_logic_cmd, "set-logic", "<symbol>", "set the background logic.", C
           }
           );
 
-UNARY_CMD(pp_cmd, "display", "<term>", "display the given term.", CPK_EXPR, expr *, { 
+UNARY_CMD(pp_cmd, "display", "<term>", "display the given term.", CPK_EXPR, expr *, {
     ctx.display(ctx.regular_stream(), arg);
-    ctx.regular_stream() << std::endl; 
+    ctx.regular_stream() << std::endl;
 });
 
-UNARY_CMD(echo_cmd, "echo", "<string>", "display the given string", CPK_STRING, char const *, ctx.regular_stream() << arg << std::endl;);
+UNARY_CMD(echo_cmd, "echo", "<string>", "display the given string", CPK_STRING, char const *,
+    bool smt2c = ctx.params().m_smtlib2_compliant;
+    ctx.regular_stream() << (smt2c ? "\"" : "") << arg << (smt2c ? "\"" : "") << std::endl;);
 
 
 class set_get_option_cmd : public cmd {
@@ -297,18 +307,18 @@ protected:
     symbol      m_reproducible_resource_limit;
 
     bool is_builtin_option(symbol const & s) const {
-        return 
-            s == m_print_success || s == m_print_warning || s == m_expand_definitions || 
+        return
+            s == m_print_success || s == m_print_warning || s == m_expand_definitions ||
             s == m_interactive_mode || s == m_produce_proofs || s == m_produce_unsat_cores || s == m_produce_unsat_assumptions ||
             s == m_produce_models || s == m_produce_assignments || s == m_produce_interpolants ||
-            s == m_regular_output_channel || s == m_diagnostic_output_channel || 
+            s == m_regular_output_channel || s == m_diagnostic_output_channel ||
             s == m_random_seed || s == m_verbosity || s == m_global_decls || s == m_global_declarations ||
             s == m_produce_assertions || s == m_reproducible_resource_limit;
     }
 
 public:
     set_get_option_cmd(char const * name):
-        cmd(name), 
+        cmd(name),
         m_true("true"),
         m_false("false"),
         m_print_success(":print-success"),
@@ -340,7 +350,7 @@ public:
 class set_option_cmd : public set_get_option_cmd {
     bool        m_unsupported;
     symbol      m_option;
-    
+
     bool to_bool(symbol const & value) const {
         if (value != m_true && value != m_false)
             throw cmd_exception("invalid option value, true/false expected");
@@ -361,7 +371,7 @@ class set_option_cmd : public set_get_option_cmd {
             throw cmd_exception(msg);
         }
     }
-    
+
     void set_param(cmd_context & ctx, char const * value) {
         try {
             gparams::set(m_option, value);
@@ -458,11 +468,11 @@ public:
 
     virtual void prepare(cmd_context & ctx) { m_unsupported = false; m_option = symbol::null; }
 
-    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { 
+    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
         return m_option == symbol::null ? CPK_KEYWORD : CPK_OPTION_VALUE;
     }
 
-    virtual void set_next_arg(cmd_context & ctx, symbol const & opt) { 
+    virtual void set_next_arg(cmd_context & ctx, symbol const & opt) {
         if (m_option == symbol::null) {
             m_option = opt;
         }
@@ -517,7 +527,7 @@ class get_option_cmd : public set_get_option_cmd {
     static void print_bool(cmd_context & ctx, bool b) {
         ctx.regular_stream() << (b ? "true" : "false") << std::endl;
     }
-    
+
     static void print_unsigned(cmd_context & ctx, unsigned v) {
         ctx.regular_stream() << v << std::endl;
     }
@@ -534,11 +544,11 @@ public:
     virtual char const * get_descr(cmd_context & ctx) const { return "get configuration option."; }
     virtual unsigned get_arity() const { return 1; }
     virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_KEYWORD; }
-    virtual void set_next_arg(cmd_context & ctx, symbol const & opt) { 
+    virtual void set_next_arg(cmd_context & ctx, symbol const & opt) {
         if (opt == m_print_success) {
-            print_bool(ctx, ctx.print_success_enabled()); 
+            print_bool(ctx, ctx.print_success_enabled());
         }
-        // TODO: 
+        // TODO:
         // else if (opt == m_print_warning) {
         // print_bool(ctx, );
         // }
@@ -628,7 +638,7 @@ public:
     virtual char const * get_descr(cmd_context & ctx) const { return "get information."; }
     virtual unsigned get_arity() const { return 1; }
     virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_KEYWORD; }
-    virtual void set_next_arg(cmd_context & ctx, symbol const & opt) { 
+    virtual void set_next_arg(cmd_context & ctx, symbol const & opt) {
         if (opt == m_error_behavior) {
             if (ctx.exit_on_error())
                 ctx.regular_stream() << "(:error-behavior immediate-exit)" << std::endl;
@@ -684,12 +694,12 @@ public:
     virtual char const * get_descr(cmd_context & ctx) const { return "set information."; }
     virtual unsigned get_arity() const { return 2; }
     virtual void prepare(cmd_context & ctx) { m_info = symbol::null; }
-    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { 
-        return m_info == symbol::null ? CPK_KEYWORD : CPK_OPTION_VALUE; 
+    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
+        return m_info == symbol::null ? CPK_KEYWORD : CPK_OPTION_VALUE;
     }
     virtual void set_next_arg(cmd_context & ctx, rational const & val) {}
     virtual void set_next_arg(cmd_context & ctx, char const * val) {}
-    virtual void set_next_arg(cmd_context & ctx, symbol const & s) { 
+    virtual void set_next_arg(cmd_context & ctx, symbol const & s) {
         if (m_info == symbol::null) {
             m_info = s;
         }
@@ -737,7 +747,7 @@ public:
     virtual char const * get_descr(cmd_context & ctx) const { return "declare a new array map operator with name <symbol> using the given function declaration.\n<func-decl-ref> ::= <symbol>\n                  | (<symbol> (<sort>*) <sort>)\n                  | ((_ <symbol> <numeral>+) (<sort>*) <sort>)\nThe last two cases are used to disumbiguate between declarations with the same name and/or select (indexed) builtin declarations.\nFor more details about the the array map operator, see 'Generalized and Efficient Array Decision Procedures' (FMCAD 2009).\nExample: (declare-map set-union (Int) (or (Bool Bool) Bool))\nDeclares a new function (declare-fun set-union ((Array Int Bool) (Array Int Bool)) (Array Int Bool)).\nThe instance of the map axiom for this new declaration is:\n(forall ((a1 (Array Int Bool)) (a2 (Array Int Bool)) (i Int)) (= (select (set-union a1 a2) i) (or (select a1 i) (select a2 i))))"; }
     virtual unsigned get_arity() const { return 3; }
     virtual void prepare(cmd_context & ctx) { m_name = symbol::null; m_domain.reset(); }
-    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { 
+    virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const {
         if (m_name == symbol::null) return CPK_SYMBOL;
         if (m_domain.empty()) return CPK_SORT_LIST;
         return CPK_FUNC_DECL;
@@ -748,10 +758,10 @@ public:
             throw cmd_exception("invalid map declaration, empty sort list");
         m_domain.append(num, slist);
     }
-    virtual void set_next_arg(cmd_context & ctx, func_decl * f) { 
-        m_f = f; 
-        if (m_f->get_arity() == 0) 
-            throw cmd_exception("invalid map declaration, function declaration must have arity > 0"); 
+    virtual void set_next_arg(cmd_context & ctx, func_decl * f) {
+        m_f = f;
+        if (m_f->get_arity() == 0)
+            throw cmd_exception("invalid map declaration, function declaration must have arity > 0");
     }
     virtual void reset(cmd_context & ctx) {
         m_array_fid = null_family_id;
@@ -790,7 +800,7 @@ public:
     virtual char const * get_descr(cmd_context & ctx) const { return "retrieve consequences that fix values for supplied variables"; }
     virtual unsigned get_arity() const { return 2; }
     virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_EXPR_LIST; }
-    virtual void set_next_arg(cmd_context & ctx, unsigned num, expr * const * tlist) { 
+    virtual void set_next_arg(cmd_context & ctx, unsigned num, expr * const * tlist) {
         if (m_count == 0) {
             m_assumptions.append(num, tlist);
             ++m_count;
@@ -850,7 +860,7 @@ void install_basic_cmds(cmd_context & ctx) {
     ctx.insert(alloc(builtin_cmd, "declare-fun", "<symbol> (<sort>*) <sort>", "declare a new function/constant."));
     ctx.insert(alloc(builtin_cmd, "declare-const", "<symbol> <sort>", "declare a new constant."));
     ctx.insert(alloc(builtin_cmd, "declare-datatypes", "(<symbol>*) (<datatype-declaration>+)", "declare mutually recursive datatypes.\n<datatype-declaration> ::= (<symbol> <constructor-decl>+)\n<constructor-decl> ::= (<symbol> <accessor-decl>*)\n<accessor-decl> ::= (<symbol> <sort>)\nexample: (declare-datatypes (T) ((BinTree (leaf (value T)) (node (left BinTree) (right BinTree)))))"));
-    ctx.insert(alloc(builtin_cmd, "check-sat-asuming", "( hprop_literali* )", "check sat assuming a collection of literals"));
+    ctx.insert(alloc(builtin_cmd, "check-sat-assuming", "( hprop_literali* )", "check sat assuming a collection of literals"));
 
     ctx.insert(alloc(get_unsat_assumptions_cmd));
     ctx.insert(alloc(reset_assertions_cmd));

src/cmd_context/cmd_context.cpp

@@ -15,6 +15,7 @@ Author:
 Notes:
 
 --*/
+
 #include<signal.h>
 #include"tptr.h"
 #include"cmd_context.h"
@@ -325,8 +326,8 @@ cmd_context::cmd_context(bool main_ctx, ast_manager * m, symbol const & l):
     m_status(UNKNOWN),
     m_numeral_as_real(false),
     m_ignore_check(false),
-    m_exit_on_error(false),
     m_processing_pareto(false),
+    m_exit_on_error(false),
     m_manager(m),
     m_own_manager(m == 0),
     m_manager_initialized(false),

src/cmd_context/cmd_context.h

@@ -159,7 +159,7 @@ protected:
     bool                         m_produce_assignments;
     status                       m_status;
     bool                         m_numeral_as_real;
-    bool                         m_ignore_check; // used by the API to disable check-sat() commands when parsing SMT 2.0 files.
+    bool                         m_ignore_check;      // used by the API to disable check-sat() commands when parsing SMT 2.0 files.
     bool                         m_processing_pareto; // used when re-entering check-sat for pareto front.
     bool                         m_exit_on_error;
     

src/cmd_context/extra_cmds/CMakeLists.txt

@@ -0,0 +1,10 @@
+z3_add_component(extra_cmds
+  SOURCES
+    dbg_cmds.cpp
+    polynomial_cmds.cpp
+    subpaving_cmds.cpp
+  COMPONENT_DEPENDENCIES
+    arith_tactics
+    cmd_context
+    subpaving_tactic
+)

src/duality/CMakeLists.txt

@@ -0,0 +1,11 @@
+z3_add_component(duality
+  SOURCES
+    duality_profiling.cpp
+    duality_rpfp.cpp
+    duality_solver.cpp
+    duality_wrapper.cpp
+  COMPONENT_DEPENDENCIES
+    interp
+    qe
+    smt
+)

src/interp/CMakeLists.txt

@@ -0,0 +1,18 @@
+z3_add_component(interp
+  SOURCES
+    iz3base.cpp
+    iz3checker.cpp
+    iz3interp.cpp
+    iz3mgr.cpp
+    iz3pp.cpp
+    iz3profiling.cpp
+    iz3proof.cpp
+    iz3proof_itp.cpp
+    iz3scopes.cpp
+    iz3translate.cpp
+    iz3translate_direct.cpp
+  COMPONENT_DEPENDENCIES
+    solver
+  PYG_FILES
+    interp_params.pyg
+)

src/math/automata/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(automata
+  SOURCES
+    automaton.cpp
+  COMPONENT_DEPENDENCIES
+    util
+)

src/math/euclid/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(euclid
+  SOURCES
+    euclidean_solver.cpp
+  COMPONENT_DEPENDENCIES
+    util
+)

src/math/grobner/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(grobner
+  SOURCES
+    grobner.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+)

src/math/hilbert/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(hilbert
+  SOURCES
+    hilbert_basis.cpp
+  COMPONENT_DEPENDENCIES
+    util
+)

src/math/interval/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(interval
+  SOURCES
+    interval_mpq.cpp
+  COMPONENT_DEPENDENCIES
+    util
+)

src/math/polynomial/CMakeLists.txt

@@ -0,0 +1,15 @@
+z3_add_component(polynomial
+  SOURCES
+    algebraic_numbers.cpp
+    polynomial_cache.cpp
+    polynomial.cpp
+    rpolynomial.cpp
+    sexpr2upolynomial.cpp
+    upolynomial.cpp
+    upolynomial_factorization.cpp
+  COMPONENT_DEPENDENCIES
+    util
+  PYG_FILES
+    algebraic_params.pyg
+)
+

src/math/realclosure/CMakeLists.txt

@@ -0,0 +1,9 @@
+z3_add_component(realclosure
+  SOURCES
+    mpz_matrix.cpp
+    realclosure.cpp
+  COMPONENT_DEPENDENCIES
+    interval
+  PYG_FILES
+    rcf_params.pyg
+)

src/math/simplex/CMakeLists.txt

@@ -0,0 +1,7 @@
+z3_add_component(simplex
+  SOURCES
+    simplex.cpp
+    model_based_opt.cpp
+  COMPONENT_DEPENDENCIES
+    util
+)

src/math/subpaving/CMakeLists.txt

@@ -0,0 +1,11 @@
+z3_add_component(subpaving
+  SOURCES
+    subpaving.cpp
+    subpaving_hwf.cpp
+    subpaving_mpf.cpp
+    subpaving_mpff.cpp
+    subpaving_mpfx.cpp
+    subpaving_mpq.cpp
+  COMPONENT_DEPENDENCIES
+    interval
+)

src/math/subpaving/tactic/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(subpaving_tactic
+  SOURCES
+    expr2subpaving.cpp
+    subpaving_tactic.cpp
+  COMPONENT_DEPENDENCIES
+    core_tactics
+    subpaving
+)

src/model/CMakeLists.txt

@@ -0,0 +1,18 @@
+z3_add_component(model
+  SOURCES
+    func_interp.cpp
+    model2expr.cpp
+    model_core.cpp
+    model.cpp
+    model_evaluator.cpp
+    model_implicant.cpp
+    model_pp.cpp
+    model_smt2_pp.cpp
+    model_v2_pp.cpp
+  COMPONENT_DEPENDENCIES
+    rewriter
+  PYG_FILES
+    model_evaluator_params.pyg
+    model_params.pyg
+)
+

src/muz/base/CMakeLists.txt

@@ -0,0 +1,23 @@
+z3_add_component(muz
+  SOURCES
+    bind_variables.cpp
+    dl_boogie_proof.cpp
+    dl_context.cpp
+    dl_costs.cpp
+    dl_rule.cpp
+    dl_rule_set.cpp
+    dl_rule_subsumption_index.cpp
+    dl_rule_transformer.cpp
+    dl_util.cpp
+    hnf.cpp
+    proof_utils.cpp
+    rule_properties.cpp
+  COMPONENT_DEPENDENCIES
+    aig_tactic
+    qe
+    sat
+    smt
+    smt2parser
+  PYG_FILES
+    fixedpoint_params.pyg
+)

src/muz/base/dl_rule.cpp

@@ -784,7 +784,7 @@ namespace datalog {
 
         SASSERT(tail.size()==tail_neg.size());
         rule_ref old_r = r;
-        r = mk(head, tail.size(), tail.c_ptr(), tail_neg.c_ptr());
+        r = mk(head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), old_r->name());
         r->set_accounting_parent_object(m_ctx, old_r);
     }
 
@@ -1003,6 +1003,7 @@ namespace datalog {
 
     void rule::display(context & ctx, std::ostream & out) const {
         ast_manager & m = ctx.get_manager();
+        out << m_name.str () << ":\n";
         //out << mk_pp(m_head, m);
         output_predicate(ctx, m_head, out);
         if (m_tail_size == 0) {

src/muz/base/dl_rule.h

@@ -298,7 +298,7 @@ namespace datalog {
         
         static unsigned get_obj_size(unsigned n) { return sizeof(rule) + n * sizeof(app *); }
 
-        rule() : m_ref_cnt(0) {}
+        rule() : m_ref_cnt(0), m_name(symbol::null) {}
         ~rule() {}
 
         void deallocate(ast_manager & m);
@@ -355,7 +355,12 @@ namespace datalog {
 
         void display(context & ctx, std::ostream & out) const;
 
-        symbol const& name() const { return m_name; }
+        /**
+           \brief Return the name(s) associated with this rule. Plural for preprocessed (e.g. obtained by inlining) rules.
+
+           This possibly returns a ";"-separated list of names.
+        */
+        symbol const& name() const { return m_name; } ;
 
         unsigned hash() const;
 

src/muz/bmc/CMakeLists.txt

@@ -0,0 +1,7 @@
+z3_add_component(bmc
+  SOURCES
+    dl_bmc_engine.cpp
+  COMPONENT_DEPENDENCIES
+    muz
+    transforms
+)

src/muz/clp/CMakeLists.txt

@@ -0,0 +1,7 @@
+z3_add_component(clp
+  SOURCES
+    clp_context.cpp
+  COMPONENT_DEPENDENCIES
+    muz
+    transforms
+)

src/muz/dataflow/CMakeLists.txt

@@ -0,0 +1,6 @@
+z3_add_component(dataflow
+  SOURCES
+    dataflow.cpp
+  COMPONENT_DEPENDENCIES
+    muz
+)

src/muz/ddnf/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(ddnf
+  SOURCES
+    ddnf.cpp
+  COMPONENT_DEPENDENCIES
+    muz
+    rel
+    transforms
+)

src/muz/duality/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(duality_intf
+  SOURCES
+    duality_dl_interface.cpp
+  COMPONENT_DEPENDENCIES
+    duality
+    muz
+    transforms
+)

src/muz/fp/CMakeLists.txt

@@ -0,0 +1,16 @@
+z3_add_component(fp
+  SOURCES
+    datalog_parser.cpp
+    dl_cmds.cpp
+    dl_register_engine.cpp
+    horn_tactic.cpp
+  COMPONENT_DEPENDENCIES
+    bmc
+    clp
+    ddnf
+    duality_intf
+    muz
+    pdr
+    rel
+    tab
+)

src/muz/pdr/CMakeLists.txt

@@ -0,0 +1,20 @@
+z3_add_component(pdr
+  SOURCES
+    pdr_closure.cpp
+    pdr_context.cpp
+    pdr_dl_interface.cpp
+    pdr_farkas_learner.cpp
+    pdr_generalizers.cpp
+    pdr_manager.cpp
+    pdr_prop_solver.cpp
+    pdr_reachable_cache.cpp
+    pdr_smt_context_manager.cpp
+    pdr_sym_mux.cpp
+    pdr_util.cpp
+  COMPONENT_DEPENDENCIES
+    arith_tactics
+    core_tactics
+    muz
+    smt_tactic
+    transforms
+)

src/muz/rel/CMakeLists.txt

@@ -0,0 +1,31 @@
+z3_add_component(rel
+  SOURCES
+    aig_exporter.cpp
+    check_relation.cpp
+    dl_base.cpp
+    dl_bound_relation.cpp
+    dl_check_table.cpp
+    dl_compiler.cpp
+    dl_external_relation.cpp
+    dl_finite_product_relation.cpp
+    dl_instruction.cpp
+    dl_interval_relation.cpp
+    dl_lazy_table.cpp
+    dl_mk_explanations.cpp
+    dl_mk_similarity_compressor.cpp
+    dl_mk_simple_joins.cpp
+    dl_product_relation.cpp
+    dl_relation_manager.cpp
+    dl_sieve_relation.cpp
+    dl_sparse_table.cpp
+    dl_table.cpp
+    dl_table_relation.cpp
+    doc.cpp
+    karr_relation.cpp
+    rel_context.cpp
+    tbv.cpp
+    udoc_relation.cpp
+  COMPONENT_DEPENDENCIES
+    muz
+    transforms
+)

src/muz/tab/CMakeLists.txt

@@ -0,0 +1,7 @@
+z3_add_component(tab
+  SOURCES
+    tab_context.cpp
+  COMPONENT_DEPENDENCIES
+    muz
+    transforms
+)

src/muz/transforms/CMakeLists.txt

@@ -0,0 +1,28 @@
+z3_add_component(transforms
+  SOURCES
+    dl_mk_array_blast.cpp
+    dl_mk_backwards.cpp
+    dl_mk_bit_blast.cpp
+    dl_mk_coalesce.cpp
+    dl_mk_coi_filter.cpp
+    dl_mk_filter_rules.cpp
+    dl_mk_interp_tail_simplifier.cpp
+    dl_mk_karr_invariants.cpp
+    dl_mk_loop_counter.cpp
+    dl_mk_magic_sets.cpp
+    dl_mk_magic_symbolic.cpp
+    dl_mk_quantifier_abstraction.cpp
+    dl_mk_quantifier_instantiation.cpp
+    dl_mk_rule_inliner.cpp
+    dl_mk_scale.cpp
+    dl_mk_separate_negated_tails.cpp
+    dl_mk_slice.cpp
+    dl_mk_subsumption_checker.cpp
+    dl_mk_unbound_compressor.cpp
+    dl_mk_unfold.cpp
+    dl_transforms.cpp
+  COMPONENT_DEPENDENCIES
+    dataflow
+    hilbert
+    muz
+)

src/muz/transforms/dl_mk_filter_rules.cpp

@@ -140,7 +140,7 @@ namespace datalog {
         if (rule_modified) {
             remove_duplicate_tails(new_tail, new_is_negated);
             SASSERT(new_tail.size() == new_is_negated.size());
-            rule * new_rule = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(), new_is_negated.c_ptr());
+            rule * new_rule = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(), new_is_negated.c_ptr(), r->name());
             new_rule->set_accounting_parent_object(m_context, m_current);
             m_result->add_rule(new_rule);
             m_context.get_rule_manager().mk_rule_rewrite_proof(*r, *new_rule);

src/muz/transforms/dl_mk_interp_tail_simplifier.cpp

@@ -84,7 +84,7 @@ namespace datalog {
         mk_rule_inliner::remove_duplicate_tails(m_tail, m_neg);
 
         SASSERT(m_tail.size() == m_neg.size());
-        res = m_context.get_rule_manager().mk(m_head, m_tail.size(), m_tail.c_ptr(), m_neg.c_ptr());
+        res = m_context.get_rule_manager().mk(m_head, m_tail.size(), m_tail.c_ptr(), m_neg.c_ptr(),m_rule->name());
         res->set_accounting_parent_object(m_context, m_rule);
         res->norm_vars(res.get_manager());
     }
@@ -557,7 +557,7 @@ namespace datalog {
             }
 
             SASSERT(m_tail.size() == m_tail_neg.size());
-            res = m_context.get_rule_manager().mk(head, m_tail.size(), m_tail.c_ptr(), m_tail_neg.c_ptr());
+            res = m_context.get_rule_manager().mk(head, m_tail.size(), m_tail.c_ptr(), m_tail_neg.c_ptr(), r->name());
             res->set_accounting_parent_object(m_context, r);
         }
         else {

src/muz/transforms/dl_mk_magic_sets.cpp

@@ -280,7 +280,7 @@ namespace datalog {
         new_tail.push_back(create_magic_literal(new_head));
         negations.push_back(false);
 
-        rule * nr = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(), negations.c_ptr());
+        rule * nr = m_context.get_rule_manager().mk(new_head, new_tail.size(), new_tail.c_ptr(), negations.c_ptr(), r->name());
         result.add_rule(nr);
         nr->set_accounting_parent_object(m_context, r);
     }

src/muz/transforms/dl_mk_quantifier_abstraction.cpp

@@ -341,7 +341,7 @@ namespace datalog {
             head = mk_head(source, *result, r.get_head(), cnt);
             fml = m.mk_implies(m.mk_and(tail.size(), tail.c_ptr()), head);
             proof_ref pr(m);
-            rm.mk_rule(fml, pr, *result);
+            rm.mk_rule(fml, pr, *result, r.name());
             TRACE("dl", result->last()->display(m_ctx, tout););
         }        
         

src/muz/transforms/dl_mk_quantifier_instantiation.cpp

@@ -232,7 +232,7 @@ namespace datalog {
         
         rule_set added_rules(m_ctx);
         proof_ref pr(m); 
-        rm.mk_rule(fml, pr, added_rules);
+        rm.mk_rule(fml, pr, added_rules, r.name());
         if (r.get_proof()) {
             // use def-axiom to encode that new rule is a weakening of the original.
             proof* p1 = r.get_proof();

src/muz/transforms/dl_mk_rule_inliner.cpp

@@ -114,7 +114,10 @@ namespace datalog {
         apply(src, false, UINT_MAX,   tail, tail_neg);
         mk_rule_inliner::remove_duplicate_tails(tail, tail_neg);
         SASSERT(tail.size()==tail_neg.size());
-        res = m_rm.mk(new_head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), tgt.name(), m_normalize);
+        std::ostringstream comb_name;
+        comb_name << tgt.name().str() << ";" << src.name().str();
+        symbol combined_rule_name = symbol(comb_name.str().c_str());
+        res = m_rm.mk(new_head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), combined_rule_name, m_normalize);
         res->set_accounting_parent_object(m_context, const_cast<rule*>(&tgt));
         TRACE("dl",
               tgt.display(m_context,  tout << "tgt (" << tail_index << "): \n");

src/muz/transforms/dl_mk_slice.cpp

@@ -22,7 +22,7 @@ Revision History:
     input:  x, z
     output: x, y
 
-    Let x_i, y_i, z_i be incides into the vectors x, y, z.
+    Let x_i, y_i, z_i be indices into the vectors x, y, z.
 
     Suppose that positions in P and R are annotated with what is
     slicable.

src/muz/transforms/dl_mk_subsumption_checker.cpp

@@ -159,7 +159,7 @@ namespace datalog {
         }
 
         SASSERT(tail.size()==tail_neg.size());
-        res = m_context.get_rule_manager().mk(head, tail.size(), tail.c_ptr(), tail_neg.c_ptr());
+        res = m_context.get_rule_manager().mk(head, tail.size(), tail.c_ptr(), tail_neg.c_ptr(), r->name());
         res->set_accounting_parent_object(m_context, r);
         m_context.get_rule_manager().fix_unbound_vars(res, true);
         m_context.get_rule_manager().mk_rule_rewrite_proof(*r, *res.get());

src/nlsat/CMakeLists.txt

@@ -0,0 +1,14 @@
+z3_add_component(nlsat
+  SOURCES
+    nlsat_clause.cpp
+    nlsat_evaluator.cpp
+    nlsat_explain.cpp
+    nlsat_interval_set.cpp
+    nlsat_solver.cpp
+    nlsat_types.cpp
+  COMPONENT_DEPENDENCIES
+    polynomial
+    sat
+  PYG_FILES
+    nlsat_params.pyg
+)

src/nlsat/tactic/CMakeLists.txt

@@ -0,0 +1,10 @@
+z3_add_component(nlsat_tactic
+  SOURCES
+    goal2nlsat.cpp
+    nlsat_tactic.cpp
+    qfnra_nlsat_tactic.cpp
+  COMPONENT_DEPENDENCIES
+    arith_tactics
+    nlsat
+    sat_tactic
+)

src/opt/CMakeLists.txt

@@ -0,0 +1,21 @@
+z3_add_component(opt
+  SOURCES
+    maxres.cpp
+    maxsmt.cpp
+    mss.cpp
+    opt_cmds.cpp
+    opt_context.cpp
+    opt_pareto.cpp
+    optsmt.cpp
+    opt_solver.cpp
+    pb_sls.cpp
+    sortmax.cpp
+    wmax.cpp
+  COMPONENT_DEPENDENCIES
+    sat_solver
+    sls_tactic
+    smt
+    smtlogic_tactics
+  PYG_FILES
+    opt_params.pyg
+)

src/opt/opt_cmds.cpp

@@ -100,6 +100,7 @@ public:
         rational weight = ps().get_rat(symbol("weight"), rational::one());
         symbol id = ps().get_sym(symbol("id"), symbol::null);        
         get_opt(ctx, m_opt).add_soft_constraint(m_formula, weight, id);
+        ctx.print_success();
         reset(ctx);
     }
 
@@ -131,6 +132,7 @@ public:
             throw cmd_exception("malformed objective term: it cannot be a quantifier or bound variable");
         }
         get_opt(ctx, m_opt).add_objective(to_app(t), m_is_max);
+        ctx.print_success();
     }
 
     virtual void failure_cleanup(cmd_context & ctx) {

src/parsers/smt/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(smtparser
+  SOURCES
+    smtlib.cpp
+    smtlib_solver.cpp
+    smtparser.cpp
+  COMPONENT_DEPENDENCIES
+    portfolio
+)

src/parsers/smt2/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(smt2parser
+  SOURCES
+    smt2parser.cpp
+    smt2scanner.cpp
+  COMPONENT_DEPENDENCIES
+    cmd_context
+    parser_util
+)

src/parsers/smt2/smt2scanner.cpp

@@ -23,7 +23,7 @@ namespace smt2 {
 
     void scanner::next() {
         if (m_cache_input)
-            m_cache.push_back(m_curr);                
+            m_cache.push_back(m_curr);
         SASSERT(!m_at_eof);
         if (m_interactive) {
             m_curr = m_stream.get();
@@ -293,11 +293,11 @@ namespace smt2 {
     }
 
     scanner::token scanner::scan() {
-        while (true) {            
+        while (true) {
             signed char c = curr();
             m_pos = m_spos;
 
-            if (m_at_eof)                
+            if (m_at_eof)
                 return EOF_TOKEN;
 
             switch (m_normalized[(unsigned char) c]) {

src/parsers/util/CMakeLists.txt

@@ -0,0 +1,11 @@
+z3_add_component(parser_util
+  SOURCES
+    cost_parser.cpp
+    pattern_validation.cpp
+    scanner.cpp
+    simple_parser.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+  PYG_FILES
+    parser_params.pyg
+)

src/qe/CMakeLists.txt

@@ -0,0 +1,28 @@
+z3_add_component(qe
+  SOURCES
+    nlarith_util.cpp
+    nlqsat.cpp
+    qe_arith.cpp
+    qe_arith_plugin.cpp
+    qe_array_plugin.cpp
+    qe_arrays.cpp
+    qe_bool_plugin.cpp
+    qe_bv_plugin.cpp
+    qe_cmd.cpp
+    qe.cpp
+    qe_datatype_plugin.cpp
+    qe_datatypes.cpp
+    qe_dl_plugin.cpp
+    qe_lite.cpp
+    qe_mbp.cpp
+    qe_sat_tactic.cpp
+    qe_tactic.cpp
+    qsat.cpp
+    vsubst_tactic.cpp
+  COMPONENT_DEPENDENCIES
+    nlsat_tactic
+    nlsat
+    sat
+    smt   
+    tactic 
+)

src/qe/qe_lite.cpp

@@ -36,44 +36,7 @@ Revision History:
 #include "cooperate.h"
 #include "datatype_decl_plugin.h"
 
-class is_variable_proc {
-public:
-    virtual bool operator()(expr* e) const = 0;
-};
-
-class is_variable_test : public is_variable_proc {
-    enum is_var_kind { BY_VAR_SET, BY_VAR_SET_COMPLEMENT, BY_NUM_DECLS };
-    uint_set m_var_set;
-    unsigned m_num_decls;
-    is_var_kind m_var_kind;
-public:
-    is_variable_test(uint_set const& vars, bool index_of_bound) :
-        m_var_set(vars),
-        m_num_decls(0),
-        m_var_kind(index_of_bound?BY_VAR_SET:BY_VAR_SET_COMPLEMENT) {}
-
-    is_variable_test(unsigned num_decls) :
-        m_num_decls(num_decls),
-        m_var_kind(BY_NUM_DECLS) {}
-
-    virtual bool operator()(expr* e) const {
-        if (!is_var(e)) {
-            return false;
-        }
-        unsigned idx = to_var(e)->get_idx();
-        switch(m_var_kind) {
-        case BY_VAR_SET:
-            return m_var_set.contains(idx);
-        case BY_VAR_SET_COMPLEMENT:
-            return !m_var_set.contains(idx);
-        case BY_NUM_DECLS:
-            return idx < m_num_decls;
-        }
-        UNREACHABLE();
-        return false;
-    }
-};
-
+#include "qe_vartest.h"
 
 namespace eq {
     class der {
@@ -86,6 +49,7 @@ namespace eq {
 
         ptr_vector<expr> m_map;
         int_vector       m_pos2var;
+        int_vector       m_var2pos;
         ptr_vector<var>  m_inx2var;
         unsigned_vector  m_order;
         expr_ref_vector  m_subst_map;
@@ -578,6 +542,7 @@ namespace eq {
             largest_vinx = 0;
             m_map.reset();
             m_pos2var.reset();
+            m_var2pos.reset();
             m_inx2var.reset();
             m_pos2var.reserve(num_args, -1);
 
@@ -597,10 +562,48 @@ namespace eq {
                             m_map[idx] = t;
                             m_inx2var[idx] = v;
                             m_pos2var[i] = idx;
+                            m_var2pos.reserve(idx + 1, -1);
+                            m_var2pos[idx] = i;
                             def_count++;
                             largest_vinx = std::max(idx, largest_vinx);
                             m_new_exprs.push_back(t);
                         }
+                        else if (!m.is_value(m_map[idx])) {
+                            // check if the new definition is simpler
+                            expr *old_def = m_map[idx];
+
+                            // -- prefer values
+                            if (m.is_value(t)) {
+                                m_pos2var[m_var2pos[idx]] = -1;
+                                m_pos2var[i] = idx;
+                                m_var2pos[idx] = i;
+                                m_map[idx] = t;
+                                m_new_exprs.push_back(t);
+                          }
+                          // -- prefer ground
+                          else if (is_app(t) && to_app(t)->is_ground() &&
+                                   (!is_app(old_def) ||
+                                    !to_app(old_def)->is_ground())) {
+                              m_pos2var[m_var2pos[idx]] = -1;
+                              m_pos2var[i] = idx;
+                              m_var2pos[idx] = i;
+                              m_map[idx] = t;
+                              m_new_exprs.push_back(t);
+                          }
+                          // -- prefer constants
+                          else if (is_uninterp_const(t)
+                                   /* && !is_uninterp_const(old_def) */){
+                              m_pos2var[m_var2pos[idx]] = -1;
+                              m_pos2var[i] = idx;
+                              m_var2pos[idx] = i;
+                              m_map[idx] = t;
+                              m_new_exprs.push_back(t);
+                          }
+                          TRACE ("qe_def",
+                                 tout << "Replacing definition of VAR " << idx << " from "
+                                 << mk_pp(old_def, m) << " to " << mk_pp(t, m)
+                                 << " inferred from: " << mk_pp(args[i], m) << "\n";);
+                        }
                     }
                 }
             }
@@ -825,12 +828,13 @@ namespace ar {
         }
 
         /**
-           Ex A. A[x] = t & Phi where x \not\in A, t. A \not\in t, x
+           Ex A. A[x] = t & Phi[A] where x \not\in A, t. A \not\in t, x
            =>
            Ex A. Phi[store(A,x,t)]
 
+           (Not implemented)
            Perhaps also:
-           Ex A. store(A,y,z)[x] = t & Phi where x \not\in A, t, y, z, A \not\in y z, t
+           Ex A. store(A,y,z)[x] = t & Phi[A] where x \not\in A, t, y, z, A \not\in y z, t
            =>
            Ex A, v . (x = y => z = t) & Phi[store(store(A,x,t),y,v)]
 
@@ -859,7 +863,8 @@ namespace ar {
                 expr_safe_replace rep(m);
                 rep.insert(A, B);
                 expr_ref tmp(m);
-                std::cout << mk_pp(e1, m) << " = " << mk_pp(e2, m) << "\n";
+                TRACE("qe_lite",
+                      tout << mk_pp(e1, m) << " = " << mk_pp(e2, m) << "\n";);
                 for (unsigned j = 0; j < conjs.size(); ++j) {
                     if (i == j) {
                         conjs[j] = m.mk_true();
@@ -1491,8 +1496,10 @@ namespace fm {
             unsigned sz = g.size();
             for (unsigned i = 0; i < sz; i++) {
                 expr * f = g[i];
-                if (is_occ(f))
+                if (is_occ(f)) {
+                    TRACE("qe_lite", tout << "OCC: " << mk_ismt2_pp(f, m) << "\n";);
                     continue;
+                }
                 TRACE("qe_lite", tout << "not OCC:\n" << mk_ismt2_pp(f, m) << "\n";);
                 quick_for_each_expr(proc, visited, f);
             }
@@ -2221,6 +2228,9 @@ namespace fm {
         void operator()(expr_ref_vector& fmls) {
             init(fmls);
             init_use_list(fmls);
+            for (auto & f : fmls) {
+                if (has_quantifiers(f)) return;
+            }
             if (m_inconsistent) {
                 m_new_fmls.reset();
                 m_new_fmls.push_back(m.mk_false());

src/qe/qe_vartest.h

@@ -0,0 +1,63 @@
+/*++
+Copyright (c) 2013 Microsoft Corporation
+
+Module Name:
+
+    qe_vartest.h
+
+Abstract:
+
+    Utilities for quantifiers.
+
+Author:
+
+    Nikolaj Bjorner (nbjorner) 2013-08-28
+
+Revision History:
+
+--*/
+#ifndef QE_VARTEST_H_
+#define QE_VARTEST_H_
+
+#include "ast.h"
+#include "uint_set.h"
+
+class is_variable_proc {
+public:
+    virtual bool operator()(expr* e) const = 0;
+};
+
+class is_variable_test : public is_variable_proc {
+    enum is_var_kind { BY_VAR_SET, BY_VAR_SET_COMPLEMENT, BY_NUM_DECLS };
+    uint_set m_var_set;
+    unsigned m_num_decls;
+    is_var_kind m_var_kind;
+public:
+    is_variable_test(uint_set const& vars, bool index_of_bound) :
+        m_var_set(vars),
+        m_num_decls(0),
+        m_var_kind(index_of_bound?BY_VAR_SET:BY_VAR_SET_COMPLEMENT) {}
+
+    is_variable_test(unsigned num_decls) :
+        m_num_decls(num_decls),
+        m_var_kind(BY_NUM_DECLS) {}
+
+    virtual bool operator()(expr* e) const {
+        if (!is_var(e)) {
+            return false;
+        }
+        unsigned idx = to_var(e)->get_idx();
+        switch(m_var_kind) {
+        case BY_VAR_SET:
+            return m_var_set.contains(idx);
+        case BY_VAR_SET_COMPLEMENT:
+            return !m_var_set.contains(idx);
+        case BY_NUM_DECLS:
+            return idx < m_num_decls;
+        }
+        UNREACHABLE();
+        return false;
+    }
+};
+
+#endif

src/sat/CMakeLists.txt

@@ -0,0 +1,28 @@
+z3_add_component(sat
+  SOURCES
+    dimacs.cpp
+    sat_asymm_branch.cpp
+    sat_clause.cpp
+    sat_clause_set.cpp
+    sat_clause_use_list.cpp
+    sat_cleaner.cpp
+    sat_config.cpp
+    sat_elim_eqs.cpp
+    sat_iff3_finder.cpp
+    sat_integrity_checker.cpp
+    sat_model_converter.cpp
+    sat_mus.cpp
+    sat_par.cpp
+    sat_probing.cpp
+    sat_scc.cpp
+    sat_simplifier.cpp
+    sat_solver.cpp
+    sat_watched.cpp
+  COMPONENT_DEPENDENCIES
+    util
+  PYG_FILES
+    sat_asymm_branch_params.pyg
+    sat_params.pyg
+    sat_scc_params.pyg
+    sat_simplifier_params.pyg
+)

src/sat/sat_solver/CMakeLists.txt

@@ -0,0 +1,11 @@
+z3_add_component(sat_solver
+  SOURCES
+    inc_sat_solver.cpp
+  COMPONENT_DEPENDENCIES
+    aig_tactic
+    arith_tactics
+    bv_tactics
+    core_tactics
+    sat_tactic
+    solver
+)

src/sat/sat_solver/inc_sat_solver.cpp

@@ -326,7 +326,6 @@ public:
         return l_true;
     }
 
-
     virtual std::string reason_unknown() const {
         return m_unknown;
     }
@@ -598,16 +597,14 @@ private:
         extract_asm2dep(dep2asm, asm2dep);
         sat::literal_vector const& core = m_solver.get_core();
         TRACE("sat",
-              dep2asm_t::iterator it2 = dep2asm.begin();
-              dep2asm_t::iterator end2 = dep2asm.end();
-              for (; it2 != end2; ++it2) {
-                  tout << mk_pp(it2->m_key, m) << " |-> " << sat::literal(it2->m_value) << "\n";
+              for (auto kv : dep2asm) {
+                  tout << mk_pp(kv.m_key, m) << " |-> " << sat::literal(kv.m_value) << "\n";
               }
-              tout << "core: ";
-              for (unsigned i = 0; i < core.size(); ++i) {
-                  tout << core[i] << " ";
+              tout << "asm2fml: ";
+              for (auto kv : asm2fml) {
+                  tout << mk_pp(kv.m_key, m) << " |-> " << mk_pp(kv.m_value, m) << "\n";
               }
-              tout << "\n";
+              tout << "core: "; for (auto c : core) tout << c << " ";  tout << "\n";
               );
 
         m_core.reset();

src/sat/tactic/CMakeLists.txt

@@ -0,0 +1,9 @@
+z3_add_component(sat_tactic
+  SOURCES
+    atom2bool_var.cpp
+    goal2sat.cpp
+    sat_tactic.cpp
+  COMPONENT_DEPENDENCIES
+    sat
+    tactic
+)

src/shell/CMakeLists.txt

@@ -0,0 +1,48 @@
+set (shell_object_files "")
+# FIXME: z3 should really link against libz3 and not the
+# individual components. Several things prevent us from
+# doing this
+# * The api_dll component in libz3 shouldn't be used the
+#   the z3 executable.
+# * The z3 executable uses symbols that are hidden in libz3
+
+# We are only using these dependencies to enforce a build
+# order. We don't use this list for actual linking.
+set(shell_deps api extra_cmds opt sat)
+z3_expand_dependencies(shell_expanded_deps ${shell_deps})
+get_property(Z3_LIBZ3_COMPONENTS_LIST GLOBAL PROPERTY Z3_LIBZ3_COMPONENTS)
+foreach (component ${Z3_LIBZ3_COMPONENTS_LIST})
+  if (NOT ("${component}" STREQUAL "api_dll"))
+    # We don't use the api_dll component in the Z3 executable
+    list(APPEND shell_object_files $<TARGET_OBJECTS:${component}>)
+  endif()
+endforeach()
+add_executable(shell
+  datalog_frontend.cpp
+  dimacs_frontend.cpp
+  "${CMAKE_CURRENT_BINARY_DIR}/gparams_register_modules.cpp"
+  "${CMAKE_CURRENT_BINARY_DIR}/install_tactic.cpp"
+  main.cpp
+  "${CMAKE_CURRENT_BINARY_DIR}/mem_initializer.cpp"
+  opt_frontend.cpp
+  smtlib_frontend.cpp
+  z3_log_frontend.cpp
+  lp_frontend.cpp
+# FIXME: shell should really link against libz3 but it can't due to requiring
+# use of some hidden symbols. Also libz3 has the ``api_dll`` component which
+# we don't want (I think).
+  ${shell_object_files}
+)
+z3_add_install_tactic_rule(${shell_deps})
+z3_add_memory_initializer_rule(${shell_deps})
+z3_add_gparams_register_modules_rule(${shell_deps})
+set_target_properties(shell PROPERTIES OUTPUT_NAME z3)
+target_compile_definitions(shell PRIVATE ${Z3_COMPONENT_CXX_DEFINES})
+target_compile_options(shell PRIVATE ${Z3_COMPONENT_CXX_FLAGS})
+target_include_directories(shell PRIVATE ${Z3_COMPONENT_EXTRA_INCLUDE_DIRS})
+target_link_libraries(shell PRIVATE ${Z3_DEPENDENT_LIBS})
+z3_add_component_dependencies_to_target(shell ${shell_expanded_deps})
+z3_append_linker_flag_list_to_target(shell ${Z3_DEPENDENT_EXTRA_CXX_LINK_FLAGS})
+install(TARGETS shell
+  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+)

src/smt/CMakeLists.txt

@@ -0,0 +1,82 @@
+z3_add_component(smt
+  SOURCES
+    arith_eq_adapter.cpp
+    arith_eq_solver.cpp
+    asserted_formulas.cpp
+    cached_var_subst.cpp
+    cost_evaluator.cpp
+    dyn_ack.cpp
+    elim_term_ite.cpp
+    expr_context_simplifier.cpp
+    fingerprints.cpp
+    mam.cpp
+    old_interval.cpp
+    qi_queue.cpp
+    smt_almost_cg_table.cpp
+    smt_case_split_queue.cpp
+    smt_cg_table.cpp
+    smt_checker.cpp
+    smt_clause.cpp
+    smt_conflict_resolution.cpp
+    smt_consequences.cpp
+    smt_context.cpp
+    smt_context_inv.cpp
+    smt_context_pp.cpp
+    smt_context_stat.cpp
+    smt_enode.cpp
+    smt_farkas_util.cpp
+    smt_for_each_relevant_expr.cpp
+    smt_implied_equalities.cpp
+    smt_internalizer.cpp
+    smt_justification.cpp
+    smt_kernel.cpp
+    smt_literal.cpp
+    smt_model_checker.cpp
+    smt_model_finder.cpp
+    smt_model_generator.cpp
+    smt_quantifier.cpp
+    smt_quantifier_stat.cpp
+    smt_quick_checker.cpp
+    smt_relevancy.cpp
+    smt_setup.cpp
+    smt_solver.cpp
+    smt_statistics.cpp
+    smt_theory.cpp
+    smt_value_sort.cpp
+    smt2_extra_cmds.cpp
+    theory_arith.cpp
+    theory_array_base.cpp
+    theory_array.cpp
+    theory_array_full.cpp
+    theory_bv.cpp
+    theory_datatype.cpp
+    theory_dense_diff_logic.cpp
+    theory_diff_logic.cpp
+    theory_dl.cpp
+    theory_dummy.cpp
+    theory_fpa.cpp
+    theory_lra.cpp
+    theory_opt.cpp
+    theory_pb.cpp
+    theory_seq.cpp
+    theory_str.cpp
+    theory_utvpi.cpp
+    theory_wmaxsat.cpp
+    uses_theory.cpp
+    watch_list.cpp
+  COMPONENT_DEPENDENCIES
+    bit_blaster
+    cmd_context
+    euclid
+    fpa
+    grobner
+    lp
+    macros
+    normal_forms
+    parser_util
+    pattern
+    proof_checker
+    proto_model
+    simplex
+    substitution
+)

src/smt/params/CMakeLists.txt

@@ -0,0 +1,19 @@
+z3_add_component(smt_params
+  SOURCES
+    dyn_ack_params.cpp
+    preprocessor_params.cpp
+    qi_params.cpp
+    smt_params.cpp
+    theory_arith_params.cpp
+    theory_array_params.cpp
+    theory_bv_params.cpp
+    theory_pb_params.cpp
+    theory_str_params.cpp
+  COMPONENT_DEPENDENCIES
+    ast
+    bit_blaster
+    pattern
+    simplifier
+  PYG_FILES
+    smt_params_helper.pyg
+)

src/smt/proto_model/CMakeLists.txt

@@ -0,0 +1,13 @@
+z3_add_component(proto_model
+  SOURCES
+    array_factory.cpp
+    datatype_factory.cpp
+    numeral_factory.cpp
+    proto_model.cpp
+    struct_factory.cpp
+    value_factory.cpp
+  COMPONENT_DEPENDENCIES
+    model
+    simplifier
+    smt_params
+)

src/smt/smt_conflict_resolution.cpp

@@ -1405,6 +1405,7 @@ namespace smt {
             switch (js.get_kind()) {
             case b_justification::CLAUSE: {
                 clause * cls = js.get_clause();
+                TRACE("unsat_core_bug", m_ctx.display_clause_detail(tout, cls););
                 unsigned num_lits = cls->get_num_literals();
                 unsigned i        = 0;
                 if (consequent != false_literal) {
@@ -1422,8 +1423,9 @@ namespace smt {
                     process_antecedent_for_unsat_core(~l);
                 }
                 justification * js = cls->get_justification();
-                if (js)
+                if (js) {
                     process_justification_for_unsat_core(js);
+                }
                 break;
             }
             case b_justification::BIN_CLAUSE:

src/smt/smt_internalizer.cpp

@@ -1034,8 +1034,10 @@ namespace smt {
             lbool   val  = get_assignment(curr);
             switch(val) {
             case l_false:
+                TRACE("simplify_aux_clause_literals", display_literal(tout << get_assign_level(curr) << " " << get_scope_level() << " ", curr); tout << "\n"; );
                 simp_lits.push_back(~curr);
-                break; // ignore literal
+                break; // ignore literal                
+                // fall through
             case l_undef:
                 if (curr == ~prev)
                     return false; // clause is equivalent to true

src/smt/tactic/CMakeLists.txt

@@ -0,0 +1,8 @@
+z3_add_component(smt_tactic
+  SOURCES
+    ctx_solver_simplify_tactic.cpp
+    smt_tactic.cpp
+    unit_subsumption_tactic.cpp
+  COMPONENT_DEPENDENCIES
+    smt
+)

src/smt/theory_arith_aux.h

@@ -1458,7 +1458,7 @@ namespace smt {
             normalize_gain(min_gain.get_rational(), max_gain);
         }
 
-        if (is_int(x_i) && !max_gain.is_rational()) {
+        if (is_int(x_i) && !max_gain.is_int()) {
             max_gain = inf_numeral(floor(max_gain));
             normalize_gain(min_gain.get_rational(), max_gain);
         }
@@ -1483,7 +1483,7 @@ namespace smt {
             }
         }
         TRACE("opt",
-              tout << "v" << x_i << " a_ij " << a_ij << " "
+              tout << "v" << x_i << (is_int(x_i)?" int":" real") << " a_ij " << a_ij << " "
               << "min gain: " << min_gain << " " 
               << "max gain: " << max_gain << " tighter: "
               << (is_tighter?"true":"false") << "\n";);
@@ -1696,6 +1696,7 @@ namespace smt {
                   if (lower(x_j)) tout << "lower x_j: " << lower_bound(x_j) << " ";
                   tout << "value x_j: " << get_value(x_j) << "\n";
                   );
+
             pivot<true>(x_i, x_j, a_ij, false);
                         
             SASSERT(is_non_base(x_i));

src/smt/theory_seq.cpp

@@ -2176,8 +2176,67 @@ bool theory_seq::simplify_and_solve_eqs() {
     return m_new_propagation || ctx.inconsistent();
 }
 
-void theory_seq::internalize_eq_eh(app * atom, bool_var v) {}
+void theory_seq::internalize_eq_eh(app * atom, bool_var v) {
+}
 
+bool theory_seq::internalize_atom(app* a, bool) {
+#if 1
+    return internalize_term(a);
+#else
+    if (is_skolem(m_eq, a)) {
+        return internalize_term(a);
+    }
+    context & ctx   = get_context();
+    bool_var bv = ctx.mk_bool_var(a);
+    ctx.set_var_theory(bv, get_id());
+    ctx.mark_as_relevant(bv);
+
+    expr* e1, *e2;
+    if (m_util.str.is_in_re(a, e1, e2)) {        
+        return internalize_term(to_app(e1)) && internalize_re(e2);
+    }
+    if (m_util.str.is_contains(a, e1, e2) ||
+        m_util.str.is_prefix(a, e1, e2) ||
+        m_util.str.is_suffix(a, e1, e2)) {
+        return internalize_term(to_app(e1)) && internalize_term(to_app(e2));        
+    }
+    if (is_accept(a) || is_reject(a) || is_step(a) || is_skolem(symbol("seq.is_digit"), a)) {
+        return true;
+    }
+    UNREACHABLE();
+    return internalize_term(a);
+#endif
+}
+
+bool theory_seq::internalize_re(expr* e) {
+    expr* e1, *e2;
+    unsigned lc, uc;
+    if (m_util.re.is_to_re(e, e1)) {
+        return internalize_term(to_app(e1));
+    }
+    if (m_util.re.is_star(e, e1) ||
+        m_util.re.is_plus(e, e1) ||
+        m_util.re.is_opt(e, e1) ||
+        m_util.re.is_loop(e, e1, lc) ||
+        m_util.re.is_loop(e, e1, lc, uc) ||
+        m_util.re.is_complement(e, e1)) {
+        return internalize_re(e1);
+    }
+    if (m_util.re.is_union(e, e1, e2) ||
+        m_util.re.is_intersection(e, e1, e2) ||
+        m_util.re.is_concat(e, e1, e2)) {
+        return internalize_re(e1) && internalize_re(e2);
+    }
+    if (m_util.re.is_full(e) ||
+        m_util.re.is_empty(e)) {
+        return true;
+    }
+    if (m_util.re.is_range(e, e1, e2)) {
+        return internalize_term(to_app(e1)) && internalize_term(to_app(e2));
+    }
+    UNREACHABLE();
+    return internalize_term(to_app(e));
+}
 
 bool theory_seq::internalize_term(app* term) {
     context & ctx   = get_context();
@@ -2962,6 +3021,7 @@ void theory_seq::deque_axiom(expr* n) {
         add_length_axiom(n);
     }
     else if (m_util.str.is_empty(n) && !has_length(n) && !m_length.empty()) {
+        ensure_enode(n);
         enforce_length(get_context().get_enode(n));
     }
     else if (m_util.str.is_index(n)) {
@@ -3567,8 +3627,8 @@ void theory_seq::add_at_axiom(expr* e) {
     add_axiom(~i_ge_0, i_ge_len_s, mk_eq(one, len_e, false));
     add_axiom(~i_ge_0, i_ge_len_s, mk_eq(i, len_x, false));
 
-    add_axiom(i_ge_0, mk_eq(s, emp, false));
-    add_axiom(~i_ge_len_s, mk_eq(s, emp, false));
+    add_axiom(i_ge_0, mk_eq(e, emp, false));
+    add_axiom(~i_ge_len_s, mk_eq(e, emp, false));
 }
 
 /**
@@ -3875,7 +3935,7 @@ void theory_seq::new_eq_eh(dependency* deps, enode* n1, enode* n2) {
         enforce_length_coherence(n1, n2);
     }
     else if (n1 != n2 && m_util.is_re(n1->get_owner())) {
-        warning_msg("equality between regular expressions is not yet supported");
+        // ignore
         // eautomaton* a1 = get_automaton(n1->get_owner());
         // eautomaton* a2 = get_automaton(n2->get_owner());
         // eautomaton* b1 = mk_difference(*a1, *a2);
@@ -3995,7 +4055,7 @@ void theory_seq::relevant_eh(app* n) {
     }
 
     expr* arg;
-    if (m_util.str.is_length(n, arg) && !has_length(arg)) {
+    if (m_util.str.is_length(n, arg) && !has_length(arg) && get_context().e_internalized(arg)) {
         enforce_length(get_context().get_enode(arg));
     }
 }