Embedded/pikapython
1
0
Fork 0
mirror of https://gitee.com/Lyon1998/pikapython.git synced 2025-01-29 17:22:56 +08:00
Code Issues Packages Projects Releases Wiki Activity

use pure_stack_arg

Browse Source
This commit is contained in:
pikastech 2022-07-31 17:18:29 +08:00
parent e929bc67db
commit 6be2bc41b6
9 changed files with 224 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
port/linux/.vscode/launch.json vendored
View File

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

1
port/linux/test/VM-test.cpp
View File

@ -183,7 +183,6 @@ TEST(VM, a_1_1) {
int res = args_getInt(globals->list, "a");
obj_deinit(self);
// obj_deinit(globals);
args_deinit(buffs);
ASSERT_EQ(res, 2);
EXPECT_EQ(pikaMemNow(), 0);

2
port/linux/test/pikaMain-test.cpp
View File

@ -984,7 +984,7 @@ TEST(pikaMain, task_run_period_until) {
" if mem_now == 0:\n"
" mem_now = mem.getNow()\n"
" else:\n"
" if mem.getNow() > mem_now + 0.1:\n"
" if mem.getNow() > mem_now + 1:\n"
" mem_lack = True\n"
" print(cformat('%0.8f', mem.getNow()))\n"
"def todo2():\n"

177
src/PikaVM.c
View File

@ -218,9 +218,15 @@ static void VMState_setLReg(VMState* vs, uint8_t index, PikaObj* obj) {
vs->lreg[index] = obj;
}
typedef Arg* (*VM_instruct_handler)(PikaObj* self, VMState* vs, char* data);
typedef Arg* (*VM_instruct_handler)(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack);
static Arg* VM_instruction_handler_NON(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_NON(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
return NULL;
}
@ -340,7 +346,10 @@ Arg* __vm_slice(PikaObj* self, Arg* end, Arg* obj, Arg* start, int step) {
#endif
}
static Arg* VM_instruction_handler_SLC(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_SLC(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
#if PIKA_SYNTAX_SLICE_ENABLE
int arg_num_input = VMState_getInputArgNum(vs);
if (arg_num_input < 2) {
@ -375,18 +384,27 @@ static Arg* VM_instruction_handler_SLC(PikaObj* self, VMState* vs, char* data) {
#endif
}
static Arg* VM_instruction_handler_TRY(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_TRY(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
pika_assert(NULL != vs->try_info);
vs->try_info->try_state = TRY_STATE_TOP;
return NULL;
}
static Arg* VM_instruction_handler_NTR(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_NTR(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
vs->try_info->try_state = TRY_STATE_NONE;
return NULL;
}
static Arg* VM_instruction_handler_NEW(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_NEW(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* origin_arg = obj_getArg(vs->locals, data);
Arg* new_arg = arg_copy(origin_arg);
origin_arg = arg_setType(origin_arg, ARG_TYPE_OBJECT);
@ -394,7 +412,10 @@ static Arg* VM_instruction_handler_NEW(PikaObj* self, VMState* vs, char* data) {
return new_arg;
}
static Arg* VM_instruction_handler_REF(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_REF(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
if (strEqu(data, (char*)"True")) {
return arg_newInt(1);
}
@ -431,7 +452,10 @@ static Arg* VM_instruction_handler_REF(PikaObj* self, VMState* vs, char* data) {
return arg;
}
static Arg* VM_instruction_handler_GER(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_GER(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
PIKA_RES err = (PIKA_RES)vs->try_error_code;
Arg* err_arg = arg_newInt(err);
return err_arg;
@ -685,11 +709,14 @@ static Arg* _vm_create_list_or_tuple(PikaObj* self,
stack_deinit(&stack);
return arg_newPtr(ARG_TYPE_OBJECT, list);
#else
return VM_instruction_handler_NON(self, vs, "");
return VM_instruction_handler_NON(self, vs, "", NULL);
#endif
}
static Arg* VM_instruction_handler_LST(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_LST(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
return _vm_create_list_or_tuple(self, vs, PIKA_TRUE);
}
@ -714,7 +741,10 @@ void __vm_Dict_set(PikaObj* self, Arg* arg, char* key) {
PikaObj* New_PikaStdData_Dict(Args* args);
#endif
static Arg* VM_instruction_handler_DCT(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_DCT(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
#if PIKA_BUILTIN_STRUCT_ENABLE
uint8_t arg_num = VMState_getInputArgNum(vs);
PikaObj* dict = newNormalObj(New_PikaStdData_Dict);
@ -736,11 +766,14 @@ static Arg* VM_instruction_handler_DCT(PikaObj* self, VMState* vs, char* data) {
stack_deinit(&stack);
return arg_newPtr(ARG_TYPE_OBJECT, dict);
#else
return VM_instruction_handler_NON(self, vs, data);
return VM_instruction_handler_NON(self, vs, data, arg_return_stack);
#endif
}
static Arg* VM_instruction_handler_RUN(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_RUN(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Args buffs = {0};
Arg* return_arg = NULL;
VMParameters* sub_locals = NULL;
@ -946,7 +979,10 @@ static char* __get_transferd_str(Args* buffs, char* str, size_t* iout_p) {
return transfered_str;
}
static Arg* VM_instruction_handler_STR(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_STR(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
if (strIsContain(data, '\\')) {
Args buffs = {0};
size_t i_out = 0;
@ -959,7 +995,10 @@ static Arg* VM_instruction_handler_STR(PikaObj* self, VMState* vs, char* data) {
return arg_newStr(data);
}
static Arg* VM_instruction_handler_BYT(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_BYT(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
if (strIsContain(data, '\\')) {
Args buffs = {0};
size_t i_out = 0;
@ -973,7 +1012,10 @@ static Arg* VM_instruction_handler_BYT(PikaObj* self, VMState* vs, char* data) {
return arg_newBytes((uint8_t*)data, strGetSize(data));
}
static Arg* VM_instruction_handler_OUT(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_OUT(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* outArg = stack_popArg(&(vs->stack));
ArgType outArg_type = arg_getType(outArg);
@ -1020,7 +1062,10 @@ static Arg* VM_instruction_handler_OUT(PikaObj* self, VMState* vs, char* data) {
}
/* run as */
static Arg* VM_instruction_handler_RAS(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_RAS(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
if (strEqu(data, "$origin")) {
/* use origin object to run */
obj_removeArg(vs->locals, "__runAs");
@ -1032,7 +1077,10 @@ static Arg* VM_instruction_handler_RAS(PikaObj* self, VMState* vs, char* data) {
return NULL;
}
static Arg* VM_instruction_handler_NUM(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_NUM(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* numArg = New_arg(NULL);
/* hex */
if (data[1] == 'x' || data[1] == 'X') {
@ -1057,17 +1105,26 @@ static Arg* VM_instruction_handler_NUM(PikaObj* self, VMState* vs, char* data) {
return arg_setInt(numArg, "", fast_atoi(data));
}
static Arg* VM_instruction_handler_JMP(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_JMP(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
vs->jmp = fast_atoi(data);
return NULL;
}
static Arg* VM_instruction_handler_SER(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_SER(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
vs->try_error_code = fast_atoi(data);
return NULL;
}
static Arg* VM_instruction_handler_JEZ(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_JEZ(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
int thisBlockDeepth;
thisBlockDeepth = VMState_getBlockDeepthNow(vs);
int jmp_expect = fast_atoi(data);
@ -1115,8 +1172,11 @@ static uint8_t VMState_getInputArgNum(VMState* vs) {
return num;
}
static Arg* VM_instruction_handler_OPT(PikaObj* self, VMState* vs, char* data) {
Arg* outArg = NULL;
static Arg* VM_instruction_handler_OPT(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* outArg = arg_return_stack;
uint8_t input_arg_num = VMState_getInputArgNum(vs);
Arg* arg2 = NULL;
Arg* arg1 = NULL;
@ -1453,15 +1513,24 @@ static Arg* __VM_instruction_handler_DEF(PikaObj* self,
return NULL;
}
static Arg* VM_instruction_handler_DEF(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_DEF(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
return __VM_instruction_handler_DEF(self, vs, data, 0);
}
static Arg* VM_instruction_handler_CLS(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_CLS(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
return __VM_instruction_handler_DEF(self, vs, data, 1);
}
static Arg* VM_instruction_handler_RET(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_RET(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
/* exit jmp signal */
vs->jmp = VM_JMP_EXIT;
Arg* return_arg = stack_popArg(&(vs->stack));
@ -1469,7 +1538,10 @@ static Arg* VM_instruction_handler_RET(PikaObj* self, VMState* vs, char* data) {
return NULL;
}
static Arg* VM_instruction_handler_RIS(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_RIS(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* err_arg = stack_popArg(&(vs->stack));
PIKA_RES err = (PIKA_RES)arg_getInt(err_arg);
VMState_setErrorCode(vs, err);
@ -1479,12 +1551,15 @@ static Arg* VM_instruction_handler_RIS(PikaObj* self, VMState* vs, char* data) {
vs->jmp = VM_JMP_RAISE;
} else if (vs->try_info->try_state == TRY_STATE_INNER) {
vs->try_info->try_result = TRY_RESULT_RAISE;
return VM_instruction_handler_RET(self, vs, data);
return VM_instruction_handler_RET(self, vs, data, arg_return_stack);
}
return NULL;
}
static Arg* VM_instruction_handler_NEL(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_NEL(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
int thisBlockDeepth = VMState_getBlockDeepthNow(vs);
if (0 == vs->ireg[thisBlockDeepth]) {
/* set __else flag */
@ -1493,7 +1568,10 @@ static Arg* VM_instruction_handler_NEL(PikaObj* self, VMState* vs, char* data) {
return NULL;
}
static Arg* VM_instruction_handler_DEL(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_DEL(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
if (_checkLReg(data)) {
uint8_t reg_index = _getLRegIndex(data);
VMState_delLReg(vs, reg_index);
@ -1503,7 +1581,10 @@ static Arg* VM_instruction_handler_DEL(PikaObj* self, VMState* vs, char* data) {
return NULL;
}
static Arg* VM_instruction_handler_EST(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_EST(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* arg = obj_getArg(vs->locals, data);
if (arg == NULL) {
return arg_newInt(0);
@ -1514,19 +1595,28 @@ static Arg* VM_instruction_handler_EST(PikaObj* self, VMState* vs, char* data) {
return arg_newInt(1);
}
static Arg* VM_instruction_handler_BRK(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_BRK(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
/* break jmp signal */
vs->jmp = VM_JMP_BREAK;
return NULL;
}
static Arg* VM_instruction_handler_CTN(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_CTN(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
/* continue jmp signal */
vs->jmp = VM_JMP_CONTINUE;
return NULL;
}
static Arg* VM_instruction_handler_GLB(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_GLB(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
Arg* global_list_buff = NULL;
char* global_list = args_getStr(vs->locals->list, "__gl");
/* create new global_list */
@ -1547,7 +1637,10 @@ exit:
return NULL;
}
static Arg* VM_instruction_handler_IMP(PikaObj* self, VMState* vs, char* data) {
static Arg* VM_instruction_handler_IMP(PikaObj* self,
VMState* vs,
char* data,
Arg* arg_return_stack) {
/* the module is already imported, skip. */
if (obj_isArgExist(self, data)) {
return NULL;
@ -1582,15 +1675,23 @@ static int pikaVM_runInstructUnit(PikaObj* self,
VMState* vs,
InstructUnit* ins_unit) {
enum Instruct instruct = instructUnit_getInstruct(ins_unit);
Arg* return_arg;
Arg return_arg_stack = {0};
uint8_t arg_buff[PIKA_ARG_BUFF_SIZE];
arg_init_stack(&return_arg_stack, arg_buff, PIKA_ARG_BUFF_SIZE);
Arg* return_arg = &return_arg_stack;
// char invode_deepth1_str[2] = {0};
int32_t pc_next = vs->pc + instructUnit_getSize();
char* data = VMState_getConstWithInstructUnit(vs, ins_unit);
/* run instruct */
pika_assert(NULL != vs->try_info);
return_arg = VM_instruct_handler_table[instruct](self, vs, data);
return_arg =
VM_instruct_handler_table[instruct](self, vs, data, &return_arg_stack);
if (NULL != return_arg) {
stack_pushArg(&(vs->stack), return_arg);
if (return_arg == &return_arg_stack) {
stack_pushArg_noalloc(&(vs->stack), return_arg);
} else {
stack_pushArg(&(vs->stack), return_arg);
}
}
goto nextLine;
nextLine:

42
src/dataArg.c
View File

@ -57,9 +57,11 @@ static Arg* arg_init_hash(Hash nameHash,
self->size = size;
self->name_hash = nameHash;
self->type = type;
__platform_memset(self->content, 0, aline_by(size, sizeof(uint32_t)));
self->is_serialized = 1;
__platform_memset(arg_getContent(self), 0,
aline_by(size, sizeof(uint32_t)));
if (NULL != content) {
__platform_memcpy(self->content, content, size);
__platform_memcpy(arg_getContent(self), content, size);
}
return self;
@ -74,6 +76,14 @@ static Arg* arg_init(char* name,
return arg_init_hash(nameHash, type, content, size, next);
}
void arg_init_stack(Arg* self, uint8_t* buffer, uint32_t size) {
self->buffer = buffer;
self->size = size;
self->type = ARG_TYPE_UNDEF;
self->name_hash = 0;
self->is_serialized = 0;
}
uint32_t arg_totleSize(Arg* self) {
return ((Arg*)self)->size + sizeof(Arg);
}
@ -93,8 +103,8 @@ Arg* arg_setContent(Arg* self, uint8_t* content, uint32_t size) {
}
/* only copy */
if (arg_getSize(self) == size) {
__platform_memcpy(((Arg*)self)->content, content, size);
if (arg_getSize(self) >= size) {
__platform_memcpy(arg_getContent((Arg*)self), content, size);
return self;
}
@ -214,7 +224,13 @@ void* arg_getHeapStructDeinitFun(Arg* self) {
}
Arg* arg_setInt(Arg* self, char* name, int64_t val) {
return arg_init(name, ARG_TYPE_INT, (uint8_t*)&val, sizeof(val), NULL);
if (NULL == self) {
return arg_init(name, ARG_TYPE_INT, (uint8_t*)&val, sizeof(val), NULL);
}
self = arg_setContent(self, (uint8_t*)&val, sizeof(val));
self = arg_setType(self, ARG_TYPE_INT);
self = arg_setName(self, name);
return self;
}
Arg* arg_setNull(Arg* self) {
@ -222,7 +238,14 @@ Arg* arg_setNull(Arg* self) {
}
Arg* arg_setFloat(Arg* self, char* name, double val) {
return arg_init(name, ARG_TYPE_FLOAT, (uint8_t*)&val, sizeof(val), NULL);
if (NULL == self) {
return arg_init(name, ARG_TYPE_FLOAT, (uint8_t*)&val, sizeof(val),
NULL);
}
self = arg_setContent(self, (uint8_t*)&val, sizeof(val));
self = arg_setType(self, ARG_TYPE_FLOAT);
self = arg_setName(self, name);
return self;
}
double arg_getFloat(Arg* self) {
@ -230,7 +253,7 @@ double arg_getFloat(Arg* self) {
return -999.999;
}
return *(double*)self->content;
return *(double*)arg_getContent(self);
}
Arg* arg_setPtr(Arg* self, char* name, ArgType type, void* pointer) {
@ -249,14 +272,14 @@ int64_t arg_getInt(Arg* self) {
if (NULL == arg_getContent(self)) {
return -999999;
}
return *(int64_t*)self->content;
return *(int64_t*)arg_getContent(self);
}
void* arg_getPtr(Arg* self) {
if (NULL == arg_getContent(self)) {
return NULL;
}
return *(void**)self->content;
return *(void**)arg_getContent(self);
}
char* arg_getStr(Arg* self) {
return (char*)arg_getContent(self);
@ -390,4 +413,3 @@ void arg_deinit(Arg* self) {
/* free the ref */
arg_freeContent(self);
}

11
src/dataArg.h
View File

@ -57,9 +57,13 @@ typedef void (*StructDeinitFun)(void* struct_);
typedef struct Arg Arg;
struct Arg {
Arg* next;
union {
Arg* next;
uint8_t* buffer;
};
uint32_t size;
uint8_t type;
PIKA_BOOL is_serialized;
Hash name_hash;
uint8_t content[];
};
@ -126,7 +130,8 @@ uint8_t argType_isObject(ArgType type);
#define arg_getNext(self) ((self)->next)
#define arg_getSize(self) ((self)->size)
#define arg_getContent(self) ((self)->content)
#define arg_getContent(self) \
((self)->is_serialized ? (self)->content : ((self)->buffer))
#define arg_getNext(self) ((self)->next)
#define arg_setNext(self, __next) ((self)->next = (__next))
@ -134,3 +139,5 @@ uint8_t argType_isObject(ArgType type);
((type) == ARG_TYPE_OBJECT || (type) == ARG_TYPE_OBJECT_NEW)
#endif
void arg_init_stack(Arg* self, uint8_t* buffer, uint32_t size);

47
src/dataStack.c
View File

@ -74,7 +74,14 @@ void stack_pushPyload(Stack* stack, Arg* content, size_t size) {
while (1) {
}
}
__platform_memcpy(stack->sp, content, size);
if (content->is_serialized) {
__platform_memcpy(stack->sp, content, size);
} else {
content->is_serialized = 1;
__platform_memcpy(stack->sp, content, sizeof(Arg));
__platform_memcpy(stack->sp + sizeof(Arg), content->buffer,
size - sizeof(Arg));
}
stack->sp += size;
}
@ -83,7 +90,7 @@ uint8_t* stack_popPyload(Stack* stack, size_t size) {
return stack->sp;
}
int32_t stack_pushArg(Stack* stack, Arg* arg) {
static int32_t _stack_pushArg(Stack* stack, Arg* arg, PIKA_BOOL is_alloc) {
stack->top++;
size_t size = arg_getTotleSize(arg);
@ -98,22 +105,39 @@ int32_t stack_pushArg(Stack* stack, Arg* arg) {
}
stack_pushSize(stack, size);
stack_pushPyload(stack, arg, size);
arg_deinit(arg);
if (is_alloc) {
arg_deinit(arg);
} else {
arg_deinitHeap(arg);
}
return 0;
}
int32_t stack_pushArg(Stack* stack, Arg* arg) {
return _stack_pushArg(stack, arg, PIKA_TRUE);
}
int32_t stack_pushArg_noalloc(Stack* stack, Arg* arg) {
return _stack_pushArg(stack, arg, PIKA_FALSE);
}
int32_t stack_pushStr(Stack* stack, char* str) {
Arg* newArg = arg_newStr(str);
return stack_pushArg(stack, newArg);
}
Arg* stack_popArg(Stack* stack) {
Arg* _stack_popArg(Stack* stack, Arg* arg_dict, PIKA_BOOL is_alloc) {
if (stack->top == 0) {
return NULL;
}
stack->top--;
int32_t size = stack_popSize(stack);
Arg* arg = arg_copy((Arg*)stack_popPyload(stack, size));
Arg* arg = NULL;
if (is_alloc) {
arg = arg_copy((Arg*)stack_popPyload(stack, size));
} else {
arg_copy_noalloc((Arg*)stack_popPyload(stack, size), arg_dict);
}
ArgType type = arg_getType(arg);
/* decrase ref_cnt */
if (argType_isObject(type)) {
@ -122,13 +146,12 @@ Arg* stack_popArg(Stack* stack) {
return arg;
}
void stack_popArg_noalloc(Stack* stack, Arg* arg_dict){
if (stack->top == 0) {
return;
}
stack->top--;
int32_t size = stack_popSize(stack);
arg_copy_noalloc((Arg*)stack_popPyload(stack, size), arg_dict);
Arg* stack_popArg(Stack* stack) {
return _stack_popArg(stack, NULL, PIKA_TRUE);
}
void stack_popArg_noalloc(Stack* stack, Arg* arg_dict) {
_stack_popArg(stack, arg_dict, PIKA_FALSE);
}
char* stack_popStr(Stack* stack, char* outBuff) {

4
src/dataStack.h
View File

@ -42,8 +42,10 @@ int32_t stack_deinit(Stack* stack);
int32_t stack_pushStr(Stack* stack, char* str);
char* stack_popStr(Stack* stack, char* outBuff);
Arg* stack_popArg(Stack* stack);
int32_t stack_pushArg(Stack* stack, Arg* arg);
int32_t stack_pushArg_noalloc(Stack* stack, Arg* arg);
Arg* stack_popArg(Stack* stack);
void stack_popArg_noalloc(Stack* stack, Arg* arg_dict);
int32_t stack_getTop(Stack* stack);
int32_t stack_init(Stack* stack);
int32_t stack_popSize(Stack* stack);

4
src/pika_config_valid.h
View File

@ -250,6 +250,10 @@
#define PIKA_REGIST_SIZE 10
#endif
#ifndef PIKA_ARG_BUFF_SIZE
#define PIKA_ARG_BUFF_SIZE sizeof(double)
#endif
/* configuration validation */
#endif