diff --git a/src/PikaObj.h b/src/PikaObj.h index a9516ada5..ccd89bcbf 100644 --- a/src/PikaObj.h +++ b/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, diff --git a/src/PikaVM.c b/src/PikaVM.c index 775bee2e7..90f191000 100644 --- a/src/PikaVM.c +++ b/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) { diff --git a/src/PikaVM.h b/src/PikaVM.h index 46d26f90a..9fe513ebb 100644 --- a/src/PikaVM.h +++ b/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); diff --git a/src/PikaVersion.h b/src/PikaVersion.h index 265ab0bea..813260d45 100644 --- a/src/PikaVersion.h +++ b/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" diff --git a/src/dataArg.h b/src/dataArg.h index f4bfa41a2..02e90a730 100644 --- a/src/dataArg.h +++ b/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 \ No newline at end of file diff --git a/src/dataArgs.h b/src/dataArgs.h index 4be242d50..b5ba01b49 100644 --- a/src/dataArgs.h +++ b/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 +#endif \ No newline at end of file diff --git a/src/dataStack.c b/src/dataStack.c index 6f4076fee..ea4dc07d3 100644 --- a/src/dataStack.c +++ b/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; }