added bit ops from Toralf Wittner

4 files changed, 209 insertions, 1 deletions

diff --git a/src/boot.clj b/src/boot.clj
index ad43cb53..94860790 100644
--- a/src/boot.clj
+++ b/src/boot.clj
@@ -267,6 +267,26 @@
 (defn rem [num div]
   (. clojure.lang.Num (remainder num div)))
 
+;;Bit ops
+
+(defn bit-shift-left [x y]
+  (. clojure.lang.IntegerNum (shiftLeft x y)))
+
+(defn bit-shift-right [x y]
+  (. clojure.lang.IntegerNum (shiftRight x y)))
+
+(defn bit-and [x y]
+  (. clojure.lang.IntegerNum (bitAnd x y)))
+
+(defn bit-or [x y]
+  (. clojure.lang.IntegerNum (bitOr x y)))
+
+(defn bit-xor [x y]
+  (. clojure.lang.IntegerNum (bitXor x y)))
+
+(defn bit-not [x]
+  (. clojure.lang.IntegerNum (bitNot x)))
+
 (defn complement [f]
   (fn [& args]
     (not (apply f args))))
@@ -923,5 +943,7 @@
 		make-array
 		macroexpand-1 macroexpand
 		max min
+		bit-shift-left bit-shift-right
+		bit-and bit-or bit-xor bit-not
 	))
 
diff --git a/src/jvm/clojure/lang/BigNum.java b/src/jvm/clojure/lang/BigNum.java
index 3d0e9091..4b36160f 100644
--- a/src/jvm/clojure/lang/BigNum.java
+++ b/src/jvm/clojure/lang/BigNum.java
@@ -181,5 +181,70 @@ public Num oneMinus(){
 public Num onePlus(){
 	return Num.from(val.add(BigInteger.ONE));
 }
+
+public Num bitXorBy(IntegerNum rhs){
+	return rhs.bitXor(val);
+}
+
+public Num bitXor(BigInteger y){
+	return Num.from(val.xor(y));
+}
+
+public Num bitXor(int y){
+	return Num.from(val.xor(BigInteger.valueOf(y)));
+}
+
+public Num bitAndBy(IntegerNum rhs){
+	return rhs.bitAnd(val);
+}
+
+public Num bitAnd(int y){
+	return Num.from(val.and(BigInteger.valueOf(y)));
+}
+
+public Num bitAnd(BigInteger y){
+	return Num.from(val.and(y));
+}
+
+public Num bitOrBy(IntegerNum rhs){
+	return rhs.bitOr(val);
+}
+
+public Num bitOr(int y){
+	return Num.from(val.or(BigInteger.valueOf(y)));
+}
+
+public Num bitOr(BigInteger y){
+	return Num.from(val.or(y));
+}
+
+public Num bitNot(){
+	return Num.from(val.not());
+}
+
+public Num shiftLeftBy(IntegerNum rhs){
+	return rhs.shiftLeft(val);
+}
+
+public Num shiftLeft(BigInteger y){
+	return Num.from(val.shiftLeft(y.intValue()));
+}
+
+public Num shiftLeft(int y){
+	return Num.from(val.shiftLeft(y));
+}
+
+public Num shiftRightBy(IntegerNum rhs){
+	return rhs.shiftRight(val);
+}
+
+public Num shiftRight(BigInteger y){
+	return Num.from(val.shiftRight(y.intValue()));
+}
+
+public Num shiftRight(int y){
+	return Num.from(val.shiftRight(y));
+}
+
 }
 
diff --git a/src/jvm/clojure/lang/FixNum.java b/src/jvm/clojure/lang/FixNum.java
index 3f784b21..4789dfea 100644
--- a/src/jvm/clojure/lang/FixNum.java
+++ b/src/jvm/clojure/lang/FixNum.java
@@ -201,4 +201,69 @@ public Num onePlus(){
 	return Num.from(val + 1);
 }
 
+public Num bitXorBy(IntegerNum rhs){
+	return rhs.bitXor(val);
+}
+
+public Num bitXor(BigInteger y){
+	return Num.from(BigInteger.valueOf(val).xor(y));
+}
+
+public Num bitXor(int y){
+	return Num.from(val ^ y);
+}
+
+public Num bitAndBy(IntegerNum rhs){
+	return rhs.bitAnd(val);
+}
+
+public Num bitAnd(int y){
+	return Num.from(val & y);
+}
+
+public Num bitAnd(BigInteger y){
+	return Num.from(BigInteger.valueOf(val).and(y));
+}
+
+public Num bitOrBy(IntegerNum rhs){
+	return rhs.bitOr(val);
+}
+
+public Num bitOr(int y){
+	return Num.from(val | y);
+}
+
+public Num bitOr(BigInteger y){
+	return Num.from(BigInteger.valueOf(val).or(y));
+}
+
+public Num bitNot(){
+	return Num.from(~val);
+}
+
+public Num shiftLeftBy(IntegerNum rhs){
+	return rhs.shiftLeft(val);
+}
+
+public Num shiftLeft(BigInteger y){
+	return Num.from(val << y.intValue());
+}
+
+public Num shiftLeft(int y){
+	return Num.from(val << y);
+}
+
+public Num shiftRightBy(IntegerNum rhs){
+	return rhs.shiftRight(val);
+}
+
+public Num shiftRight(BigInteger y){
+	return Num.from(val >> y.intValue());
+}
+
+public Num shiftRight(int y){
+	return Num.from(val >> y);
+}
+
+
 }
diff --git a/src/jvm/clojure/lang/IntegerNum.java b/src/jvm/clojure/lang/IntegerNum.java
index 6fe1ad79..937c3356 100644
--- a/src/jvm/clojure/lang/IntegerNum.java
+++ b/src/jvm/clojure/lang/IntegerNum.java
@@ -12,6 +12,62 @@
 
 package clojure.lang;
 
-public abstract class IntegerNum extends RationalNum {
+import java.math.BigInteger;
 
+public abstract class IntegerNum extends RationalNum{
+static public Num bitXor(Object x, Object y){
+	return ((IntegerNum) Num.from(y)).bitXorBy((IntegerNum) Num.from(x));
+}
+
+abstract public Num bitXorBy(IntegerNum y);
+
+abstract public Num bitXor(int y);
+
+abstract public Num bitXor(BigInteger y);
+
+static public Num bitAnd(Object x, Object y){
+	return ((IntegerNum) Num.from(y)).bitAndBy((IntegerNum) Num.from(x));
+}
+
+abstract public Num bitAndBy(IntegerNum y);
+
+abstract public Num bitAnd(int y);
+
+abstract public Num bitAnd(BigInteger y);
+
+static public Num bitOr(Object x, Object y){
+	return ((IntegerNum) Num.from(y)).bitOrBy((IntegerNum) Num.from(x));
+}
+
+abstract public Num bitOrBy(IntegerNum y);
+
+abstract public Num bitOr(int y);
+
+abstract public Num bitOr(BigInteger y);
+
+static public Num bitNot(Object x){
+	return ((IntegerNum) Num.from(x)).bitNot();
+}
+
+abstract public Num bitNot();
+
+static public Num shiftLeft(Object x, Object y){
+	return ((IntegerNum) Num.from(y)).shiftLeftBy((IntegerNum) Num.from(x));
+}
+
+abstract public Num shiftLeftBy(IntegerNum y);
+
+abstract public Num shiftLeft(BigInteger y);
+
+abstract public Num shiftLeft(int y);
+
+static public Num shiftRight(Object x, Object y){
+	return ((IntegerNum) Num.from(y)).shiftRightBy((IntegerNum) Num.from(x));
+}
+
+abstract public Num shiftRightBy(IntegerNum y);
+
+abstract public Num shiftRight(BigInteger y);
+
+abstract public Num shiftRight(int y);
 }
\ No newline at end of file