[Commit] nickle ChangeLog, 1.58, 1.59 int.c, 1.22, 1.23 nickle.h, 1.116, 1.117 value.h, 1.103, 1.104

[Keith Packard]

Committed by: keithp

Update of /local/src/CVS/nickle
In directory home.keithp.com:/tmp/cvs-serv15958

Modified Files:
	ChangeLog int.c nickle.h value.h 
Log Message:
2004-05-27  Keith Packard  <keithp at keithp.com>

	reviewed by: <delete if not using a buddy>

	* int.c: (IntPlus), (IntMinus):
	* nickle.h:
	* value.h:
	Overflow detection from small integer add/subtract was
	broken.


Index: ChangeLog
===================================================================
RCS file: /local/src/CVS/nickle/ChangeLog,v
retrieving revision 1.58
retrieving revision 1.59
diff -u -d -r1.58 -r1.59
--- a/ChangeLog	28 May 2004 01:26:38 -0000	1.58
+++ b/ChangeLog	28 May 2004 02:58:14 -0000	1.59
@@ -1,4 +1,14 @@
 2004-05-27  Keith Packard  <keithp at keithp.com>
+
+	reviewed by: <delete if not using a buddy>
+
+	* int.c: (IntPlus), (IntMinus):
+	* nickle.h:
+	* value.h:
+	Overflow detection from small integer add/subtract was
+	broken.
+
+2004-05-27  Keith Packard  <keithp at keithp.com>
 version 2.37
 
 	* value.c: (ShiftR):

Index: int.c
===================================================================
RCS file: /local/src/CVS/nickle/int.c,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -d -r1.22 -r1.23
--- a/int.c	16 Apr 2004 21:41:52 -0000	1.22
+++ b/int.c	28 May 2004 02:58:14 -0000	1.23
@@ -11,9 +11,9 @@
 static Value
 IntPlus (Value av, Value bv, int expandOk)
 {
-    int	    r = ValueUInt(av) + ValueUInt(bv);
+    int	    r = ValueInt(av) + ValueInt(bv);
     
-    if (expandOk && (r & NICKLE_INT_CARRY))
+    if (expandOk && NICKLE_INT_CARRIED(r))
 	return Plus (NewIntInteger (ValueInt(av)), NewIntInteger(ValueInt(bv)));
     return NewInt(r);
 }
@@ -21,9 +21,9 @@
 static Value
 IntMinus (Value av, Value bv, int expandOk)
 {
-    int	    r = ValueUInt(av) - ValueUInt(bv);
+    int	    r = ValueInt(av) - ValueInt(bv);
     
-    if (expandOk && (r & NICKLE_INT_CARRY))
+    if (expandOk && NICKLE_INT_CARRIED(r))
 	return Minus (NewIntInteger (ValueInt(av)), NewIntInteger(ValueInt(bv)));
     return NewInt(r);
 }

Index: nickle.h
===================================================================
RCS file: /local/src/CVS/nickle/nickle.h,v
retrieving revision 1.116
retrieving revision 1.117
diff -u -d -r1.116 -r1.117
--- a/nickle.h	13 May 2004 21:16:52 -0000	1.116
+++ b/nickle.h	28 May 2004 02:58:14 -0000	1.117
@@ -772,15 +772,15 @@
     signed_digit rd;
     switch (operator) {
     case PlusOp:
-	r = ValueUInt(av) + ValueUInt(bv);
+	r = ValueInt(av) + ValueInt(bv);
 
-	if (r & NICKLE_INT_CARRY)
+	if (NICKLE_INT_CARRIED(r))
 	    return Plus (NewIntInteger (ValueInt(av)), NewIntInteger(ValueInt(bv)));
 	return NewInt(r);
     case MinusOp:
-	r = ValueUInt(av) - ValueUInt(bv);
+	r = ValueInt(av) - ValueInt(bv);
 
-	if (r & NICKLE_INT_CARRY)
+	if (NICKLE_INT_CARRIED(r))
 	    return Minus (NewIntInteger (ValueInt(av)), NewIntInteger(ValueInt(bv)));
 	return NewInt(r);    
     case TimesOp:
@@ -886,7 +886,7 @@
 	a++;
     else
 	a--;
-    if ((a << 1 ^ a) & NICKLE_INT_CARRY)
+    if (NICKLE_INT_CARRIED(a))
 	return NewIntInteger (a);
     return NewInt (a);
 }

Index: value.h
===================================================================
RCS file: /local/src/CVS/nickle/value.h,v
retrieving revision 1.103
retrieving revision 1.104
diff -u -d -r1.103 -r1.104
--- a/value.h	26 May 2004 08:59:23 -0000	1.103
+++ b/value.h	28 May 2004 02:58:14 -0000	1.104
@@ -303,10 +303,30 @@
 #define NewInt(i)	((Value) IntToPtr ((((i) << 1) | 1)))
 #define IntSign(i)	((i) < 0 ? Negative : Positive)
 
+/*
+ * Use all but one bit to hold immediate integer values
+ */
 #define NICKLE_INT_BITS	    ((sizeof (int) * 8) - 1)
-#define NICKLE_INT_CARRY    (1 << (NICKLE_INT_BITS - 1))
+#define NICKLE_INT_SIGN	    (1 << (NICKLE_INT_BITS - 1))
+/*
+ * this bit holds any overflow; when different from SIGN,
+ * an addition/subtraction has overflowed
+ */
+#define NICKLE_INT_CARRY    (1 << NICKLE_INT_BITS)
+/*
+ * An int fits in a 'nickle int' if the top two bits
+ * are the same.  There are four initial values:
+ *
+ *  00 + 01 = 01
+ *  01 + 01 = 10
+ *  10 + 01 = 11
+ *  11 + 01 = 00
+ *
+ * So, the two 'naughty' ones end up with the high bit set
+ */
+#define NICKLE_INT_CARRIED(r)	(((r) + NICKLE_INT_SIGN) & NICKLE_INT_CARRY)
 
-#define MAX_NICKLE_INT	    ((int) ((unsigned) NICKLE_INT_CARRY - 1))
+#define MAX_NICKLE_INT	    ((int) ((unsigned) NICKLE_INT_SIGN - 1))
 #define MIN_NICKLE_INT	    (-MAX_NICKLE_INT - 1)
 
 #define One NewInt(1)
@@ -315,7 +335,6 @@
 #define ValueIsPtr(v)	((PtrToInt(v) & 1) == 0)
 #define ValueIsInt(v)	(!ValueIsPtr(v))
 #define ValueInt(v)	(PtrToInt (v) >> 1)
-#define ValueUInt(v)	(PtrToUInt (v) >> 1)
 
 #define ValueRep(v) (ValueIsInt(v) ? &IntRep : (v)->value.type)
 #define ValueIsInteger(v) (ValueRep(v) == &IntegerRep)