add git core as nomal file

src/package/pikascript/pikascript-core/.gitignore

@@ -0,0 +1,2 @@
+*kite*
+*.o

src/package/pikascript/pikascript-core/BaseObj.c

@@ -0,0 +1,168 @@
+#include "PikaObj.h"
+#include "TinyObj.h"
+#include "BaseObj.h"
+#include "dataMemory.h"
+#include "dataString.h"
+#include "dataStrs.h"
+
+static void *getClassPtr(PikaObj *classObj, char *classPath)
+{
+    char *ptrPath = classPath;
+    return obj_getPtr(classObj, ptrPath);
+}
+
+int32_t obj_newObjByFun(PikaObj *self, char *objName, char *className, void *newFunPtr)
+{
+    /* class means subprocess init */
+    Args *buffs = New_strBuff();
+
+    /* class means subprocess init */
+    char *mataObjName = strsAppend(buffs, "[mate]", objName);
+    obj_setPtr(self, mataObjName, newFunPtr);
+    /* add void process Ptr, no inited */
+    args_setObjectWithClass(self->attributeList, objName, className, NULL);
+
+    args_deinit(buffs);
+    return 0;
+}
+
+int32_t sysObj_setObjbyClass(PikaObj *self, char *objName, char *classPath)
+{
+    /* class means subprocess init */
+    Args *buffs = New_strBuff();
+    PikaObj *classLoader = obj_getObj(self, "__classLoader", 0);
+    void *newFunPtr = getClassPtr(classLoader, classPath);
+
+    /* class means subprocess init */
+    char *mataObjName = strsAppend(buffs, "[mate]", objName);
+    obj_setPtr(self, mataObjName, newFunPtr);
+    /* add void process Ptr, no inited */
+    args_setObjectWithClass(self->attributeList, objName, classPath, NULL);
+
+    args_deinit(buffs);
+    return 0;
+}
+
+static int32_t storeClassInfo(PikaObj *self, Args *buffs, char *classPath, void *classPtr)
+{
+    int32_t res = 0;
+    PikaObj *classHost = obj_getObj(self, classPath, 1);
+    if (NULL == classHost)
+    {
+        res = 1;
+        goto exit;
+    }
+    char *className = strsGetLastToken(buffs, classPath, '.');
+    char *classStoreName = className;
+    obj_setPtr(classHost, classStoreName, classPtr);
+    res = 0;
+    goto exit;
+exit:
+    return res;
+}
+
+int32_t obj_import(PikaObj *self, char *className, NewFun classPtr)
+{
+    PikaObj *classLoader = obj_getObj(self, "__classLoader", 0);
+    Args *buffs = New_args(NULL);
+    int32_t res = storeClassInfo(classLoader, buffs, className, classPtr);
+    args_deinit(buffs);
+    return res;
+}
+
+int32_t obj_newObj(PikaObj *self, char *objPath, char *classPath)
+{
+    PikaObj *classLoader = obj_getObj(self, "__classLoader", 0);
+    Args *buffs = New_args(NULL);
+    int res = 0;
+    void *NewObjPtr = getClassPtr(classLoader, classPath);
+    if (NULL == NewObjPtr)
+    {
+        res = 1;
+        goto exit;
+    }
+    PikaObj *objHost = obj_getObj(self, objPath, 1);
+    if (NULL == objHost)
+    {
+        res = 2;
+        goto exit;
+    }
+    char *objName = strsGetLastToken(buffs, objPath, '.');
+    obj_newObjByFun(objHost, objName, classPath, NewObjPtr);
+    res = 0;
+    goto exit;
+
+    exit:
+    args_deinit(buffs);
+    return res;
+}
+
+static void print(PikaObj *self, Args *args)
+{
+    obj_setErrorCode(self, 0);
+    char *res = args_print(args, "val");
+    if (NULL == res)
+    {
+        obj_setSysOut(self, "[error] print: can not print32_t val");
+        obj_setErrorCode(self, 1);
+        return;
+    }
+    /* not empty */
+    obj_setSysOut(self, res);
+}
+
+static void set(PikaObj *self, Args *args)
+{
+    obj_setErrorCode(self, 0);
+    char *argPath = method_getStr(args, "argPath");
+    if (obj_isArgExist(self, argPath))
+    {
+        /* update arg */
+        char *valStr = args_print(args, "val");
+        int32_t res = obj_set(self, argPath, valStr);
+        if (1 == res)
+        {
+            obj_setSysOut(self, "[error] set: arg no found.");
+            obj_setErrorCode(self, 1);
+            return;
+        }
+        if (2 == res)
+        {
+            obj_setSysOut(self, "[error] set: type not match.");
+            obj_setErrorCode(self, 1);
+            return;
+        }
+        if (3 == res)
+        {
+            obj_setSysOut(self, "[error] set: object not found.");
+            obj_setErrorCode(self, 1);
+            return;
+        }
+        return;
+    }
+    /* new arg */
+    Arg *val = args_getArg(args, "val");
+    Arg *newArg = arg_copy(val);
+    char *argName = strsGetLastToken(args, argPath, '.');
+    newArg = arg_setName(newArg, argName);
+    int32_t res = obj_setArg(self, argPath, newArg);
+    if (res == 1)
+    {
+        obj_setSysOut(self, "[error] set: object not found.");
+        obj_setErrorCode(self, 1);
+    }
+    arg_deinit(newArg);
+    newArg = NULL;
+    return;
+}
+
+
+PikaObj *New_BaseObj(Args *args)
+{
+    PikaObj *self = New_TinyObj(args);
+    obj_setObjWithoutClass(self, "__classLoader", New_TinyObj);
+    obj_getObj(self, "__classLoader", 0);
+    class_defineMethod(self, "print(val:any)", print);
+    class_defineMethod(self, "set(argPath:str, val:any)", set);
+    return self;
+}

src/package/pikascript/pikascript-core/BaseObj.h

@@ -0,0 +1,11 @@
+#ifndef _PikaObj_baseObj__H
+#define _PikaObj_baseObj__H
+#include "dataMemory.h"
+#include "PikaObj.h"
+#include "TinyObj.h"
+
+PikaObj *New_BaseObj(Args *args);
+int32_t obj_newObj(PikaObj *self, char *objPath, char *classPath);
+int32_t obj_import(PikaObj *self, char *className, NewFun classPtr);
+int32_t obj_newObjByFun(PikaObj *self, char *objName, char *className, void *newFunPtr);
+#endif

src/package/pikascript/pikascript-core/CMakeLists.txt

@@ -0,0 +1,9 @@
+#设置 BINARY 为项目名IndexProject
+set(BINARY ${CMAKE_PROJECT_NAME})
+ 
+file(GLOB_RECURSE SOURCES LIST_DIRECTORIES true *.h *.c)
+set(SOURCES ${SOURCES})
+
+add_library(${BINARY}-core 
+            STATIC 
+            ${SOURCES})

src/package/pikascript/pikascript-core/PikaObj.h

@@ -0,0 +1,83 @@
+#ifndef _Process__H
+#define _Process__H
+#include "dataArgs.h"
+#include "dataLink.h"
+#include "dataMemory.h"
+#include "method.h"
+typedef struct PikaObj_t PikaObj;
+typedef PikaObj *(*NewFun)(Args *args);
+typedef PikaObj *(*InitFun)(PikaObj *self, Args *args);
+
+struct PikaObj_t
+{
+    /* list */
+    Args *attributeList;
+    char *name;
+};
+
+/* operation */
+int32_t obj_deinit(PikaObj *self);
+int32_t obj_init(PikaObj *self, Args *args);
+int32_t obj_update(PikaObj *self);
+int32_t obj_enable(PikaObj *self);
+int32_t obj_disable(PikaObj *self);
+
+// arg type operations
+int32_t obj_setInt(PikaObj *self, char *argPath, int64_t val);
+int32_t obj_setPtr(PikaObj *self, char *argPath, void *pointer);
+int32_t obj_setFloat(PikaObj *self, char *argPath, float value);
+int32_t obj_setStr(PikaObj *self, char *argPath, char *str);
+int32_t obj_setArg(PikaObj *self, char *argPath, Arg *arg);
+
+void *obj_getPtr(PikaObj *self, char *argPath);
+float obj_getFloat(PikaObj *self, char *argPath);
+char *obj_getStr(PikaObj *self, char *argPath);
+int64_t obj_getInt(PikaObj *self, char *argPath);
+Arg *obj_getArg(PikaObj *self, char *argPath);
+
+// arg general operations
+int32_t obj_bind(PikaObj *self, char *type, char *name, void *pointer);
+int32_t obj_set(PikaObj *self, char *name, char *valStr);
+
+int32_t obj_bindInt(PikaObj *self, char *name, int32_t *valPtr);
+int32_t obj_bindFloat(PikaObj *self, char *name, float *valPtr);
+int32_t obj_bindString(PikaObj *self, char *name, char **valPtr);
+
+char *obj_print(PikaObj *self, char *name);
+
+// args operations
+int32_t obj_load(PikaObj *self, Args *args, char *name);
+
+// subObject
+int32_t obj_addOther(PikaObj *self, char *subObjectName, void *new_projcetFun);
+int32_t obj_setObjWithoutClass(PikaObj *self, char *subObjectName, void *new_projcetFun);
+PikaObj *obj_getObjDirect(PikaObj *self, char *name);
+PikaObj *obj_getObj(PikaObj *self, char *processPathectory, int32_t deepth);
+
+// subProcess
+int32_t obj_freeObj(PikaObj *self, char *subObjectName);
+
+/* method */
+int32_t class_defineMethod(PikaObj *self,
+                           char *declearation,
+                           void (*methodPtr)(PikaObj *self, Args *args));
+
+void obj_runNoRes(PikaObj *slef, char *cmd);
+void obj_run(PikaObj *self, char *cmd);
+Args *obj_runDirect(PikaObj *self, char *cmd);
+int32_t obj_removeArg(PikaObj *self, char *argPath);
+int32_t obj_isArgExist(PikaObj *self, char *argPath);
+PikaObj *obj_getClassObjByNewFun(PikaObj *self, char *name, NewFun newClassFun);
+PikaObj *newRootObj(char *name, NewFun newObjFun);
+
+void obj_setErrorCode(PikaObj *self, int32_t errCode);
+int32_t obj_getErrorCode(PikaObj *self);
+void obj_setSysOut(PikaObj *self, char *str);
+char *args_getSysOut(Args *args);
+void args_setErrorCode(Args *args, int32_t errCode);
+int32_t args_getErrorCode(Args *args);
+void args_setSysOut(Args *args, char *str);
+char *obj_getSysOut(PikaObj *self);
+void obj_sysPrintf(PikaObj *self, char *fmt, ...);
+
+#endif

src/package/pikascript/pikascript-core/README.md

@@ -0,0 +1 @@
+# PikaScript 运行时内核

src/package/pikascript/pikascript-core/TinyObj.c

@@ -0,0 +1,34 @@
+#include "PikaObj.h"
+
+void _UpdateHandle(PikaObj *self)
+{
+    // override the handle function here
+}
+
+void _beforDinit(PikaObj *self)
+{
+    /* override in user code */
+}
+
+PikaObj *New_TinyObj(Args *args)
+{
+    PikaObj *self = pikaMalloc(sizeof(PikaObj));
+
+    /* List */
+    self->attributeList = New_args(NULL);
+
+    /* attribute */
+    obj_setPtr(self, "__context", self);
+    obj_setStr(self, "__name", "root");
+
+    /* load */
+    if (NULL != args)
+    {
+        obj_load(self, args, "__name");
+        obj_load(self, args, "__context");
+    }
+
+    /* hard attribute */
+    self->name = obj_getStr(self, "__name");
+    return self;
+}

src/package/pikascript/pikascript-core/TinyObj.h

@@ -0,0 +1,5 @@
+#ifndef __TYNYOBJ__H
+#define __TYNYOBJ__H
+#include "PikaObj.h"
+PikaObj *New_TinyObj(Args *args);
+#endif

src/package/pikascript/pikascript-core/dataArg.c

@@ -0,0 +1,373 @@
+#include "dataArg.h"
+#include "dataArgs.h"
+#include "dataMemory.h"
+#include "dataString.h"
+#include "stdlib.h"
+#include <stdint.h>
+
+void arg_deinit(Arg *self)
+{
+    arg_freeContent(self);
+}
+
+uint16_t arg_getTotleSize(Arg *self)
+{
+    return content_totleSize(self);
+}
+
+uint16_t content_sizeOffset(uint8_t *self)
+{
+    const uint8_t nextLength = sizeof(uint8_t *);
+    return nextLength;
+}
+
+uint16_t content_getSize(uint8_t *self)
+{
+    uint16_t size = 0;
+    // add 0x30 to avoid 0
+    size += self[content_sizeOffset(self) + 1];
+    size = (size << 8);
+    size += self[content_sizeOffset(self)];
+    return size;
+}
+
+void content_setNext(uint8_t *self, uint8_t *next)
+{
+    uint8_t *nextDir = self + content_nextOffset(self);
+    uint64_t pointerTemp = (uint64_t)next;
+    for (uint32_t i = 0; i < sizeof(uint8_t *); i++)
+    {
+        // aboid \0
+        nextDir[i] = pointerTemp;
+        pointerTemp = pointerTemp >> 8;
+    }
+}
+
+uint8_t *content_init(char *name, char *type, uint8_t *content, uint16_t size, uint8_t *next)
+{
+    const uint8_t nextLength = sizeof(uint8_t *);
+    const uint8_t sizeLength = 2;
+    uint16_t nameSize = strGetSize(name);
+    uint16_t typeSize = strGetSize(type);
+    uint8_t *self = (uint8_t *)pikaMalloc(nextLength +
+                                          sizeLength +
+                                          nameSize + 1 +
+                                          size +
+                                          typeSize + 1);
+
+    uint8_t *nextDir = self;
+    uint8_t *sizeDir = nextDir + nextLength;
+    uint8_t *nameDir = sizeDir + sizeLength;
+    uint8_t *contentDir = nameDir + nameSize + 1;
+    uint8_t *typeDir = contentDir + size;
+
+    memcpy(nameDir, name, nameSize + 1);
+    memcpy(typeDir, type, typeSize + 1);
+    sizeDir[0] = size;
+    sizeDir[1] = size >> 8;
+    if (NULL != content)
+    {
+        memcpy(contentDir, content, size);
+    }
+    else
+    {
+        memset(contentDir, 0, size);
+    }
+
+    uint64_t pointerTemp = (uint64_t)next;
+    for (uint32_t i = 0; i < sizeof(uint8_t *); i++)
+    {
+        // aboid \0
+        nextDir[i] = pointerTemp;
+        pointerTemp = pointerTemp >> 8;
+    }
+
+    return self;
+}
+
+uint16_t content_totleSize(uint8_t *self)
+{
+    char *name = content_getName(self);
+    char *type = content_getType(self);
+    const uint8_t sizeLenth = 2;
+    const uint8_t nextLength = sizeof(uint8_t *);
+    uint16_t size = content_getSize(self);
+    return size + strGetSize(name) + 1 + strGetSize(type) + 1 + sizeLenth + nextLength;
+}
+
+void arg_freeContent(Arg *self)
+{
+    if (NULL != self)
+    {
+        content_deinit(self);
+    }
+}
+
+uint8_t content_nameOffset(uint8_t *self)
+{
+    const uint8_t nextLength = sizeof(uint8_t *);
+    const uint8_t sizeLength = 2;
+    return nextLength + sizeLength;
+}
+
+char *content_getName(uint8_t *self)
+{
+    return (char *)self + content_nameOffset(self);
+}
+
+uint8_t *content_deinit(uint8_t *self)
+{
+    uint16_t totleSize = content_totleSize(self);
+    pikaFree(self, totleSize);
+    return 0;
+}
+
+uint8_t *content_setContent(uint8_t *self, uint8_t *content, uint16_t size)
+{
+    if (NULL == self)
+    {
+        return content_init("", "", content, size, NULL);
+    }
+    char *name = content_getName(self);
+    char *type = content_getType(self);
+    uint8_t *next = content_getNext(self);
+    uint8_t *newContent = content_init(name, type, content, size, next);
+    content_deinit(self);
+    return newContent;
+}
+
+uint8_t *content_setName(uint8_t *self, char *name)
+{
+    if (NULL == self)
+    {
+        return content_init(name, "", NULL, 0, NULL);
+    }
+    char *type = content_getType(self);
+    uint8_t *content = content_getContent(self);
+    uint16_t size = content_getSize(self);
+    uint8_t *next = content_getNext(self);
+    uint8_t *newContent = content_init(name, type, content, size, next);
+    content_deinit(self);
+    return newContent;
+}
+
+uint8_t *content_setType(uint8_t *self, char *type)
+{
+    if (NULL == self)
+    {
+        return content_init("", type, NULL, 0, NULL);
+    }
+    char *name = content_getName(self);
+    uint8_t *content = content_getContent(self);
+    uint16_t size = content_getSize(self);
+    uint8_t *next = content_getNext(self);
+    uint8_t *newContent = content_init(name, type, content, size, next);
+    content_deinit(self);
+    return newContent;
+}
+
+Arg *arg_newContent(Arg *self, uint32_t size)
+{
+    uint8_t *newContent = content_init("", "", NULL, size, NULL);
+    arg_freeContent(self);
+    return newContent;
+}
+
+Arg *arg_setContent(Arg *self, uint8_t *content, uint32_t size)
+{
+    return content_setContent(self, content, size);
+}
+
+Arg *arg_setName(Arg *self, char *name)
+{
+    return content_setName(self, name);
+}
+
+Arg *arg_setType(Arg *self, char *type)
+{
+    return content_setType(self, type);
+}
+
+char *content_getType(uint8_t *self)
+{
+    return (char *)self + content_typeOffset(self);
+}
+
+uint16_t content_contentOffset(uint8_t *self)
+{
+    const uint8_t nextLength = sizeof(uint8_t *);
+    const uint8_t sizeLength = 2;
+    char *name = content_getName(self);
+    return nextLength + sizeLength + strGetSize(name) + 1;
+}
+
+uint16_t content_nextOffset(uint8_t *self)
+{
+    return 0;
+}
+
+uint8_t *content_getNext(uint8_t *self)
+{
+    uint8_t *nextDir = self + content_nextOffset(self);
+    uint8_t *next = NULL;
+    uint64_t pointerTemp = 0;
+
+    for (int32_t i = sizeof(uint8_t *); i > -1; i--)
+    {
+        // avoid \0
+        uint8_t val = nextDir[i];
+        pointerTemp = (pointerTemp << 8);
+        pointerTemp += val;
+    }
+    next = (uint8_t *)pointerTemp;
+    return next;
+}
+
+uint8_t *content_getContent(uint8_t *self)
+{
+    return self + content_contentOffset(self);
+}
+
+uint8_t *arg_getContent(Arg *self)
+{
+    return content_getContent(self);
+}
+
+Arg *arg_setInt(Arg *self, char *name, int64_t val)
+{
+    int64_t int64Temp = val;
+    uint8_t contentBuff[8];
+    for (uint32_t i = 0; i < 4; i++)
+    {
+        // add 0x30 to void \0
+        contentBuff[i] = int64Temp;
+        int64Temp = int64Temp >> 8;
+    }
+    return content_init(name, "int", contentBuff, 4, NULL);
+}
+
+Arg *arg_setFloat(Arg *self, char *name, float val)
+{
+    uint8_t contentBuff[4];
+    uint8_t *valPtr = (uint8_t *)&val;
+    for (uint32_t i = 0; i < 4; i++)
+    {
+        // add 0x30 to void \0
+        contentBuff[i] = valPtr[i];
+    }
+    return content_init(name, "float", contentBuff, 4, NULL);
+}
+
+float arg_getFloat(Arg *self)
+{
+    if (NULL == arg_getContent(self))
+    {
+        return -999.999;
+    }
+
+    float valOut = 0;
+    uint8_t *valOutPtr = (uint8_t *)(&valOut);
+    uint8_t *valPtr = arg_getContent(self);
+    for (uint32_t i = 0; i < 4; i++)
+    {
+        valOutPtr[i] = valPtr[i];
+    }
+    return valOut;
+}
+
+Arg *arg_setPtr(Arg *self, char *name, char *type, void *pointer)
+{
+    uint64_t pointerTemp = (uint64_t)pointer;
+    uint8_t contentBuff[8];
+    for (uint32_t i = 0; i < sizeof(uint8_t *); i++)
+    {
+        // aboid \0
+        contentBuff[i] = pointerTemp;
+        pointerTemp = pointerTemp >> 8;
+    }
+    return content_init(name, type, contentBuff, sizeof(uint8_t *), NULL);
+}
+
+Arg *arg_setStr(Arg *self, char *name, char *string)
+{
+    return content_init(name, "str", (uint8_t *)string, strGetSize(string) + 1, NULL);
+}
+
+int64_t arg_getInt(Arg *self)
+{
+    if (NULL == arg_getContent(self))
+    {
+        return -999999;
+    }
+    int64_t int64Temp = 0;
+    for (int32_t i = 3; i > -1; i--)
+    {
+        // add 0x30 to avoid 0
+        int64Temp = (int64Temp << 8);
+        int64Temp += arg_getContent(self)[i];
+    }
+    return int64Temp;
+}
+
+void *arg_getPtr(Arg *self)
+{
+    void *pointer = NULL;
+    uint64_t pointerTemp = 0;
+    if (NULL == arg_getContent(self))
+    {
+        return NULL;
+    }
+    uint8_t *content = arg_getContent(self);
+    for (int32_t i = sizeof(uint8_t *) - 1; i > -1; i--)
+    {
+        // avoid \0
+        uint8_t val = content[i];
+        pointerTemp = (pointerTemp << 8);
+        pointerTemp += val;
+    }
+    pointer = (void *)pointerTemp;
+    return pointer;
+}
+char *arg_getStr(Arg *self)
+{
+    return (char *)arg_getContent(self);
+}
+
+uint16_t content_typeOffset(uint8_t *self)
+{
+    const uint8_t nextLength = sizeof(uint8_t *);
+    const uint8_t sizeLength = 2;
+    uint16_t size = content_getSize(self);
+    char *name = content_getName(self);
+    uint16_t nameSize = strGetSize(name);
+    return nextLength + sizeLength + nameSize + 1 + size;
+}
+
+char *arg_getName(Arg *self)
+{
+    return content_getName(self);
+}
+
+char *arg_getType(Arg *self)
+{
+    return content_getType(self);
+}
+
+uint16_t arg_getContentSize(Arg *self)
+{
+    return content_getSize(self);
+}
+
+Arg *New_arg(void *voidPointer)
+{
+    return NULL;
+}
+
+Arg *arg_copy(Arg *argToBeCopy)
+{
+    Arg *argCopied = New_arg(NULL);
+    argCopied = arg_setContent(argCopied, arg_getContent(argToBeCopy), arg_getContentSize(argToBeCopy));
+    argCopied = arg_setName(argCopied, arg_getName(argToBeCopy));
+    argCopied = arg_setType(argCopied, arg_getType(argToBeCopy));
+    return argCopied;
+}

src/package/pikascript/pikascript-core/dataArg.h

@@ -0,0 +1,56 @@
+#ifndef _arg__H
+#define _arg__H
+#include "dataMemory.h"
+
+typedef uint8_t Arg;
+
+uint16_t content_typeOffset(uint8_t *content);
+uint16_t content_contentOffset(uint8_t *content);
+uint16_t content_sizeOffset(uint8_t *self);
+uint16_t content_contentOffset(uint8_t *self);
+uint16_t content_nextOffset(uint8_t *self);
+uint8_t content_nameOffset(uint8_t *self);
+
+char *content_getName(uint8_t *content);
+char *content_getType(uint8_t *content);
+uint8_t *content_getNext(uint8_t *self);
+uint16_t content_getSize(uint8_t *self);
+uint8_t *content_getContent(uint8_t *content);
+
+uint16_t content_totleSize(uint8_t *self);
+
+uint8_t *content_init(char *name, char *type, uint8_t *content, uint16_t size, uint8_t *next);
+uint8_t *content_deinit(uint8_t *self);
+uint8_t *content_setName(uint8_t *self, char *name);
+uint8_t *content_setType(uint8_t *self, char *type);
+uint8_t *content_setContent(uint8_t *self, uint8_t *content, uint16_t size);
+void content_setNext(uint8_t *self, uint8_t *next);
+
+uint16_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(Arg *self, uint32_t size);
+Arg *arg_setType(Arg *self, char *type);
+char *arg_getName(Arg *self);
+char *arg_getType(Arg *self);
+uint8_t *arg_getContent(Arg *self);
+uint16_t arg_getContentSize(Arg *self);
+
+Arg *arg_setInt(Arg *self, char *name, int64_t val);
+Arg *arg_setFloat(Arg *self, char *name, float val);
+Arg *arg_setPtr(Arg *self, char *name, char *type, void *pointer);
+Arg *arg_setStr(Arg *self, char *name, char *string);
+
+int64_t arg_getInt(Arg *self);
+float arg_getFloat(Arg *self);
+void *arg_getPtr(Arg *self);
+char *arg_getStr(Arg *self);
+Arg *arg_copy(Arg *argToBeCopy);
+
+Arg *arg_init(Arg *self, void *voidPointer);
+void arg_deinit(Arg *self);
+
+Arg *New_arg(void *voidPointer);
+#endif

src/package/pikascript/pikascript-core/dataArgs.c

@@ -0,0 +1,515 @@
+#include "dataArgs.h"
+#include "dataStrs.h"
+#include "dataLink.h"
+#include "dataMemory.h"
+#include "dataString.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+void args_deinit(Args *self)
+{
+    link_deinit(self);
+}
+
+int32_t args_setFloat(Args *self, char *name, float argFloat)
+{
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_setFloat(argNew, name, argFloat);
+    args_setArg(self, argNew);
+    return 0;
+}
+
+void *args_getPtr(Args *self, char *name)
+{
+    void *pointer = NULL;
+    Arg *arg = args_getArg(self, name);
+    if (NULL == arg)
+    {
+        return NULL;
+    }
+
+    pointer = arg_getPtr(arg);
+    return pointer;
+}
+
+int32_t args_setPtr(Args *self, char *name, void *argPointer)
+{
+    int32_t errCode = 0;
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_setPtr(argNew, name, "pointer", argPointer);
+    args_setArg(self, argNew);
+    return errCode;
+}
+
+int32_t args_setStr(Args *self, char *name, char *strIn)
+{
+    int32_t errCode = 0;
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_setStr(argNew, name, strIn);
+    args_setArg(self, argNew);
+    return errCode;
+}
+
+void setArgDirect(Args *self, Arg *arg)
+{
+    link_addNode(self, arg);
+}
+
+char *args_getBuff(Args *self, int32_t size)
+{
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_newContent(argNew, size + 1);
+    setArgDirect(self, argNew);
+    return (char *)arg_getContent(argNew);
+}
+
+char *args_getStr(Args *self, char *name)
+{
+    Arg *arg = args_getArg(self, name);
+    if (NULL == arg)
+    {
+        return NULL;
+    }
+    if (NULL == arg_getContent(arg))
+    {
+        return NULL;
+    }
+    return (char *)arg_getContent(arg);
+}
+
+int32_t args_setInt(Args *self, char *name, int64_t int64In)
+{
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_setInt(argNew, name, int64In);
+    args_setArg(self, argNew);
+    return 0;
+}
+
+int64_t args_getInt(Args *self, char *name)
+{
+    Arg *arg = args_getArg(self, name);
+    if (NULL == arg)
+    {
+        return -999999999;
+    }
+    return arg_getInt(arg);
+}
+
+int32_t args_getSize(Args *self)
+{
+    return link_getSize(self);
+}
+
+char *args_getType(Args *self, char *name)
+{
+    Arg *arg = NULL;
+    arg = args_getArg(self, name);
+    if (NULL == arg)
+    {
+        return NULL;
+    }
+    return arg_getType(arg);
+}
+
+float args_getFloat(Args *self, char *name)
+{
+    Arg *arg = args_getArg(self, name);
+    if (NULL == arg)
+    {
+        return -999999999.0;
+    }
+    return arg_getFloat(arg);
+}
+
+int32_t args_copyArg(Args *self, Arg *argToBeCopy)
+{
+    if (NULL == argToBeCopy)
+    {
+        return 1;
+    }
+    Arg *argCopied = arg_copy(argToBeCopy);
+    args_setArg(self, argCopied);
+
+    return 0;
+}
+
+int32_t args_copyArgByName(Args *self, char *name, Args *directArgs)
+{
+    Arg *argToBeCopy = args_getArg(self, name);
+    args_copyArg(directArgs, argToBeCopy);
+    return 0;
+}
+
+int32_t args_isArgExist(Args *self, char *name)
+{
+    if (NULL == name)
+    {
+        return 0;
+    }
+    if (NULL != args_getArg(self, name))
+    {
+        return 1;
+    }
+    return 0;
+}
+
+int32_t updateArg(Args *self, Arg *argNew)
+{
+    LinkNode *nodeToUpdate = NULL;
+    LinkNode *nodeNow = self->firstNode;
+    LinkNode *priorNode = NULL;
+    char *name = arg_getName(argNew);
+    while (1)
+    {
+        if (strEqu(content_getName(nodeNow), name))
+        {
+            nodeToUpdate = nodeNow;
+            break;
+        }
+        if (content_getNext(nodeNow) == NULL)
+        {
+            // error, node no found
+            goto exit;
+        }
+        priorNode = nodeNow;
+        nodeNow = content_getNext(nodeNow);
+    }
+
+    nodeToUpdate = arg_setContent(nodeToUpdate, arg_getContent(argNew), arg_getContentSize(argNew));
+
+    // update privior link, because arg_getContent would free origin pointer
+    if (NULL == priorNode)
+    {
+        self->firstNode = nodeToUpdate;
+        goto exit;
+    }
+
+    content_setNext(priorNode, nodeToUpdate);
+    goto exit;
+exit:
+    arg_deinit(argNew);
+    return 0;
+}
+
+int32_t args_setArg(Args *self, Arg *arg)
+{
+    char *name = arg_getName(arg);
+    if (!args_isArgExist(self, name))
+    {
+        setArgDirect(self, arg);
+        return 0;
+    }
+    updateArg(self, arg);
+    return 0;
+}
+
+LinkNode *args_getNode(Args *self, char *name)
+{
+    LinkNode *nodeNow = self->firstNode;
+    if (NULL == nodeNow)
+    {
+        return NULL;
+    }
+    while (1)
+    {
+        Arg *arg = nodeNow;
+        char *thisName = arg_getName(arg);
+        if (strEqu(name, thisName))
+        {
+            return nodeNow;
+        }
+        if (NULL == content_getNext(nodeNow))
+        {
+            return NULL;
+        }
+        nodeNow = content_getNext(nodeNow);
+    }
+}
+
+Arg *args_getArg(Args *self, char *name)
+{
+    LinkNode *node = args_getNode(self, name);
+    if (NULL == node)
+    {
+        return NULL;
+    }
+    return node;
+}
+
+void args_bind(Args *self, char *type, char *name, void *pointer)
+{
+    Args *buffs = New_strBuff();
+    char *typeWithBind = strsAppend(buffs, "_bind-", type);
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_setPtr(argNew, name, typeWithBind, pointer);
+    args_setArg(self, argNew);
+    args_deinit(buffs);
+    return;
+}
+
+void args_bindInt(Args *self, char *name, int32_t *intPtr)
+{
+    args_bind(self, "int", name, intPtr);
+}
+
+void args_bindFloat(Args *self, char *name, float *floatPtr)
+{
+    args_bind(self, "float", name, floatPtr);
+}
+
+void args_bindStr(Args *self, char *name, char **stringPtr)
+{
+    args_bind(self, "str", name, stringPtr);
+}
+
+char *getPrintSring(Args *self, char *name, char *valString)
+{
+    Args *buffs = New_strBuff();
+    char *printName = strsFormat(buffs, "[printBuff]%s", name);
+    char *printString = strsCopy(buffs, valString);
+    args_setStr(self, printName, printString);
+    char *res = args_getStr(self, printName);
+    args_deinit(buffs);
+    return res;
+}
+
+char *getPrintStringFromInt(Args *self, char *name, int32_t val)
+{
+    Args *buffs = New_strBuff();
+    char *res = NULL;
+    char *valString = strsFormat(buffs, "%d", val);
+    res = getPrintSring(self, name, valString);
+    args_deinit(buffs);
+    return res;
+}
+
+char *getPrintStringFromFloat(Args *self, char *name, float val)
+{
+    Args *buffs = New_strBuff();
+    char *res = NULL;
+    char *valString = strsFormat(buffs, "%f", val);
+    res = getPrintSring(self, name, valString);
+    args_deinit(buffs);
+    return res;
+}
+
+char *getPrintStringFromPtr(Args *self, char *name, void *val)
+{
+    Args *buffs = New_strBuff();
+    char *res = NULL;
+    uint64_t intVal = (uint64_t)val;
+    char *valString = strsFormat(buffs, "0x%llx", intVal);
+    res = getPrintSring(self, name, valString);
+    args_deinit(buffs);
+    return res;
+}
+
+char *args_print(Args *self, char *name)
+{
+    char *res = NULL;
+    char *type = args_getType(self, name);
+    Args *buffs = New_strBuff();
+    if (NULL == type)
+    {
+        /* can not get arg */
+        res = NULL;
+        goto exit;
+    }
+
+    if (strEqu(type, "int"))
+    {
+        int32_t val = args_getInt(self, name);
+        res = getPrintStringFromInt(self, name, val);
+        goto exit;
+    }
+
+    if (strEqu(type, "float"))
+    {
+        float val = args_getFloat(self, name);
+        res = getPrintStringFromFloat(self, name, val);
+        goto exit;
+    }
+
+    if (strEqu(type, "str"))
+    {
+        res = args_getStr(self, name);
+        goto exit;
+    }
+
+    if (strEqu(type, "pointer"))
+    {
+        void *val = args_getPtr(self, name);
+        res = getPrintStringFromPtr(self, name, val);
+        goto exit;
+    }
+
+    char *bindTypePrefix = strsCopy(self, "_bind-");
+    if (strIsStartWith(type, bindTypePrefix))
+    {
+        char *typeWithoutBind = strsRemovePrefix(buffs, type, bindTypePrefix);
+        if (strEqu(typeWithoutBind, "int"))
+        {
+            int32_t *valPtr = args_getPtr(self, name);
+            int32_t val = *valPtr;
+            res = getPrintStringFromInt(self, name, val);
+            goto exit;
+        }
+        if (strEqu(typeWithoutBind, "float"))
+        {
+            float *valPtr = args_getPtr(self, name);
+            float val = *valPtr;
+            res = getPrintStringFromFloat(self, name, val);
+            goto exit;
+        }
+        if (strEqu(typeWithoutBind, "str"))
+        {
+            // the value of &string is equal to string it self
+            char *string = args_getPtr(self, name);
+            res = string;
+            goto exit;
+        }
+    }
+    /* can not match type */
+    res = NULL;
+    goto exit;
+
+exit:
+    args_deinit(buffs);
+    return res;
+}
+
+int32_t args_set(Args *self, char *name, char *valStr)
+{
+    char *type = args_getType(self, name);
+    Args *buffs = New_strBuff();
+    int32_t err = 0;
+
+    if (NULL == type)
+    {
+        /* do not get arg */
+        err = 1;
+        goto exit;
+    }
+
+    if (strEqu("int", type))
+    {
+        int32_t val = atoi(valStr);
+        args_setInt(self, name, val);
+        // operation succeed
+        err = 0;
+        goto exit;
+    }
+    if (strEqu("float", type))
+    {
+        float val = atof(valStr);
+        args_setFloat(self, name, val);
+        // operation succeed
+        err = 0;
+        goto exit;
+    }
+    if (strEqu("str", type))
+    {
+        args_setStr(self, name, valStr);
+        // operation succeed
+        err = 0;
+        goto exit;
+    }
+
+    char *bindTypePrefix = strsCopy(self, "_bind-");
+    if (strIsStartWith(type, bindTypePrefix))
+    {
+        char *typeWithoutBind = strsRemovePrefix(buffs, type, bindTypePrefix);
+        if (strEqu(typeWithoutBind, "int"))
+        {
+            int32_t *valPtr = args_getPtr(self, name);
+            int32_t val = atoi(valStr);
+            *valPtr = val;
+            // operation succeed
+            err = 0;
+            goto exit;
+        }
+        if (strEqu(typeWithoutBind, "float"))
+        {
+            float *valPtr = args_getPtr(self, name);
+            float val = atof(valStr);
+            *valPtr = val;
+            // operation succeed
+            err = 0;
+            goto exit;
+        }
+        if (strEqu(typeWithoutBind, "str"))
+        {
+            char *stringBinded = args_getPtr(self, name);
+            /* size add 1 to copy the '\0' */
+            memcpy(stringBinded, valStr, strGetSize(valStr) + 1);
+            // operation succeed
+            err = 0;
+            goto exit;
+        }
+    }
+    /* type not match */
+    err = 2;
+    goto exit;
+exit:
+    args_deinit(buffs);
+    return err;
+}
+
+int32_t args_setPtrWithType(Args *self, char *name, char *type, void *objPtr)
+{
+    Arg *argNew = New_arg(NULL);
+    argNew = arg_setPtr(argNew, name, type, objPtr);
+    args_setArg(self, argNew);
+    return 0;
+}
+
+int32_t args_setObjectWithClass(Args *self, char *objName, char *className, void *objPtr)
+{
+    Args *buffs = New_strBuff();
+    char *typeWithClass = strsAppend(buffs, "_class-", className);
+    args_setPtrWithType(self, objName, typeWithClass, objPtr);
+    args_deinit(buffs);
+    return 0;
+}
+
+int32_t args_foreach(Args *self, int32_t (*eachHandle)(Arg *argEach, Args *handleArgs), Args *handleArgs)
+{
+    LinkNode *nodeNow = self->firstNode;
+    while (1)
+    {
+        Arg *argNow = nodeNow;
+        if (NULL == argNow)
+        {
+            continue;
+        }
+        LinkNode *nextNode = content_getNext(nodeNow);
+        eachHandle(argNow, handleArgs);
+
+        if (NULL == nextNode)
+        {
+            break;
+        }
+        nodeNow = nextNode;
+    }
+    return 0;
+}
+
+int32_t args_removeArg(Args *self, char *name)
+{
+    Arg *argNow = args_getArg(self, name);
+    if (NULL == argNow)
+    {
+        /* can not found arg */
+        return 1;
+    }
+    link_removeNode(self, argNow);
+    return 0;
+}
+
+Args *New_args(Args *args)
+{
+    Args *self = New_link(NULL);
+    return self;
+}

src/package/pikascript/pikascript-core/dataArgs.h

@@ -0,0 +1,57 @@
+#ifndef _dataArgs__H
+#define _dataArgs__H
+#include "dataLink.h"
+#include "dataString.h"
+#include "dataMemory.h"
+#include "dataArg.h"
+
+typedef Link Args;
+
+/* operation */
+void args_deinit(Args *self);
+void args_init(Args *self, Args *args);
+int32_t args_getSize(Args *self);
+LinkNode *args_getNode(Args *self, char *name);
+
+Arg *args_getArgByIndex(Args *self,int32_t index);
+Arg *args_getArg(Args *self, char *name);
+int32_t args_removeArg(Args *self, char *name);
+
+int32_t args_setArg(Args *self, Arg *arg);
+
+int32_t args_copyArgByName(Args *self, char *name, Args *directList);
+int32_t args_copyArg(Args *self, Arg *argToBeCopy);
+
+char *args_getType(Args *self, char *name);
+int32_t args_isArgExist(Args *self, char *name);
+
+int32_t args_setStr(Args *self, char *name, char *strIn);
+int32_t args_setStrWithDefaultName(Args *self, char *strIn);
+char *args_getStr(Args *self, char *name);
+
+int32_t args_setFloatWithDefaultName(Args *self, float argFloat);
+int32_t args_setFloat(Args *self, char *name, float argFloat);
+float args_getFloat(Args *self, char *name);
+
+int32_t args_setPtr(Args *self, char *name, void *argPointer);
+void *args_getPtr(Args *self, char *name);
+
+int32_t args_setInt(Args *self, char *name, int64_t int64In);
+int64_t args_getInt(Args *self, char *name);
+
+void args_bindInt(Args *self, char *name,int32_t *intPtr);
+void args_bindFloat(Args *self, char *name, float *floatPtr);
+void args_bindStr(Args *self, char *name, char **stringPtr);
+/* arg general opeartion */
+void args_bind(Args *self, char *type, char *name, void *pointer);
+char *args_print(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, char *objName, char *type, void *objPtr);
+int32_t args_foreach (Args *self,int32_t (*eachHandle)(Arg *argEach, Args *handleArgs), Args * handleArgs);
+
+char *args_getBuff(Args *self,int32_t size);
+
+Args *New_args(Args *args);
+#endif

src/package/pikascript/pikascript-core/dataLink.c

@@ -0,0 +1,95 @@
+#include "dataLink.h"
+#include "dataLinkNode.h"
+#include "dataMemory.h"
+#include "dataArg.h"
+
+void link_deinit(Link *self)
+{
+    LinkNode *nowNode = self->firstNode;
+    while (NULL != nowNode)
+    {
+        LinkNode *nodeNext = content_getNext(nowNode);
+        linkNode_deinit(nowNode);
+        nowNode = nodeNext;
+    }
+    // DynMemPut(self->mem);
+    pikaFree(self, sizeof(Link));
+    self = NULL;
+}
+
+void link_addNode(Link *self, void *content)
+{
+    // old first node become new second node
+    LinkNode *secondNode = self->firstNode;
+
+    self->firstNode = content;
+    // change the first node to new node
+    content_setNext(content, secondNode);
+}
+
+void link_removeNode(Link *self, void *content)
+{
+    LinkNode *nodeToDelete = NULL;
+    LinkNode *nodeNow = self->firstNode;
+    LinkNode *priorNode = NULL;
+    while (1)
+    {
+        if (nodeNow == content)
+        {
+            nodeToDelete = nodeNow;
+            break;
+        }
+        if (nodeNow == NULL)
+        {
+            // error, node no found
+            goto exit;
+        }
+        priorNode = nodeNow;
+        nodeNow = content_getNext(nodeNow);
+    }
+
+    LinkNode *nextNode = content_getNext(nodeToDelete);
+    if (nodeToDelete == self->firstNode)
+    {
+        self->firstNode = content_getNext(nodeToDelete);
+    }
+
+    if (NULL == priorNode)
+    {
+        self->firstNode = nextNode;
+        goto exit;
+    }
+
+    content_setNext(priorNode, nextNode);
+    goto exit;
+
+// deinit the node
+exit:
+    linkNode_deinit(nodeToDelete);
+    return;
+}
+
+int32_t link_getSize(Link *self)
+{
+    LinkNode *NowNode;
+    int32_t size = 0;
+    NowNode = self->firstNode;
+    while (NULL != NowNode)
+    {
+        size++;
+        NowNode = content_getNext(NowNode);
+    }
+    return size;
+}
+
+void link_init(Link *self, void *args)
+{
+    self->firstNode = NULL;
+}
+
+Link *New_link(void *args)
+{
+    Link *self = pikaMalloc(sizeof(Link));
+    link_init(self, args);
+    return self;
+}

src/package/pikascript/pikascript-core/dataLink.h

@@ -0,0 +1,20 @@
+#ifndef _link2__H
+#define _link2__H
+#include "dataLinkNode.h"
+#include "dataMemory.h"
+
+typedef struct Class_link Link;
+struct Class_link
+{
+    LinkNode *firstNode;
+};
+
+void link_deinit(Link *self);
+void link_init(Link *self, void *args);
+void link_addNode(Link *self, void *content);
+void link_removeNode(Link *self, void *content);
+LinkNode *link_getNode(Link *self, int64_t id);
+int32_t link_getSize(Link *self);
+
+Link *New_link(void *args);
+#endif

src/package/pikascript/pikascript-core/dataLinkNode.c

@@ -0,0 +1,18 @@
+#include "dataLinkNode.h"
+#include "dataMemory.h"
+#include "dataArg.h"
+
+void linkNode_deinit(LinkNode *self)
+{
+    arg_deinit(self);
+}
+
+void linkNode_init(LinkNode *self, void *args)
+{
+    /* attribute */
+}
+
+LinkNode *New_linkNode(void *args)
+{
+    return NULL;
+}

src/package/pikascript/pikascript-core/dataLinkNode.h

@@ -0,0 +1,10 @@
+#ifndef _linkNode__H
+#define _linkNode__H
+#include "dataMemory.h"
+typedef uint8_t LinkNode;
+
+void linkNode_deinit(LinkNode *self);
+void linkNode_init(LinkNode *self, void *args);
+
+LinkNode *New_linkNode(void *args);
+#endif

src/package/pikascript/pikascript-core/dataMemory.c

@@ -0,0 +1,44 @@
+#include "dataMemory.h"
+#include <stdint.h>
+#include <stdlib.h>
+
+PikaMemInfo pikaMemInfo = {0};
+
+void *pikaMalloc(uint32_t size)
+{
+    pikaMemInfo.heapUsed += size;
+    if (pikaMemInfo.heapUsedMax < pikaMemInfo.heapUsed)
+    {
+        pikaMemInfo.heapUsedMax = pikaMemInfo.heapUsed;
+    }
+    void *mem = malloc(size);
+    if (NULL == mem)
+    {
+        printf("[error]: No heap space!\r\n");
+        while (1)
+        {
+        }
+    }
+    return mem;
+}
+
+void pikaFree(void *mem, uint32_t size)
+{
+    free(mem);
+    pikaMemInfo.heapUsed -= size;
+}
+
+uint16_t pikaMemNow(void)
+{
+    return pikaMemInfo.heapUsed;
+}
+
+uint16_t pikaMemMax(void)
+{
+    return pikaMemInfo.heapUsedMax;
+}
+
+void pikaMemMaxReset(void)
+{
+    pikaMemInfo.heapUsedMax = 0;
+}

src/package/pikascript/pikascript-core/dataMemory.h

@@ -0,0 +1,19 @@
+#ifndef __MEMORY_H__
+#define __MEMORY_H__
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct
+{
+    uint32_t heapUsed;
+    uint32_t heapUsedMax;
+} PikaMemInfo;
+
+void pikaFree(void *mem, uint32_t size);
+void *pikaMalloc(uint32_t size);
+uint16_t pikaMemNow(void);
+uint16_t pikaMemMax(void);
+void pikaMemMaxReset(void);
+#endif 

src/package/pikascript/pikascript-core/dataString.c

@@ -0,0 +1,327 @@
+#include "dataString.h"
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *strAppendWithSize_unlimited(char *strOut, char *pData, int32_t Size)
+{
+	int32_t strOut_i = strGetSize(strOut);
+	for (int32_t i = 0; i < Size; i++)
+	{
+		strOut[strOut_i + i] = pData[i];
+	}
+	strOut_i += Size;
+	// add \0 to the end of strOut
+	strOut[strOut_i] = 0;
+
+	return strOut;
+}
+
+char *strCut(char *strOut, char *strIn, char startSign, char endSign)
+{
+	int32_t Size = strGetSize(strIn);
+	int32_t isStart = 0;
+	int32_t isEnd = 0;
+	int32_t iOut = 0;
+	for (int32_t i = 0; i < Size; i++)
+	{
+		if (!isStart && (strIn[i] == startSign))
+		{
+			isStart = 1;
+			continue;
+		}
+		if (isStart && (strIn[i] == endSign))
+		{
+			isEnd = 1;
+			break;
+		}
+		if (isStart)
+		{
+			strOut[iOut] = strIn[i];
+			iOut++;
+		}
+	}
+	/* add \0 */
+	strOut[iOut] = 0;
+	if (isStart && isEnd)
+	{
+		/* succeed */
+		return strOut;
+	}
+	/* faild */
+	return NULL;
+}
+
+char *strDeleteChar(char *strOut, char *strIn, char ch)
+{
+	int32_t iOut = 0;
+	for (int32_t i = 0; i < strGetSize(strIn); i++)
+	{
+		if (ch == strIn[i])
+		{
+			continue;
+		}
+		strOut[iOut] = strIn[i];
+		iOut++;
+	}
+	/* add \0 */
+	strOut[iOut] = 0;
+	return strOut;
+}
+
+char *strDeleteEnter(char *str)
+{
+	return strDeleteChar(str, str, '\n');
+}
+
+char *strAppendWithSize(char *strOut, char *pData, int32_t Size)
+{
+	int32_t strOut_i = strGetSize(strOut);
+	for (int32_t i = 0; i < Size; i++)
+	{
+		strOut[strOut_i + i] = pData[i];
+	}
+	strOut_i += Size;
+	// add \0 to the end of strOut
+	strOut[strOut_i] = 0;
+
+	return strOut;
+}
+
+int32_t strCountSign(char *strIn, char sign)
+{
+	int32_t count = 0;
+	for (int32_t i = 0; i < strGetSize(strIn); i++)
+	{
+		if (sign == strIn[i])
+		{
+			count++;
+		}
+	}
+	return count;
+}
+
+int32_t strGetTokenNum(char *strIn, char sign)
+{
+	return strCountSign(strIn, sign) + 1;
+}
+
+uint32_t strGetSize(char *pData)
+{
+	if (NULL == pData)
+	{
+		return 0;
+	}
+	uint32_t Size = 0;
+	if (NULL == pData)
+	{
+		return 0;
+	}
+	for (int32_t i = 0; pData[i] != 0; i++)
+	{
+		Size++;
+	}
+	return Size;
+}
+
+char *strAppend_unlimited(char *strOut, char *pData)
+{
+	uint32_t Size = 0;
+	Size = strGetSize(pData);
+	return strAppendWithSize_unlimited(strOut, pData, Size);
+}
+
+char *strGetLastToken(char *strOut, char *strIn, char sign)
+{
+	int32_t size = strGetSize(strIn);
+	int32_t isGetSign = 0;
+	int32_t buffSize = 0;
+	for (int32_t i = size - 1; i > -1; i--)
+	{
+		if (strIn[i] != sign)
+		{
+			strOut[size - i - 1] = strIn[i];
+			buffSize++;
+		}
+		if (strIn[i] == sign)
+		{
+			isGetSign = 1;
+			break;
+		}
+	}
+	int32_t i = 0;
+	for (i = 0; i < buffSize / 2; i++)
+	{
+		char buff = strOut[i];
+		strOut[i] = strOut[buffSize - i - 1];
+		strOut[buffSize - i - 1] = buff;
+	}
+	strOut[buffSize] = 0;
+	return strOut;
+}
+
+char *strPopToken(char *strOut, char *strIn, char sign)
+{
+	int32_t getSign = 0;
+	int32_t iPoped = 0;
+	int32_t iOut = 0;
+	int32_t size = strGetSize(strIn);
+	int32_t i = 0;
+	for (i = 0; i < size; i++)
+	{
+		if (getSign)
+		{
+			strIn[iPoped++] = strIn[i];
+			continue;
+		}
+		if (strIn[i] != sign)
+		{
+			strOut[iOut++] = strIn[i];
+			continue;
+		}
+		if (strIn[i] == sign)
+		{
+			getSign = 1;
+			continue;
+		}
+	}
+	strOut[iOut] = 0;
+	strIn[iPoped] = 0;
+	return strOut;
+}
+
+char *strGetFirstToken(char *strOut, char *strIn, char sign)
+{
+	int32_t size = strGetSize(strIn);
+	for (int32_t i = 0; i < size; i++)
+	{
+		if (strIn[i] != sign)
+		{
+			strOut[i] = strIn[i];
+		}
+		if (strIn[i] == sign)
+		{
+			break;
+		}
+	}
+	return strOut;
+}
+
+int32_t strGetToken(char *string, char **argv, char sign)
+{
+	int32_t argc = 0;
+	int32_t i = 0;
+	//arg_i point32_t to the arg operated now
+	int32_t arg_i = 0;
+	// if not found ' ', then put chars from CMD to argv_tem
+	int32_t char_i = 0;
+	for (i = 0; (i < strGetSize(string)); i++)
+	{
+		if (string[i] != sign)
+		{
+			argv[arg_i][char_i] = string[i];
+			char_i++;
+		}
+		if (string[i] == sign)
+		{
+			// write '\0' to the end of argv
+			argv[arg_i][char_i] = 0;
+			arg_i++;
+			char_i = 0;
+		}
+		// write '\0' to the end of last argv
+		argv[arg_i][char_i] = 0;
+	}
+	argc = arg_i + 1;
+	return argc;
+}
+
+char *strAppend(char *strOut, char *pData)
+{
+	uint32_t Size = 0;
+	Size = strGetSize(pData);
+	return strAppendWithSize(strOut, pData, Size);
+}
+
+int32_t strIsStartWith(char *str, char *strStart)
+{
+	if (NULL == str || NULL == strStart)
+	{
+		/* input is null */
+		return 0;
+	}
+	uint32_t size = strGetSize(strStart);
+	uint32_t CMDName_get = 1;
+	for (int32_t i = 0; i < size; i++)
+	{
+		if (str[i] != strStart[i])
+		{
+			CMDName_get = 0;
+		}
+	}
+	return CMDName_get;
+}
+
+int32_t strEqu(char *str1, char *str2)
+{
+	if (str1 == NULL || str2 == NULL)
+	{
+		return 0;
+	}
+	int32_t size1 = strGetSize(str1);
+	int32_t size2 = strGetSize(str2);
+	if (size1 != size2)
+	{
+		return 0; // not equal
+	}
+	for (int32_t i = 0; i < size1; i++)
+	{
+		if (str1[i] != str2[i])
+		{
+			return 0; // not equal
+		}
+	}
+	return 1;
+}
+
+char *strRemovePrefix(char *inputStr, char *prefix, char *outputStr)
+{
+	if (!strIsStartWith(inputStr, prefix))
+	{
+		return NULL;
+	}
+
+	for (int32_t i = strGetSize(prefix); i < strGetSize(inputStr); i++)
+	{
+		outputStr[i - strGetSize(prefix)] = inputStr[i];
+	}
+	return outputStr;
+}
+
+char *strClear(char *str)
+{
+	for (int32_t i = 0; i < sizeof(str); i++)
+	{
+		str[i] = 0;
+	}
+	return str;
+}
+
+int32_t strIsContain(char *str, char ch)
+{
+	for (int32_t i = 0; i < strGetSize(str); i++)
+	{
+		if (str[i] == ch)
+		{
+			return 1;
+		}
+	}
+	return 0;
+}
+
+char *strCopy(char *strBuff, char *strIn)
+{
+	memcpy(strBuff, strIn, strGetSize(strIn));
+	return strBuff;
+}

src/package/pikascript/pikascript-core/dataString.h

@@ -0,0 +1,32 @@
+#ifndef __MY_TEST_TOOLS_H 
+#define __MY_TEST_TOOLS_H 
+#include <stdint.h>
+
+/* size */
+uint32_t strGetSize(char *pData);
+/* append */
+char *strAppend(char *strOut, char *pData);
+char *strAppend_unlimited(char *strOut, char *pData);
+char *strAppendWithSize(char *strOut, char *pData,int32_t Size);
+/* cut */
+char *strCut(char *strOut, char *strIn, char startSign, char endSign);
+/* assert */
+int32_t strIsStartWith(char *str, char *strStart);
+int32_t strEqu(char *str1, char *str2);
+/* delete */
+char *strDeleteEnter(char *str);
+char *strDeleteChar(char *strOut, char *strIn, char ch);
+/* prefix */
+char *strRemovePrefix(char *inputStr, char *prefix, char *outputStr);
+/* token */
+int32_t strGetToken(char *string, char **argv, char sign);
+char *strPopToken(char *strOut, char *strIn, char sign);
+int32_t strCountSign(char *strIn, char sign);
+int32_t strGetTokenNum(char *strIn, char sign);
+char *strGetFirstToken(char *strOut, char *strIn, char sign);
+char *strGetLastToken(char *strOut, char *strIn, char sign);
+char *strClear(char *str);
+int32_t strIsContain(char *str, char ch);
+char *strCopy(char *strBuff, char *strIn);
+
+#endif

src/package/pikascript/pikascript-core/dataStrs.c

@@ -0,0 +1,75 @@
+#include "dataStrs.h"
+#include "dataString.h"
+#include <stdio.h>
+#include <stdarg.h>
+
+Args *New_strBuff(void)
+{
+    return New_args(NULL);
+}
+
+char *strsRemovePrefix(Args *buffs, char *inputStr, char *prefix)
+{
+    int32_t size = strGetSize(inputStr);
+    char *buff = args_getBuff(buffs, size);
+    return strRemovePrefix(inputStr, prefix, buff);
+}
+
+char *strsAppend(Args *buffs, char *strOrigin, char *strToAppend)
+{
+    int32_t size = strGetSize(strOrigin) + strGetSize(strToAppend);
+    char *buff = args_getBuff(buffs, size);
+    char *strOut = strCopy(buff, strOrigin);
+    strAppend(strOut, strToAppend);
+    return strOut;
+}
+
+char *strsGetLastToken(Args *buffs, char *argPath, char sign)
+{
+    int32_t size = strGetSize(argPath);
+    char *buff = args_getBuff(buffs, size);
+    return strGetLastToken(buff, argPath, sign);
+}
+
+char *strsCut(Args *buffs, char *strIn, char startSign, char endSign)
+{
+    int32_t size = strGetSize(strIn);
+    char *buff = args_getBuff(buffs, size);
+    return strCut(buff, strIn, startSign, endSign);
+}
+
+char *strsDeleteChar(Args *buffs, char *strIn, char ch)
+{
+    int32_t size = strGetSize(strIn);
+    return strDeleteChar(args_getBuff(buffs, size), strIn, ch);
+}
+
+char *strsGetFirstToken(Args *buffs, char *strIn, char sign)
+{
+    int32_t size = strGetSize(strIn);
+    return strGetFirstToken(args_getBuff(buffs, size), strIn, sign);
+}
+
+char *strsPopToken(Args *buffs, char *tokens, char sign)
+{
+    int32_t size = strGetSize(tokens);
+    char *buff = args_getBuff(buffs, size);
+    return strPopToken(buff, tokens, sign);
+}
+
+char *strsCopy(Args *buffs, char *source)
+{
+    int32_t size = strGetSize(source);
+    char *buff = args_getBuff(buffs, size);
+    return strCopy(buff, source);
+}
+
+char *strsFormat(Args *buffs, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    char *res = args_getBuff(buffs, 256);
+    vsprintf(res, fmt, args);
+    va_end(args);
+    return res;
+}

src/package/pikascript/pikascript-core/dataStrs.h

@@ -0,0 +1,14 @@
+#ifndef __STR_ARGS__H
+#define __STR_ARGS__H
+#include "dataArgs.h"
+Args *New_strBuff(void);
+char *strsGetFirstToken(Args *buffs, char *strIn, char sign);
+char *strsGetLastToken(Args *buffs, char *arg_Path, char sign);
+char *strsPopToken(Args *buffs, char *tokens, char sign);
+char *strsCopy(Args *buffs, char *source);
+char *strsDeleteChar(Args *buff, char *strIn, char ch);
+char *strsCut(Args *buffs, char *strIn, char startSign, char endSign);
+char *strsRemovePrefix(Args *buffs, char *inputStr, char *prefix);
+char *strsAppend(Args *buffs, char *strOrigin, char *strAppend);
+char *strsFormat(Args *buffs, const char *fmt, ...);
+#endif

src/package/pikascript/pikascript-core/method.c

@@ -0,0 +1,32 @@
+#include "PikaObj.h"
+#include "dataArgs.h"
+
+void method_returnStr(Args *args, char *val)
+{
+    args_setStr(args, "return", val);
+}
+void method_returnInt(Args *args, int32_t val)
+{
+    args_setInt(args, "return", val);
+}
+void method_returnFloat(Args *args, float val)
+{
+    args_setFloat(args, "return", val);
+}
+void method_returnPtr(Args *args, void *val)
+{
+    args_setPtr(args, "return", val);
+}
+
+int32_t method_getInt(Args *args, char *argName)
+{
+    return args_getInt(args, argName);
+}
+float method_getFloat(Args *args, char *argName)
+{
+    return args_getFloat(args, argName);
+}
+char *method_getStr(Args *args, char *argName)
+{
+    return args_getStr(args, argName);
+}

src/package/pikascript/pikascript-core/method.h

@@ -0,0 +1,11 @@
+#ifndef METHOD__H
+#define METHOD__H
+#include "dataArgs.h"
+void method_returnStr(Args *args, char *val);
+void method_returnInt(Args *args, int32_t val);
+void method_returnFloat(Args *args, float val);
+void method_returnPtr(Args *args, void *val);
+int32_t method_getInt(Args *args, char *argName);
+float method_getFloat(Args *args, char *argName);
+char *method_getStr(Args *args, char *argName);
+#endif