implemented the single quote character literal.

added the error literal and the smptr literal notations and types

lib/hcl.h

@@ -236,6 +236,7 @@ typedef struct hcl_obj_word_t*     hcl_oop_word_t;
 #endif
 
 
+#if 0
 /* 
  * OOP encoding
  * An object pointer(OOP) is an ordinary pointer value to an object.
@@ -266,12 +267,74 @@ typedef struct hcl_obj_word_t*     hcl_oop_word_t;
 #define HCL_CHAR_TO_OOP(num) ((hcl_oop_t)((((hcl_oow_t)(num)) << HCL_OOP_TAG_BITS) | HCL_OOP_TAG_CHAR))
 #define HCL_OOP_TO_CHAR(oop) (((hcl_oow_t)oop) >> HCL_OOP_TAG_BITS)
 
+#else
+/* 
+ * OOP encoding
+ * An object pointer(OOP) is an ordinary pointer value to an object.
+ * but some simple numeric values are also encoded into OOP using a simple
+ * bit-shifting and masking.
+ *
+ * A real OOP is stored without any bit-shifting while a non-pointer value encoded
+ * in an OOP is bit-shifted to the left by 2 and the 2 least-significant bits
+ * are set to 1 or 2.
+ * 
+ * This scheme works because the object allocators aligns the object size to
+ * a multiple of sizeof(moo_oop_t). This way, the 2 least-significant bits
+ * of a real OOP are always 0s.
+ *
+ * With 2 bits, i can encode only 3 special types except object pointers. 
+ * Since I need more than 3 special types, I extend the tag bits up to 4 bits
+ * to represent a special data type that doesn't require a range as wide
+ * as a small integer. A unicode character, for instance, only requires 21 
+ * bits at most. An error doesn't need to be as diverse as a small integer.
+ */
+
+#define HCL_OOP_TAG_BITS_LO     2
+#define HCL_OOP_TAG_BITS_HI     2
+
+#define HCL_OOP_TAG_SMOOI       1    /* 01 */
+#define HCL_OOP_TAG_SMPTR       2    /* 10 */
+#define HCL_OOP_TAG_EXTENDED    3    /* 11 - internal use only */
+#define HCL_OOP_TAG_CHAR        3    /* 0011 */
+#define HCL_OOP_TAG_ERROR       7    /* 0111 */
+#define HCL_OOP_TAG_RESERVED0   11   /* 1011 */
+#define HCL_OOP_TAG_RESERVED1   15   /* 1111 */
+
+#define HCL_OOP_GET_TAG_LO(oop) (((hcl_oow_t)oop) & HCL_LBMASK(hcl_oow_t, HCL_OOP_TAG_BITS_LO))
+#define HCL_OOP_GET_TAG_LOHI(oop) (((hcl_oow_t)oop) & HCL_LBMASK(hcl_oow_t, HCL_OOP_TAG_BITS_LO + HCL_OOP_TAG_BITS_HI))
+#define HCL_OOP_GET_TAG(oop) (HCL_OOP_GET_TAG_LO(oop) == HCL_OOP_TAG_EXTENDED? HCL_OOP_GET_TAG_LOHI(oop): HCL_OOP_GET_TAG_LO(oop))
+
+#define HCL_OOP_IS_NUMERIC(oop) (HCL_OOP_GET_TAG_LO(oop) != 0)
+#define HCL_OOP_IS_POINTER(oop) (HCL_OOP_GET_TAG_LO(oop) == 0)
+
+#define HCL_OOP_IS_SMOOI(oop) (HCL_OOP_GET_TAG_LO(oop) == HCL_OOP_TAG_SMOOI)
+#define HCL_OOP_IS_SMPTR(oop) (HCL_OOP_GET_TAG_LO(oop) == HCL_OOP_TAG_SMPTR)
+
+#define HCL_SMOOI_TO_OOP(num) ((hcl_oop_t)((((hcl_ooi_t)(num)) << HCL_OOP_TAG_BITS_LO) | HCL_OOP_TAG_SMOOI))
+#define HCL_OOP_TO_SMOOI(oop) (((hcl_ooi_t)oop) >> HCL_OOP_TAG_BITS_LO)
+/*
+#define HCL_SMPTR_TO_OOP(num) ((hcl_oop_t)((((hcl_ooi_t)(num)) << HCL_OOP_TAG_BITS_LO) | HCL_OOP_TAG_SMPTR))
+#define HCL_OOP_TO_SMPTR(oop) (((hcl_ooi_t)oop) >> HCL_OOP_TAG_BITS_LO)
+*/
+#define HCL_SMPTR_TO_OOP(ptr) ((hcl_oop_t)(((hcl_oow_t)ptr) | HCL_OOP_TAG_SMPTR))
+#define HCL_OOP_TO_SMPTR(oop) ((void*)(((hcl_oow_t)oop) & ~HCL_LBMASK(hcl_oow_t, HCL_OOP_TAG_BITS_LO)))
+
+#define HCL_OOP_IS_CHAR(oop) (HCL_OOP_GET_TAG(oop) == HCL_OOP_TAG_CHAR)
+#define HCL_OOP_IS_ERROR(oop) (HCL_OOP_GET_TAG(oop) == HCL_OOP_TAG_ERROR)
+
+#define HCL_OOP_TO_CHAR(oop) (((hcl_oow_t)oop) >> (HCL_OOP_TAG_BITS_LO + HCL_OOP_TAG_BITS_LO))
+#define HCL_CHAR_TO_OOP(num) ((hcl_oop_t)((((hcl_oow_t)(num)) << (HCL_OOP_TAG_BITS_LO + HCL_OOP_TAG_BITS_LO)) | HCL_OOP_TAG_CHAR))
+#define HCL_OOP_TO_ERROR(oop) (((hcl_oow_t)oop) >> (HCL_OOP_TAG_BITS_LO + HCL_OOP_TAG_BITS_LO))
+#define HCL_ERROR_TO_OOP(num) ((hcl_oop_t)((((hcl_oow_t)(num)) << (HCL_OOP_TAG_BITS_LO + HCL_OOP_TAG_BITS_LO)) | HCL_OOP_TAG_ERROR))
+
+#endif
+
 /* SMOOI takes up 62 bit on a 64-bit architecture and 30 bits 
  * on a 32-bit architecture. The absolute value takes up 61 bits and 29 bits
  * respectively for the 1 sign bit. */
-#define HCL_SMOOI_BITS (HCL_OOI_BITS - HCL_OOP_TAG_BITS)
+#define HCL_SMOOI_BITS (HCL_OOI_BITS - HCL_OOP_TAG_BITS_LO)
 #define HCL_SMOOI_ABS_BITS (HCL_SMOOI_BITS - 1)
-#define HCL_SMOOI_MAX ((hcl_ooi_t)(~((hcl_oow_t)0) >> (HCL_OOP_TAG_BITS + 1)))
+#define HCL_SMOOI_MAX ((hcl_ooi_t)(~((hcl_oow_t)0) >> (HCL_OOP_TAG_BITS_LO + 1)))
 /* Sacrificing 1 bit pattern for a negative SMOOI makes 
  * implementation a lot eaisier in many respect. */
 /*#define HCL_SMOOI_MIN (-HCL_SMOOI_MAX - 1)*/