add bool value to speed up primitives

src/arobject.h

@@ -72,6 +72,7 @@ struct ArgonObject {
   ArgonType type;
   ArgonType child_type;
   struct hashmap_GC *dict;
+  bool as_bool;
   union {
     mpq_t *as_number;
     struct string_struct as_str;

src/runtime/objects/number/number.c

@@ -398,6 +398,7 @@ ArgonObject *new_number_object(mpq_t number) {
   add_field(object, "__class__", ARGON_NUMBER_TYPE);
   object->type = TYPE_NUMBER;
   object->value.as_number = mpq_new_gc_from(number);
+  object->as_bool = mpq_cmp_si(number, 0, 1) != 0;
   return object;
 }
 
@@ -409,6 +410,7 @@ ArgonObject *new_number_object_from_long(long n, unsigned long d) {
   mpq_set_si(r, n, d);
   object->type = TYPE_NUMBER;
   object->value.as_number = mpq_new_gc_from(r);
+  object->as_bool = n!=0;
   mpq_clear(r);
   return object;
 }
@@ -421,6 +423,7 @@ ArgonObject *new_number_object_from_double(double d) {
   mpq_set_d(r, d);
   object->type = TYPE_NUMBER;
   object->value.as_number = mpq_new_gc_from(r);
+  object->as_bool = d!=0;
   mpq_clear(r);
   return object;
 }

src/runtime/objects/object.c

@@ -21,6 +21,7 @@ ArgonObject *new_object() {
   object->dict = createHashmap_GC();
   add_field(object, "__class__", ARGON_TYPE_TYPE);
   add_field(object, "__base__", BASE_CLASS);
+  object->as_bool = true;
   return object;
 }
 

src/runtime/objects/string/string.c

@@ -22,6 +22,7 @@ ArgonObject *new_string_object(char*data, size_t length) {
   object->value.as_str.data = ar_alloc_atomic(length);
   memcpy(object->value.as_str.data, data, length);
   object->value.as_str.length = length;
+  object->as_bool = length;
   return object;
 }
 

src/runtime/runtime.c

@@ -474,6 +474,7 @@ void bootstrap_types() {
   add_field(ARGON_NULL_TYPE, "__base__", BASE_CLASS);
   ARGON_NULL = new_object();
   add_field(ARGON_NULL, "__class__", ARGON_NULL_TYPE);
+  ARGON_NULL->as_bool = false;
 
   add_field(BASE_CLASS, "__base__", NULL);
   add_field(BASE_CLASS, "__class__", ARGON_TYPE_TYPE);
@@ -484,6 +485,7 @@ void bootstrap_types() {
   add_field(ARGON_TRUE, "__class__", ARGON_BOOL_TYPE);
   ARGON_FALSE = new_object();
   add_field(ARGON_FALSE, "__class__", ARGON_BOOL_TYPE);
+  ARGON_NULL->as_bool = false;
 
   ARGON_STRING_TYPE = new_object();
   add_field(ARGON_STRING_TYPE, "__base__", BASE_CLASS);
@@ -676,7 +678,7 @@ static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
       [OP_LOAD_MULTIPLY_FUNCTION] = &&DO_LOAD_MULTIPLY_FUNCTION,
       [OP_LOAD_DIVISION_FUNCTION] = &&DO_LOAD_DIVISION_FUNCTION,
       [OP_ASSIGN] = &&DO_ASSIGN};
-goto *dispatch_table[pop_byte(translated, state)];
+  goto *dispatch_table[pop_byte(translated, state)];
 DO_LOAD_NULL:
   state->registers[pop_byte(translated, state)] = ARGON_NULL;
   goto BREAK;
@@ -695,19 +697,26 @@ DO_DECLARE:
   return runtime_declaration(translated, state, *stack);
 DO_ASSIGN:
   return runtime_assignment(translated, state, *stack);
-DO_BOOL:;
+DO_BOOL: {
-  ArErr err = no_err;
   uint8_t to_register = pop_byte(translated, state);
+  if (state->registers[0]->type != TYPE_OBJECT) {
+    state->registers[to_register] =
+        state->registers[0]->as_bool ? ARGON_TRUE : ARGON_FALSE;
+    goto BREAK;
+  }
+  ArErr err = no_err;
   ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
   state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, &err, state);
   return err;
-DO_JUMP_IF_FALSE:;
+}
+DO_JUMP_IF_FALSE: {
   uint8_t from_register = pop_byte(translated, state);
   uint64_t to = pop_bytecode(translated, state);
   if (state->registers[from_register] == ARGON_FALSE) {
     state->head = to;
   }
   goto BREAK;
+}
 DO_JUMP:
   state->head = pop_bytecode(translated, state);
   goto BREAK;
@@ -738,7 +747,7 @@ DO_POP_SCOPE:;
   // free(array);
   *stack = (*stack)->prev;
   goto BREAK;
-DO_INIT_CALL:;
+DO_INIT_CALL: {
   size_t length = pop_bytecode(translated, state);
   call_instance call_instance = {state->call_instance, state->registers[0],
                                  ar_alloc(length * sizeof(ArgonObject *)),
@@ -746,12 +755,13 @@ DO_INIT_CALL:;
   state->call_instance = ar_alloc(sizeof(call_instance));
   *state->call_instance = call_instance;
   goto BREAK;
+}
 DO_INSERT_ARG:;
   size_t index = pop_bytecode(translated, state);
   (state->call_instance->args)[index] = state->registers[0];
   goto BREAK;
-DO_CALL:;
+DO_CALL: {
-  err =
+  ArErr err =
       run_call(state->call_instance->to_call, state->call_instance->args_length,
                state->call_instance->args, state, false);
   state->call_instance = (*state->call_instance).previous;
@@ -775,6 +785,7 @@ DO_CALL:;
   //   (int)class_name->value.as_str.length, class_name->value.as_str.data,
   //   object);
   // }
+}
 DO_SOURCE_LOCATION:
   state->source_location = (SourceLocation){pop_bytecode(translated, state),
                                             pop_bytecode(translated, state),