support bool type

package/PikaStdLib/PikaStdData_String.c

@@ -2,6 +2,7 @@
 #include "PikaStdData_List.h"
 #include "PikaStdData_String_Util.h"
 #include "dataStrs.h"
+#include "PikaVM.h"
 
 char* _strlwr(char* str);
 static int string_len(char* str);
@@ -87,7 +88,7 @@ char* string_slice(Args* outBuffs, char* str, int start, int end) {
         start += string_len(str);
     }
     /* magic code, to the end */
-    if (end == -99999) {
+    if (end == VM_PC_EXIT) {
         end = string_len(str);
     }
     if (end < 0) {

package/PikaStdLib/PikaStdLib.pyi

@@ -20,7 +20,7 @@ class SysObj:
     def int(arg: any) -> int: ...
 
     @staticmethod
-    def bool(arg: any) -> int: ...
+    def bool(arg: any) -> bool: ...
 
     @staticmethod
     def float(arg: any) -> float: ...

package/PikaStdLib/PikaStdLib_SysObj.c

@@ -36,6 +36,9 @@ Arg* PikaStdLib_SysObj_type(PikaObj* self, Arg* arg) {
     if (ARG_TYPE_STRING == type) {
         return arg_copy(obj_getMethodArg(self, "str"));
     }
+    if (ARG_TYPE_BOOL == type) {
+        return arg_copy(obj_getMethodArg(self, "bool"));
+    }
     if (argType_isObject(type)) {
         PikaObj* obj = arg_getPtr(arg);
         NewFun clsptr = obj_getClass(obj);
@@ -88,39 +91,62 @@ pika_float PikaStdLib_SysObj_float(PikaObj* self, Arg* arg) {
     if (ARG_TYPE_STRING == type) {
         return strtod(arg_getStr(arg), NULL);
     }
+    if (ARG_TYPE_BOOL == type) {
+        return (float)arg_getBool(arg);
+    }
     obj_setSysOut(self, "[error] convert to pika_float type failed.");
     obj_setErrorCode(self, 1);
-    return -99999.99999;
+    return _PIKA_FLOAT_ERR;
 }
 
-int PikaStdLib_SysObj_int(PikaObj* self, Arg* arg) {
+PIKA_RES _transeInt(Arg* arg, int* res) {
     ArgType type = arg_getType(arg);
     if (ARG_TYPE_INT == type) {
-        return (int)arg_getInt(arg);
+        *res = (int)arg_getInt(arg);
+        return PIKA_RES_OK;
+    }
+    if (ARG_TYPE_BOOL == type) {
+        *res = (int)arg_getBool(arg);
+        return PIKA_RES_OK;
     }
     if (ARG_TYPE_FLOAT == type) {
-        return (int)arg_getFloat(arg);
+        *res = (int)arg_getFloat(arg);
+        return PIKA_RES_OK;
     }
     if (ARG_TYPE_STRING == type) {
-        return (int)fast_atoi(arg_getStr(arg));
+        *res = (int)fast_atoi(arg_getStr(arg));
+        return PIKA_RES_OK;
     }
     if (ARG_TYPE_BYTES == type) {
         size_t size = arg_getBytesSize(arg);
         if (size != 1) {
-            obj_setSysOut(self, "ValueError: invalid literal for int()");
-            obj_setErrorCode(self, 1);
-            return -999999999;
+            return PIKA_RES_ERR_INVALID_PARAM;
         }
         uint8_t val = *arg_getBytes(arg);
-        return val;
+        *res = val;
+        return PIKA_RES_OK;
     }
-    obj_setSysOut(self, "[error] convert to int type failed.");
+    return PIKA_RES_ERR_INVALID_PARAM;
+}
+
+int PikaStdLib_SysObj_int(PikaObj* self, Arg* arg) {
+    int res = 0;
+    if (_transeInt(arg, &res) == PIKA_RES_OK) {
+        return res;
+    }
+    obj_setSysOut(self, "ValueError: invalid literal for int()");
     obj_setErrorCode(self, 1);
-    return -999999999;
+    return _PIKA_INT_ERR;
 }
 
-int PikaStdLib_SysObj_bool(PikaObj* self, Arg* arg) {
-    return PikaStdLib_SysObj_int(self, arg);
+PIKA_BOOL PikaStdLib_SysObj_bool(PikaObj* self, Arg* arg) {
+    int res = 0;
+    if (_transeInt(arg, &res) == PIKA_RES_OK) {
+        return res ? PIKA_TRUE : PIKA_FALSE;
+    }
+    obj_setSysOut(self, "ValueError: invalid literal for bool()");
+    obj_setErrorCode(self, 1);
+    return _PIKA_BOOL_ERR;
 }
 
 char* PikaStdLib_SysObj_str(PikaObj* self, Arg* arg) {

port/linux/.vscode/launch.json

@@ -11,7 +11,7 @@
             "program": "${workspaceFolder}/build/test/pikascript_test",
             // "program": "${workspaceFolder}/build/boot/demo06-pikamain/pikascript_demo06-pikamain",
             "args": [
-                "--gtest_filter=except.while_try_while"
+                // "--gtest_filter=except.while_try_while"
             ],
             "stopAtEntry": false,
             "cwd": "${workspaceFolder}",

port/linux/package/pikascript/PikaStdLib.pyi

@@ -20,7 +20,7 @@ class SysObj:
     def int(arg: any) -> int: ...
 
     @staticmethod
-    def bool(arg: any) -> int: ...
+    def bool(arg: any) -> bool: ...
 
     @staticmethod
     def float(arg: any) -> float: ...

port/linux/package/pikascript/pikascript-lib/PikaStdLib/PikaStdData_String.c

@@ -2,6 +2,7 @@
 #include "PikaStdData_List.h"
 #include "PikaStdData_String_Util.h"
 #include "dataStrs.h"
+#include "PikaVM.h"
 
 char* _strlwr(char* str);
 static int string_len(char* str);
@@ -87,7 +88,7 @@ char* string_slice(Args* outBuffs, char* str, int start, int end) {
         start += string_len(str);
     }
     /* magic code, to the end */
-    if (end == -99999) {
+    if (end == VM_PC_EXIT) {
         end = string_len(str);
     }
     if (end < 0) {

port/linux/package/pikascript/pikascript-lib/PikaStdLib/PikaStdLib_SysObj.c

@@ -36,6 +36,9 @@ Arg* PikaStdLib_SysObj_type(PikaObj* self, Arg* arg) {
     if (ARG_TYPE_STRING == type) {
         return arg_copy(obj_getMethodArg(self, "str"));
     }
+    if (ARG_TYPE_BOOL == type) {
+        return arg_copy(obj_getMethodArg(self, "bool"));
+    }
     if (argType_isObject(type)) {
         PikaObj* obj = arg_getPtr(arg);
         NewFun clsptr = obj_getClass(obj);
@@ -88,39 +91,62 @@ pika_float PikaStdLib_SysObj_float(PikaObj* self, Arg* arg) {
     if (ARG_TYPE_STRING == type) {
         return strtod(arg_getStr(arg), NULL);
     }
+    if (ARG_TYPE_BOOL == type) {
+        return (float)arg_getBool(arg);
+    }
     obj_setSysOut(self, "[error] convert to pika_float type failed.");
     obj_setErrorCode(self, 1);
-    return -99999.99999;
+    return _PIKA_FLOAT_ERR;
 }
 
-int PikaStdLib_SysObj_int(PikaObj* self, Arg* arg) {
+PIKA_RES _transeInt(Arg* arg, int* res) {
     ArgType type = arg_getType(arg);
     if (ARG_TYPE_INT == type) {
-        return (int)arg_getInt(arg);
+        *res = (int)arg_getInt(arg);
+        return PIKA_RES_OK;
+    }
+    if (ARG_TYPE_BOOL == type) {
+        *res = (int)arg_getBool(arg);
+        return PIKA_RES_OK;
     }
     if (ARG_TYPE_FLOAT == type) {
-        return (int)arg_getFloat(arg);
+        *res = (int)arg_getFloat(arg);
+        return PIKA_RES_OK;
     }
     if (ARG_TYPE_STRING == type) {
-        return (int)fast_atoi(arg_getStr(arg));
+        *res = (int)fast_atoi(arg_getStr(arg));
+        return PIKA_RES_OK;
     }
     if (ARG_TYPE_BYTES == type) {
         size_t size = arg_getBytesSize(arg);
         if (size != 1) {
-            obj_setSysOut(self, "ValueError: invalid literal for int()");
-            obj_setErrorCode(self, 1);
-            return -999999999;
+            return PIKA_RES_ERR_INVALID_PARAM;
         }
         uint8_t val = *arg_getBytes(arg);
-        return val;
+        *res = val;
+        return PIKA_RES_OK;
     }
-    obj_setSysOut(self, "[error] convert to int type failed.");
+    return PIKA_RES_ERR_INVALID_PARAM;
+}
+
+int PikaStdLib_SysObj_int(PikaObj* self, Arg* arg) {
+    int res = 0;
+    if (_transeInt(arg, &res) == PIKA_RES_OK) {
+        return res;
+    }
+    obj_setSysOut(self, "ValueError: invalid literal for int()");
     obj_setErrorCode(self, 1);
-    return -999999999;
+    return _PIKA_INT_ERR;
 }
 
-int PikaStdLib_SysObj_bool(PikaObj* self, Arg* arg) {
-    return PikaStdLib_SysObj_int(self, arg);
+PIKA_BOOL PikaStdLib_SysObj_bool(PikaObj* self, Arg* arg) {
+    int res = 0;
+    if (_transeInt(arg, &res) == PIKA_RES_OK) {
+        return res ? PIKA_TRUE : PIKA_FALSE;
+    }
+    obj_setSysOut(self, "ValueError: invalid literal for bool()");
+    obj_setErrorCode(self, 1);
+    return _PIKA_BOOL_ERR;
 }
 
 char* PikaStdLib_SysObj_str(PikaObj* self, Arg* arg) {

src/PikaObj.c

@@ -230,13 +230,23 @@ PIKA_RES obj_setBytes(PikaObj* self, char* argPath, uint8_t* src, size_t size) {
 int64_t obj_getInt(PikaObj* self, char* argPath) {
     PikaObj* obj = obj_getHostObj(self, argPath);
     if (NULL == obj) {
-        return -999999999;
+        return _PIKA_INT_ERR;
     }
     char* argName = strPointToLastToken(argPath, '.');
     int64_t res = args_getInt(obj->list, argName);
     return res;
 }
 
+PIKA_BOOL obj_getBool(PikaObj* self, char* argPath) {
+    PikaObj* obj = obj_getHostObj(self, argPath);
+    if (NULL == obj) {
+        return PIKA_FALSE;
+    }
+    char* argName = strPointToLastToken(argPath, '.');
+    PIKA_BOOL res = args_getBool(obj->list, argName);
+    return res;
+}
+
 Arg* obj_getArg(PikaObj* self, char* argPath) {
     PIKA_BOOL is_temp = PIKA_FALSE;
     PikaObj* obj = obj_getHostObjWithIsTemp(self, argPath, &is_temp);
@@ -1590,6 +1600,13 @@ void method_returnInt(Args* args, int64_t val) {
     args_pushArg_name(args, "@rt", arg_newInt(val));
 }
 
+void method_returnBool(Args* args, PIKA_BOOL val) {
+    if (val == _PIKA_BOOL_ERR) {
+        return;
+    }
+    args_pushArg_name(args, "@rt", arg_newBool(val));
+}
+
 void method_returnFloat(Args* args, pika_float val) {
     args_pushArg_name(args, "@rt", arg_newFloat(val));
 }

src/PikaObj.h

@@ -175,6 +175,7 @@ void* obj_getPtr(PikaObj* self, char* argPath);
 pika_float obj_getFloat(PikaObj* self, char* argPath);
 char* obj_getStr(PikaObj* self, char* argPath);
 int64_t obj_getInt(PikaObj* self, char* argPath);
+PIKA_BOOL obj_getBool(PikaObj* self, char* argPath);
 Arg* obj_getArg(PikaObj* self, char* argPath);
 uint8_t* obj_getBytes(PikaObj* self, char* argPath);
 size_t obj_getBytesSize(PikaObj* self, char* argPath);
@@ -249,6 +250,7 @@ uint8_t obj_getAnyArg(PikaObj* self,
 
 void method_returnStr(Args* args, char* val);
 void method_returnInt(Args* args, int64_t val);
+void method_returnBool(Args* args, PIKA_BOOL val);
 void method_returnFloat(Args* args, pika_float val);
 void method_returnPtr(Args* args, void* val);
 void method_returnObj(Args* args, void* val);

src/PikaPlatform.h

@@ -110,8 +110,12 @@ typedef enum {
 typedef enum {
     PIKA_TRUE   = 1,
     PIKA_FALSE  = 0,
+    _PIKA_BOOL_ERR = -1,
 } PIKA_BOOL;
 
+#define _PIKA_INT_ERR (-999999999)
+#define _PIKA_FLOAT_ERR (-999999999.0)
+
 /* clang-format on */
 
 /*
@@ -278,7 +282,7 @@ typedef struct pika_platform_timer {
 
 void pika_platform_thread_timer_init(pika_platform_timer_t* timer);
 void pika_platform_thread_timer_cutdown(pika_platform_timer_t* timer,
-                                 unsigned int timeout);
+                                        unsigned int timeout);
 char pika_platform_thread_timer_is_expired(pika_platform_timer_t* timer);
 int pika_platform_thread_timer_remain(pika_platform_timer_t* timer);
 unsigned long pika_platform_thread_timer_now(void);

src/PikaVM.c

@@ -592,8 +592,8 @@ Arg* _vm_slice(VMState* vm,
         if (start_i < 0) {
             start_i += len;
         }
-        /* magit code, to the end */
-        if (end_i == -99999) {
+        /* megic code, to the end */
+        if (end_i == VM_PC_EXIT) {
             end_i = len;
         }
         if (end_i < 0) {
@@ -782,12 +782,12 @@ static Arg* VM_instruction_handler_REF(PikaObj* self,
     switch (data[0]) {
         case 'T':
             if (strEqu(arg_path, (char*)"True")) {
-                return arg_setInt(arg_ret_reg, "", 1);
+                return arg_setBool(arg_ret_reg, "", PIKA_TRUE);
             }
             break;
         case 'F':
             if (strEqu(arg_path, (char*)"False")) {
-                return arg_setInt(arg_ret_reg, "", 0);
+                return arg_setBool(arg_ret_reg, "", PIKA_FALSE);
             }
             break;
         case 'N':
@@ -2202,6 +2202,9 @@ void operatorInfo_init(OperatorInfo* info,
         } else if (info->t1 == ARG_TYPE_FLOAT) {
             info->f1 = arg_getFloat(info->a1);
             info->i1 = (int64_t)info->f1;
+        } else if (info->t1 == ARG_TYPE_BOOL) {
+            info->i1 = arg_getBool(info->a1);
+            info->f1 = (pika_float)info->i1;
         }
     }
     info->t2 = arg_getType(info->a2);
@@ -2212,6 +2215,9 @@ void operatorInfo_init(OperatorInfo* info,
     } else if (info->t2 == ARG_TYPE_FLOAT) {
         info->f2 = arg_getFloat(info->a2);
         info->i2 = (int64_t)info->f2;
+    } else if (info->t2 == ARG_TYPE_BOOL) {
+        info->i2 = arg_getBool(info->a2);
+        info->f2 = (pika_float)info->i2;
     }
 }
 
@@ -2395,7 +2401,7 @@ static void _OPT_EQU(OperatorInfo* op) {
         is_equ = (arg_getPtr(op->a1) == arg_getPtr(op->a2));
         goto exit;
     }
-    /* default: int and float */
+    /* default: int bool, and float */
     is_equ = ((op->f1 - op->f2) * (op->f1 - op->f2) < (pika_float)0.000001);
     goto exit;
 exit:
@@ -2779,7 +2785,9 @@ static Arg* VM_instruction_handler_ASS(PikaObj* self,
         arg1 = stack_popArg(&vm->stack, &reg1);
     }
     /* assert failed */
-    if (arg_getType(arg1) == ARG_TYPE_INT && arg_getInt(arg1) == 0) {
+    if ((arg_getType(arg1) == ARG_TYPE_INT && arg_getInt(arg1) == 0) ||
+        (arg_getType(arg1) == ARG_TYPE_BOOL &&
+         arg_getBool(arg1) == PIKA_FALSE)) {
         stack_pushArg(&vm->stack, arg_newInt(PIKA_RES_ERR_ASSERT));
         res = VM_instruction_handler_RIS(self, vm, data, arg_ret_reg);
         if (vm->run_state->try_state == TRY_STATE_NONE) {

src/PikaVM.h

@@ -48,7 +48,7 @@ typedef enum {
     VM_JMP_RAISE = -996,
 } VM_JMP;
 
-typedef enum { VM_PC_EXIT = -99999 } VM_PC;
+#define VM_PC_EXIT (-99999)
 
 typedef enum {
     TRY_STATE_NONE = 0,

src/dataArg.c

@@ -285,6 +285,12 @@ Arg* arg_toStrArg(Arg* arg) {
 #endif
         return arg_newStr(buff);
     }
+    if (type == ARG_TYPE_BOOL) {
+        if (arg_getBool(arg)) {
+            return arg_newStr("True");
+        }
+        return arg_newStr("False");
+    }
     if (type == ARG_TYPE_FLOAT) {
         pika_platform_snprintf(buff, PIKA_SPRINTF_BUFF_SIZE, "%f",
                                arg_getFloat(arg));
@@ -395,6 +401,10 @@ Arg* arg_setInt(Arg* self, char* name, int64_t val) {
     return arg_set(self, name, ARG_TYPE_INT, (uint8_t*)&val, sizeof(val));
 }
 
+Arg* arg_setBool(Arg* self, char* name, PIKA_BOOL val) {
+    return arg_set(self, name, ARG_TYPE_BOOL, (uint8_t*)&val, sizeof(val));
+}
+
 Arg* arg_setNull(Arg* self) {
     return arg_set(self, "", ARG_TYPE_NONE, NULL, 0);
 }
@@ -426,11 +436,19 @@ Arg* arg_setStr(Arg* self, char* name, char* string) {
 int64_t arg_getInt(Arg* self) {
     pika_assert(NULL != self);
     if (NULL == arg_getContent(self)) {
-        return -999999;
+        return _PIKA_INT_ERR;
     }
     return *(int64_t*)arg_getContent(self);
 }
 
+PIKA_BOOL arg_getBool(Arg* self) {
+    pika_assert(NULL != self);
+    if (NULL == arg_getContent(self)) {
+        return _PIKA_BOOL_ERR;
+    }
+    return *(PIKA_BOOL*)arg_getContent(self);
+}
+
 void* arg_getPtr(Arg* self) {
     if (arg_getType(self) == ARG_TYPE_NONE) {
         return NULL;
@@ -539,7 +557,6 @@ void* arg_getHeapStruct(Arg* self) {
     return arg_getContent(self) + sizeof(void*);
 }
 
-
 void arg_deinitHeap(Arg* self) {
     if (arg_getIsWeakRef(self)) {
         return;

src/dataArg.h

@@ -36,6 +36,7 @@ typedef enum {
     ARG_TYPE_UNDEF = 0,
     ARG_TYPE_NONE,
     ARG_TYPE_INT,
+    ARG_TYPE_BOOL,
     ARG_TYPE_FLOAT,
     ARG_TYPE_STRING,
     ARG_TYPE_BYTES,
@@ -113,6 +114,7 @@ uint32_t arg_getContentSize(Arg* self);
 Hash hash_time33(char* str);
 
 Arg* arg_setInt(Arg* self, char* name, int64_t val);
+Arg* arg_setBool(Arg* self, char* name, PIKA_BOOL val);
 Arg* arg_setFloat(Arg* self, char* name, pika_float val);
 Arg* arg_setPtr(Arg* self, char* name, ArgType type, void* pointer);
 Arg* arg_setStr(Arg* self, char* name, char* string);
@@ -123,6 +125,10 @@ static inline Arg* arg_newInt(int64_t val) {
     return arg_setInt(NULL, (char*)"", (val));
 }
 
+static inline Arg* arg_newBool(PIKA_BOOL val) {
+    return arg_setBool(NULL, (char*)"", (val));
+}
+
 static inline Arg* arg_newFloat(pika_float val) {
     return arg_setFloat(NULL, (char*)"", (val));
 }
@@ -144,6 +150,7 @@ static inline Arg* arg_newBytes(uint8_t* src, size_t size) {
 }
 
 int64_t arg_getInt(Arg* self);
+PIKA_BOOL arg_getBool(Arg* self);
 pika_float arg_getFloat(Arg* self);
 void* arg_getPtr(Arg* self);
 char* arg_getStr(Arg* self);

src/dataArgs.c

@@ -188,7 +188,7 @@ PIKA_RES args_setInt(Args* self, char* name, int64_t val) {
 int64_t args_getInt(Args* self, char* name) {
     Arg* arg = args_getArg(self, name);
     if (NULL == arg) {
-        return -999999999;
+        return _PIKA_INT_ERR;
     }
     ArgType arg_type = arg_getType(arg);
     if (arg_type == ARG_TYPE_INT) {
@@ -196,7 +196,19 @@ int64_t args_getInt(Args* self, char* name) {
     } else if (arg_type == ARG_TYPE_FLOAT) {
         return (int)arg_getFloat(arg);
     }
-    return -999999999;
+    return _PIKA_INT_ERR;
+}
+
+PIKA_BOOL args_getBool(Args* self, char* name) {
+    Arg* arg = args_getArg(self, name);
+    if (NULL == arg) {
+        return _PIKA_BOOL_ERR;
+    }
+    ArgType arg_type = arg_getType(arg);
+    if (arg_type == ARG_TYPE_BOOL) {
+        return arg_getBool(arg);
+    }
+    return _PIKA_BOOL_ERR;
 }
 
 int32_t args_getSize(Args* self) {
@@ -215,7 +227,7 @@ ArgType args_getType(Args* self, char* name) {
 pika_float args_getFloat(Args* self, char* name) {
     Arg* arg = args_getArg(self, name);
     if (NULL == arg) {
-        return -999999999.0;
+        return _PIKA_FLOAT_ERR;
     }
     ArgType arg_type = arg_getType(arg);
     if (arg_type == ARG_TYPE_FLOAT) {
@@ -223,7 +235,7 @@ pika_float args_getFloat(Args* self, char* name) {
     } else if (arg_type == ARG_TYPE_INT) {
         return (pika_float)arg_getInt(arg);
     }
-    return -999999999.0;
+    return _PIKA_FLOAT_ERR;
 }
 
 PIKA_RES args_copyArg(Args* self, Arg* argToBeCopy) {

src/dataArgs.h

@@ -71,6 +71,7 @@ void* args_getPtr(Args* self, char* name);
 
 PIKA_RES args_setInt(Args* self, char* name, int64_t int64In);
 int64_t args_getInt(Args* self, char* name);
+PIKA_BOOL args_getBool(Args* self, char* name);
 
 char* args_print(Args* self, char* name);
 

test/VM-test.cpp

@@ -353,7 +353,7 @@ TEST(VM, RUN_local_b) {
     int c = obj_getInt(globals, "c");
     EXPECT_EQ(a, 1);
     /* b is local, should not be exist in globals */
-    EXPECT_EQ(b, -999999999);
+    EXPECT_EQ(b, _PIKA_INT_ERR);
     EXPECT_EQ(c, 2);
     obj_deinit(self);
     // obj_deinit(globals);
@@ -381,9 +381,9 @@ TEST(VM, RUN_DEF_add) {
     int b = obj_getInt(globals, "b");
     int c = obj_getInt(globals, "c");
     /* a is local, should not be exist in globals */
-    EXPECT_EQ(a, -999999999);
+    EXPECT_EQ(a, _PIKA_INT_ERR);
     /* b is local, should not be exist in globals */
-    EXPECT_EQ(b, -999999999);
+    EXPECT_EQ(b, _PIKA_INT_ERR);
     EXPECT_EQ(c, 3);
     obj_deinit(self);
     // obj_deinit(globals);
@@ -507,7 +507,7 @@ TEST(VM, EST) {
     int a = obj_getInt(self, "a");
     int b = obj_getInt(self, "b");
     /* a is local, should not be exist in globals */
-    EXPECT_EQ(a, -999999999);
+    EXPECT_EQ(a, _PIKA_INT_ERR);
     /* b is local, should not be exist in globals */
     EXPECT_EQ(b, 0);
     obj_deinit(self);
@@ -2648,6 +2648,14 @@ TEST(vm, run_file) {
     EXPECT_EQ(pikaMemNow(), 0);
 }
 
+TEST(vm, bool_){
+    PikaObj* pikaMain = newRootObj("pikaMain", New_PikaMain);
+    obj_run(pikaMain, "print(True)\n");
+    obj_deinit(pikaMain);
+    EXPECT_STREQ(log_buff[0], "True\r\n");
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
 #endif
 
 TEST_END

test/arg-test.cpp

@@ -20,6 +20,15 @@ TEST(arg_test, int_) {
     EXPECT_EQ(pikaMemNow(), 0);
 }
 
+TEST(arg_test, bool_) {
+    Arg* arg = New_arg(NULL);
+    arg = arg_setBool(arg, "test", PIKA_TRUE);
+    PIKA_BOOL a = arg_getBool(arg);
+    EXPECT_EQ(a, PIKA_TRUE);
+    arg_deinit(arg);
+    EXPECT_EQ(pikaMemNow(), 0);
+}
+
 TEST(arg_test, float_) {
     Arg* arg = New_arg(NULL);
     arg = arg_setFloat(arg, "test", 1.01);

test/args-test.cpp

@@ -137,7 +137,7 @@ TEST(args, test12) {
     EXPECT_EQ(13, (int)args_getInt(args, "test"));
     args_removeArg(args, args_getArg(args, "test"));
     EXPECT_EQ(1, args_getSize(args));
-    EXPECT_EQ(-999999999, (int)args_getInt(args, "test"));
+    EXPECT_EQ(_PIKA_INT_ERR, (int)args_getInt(args, "test"));
     args_deinit(args);
     EXPECT_EQ(pikaMemNow(), 0);
 }
@@ -234,7 +234,7 @@ TEST(args, args_move) {
     args_setInt(args, "a", 100);
     args_moveArg(args, args2, args_getArg(args, "a"));
     /* assert */
-    EXPECT_EQ(-999999999, args_getInt(args, "a"));
+    EXPECT_EQ(_PIKA_INT_ERR, args_getInt(args, "a"));
     EXPECT_EQ(100, args_getInt(args2, "a"));
     /* deinit */
     args_deinit(args);

test/pikaMain-test.cpp

@@ -274,7 +274,7 @@ TEST(pikaMain, PikaStdData) {
     int b = obj_getInt(pikaMain, "b");
     /* assert */
     EXPECT_EQ(a, 1);
-    EXPECT_EQ(b, -999999999);
+    EXPECT_EQ(b, _PIKA_INT_ERR);
 
     /* deinit */
     obj_deinit(pikaMain);
@@ -1004,7 +1004,7 @@ TEST(pikaMain, task_run_period_until) {
             "task.run_until_ms(1000)\n"
             "\n");
     /* collect */
-    int mem_lack = obj_getInt(pikaMain, "mem_lack");
+    PIKA_BOOL mem_lack = obj_getBool(pikaMain, "mem_lack");
     /* assert */
     EXPECT_STREQ(log_buff[0], "task 1 running...\r\n");
     EXPECT_STREQ(log_buff[1], "task 1 running...\r\n");
@@ -1014,7 +1014,7 @@ TEST(pikaMain, task_run_period_until) {
     EXPECT_STREQ(log_buff[5], "task 2 running...\r\n");
     EXPECT_STREQ(log_buff[6], "task 1 running...\r\n");
     EXPECT_STREQ(log_buff[7], "BEGIN\r\n");
-    EXPECT_EQ(mem_lack, 0);
+    EXPECT_EQ(mem_lack, PIKA_FALSE);
     /* deinit */
     obj_deinit(pikaMain);
     EXPECT_EQ(pikaMemNow(), 0);

tools/pikaCompiler/src/py_type.rs

@@ -29,6 +29,9 @@ impl PyType {
         if self.type_name == "any" {
             return "Arg*".to_string();
         }
+        if self.type_name == "bool"{
+            return "PIKA_BOOL".to_string();
+        }
         if self.type_name == "@tupleVarPar" {
             return "PikaTuple*".to_string();
         }
@@ -45,6 +48,9 @@ impl PyType {
         if self.type_name == "int64" {
             return "int64_t".to_string();
         }
+        if self.type_name == "bool" {
+            return "PIKA_BOOL".to_string();
+        }
         if self.type_name == "float" {
             return "pika_float".to_string();
         }
@@ -81,6 +87,9 @@ impl PyType {
         if self.type_name == "int64" {
             return "    method_returnInt(args, res);\n".to_string();
         }
+        if self.type_name == "bool" {
+            return "    method_returnBool(args, res);\n".to_string();
+        }
         if self.type_name == "float" {
             return "    method_returnFloat(args, res);\n".to_string();
         }
@@ -123,6 +132,9 @@ impl PyType {
         if self.type_name == "int64" {
             return "args_getInt".to_string();
         }
+        if self.type_name == "bool"{
+            return "args_getBool".to_string();
+        }
         if self.type_name == "float" {
             return "args_getFloat".to_string();
         }