* arith.c: File is now generated using TXR.

(NOOP): New macro.
(plus): Use NOOP macro.
(minus, neg): Function moved here from lib.c and rewritten
for bignum support.

* lib.c (minus, neg): Functions removed.

* arith.txr: New file.

1 files changed, 82 insertions, 1 deletions

diff --git a/arith.c b/arith.c
index a1026b37..f13d067e 100644
--- a/arith.c
+++ b/arith.c
@@ -1,4 +1,6 @@
-/* Copyright 2011
+/* This file is generated using txr arith.txr > arith.c!
+ *
+ * Copyright 2011
  * Kaz Kylheku <kaz@kylheku.com>
  * Vancouver, Canada
  * All rights reserved.
@@ -42,6 +44,7 @@
 #include "arith.h"
 
 #define TAG_PAIR(A, B) ((A) << TAG_SHIFT | (B))
+#define NOOP(A, B)
 
 static mp_int NUM_MAX_MP;
 
@@ -95,6 +98,7 @@ val plus(val anum, val bnum)
       n = make_bignum();
       if (sizeof (int_ptr_t) <= sizeof (mp_digit))  {
         mp_add_d(mp(bnum), c_num(anum), mp(n));
+        NOOP(mp(n), mp(n));
       } else {
         mp_int tmp;
         mp_init(&tmp);
@@ -132,6 +136,83 @@ val plus(val anum, val bnum)
   abort();
 }
 
+val minus(val anum, val bnum)
+{
+  int tag_a = tag(anum);
+  int tag_b = tag(bnum);
+
+  switch (TAG_PAIR(tag_a, tag_b)) {
+  case TAG_PAIR(TAG_NUM, TAG_NUM): 
+    {
+      cnum a = c_num(anum);
+      cnum b = c_num(bnum);
+      cnum sum = a - b;
+
+      if (sum < NUM_MIN || sum > NUM_MAX) {
+        val n = make_bignum();
+        mp_set_intptr(mp(n), sum);
+        return n;
+      }
+
+      return num(sum);
+    } 
+  case TAG_PAIR(TAG_NUM, TAG_PTR):
+    {
+      val n;
+      type_check(bnum, BGNUM);
+      n = make_bignum();
+      if (sizeof (int_ptr_t) <= sizeof (mp_digit))  {
+        mp_sub_d(mp(bnum), c_num(anum), mp(n));
+        mp_neg(mp(n), mp(n));
+      } else {
+        mp_int tmp;
+        mp_init(&tmp);
+        mp_set_intptr(&tmp, c_num(anum));
+        mp_sub(mp(bnum), &tmp, mp(n));
+      }
+      return normalize(n);
+    }
+  case TAG_PAIR(TAG_PTR, TAG_NUM):
+    {
+        val n;
+        type_check(anum, BGNUM);
+        n = make_bignum();
+        if (sizeof (int_ptr_t) <= sizeof (mp_digit))  {
+          mp_sub_d(mp(anum), c_num(bnum), mp(n));
+        } else {
+          mp_int tmp;
+          mp_init(&tmp);
+          mp_set_intptr(&tmp, c_num(bnum));
+          mp_sub(mp(anum), &tmp, mp(n));
+        }
+        return normalize(n);
+    }
+  case TAG_PAIR(TAG_PTR, TAG_PTR):
+    {
+      val n;
+      type_check(anum, BGNUM);
+      type_check(bnum, BGNUM);
+      n = make_bignum();
+      mp_sub(mp(anum), mp(bnum), mp(n));
+      return normalize(n);
+    }
+  }
+  uw_throwf(error_s, lit("minus: invalid operands ~s ~s"), anum, bnum, nao);
+  abort();
+}
+
+val neg(val anum)
+{
+  if (bignump(anum)) {
+    val n = make_bignum();
+    mp_neg(mp(anum), mp(n));
+    return n;
+  } else {
+    cnum n = c_num(anum);
+    return num(-n);
+  }
+}
+
 void arith_init(void)
 {
   mp_init(&NUM_MAX_MP);