lisp: 63 bit -> 56 bit SMI

This massively simplifies the tagging implementation as all types now
have a 1 byte tag.  However, this does make the need for Big Integers
much greater as we've lost 8 bits of precision.

include/alisp/lisp.h

@@ -26,39 +26,26 @@ typedef struct
 /// Tagging system
 typedef enum Tag
 {
-  TAG_NIL  = 0b00000000, // Start of atomic types
+  TAG_INT  = 0b00000001, // Atomic types
-  TAG_INT  = 0b00000001, // Special tag so we can encode 63 bit integers
+  TAG_SYM  = 0b00000011,
-  TAG_SYM  = 0b00000100,
+  TAG_NIL  = 0b00000000, // Container types (0 LSB)
-  TAG_CONS = 0b00000010, // Start of container types
+  TAG_CONS = 0b00000010,
-  TAG_VEC  = 0b00000110,
+  TAG_VEC  = 0b00000100,
   NUM_TAGS = 5,
 } tag_t;
 
-static_assert(NUM_TAGS == 5, "Expected NUM_TAGS == 5 for enum SHIFT");
-enum Shift
-{
-  SHIFT_INT  = 1,
-  SHIFT_SYM  = 8,
-  SHIFT_CONS = 8,
-  SHIFT_VEC  = 8,
-};
-
-static_assert(NUM_TAGS == 5, "Expected NUM_TAGS == 5 for enum MASK");
-enum Mask
-{
-  MASK_INT  = 0b00000001,
-  MASK_SYM  = 0b11111111,
-  MASK_CONS = 0b11111111,
-  MASK_VEC  = 0b11111111,
-};
-
 // Some helper macros for tagging
-#define TAG(PTR, TYPE)    ((lisp_t *)(((PTR) << SHIFT_##TYPE) | TAG_##TYPE))
+#define SHIFT_TAG (8)
-#define IS_TAG(PTR, TYPE) (((u64)(PTR) & MASK_##TYPE) == TAG_##TYPE)
+#define MASK_TAG  ((1 << SHIFT_TAG) - 1)
-#define UNTAG(PTR, TYPE)  (((u64)PTR) >> SHIFT_##TYPE)
 
-#define INT_MAX ((((i64)1) << 62) - 1)
+#define TAG(PTR, TYPE)    ((lisp_t *)((((u64)(PTR)) << SHIFT_TAG) | TAG_##TYPE))
-#define INT_MIN (-(((i64)1) << 62))
+#define UNTAG(PTR)        (((u64)PTR) >> SHIFT_TAG)
+#define GET_TAG(PTR)      ((tag_t)(((u64)(PTR)) & MASK_TAG))
+#define IS_TAG(PTR, TYPE) (GET_TAG(PTR) == TAG_##TYPE)
+
+#define INT_BITS ((sizeof(i64) * 8) - SHIFT_TAG)
+#define INT_MAX  ((((i64)1) << (INT_BITS - 1)) - 1)
+#define INT_MIN  (-(INT_MAX + 1))
 
 tag_t get_tag(const lisp_t *);
 lisp_t *tag_int(const i64);

src/lisp.c

@@ -12,22 +12,22 @@
 
 lisp_t *tag_int(i64 i)
 {
-  return TAG((u64)i, INT);
+  return TAG(i, INT);
 }
 
 lisp_t *tag_sym(const char *str)
 {
-  return TAG((u64)str, SYM);
+  return TAG(str, SYM);
 }
 
 lisp_t *tag_vec(const vec_t *vec)
 {
-  return TAG((u64)vec, VEC);
+  return TAG(vec, VEC);
 }
 
 lisp_t *tag_cons(const cons_t *cons)
 {
-  return TAG((u64)cons, CONS);
+  return TAG(cons, CONS);
 }
 
 lisp_t *tag_generic(void *ptr, tag_t type)
@@ -35,7 +35,7 @@ lisp_t *tag_generic(void *ptr, tag_t type)
   switch (type)
   {
   case TAG_NIL:
-    return NIL;
+    return TAG(ptr, NIL);
   case TAG_INT:
     return tag_int((i64)ptr);
   case TAG_SYM:
@@ -53,39 +53,34 @@ lisp_t *tag_generic(void *ptr, tag_t type)
 tag_t get_tag(const lisp_t *lisp)
 {
   static_assert(NUM_TAGS == 5);
-  if (!lisp)
+  return GET_TAG(lisp);
-    return TAG_NIL;
-  else if (IS_TAG(lisp, INT))
-    return TAG_INT;
-
-  return (u64)lisp & 0xFF;
 }
 
 i64 as_int(lisp_t *obj)
 {
   assert(IS_TAG(obj, INT));
-  u64 p_obj = (u64)obj;
+  u64 raw_obj = UNTAG(obj);
-  return UNTAG(p_obj, INT) |               // Delete the tag
+  u64 msb     = (NTH_BYTE(raw_obj, 6) & 0x80) >> 7;
-         (NTH_BYTE(p_obj, 7) & 0x80) << 56 // duplicate the MSB (preserve sign)
+  msb         = ((1LU << 8) - msb) << 56;
-      ;
+  return (i64)(raw_obj | msb);
 }
 
 char *as_sym(lisp_t *obj)
 {
   assert(IS_TAG(obj, SYM));
-  return (char *)UNTAG(obj, SYM);
+  return (char *)UNTAG(obj);
 }
 
 cons_t *as_cons(lisp_t *obj)
 {
   assert(IS_TAG(obj, CONS));
-  return (cons_t *)UNTAG(obj, CONS);
+  return (cons_t *)UNTAG(obj);
 }
 
 vec_t *as_vec(lisp_t *obj)
 {
   assert(IS_TAG(obj, VEC));
-  return (vec_t *)UNTAG(obj, VEC);
+  return (vec_t *)UNTAG(obj);
 }
 
 void lisp_print(FILE *fp, lisp_t *lisp)