use buffs = {0} instead of buffs = New_strBuff()

port/linux/package/pikascript/pikascript-lib/PikaStdLib/PikaStdLib_SysObj.c

@@ -79,22 +79,22 @@ int PikaStdLib_SysObj_int(PikaObj* self, Arg* arg) {
 
 char* PikaStdLib_SysObj_str(PikaObj* self, Arg* arg) {
     ArgType type = arg_getType(arg);
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     char* res = NULL;
     do {
         if (ARG_TYPE_INT == type) {
             int val = arg_getInt(arg);
-            res = strsFormat(buffs, 11, "%d", val);
+            res = strsFormat(&buffs, 11, "%d", val);
             break;
         }
         if (ARG_TYPE_FLOAT == type) {
             float val = arg_getFloat(arg);
-            res = strsFormat(buffs, 11, "%f", val);
+            res = strsFormat(&buffs, 11, "%f", val);
             break;
         }
     } while (0);
     obj_setStr(self, "__strtmp", res);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return obj_getStr(self, "__strtmp");
 }
 

src/BaseObj.c

@@ -35,11 +35,10 @@
 #include "dataStrs.h"
 
 Arg* arg_setMetaObj(char* objName, char* className, NewFun objPtr) {
-    Args* buffs = New_strBuff();
-    Arg* argNew = New_arg(NULL);
+    Args buffs = {0};    Arg* argNew = New_arg(NULL);
     /* m means mate-object */
     argNew = arg_setPtr(argNew, objName, ARG_TYPE_MATE_OBJECT, (void*)objPtr);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return argNew;
 }
 
@@ -53,7 +52,7 @@ int32_t obj_newObj(PikaObj* self,
     return 0;
 }
 
-static void print_no_end(PikaObj* self, Args* args){
+static void print_no_end(PikaObj* self, Args* args) {
     obj_setErrorCode(self, 0);
     char* res = args_print(args, "val");
     if (NULL == res) {

src/PikaObj.c

@@ -329,8 +329,7 @@ PikaObj* newRootObj(char* name, NewFun newObjFun) {
 static PikaObj* __initObj(PikaObj* obj, char* name) {
     PikaObj* res = NULL;
     NewFun newObjFun = (NewFun)getNewClassObjFunByName(obj, name);
-    Args* buffs = New_args(NULL);
-    PikaObj* thisClass;
+    Args buffs = {0};    PikaObj* thisClass;
     PikaObj* newObj;
     if (NULL == newObjFun) {
         /* no such object */
@@ -344,7 +343,7 @@ static PikaObj* __initObj(PikaObj* obj, char* name) {
     res = obj_getPtr(obj, name);
     goto exit;
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
@@ -402,13 +401,12 @@ static void obj_saveMethodInfo(PikaObj* self,
                                char* method_dec,
                                void* method_ptr,
                                ArgType method_type) {
-    Args* buffs = New_strBuff();
-    char* pars = strsRemovePrefix(buffs, method_dec, method_name);
+    Args buffs = {0};    char* pars = strsRemovePrefix(&buffs, method_dec, method_name);
     Arg* arg = New_arg(NULL);
     uint32_t size_ptr = sizeof(void*);
     uint32_t size_pars = strGetSize(pars);
     uint32_t size_info = size_ptr + size_pars + 1;
-    void* info = args_getBuff(buffs, size_info);
+    void* info = args_getBuff(&buffs, size_info);
     __platform_memcpy(info, &method_ptr, size_ptr);
     /* +1 to add \0 */
     __platform_memcpy((void*)((uintptr_t)info + size_ptr), pars, size_pars + 1);
@@ -417,7 +415,7 @@ static void obj_saveMethodInfo(PikaObj* self,
     arg = arg_setContent(arg, info, size_info);
 
     args_setArg(self->list, arg);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
 }
 
 static int32_t __class_defineMethodWithType(PikaObj* self,
@@ -426,11 +424,10 @@ static int32_t __class_defineMethodWithType(PikaObj* self,
                                             ArgType method_type) {
     int32_t size = strGetSize(declearation);
     int32_t res = 0;
-    Args* buffs = New_strBuff();
-    char* cleanDeclearation =
-        strDeleteChar(args_getBuff(buffs, size), declearation, ' ');
+    Args buffs = {0};    char* cleanDeclearation =
+        strDeleteChar(args_getBuff(&buffs, size), declearation, ' ');
     char* methodPath =
-        strGetFirstToken(args_getBuff(buffs, size), cleanDeclearation, '(');
+        strGetFirstToken(args_getBuff(&buffs, size), cleanDeclearation, '(');
 
     PikaObj* methodHost = obj_getObj(self, methodPath, 1);
     char* methodName;
@@ -446,7 +443,7 @@ static int32_t __class_defineMethodWithType(PikaObj* self,
     res = 0;
     goto exit;
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
@@ -551,8 +548,8 @@ static void __clearBuff(char* buff, int size) {
 void obj_shellLineProcess(PikaObj* self,
                           __obj_shellLineHandler_t __lineHandler_fun,
                           struct shell_config* cfg) {
-    Args* buffs = New_strBuff();
-    char* rxBuff = args_getBuff(buffs, PIKA_CONFIG_LINE_BUFF_SIZE);
+    Args buffs = {0};    
+    char* rxBuff = args_getBuff(&buffs, PIKA_CONFIG_LINE_BUFF_SIZE);
     char* input_line = NULL;
     uint8_t is_in_block = 0;
     __platform_printf(cfg->prefix);
@@ -582,13 +579,12 @@ void obj_shellLineProcess(PikaObj* self,
             /* still in block */
             if (is_in_block) {
                 /* load new line into buff */
-                Args* buffs = New_strBuff();
-                char _n = '\n';
+                Args buffs = {0};                char _n = '\n';
                 strAppendWithSize(rxBuff, &_n, 1);
                 char* shell_buff_new =
-                    strsAppend(buffs, obj_getStr(self, "shell_buff"), rxBuff);
+                    strsAppend(&buffs, obj_getStr(self, "shell_buff"), rxBuff);
                 obj_setStr(self, "shell_buff", shell_buff_new);
-                args_deinit(buffs);
+                strsDeinit(&buffs);
                 /* go out from block */
                 if (rxBuff[0] != ' ') {
                     is_in_block = 0;
@@ -626,7 +622,7 @@ void obj_shellLineProcess(PikaObj* self,
             continue;
         }
     }
-    args_deinit(buffs);
+    strsDeinit(&buffs);
 }
 
 static enum shell_state __obj_shellLineHandler_debuger(PikaObj* self,

src/PikaParser.c

@@ -47,7 +47,7 @@ uint16_t Lexer_getTokenSize(char* tokens) {
     return strCountSign(tokens, 0x1F) + 1;
 }
 
-char* strsPopTokenWithSkip_byStr(Args* buffs,
+char* strsPopTokenWithSkip_byStr(Args* buffs_p,
                                  char* stmts,
                                  char* str,
                                  char skipStart,
@@ -57,7 +57,7 @@ char* strsPopTokenWithSkip_byStr(Args* buffs,
     if (0 == size) {
         return NULL;
     }
-    char* strOut = args_getBuff(buffs, size);
+    char* strOut = args_getBuff(buffs_p, size);
     int32_t stmtEnd = 0;
     uint8_t isGetSign = 0;
     int32_t parentheseDeepth = 0;
@@ -87,26 +87,26 @@ char* strsPopTokenWithSkip_byStr(Args* buffs,
     return strOut;
 }
 
-char* strsPopTokenWithSkip(Args* buffs,
+char* strsPopTokenWithSkip(Args* buffs_p,
                            char* stmts,
                            char sign,
                            char skipStart,
                            char skipEnd) {
     char str_buff[2] = {0};
     str_buff[0] = sign;
-    return strsPopTokenWithSkip_byStr(buffs, stmts, str_buff, skipStart,
+    return strsPopTokenWithSkip_byStr(buffs_p, stmts, str_buff, skipStart,
                                       skipEnd);
 }
 
 char* strsGetCleanCmd(Args* outBuffs, char* cmd) {
     int32_t size = strGetSize(cmd);
-    Args* buffs = New_strBuff();
-    char* tokens = Lexer_getTokens(buffs, cmd);
+    Args buffs = {0};    
+    char* tokens = Lexer_getTokens(&buffs, cmd);
     uint16_t token_size = Lexer_getTokenSize(tokens);
     char* strOut = args_getBuff(outBuffs, size);
     int32_t iOut = 0;
     for (uint16_t i = 0; i < token_size; i++) {
-        char* token = strsPopToken(buffs, tokens, 0x1F);
+        char* token = strsPopToken(&buffs, tokens, 0x1F);
         for (uint16_t k = 0; k < strGetSize(token + 1); k++) {
             strOut[iOut] = token[k + 1];
             iOut++;
@@ -114,7 +114,7 @@ char* strsGetCleanCmd(Args* outBuffs, char* cmd) {
     }
     /* add \0 */
     strOut[iOut] = 0;
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return strOut;
 }
 
@@ -136,9 +136,9 @@ enum StmtType {
     STMT_none,
 };
 
-char* strsDeleteBetween(Args* buffs, char* strIn, char begin, char end) {
+char* strsDeleteBetween(Args* buffs_p, char* strIn, char begin, char end) {
     int32_t size = strGetSize(strIn);
-    char* strOut = args_getBuff(buffs, size);
+    char* strOut = args_getBuff(buffs_p, size);
     uint8_t deepth = 0;
     uint32_t iOut = 0;
     for (int i = 0; i < size; i++) {
@@ -158,24 +158,24 @@ char* strsDeleteBetween(Args* buffs, char* strIn, char begin, char end) {
 }
 
 static uint8_t Lexer_isError(char* line) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     uint8_t res = 0; /* not error */
-    char* tokens = Lexer_getTokens(buffs, line);
+    char* tokens = Lexer_getTokens(&buffs, line);
     if (NULL == tokens) {
         res = 1; /* lex error */
         goto exit;
     }
     goto exit;
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
 static enum StmtType Lexer_matchStmtType(char* right) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     enum StmtType stmtType = STMT_none;
-    char* rightWithoutSubStmt = strsDeleteBetween(buffs, right, '(', ')');
-    char* tokens = Lexer_getTokens(buffs, rightWithoutSubStmt);
+    char* rightWithoutSubStmt = strsDeleteBetween(&buffs, right, '(', ')');
+    char* tokens = Lexer_getTokens(&buffs, rightWithoutSubStmt);
     uint16_t token_size = strCountSign(tokens, 0x1F) + 1;
     uint8_t is_get_operator = 0;
     uint8_t is_get_method = 0;
@@ -183,7 +183,7 @@ static enum StmtType Lexer_matchStmtType(char* right) {
     uint8_t is_get_number = 0;
     uint8_t is_get_symbol = 0;
     for (int i = 0; i < token_size; i++) {
-        char* token = strsPopToken(buffs, tokens, 0x1F);
+        char* token = strsPopToken(&buffs, tokens, 0x1F);
         enum TokenType token_type = (enum TokenType)token[0];
         /* collect type */
         if (token_type == TOKEN_operator) {
@@ -228,7 +228,7 @@ static enum StmtType Lexer_matchStmtType(char* right) {
         goto exit;
     }
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return stmtType;
 }
 
@@ -248,33 +248,33 @@ uint8_t Parser_checkIsDirect(char* str) {
 
 char* Lexer_printTokens(Args* outBuffs, char* tokens) {
     /* init */
-    Args* buffs = New_strBuff();
-    char* printOut = strsCopy(buffs, "");
+    Args buffs = {0};    
+    char* printOut = strsCopy(&buffs, "");
 
     /* process */
     uint16_t tokenSize = strCountSign(tokens, 0x1F) + 1;
     for (uint16_t i = 0; i < tokenSize; i++) {
-        char* token = strsPopToken(buffs, tokens, 0x1F);
+        char* token = strsPopToken(&buffs, tokens, 0x1F);
         if (token[0] == TOKEN_operator) {
-            printOut = strsAppend(buffs, printOut, "{opt}");
-            printOut = strsAppend(buffs, printOut, token + 1);
+            printOut = strsAppend(&buffs, printOut, "{opt}");
+            printOut = strsAppend(&buffs, printOut, token + 1);
         }
         if (token[0] == TOKEN_devider) {
-            printOut = strsAppend(buffs, printOut, "{dvd}");
-            printOut = strsAppend(buffs, printOut, token + 1);
+            printOut = strsAppend(&buffs, printOut, "{dvd}");
+            printOut = strsAppend(&buffs, printOut, token + 1);
         }
         if (token[0] == TOKEN_symbol) {
-            printOut = strsAppend(buffs, printOut, "{sym}");
-            printOut = strsAppend(buffs, printOut, token + 1);
+            printOut = strsAppend(&buffs, printOut, "{sym}");
+            printOut = strsAppend(&buffs, printOut, token + 1);
         }
         if (token[0] == TOKEN_literal) {
-            printOut = strsAppend(buffs, printOut, "{lit}");
-            printOut = strsAppend(buffs, printOut, token + 1);
+            printOut = strsAppend(&buffs, printOut, "{lit}");
+            printOut = strsAppend(&buffs, printOut, token + 1);
         }
     }
     /* out put */
     printOut = strsCopy(outBuffs, printOut);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return printOut;
 }
 
@@ -282,16 +282,16 @@ Arg* Lexer_setToken(Arg* tokens_arg,
                     enum TokenType token_type,
                     char*
                     operator) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     char token_type_buff[3] = {0};
     token_type_buff[0] = 0x1F;
     token_type_buff[1] = token_type;
     char* tokens = arg_getStr(tokens_arg);
-    tokens = strsAppend(buffs, tokens, token_type_buff);
-    tokens = strsAppend(buffs, tokens, operator);
+    tokens = strsAppend(&buffs, tokens, token_type_buff);
+    tokens = strsAppend(&buffs, tokens, operator);
     Arg* new_tokens_arg = arg_setStr(tokens_arg, "", tokens);
     arg_deinit(tokens_arg);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return new_tokens_arg;
 }
 
@@ -299,14 +299,14 @@ Arg* Lexer_setSymbel(Arg* tokens_arg,
                      char* stmt,
                      int32_t i,
                      int32_t* symbol_start_index) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     char* symbol_buff = NULL;
     /* nothing to add symbel */
     if (i == *symbol_start_index) {
         *symbol_start_index = -1;
         goto exit;
     }
-    symbol_buff = args_getBuff(buffs, i - *symbol_start_index);
+    symbol_buff = args_getBuff(&buffs, i - *symbol_start_index);
     __platform_memcpy(symbol_buff, stmt + *symbol_start_index,
                       i - *symbol_start_index);
     /* literal */
@@ -320,7 +320,7 @@ Arg* Lexer_setSymbel(Arg* tokens_arg,
     }
     *symbol_start_index = -1;
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return tokens_arg;
 }
 
@@ -552,8 +552,8 @@ exit:
     return tokens;
 }
 
-char* Lexer_popToken(Args* buffs, char* tokens) {
-    return strsPopToken(buffs, tokens, 0x1F);
+char* Lexer_popToken(Args* buffs_p, char* tokens) {
+    return strsPopToken(buffs_p, tokens, 0x1F);
 }
 
 enum TokenType Lexer_getTokenType(char* token) {
@@ -565,12 +565,12 @@ char* Lexer_getTokenPyload(char* token) {
 }
 
 uint8_t Lexer_isContain(char* tokens, enum TokenType token_type, char* pyload) {
-    Args* buffs = New_strBuff();
-    char* tokens_buff = strsCopy(buffs, tokens);
+    Args buffs = {0};    
+    char* tokens_buff = strsCopy(&buffs, tokens);
     uint8_t res = 0;
     uint16_t token_size = Lexer_getTokenSize(tokens);
     for (int i = 0; i < token_size; i++) {
-        char* token = Lexer_popToken(buffs, tokens_buff);
+        char* token = Lexer_popToken(&buffs, tokens_buff);
         if (token_type == Lexer_getTokenType(token)) {
             if (strEqu(Lexer_getTokenPyload(token), pyload)) {
                 res = 1;
@@ -579,13 +579,13 @@ uint8_t Lexer_isContain(char* tokens, enum TokenType token_type, char* pyload) {
         }
     }
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
 char* Lexer_getOperator(Args* outBuffs, char* stmt) {
-    Args* buffs = New_strBuff();
-    char* tokens = Lexer_getTokens(buffs, stmt);
+    Args buffs = {0};    
+    char* tokens = Lexer_getTokens(&buffs, stmt);
     char* operator= NULL;
     const char operators[][6] = {
         "**", "~",   "*",  "/",  "%",  "//",  "+",     "-",     ">>",  "<<",
@@ -593,12 +593,12 @@ char* Lexer_getOperator(Args* outBuffs, char* stmt) {
         "/=", "//=", "-=", "+=", "*=", "**=", " not ", " and ", " or "};
     for (uint32_t i = 0; i < sizeof(operators) / 6; i++) {
         if (Lexer_isContain(tokens, TOKEN_operator, (char*)operators[i])) {
-            operator= strsCopy(buffs, (char*)operators[i]);
+            operator= strsCopy(&buffs, (char*)operators[i]);
         }
     }
     /* out put */
     operator= strsCopy(outBuffs, operator);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return operator;
 }
 
@@ -615,7 +615,7 @@ struct ParserState {
     struct LexToken token2;
     Arg* last_token;
     Args* iter_buffs;
-    Args* buffs;
+    Args* buffs_p;
 };
 
 void LexToken_update(struct LexToken* lex_token) {
@@ -645,7 +645,7 @@ void ParserState_init(struct ParserState* ps) {
     ps->length = 0;
     ps->last_token = NULL;
     ps->iter_buffs = NULL;
-    ps->buffs = New_strBuff();
+    ps->buffs_p = New_strBuff();
     LexToken_init(&ps->token1);
     LexToken_init(&ps->token2);
 }
@@ -658,19 +658,19 @@ void ParserState_deinit(struct ParserState* ps) {
     if (NULL != ps->last_token) {
         arg_deinit(ps->last_token);
     }
-    args_deinit(ps->buffs);
+    args_deinit(ps->buffs_p);
 }
 
 void ParserState_parse(struct ParserState* ps, char* stmt) {
-    ps->tokens = Lexer_getTokens(ps->buffs, stmt);
+    ps->tokens = Lexer_getTokens(ps->buffs_p, stmt);
     ps->length = Lexer_getTokenSize(ps->tokens);
 }
 
 void ParserState_beforeIter(struct ParserState* ps) {
     /* clear first token */
-    Lexer_popToken(ps->buffs, ps->tokens);
+    Lexer_popToken(ps->buffs_p, ps->tokens);
     ps->last_token =
-        arg_setStr(NULL, "", Lexer_popToken(ps->buffs, ps->tokens));
+        arg_setStr(NULL, "", Lexer_popToken(ps->buffs_p, ps->tokens));
 }
 
 char* Parser_solveBranckets(Args* outBuffs,
@@ -678,10 +678,10 @@ char* Parser_solveBranckets(Args* outBuffs,
                             char* stmt,
                             char* mode) {
     /* init objects */
-    Args* buffs = New_args(NULL);
+    Args buffs = {0};    
     Arg* right_arg = arg_setStr(NULL, "", "");
     uint8_t is_in_brancket = 0;
-    args_setStr(buffs, "index", "");
+    args_setStr(&buffs, "index", "");
     /* init parserState */
     struct ParserState ps;
     ParserState_init(&ps);
@@ -709,15 +709,15 @@ char* Parser_solveBranckets(Args* outBuffs,
         /* matched [] */
         if ((TOKEN_devider == ps.token2.type) &&
             (strEqu(ps.token2.pyload, "["))) {
-            args_setStr(buffs, "obj", ps.token1.pyload);
+            args_setStr(&buffs, "obj", ps.token1.pyload);
             is_in_brancket = 1;
         } else if ((TOKEN_devider == ps.token2.type) &&
                    (strEqu(ps.token2.pyload, "]"))) {
             is_in_brancket = 0;
-            char* index = args_getStr(buffs, "index");
+            char* index = args_getStr(&buffs, "index");
             Arg* index_arg = arg_setStr(NULL, "", index);
             index_arg = arg_strAppend(index_arg, ps.token1.pyload);
-            args_setStr(buffs, "index", arg_getStr(index_arg));
+            args_setStr(&buffs, "index", arg_getStr(index_arg));
             arg_deinit(index_arg);
 
             if (strEqu(mode, "right")) {
@@ -725,25 +725,25 @@ char* Parser_solveBranckets(Args* outBuffs,
             } else if (strEqu(mode, "left")) {
                 right_arg = arg_strAppend(right_arg, "__set__(");
             }
-            right_arg = arg_strAppend(right_arg, args_getStr(buffs, "obj"));
+            right_arg = arg_strAppend(right_arg, args_getStr(&buffs, "obj"));
             right_arg = arg_strAppend(right_arg, ",");
-            right_arg = arg_strAppend(right_arg, args_getStr(buffs, "index"));
+            right_arg = arg_strAppend(right_arg, args_getStr(&buffs, "index"));
             if (strEqu(mode, "left")) {
                 right_arg = arg_strAppend(right_arg, ",");
                 right_arg = arg_strAppend(right_arg, stmt);
                 right_arg = arg_strAppend(right_arg,
                                           ","
                                           "'");
-                right_arg = arg_strAppend(right_arg, args_getStr(buffs, "obj"));
+                right_arg = arg_strAppend(right_arg, args_getStr(&buffs, "obj"));
                 right_arg = arg_strAppend(right_arg, "'");
             }
             right_arg = arg_strAppend(right_arg, ")");
-            args_setStr(buffs, "index", "");
+            args_setStr(&buffs, "index", "");
         } else if (is_in_brancket && (!strEqu(ps.token1.pyload, "["))) {
-            char* index = args_getStr(buffs, "index");
+            char* index = args_getStr(&buffs, "index");
             Arg* index_arg = arg_setStr(NULL, "", index);
             index_arg = arg_strAppend(index_arg, ps.token1.pyload);
-            args_setStr(buffs, "index", arg_getStr(index_arg));
+            args_setStr(&buffs, "index", arg_getStr(index_arg));
             arg_deinit(index_arg);
         } else if (!is_in_brancket && (!strEqu(ps.token1.pyload, "]"))) {
             right_arg = arg_strAppend(right_arg, ps.token1.pyload);
@@ -756,7 +756,7 @@ exit:
     content = strsCopy(outBuffs, arg_getStr(right_arg));
     ParserState_deinit(&ps);
     arg_deinit(right_arg);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return content;
 }
 
@@ -769,8 +769,8 @@ char* Parser_solveLeftBranckets(Args* outBuffs, char* right, char* left) {
 }
 
 AST* AST_parseStmt(AST* ast, char* stmt) {
-    Args* buffs = New_strBuff();
-    char* assignment = strsGetFirstToken(buffs, stmt, '(');
+    Args buffs = {0};    
+    char* assignment = strsGetFirstToken(&buffs, stmt, '(');
     char* method = NULL;
     char* ref = NULL;
     char* str = NULL;
@@ -783,17 +783,17 @@ AST* AST_parseStmt(AST* ast, char* stmt) {
         isLeftExist = 1;
     }
     if (isLeftExist) {
-        left = strsGetFirstToken(buffs, assignment, '=');
+        left = strsGetFirstToken(&buffs, assignment, '=');
     }
     /* solve right stmt */
     if (isLeftExist) {
-        right = strPointToLastToken( stmt, '=');
+        right = strPointToLastToken(stmt, '=');
     } else {
         right = stmt;
     }
     /* solve the [] stmt */
-    right = Parser_solveRightBranckets(buffs, right);
-    char* right_new = Parser_solveLeftBranckets(buffs, right, left);
+    right = Parser_solveRightBranckets(&buffs, right);
+    char* right_new = Parser_solveLeftBranckets(&buffs, right, left);
     /* left is contain the '[]' */
     if (!strEqu(right_new, right)) {
         /* update new right */
@@ -808,12 +808,12 @@ AST* AST_parseStmt(AST* ast, char* stmt) {
     enum StmtType stmtType = Lexer_matchStmtType(right);
     /* solve operator stmt */
     if (STMT_operator == stmtType) {
-        char* rightWithoutSubStmt = strsDeleteBetween(buffs, right, '(', ')');
-        char* operator= Lexer_getOperator(buffs, rightWithoutSubStmt);
+        char* rightWithoutSubStmt = strsDeleteBetween(&buffs, right, '(', ')');
+        char* operator= Lexer_getOperator(&buffs, rightWithoutSubStmt);
         obj_setStr(ast, (char*)"operator", operator);
-        char* rightBuff = strsCopy(buffs, right);
+        char* rightBuff = strsCopy(&buffs, right);
         char* subStmt1 =
-            strsPopTokenWithSkip_byStr(buffs, rightBuff, operator, '(', ')');
+            strsPopTokenWithSkip_byStr(&buffs, rightBuff, operator, '(', ')');
         char* subStmt2 = rightBuff;
         queueObj_pushObj(ast, (char*)"stmt");
         AST_parseStmt(queueObj_getCurrentObj(ast), subStmt1);
@@ -823,11 +823,11 @@ AST* AST_parseStmt(AST* ast, char* stmt) {
     }
     /* solve method stmt */
     if (STMT_method == stmtType) {
-        method = strsGetFirstToken(buffs, right, '(');
+        method = strsGetFirstToken(&buffs, right, '(');
         obj_setStr(ast, (char*)"method", method);
-        char* subStmts = strsCut(buffs, right, '(', ')');
+        char* subStmts = strsCut(&buffs, right, '(', ')');
         /* add ',' at the end */
-        subStmts = strsAppend(buffs, subStmts, ",");
+        subStmts = strsAppend(&buffs, subStmts, ",");
         struct ParserState ps;
         /* init parserStage */
         ParserState_init(&ps);
@@ -885,8 +885,8 @@ AST* AST_parseStmt(AST* ast, char* stmt) {
     /* solve str stmt */
     if (STMT_string == stmtType) {
         str = right;
-        str = strsDeleteChar(buffs, str, '\'');
-        str = strsDeleteChar(buffs, str, '\"');
+        str = strsDeleteChar(&buffs, str, '\'');
+        str = strsDeleteChar(&buffs, str, '\"');
         obj_setStr(ast, (char*)"string", str);
         goto exit;
     }
@@ -897,7 +897,7 @@ AST* AST_parseStmt(AST* ast, char* stmt) {
         goto exit;
     }
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return ast;
 }
 
@@ -961,7 +961,7 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
     }
     /* init data */
     AST* ast = New_queueObj();
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     uint8_t block_deepth, block_deepth_last;
     char *line_start, *stmt;
     /* get block deepth */
@@ -1002,7 +1002,7 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
         uint8_t keyword_len = strGetSize(keyword);
         if (strIsStartWith(line_start, keyword) &&
             (line_start[keyword_len] == ' ')) {
-            stmt = strsCut(buffs, line_start, ' ', ':');
+            stmt = strsCut(&buffs, line_start, ' ', ':');
             obj_setStr(ast, "block", keyword);
             if (NULL != block_stack) {
                 stack_pushStr(block_stack, keyword);
@@ -1036,7 +1036,7 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
         char* list_in = strsPopToken(list_buffs, line_buff, ':');
         list_in = strsAppend(list_buffs, "iter(", list_in);
         list_in = strsAppend(list_buffs, list_in, ")");
-        list_in = strsCopy(buffs, list_in);
+        list_in = strsCopy(&buffs, list_in);
         args_deinit(list_buffs);
         obj_setStr(ast, "block", "for");
         obj_setStr(ast, "list_in", list_in);
@@ -1063,8 +1063,8 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
         goto block_matched;
     }
     if (strIsStartWith(line_start, "return ")) {
-        char* lineBuff = strsCopy(buffs, line_start);
-        strsPopToken(buffs, lineBuff, ' ');
+        char* lineBuff = strsCopy(&buffs, line_start);
+        strsPopToken(&buffs, lineBuff, ' ');
         stmt = lineBuff;
         obj_setStr(ast, "return", "");
         goto block_matched;
@@ -1072,14 +1072,14 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
     if (strIsStartWith(line_start, "global ")) {
         stmt = "";
         char* global_list = line_start + 7;
-        global_list = strsGetCleanCmd(buffs, global_list);
+        global_list = strsGetCleanCmd(&buffs, global_list);
         obj_setStr(ast, "global", global_list);
         goto block_matched;
     }
     if (strIsStartWith(line_start, (char*)"def ")) {
         stmt = "";
-        char* declear = strsCut(buffs, line_start, ' ', ':');
-        declear = strsGetCleanCmd(buffs, declear);
+        char* declear = strsCut(&buffs, line_start, ' ', ':');
+        declear = strsGetCleanCmd(&buffs, declear);
         obj_setStr(ast, "block", "def");
         obj_setStr(ast, "declear", declear);
         if (NULL != block_stack) {
@@ -1089,8 +1089,8 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
     }
     if (strIsStartWith(line_start, (char*)"class ")) {
         stmt = "";
-        char* declear = strsCut(buffs, line_start, ' ', ':');
-        declear = strsGetCleanCmd(buffs, declear);
+        char* declear = strsCut(&buffs, line_start, ' ', ':');
+        declear = strsGetCleanCmd(&buffs, declear);
         obj_setStr(ast, "block", "class");
         obj_setStr(ast, "declear", declear);
         if (NULL != block_stack) {
@@ -1100,33 +1100,33 @@ AST* AST_parseLine(char* line, Stack* block_stack) {
     }
 
 block_matched:
-    stmt = strsGetCleanCmd(buffs, stmt);
+    stmt = strsGetCleanCmd(&buffs, stmt);
     ast = AST_parseStmt(ast, stmt);
     goto exit;
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return ast;
 }
 
-static char* Parser_linePreProcess(Args* buffs, char* line) {
+static char* Parser_linePreProcess(Args* buffs_p, char* line) {
     /* check syntex error */
     if (Lexer_isError(line)) {
         line = NULL;
         goto exit;
     }
     /* process EOL */
-    line = strsDeleteChar(buffs, line, '\r');
+    line = strsDeleteChar(buffs_p, line, '\r');
     line = Parser_removeAnnotation(line);
 
 exit:
     return line;
 }
 
-char* Parser_LineToAsm(Args* buffs, char* line, Stack* blockStack) {
+char* Parser_LineToAsm(Args* buffs_p, char* line, Stack* blockStack) {
     char* ASM = NULL;
     AST* ast = NULL;
     /* pre process */
-    line = Parser_linePreProcess(buffs, line);
+    line = Parser_linePreProcess(buffs_p, line);
     if (NULL == line) {
         /* preprocess error */
         goto exit;
@@ -1140,7 +1140,7 @@ char* Parser_LineToAsm(Args* buffs, char* line, Stack* blockStack) {
     /* parse tokens to AST */
     ast = AST_parseLine(line, blockStack);
     /* gen ASM from AST */
-    ASM = AST_toPikaASM(ast, buffs);
+    ASM = AST_toPikaASM(ast, buffs_p);
 exit:
     if (NULL != ast) {
         AST_deinit(ast);
@@ -1148,7 +1148,7 @@ exit:
     return ASM;
 }
 
-static Arg* ASM_saveSingleASM(Args* buffs,
+static Arg* ASM_saveSingleASM(Args* buffs_p,
                               Arg* pikaAsmBuff,
                               char* singleAsm,
                               uint8_t isToFlash) {
@@ -1163,7 +1163,7 @@ static Arg* ASM_saveSingleASM(Args* buffs,
     }
 
     char* pikaAsm = arg_getStr(pikaAsmBuff);
-    pikaAsm = strsAppend(buffs, pikaAsm, singleAsm);
+    pikaAsm = strsAppend(buffs_p, pikaAsm, singleAsm);
     arg_deinit(pikaAsmBuff);
     pikaAsmBuff = arg_setStr(NULL, "", pikaAsm);
     return pikaAsmBuff;
@@ -1186,21 +1186,21 @@ char* Parser_multiLineToAsm(Args* outBuffs, char* multi_line) {
     char* out_ASM = NULL;
     /* parse each line */
     while (1) {
-        Args* buffs = New_strBuff();
+        Args buffs = {0};        
         /* get single line by pop multiline */
-        char* line = strsGetFirstToken(buffs, multi_line + line_offset, '\n');
+        char* line = strsGetFirstToken(&buffs, multi_line + line_offset, '\n');
         uint32_t line_size = strGetSize(line);
         line_offset = line_offset + line_size + 1;
         /* parse single Line to Asm */
-        char* single_ASM = Parser_LineToAsm(buffs, line, block_stack);
+        char* single_ASM = Parser_LineToAsm(&buffs, line, block_stack);
         if (NULL == single_ASM) {
             out_ASM = NULL;
-            args_deinit(buffs);
+            strsDeinit(&buffs);
             goto exit;
         }
         /* save ASM */
-        asm_buff = ASM_saveSingleASM(buffs, asm_buff, single_ASM, is_to_flash);
-        args_deinit(buffs);
+        asm_buff = ASM_saveSingleASM(&buffs, asm_buff, single_ASM, is_to_flash);
+        strsDeinit(&buffs);
         /* exit when finished */
         if (line_offset >= multi_line_size) {
             break;
@@ -1223,14 +1223,14 @@ exit:
 
 char* AST_appandPikaASM(AST* ast, AST* subAst, Args* outBuffs, char* pikaAsm) {
     int deepth = obj_getInt(ast, "deepth");
-    Args* buffs = New_strBuff();
+    Args buffs = {0};    
     while (1) {
         QueueObj* subStmt = queueObj_popObj(subAst);
         if (NULL == subStmt) {
             break;
         }
         obj_setInt(ast, "deepth", deepth + 1);
-        pikaAsm = AST_appandPikaASM(ast, subStmt, buffs, pikaAsm);
+        pikaAsm = AST_appandPikaASM(ast, subStmt, &buffs, pikaAsm);
     }
     char* method = obj_getStr(subAst, "method");
     char* operator= obj_getStr(subAst, "operator");
@@ -1238,55 +1238,55 @@ char* AST_appandPikaASM(AST* ast, AST* subAst, Args* outBuffs, char* pikaAsm) {
     char* left = obj_getStr(subAst, "left");
     char* str = obj_getStr(subAst, "string");
     char* num = obj_getStr(subAst, "num");
-    char* buff = args_getBuff(buffs, PIKA_CONFIG_SPRINTF_BUFF_SIZE);
+    char* buff = args_getBuff(&buffs, PIKA_CONFIG_SPRINTF_BUFF_SIZE);
     if (NULL != ref) {
         __platform_sprintf(buff, "%d REF %s\n", deepth, ref);
-        pikaAsm = strsAppend(buffs, pikaAsm, buff);
+        pikaAsm = strsAppend(&buffs, pikaAsm, buff);
     }
     if (NULL != operator) {
         __platform_sprintf(buff, "%d OPT %s\n", deepth, operator);
-        pikaAsm = strsAppend(buffs, pikaAsm, buff);
+        pikaAsm = strsAppend(&buffs, pikaAsm, buff);
     }
     if (NULL != method) {
         __platform_sprintf(buff, "%d RUN %s\n", deepth, method);
-        pikaAsm = strsAppend(buffs, pikaAsm, buff);
+        pikaAsm = strsAppend(&buffs, pikaAsm, buff);
     }
     if (NULL != str) {
         __platform_sprintf(buff, "%d STR %s\n", deepth, str);
-        pikaAsm = strsAppend(buffs, pikaAsm, buff);
+        pikaAsm = strsAppend(&buffs, pikaAsm, buff);
     }
     if (NULL != num) {
         __platform_sprintf(buff, "%d NUM %s\n", deepth, num);
-        pikaAsm = strsAppend(buffs, pikaAsm, buff);
+        pikaAsm = strsAppend(&buffs, pikaAsm, buff);
     }
     if (NULL != left) {
         __platform_sprintf(buff, "%d OUT %s\n", deepth, left);
-        pikaAsm = strsAppend(buffs, pikaAsm, buff);
+        pikaAsm = strsAppend(&buffs, pikaAsm, buff);
     }
     obj_setInt(ast, "deepth", deepth - 1);
     goto exit;
 exit:
     pikaAsm = strsCopy(outBuffs, pikaAsm);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return pikaAsm;
 }
 
 char* ASM_addBlockDeepth(AST* ast,
-                         Args* buffs,
+                         Args* buffs_p,
                          char* pikaAsm,
                          uint8_t deepthOffset) {
-    pikaAsm = strsAppend(buffs, pikaAsm, (char*)"B");
+    pikaAsm = strsAppend(buffs_p, pikaAsm, (char*)"B");
     char buff[11];
     pikaAsm = strsAppend(
-        buffs, pikaAsm,
+        buffs_p, pikaAsm,
         fast_itoa(buff, obj_getInt(ast, "blockDeepth") + deepthOffset));
-    pikaAsm = strsAppend(buffs, pikaAsm, (char*)"\n");
+    pikaAsm = strsAppend(buffs_p, pikaAsm, (char*)"\n");
     return pikaAsm;
 }
 
 char* AST_toPikaASM(AST* ast, Args* outBuffs) {
-    Args* buffs = New_strBuff();
-    char* pikaAsm = strsCopy(buffs, "");
+    Args buffs = {0};    
+    char* pikaAsm = strsCopy(&buffs, "");
     QueueObj* exitBlock = obj_getObj(ast, "exitBlock", 0);
     /* exiting from block */
     if (exitBlock != NULL) {
@@ -1356,7 +1356,7 @@ char* AST_toPikaASM(AST* ast, Args* outBuffs) {
         _l_x[sizeof(_l_x) - 2] = block_deepth_char;
         /* init iter */
         /*     get the iter(_l<x>) */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
         newAsm_arg = arg_strAppend(newAsm_arg, "0 OUT ");
         newAsm_arg = arg_strAppend(newAsm_arg, _l_x);
         newAsm_arg = arg_strAppend(newAsm_arg, "\n");
@@ -1377,7 +1377,7 @@ char* AST_toPikaASM(AST* ast, Args* outBuffs) {
             newAsm_arg = arg_strAppend(newAsm_arg, _l_x);
             newAsm_arg = arg_strAppend(newAsm_arg, ".a3\n");
         }
-        pikaAsm = strsAppend(buffs, pikaAsm, arg_getStr(newAsm_arg));
+        pikaAsm = strsAppend(&buffs, pikaAsm, arg_getStr(newAsm_arg));
         arg_deinit(newAsm_arg);
         newAsm_arg = arg_setStr(NULL, "", "");
         /* get next */
@@ -1395,43 +1395,43 @@ char* AST_toPikaASM(AST* ast, Args* outBuffs) {
                                    "0 EST ");
         newAsm_arg = arg_strAppend(newAsm_arg, arg_in);
         newAsm_arg = arg_strAppend(newAsm_arg, "\n0 JEZ 2\n");
-        pikaAsm = strsAppend(buffs, pikaAsm, arg_getStr(newAsm_arg));
+        pikaAsm = strsAppend(&buffs, pikaAsm, arg_getStr(newAsm_arg));
         arg_deinit(newAsm_arg);
         is_block_matched = 1;
         goto exit;
     }
     if (strEqu(obj_getStr(ast, "block"), "while")) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 JEZ 2\n");
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 JEZ 2\n");
         is_block_matched = 1;
         goto exit;
     }
     if (strEqu(obj_getStr(ast, "block"), "if")) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 JEZ 1\n");
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 JEZ 1\n");
         is_block_matched = 1;
         goto exit;
     }
     if (strEqu(obj_getStr(ast, "block"), "else")) {
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 NEL 1\n");
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 NEL 1\n");
         goto exit;
     }
     if (strEqu(obj_getStr(ast, "block"), "elif")) {
         /* skip if __else is 0 */
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 NEL 1\n");
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 NEL 1\n");
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
         /* skip if stmt is 0 */
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 JEZ 1\n");
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 JEZ 1\n");
         is_block_matched = 1;
         goto exit;
     }
     if (strEqu(obj_getStr(ast, "block"), "def")) {
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 DEF ");
-        pikaAsm = strsAppend(buffs, pikaAsm, obj_getStr(ast, "declear"));
-        pikaAsm = strsAppend(buffs, pikaAsm,
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 DEF ");
+        pikaAsm = strsAppend(&buffs, pikaAsm, obj_getStr(ast, "declear"));
+        pikaAsm = strsAppend(&buffs, pikaAsm,
                              "\n"
                              "0 JMP 1\n");
         is_block_matched = 1;
@@ -1439,13 +1439,13 @@ char* AST_toPikaASM(AST* ast, Args* outBuffs) {
     }
 
     if (strEqu(obj_getStr(ast, "block"), "class")) {
-        Args* buffs = New_strBuff();
+        Args buffs = {0};        
         char* declear = obj_getStr(ast, "declear");
         char* thisClass = NULL;
         char* superClass = NULL;
         if (strIsContain(declear, '(')) {
-            thisClass = strsGetFirstToken(buffs, declear, '(');
-            superClass = strsCut(buffs, declear, '(', ')');
+            thisClass = strsGetFirstToken(&buffs, declear, '(');
+            superClass = strsCut(&buffs, declear, '(', ')');
         } else {
             thisClass = declear;
             superClass = "";
@@ -1454,66 +1454,66 @@ char* AST_toPikaASM(AST* ast, Args* outBuffs) {
             /* default superClass */
             superClass = "PikaStdLib.PikaObj";
         }
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 DEF ");
-        pikaAsm = strsAppend(buffs, pikaAsm,
-                             strsAppend(buffs, thisClass,
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 DEF ");
+        pikaAsm = strsAppend(&buffs, pikaAsm,
+                             strsAppend(&buffs, thisClass,
                                         "()\n"
                                         "0 JMP 1\n"));
         char block_deepth_str[] = "B0\n";
         /* goto deeper block */
         block_deepth_str[1] += obj_getInt(ast, "blockDeepth") + 1;
-        pikaAsm = strsAppend(buffs, pikaAsm, block_deepth_str);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 RUN ");
-        pikaAsm = strsAppend(buffs, pikaAsm, superClass);
-        pikaAsm = strsAppend(buffs, pikaAsm, "\n");
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 OUT self\n");
-        pikaAsm = strsAppend(buffs, pikaAsm, block_deepth_str);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 RAS self\n");
+        pikaAsm = strsAppend(&buffs, pikaAsm, block_deepth_str);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 RUN ");
+        pikaAsm = strsAppend(&buffs, pikaAsm, superClass);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "\n");
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 OUT self\n");
+        pikaAsm = strsAppend(&buffs, pikaAsm, block_deepth_str);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 RAS self\n");
 
         is_block_matched = 1;
-        args_deinit(buffs);
+        strsDeinit(&buffs);
         goto exit;
     }
 
     if (obj_isArgExist(ast, "return")) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 RET\n");
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 RET\n");
         is_block_matched = 1;
         goto exit;
     }
     if (obj_isArgExist(ast, "global")) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 GLB ");
-        pikaAsm = strsAppend(buffs, pikaAsm, obj_getStr(ast, "global"));
-        pikaAsm = strsAppend(buffs, pikaAsm, "\n");
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 GLB ");
+        pikaAsm = strsAppend(&buffs, pikaAsm, obj_getStr(ast, "global"));
+        pikaAsm = strsAppend(&buffs, pikaAsm, "\n");
         is_block_matched = 1;
         goto exit;
     }
     if (obj_isArgExist(ast, "break")) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 BRK\n");
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 BRK\n");
         is_block_matched = 1;
         goto exit;
     }
     if (obj_isArgExist(ast, "continue")) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
-        pikaAsm = strsAppend(buffs, pikaAsm, "0 CTN\n");
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
+        pikaAsm = strsAppend(&buffs, pikaAsm, "0 CTN\n");
         is_block_matched = 1;
         goto exit;
     }
 exit:
     if (!is_block_matched) {
         /* parse stmt ast */
-        pikaAsm = AST_appandPikaASM(ast, ast, buffs, pikaAsm);
+        pikaAsm = AST_appandPikaASM(ast, ast, &buffs, pikaAsm);
     }
 
     /* output pikaAsm */
     pikaAsm = strsCopy(outBuffs, pikaAsm);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return pikaAsm;
 }
 

src/PikaVM.c

@@ -200,7 +200,7 @@ static Arg* VM_instruction_handler_REF(PikaObj* self, VMState* vs, char* data) {
 }
 
 static Arg* VM_instruction_handler_RUN(PikaObj* self, VMState* vs, char* data) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
     Arg* return_arg = NULL;
     VMParameters* sub_locals = NULL;
     char* methodPath = data;
@@ -244,12 +244,12 @@ static Arg* VM_instruction_handler_RUN(PikaObj* self, VMState* vs, char* data) {
     /* get method Ptr */
     method_ptr = (Method)methodArg_getPtr(method_arg);
     /* get method Decleartion */
-    method_dec = strsCopy(buffs, methodArg_getDec(method_arg));
+    method_dec = strsCopy(&buffs, methodArg_getDec(method_arg));
     arg_deinit(method_arg);
     method_type = arg_getType(method_arg);
 
     /* get type list */
-    type_list = strsCut(buffs, method_dec, '(', ')');
+    type_list = strsCut(&buffs, method_dec, '(', ')');
 
     if (type_list == NULL) {
         /* typeList no found */
@@ -272,8 +272,8 @@ static Arg* VM_instruction_handler_RUN(PikaObj* self, VMState* vs, char* data) {
         if (NULL == call_arg) {
             break;
         }
-        char* argDef = strsPopToken(buffs, type_list, ',');
-        char* argName = strsGetFirstToken(buffs, argDef, ':');
+        char* argDef = strsPopToken(&buffs, type_list, ',');
+        char* argName = strsGetFirstToken(&buffs, argDef, ':');
         call_arg = arg_setName(call_arg, argName);
         args_setArg(sub_locals->list, call_arg);
         call_arg_index++;
@@ -313,7 +313,7 @@ RUN_exit:
     if (NULL != sub_locals) {
         obj_deinit(sub_locals);
     }
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return return_arg;
 }
 
@@ -457,12 +457,12 @@ static Arg* VM_instruction_handler_OPT(PikaObj* self, VMState* vs, char* data) {
         if ((type_arg1 == ARG_TYPE_STRING) && (type_arg2 == ARG_TYPE_STRING)) {
             char* num1_s = NULL;
             char* num2_s = NULL;
-            Args* str_opt_buffs = New_strBuff();
+            Args str_opt_buffs = {0};
             num1_s = arg_getStr(arg1);
             num2_s = arg_getStr(arg2);
-            char* opt_str_out = strsAppend(str_opt_buffs, num1_s, num2_s);
+            char* opt_str_out = strsAppend(&str_opt_buffs, num1_s, num2_s);
             outArg = arg_setStr(outArg, "", opt_str_out);
-            args_deinit(str_opt_buffs);
+            strsDeinit(&str_opt_buffs);
             goto OPT_exit;
         }
         /* match float */
@@ -714,7 +714,7 @@ int32_t pikaVM_runAsmLine(PikaObj* self,
                           VMParameters* globals,
                           char* pikaAsm,
                           int32_t lineAddr) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
     VMState vs = {
         .locals = locals,
         .globals = globals,
@@ -724,7 +724,7 @@ int32_t pikaVM_runAsmLine(PikaObj* self,
         .pc = pikaAsm + lineAddr,
         .ASM_start = pikaAsm,
     };
-    char* line = strsGetLine(buffs, vs.pc);
+    char* line = strsGetLine(&buffs, vs.pc);
     int32_t nextAddr = lineAddr + strGetSize(line) + 1;
     enum Instruct instruct;
     char invokeDeepth0[2] = {0}, invokeDeepth1[2] = {0};
@@ -760,7 +760,7 @@ int32_t pikaVM_runAsmLine(PikaObj* self,
     }
     goto nextLine;
 nextLine:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     /* exit */
     if (-999 == vs.jmp) {
         return -99999;
@@ -804,10 +804,10 @@ VMParameters* pikaVM_runAsmWithPars(PikaObj* self,
             __platform_printf("%s\r\n", sysOut);
         }
         if (0 != errcode) {
-            Args* buffs = New_strBuff();
-            char* onlyThisLine = strsGetFirstToken(buffs, thisLine, '\n');
+            Args buffs = {0};
+            char* onlyThisLine = strsGetFirstToken(&buffs, thisLine, '\n');
             __platform_printf("[info] input commond: %s\r\n", onlyThisLine);
-            args_deinit(buffs);
+            strsDeinit(&buffs);
         }
     }
     __clearInvokeQueues(locals);
@@ -820,9 +820,10 @@ VMParameters* pikaVM_runAsm(PikaObj* self, char* pikaAsm) {
 }
 
 VMParameters* pikaVM_run(PikaObj* self, char* multiLine) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
+    Args* buffs_p = &buffs;
     VMParameters* globals = NULL;
-    char* pikaAsm = Parser_multiLineToAsm(buffs, multiLine);
+    char* pikaAsm = Parser_multiLineToAsm(&buffs, multiLine);
     if (NULL == pikaAsm) {
         __platform_printf("[error]: Syntax error.\r\n");
         globals = NULL;
@@ -832,15 +833,15 @@ VMParameters* pikaVM_run(PikaObj* self, char* multiLine) {
     if ((1 == __platform_save_pikaAsm("")) &&
         (!obj_isArgExist(self, "__asm"))) {
         obj_setStr(self, "__asm", pikaAsm);
-        args_deinit(buffs);
-        buffs = NULL;
+        strsDeinit(&buffs);
+        buffs_p = NULL;
         pikaAsm = obj_getStr(self, "__asm");
     }
     globals = pikaVM_runAsm(self, pikaAsm);
     goto exit;
 exit:
-    if (NULL != buffs) {
-        args_deinit(buffs);
+    if (NULL != buffs_p) {
+        strsDeinit(&buffs);
     }
     return globals;
 }

src/dataArgs.c

@@ -239,43 +239,39 @@ int32_t args_setArg(Args* self, Arg* arg) {
     return 0;
 }
 
-
 #ifndef __PIKA_CFG_HASH_LIST_CACHE_SIZE
-#define __PIKA_CFG_HASH_LIST_CACHE_SIZE     4
+#define __PIKA_CFG_HASH_LIST_CACHE_SIZE 4
 #endif
 
 LinkNode* args_getNode_hash(Args* self, Hash nameHash) {
-    
-    LinkNode ** ppnode = (LinkNode **)&(self->firstNode);
+    LinkNode** ppnode = (LinkNode**)&(self->firstNode);
     int_fast8_t n = 0;
-    
+
     while (NULL != (*ppnode)) {
         Arg* arg = (*ppnode);
         Hash thisNameHash = arg_getNameHash(arg);
         if (thisNameHash == nameHash) {
-        
-            __arg *tmp = (__arg *)(*ppnode);
+            __arg* tmp = (__arg*)(*ppnode);
             if (n > __PIKA_CFG_HASH_LIST_CACHE_SIZE) {
-
-                /* the first __PIKA_CFG_HASH_LIST_CACHE_SIZE items in the list 
-                 * is considered as a cache. 
+                /* the first __PIKA_CFG_HASH_LIST_CACHE_SIZE items in the list
+                 * is considered as a cache.
                  * Don't make __PIKA_CFG_HASH_LIST_CACHE_SIZE too big, otherwise
                  * this optimisation is useless.
                  */
-             
+
                 /*! remove current node from the list */
-                (*ppnode) = (LinkNode *)(tmp->next);
-                
+                (*ppnode) = (LinkNode*)(tmp->next);
+
                 /*! move the node to the cache */
-                tmp->next = (__arg *)(self->firstNode);
-                self->firstNode = (LinkNode *)tmp;
+                tmp->next = (__arg*)(self->firstNode);
+                self->firstNode = (LinkNode*)tmp;
             }
-            return (LinkNode *)tmp;
+            return (LinkNode*)tmp;
         }
         n++;
-        ppnode = (LinkNode **)&(((__arg *)(*ppnode))->next);
+        ppnode = (LinkNode**)&(((__arg*)(*ppnode))->next);
     }
-    
+
     return NULL;
 }
 
@@ -311,47 +307,47 @@ Arg* args_getArg_index(Args* self, int index) {
 }
 
 char* getPrintSring(Args* self, char* name, char* valString) {
-    Args* buffs = New_strBuff();
-    char* printName = strsFormat(buffs, 128, "[printBuff]%s", name);
-    char* printString = strsCopy(buffs, valString);
+    Args buffs = {0};
+    char* printName = strsFormat(&buffs, 128, "[printBuff]%s", name);
+    char* printString = strsCopy(&buffs, valString);
     args_setStr(self, printName, printString);
     char* res = args_getStr(self, printName);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
 char* getPrintStringFromInt(Args* self, char* name, int32_t val) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
     char* res = NULL;
-    char* valString = strsFormat(buffs, 32, "%d", val);
+    char* valString = strsFormat(&buffs, 32, "%d", val);
     res = getPrintSring(self, name, valString);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
 char* getPrintStringFromFloat(Args* self, char* name, float val) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
     char* res = NULL;
-    char* valString = strsFormat(buffs, 32, "%f", val);
+    char* valString = strsFormat(&buffs, 32, "%f", val);
     res = getPrintSring(self, name, valString);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
 char* getPrintStringFromPtr(Args* self, char* name, void* val) {
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
     char* res = NULL;
     uint64_t intVal = (uintptr_t)val;
-    char* valString = strsFormat(buffs, 32, "0x%llx", intVal);
+    char* valString = strsFormat(&buffs, 32, "0x%llx", intVal);
     res = getPrintSring(self, name, valString);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 
 char* args_print(Args* self, char* name) {
     char* res = NULL;
     ArgType type = args_getType(self, name);
-    Args* buffs = New_strBuff();
+    Args buffs = {0};
     if (ARG_TYPE_NONE == type) {
         /* can not get arg */
         res = NULL;
@@ -386,7 +382,7 @@ char* args_print(Args* self, char* name) {
     goto exit;
 
 exit:
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return res;
 }
 

src/dataStrs.c

@@ -33,48 +33,48 @@ Args* New_strBuff(void) {
     return New_args(NULL);
 }
 
-char* strsRemovePrefix(Args* buffs, char* inputStr, char* prefix) {
+char* strsRemovePrefix(Args* buffs_p, char* inputStr, char* prefix) {
     int32_t size = strGetSize(inputStr);
-    char* buff = args_getBuff(buffs, size);
+    char* buff = args_getBuff(buffs_p, size);
     return strRemovePrefix(inputStr, prefix, buff);
 }
 
-char* strsGetDirectStr(Args* buffs, char* argPath) {
+char* strsGetDirectStr(Args* buffs_p, char* argPath) {
     char* directStr = NULL;
-    directStr = strsCut(buffs, argPath, '"', '"');
+    directStr = strsCut(buffs_p, argPath, '"', '"');
     if (NULL != directStr) {
         return directStr;
     }
-    directStr = strsCut(buffs, argPath, '\'', '\'');
+    directStr = strsCut(buffs_p, argPath, '\'', '\'');
     if (NULL != directStr) {
         return directStr;
     }
     return NULL;
 }
 
-char* strsAppend(Args* buffs, char* strOrigin, char* strToAppend) {
+char* strsAppend(Args* buffs_p, char* strOrigin, char* strToAppend) {
     int32_t size = strGetSize(strOrigin) + strGetSize(strToAppend);
-    char* buff = args_getBuff(buffs, size);
+    char* buff = args_getBuff(buffs_p, size);
     char* strOut = strCopy(buff, strOrigin);
     strAppend(strOut, strToAppend);
     return strOut;
 }
 
-char* strsGetLastToken(Args* buffs, char* argPath, char sign) {
+char* strsGetLastToken(Args* buffs_p, char* argPath, char sign) {
     int32_t size = strGetSize(argPath);
-    char* buff = args_getBuff(buffs, size);
+    char* buff = args_getBuff(buffs_p, size);
     return strGetLastToken(buff, argPath, sign);
 }
 
-char* strsCut(Args* buffs, char* strIn, char startSign, char endSign) {
+char* strsCut(Args* buffs_p, char* strIn, char startSign, char endSign) {
     int32_t size = strGetSize(strIn);
-    char* buff = args_getBuff(buffs, size);
+    char* buff = args_getBuff(buffs_p, size);
     return strCut(buff, strIn, startSign, endSign);
 }
 
-char* strsDeleteChar(Args* buffs, char* strIn, char ch) {
+char* strsDeleteChar(Args* buffs_p, char* strIn, char ch) {
     int32_t size = strGetSize(strIn);
-    return strDeleteChar(args_getBuff(buffs, size), strIn, ch);
+    return strDeleteChar(args_getBuff(buffs_p, size), strIn, ch);
 }
 
 static uint32_t getSizeOfFirstToken(char* str, char sign) {
@@ -87,42 +87,42 @@ static uint32_t getSizeOfFirstToken(char* str, char sign) {
     return size;
 }
 
-char* strsGetFirstToken(Args* buffs, char* strIn, char sign) {
+char* strsGetFirstToken(Args* buffs_p, char* strIn, char sign) {
     int32_t size = getSizeOfFirstToken(strIn, sign);
-    return strGetFirstToken(args_getBuff(buffs, size), strIn, sign);
+    return strGetFirstToken(args_getBuff(buffs_p, size), strIn, sign);
 }
 
-char* strsPopToken(Args* buffs, char* tokens, char sign) {
+char* strsPopToken(Args* buffs_p, char* tokens, char sign) {
     int32_t size = strGetSize(tokens);
-    char* buff = args_getBuff(buffs, size);
+    char* buff = args_getBuff(buffs_p, size);
     return strPopToken(buff, tokens, sign);
 }
 
-char* strsCopy(Args* buffs, char* source) {
+char* strsCopy(Args* buffs_p, char* source) {
     int32_t size = strGetSize(source);
-    char* buff = args_getBuff(buffs, size);
+    char* buff = args_getBuff(buffs_p, size);
     return strCopy(buff, source);
 }
 
-char* strsFormat(Args* buffs, uint16_t buffSize, const char* fmt, ...) {
+char* strsFormat(Args* buffs_p, uint16_t buffSize, const char* fmt, ...) {
     va_list args;
     va_start(args, fmt);
-    char* res = args_getBuff(buffs, buffSize);
+    char* res = args_getBuff(buffs_p, buffSize);
     __platform_vsnprintf(res, buffSize, fmt, args);
     va_end(args);
     return res;
 }
 
 Arg* arg_strAppend(Arg* arg_in, char* str_to_append) {
-    Args* buffs = New_strBuff();
-    char* str_out = strsAppend(buffs, arg_getStr(arg_in), str_to_append);
+    Args buffs = {0};    
+    char* str_out = strsAppend(&buffs, arg_getStr(arg_in), str_to_append);
     Arg* arg_out = arg_setStr(arg_in, "", str_out);
     arg_deinit(arg_in);
-    args_deinit(buffs);
+    strsDeinit(&buffs);
     return arg_out;
 }
 
-char* strsReplace(Args* buffs, char* orig, char* rep, char* with) {
+char* strsReplace(Args* buffs_p, char* orig, char* rep, char* with) {
     char* result;   // the return string
     char* ins;      // the next insert point
     char* tmp;      // varies
@@ -149,7 +149,7 @@ char* strsReplace(Args* buffs, char* orig, char* rep, char* with) {
         ins = tmp + len_rep;
         tmp = strstr(ins, rep);
     }
-    tmp = args_getBuff(buffs, strlen(orig) + (len_with - len_rep) * count + 1);
+    tmp = args_getBuff(buffs_p, strlen(orig) + (len_with - len_rep) * count + 1);
     result = tmp;
     if (NULL == result) {
         return NULL;
@@ -180,10 +180,19 @@ static int32_t __getLineSize(char* str) {
     }
 }
 
-char* strsGetLine(Args* buffs, char* code) {
+char* strsGetLine(Args* buffs_p, char* code) {
     int32_t lineSize = __getLineSize(code);
-    char* line = args_getBuff(buffs, lineSize + 1);
+    char* line = args_getBuff(buffs_p, lineSize + 1);
     __platform_memcpy(line, code, lineSize);
     line[lineSize + 1] = 0;
     return line;
 }
+
+void strsDeinit(Args* buffs_p) {
+    LinkNode* nowNode = buffs_p->firstNode;
+    while (NULL != nowNode) {
+        LinkNode* nodeNext = content_getNext(nowNode);
+        linkNode_deinit(nowNode);
+        nowNode = nodeNext;
+    }
+}

src/dataStrs.h

@@ -42,4 +42,5 @@ char* strsGetDirectStr(Args* buffs, char* argPath);
 Arg* arg_strAppend(Arg* arg_in, char* str_to_append);
 char* strsReplace(Args* buffs, char* orig, char* rep, char* with);
 char* strsGetLine(Args* buffs, char* code);
+void strsDeinit(Args* buffs);
 #endif