z3 0.0.20180624 → 0.0.20211213

data/lib/z3/sort/bitvec_sort.rb

@@ -1,6 +1,7 @@
 module Z3
   class BitvecSort < Sort
     def initialize(n)
+      raise Z3::Exception, "Bitvec width must be positive" unless n >= 1
       super LowLevel.mk_bv_sort(n)
     end
 

data/lib/z3/sort/sort.rb

@@ -57,12 +57,16 @@ module Z3
     end
 
     def var(name)
-      new(
-        LowLevel.mk_const(
-          LowLevel.mk_string_symbol(name),
-          self,
+      if name.is_a?(Enumerable)
+        name.map{|v| var(v)}
+      else
+        new(
+          LowLevel.mk_const(
+            LowLevel.mk_string_symbol(name),
+            self,
+          )
         )
-      )
+      end
     end
 
     # We pretend to be a class, sort of

data/lib/z3/very_low_level.rb

@@ -1,19 +1,21 @@
 # Seriously do not use this directly in your code
-
-require 'ffi'
+require "ffi"
 
 module Z3
   module VeryLowLevel
     extend FFI::Library
-    ffi_lib "z3"
+    ffi_lib ["libz3.so.4.8", "libz3.so", "z3"]
 
     class << self
       # Aliases defined just to make APIs below look nicer
       def attach_function(name, arg_types, return_type)
-
-        arg_types = arg_types.map{|t| map_type(t)}
+        arg_types = arg_types.map { |t| map_type(t) }
         return_type = map_type(return_type)
         super(name, arg_types, return_type)
+      rescue FFI::NotFoundError
+        define_singleton_method(name) do |*args|
+          raise Z3::Exception, "Could not find #{name} in the Z3 library. It is likely that the Z3 library has wrong version."
+        end
       end
 
       def map_type(t)
@@ -40,5 +42,6 @@ module Z3
     attach_function :Z3_mk_set_union, [:ctx_pointer, :int, :pointer], :ast_pointer
     attach_function :Z3_mk_set_intersect, [:ctx_pointer, :int, :pointer], :ast_pointer
     attach_function :Z3_mk_distinct, [:ctx_pointer, :int, :pointer], :ast_pointer
+    attach_function :Z3_optimize_check, [:ctx_pointer, :optimize_pointer, :int, :pointer], :int
   end
 end

data/lib/z3/very_low_level_auto.rb

@@ -6,6 +6,8 @@ module Z3
     attach_function :Z3_algebraic_div, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_algebraic_eq, [:ctx_pointer, :ast_pointer, :ast_pointer], :bool
     attach_function :Z3_algebraic_ge, [:ctx_pointer, :ast_pointer, :ast_pointer], :bool
+    attach_function :Z3_algebraic_get_i, [:ctx_pointer, :ast_pointer], :uint
+    attach_function :Z3_algebraic_get_poly, [:ctx_pointer, :ast_pointer], :ast_vector_pointer
     attach_function :Z3_algebraic_gt, [:ctx_pointer, :ast_pointer, :ast_pointer], :bool
     attach_function :Z3_algebraic_is_neg, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_algebraic_is_pos, [:ctx_pointer, :ast_pointer], :bool
@@ -19,7 +21,6 @@ module Z3
     attach_function :Z3_algebraic_root, [:ctx_pointer, :ast_pointer, :uint], :ast_pointer
     attach_function :Z3_algebraic_sign, [:ctx_pointer, :ast_pointer], :int
     attach_function :Z3_algebraic_sub, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_apply_result_convert_model, [:ctx_pointer, :apply_result_pointer, :uint, :model_pointer], :model_pointer
     attach_function :Z3_apply_result_dec_ref, [:ctx_pointer, :apply_result_pointer], :void
     attach_function :Z3_apply_result_get_num_subgoals, [:ctx_pointer, :apply_result_pointer], :uint
     attach_function :Z3_apply_result_get_subgoal, [:ctx_pointer, :apply_result_pointer, :uint], :goal_pointer
@@ -53,6 +54,7 @@ module Z3
     attach_function :Z3_del_context, [:ctx_pointer], :void
     attach_function :Z3_disable_trace, [:string], :void
     attach_function :Z3_enable_trace, [:string], :void
+    attach_function :Z3_eval_smtlib2_string, [:ctx_pointer, :string], :string
     attach_function :Z3_finalize_memory, [], :void
     attach_function :Z3_fixedpoint_add_cover, [:ctx_pointer, :fixedpoint_pointer, :int, :func_decl_pointer, :ast_pointer], :void
     attach_function :Z3_fixedpoint_add_invariant, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer, :ast_pointer], :void
@@ -75,8 +77,6 @@ module Z3
     attach_function :Z3_fixedpoint_get_rules_along_trace, [:ctx_pointer, :fixedpoint_pointer], :ast_vector_pointer
     attach_function :Z3_fixedpoint_get_statistics, [:ctx_pointer, :fixedpoint_pointer], :stats_pointer
     attach_function :Z3_fixedpoint_inc_ref, [:ctx_pointer, :fixedpoint_pointer], :void
-    attach_function :Z3_fixedpoint_pop, [:ctx_pointer, :fixedpoint_pointer], :void
-    attach_function :Z3_fixedpoint_push, [:ctx_pointer, :fixedpoint_pointer], :void
     attach_function :Z3_fixedpoint_query, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer], :int
     attach_function :Z3_fixedpoint_query_from_lvl, [:ctx_pointer, :fixedpoint_pointer, :ast_pointer, :uint], :int
     attach_function :Z3_fixedpoint_register_relation, [:ctx_pointer, :fixedpoint_pointer, :func_decl_pointer], :void
@@ -145,13 +145,13 @@ module Z3
     attach_function :Z3_get_full_version, [], :string
     attach_function :Z3_get_func_decl_id, [:ctx_pointer, :func_decl_pointer], :uint
     attach_function :Z3_get_index_value, [:ctx_pointer, :ast_pointer], :uint
-    attach_function :Z3_get_interpolant, [:ctx_pointer, :ast_pointer, :ast_pointer, :params_pointer], :ast_vector_pointer
     attach_function :Z3_get_num_probes, [:ctx_pointer], :uint
     attach_function :Z3_get_num_tactics, [:ctx_pointer], :uint
+    attach_function :Z3_get_numeral_binary_string, [:ctx_pointer, :ast_pointer], :string
     attach_function :Z3_get_numeral_decimal_string, [:ctx_pointer, :ast_pointer, :uint], :string
+    attach_function :Z3_get_numeral_double, [:ctx_pointer, :ast_pointer], :double
     attach_function :Z3_get_numeral_string, [:ctx_pointer, :ast_pointer], :string
     attach_function :Z3_get_numerator, [:ctx_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_get_parser_error, [:ctx_pointer], :string
     attach_function :Z3_get_pattern, [:ctx_pointer, :pattern_pointer, :uint], :ast_pointer
     attach_function :Z3_get_pattern_num_terms, [:ctx_pointer, :pattern_pointer], :uint
     attach_function :Z3_get_probe_name, [:ctx_pointer, :uint], :string
@@ -165,12 +165,15 @@ module Z3
     attach_function :Z3_get_quantifier_pattern_ast, [:ctx_pointer, :ast_pointer, :uint], :pattern_pointer
     attach_function :Z3_get_quantifier_weight, [:ctx_pointer, :ast_pointer], :uint
     attach_function :Z3_get_range, [:ctx_pointer, :func_decl_pointer], :sort_pointer
+    attach_function :Z3_get_re_sort_basis, [:ctx_pointer, :sort_pointer], :sort_pointer
     attach_function :Z3_get_relation_arity, [:ctx_pointer, :sort_pointer], :uint
     attach_function :Z3_get_relation_column, [:ctx_pointer, :sort_pointer, :uint], :sort_pointer
+    attach_function :Z3_get_seq_sort_basis, [:ctx_pointer, :sort_pointer], :sort_pointer
     attach_function :Z3_get_sort, [:ctx_pointer, :ast_pointer], :sort_pointer
     attach_function :Z3_get_sort_id, [:ctx_pointer, :sort_pointer], :uint
     attach_function :Z3_get_sort_kind, [:ctx_pointer, :sort_pointer], :uint
     attach_function :Z3_get_sort_name, [:ctx_pointer, :sort_pointer], :symbol_pointer
+    attach_function :Z3_get_string_length, [:ctx_pointer, :ast_pointer], :uint
     attach_function :Z3_get_symbol_int, [:ctx_pointer, :symbol_pointer], :int
     attach_function :Z3_get_symbol_kind, [:ctx_pointer, :symbol_pointer], :uint
     attach_function :Z3_get_symbol_string, [:ctx_pointer, :symbol_pointer], :string
@@ -181,6 +184,7 @@ module Z3
     attach_function :Z3_global_param_reset_all, [], :void
     attach_function :Z3_global_param_set, [:string, :string], :void
     attach_function :Z3_goal_assert, [:ctx_pointer, :goal_pointer, :ast_pointer], :void
+    attach_function :Z3_goal_convert_model, [:ctx_pointer, :goal_pointer, :model_pointer], :model_pointer
     attach_function :Z3_goal_dec_ref, [:ctx_pointer, :goal_pointer], :void
     attach_function :Z3_goal_depth, [:ctx_pointer, :goal_pointer], :uint
     attach_function :Z3_goal_formula, [:ctx_pointer, :goal_pointer, :uint], :ast_pointer
@@ -192,18 +196,21 @@ module Z3
     attach_function :Z3_goal_precision, [:ctx_pointer, :goal_pointer], :uint
     attach_function :Z3_goal_reset, [:ctx_pointer, :goal_pointer], :void
     attach_function :Z3_goal_size, [:ctx_pointer, :goal_pointer], :uint
+    attach_function :Z3_goal_to_dimacs_string, [:ctx_pointer, :goal_pointer, :bool], :string
     attach_function :Z3_goal_to_string, [:ctx_pointer, :goal_pointer], :string
     attach_function :Z3_goal_translate, [:ctx_pointer, :goal_pointer, :ctx_pointer], :goal_pointer
     attach_function :Z3_inc_ref, [:ctx_pointer, :ast_pointer], :void
-    attach_function :Z3_interpolation_profile, [:ctx_pointer], :string
     attach_function :Z3_interrupt, [:ctx_pointer], :void
     attach_function :Z3_is_algebraic_number, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_app, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_as_array, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_is_char_sort, [:ctx_pointer, :sort_pointer], :bool
     attach_function :Z3_is_eq_ast, [:ctx_pointer, :ast_pointer, :ast_pointer], :bool
     attach_function :Z3_is_eq_func_decl, [:ctx_pointer, :func_decl_pointer, :func_decl_pointer], :bool
     attach_function :Z3_is_eq_sort, [:ctx_pointer, :sort_pointer, :sort_pointer], :bool
+    attach_function :Z3_is_lambda, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_numeral_ast, [:ctx_pointer, :ast_pointer], :bool
+    attach_function :Z3_is_quantifier_exists, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_quantifier_forall, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_is_well_sorted, [:ctx_pointer, :ast_pointer], :bool
     attach_function :Z3_mk_array_default, [:ctx_pointer, :ast_pointer], :ast_pointer
@@ -252,12 +259,19 @@ module Z3
     attach_function :Z3_mk_bvurem, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_bvxnor, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_bvxor, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_char_from_bv, [:ctx_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_char_is_digit, [:ctx_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_char_le, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_char_sort, [:ctx_pointer], :sort_pointer
+    attach_function :Z3_mk_char_to_bv, [:ctx_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_char_to_int, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_concat, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_config, [], :config_pointer
     attach_function :Z3_mk_const, [:ctx_pointer, :symbol_pointer, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_const_array, [:ctx_pointer, :sort_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_context_rc, [:config_pointer], :ctx_pointer
     attach_function :Z3_mk_div, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_divides, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_empty_set, [:ctx_pointer, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_eq, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_ext_rotate_left, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
@@ -337,11 +351,11 @@ module Z3
     attach_function :Z3_mk_int_sort, [:ctx_pointer], :sort_pointer
     attach_function :Z3_mk_int_symbol, [:ctx_pointer, :int], :symbol_pointer
     attach_function :Z3_mk_int_to_str, [:ctx_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_mk_interpolant, [:ctx_pointer, :ast_pointer], :ast_pointer
-    attach_function :Z3_mk_interpolation_context, [:config_pointer], :ctx_pointer
     attach_function :Z3_mk_is_int, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_ite, [:ctx_pointer, :ast_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_le, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_linear_order, [:ctx_pointer, :sort_pointer, :uint], :func_decl_pointer
+    attach_function :Z3_mk_lstring, [:ctx_pointer, :uint, :string], :ast_pointer
     attach_function :Z3_mk_lt, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_mod, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_model, [:ctx_pointer], :model_pointer
@@ -349,8 +363,11 @@ module Z3
     attach_function :Z3_mk_numeral, [:ctx_pointer, :string, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_optimize, [:ctx_pointer], :optimize_pointer
     attach_function :Z3_mk_params, [:ctx_pointer], :params_pointer
+    attach_function :Z3_mk_partial_order, [:ctx_pointer, :sort_pointer, :uint], :func_decl_pointer
+    attach_function :Z3_mk_piecewise_linear_order, [:ctx_pointer, :sort_pointer, :uint], :func_decl_pointer
     attach_function :Z3_mk_power, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_probe, [:ctx_pointer, :string], :probe_pointer
+    attach_function :Z3_mk_re_allchar, [:ctx_pointer, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_re_complement, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_re_empty, [:ctx_pointer, :sort_pointer], :ast_pointer
     attach_function :Z3_mk_re_full, [:ctx_pointer, :sort_pointer], :ast_pointer
@@ -363,11 +380,15 @@ module Z3
     attach_function :Z3_mk_repeat, [:ctx_pointer, :uint, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_rotate_left, [:ctx_pointer, :uint, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_rotate_right, [:ctx_pointer, :uint, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_sbv_to_str, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_select, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_seq_last_index, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_seq_nth, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_set_add, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_set_complement, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_set_del, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_set_difference, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_set_has_size, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_set_member, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_set_sort, [:ctx_pointer, :sort_pointer], :sort_pointer
     attach_function :Z3_mk_set_subset, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
@@ -377,10 +398,15 @@ module Z3
     attach_function :Z3_mk_solver_for_logic, [:ctx_pointer, :symbol_pointer], :solver_pointer
     attach_function :Z3_mk_solver_from_tactic, [:ctx_pointer, :tactic_pointer], :solver_pointer
     attach_function :Z3_mk_store, [:ctx_pointer, :ast_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_str_le, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
+    attach_function :Z3_mk_str_lt, [:ctx_pointer, :ast_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_str_to_int, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_string_symbol, [:ctx_pointer, :string], :symbol_pointer
     attach_function :Z3_mk_tactic, [:ctx_pointer, :string], :tactic_pointer
+    attach_function :Z3_mk_transitive_closure, [:ctx_pointer, :func_decl_pointer], :func_decl_pointer
+    attach_function :Z3_mk_tree_order, [:ctx_pointer, :sort_pointer, :uint], :func_decl_pointer
     attach_function :Z3_mk_true, [:ctx_pointer], :ast_pointer
+    attach_function :Z3_mk_ubv_to_str, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_unary_minus, [:ctx_pointer, :ast_pointer], :ast_pointer
     attach_function :Z3_mk_uninterpreted_sort, [:ctx_pointer, :symbol_pointer], :sort_pointer
     attach_function :Z3_mk_unsigned_int, [:ctx_pointer, :uint, :sort_pointer], :ast_pointer
@@ -401,9 +427,10 @@ module Z3
     attach_function :Z3_model_has_interp, [:ctx_pointer, :model_pointer, :func_decl_pointer], :bool
     attach_function :Z3_model_inc_ref, [:ctx_pointer, :model_pointer], :void
     attach_function :Z3_model_to_string, [:ctx_pointer, :model_pointer], :string
+    attach_function :Z3_model_translate, [:ctx_pointer, :model_pointer, :ctx_pointer], :model_pointer
     attach_function :Z3_optimize_assert, [:ctx_pointer, :optimize_pointer, :ast_pointer], :void
+    attach_function :Z3_optimize_assert_and_track, [:ctx_pointer, :optimize_pointer, :ast_pointer, :ast_pointer], :void
     attach_function :Z3_optimize_assert_soft, [:ctx_pointer, :optimize_pointer, :ast_pointer, :string, :symbol_pointer], :uint
-    attach_function :Z3_optimize_check, [:ctx_pointer, :optimize_pointer], :int
     attach_function :Z3_optimize_dec_ref, [:ctx_pointer, :optimize_pointer], :void
     attach_function :Z3_optimize_from_file, [:ctx_pointer, :optimize_pointer, :string], :void
     attach_function :Z3_optimize_from_string, [:ctx_pointer, :optimize_pointer, :string], :void
@@ -416,6 +443,7 @@ module Z3
     attach_function :Z3_optimize_get_param_descrs, [:ctx_pointer, :optimize_pointer], :param_descrs_pointer
     attach_function :Z3_optimize_get_reason_unknown, [:ctx_pointer, :optimize_pointer], :string
     attach_function :Z3_optimize_get_statistics, [:ctx_pointer, :optimize_pointer], :stats_pointer
+    attach_function :Z3_optimize_get_unsat_core, [:ctx_pointer, :optimize_pointer], :ast_vector_pointer
     attach_function :Z3_optimize_get_upper, [:ctx_pointer, :optimize_pointer, :uint], :ast_pointer
     attach_function :Z3_optimize_get_upper_as_vector, [:ctx_pointer, :optimize_pointer, :uint], :ast_vector_pointer
     attach_function :Z3_optimize_inc_ref, [:ctx_pointer, :optimize_pointer], :void
@@ -485,6 +513,7 @@ module Z3
     attach_function :Z3_solver_assert, [:ctx_pointer, :solver_pointer, :ast_pointer], :void
     attach_function :Z3_solver_assert_and_track, [:ctx_pointer, :solver_pointer, :ast_pointer, :ast_pointer], :void
     attach_function :Z3_solver_check, [:ctx_pointer, :solver_pointer], :int
+    attach_function :Z3_solver_cube, [:ctx_pointer, :solver_pointer, :ast_vector_pointer, :uint], :ast_vector_pointer
     attach_function :Z3_solver_dec_ref, [:ctx_pointer, :solver_pointer], :void
     attach_function :Z3_solver_from_file, [:ctx_pointer, :solver_pointer, :string], :void
     attach_function :Z3_solver_from_string, [:ctx_pointer, :solver_pointer, :string], :void
@@ -492,17 +521,24 @@ module Z3
     attach_function :Z3_solver_get_consequences, [:ctx_pointer, :solver_pointer, :ast_vector_pointer, :ast_vector_pointer, :ast_vector_pointer], :int
     attach_function :Z3_solver_get_help, [:ctx_pointer, :solver_pointer], :string
     attach_function :Z3_solver_get_model, [:ctx_pointer, :solver_pointer], :model_pointer
+    attach_function :Z3_solver_get_non_units, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
     attach_function :Z3_solver_get_num_scopes, [:ctx_pointer, :solver_pointer], :uint
     attach_function :Z3_solver_get_param_descrs, [:ctx_pointer, :solver_pointer], :param_descrs_pointer
     attach_function :Z3_solver_get_proof, [:ctx_pointer, :solver_pointer], :ast_pointer
     attach_function :Z3_solver_get_reason_unknown, [:ctx_pointer, :solver_pointer], :string
     attach_function :Z3_solver_get_statistics, [:ctx_pointer, :solver_pointer], :stats_pointer
+    attach_function :Z3_solver_get_trail, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
+    attach_function :Z3_solver_get_units, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
     attach_function :Z3_solver_get_unsat_core, [:ctx_pointer, :solver_pointer], :ast_vector_pointer
+    attach_function :Z3_solver_import_model_converter, [:ctx_pointer, :solver_pointer, :solver_pointer], :void
     attach_function :Z3_solver_inc_ref, [:ctx_pointer, :solver_pointer], :void
+    attach_function :Z3_solver_interrupt, [:ctx_pointer, :solver_pointer], :void
     attach_function :Z3_solver_pop, [:ctx_pointer, :solver_pointer, :uint], :void
+    attach_function :Z3_solver_propagate_register, [:ctx_pointer, :solver_pointer, :ast_pointer], :uint
     attach_function :Z3_solver_push, [:ctx_pointer, :solver_pointer], :void
     attach_function :Z3_solver_reset, [:ctx_pointer, :solver_pointer], :void
     attach_function :Z3_solver_set_params, [:ctx_pointer, :solver_pointer, :params_pointer], :void
+    attach_function :Z3_solver_to_dimacs_string, [:ctx_pointer, :solver_pointer, :bool], :string
     attach_function :Z3_solver_to_string, [:ctx_pointer, :solver_pointer], :string
     attach_function :Z3_stats_dec_ref, [:ctx_pointer, :stats_pointer], :void
     attach_function :Z3_stats_get_double_value, [:ctx_pointer, :stats_pointer, :uint], :double

data/spec/bitvec_expr_spec.rb

@@ -4,6 +4,7 @@ module Z3
     let(:b) { Z3.Bitvec("b", 8) }
     let(:c) { Z3.Bitvec("c", 8) }
     let(:d) { Z3.Bitvec("d", 12) }
+    let(:e) { Z3.Bitvec("e", 4) }
     let(:x) { Z3.Bool("x") }
 
     it "==" do
@@ -168,28 +169,28 @@ module Z3
       expect([a ==   127, b ==  1, x == a.signed_div_no_overflow?(b)]).to have_solution(x => true)
     end
 
-    ## This API is broken, z3 returns unevaluated bvsmul_noovfl(10, 10) instead of actual answer
-
-    # it "signed_mul_no_overflow?" do
-    #   expect([a ==   10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
-    #   expect([a ==   20, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
-    #   expect([a ==   20, b ==   20, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
-    #   expect([a ==  -10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
-    # end
-    #
-    # it "unsigned_mul_no_overflow?" do
-    #   expect([a ==   10, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
-    #   expect([a ==   20, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
-    #   expect([a ==   20, b ==   20, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
-    #   expect([a ==  -10, b ==  -10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
-    # end
-    #
+    it "signed_mul_no_overflow?" do
+      expect([a ==   10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   20, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==   20, b ==   20, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==   10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -10, b ==   10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -10, b ==  -10, x == a.signed_mul_no_overflow?(b)]).to have_solution(x => false)
+    end
+
+    it "unsigned_mul_no_overflow?" do
+      expect([a ==   10, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   20, b ==   10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => true)
+      expect([a ==   20, b ==   20, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
+      expect([a ==  -10, b ==  -10, x == a.unsigned_mul_no_overflow?(b)]).to have_solution(x => false)
+    end
+
     # # Inherently signed, unsigned can't underflow
-    # it "signed_mul_no_underflow?" do
-    #   expect([a ==  -10, b ==  -10, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
-    #   expect([a ==  -20, b ==  -20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
-    #   expect([a ==  -20, b ==   20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => false)
-    # end
+    it "signed_mul_no_underflow?" do
+      expect([a ==  -10, b ==  -10, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
+      expect([a ==  -20, b ==  -20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => true)
+      expect([a ==  -20, b ==   20, x == a.signed_mul_no_underflow?(b)]).to have_solution(x => false)
+    end
 
     it "zero_ext / sign_ext" do
       expect([a ==  100, d ==  a.zero_ext(4)]).to have_solution(d => 100)
@@ -204,5 +205,18 @@ module Z3
       expect([a == 0b0101_0110, b == a.rotate_right(1)]).to have_solution(b => 0b0_0101_011)
       expect([a == 0b0101_0110, b == a.rotate_right(4)]).to have_solution(b => 0b0110_0101)
     end
+
+    it "extract" do
+      expect([a == 0b0101_0110, e == a.extract(3, 0)]).to have_solution(e => 0b0110)
+      expect([a == 0b0101_0110, e == a.extract(7, 4)]).to have_solution(e => 0b0101)
+      expect{ a.extract(8, 4) }.to raise_error(Z3::Exception)
+      expect{ a.extract(2, 3) }.to raise_error(Z3::Exception)
+      expect{ a.extract(2, -1) }.to raise_error(Z3::Exception)
+    end
+
+    it "concat" do
+      expect([a == 0b0101_0110, e == 0b1101, d == a.concat(e)]).to have_solution(d => 0b0101_0110_1101)
+      expect([a == 0b0101_0110, e == 0b1101, d == e.concat(a)]).to have_solution(d => 0b1101_0101_0110)
+    end
   end
 end

data/spec/bitvec_sort_spec.rb

@@ -32,5 +32,9 @@ module Z3
       expect(Z3.Bitvec("a", 8).inspect).to eq("Bitvec(8)<a>")
       expect(Z3.Bitvec("a", 32).inspect).to eq("Bitvec(32)<a>")
     end
+
+    it "number of bits must be positive" do
+      expect{ Z3.Bitvec("a", 0) }.to raise_error(Z3::Exception)
+    end
   end
 end

data/spec/expr_spec.rb

@@ -183,4 +183,66 @@ module Z3
       end
     end
   end
+
+  describe "#hash / #eql?" do
+    let(:x1) { Z3.Int("x") }
+    let(:x2) { Z3.Int("x") }
+    let(:y1) { Z3.Int("y") }
+    let(:y2) { Z3.Int("y") }
+    let(:e1) { x1 + y1 }
+    let(:e2) { x2 + y2 }
+    let(:f1) { y1 + x1 }
+    let(:f2) { y2 + x2 }
+    let(:samples) { [x1, x2, y1, y2, e1, e2, f1, f2] }
+
+    it "object is eql? to itself" do
+      expect(x1.eql?(x1)).to be true
+      expect(y1.eql?(y1)).to be true
+      expect(e1.eql?(e1)).to be true
+
+      expect(x1.eql?(y1)).to be false
+      expect(x1.eql?(e1)).to be false
+    end
+
+    it "object is eql? to structurally identical object" do
+      expect(x1.eql?(x2)).to be true
+      expect(y1.eql?(y2)).to be true
+      expect(e1.eql?(e2)).to be true
+      expect(f1.eql?(f2)).to be true
+    end
+
+    it "object is not eql? to semantically identical object" do
+      expect(e1.eql?(f1)).to be false
+    end
+
+    it "#hash aligns with #eql?" do
+      samples.each do |a|
+        samples.each do |b|
+          if a.eql?(b)
+            expect(a.hash).to eq(b.hash)
+          else
+            expect(a.hash).to_not eq(b.hash)
+          end
+        end
+      end
+    end
+
+    it "works when used as Hash keys" do
+      ht = {}
+      ht[x1] = 1
+      ht[y1] = 2
+      ht[e1] = 3
+      ht[e2] = 4
+
+      expect(ht.size).to eq(3)
+      expect(ht[x1]).to eq(1)
+      expect(ht[x2]).to eq(1)
+      expect(ht[y1]).to eq(2)
+      expect(ht[y2]).to eq(2)
+      expect(ht[e1]).to eq(4)
+      expect(ht[e2]).to eq(4)
+      expect(ht[f1]).to eq(nil)
+      expect(ht[f2]).to eq(nil)
+    end
+  end
 end

data/spec/integration/abc_path_spec.rb

@@ -0,0 +1,21 @@
+# There are multiple solutions, so this test is nondeterministic
+# This is what Z3 4.8.13 returns
+describe "ABC Path" do
+  it do
+    expect("abc_path").to have_output <<'EOF'
+C O R D F B U
+
+N o-n l-k-j L
+  | |/    |
+G p m g-f i I
+  |    x /
+Q q-r e h a H
+   /  |   |
+V s v d-c-b S
+   x \
+T u-t w-x-y X
+
+J P M W K Y E
+EOF
+  end
+end

data/spec/integration/aquarium_spec.rb

@@ -0,0 +1,27 @@
+describe "Aquarium" do
+  it do
+    expect("aquarium").to have_output <<EOF
++-+-+-+-+-+-+-+-+-+-+
+|# #|# # # # #|# #| |
++ +-+-+-+-+-+ +-+ + +
+|#|#|       |# #|#|#|
++ + + +-+-+-+-+-+-+-+
+|#|#| |# #|# #|   |#|
++ + + +-+-+-+-+   + +
+|#|#|#|   |   |   |#|
++ +-+-+   +   +-+-+-+
+|#|       |   |     |
++ + +-+   +-+ + +-+-+
+|#| | |   | |#|#|# #|
++ + + +-+-+ + +-+   +
+|#| |     | |#| |# #|
++ + +-+   + +-+ +-+ +
+|#|# #|   | |# # #|#|
++-+-+-+   + + +-+-+-+
+| |       |#|#|#|   |
++ +-+-+   + +-+ +   +
+|# # #|   |# #|#|# #|
++-+-+-+-+-+-+-+-+-+-+
+EOF
+  end
+end

data/spec/integration/cats_organized_neatly_spec.rb

@@ -0,0 +1,14 @@
+describe "Cats Organized Neatly" do
+  it do
+    expect("cats_organized_neatly").to have_output <<EOF
+.ffffbbb
+.fdddbbb
+aadddbbb
+aadddbbe
+aagggcee
+aagggcce
+aagggcc.
+..gggcc.
+EOF
+  end
+end

data/spec/integration/color_nonogram_spec.rb

@@ -0,0 +1,28 @@
+describe "Color Nonogram" do
+  let(:ascii_board) do <<EOF
+3 3 3 3 3 3 3 3 3 3
+3 0 2 2 0 0 0 0 0 3
+3 0 0 0 0 0 0 0 0 3
+3 2 1 0 0 0 2 1 0 3
+3 3 3 0 0 0 1 1 0 0
+3 0 0 0 0 0 0 0 0 0
+0 2 2 1 2 2 2 2 0 3
+0 0 2 2 2 2 2 0 0 3
+3 0 0 0 0 0 0 0 0 3
+3 0 0 3 3 3 3 0 0 3
+EOF
+  end
+
+  it do
+    color_board = ascii_board.gsub(/\d/) do |i|
+      {
+        "0" => "\e[38;2;255;0;0m0\e[0m",
+        "1" => "\e[38;2;0;0;0m1\e[0m",
+        "2" => "\e[38;2;255;255;255m2\e[0m",
+        "3" => "\e[38;2;165;42;42m3\e[0m",
+      }[i]
+    end
+
+    expect("color_nonogram").to have_output color_board
+  end
+end

data/spec/integration/dominion_spec.rb

@@ -0,0 +1,14 @@
+describe "Dominion" do
+  it do
+    expect("dominion").to have_output <<EOF
+**AAAA*B
+FF*AAA*B
+FF*A**BB
+F*E*GG**
+F*E*G*DD
+*G*GG*DD
+*G*G*C**
+GGGG*CCC
+EOF
+  end
+end

data/spec/integration/dominosa_spec.rb

@@ -0,0 +1,21 @@
+describe "Dominosa" do
+  it do
+    expect("dominosa").to have_output <<EOF
+5*5 7 4*1 1 4 2 3
+    *     * * * *
+2*0 2 4*7 5 4 2 0
+
+4*0 0 3 2 0 3 4*5
+    * * * * *
+1*1 6 4 6 5 2 5 6
+              * *
+6 1 1 7*7 5 6 3 6
+* * *     * *
+7 3 0 2*4 2 1 6*3
+
+6 5*6 0 1 3*3 0*0
+*     * *
+4 5*7 7 7 2*1 7*3
+EOF
+  end
+end

data/spec/integration/eulero_spec.rb

@@ -0,0 +1,11 @@
+describe "Eulero" do
+  it do
+    expect("eulero").to have_output <<EOF
+C2 B4 D5 A1 E3
+D1 A2 B3 E5 C4
+E4 D3 C1 B2 A5
+B5 E1 A4 C3 D2
+A3 C5 E2 D4 B1
+EOF
+  end
+end

data/spec/integration/futoshiki_spec.rb

@@ -0,0 +1,23 @@
+describe "Futoshiki" do
+  it do
+    expect("futoshiki").to have_output <<EOF
+2 5 3 4 1 7 6<9 8
+
+1 9 7 2 8 5 3<4<6
+  _
+7<8 2 5>3>1 4<6 9
+^
+8 1<5<9 7 6 2 3 4
+            ^
+4 7>6>1 9 2 5 8 3
+^         ^     ^
+6 4 1 8 2 3 9 5 7
+  _   _ ^   _ _
+9 3 4 6>5 8 7 1 2
+_
+5 2 9>3 6>4 8>7 1
+              _
+3 6 8>7>4 9 1<2 5
+EOF
+  end
+end

data/spec/integration/kakurasu_spec.rb

@@ -0,0 +1,18 @@
+describe "Kakurasu" do
+  it do
+    expect("kakurasu").to have_output <<EOF
+[ ][ ][X][ ][ ][ ][X][ ][ ][ ][ ][ ]
+[ ][X][ ][X][ ][ ][ ][ ][ ][X][X][X]
+[ ][X][X][X][ ][ ][X][ ][ ][ ][ ][ ]
+[ ][X][X][ ][ ][X][X][X][X][ ][X][X]
+[ ][X][ ][ ][ ][ ][ ][ ][ ][ ][ ][ ]
+[ ][ ][X][ ][ ][ ][ ][X][ ][ ][X][ ]
+[X][ ][ ][ ][ ][X][X][ ][ ][ ][X][X]
+[ ][ ][ ][ ][ ][ ][X][ ][ ][ ][X][X]
+[ ][ ][X][ ][ ][ ][ ][ ][ ][ ][X][ ]
+[ ][ ][ ][ ][X][ ][X][ ][X][ ][X][ ]
+[ ][ ][ ][ ][ ][X][X][ ][X][ ][X][ ]
+[ ][ ][X][ ][X][ ][X][ ][X][ ][X][ ]
+EOF
+  end
+end

data/spec/integration/killer_sudoku_spec.rb

@@ -0,0 +1,10 @@
+describe "Killer Sudoku" do
+  it do
+    expect("killer_sudoku").to have_output <<EOF
+4 2 3 1
+3 1 2 4
+2 4 1 3
+1 3 4 2
+EOF
+  end
+end