args_heapStuct is tested ok

port/linux/test/args-test.cpp

@@ -1,5 +1,6 @@
 #include "gtest/gtest.h"
 extern "C" {
+#include "PikaVM.h"
 #include "dataArgs.h"
 #include "dataString.h"
 }
@@ -148,15 +149,16 @@ TEST(args, test12) {
 struct test {
     int a;
     float b;
+    int c;
 };
 TEST(args, struct_) {
     Args* args = New_args(NULL);
-    struct test test_struct = {1, 2.2};
+    struct test test_struct = {1, 2.2, 4};
-    args_setStruct(args, (char*)"test", &test_struct, sizeof(struct test));
+    args_setStruct(args, (char*)"test", test_struct);
-    struct test test_struct_out;
+    struct test* out_struct = (struct test*)args_getStruct(args, (char*)"test");
-    args_getStruct(args, (char*)"test", &test_struct_out);
+    EXPECT_EQ(out_struct->a, 1);
-    EXPECT_EQ(test_struct_out.a, 1);
+    EXPECT_FLOAT_EQ(out_struct->b, 2.2);
-    EXPECT_FLOAT_EQ(test_struct_out.b, 2.2);
+    EXPECT_EQ(out_struct->c, 4);
     args_deinit(args);
     EXPECT_EQ(pikaMemNow(), 0);
 }
@@ -194,4 +196,19 @@ TEST(args, int_float_convert) {
     /* check memory */
     args_deinit(args);
     EXPECT_EQ(pikaMemNow(), 0);
-}
+}
+
+TEST(args, heap_struct) {
+    ByteCodeFrame bytecode_frame;
+    byteCodeFrame_init(&bytecode_frame);
+    bytecode_frame.const_pool.size = 100;
+    Args* args = New_args(NULL);
+    args_setHeapStruct(args, (char*)"a", bytecode_frame, byteCodeFrame_deinit);
+    ByteCodeFrame* bf_out =
+        (ByteCodeFrame*)args_getHeapStruct(args, (char*)"a");
+    /* assert */
+    EXPECT_EQ(bf_out->const_pool.size, 100);
+    /* check memory */
+    args_deinit(args);
+    EXPECT_EQ(pikaMemNow(), 0);
+}

src/PikaObj.c

@@ -734,6 +734,8 @@ char* method_getStr(Args* args, char* argName) {
     return args_getStr(args, argName);
 }
 
+
+
 PikaObj* New_PikaObj(void) {
     PikaObj* self = pikaMalloc(sizeof(PikaObj));
     /* List */

src/PikaParser.c

@@ -1149,13 +1149,6 @@ exit:
     return ASM;
 }
 
-static char* ASM_loadASM(Args* outBuffs, Arg* pikaAsmBuff, uint8_t isToFlash) {
-    if (isToFlash) {
-        return __platform_load_pikaAsm();
-    }
-    return strsCopy(outBuffs, arg_getStr(pikaAsmBuff));
-}
-
 char* Parser_multiLineToAsmOrByteCode(Args* outBuffs,
                                       ByteCodeFrame* bytecode_frame,
                                       char* multi_line) {

src/dataArg.c

@@ -31,10 +31,6 @@
 #include "dataString.h"
 #include "stdlib.h"
 
-void arg_deinit(Arg* self) {
-    arg_freeContent(self);
-}
-
 uint16_t arg_getTotleSize(Arg* self) {
     return content_totleSize(self);
 }
@@ -165,10 +161,33 @@ Arg* arg_setStruct(Arg* self,
         return NULL;
     }
     Arg* struct_arg = arg_setContent(NULL, (uint8_t*)struct_ptr, struct_size);
+    struct_arg = arg_setType(struct_arg, ARG_TYPE_STRUCT);
     struct_arg = arg_setName(struct_arg, name);
     return struct_arg;
 }
 
+Arg* arg_setHeapStruct(Arg* self,
+                       char* name,
+                       void* struct_ptr,
+                       uint32_t struct_size,
+                       void* struct_deinit_fun) {
+    if (NULL == struct_ptr) {
+        return NULL;
+    }
+    Arg* struct_arg =
+        arg_setContent(NULL, (uint8_t*)&struct_deinit_fun, sizeof(void*));
+    struct_arg = arg_append(struct_arg, (uint8_t*)struct_ptr, struct_size);
+    struct_arg = arg_setType(struct_arg, ARG_TYPE_HEAP_STRUCT);
+    struct_arg = arg_setName(struct_arg, name);
+    return struct_arg;
+}
+
+void* arg_getHeapStructDeinitFun(Arg* self) {
+    void* deinit_fun = NULL;
+    __platform_memcpy(&deinit_fun, arg_getContent(self), sizeof(void*));
+    return deinit_fun;
+}
+
 Arg* arg_setName(Arg* self, char* name) {
     return content_setName(self, name);
 }
@@ -279,3 +298,17 @@ Arg* arg_append(Arg* arg_in, void* new_content, size_t new_size) {
     arg_deinit(arg_in);
     return arg_out;
 }
+
+void* arg_getHeapStruct(Arg* self) {
+    return arg_getContent(self) + sizeof(void*);
+}
+
+void arg_deinit(Arg* self) {
+    if (arg_getType(self) == ARG_TYPE_HEAP_STRUCT) {
+        /* deinit heap strcut */
+        StructDeinitFun struct_deinit_fun =
+            (StructDeinitFun)arg_getHeapStructDeinitFun(self);
+        struct_deinit_fun(arg_getHeapStruct(self));
+    }
+    arg_freeContent(self);
+}

src/dataArg.h

@@ -44,8 +44,13 @@ typedef enum {
     ARG_TYPE_NATIVE_METHOD,
     ARG_TYPE_OBJECT_METHOD,
     ARG_TYPE_STATIC_METHOD,
+    ARG_TYPE_STRUCT,
+    ARG_TYPE_HEAP_STRUCT,
 } ArgType;
 
+
+typedef void (*StructDeinitFun)(void* struct_);
+
 typedef struct __arg __arg;
 struct __arg {
     __arg* next;
@@ -118,5 +123,11 @@ Arg* arg_setStruct(Arg* self,
                    char* name,
                    void* struct_ptr,
                    uint32_t struct_size);
+Arg* arg_setHeapStruct(Arg* self,
+                       char* name,
+                       void* struct_ptr,
+                       uint32_t struct_size,
+                       void* struct_deinit_fun);
+void* arg_getHeapStruct(Arg* self);
 
 #endif

src/dataArgs.c

@@ -159,10 +159,10 @@ int32_t args_copyArg(Args* self, Arg* argToBeCopy) {
     return 0;
 }
 
-int32_t args_setStruct(Args* self,
+int32_t args_setStructWithSize(Args* self,
-                       char* name,
+                               char* name,
-                       void* struct_ptr,
+                               void* struct_ptr,
-                       uint32_t struct_size) {
+                               uint32_t struct_size) {
     Arg* struct_arg = arg_setStruct(NULL, name, struct_ptr, struct_size);
     if (NULL == struct_arg) {
         /* faild */
@@ -172,11 +172,29 @@ int32_t args_setStruct(Args* self,
     return 0;
 }
 
-void* args_getStruct(Args* self, char* name, void* struct_out) {
+void* args_getStruct(Args* self, char* name) {
     Arg* struct_arg = args_getArg(self, name);
-    uint32_t struct_size = arg_getContentSize(struct_arg);
+    return arg_getContent(struct_arg);
-    return __platform_memcpy(struct_out, arg_getContent(struct_arg),
+}
-                             struct_size);
+
+void* args_getHeapStruct(Args* self, char* name) {
+    Arg* struct_arg = args_getArg(self, name);
+    return arg_getHeapStruct(struct_arg);
+}
+
+int32_t args_setHeapStructWithSize(Args* self,
+                                   char* name,
+                                   void* struct_ptr,
+                                   uint32_t struct_size,
+                                   void* struct_deinit_fun) {
+    Arg* struct_arg = arg_setHeapStruct(NULL, name, struct_ptr, struct_size,
+                                        struct_deinit_fun);
+    if (NULL == struct_arg) {
+        /* faild */
+        return 1;
+    }
+    args_setArg(self, struct_arg);
+    return 0;
 }
 
 int32_t args_copyArgByName(Args* self, char* name, Args* directArgs) {

src/dataArgs.h

@@ -76,21 +76,34 @@ void args_bindStr(Args* self, char* name, char** stringPtr);
 void args_bind(Args* self, char* type, char* name, void* pointer);
 char* args_print(Args* self, char* name);
 
-int32_t args_setStruct(Args* self,
+int32_t args_setStructWithSize(Args* self,
-                       char* name,
+                               char* name,
-                       void* struct_ptr,
+                               void* struct_ptr,
-                       uint32_t struct_size);
+                               uint32_t struct_size);
-void* args_getStruct(Args* self, char* name, void* struct_out);
+
+int32_t args_setHeapStructWithSize(Args* self,
+                                   char* name,
+                                   void* struct_ptr,
+                                   uint32_t struct_size,
+                                   void* struct_deinit_fun);
+
+#define args_setStruct(Args_p_self, char_p_name, struct_)            \
+    args_setStructWithSize((Args_p_self), (char_p_name), &(struct_), \
+                           sizeof(struct_))
+
+#define args_setHeapStruct(Args_p_self, char_p_name, struct_,            \
+                           struct_deinit_fun)                            \
+    args_setHeapStructWithSize((Args_p_self), (char_p_name), &(struct_), \
+                               sizeof(struct_), (void*)struct_deinit_fun)
+
+void* args_getStruct(Args* self, char* name);
 
 int32_t args_set(Args* self, char* name, char* valueStr);
 int32_t args_setObjectWithClass(Args* self,
                                 char* objectName,
                                 char* className,
                                 void* objectPtr);
-int32_t args_setPtrWithType(Args* self,
+int32_t args_setPtrWithType(Args* self, char* name, ArgType type, void* objPtr);
-                            char* name,
-                            ArgType type,
-                            void* objPtr);
 int32_t args_foreach(Args* self,
                      int32_t (*eachHandle)(Arg* argEach, Args* handleArgs),
                      Args* handleArgs);
@@ -99,6 +112,7 @@ char* args_getBuff(Args* self, int32_t size);
 uint8_t args_setLiteral(Args* self, char* targetArgName, char* literal);
 int args_pushArg(Args* self, Arg* arg);
 Arg* args_getArg_index(Args* self, int index);
+void* args_getHeapStruct(Args* self, char* name);
 
 Args* New_args(Args* args);
 #endif