use static inline instead of #define

src/PikaObj.h

@@ -96,9 +96,17 @@ struct RangeData {
 #define OBJ_FLAG_RUN_AS 0x16
 #define OBJ_FLAG_GLOBALS 0x32
 
-#define obj_getFlag(__self, __flag) (((__self)->flag & (__flag)) == (__flag))
-#define obj_setFlag(__self, __flag) ((__self)->flag |= (__flag))
-#define obj_clearFlag(__self, __flag) ((__self)->flag &= ~(__flag))
+static inline uint8_t obj_getFlag(PikaObj* self, uint8_t flag) {
+    return (self->flag & flag) == flag;
+}
+
+static inline void obj_setFlag(PikaObj* self, uint8_t flag) {
+    self->flag |= flag;
+}
+
+static inline void obj_clearFlag(PikaObj* self, uint8_t flag) {
+    self->flag &= ~flag;
+}
 
 typedef PikaObj* (*NewFun)(Args* args);
 typedef PikaObj* (*InitFun)(PikaObj* self, Args* args);
@@ -289,8 +297,13 @@ PikaObj* newNormalObj(NewFun newObjFun);
 Arg* arg_setRef(Arg* self, char* name, PikaObj* obj);
 Arg* arg_setObj(Arg* self, char* name, PikaObj* obj);
 
-#define arg_newObj(obj) arg_setObj(NULL, "", (obj))
-#define arg_newRef(obj) arg_setRef(NULL, "", (obj))
+static inline Arg* arg_newObj(PikaObj* obj) {
+    return arg_setObj(NULL, "", (obj));
+}
+
+static inline Arg* arg_newRef(PikaObj* obj) {
+    return arg_setRef(NULL, "", (obj));
+}
 
 PikaObj* obj_importModuleWithByteCodeFrame(PikaObj* self,
                                            char* name,
@@ -344,9 +357,17 @@ void pks_printVersion(void);
 void pks_getVersion(char* buff);
 void* obj_getStruct(PikaObj* self, char* name);
 
-#define obj_refcntDec(self) (((self)->refcnt--))
-#define obj_refcntInc(self) (((self)->refcnt)++)
-#define obj_refcntNow(self) ((self)->refcnt)
+static inline void obj_refcntDec(PikaObj* self) {
+    self->refcnt--;
+}
+
+static inline void obj_refcntInc(PikaObj* self) {
+    self->refcnt++;
+}
+
+static inline uint8_t obj_refcntNow(PikaObj* self) {
+    return self->refcnt;
+}
 
 #define obj_setStruct(PikaObj_p_self, char_p_name, struct_) \
     args_setStruct(((PikaObj_p_self)->list), char_p_name, struct_)
@@ -375,7 +396,7 @@ char* __printBytes(PikaObj* self, Arg* arg);
 #define PIKASCRIPT_VERSION_REQUIRE_MINIMUN(majer, minor, micro) \
     (PIKASCRIPT_VERSION_NUM >= PIKASCRIPT_VERSION_TO_NUM(majer, minor, micro))
 
-/*
+/* [example]
 const MethodProp floatMethod = {
     .ptr = (void*)PikaStdLib_SysObj_floatMethod,
     .bytecode_frame = NULL,

src/PikaVM.c

@@ -201,7 +201,7 @@ static int32_t VMState_getAddrOffsetOfJmpBack(VMState* vm) {
 
     /* find loop deepth */
     while (1) {
-        offset -= instructUnit_getSize(ins_unit_now);
+        offset -= instructUnit_getSize();
         InstructUnit* ins_unit_now =
             VMState_getInstructUnitWithOffset(vm, offset);
         uint16_t invoke_deepth = instructUnit_getInvokeDeepth(ins_unit_now);
@@ -215,7 +215,7 @@ static int32_t VMState_getAddrOffsetOfJmpBack(VMState* vm) {
 
     offset = 0;
     while (1) {
-        offset += instructUnit_getSize(ins_unit_now);
+        offset += instructUnit_getSize();
         InstructUnit* ins_unit_now =
             VMState_getInstructUnitWithOffset(vm, offset);
         enum Instruct ins = instructUnit_getInstruct(ins_unit_now);
@@ -287,7 +287,7 @@ static int32_t VMState_getAddrOffsetOfRaise(VMState* vm) {
     int offset = 0;
     InstructUnit* ins_unit_now = VMState_getInstructNow(vm);
     while (1) {
-        offset += instructUnit_getSize(ins_unit_now);
+        offset += instructUnit_getSize();
         if (vm->pc + offset >= (int)VMState_getInstructArraySize(vm)) {
             return 0;
         }
@@ -1514,7 +1514,7 @@ static PIKA_BOOL _proxy_setattr(PikaObj* self, char* name, Arg* arg) {
 #if PIKA_NANO_ENABLE
     return PIKA_FALSE;
 #endif
-    if obj_getFlag (self, OBJ_FLAG_PROXY_SETATTR) {
+    if (obj_getFlag(self, OBJ_FLAG_PROXY_SETATTR)) {
         obj_setStr(self, "@name", name);
         obj_setArg(self, "@value", arg);
         /* clang-format off */
@@ -1747,7 +1747,7 @@ static uint8_t VMState_getInputArgNum(VMState* vm) {
     uint8_t num = 0;
     while (1) {
         ins_unit_now--;
-        pc_this -= instructUnit_getSize(ins_unit_now);
+        pc_this -= instructUnit_getSize();
         uint8_t invode_deepth = instructUnit_getInvokeDeepth(ins_unit_now);
         if (pc_this < 0) {
             break;
@@ -2913,7 +2913,7 @@ void instructArray_printAsArray(InstructArray* self) {
         if (NULL == ins_unit) {
             goto exit;
         }
-        for (int i = 0; i < (int)instructUnit_getSize(ins_unit); i++) {
+        for (int i = 0; i < (int)instructUnit_getSize(); i++) {
             g_i++;
             __platform_printf("0x%02x, ", *((uint8_t*)ins_unit + (uintptr_t)i));
             if (g_i % line_num == 0) {

src/PikaVM.h

@@ -127,37 +127,45 @@ VMParameters* pikaVM_runAsm(PikaObj* self, char* pikaAsm);
 VMParameters* pikaVM_runByteCodeFrame(PikaObj* self,
                                       ByteCodeFrame* byteCode_frame);
 
-#define instructUnit_getBlockDeepth(self) (((self)->deepth) & 0x0F)
-#define instructUnit_getInvokeDeepth(self) (((self)->deepth) >> 4)
-#define instructUnit_getInstruct(self) \
-    ((enum Instruct)((self)->isNewLine_instruct & 0x7F))
-#define instructUnit_getConstPoolIndex(self) ((self)->const_pool_index)
-#define instructUnit_getIsNewLine(self) ((self)->isNewLine_instruct >> 7)
+static inline int instructUnit_getBlockDeepth(InstructUnit* self) {
+    return self->deepth & 0x0F;
+}
 
-#define instructUnit_setBlockDeepth(self, val) \
-    do {                                       \
-        ((self)->deepth) |= (0x0F & (val));    \
-    } while (0)
+static inline int instructUnit_getInvokeDeepth(InstructUnit* self) {
+    return self->deepth >> 4;
+}
 
-#define instructUnit_setConstPoolIndex(self, val) \
-    do {                                          \
-        ((self)->const_pool_index = (val));       \
-    } while (0)
+static inline enum Instruct instructUnit_getInstruct(InstructUnit* self) {
+    return (enum Instruct)(self->isNewLine_instruct & 0x7F);
+}
 
-#define instructUnit_setInvokeDeepth(self, val)    \
-    do {                                           \
-        ((self)->deepth) |= ((0x0F & (val)) << 4); \
-    } while (0)
+static inline int instructUnit_getConstPoolIndex(InstructUnit* self) {
+    return self->const_pool_index;
+}
 
-#define instructUnit_setInstruct(self, val)             \
-    do {                                                \
-        ((self)->isNewLine_instruct) |= (0x7F & (val)); \
-    } while (0)
+static inline int instructUnit_getIsNewLine(InstructUnit* self) {
+    return self->isNewLine_instruct >> 7;
+}
 
-#define instructUnit_setIsNewLine(self, val)                   \
-    do {                                                       \
-        ((self)->isNewLine_instruct) |= ((0x01 & (val)) << 7); \
-    } while (0)
+static inline void instructUnit_setBlockDeepth(InstructUnit* self, int val) {
+    self->deepth |= (0x0F & val);
+}
+
+static inline void instructUnit_setConstPoolIndex(InstructUnit* self, int val) {
+    self->const_pool_index = val;
+}
+
+static inline void instructUnit_setInvokeDeepth(InstructUnit* self, int val) {
+    self->deepth |= ((0x0F & val) << 4);
+}
+
+static inline void instructUnit_setInstruct(InstructUnit* self, int val) {
+    self->isNewLine_instruct |= (0x7F & val);
+}
+
+static inline void instructUnit_setIsNewLine(InstructUnit* self, int val) {
+    self->isNewLine_instruct |= ((0x01 & val) << 7);
+}
 
 InstructUnit* New_instructUnit(uint8_t data_size);
 void instructUnit_deinit(InstructUnit* self);
@@ -168,14 +176,23 @@ void constPool_init(ConstPool* self);
 void constPool_deinit(ConstPool* self);
 void constPool_append(ConstPool* self, char* content);
 
-#define constPool_getStart(self) ((self)->content_start)
-#define constPool_getLastOffset(self) ((self)->size)
-#define constPool_getByOffset(self, offset) \
-    (char*)((uintptr_t)constPool_getStart((self)) + (uintptr_t)(offset))
+static inline void* constPool_getStart(ConstPool* self) {
+    return self->content_start;
+}
 
-#define VMState_getConstWithInstructUnit(__vm, __ins_unit)        \
-    (constPool_getByOffset(&((__vm)->bytecode_frame->const_pool), \
-                           instructUnit_getConstPoolIndex(__ins_unit)))
+static inline int constPool_getLastOffset(ConstPool* self) {
+    return self->size;
+}
+
+static inline char* constPool_getByOffset(ConstPool* self, int offset) {
+    return (char*)((uintptr_t)constPool_getStart(self) + (uintptr_t)offset);
+}
+
+static inline char* VMState_getConstWithInstructUnit(VMState* vm,
+                                                     InstructUnit* ins_unit) {
+    return constPool_getByOffset(&(vm->bytecode_frame->const_pool),
+                                 instructUnit_getConstPoolIndex(ins_unit));
+}
 
 char* constPool_getNow(ConstPool* self);
 char* constPool_getNext(ConstPool* self);
@@ -193,30 +210,40 @@ void instructUnit_init(InstructUnit* ins_unit);
 void instructUnit_print(InstructUnit* self);
 void instructArray_print(InstructArray* self);
 
-#define instructArray_getStart(InsturctArry_p_self) \
-    ((InsturctArry_p_self)->content_start)
+static inline InstructUnit* instructArray_getStart(InstructArray* self) {
+    return (InstructUnit*)self->content_start;
+}
 
-#define instructArray_getSize(InsturctArry_p_self) \
-    ((size_t)(InsturctArry_p_self)->size)
+static inline size_t instructArray_getSize(InstructArray* self) {
+    return (size_t)self->size;
+}
 
-#define VMState_getInstructArraySize(vm) \
-    (instructArray_getSize(&((vm)->bytecode_frame->instruct_array)))
+static inline int VMState_getInstructArraySize(VMState* vm) {
+    return instructArray_getSize(&(vm->bytecode_frame->instruct_array));
+}
 
-#define instructArray_getByOffset(__self, __offset)                \
-    ((InstructUnit*)((uintptr_t)instructArray_getStart((__self)) + \
-                     (uintptr_t)(__offset)))
+static inline InstructUnit* instructArray_getByOffset(InstructArray* self,
+                                                      int offset) {
+    return (InstructUnit*)((uintptr_t)instructArray_getStart(self) +
+                           (uintptr_t)offset);
+}
 
-#define VMState_getInstructUnitWithOffset(vm, offset)                   \
-    (instructArray_getByOffset(&((vm)->bytecode_frame->instruct_array), \
-                               (vm)->pc + (offset)))
+static inline InstructUnit* VMState_getInstructUnitWithOffset(VMState* vm,
+                                                              int offset) {
+    return instructArray_getByOffset(&(vm->bytecode_frame->instruct_array),
+                                     vm->pc + offset);
+}
 
-#define VMState_getInstructNow(vm)                                      \
-    (instructArray_getByOffset(&((vm)->bytecode_frame->instruct_array), \
-                               (vm)->pc))
+static inline InstructUnit* VMState_getInstructNow(VMState* vm) {
+    return instructArray_getByOffset(&(vm->bytecode_frame->instruct_array),
+                                     vm->pc);
+}
 
 void byteCodeFrame_print(ByteCodeFrame* self);
 
-#define instructUnit_getSize(InstructUnit_p_self) ((size_t)sizeof(InstructUnit))
+static inline size_t instructUnit_getSize(void) {
+    return (size_t)sizeof(InstructUnit);
+}
 
 uint16_t constPool_getOffsetByData(ConstPool* self, char* data);
 void instructArray_printWithConst(InstructArray* self, ConstPool* const_pool);

src/PikaVersion.h

@@ -2,4 +2,4 @@
 #define PIKA_VERSION_MINOR       11
 #define PIKA_VERSION_MICRO       6
 
-#define PIKA_EDIT_TIME      "2022/11/05 16:18:10"
+#define PIKA_EDIT_TIME      "2022/11/06 13:17:15"

src/dataArg.h

@@ -86,20 +86,26 @@ typedef struct ConstArg {
     Hash name_hash;
 } ConstArg;
 
-Arg* arg_getNext(Arg* self);
-uint32_t arg_getSize(Arg* self);
-uint8_t* arg_getContent(Arg* self);
 uint32_t arg_totleSize(Arg* self);
-void arg_setNext(Arg* self, Arg* next);
 uint32_t arg_getTotleSize(Arg* self);
 void arg_freeContent(Arg* self);
 
 Arg* arg_setName(Arg* self, char* name);
 Arg* arg_setContent(Arg* self, uint8_t* content, uint32_t size);
 Arg* arg_newContent(uint32_t size);
-#define arg_setType(__self, __type) ((__self)->type = (__type))
-#define arg_getNameHash(__self) ((__self)->name_hash)
-#define arg_getType(__self) ((ArgType)(__self)->type)
+
+static inline void arg_setType(Arg* self, ArgType type) {
+    self->type = type;
+}
+
+static inline Hash arg_getNameHash(Arg* self) {
+    return self->name_hash;
+}
+
+static inline ArgType arg_getType(Arg* self) {
+    return (ArgType)self->type;
+}
+
 uint32_t arg_getContentSize(Arg* self);
 Hash hash_time33(char* str);
 
@@ -110,12 +116,29 @@ Arg* arg_setStr(Arg* self, char* name, char* string);
 Arg* arg_setNull(Arg* self);
 Arg* arg_setBytes(Arg* self, char* name, uint8_t* src, size_t size);
 
-#define arg_newInt(val) arg_setInt(NULL, "", (val))
-#define arg_newFloat(val) arg_setFloat(NULL, "", (val))
-#define arg_newPtr(type, pointer) arg_setPtr(NULL, "", (type), (pointer))
-#define arg_newStr(string) arg_setStr(NULL, "", (string))
-#define arg_newNull() arg_setNull(NULL)
-#define arg_newBytes(src, size) arg_setBytes(NULL, "", (src), (size))
+static inline Arg* arg_newInt(int64_t val) {
+    return arg_setInt(NULL, "", (val));
+}
+
+static inline Arg* arg_newFloat(pika_float val) {
+    return arg_setFloat(NULL, "", (val));
+}
+
+static inline Arg* arg_newPtr(ArgType type, void* pointer) {
+    return arg_setPtr(NULL, "", (type), (pointer));
+}
+
+static inline Arg* arg_newStr(char* string) {
+    return arg_setStr(NULL, "", (string));
+}
+
+static inline Arg* arg_newNull() {
+    return arg_setNull(NULL);
+}
+
+static inline Arg* arg_newBytes(uint8_t* src, size_t size) {
+    return arg_setBytes(NULL, "", (src), (size));
+}
 
 int64_t arg_getInt(Arg* self);
 pika_float arg_getFloat(Arg* self);
@@ -126,7 +149,6 @@ size_t arg_getBytesSize(Arg* self);
 Arg* arg_copy(Arg* argToBeCopy);
 Arg* arg_copy_noalloc(Arg* argToBeCopy, Arg* argToBeCopyTo);
 
-uint8_t* arg_getContent(Arg* self);
 void arg_deinit(Arg* self);
 
 Arg* New_arg(void* voidPointer);
@@ -144,55 +166,71 @@ void* arg_getHeapStruct(Arg* self);
 void arg_deinitHeap(Arg* self);
 void arg_printBytes(Arg* self);
 Arg* arg_loadFile(Arg* self, char* filename);
-uint8_t argType_isObject(ArgType type);
 
 #define ARG_FLAG_SERIALIZED 0x01
 #define ARG_FLAG_KEYWORD 0x02
 #define ARG_FLAG_WEAK_REF 0x04
-
 #define ARG_FLAG_MAX 0x08
 
-#define arg_getNext(self) ((self)->_.next)
-#define arg_getSize(self) ((self)->size)
-#define arg_isSerialized(self) ((self)->flag & ARG_FLAG_SERIALIZED)
-#define arg_setSerialized(self, __serialized)                      \
-    do {                                                           \
-        (self)->flag = ((self)->flag & ~ARG_FLAG_SERIALIZED) |     \
-                       ((__serialized) ? ARG_FLAG_SERIALIZED : 0); \
-    } while (0)
+static inline Arg* arg_getNext(Arg* self) {
+    return self->_.next;
+}
 
-#define arg_getIsKeyword(self) ((self)->flag & ARG_FLAG_KEYWORD)
-#define arg_setIsKeyword(self, __isKeyword)                    \
-    do {                                                       \
-        (self)->flag = ((self)->flag & ~ARG_FLAG_KEYWORD) |    \
-                       ((__isKeyword) ? ARG_FLAG_KEYWORD : 0); \
-    } while (0)
-#define arg_getIsWeakRef(self) ((self)->flag & ARG_FLAG_WEAK_REF)
-#define arg_setIsWeakRef(self, __isWeakRef)                     \
-    do {                                                        \
-        (self)->flag = ((self)->flag & ~ARG_FLAG_WEAK_REF) |    \
-                       ((__isWeakRef) ? ARG_FLAG_WEAK_REF : 0); \
-    } while (0)
+static inline void arg_setNext(Arg* self, Arg* next) {
+    self->_.next = next;
+}
 
-#define arg_getContent(self) \
-    ((arg_isSerialized(self)) ? (self)->content : ((self)->_.buffer))
-#define arg_getNext(self) ((self)->_.next)
-#define arg_setNext(self, __next) ((self)->_.next = (__next))
+static inline uint32_t arg_getSize(Arg* self) {
+    return self->size;
+}
 
-#define argType_isObject(type) \
-    ((type) == ARG_TYPE_OBJECT || (type) == ARG_TYPE_OBJECT_NEW)
+static inline uint8_t arg_isSerialized(Arg* self) {
+    return self->flag & ARG_FLAG_SERIALIZED;
+}
 
-#define argType_isCallable(type)                                             \
-    ((type) == ARG_TYPE_METHOD_CONSTRUCTOR ||                                \
-     (type) == ARG_TYPE_METHOD_OBJECT || (type) == ARG_TYPE_METHOD_STATIC || \
-     (type) == ARG_TYPE_METHOD_NATIVE ||                                     \
-     (type) == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR)
+static inline void arg_setSerialized(Arg* self, uint8_t serialized) {
+    self->flag = (self->flag & ~ARG_FLAG_SERIALIZED) |
+                 (serialized ? ARG_FLAG_SERIALIZED : 0);
+}
 
-#define argType_isNative(type)           \
-    ((type) == ARG_TYPE_METHOD_NATIVE || \
-     (type) == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR)
+static inline uint8_t arg_getIsKeyword(Arg* self) {
+    return self->flag & ARG_FLAG_KEYWORD;
+}
 
-#endif
+static inline void arg_setIsKeyword(Arg* self, uint8_t isKeyword) {
+    self->flag =
+        (self->flag & ~ARG_FLAG_KEYWORD) | (isKeyword ? ARG_FLAG_KEYWORD : 0);
+}
+
+static inline uint8_t arg_getIsWeakRef(Arg* self) {
+    return self->flag & ARG_FLAG_WEAK_REF;
+}
+
+static inline void arg_setIsWeakRef(Arg* self, uint8_t isWeakRef) {
+    self->flag =
+        (self->flag & ~ARG_FLAG_WEAK_REF) | (isWeakRef ? ARG_FLAG_WEAK_REF : 0);
+}
+
+static inline uint8_t* arg_getContent(Arg* self) {
+    return (arg_isSerialized(self)) ? (self)->content : ((self)->_.buffer);
+}
+
+static inline uint8_t argType_isObject(ArgType type) {
+    return ((type) == ARG_TYPE_OBJECT || (type) == ARG_TYPE_OBJECT_NEW);
+}
+
+static inline uint8_t argType_isCallable(ArgType type) {
+    return ((type) == ARG_TYPE_METHOD_CONSTRUCTOR ||
+            (type) == ARG_TYPE_METHOD_OBJECT ||
+            (type) == ARG_TYPE_METHOD_STATIC ||
+            (type) == ARG_TYPE_METHOD_NATIVE ||
+            (type) == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR);
+}
+
+static inline uint8_t argType_isNative(ArgType type) {
+    return ((type) == ARG_TYPE_METHOD_NATIVE ||
+            (type) == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR);
+}
 
 #define arg_newReg(__name, __size)           \
     Arg __name = {0};                        \
@@ -201,3 +239,5 @@ uint8_t argType_isObject(ArgType type);
 
 void arg_init_stack(Arg* self, uint8_t* buffer, uint32_t size);
 PIKA_BOOL arg_isEqual(Arg* self, Arg* other);
+
+#endif

src/dataArgs.h

@@ -137,30 +137,74 @@ struct PikaDict {
 
 /* dict api */
 PikaDict* New_dict(void);
-#define dict_setInt(self, name, val) \
-    args_setInt((&((self)->super)), (name), (val))
-#define dict_setFloat(self, name, val) \
-    args_setFloat((&((self)->super)), (name), (val))
-#define dict_setStr(self, name, val) \
-    args_setStr((&((self)->super)), (name), (val))
-#define dict_setPtr(self, name, val) \
-    args_setPtr((&((self)->super)), (name), (val))
-#define dict_setArg(self, val) args_setArg((&((self)->super)), (val))
-#define dict_removeArg(self, val) args_removeArg((&((self)->super)), (val))
-#define dict_setBytes(self, name, val, size) \
-    args_setBytes((&((self)->super)), (name), (val), (size))
-#define dict_getInt(self, name) (args_getInt((&((self)->super)), (name)))
-#define dict_getFloat(self, name) (args_getFloat((&((self)->super)), (name)))
-#define dict_getStr(self, name) (args_getStr((&((self)->super)), (name)))
-#define dict_getPtr(self, name) (args_getPtr((&((self)->super)), (name)))
-#define dict_getArg(self, name) (args_getArg((&((self)->super)), (name)))
-#define dict_getBytes(self, name) (args_getBytes((&((self)->super)), (name)))
-#define dict_getType(self, name) (args_getType((&((self)->super)), (name)))
-#define dict_getBytesSize(self, name) \
-    (args_getBytesSize((&((self)->super)), (name)))
-#define dict_deinit(self) (args_deinit((&((self)->super))))
 
-#define list_deinit(self) (args_deinit((&((self)->super))))
+static inline PIKA_RES dict_setInt(PikaDict* self, char* name, int64_t val) {
+    return args_setInt((&((self)->super)), (name), (val));
+}
+static inline PIKA_RES dict_setFloat(PikaDict* self,
+                                     char* name,
+                                     pika_float val) {
+    return args_setFloat((&((self)->super)), (name), (val));
+}
+static inline PIKA_RES dict_setStr(PikaDict* self, char* name, char* val) {
+    return args_setStr((&((self)->super)), (name), (val));
+}
+static inline PIKA_RES dict_setPtr(PikaDict* self, char* name, void* val) {
+    return args_setPtr((&((self)->super)), (name), (val));
+}
+
+static inline PIKA_RES dict_setArg(PikaDict* self, Arg* val) {
+    return args_setArg((&((self)->super)), (val));
+}
+
+static inline PIKA_RES dict_removeArg(PikaDict* self, Arg* val) {
+    return args_removeArg((&((self)->super)), (val));
+}
+
+static inline PIKA_RES dict_setBytes(PikaDict* self,
+                                     char* name,
+                                     uint8_t* val,
+                                     size_t size) {
+    return args_setBytes((&((self)->super)), (name), (val), (size));
+}
+
+static inline int64_t dict_getInt(PikaDict* self, char* name) {
+    return args_getInt((&((self)->super)), (name));
+}
+
+static inline pika_float dict_getFloat(PikaDict* self, char* name) {
+    return args_getFloat((&((self)->super)), (name));
+}
+
+static inline char* dict_getStr(PikaDict* self, char* name) {
+    return args_getStr((&((self)->super)), (name));
+}
+
+static inline void* dict_getPtr(PikaDict* self, char* name) {
+    return args_getPtr((&((self)->super)), (name));
+}
+
+static inline Arg* dict_getArg(PikaDict* self, char* name) {
+    return args_getArg((&((self)->super)), (name));
+}
+
+static inline uint8_t* dict_getBytes(PikaDict* self, char* name) {
+    return args_getBytes((&((self)->super)), (name));
+}
+
+static inline ArgType dict_getType(PikaDict* self, char* name) {
+    return args_getType((&((self)->super)), (name));
+}
+
+static inline size_t dict_getBytesSize(PikaDict* self, char* name) {
+    return args_getBytesSize((&((self)->super)), (name));
+}
+
+static inline void dict_deinit(PikaDict* self) {
+    args_deinit((&((self)->super)));
+}
+
+/* list api */
 PIKA_RES list_append(PikaList* self, Arg* arg);
 PIKA_RES list_setArg(PikaList* self, int index, Arg* arg);
 int list_getInt(PikaList* self, int index);
@@ -170,18 +214,50 @@ void* list_getPtr(PikaList* self, int index);
 Arg* list_getArg(PikaList* self, int index);
 size_t list_getSize(PikaList* self);
 void list_reverse(PikaList* self);
-char* strsFormatArg(Args* out_buffs, char* fmt, Arg* arg);
+PIKA_RES list_insert(PikaList* self, int index, Arg* arg);
+Arg* list_pop(PikaList* list);
+PIKA_RES list_remove(PikaList* list, Arg* arg);
+static inline void list_deinit(PikaList* self) {
+    args_deinit((&((self)->super)));
+}
+
+static inline ArgType list_getType(PikaList* self, int index) {
+    Arg* arg = list_getArg(self, index);
+    return arg_getType(arg);
+}
 
 /* tuple api */
-#define tuple_deinit(self) (list_deinit((&((self)->super))))
-#define tuple_getArg(self, index) (list_getArg((&((self)->super)), (index)))
-#define tuple_getSize(self) (list_getSize((&((self)->super))))
-#define tuple_getInt(self, index) (list_getInt((&((self)->super)), (index)))
-#define tuple_getFloat(self, index) \
-    (list_getFloat((&((self)->super)), (index)))
-#define tuple_getStr(self, index) (list_getStr((&((self)->super)), (index)))
-#define tuple_getPtr(self, index) (list_getPtr((&((self)->super)), (index)))
-#define tuple_getType(self, index) (list_getType((&((self)->super)), (index)))
+static inline void tuple_deinit(PikaTuple* self) {
+    list_deinit((&((self)->super)));
+}
+
+static inline Arg* tuple_getArg(PikaTuple* self, int index) {
+    return list_getArg((&((self)->super)), (index));
+}
+
+static inline size_t tuple_getSize(PikaTuple* self) {
+    return list_getSize((&((self)->super)));
+}
+
+static inline int64_t tuple_getInt(PikaTuple* self, int index) {
+    return list_getInt((&((self)->super)), (index));
+}
+
+static inline pika_float tuple_getFloat(PikaTuple* self, int index) {
+    return list_getFloat((&((self)->super)), (index));
+}
+
+static inline char* tuple_getStr(PikaTuple* self, int index) {
+    return list_getStr((&((self)->super)), (index));
+}
+
+static inline void* tuple_getPtr(PikaTuple* self, int index) {
+    return list_getPtr((&((self)->super)), (index));
+}
+
+static inline ArgType tuple_getType(PikaTuple* self, int index) {
+    return list_getType((&((self)->super)), (index));
+}
 
 PikaList* New_list(void);
 PikaTuple* New_tuple(void);
@@ -190,8 +266,6 @@ PikaDict* args_getDict(Args* self, char* name);
 
 char* strsFormatList(Args* out_buffs, char* fmt, PikaList* list);
 char* args_cacheStr(Args* self, char* str);
-PIKA_RES list_insert(PikaList* self, int index, Arg* arg);
-Arg* list_pop(PikaList* list);
-PIKA_RES list_remove(PikaList* list, Arg* arg);
+char* strsFormatArg(Args* out_buffs, char* fmt, Arg* arg);
 
 #endif

src/dataStack.c

@@ -122,7 +122,7 @@ static int32_t _stack_pushArg(Stack* stack, Arg* arg, PIKA_BOOL is_alloc) {
         obj_refcntInc((PikaObj*)arg_getPtr(arg));
     }
 
-    if arg_isSerialized (arg) {
+    if (arg_isSerialized(arg)) {
         is_big_arg = PIKA_TRUE;
     }