z3 0.0.20160427 → 0.0.20161008

data/lib/z3/expr/bitvec_expr.rb

@@ -9,59 +9,339 @@ module Z3
     end
 
     def &(other)
-      Z3.And(self, other)
+      Expr.And(self, other)
     end
 
     def |(other)
-      Z3.Or(self, other)
+      Expr.Or(self, other)
     end
 
     def ^(other)
-      Z3.Xor(self, other)
+      Expr.Xor(self, other)
+    end
+
+    def xnor(other)
+      BitvecExpr.Xnor(self, other)
+    end
+
+    def nand(other)
+      BitvecExpr.Nand(self, other)
+    end
+
+    def nor(other)
+      BitvecExpr.Nor(self, other)
     end
 
     def +(other)
-      ::Z3.Add(self, other)
+      Expr.Add(self, other)
     end
 
     def -(other)
-      ::Z3.Sub(self, other)
+      Expr.Sub(self, other)
     end
 
     def *(other)
-      ::Z3.Mul(self, other)
+      Expr.Mul(self, other)
+    end
+
+    def /(other)
+      raise "Use signed_div or unsigned_div"
+    end
+
+    def %(other)
+      raise "Use signed_mod or signed_rem or unsigned_rem"
+    end
+
+    def rotate_left(num)
+      sort.new(LowLevel.mk_rotate_left(num, self))
+    end
+
+    def rotate_right(num)
+      sort.new(LowLevel.mk_rotate_right(num, self))
+    end
+
+    def zero_ext(size)
+      BitvecSort.new(sort.size + size).new(LowLevel.mk_zero_ext(size, self))
+    end
+
+    def sign_ext(size)
+      BitvecSort.new(sort.size + size).new(LowLevel.mk_sign_ext(size, self))
+    end
+
+    def add_no_overflow?(other)
+      raise Z3::Exception, "Use #signed_add_no_overflow? or #unsigned_add_no_overflow? for Bitvec, not #add_no_overflow?"
+    end
+
+    def add_no_overflow?(other)
+      raise "Use signed_add_no_overflow? or unsigned_add_no_overflow?"
+    end
+    def signed_add_no_overflow?(other)
+      BitvecExpr.SignedAddNoOverflow(self, other)
+    end
+    def unsigned_add_no_overflow?(other)
+      BitvecExpr.UnsignedAddNoOverflow(self, other)
+    end
+
+    def add_no_underflow?(other)
+      BitvecExpr.SignedAddNoUnderflow(self, other)
+    end
+    def signed_add_no_underflow?(other)
+      BitvecExpr.SignedAddNoUnderflow(self, other)
+    end
+    def unsigned_add_no_underflow?(other)
+      raise "Unsigned + cannot underflow"
+    end
+
+    def unsigned_neg_no_overflow?
+      raise "There is no unsigned negation"
+    end
+    def signed_neg_no_overflow?
+      BitvecExpr.SignedNegNoOverflow(self)
+    end
+    def neg_no_overflow?
+      BitvecExpr.SignedNegNoOverflow(self)
+    end
+
+    def mul_no_overflow?(other)
+      raise "Use signed_mul_no_overflow? or unsigned_mul_no_overflow?"
+    end
+    def signed_mul_no_overflow?(other)
+      BitvecExpr.SignedMulNoOverflow(self, other)
+    end
+    def unsigned_mul_no_overflow?(other)
+      BitvecExpr.UnsignedMulNoOverflow(self, other)
+    end
+
+    def mul_no_underflow?(other)
+      BitvecExpr.SignedMulNoUnderflow(self, other)
+    end
+    def signed_mul_no_underflow?(other)
+      BitvecExpr.SignedMulNoUnderflow(self, other)
+    end
+    def unsigned_mul_no_underflow?(other)
+      raise "Unsigned + cannot underflow"
+    end
+
+    def div_no_overflow?(other)
+      BitvecExpr.SignedDivNoOverflow(self, other)
+    end
+    def signed_div_no_overflow?(other)
+      BitvecExpr.SignedDivNoOverflow(self, other)
+    end
+    def unsigned_div_no_overflow?(other)
+      raise "Unsigned / cannot underflow"
     end
 
     def >>(other)
-      Z3.RShift(self, other)
+      raise Z3::Exception, "Use #signed_rshift or #unsigned_rshift for Bitvec, not >>"
+    end
+
+    def signed_rshift(other)
+      BitvecExpr.SignedRShift(self, other)
+    end
+
+    def unsigned_rshift(other)
+      BitvecExpr.UnsignedRShift(self, other)
+    end
+
+    def rshift(other)
+      raise Z3::Exception, "Use #signed_rshift or #unsigned_rshift for Bitvec, not #rshift"
     end
 
     def <<(other)
-      Z3.LShift(self, other)
+      BitvecExpr.LShift(self, other)
+    end
+
+    def signed_lshift(other)
+      BitvecExpr.LShift(self, other)
+    end
+
+    def unsigned_lshift(other)
+      BitvecExpr.LShift(self, other)
+    end
+
+    def lshift(other)
+      BitvecExpr.LShift(self, other)
     end
 
     def >(other)
-      ::Z3.Gt(self, other)
+      Expr.Gt(self, other)
     end
 
     def >=(other)
-      ::Z3.Ge(self, other)
+      Expr.Ge(self, other)
     end
 
     def <=(other)
-      ::Z3.Le(self, other)
+      Expr.Le(self, other)
     end
 
     def <(other)
-      ::Z3.Lt(self, other)
+      Expr.Lt(self, other)
+    end
+
+    def signed_gt(other)
+      BitvecExpr.SignedGt(self, other)
+    end
+
+    def signed_ge(other)
+      BitvecExpr.SignedGe(self, other)
+    end
+
+    def signed_lt(other)
+      BitvecExpr.SignedLt(self, other)
+    end
+
+    def signed_le(other)
+      BitvecExpr.SignedLe(self, other)
+    end
+
+    def unsigned_gt(other)
+      BitvecExpr.UnsignedGt(self, other)
+    end
+
+    def unsigned_ge(other)
+      BitvecExpr.UnsignedGe(self, other)
+    end
+
+    def unsigned_lt(other)
+      BitvecExpr.UnsignedLt(self, other)
+    end
+
+    def unsigned_le(other)
+      BitvecExpr.UnsignedLe(self, other)
     end
 
     def coerce(other)
-      other_sort = Value.sort_for_const(other)
+      other_sort = Expr.sort_for_const(other)
       max_sort = [sort, other_sort].max
       [max_sort.from_const(other), max_sort.from_value(self)]
     end
 
     public_class_method :new
+
+    class << self
+      def coerce_to_same_bv_sort(*args)
+        args = coerce_to_same_sort(*args)
+        raise Z3::Exception, "Bitvec value with same size expected" unless args[0].is_a?(BitvecExpr)
+        args
+      end
+
+      def SignedRShift(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        a.sort.new(LowLevel.mk_bvashr(a, b))
+      end
+
+      def UnsignedRShift(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        a.sort.new(LowLevel.mk_bvlshr(a, b))
+      end
+
+      # Signed/Unsigned work the same
+      def LShift(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        a.sort.new(LowLevel.mk_bvshl(a, b))
+      end
+
+      def Xnor(*args)
+        args = coerce_to_same_bv_sort(*args)
+        args.inject do |a,b|
+          a.sort.new(LowLevel.mk_bvxnor(a, b))
+        end
+      end
+
+      def Nand(*args)
+        args = coerce_to_same_bv_sort(*args)
+        args.inject do |a,b|
+          a.sort.new(LowLevel.mk_bvnand(a, b))
+        end
+      end
+
+      def Nor(*args)
+        args = coerce_to_same_bv_sort(*args)
+        args.inject do |a,b|
+          a.sort.new(LowLevel.mk_bvnor(a, b))
+        end
+      end
+
+      def UnsignedGt(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvugt(a, b))
+      end
+
+      def UnsignedGe(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvuge(a, b))
+      end
+
+      def UnsignedLt(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvult(a, b))
+      end
+
+      def UnsignedLe(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvule(a, b))
+      end
+
+      def SignedGt(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvsgt(a, b))
+      end
+
+      def SignedGe(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvsge(a, b))
+      end
+
+      def SignedLt(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvslt(a, b))
+      end
+
+      def SignedLe(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvsle(a, b))
+      end
+
+      def SignedAddNoOverflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvadd_no_overflow(a, b, true))
+      end
+
+      def UnsignedAddNoOverflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvadd_no_overflow(a, b, false))
+      end
+
+      def SignedAddNoUnderflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvadd_no_underflow(a, b))
+      end
+
+      def SignedNegNoOverflow(a)
+        BoolSort.new.new(LowLevel.mk_bvneg_no_overflow(a))
+      end
+
+      def SignedMulNoOverflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvmul_no_overflow(a, b, true))
+      end
+
+      def UnsignedMulNoOverflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvmul_no_overflow(a, b, false))
+      end
+
+      def SignedMulNoUnderflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvmul_no_underflow(a, b))
+      end
+
+      def SignedDivNoOverflow(a, b)
+        a, b = coerce_to_same_bv_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_bvsdiv_no_overflow(a, b))
+      end
+    end
   end
 end

data/lib/z3/expr/bool_expr.rb

@@ -5,29 +5,53 @@ module Z3
     end
 
     def &(other)
-      Z3.And(self, other)
+      Expr.And(self, other)
     end
 
     def |(other)
-      Z3.Or(self, other)
+      Expr.Or(self, other)
     end
 
     def ^(other)
-      Z3.Xor(self, other)
+      Expr.Xor(self, other)
     end
 
     def iff(other)
-      Z3.Iff(self, other)
+      BoolExpr.Iff(self, other)
     end
 
     def implies(other)
-      Z3.Implies(self, other)
+      BoolExpr.Implies(self, other)
     end
 
     def ite(a, b)
-      Z3.IfThenElse(self, a, b)
+      BoolExpr.IfThenElse(self, a, b)
     end
 
     public_class_method :new
+
+    class << self
+      def coerce_to_same_bool_sort(*args)
+        args = coerce_to_same_sort(*args)
+        raise Z3::Exception, "Bool value expected" unless args[0].is_a?(BoolExpr)
+        args
+      end
+
+      def Implies(a,b)
+        a, b = coerce_to_same_bool_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_implies(a, b))
+      end
+
+      def Iff(a,b)
+        a, b = coerce_to_same_bool_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_iff(a, b))
+      end
+
+      def IfThenElse(a, b, c)
+        a, = coerce_to_same_bool_sort(a)
+        b, c = coerce_to_same_sort(b, c)
+        b.sort.new(LowLevel.mk_ite(a, b, c))
+      end
+    end
   end
 end

data/lib/z3/expr/expr.rb

@@ -12,14 +12,22 @@ module Z3
     end
 
     def ==(other)
-      ::Z3.Eq(self, other)
+      Expr.Eq(self, other)
     end
 
     def !=(other)
-      ::Z3.Distinct(self, other)
+      Expr.Distinct(self, other)
     end
 
     class << self
+      def coerce_to_same_sort(*args)
+        # This will raise exception unless one of the sorts is highest
+        max_sort = args.map{|a| a.is_a?(Expr) ? a.sort : Expr.sort_for_const(a)}.max
+        args.map do |a|
+          max_sort.cast(a)
+        end
+      end
+
       def sort_for_const(a)
         case a
         when TrueClass, FalseClass
@@ -37,6 +45,151 @@ module Z3
         _sort = Z3::VeryLowLevel.Z3_get_sort(Z3::LowLevel._ctx_pointer, _ast)
         Sort.from_pointer(_sort).new(_ast)
       end
+
+      def Gt(a, b)
+        a, b = coerce_to_same_sort(a, b)
+        case a
+        when ArithExpr
+          BoolSort.new.new(LowLevel.mk_gt(a, b))
+        when BitvecExpr
+          raise Z3::Exception, "Use #signed_gt or #unsigned_gt for Bitvec, not >"
+        else
+          raise Z3::Exception, "Can't compare #{a.sort} values"
+        end
+      end
+
+      def Ge(a, b)
+        a, b = coerce_to_same_sort(a, b)
+        case a
+        when ArithExpr
+          BoolSort.new.new(LowLevel.mk_ge(a, b))
+        when BitvecExpr
+          raise Z3::Exception, "Use #signed_ge or #unsigned_ge for Bitvec, not >="
+        else
+          raise Z3::Exception, "Can't compare #{a.sort} values"
+        end
+      end
+
+      def Lt(a, b)
+        a, b = coerce_to_same_sort(a, b)
+        case a
+        when ArithExpr
+          BoolSort.new.new(LowLevel.mk_lt(a, b))
+        when BitvecExpr
+          raise Z3::Exception, "Use #signed_lt or #unsigned_lt for Bitvec, not <"
+        else
+          raise Z3::Exception, "Can't compare #{a.sort} values"
+        end
+      end
+
+      def Le(a, b)
+        a, b = coerce_to_same_sort(a, b)
+        case a
+        when ArithExpr
+          BoolSort.new.new(LowLevel.mk_le(a, b))
+        when BitvecExpr
+          raise Z3::Exception, "Use #signed_le or #unsigned_le for Bitvec, not <="
+        else
+          raise Z3::Exception, "Can't compare #{a.sort} values"
+        end
+      end
+
+      def Eq(a, b)
+        a, b = coerce_to_same_sort(a, b)
+        BoolSort.new.new(LowLevel.mk_eq(a, b))
+      end
+
+      def Distinct(*args)
+        args = coerce_to_same_sort(*args)
+        BoolSort.new.new(LowLevel.mk_distinct(args))
+      end
+
+      def And(*args)
+        args = coerce_to_same_sort(*args)
+        case args[0]
+        when BoolExpr
+          BoolSort.new.new(Z3::LowLevel.mk_and(args))
+        when BitvecExpr
+          args.inject do |a,b|
+            a.sort.new(Z3::LowLevel.mk_bvand(a, b))
+          end
+        else
+          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+        end
+      end
+
+      def Or(*args)
+        args = coerce_to_same_sort(*args)
+        case args[0]
+        when BoolExpr
+          BoolSort.new.new(Z3::LowLevel.mk_or(args))
+        when BitvecExpr
+          args.inject do |a,b|
+            a.sort.new(Z3::LowLevel.mk_bvor(a, b))
+          end
+        else
+          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+        end
+      end
+
+      def Xor(*args)
+        args = coerce_to_same_sort(*args)
+        case args[0]
+        when BoolExpr
+          args.inject do |a,b|
+            BoolSort.new.new(Z3::LowLevel.mk_xor(a, b))
+          end
+        when BitvecExpr
+          args.inject do |a,b|
+            a.sort.new(Z3::LowLevel.mk_bvxor(a, b))
+          end
+        else
+          raise Z3::Exception, "Can't perform logic operations on #{a.sort} exprs, only Bool and Bitvec"
+        end
+      end
+
+      def Add(*args)
+        raise Z3::Exception if args.empty?
+        args = coerce_to_same_sort(*args)
+        case args[0]
+        when ArithExpr
+          args[0].sort.new(LowLevel.mk_add(args))
+        when BitvecExpr
+          args.inject do |a,b|
+            a.sort.new(LowLevel.mk_bvadd(a,b))
+          end
+        else
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} exprs, only Int/Real/Bitvec"
+        end
+      end
+
+      def Sub(*args)
+        args = coerce_to_same_sort(*args)
+        case args[0]
+        when ArithExpr
+          args[0].sort.new(LowLevel.mk_sub(args))
+        when BitvecExpr
+          args.inject do |a,b|
+            a.sort.new(LowLevel.mk_bvsub(a,b))
+          end
+        else
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
+        end
+      end
+
+      def Mul(*args)
+        args = coerce_to_same_sort(*args)
+        case args[0]
+        when ArithExpr
+          args[0].sort.new(LowLevel.mk_mul(args))
+        when BitvecExpr
+          args.inject do |a,b|
+            a.sort.new(LowLevel.mk_bvmul(a,b))
+          end
+        else
+          raise Z3::Exception, "Can't perform logic operations on #{args[0].sort} values, only Int/Real/Bitvec"
+        end
+      end
     end
   end
 end