Use one tag type true and false

We moved the literals true and false into one tag
type, so we an extra tag for raw pointer types
(light userdata). These can be used from the C API via
janet_wrap_pointer and janet_unwrap_pointer.

Makefile

@@ -177,13 +177,13 @@ valgrind: $(JANET_TARGET)
 	$(VALGRIND_COMMAND) ./$(JANET_TARGET)
 
 test: $(JANET_TARGET) $(TEST_PROGRAMS)
-	for f in test/*.janet; do ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do ./$(JANET_TARGET) "$$f" || exit; done
 
 valtest: $(JANET_TARGET) $(TEST_PROGRAMS)
-	for f in test/*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do $(VALGRIND_COMMAND) ./$(JANET_TARGET) "$$f" || exit; done
 
 callgrind: $(JANET_TARGET)
-	for f in test/*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
+	for f in test/suite*.janet; do valgrind --tool=callgrind ./$(JANET_TARGET) "$$f" || exit; done
 
 ########################
 ##### Distribution #####

src/core/asm.c

@@ -147,19 +147,18 @@ static const TypeAlias type_aliases[] = {
     {"callable", JANET_TFLAG_CALLABLE},
     {"cfunction", JANET_TFLAG_CFUNCTION},
     {"dictionary", JANET_TFLAG_DICTIONARY},
-    {"false", JANET_TFLAG_FALSE},
     {"fiber", JANET_TFLAG_FIBER},
     {"function", JANET_TFLAG_FUNCTION},
     {"indexed", JANET_TFLAG_INDEXED},
+    {"keyword", JANET_TFLAG_KEYWORD},
     {"nil", JANET_TFLAG_NIL},
     {"number", JANET_TFLAG_NUMBER},
+    {"pointer", JANET_TFLAG_POINTER},
     {"string", JANET_TFLAG_STRING},
     {"struct", JANET_TFLAG_STRUCT},
     {"symbol", JANET_TFLAG_SYMBOL},
-    {"keyword", JANET_TFLAG_KEYWORD},
+    {"table", JANET_TFLAG_TABLE},
-    {"table", JANET_TFLAG_BOOLEAN},
+    {"tuple", JANET_TFLAG_TUPLE}
-    {"true", JANET_TFLAG_TRUE},
-    {"tuple", JANET_TFLAG_BOOLEAN}
 };
 
 /* Deinitialize an Assembler. Does not deinitialize the parents. */

src/core/capi.c

@@ -95,16 +95,7 @@ DEFINE_GETTER(buffer, BUFFER, JanetBuffer *)
 DEFINE_GETTER(fiber, FIBER, JanetFiber *)
 DEFINE_GETTER(function, FUNCTION, JanetFunction *)
 DEFINE_GETTER(cfunction, CFUNCTION, JanetCFunction)
-
+DEFINE_GETTER(boolean, BOOLEAN, int)
-int janet_getboolean(const Janet *argv, int32_t n) {
-    Janet x = argv[n];
-    if (janet_checktype(x, JANET_TRUE)) {
-        return 1;
-    } else if (!janet_checktype(x, JANET_FALSE)) {
-        janet_panicf("bad slot #%d, expected boolean, got %v", n, x);
-    }
-    return 0;
-}
 
 int32_t janet_getinteger(const Janet *argv, int32_t n) {
     Janet x = argv[n];

src/core/emit.c

@@ -78,11 +78,9 @@ static void janetc_loadconst(JanetCompiler *c, Janet k, int32_t reg) {
         case JANET_NIL:
             janetc_emit(c, (reg << 8) | JOP_LOAD_NIL);
             break;
-        case JANET_TRUE:
+        case JANET_BOOLEAN:
-            janetc_emit(c, (reg << 8) | JOP_LOAD_TRUE);
+            janetc_emit(c, (reg << 8) |
-            break;
+                        (janet_unwrap_boolean(k) ? JOP_LOAD_TRUE : JOP_LOAD_FALSE));
-        case JANET_FALSE:
-            janetc_emit(c, (reg << 8) | JOP_LOAD_FALSE);
             break;
         case JANET_NUMBER: {
             double dval = janet_unwrap_number(k);

src/core/gc.c

@@ -376,8 +376,7 @@ static int janet_gc_idequals(Janet lhs, Janet rhs) {
     if (janet_type(lhs) != janet_type(rhs))
         return 0;
     switch (janet_type(lhs)) {
-        case JANET_TRUE:
+        case JANET_BOOLEAN:
-        case JANET_FALSE:
         case JANET_NIL:
         case JANET_NUMBER:
             /* These values don't really matter to the gc so returning 1 all the time is fine. */

src/core/marsh.c

@@ -341,9 +341,10 @@ static void marshal_one(MarshalState *st, Janet x, int flags) {
         default:
             break;
         case JANET_NIL:
-        case JANET_FALSE:
+            pushbyte(st, LB_NIL);
-        case JANET_TRUE:
+            return;
-            pushbyte(st, 200 + type);
+        case JANET_BOOLEAN:
+            pushbyte(st, janet_unwrap_boolean(x) ? LB_TRUE : LB_FALSE);
             return;
         case JANET_NUMBER: {
             double xval = janet_unwrap_number(x);

src/core/pp.c

@@ -179,11 +179,9 @@ void janet_description_b(JanetBuffer *buffer, Janet x) {
         case JANET_NIL:
             janet_buffer_push_cstring(buffer, "nil");
             return;
-        case JANET_TRUE:
+        case JANET_BOOLEAN:
-            janet_buffer_push_cstring(buffer, "true");
+            janet_buffer_push_cstring(buffer,
-            return;
+                                      janet_unwrap_boolean(x) ? "true" : "false");
-        case JANET_FALSE:
-            janet_buffer_push_cstring(buffer, "false");
             return;
         case JANET_NUMBER:
             number_to_string_b(buffer, janet_unwrap_number(x));
@@ -315,8 +313,7 @@ static void janet_pretty_one(struct pretty *S, Janet x, int is_dict_value) {
         case JANET_NIL:
         case JANET_NUMBER:
         case JANET_SYMBOL:
-        case JANET_TRUE:
+        case JANET_BOOLEAN:
-        case JANET_FALSE:
             break;
         default: {
             Janet seenid = janet_table_get(&S->seen, x);

src/core/table.c

@@ -144,7 +144,7 @@ void janet_table_put(JanetTable *t, Janet key, Janet value) {
                 janet_table_rehash(t, janet_tablen(2 * t->count + 2));
             }
             bucket = janet_table_find(t, key);
-            if (janet_checktype(bucket->value, JANET_FALSE))
+            if (janet_checktype(bucket->value, JANET_BOOLEAN))
                 --t->deleted;
             bucket->key = key;
             bucket->value = value;

src/core/util.c

@@ -42,7 +42,6 @@ const char *const janet_type_names[16] = {
     "number",
     "nil",
     "boolean",
-    "boolean",
     "fiber",
     "string",
     "symbol",
@@ -54,7 +53,8 @@ const char *const janet_type_names[16] = {
     "buffer",
     "function",
     "cfunction",
-    "abstract"
+    "abstract",
+    "pointer"
 };
 
 const char *const janet_signal_names[14] = {

src/core/value.c

@@ -36,10 +36,11 @@ int janet_equals(Janet x, Janet y) {
     } else {
         switch (janet_type(x)) {
             case JANET_NIL:
-            case JANET_TRUE:
-            case JANET_FALSE:
                 result = 1;
                 break;
+            case JANET_BOOLEAN:
+                result = (janet_unwrap_boolean(x) == janet_unwrap_boolean(y));
+                break;
             case JANET_NUMBER:
                 result = (janet_unwrap_number(x) == janet_unwrap_number(y));
                 break;
@@ -68,11 +69,8 @@ int32_t janet_hash(Janet x) {
         case JANET_NIL:
             hash = 0;
             break;
-        case JANET_FALSE:
+        case JANET_BOOLEAN:
-            hash = 1;
+            hash = janet_unwrap_boolean(x);
-            break;
-        case JANET_TRUE:
-            hash = 2;
             break;
         case JANET_STRING:
         case JANET_SYMBOL:
@@ -111,9 +109,9 @@ int janet_compare(Janet x, Janet y) {
     if (janet_type(x) == janet_type(y)) {
         switch (janet_type(x)) {
             case JANET_NIL:
-            case JANET_FALSE:
-            case JANET_TRUE:
                 return 0;
+            case JANET_BOOLEAN:
+                return janet_unwrap_boolean(x) - janet_unwrap_boolean(y);
             case JANET_NUMBER:
                 /* Check for NaNs to ensure total order */
                 if (janet_unwrap_number(x) != janet_unwrap_number(x))

src/core/wrap.c

@@ -125,22 +125,22 @@ Janet janet_wrap_nil() {
 
 Janet janet_wrap_true(void) {
     Janet y;
-    y.type = JANET_TRUE;
+    y.type = JANET_BOOLEAN;
-    y.as.u64 = 0;
+    y.as.u64 = 1;
     return y;
 }
 
 Janet janet_wrap_false(void) {
     Janet y;
-    y.type = JANET_FALSE;
+    y.type = JANET_BOOLEAN;
     y.as.u64 = 0;
     return y;
 }
 
 Janet janet_wrap_boolean(int x) {
     Janet y;
-    y.type = x ? JANET_TRUE : JANET_FALSE;
+    y.type = JANET_BOOLEAN;
-    y.as.u64 = 0;
+    y.as.u64 = !!x;
     return y;
 }
 
@@ -166,6 +166,7 @@ JANET_WRAP_DEFINE(function, JanetFunction *, JANET_FUNCTION, pointer)
 JANET_WRAP_DEFINE(cfunction, JanetCFunction, JANET_CFUNCTION, pointer)
 JANET_WRAP_DEFINE(table, JanetTable *, JANET_TABLE, pointer)
 JANET_WRAP_DEFINE(abstract, void *, JANET_ABSTRACT, pointer)
+JANET_WRAP_DEFINE(pointer, void *, JANET_POINTER, pointer)
 
 #undef JANET_WRAP_DEFINE
 

src/include/janet.h

@@ -299,8 +299,7 @@ typedef Janet(*JanetCFunction)(int32_t argc, Janet *argv);
 typedef enum JanetType {
     JANET_NUMBER,
     JANET_NIL,
-    JANET_FALSE,
+    JANET_BOOLEAN,
-    JANET_TRUE,
     JANET_FIBER,
     JANET_STRING,
     JANET_SYMBOL,
@@ -312,15 +311,15 @@ typedef enum JanetType {
     JANET_BUFFER,
     JANET_FUNCTION,
     JANET_CFUNCTION,
-    JANET_ABSTRACT
+    JANET_ABSTRACT,
+    JANET_POINTER
 } JanetType;
 
-#define JANET_COUNT_TYPES (JANET_ABSTRACT + 1)
+#define JANET_COUNT_TYPES (JANET_POINTER + 1)
 
 /* Type flags */
 #define JANET_TFLAG_NIL (1 << JANET_NIL)
-#define JANET_TFLAG_FALSE (1 << JANET_FALSE)
+#define JANET_TFLAG_BOOLEAN (1 << JANET_BOOLEAN)
-#define JANET_TFLAG_TRUE (1 << JANET_TRUE)
 #define JANET_TFLAG_FIBER (1 << JANET_FIBER)
 #define JANET_TFLAG_NUMBER (1 << JANET_NUMBER)
 #define JANET_TFLAG_STRING (1 << JANET_STRING)
@@ -334,9 +333,9 @@ typedef enum JanetType {
 #define JANET_TFLAG_FUNCTION (1 << JANET_FUNCTION)
 #define JANET_TFLAG_CFUNCTION (1 << JANET_CFUNCTION)
 #define JANET_TFLAG_ABSTRACT (1 << JANET_ABSTRACT)
+#define JANET_TFLAG_POINTER (1 << JANET_POINTER)
 
 /* Some abstractions */
-#define JANET_TFLAG_BOOLEAN (JANET_TFLAG_TRUE | JANET_TFLAG_FALSE)
 #define JANET_TFLAG_BYTES (JANET_TFLAG_STRING | JANET_TFLAG_SYMBOL | JANET_TFLAG_BUFFER | JANET_TFLAG_KEYWORD)
 #define JANET_TFLAG_INDEXED (JANET_TFLAG_ARRAY | JANET_TFLAG_TUPLE)
 #define JANET_TFLAG_DICTIONARY (JANET_TFLAG_TABLE | JANET_TFLAG_STRUCT)
@@ -403,7 +402,8 @@ JANET_API Janet janet_nanbox_from_double(double d);
 JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 
 #define janet_truthy(x) \
-    (!(janet_checktype((x), JANET_NIL) || janet_checktype((x), JANET_FALSE)))
+    (!janet_checktype((x), JANET_NIL) && \
+     (!janet_checktype((x), JANET_BOOLEAN) || ((x).u64 & 0x1)))
 
 #define janet_nanbox_from_payload(t, p) \
     janet_nanbox_from_bits(janet_nanbox_tag(t) | (p))
@@ -416,14 +416,13 @@ JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 
 /* Wrap the simple types */
 #define janet_wrap_nil() janet_nanbox_from_payload(JANET_NIL, 1)
-#define janet_wrap_true() janet_nanbox_from_payload(JANET_TRUE, 1)
+#define janet_wrap_true() janet_nanbox_from_payload(JANET_BOOLEAN, 1)
-#define janet_wrap_false() janet_nanbox_from_payload(JANET_FALSE, 1)
+#define janet_wrap_false() janet_nanbox_from_payload(JANET_BOOLEAN, 0)
-#define janet_wrap_boolean(b) janet_nanbox_from_payload((b) ? JANET_TRUE : JANET_FALSE, 1)
+#define janet_wrap_boolean(b) janet_nanbox_from_payload(JANET_BOOLEAN, !!(b))
 #define janet_wrap_number(r) janet_nanbox_from_double(r)
 
 /* Unwrap the simple types */
-#define janet_unwrap_boolean(x) \
+#define janet_unwrap_boolean(x) ((x).u64 & 0x1)
-    (janet_checktype(x, JANET_TRUE))
 #define janet_unwrap_number(x) ((x).number)
 
 /* Wrap the pointer types */
@@ -439,6 +438,7 @@ JANET_API Janet janet_nanbox_from_bits(uint64_t bits);
 #define janet_wrap_abstract(s) janet_nanbox_wrap_((s), JANET_ABSTRACT)
 #define janet_wrap_function(s) janet_nanbox_wrap_((s), JANET_FUNCTION)
 #define janet_wrap_cfunction(s) janet_nanbox_wrap_((s), JANET_CFUNCTION)
+#define janet_wrap_pointer(s) janet_nanbox_wrap_((s), JANET_POINTER)
 
 /* Unwrap the pointer types */
 #define janet_unwrap_struct(x) ((const JanetKV *)janet_nanbox_to_pointer(x))
@@ -485,16 +485,17 @@ union Janet {
 #define janet_checktype(x, t) ((t) == JANET_NUMBER \
         ? (x).tagged.type >= JANET_DOUBLE_OFFSET \
         : (x).tagged.type == (t))
-#define janet_truthy(x) ((x).tagged.type != JANET_NIL && (x).tagged.type != JANET_FALSE)
+#define janet_truthy(x) \
+    ((x).tagged.type != JANET_NIL && ((x).tagged.type != JANET_BOOLEAN || ((x).tagged.payload.integer & 0x1)))
 
 JANET_API Janet janet_wrap_number(double x);
 JANET_API Janet janet_nanbox32_from_tagi(uint32_t tag, int32_t integer);
 JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 
 #define janet_wrap_nil() janet_nanbox32_from_tagi(JANET_NIL, 0)
-#define janet_wrap_true() janet_nanbox32_from_tagi(JANET_TRUE, 0)
+#define janet_wrap_true() janet_nanbox32_from_tagi(JANET_BOOLEAN, 1)
-#define janet_wrap_false() janet_nanbox32_from_tagi(JANET_FALSE, 0)
+#define janet_wrap_false() janet_nanbox32_from_tagi(JANET_BOOLEAN, 0)
-#define janet_wrap_boolean(b) janet_nanbox32_from_tagi((b) ? JANET_TRUE : JANET_FALSE, 0)
+#define janet_wrap_boolean(b) janet_nanbox32_from_tagi(JANET_BOOLEAN, !!(b))
 
 /* Wrap the pointer types */
 #define janet_wrap_struct(s) janet_nanbox32_from_tagp(JANET_STRUCT, (void *)(s))
@@ -509,6 +510,7 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_wrap_abstract(s) janet_nanbox32_from_tagp(JANET_ABSTRACT, (void *)(s))
 #define janet_wrap_function(s) janet_nanbox32_from_tagp(JANET_FUNCTION, (void *)(s))
 #define janet_wrap_cfunction(s) janet_nanbox32_from_tagp(JANET_CFUNCTION, (void *)(s))
+#define janet_wrap_pointer(s) janet_nanbox32_from_tagp(JANET_POINTER, (void *)(s))
 
 #define janet_unwrap_struct(x) ((const JanetKV *)(x).tagged.payload.pointer)
 #define janet_unwrap_tuple(x) ((const Janet *)(x).tagged.payload.pointer)
@@ -523,7 +525,7 @@ JANET_API Janet janet_nanbox32_from_tagp(uint32_t tag, void *pointer);
 #define janet_unwrap_pointer(x) ((x).tagged.payload.pointer)
 #define janet_unwrap_function(x) ((JanetFunction *)(x).tagged.payload.pointer)
 #define janet_unwrap_cfunction(x) ((JanetCFunction)(x).tagged.payload.pointer)
-#define janet_unwrap_boolean(x) ((x).tagged.type == JANET_TRUE)
+#define janet_unwrap_boolean(x) ((x).tagged.payload.integer)
 JANET_API double janet_unwrap_number(Janet x);
 
 #else
@@ -544,7 +546,7 @@ struct Janet {
 #define janet_type(x) ((x).type)
 #define janet_checktype(x, t) ((x).type == (t))
 #define janet_truthy(x) \
-    ((x).type != JANET_NIL && (x).type != JANET_FALSE)
+    ((x).type != JANET_NIL && ((x).type != JANET_BOOLEAN || ((x).as.integer & 0x1)))
 
 #define janet_unwrap_struct(x) ((const JanetKV *)(x).as.pointer)
 #define janet_unwrap_tuple(x) ((const Janet *)(x).as.pointer)
@@ -559,7 +561,7 @@ struct Janet {
 #define janet_unwrap_pointer(x) ((x).as.pointer)
 #define janet_unwrap_function(x) ((JanetFunction *)(x).as.pointer)
 #define janet_unwrap_cfunction(x) ((JanetCFunction)(x).as.pointer)
-#define janet_unwrap_boolean(x) ((x).type == JANET_TRUE)
+#define janet_unwrap_boolean(x) ((x).as.u64 & 0x1)
 #define janet_unwrap_number(x) ((x).as.number)
 
 JANET_API Janet janet_wrap_nil(void);
@@ -579,6 +581,7 @@ JANET_API Janet janet_wrap_function(JanetFunction *x);
 JANET_API Janet janet_wrap_cfunction(JanetCFunction x);
 JANET_API Janet janet_wrap_table(JanetTable *x);
 JANET_API Janet janet_wrap_abstract(void *x);
+JANET_API Janet janet_wrap_pointer(void *x);
 
 /* End of tagged union implementation */
 #endif