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

update core for g030

Browse Source
This commit is contained in:
Lyon 2021-09-22 16:09:12 +08:00
parent 1b12eca2a1
commit 28ecb106d9
31 changed files with 1957 additions and 1807 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

213
demo/stm32g030c8/pikascript/pikascript-core/BaseObj.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "BaseObj.h"
#include "PikaObj.h"
#include "TinyObj.h"
@ -6,150 +11,150 @@
#include "dataStrs.h"
static void* getClassPtr(PikaObj* classObj, char* classPath) {
char* ptrPath = classPath;
return obj_getPtr(classObj, ptrPath);
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 */
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);
/* 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;
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, "_clsld", 0);
void* newFunPtr = getClassPtr(classLoader, classPath);
/* class means subprocess init */
Args* buffs = New_strBuff();
PikaObj* classLoader = obj_getObj(self, "_clsld", 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);
/* 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;
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;
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;
}
char* className = strsGetLastToken(buffs, classPath, '.');
char* classStoreName = className;
obj_setPtr(classHost, classStoreName, classPtr);
res = 0;
goto exit;
exit:
return res;
return res;
}
int32_t obj_import(PikaObj* self, char* className, NewFun classPtr) {
PikaObj* classLoader = obj_getObj(self, "_clsld", 0);
Args* buffs = New_args(NULL);
int32_t res = storeClassInfo(classLoader, buffs, className, classPtr);
args_deinit(buffs);
return res;
PikaObj* classLoader = obj_getObj(self, "_clsld", 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, "_clsld", 0);
Args* buffs = New_args(NULL);
int res = 0;
void* NewObjPtr = getClassPtr(classLoader, classPath);
if (NULL == NewObjPtr) {
res = 1;
PikaObj* classLoader = obj_getObj(self, "_clsld", 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;
}
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;
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 print val");
obj_setErrorCode(self, 1);
return;
}
/* not empty */
obj_setSysOut(self, res);
obj_setErrorCode(self, 0);
char* res = args_print(args, "val");
if (NULL == res) {
obj_setSysOut(self, "[error] print: can not print 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;
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;
}
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;
/* 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;
}
/* 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, "_clsld", New_TinyObj);
obj_getObj(self, "_clsld", 0);
class_defineMethod(self, "print(val:any)", print);
class_defineMethod(self, "set(argPath:str, val:any)", set);
return self;
PikaObj* self = New_TinyObj(args);
obj_setObjWithoutClass(self, "_clsld", New_TinyObj);
obj_getObj(self, "_clsld", 0);
class_defineMethod(self, "print(val:any)", print);
class_defineMethod(self, "set(argPath:str, val:any)", set);
return self;
}

5
demo/stm32g030c8/pikascript/pikascript-core/BaseObj.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _PikaObj_baseObj__H
#define _PikaObj_baseObj__H
#include "PikaObj.h"

83
demo/stm32g030c8/pikascript/pikascript-core/PikaBlock.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "PikaBlock.h"
#include <stdarg.h>
#include "PikaObj.h"
@ -8,76 +13,76 @@
#include "dataStrs.h"
void block_deinit(PikaObj* self) {
obj_deinit(self);
obj_deinit(self);
}
PikaObj* block_init(Args* args) {
PikaObj* self = New_TinyObj(args);
obj_setStr(self, "mode", "");
obj_setStr(self, "assert", "");
obj_setStr(self, "body", "");
obj_setInt(self, "lineSize", 0);
obj_setStr(self, "lineNow", "");
return self;
PikaObj* self = New_TinyObj(args);
obj_setStr(self, "mode", "");
obj_setStr(self, "assert", "");
obj_setStr(self, "body", "");
obj_setInt(self, "lineSize", 0);
obj_setStr(self, "lineNow", "");
return self;
}
char* block_getBody(PikaObj* self) {
return obj_getStr(self, "body");
return obj_getStr(self, "body");
}
void block_setBody(PikaObj* self, char* body) {
obj_setStr(self, "body", body);
obj_setStr(self, "body", body);
}
uint8_t block_checkAssert(PikaObj* self) {
Args* buffs = New_strBuff();
PikaObj* host = obj_getContext(self);
char* assert = block_getAssert(self);
obj_run(host, strsFormat(buffs, 32, "_res = %s", assert));
int res = obj_getInt(host, "_res");
obj_removeArg(host, "_res");
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
PikaObj* host = obj_getContext(self);
char* assert = block_getAssert(self);
obj_run(host, strsFormat(buffs, 32, "_res = %s", assert));
int res = obj_getInt(host, "_res");
obj_removeArg(host, "_res");
args_deinit(buffs);
return res;
}
uint16_t block_getLineSize(PikaObj* self) {
return obj_getInt(self, "lineSize");
return obj_getInt(self, "lineSize");
}
void block_setAssert(PikaObj* self, char* assert) {
obj_setStr(self, "assert", assert);
obj_setStr(self, "assert", assert);
}
char* block_getAssert(PikaObj* self) {
return obj_getStr(self, "assert");
return obj_getStr(self, "assert");
}
void block_setMode(PikaObj* self, char* mode) {
obj_setStr(self, "mode", mode);
obj_setStr(self, "mode", mode);
}
char* block_getMode(PikaObj* self) {
return obj_getStr(self, "mode");
return obj_getStr(self, "mode");
}
void block_pushLine(PikaObj* self, char* line) {
Args* buffs = New_strBuff();
char* body = obj_getStr(self, "body");
body = strsAppend(buffs, body, line);
body = strsAppend(buffs, body, "\n");
obj_setStr(self, "body", body);
obj_setInt(self, "lineSize", obj_getInt(self, "lineSize") + 1);
args_deinit(buffs);
Args* buffs = New_strBuff();
char* body = obj_getStr(self, "body");
body = strsAppend(buffs, body, line);
body = strsAppend(buffs, body, "\n");
obj_setStr(self, "body", body);
obj_setInt(self, "lineSize", obj_getInt(self, "lineSize") + 1);
args_deinit(buffs);
}
char* block_popLine(PikaObj* self) {
Args* buffs = New_strBuff();
char* body = obj_getStr(self, "body");
char* line = strsPopToken(buffs, body, '\n');
Args* buffs = New_strBuff();
char* body = obj_getStr(self, "body");
char* line = strsPopToken(buffs, body, '\n');
obj_setStr(self, "body", body);
obj_setStr(self, "lineNow", line);
obj_setInt(self, "lineSize", obj_getInt(self, "lineSize") - 1);
args_deinit(buffs);
return obj_getStr(self, "lineNow");
}
obj_setStr(self, "body", body);
obj_setStr(self, "lineNow", line);
obj_setInt(self, "lineSize", obj_getInt(self, "lineSize") - 1);
args_deinit(buffs);
return obj_getStr(self, "lineNow");
}

7
demo/stm32g030c8/pikascript/pikascript-core/PikaBlock.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _pikaBlock__H
#define _pikaBlock__H
#include "PikaObj.h"
@ -14,4 +19,4 @@ uint16_t block_getLineSize(PikaObj* self);
void block_setMode(PikaObj* self, char* mode);
char* block_getMode(PikaObj* self);
void block_setBody(PikaObj* self, char* body);
#endif
#endif

41
demo/stm32g030c8/pikascript/pikascript-core/PikaIf.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "PikaIf.h"
#include <stdarg.h>
#include "PikaBlock.h"
@ -5,30 +10,30 @@
#include "dataStrs.h"
void if_setAssert(PikaObj* self, char* line) {
Args* buffs = New_strBuff();
char* assert = strsRemovePrefix(buffs, line, "if ");
assert = strsGetFirstToken(buffs, assert, ':');
block_setAssert(self, assert);
block_setMode(self, "if");
args_deinit(buffs);
Args* buffs = New_strBuff();
char* assert = strsRemovePrefix(buffs, line, "if ");
assert = strsGetFirstToken(buffs, assert, ':');
block_setAssert(self, assert);
block_setMode(self, "if");
args_deinit(buffs);
}
void if_pushLine(PikaObj* self, char* line) {
Args* buffs = New_strBuff();
char* bodyLine = strsRemovePrefix(buffs, line, " ");
block_pushLine(self, bodyLine);
goto exit;
Args* buffs = New_strBuff();
char* bodyLine = strsRemovePrefix(buffs, line, " ");
block_pushLine(self, bodyLine);
goto exit;
exit:
args_deinit(buffs);
return;
args_deinit(buffs);
return;
}
void if_run(PikaObj* self) {
if (block_checkAssert(self)) {
PikaObj* host = obj_getContext(self);
while (0 != block_getLineSize(self)) {
char* line = block_popLine(self);
obj_run(host, line);
if (block_checkAssert(self)) {
PikaObj* host = obj_getContext(self);
while (0 != block_getLineSize(self)) {
char* line = block_popLine(self);
obj_run(host, line);
}
}
}
}

5
demo/stm32g030c8/pikascript/pikascript-core/PikaIf.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _pikaIf__H
#define _pikaIf__H
#include "PikaObj.h"

485
demo/stm32g030c8/pikascript/pikascript-core/PikaInvoke.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include <stdarg.h>
#include "PikaObj.h"
#include "dataArgs.h"
@ -10,282 +15,282 @@ static int32_t loadArgByType(PikaObj* self,
char* definedType,
char* sourceArgPath,
Args* args) {
if (strEqu(definedType, "any")) {
if (0 == obj_getAnyArg(self, definedName, sourceArgPath, args)) {
return 0;
if (strEqu(definedType, "any")) {
if (0 == obj_getAnyArg(self, definedName, sourceArgPath, args)) {
return 0;
}
/* solve arg faild */
return 3;
}
/* solve arg faild */
return 3;
}
if (strEqu(definedType, "str")) {
/* solve the string type */
char* directStr = strsGetDirectStr(args, sourceArgPath);
if (NULL != directStr) {
/* direct value */
args_setStr(args, definedName, directStr);
/* ok */
return 0;
if (strEqu(definedType, "str")) {
/* solve the string type */
char* directStr = strsGetDirectStr(args, sourceArgPath);
if (NULL != directStr) {
/* direct value */
args_setStr(args, definedName, directStr);
/* ok */
return 0;
}
/* reference value */
char* refStr = obj_getStr(self, sourceArgPath);
if (NULL == refStr) {
/* faild */
return 1;
}
args_setStr(args, definedName, refStr);
/* succeed */
return 0;
}
/* reference value */
char* refStr = obj_getStr(self, sourceArgPath);
if (NULL == refStr) {
/* faild */
return 1;
if (strEqu(definedType, "int")) {
/* solve the int32_t type */
args_setInt(args, definedName, 0);
if ((sourceArgPath[0] >= '0') && (sourceArgPath[0] <= '9')) {
/* direct value */
args_set(args, definedName, sourceArgPath);
/* succeed */
return 0;
}
/* reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
}
int32_t referenceVal = obj_getInt(self, sourceArgPath);
args_setInt(args, definedName, referenceVal);
/* succeed */
return 0;
}
args_setStr(args, definedName, refStr);
/* succeed */
return 0;
}
if (strEqu(definedType, "int")) {
/* solve the int32_t type */
args_setInt(args, definedName, 0);
if ((sourceArgPath[0] >= '0') && (sourceArgPath[0] <= '9')) {
/* direct value */
args_set(args, definedName, sourceArgPath);
/* succeed */
return 0;
if (strEqu(definedType, "float")) {
/* solve the float type */
args_setFloat(args, definedName, 0);
if ((sourceArgPath[0] >= '0') && (sourceArgPath[0] <= '9')) {
/* direct value */
args_set(args, definedName, sourceArgPath);
/* succeed */
return 0;
}
/* reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
}
float referenceVal = obj_getFloat(self, sourceArgPath);
args_setFloat(args, definedName, referenceVal);
/* succeed */
return 0;
}
/* reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
if (strEqu(definedType, "pointer")) {
/* only support reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
}
void* ptr = obj_getPtr(self, sourceArgPath);
args_setPtr(args, definedName, ptr);
return 0;
}
int32_t referenceVal = obj_getInt(self, sourceArgPath);
args_setInt(args, definedName, referenceVal);
/* succeed */
return 0;
}
if (strEqu(definedType, "float")) {
/* solve the float type */
args_setFloat(args, definedName, 0);
if ((sourceArgPath[0] >= '0') && (sourceArgPath[0] <= '9')) {
/* direct value */
args_set(args, definedName, sourceArgPath);
/* succeed */
return 0;
}
/* reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
}
float referenceVal = obj_getFloat(self, sourceArgPath);
args_setFloat(args, definedName, referenceVal);
/* succeed */
return 0;
}
if (strEqu(definedType, "pointer")) {
/* only support reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
}
void* ptr = obj_getPtr(self, sourceArgPath);
args_setPtr(args, definedName, ptr);
return 0;
}
/* type match faild */
return 2;
/* type match faild */
return 2;
}
char* getTypeVal(Args* buffs, char* typeToken) {
if (!strIsContain(typeToken, ':')) {
return strsCopy(buffs, "");
}
return strsGetLastToken(buffs, typeToken, ':');
if (!strIsContain(typeToken, ':')) {
return strsCopy(buffs, "");
}
return strsGetLastToken(buffs, typeToken, ':');
}
static Args* getArgsByNameMatch(PikaObj* self, char* typeList, char* argList) {
Args* buffs = New_strBuff();
char* typeListBuff = strsCopy(buffs, typeList);
Args* args = New_args(NULL);
while (1) {
char* typeToken = strsPopToken(buffs, typeListBuff, ',');
/* poped all type from typeList */
if (0 == typeToken[0]) {
break;
}
char* typeName = strsGetFirstToken(buffs, typeToken, ':');
char* typeVal = getTypeVal(buffs, typeToken);
char* argListBuff = strsCopy(buffs, argList);
Args* buffs = New_strBuff();
char* typeListBuff = strsCopy(buffs, typeList);
Args* args = New_args(NULL);
while (1) {
char* argToken = strsPopToken(buffs, argListBuff, ',');
char* argName = strsGetFirstToken(buffs, argToken, '=');
char* argVal = strsGetLastToken(buffs, argToken, '=');
char* typeToken = strsPopToken(buffs, typeListBuff, ',');
/* poped all type from typeList */
if (0 == typeToken[0]) {
break;
}
if (0 == argToken[0]) {
/* arg poped finised */
break;
}
char* typeName = strsGetFirstToken(buffs, typeToken, ':');
char* typeVal = getTypeVal(buffs, typeToken);
if (!strEqu(typeName, argName)) {
/* name not match */
continue;
}
char* argListBuff = strsCopy(buffs, argList);
while (1) {
char* argToken = strsPopToken(buffs, argListBuff, ',');
char* argName = strsGetFirstToken(buffs, argToken, '=');
char* argVal = strsGetLastToken(buffs, argToken, '=');
if (0 != loadArgByType(self, typeName, typeVal, argVal, args)) {
args_deinit(args);
args_deinit(buffs);
return NULL;
}
if (0 == argToken[0]) {
/* arg poped finised */
break;
}
if (!strEqu(typeName, argName)) {
/* name not match */
continue;
}
if (0 != loadArgByType(self, typeName, typeVal, argVal, args)) {
args_deinit(args);
args_deinit(buffs);
return NULL;
}
}
}
}
args_deinit(buffs);
return args;
args_deinit(buffs);
return args;
}
static Args* getArgsBySort(PikaObj* self, char* typeList, char* argList) {
Args* buffs = New_strBuff();
char* typeListBuff = strsCopy(buffs, typeList);
char* argListBuff = strsCopy(buffs, argList);
Args* args = New_args(NULL);
while (1) {
char* typeToken = strsPopToken(buffs, typeListBuff, ',');
char* argToken = strsPopToken(buffs, argListBuff, ',');
if ((0 == argToken[0]) || (0 == typeToken[0])) {
/* arg or type poped finised */
break;
}
Args* buffs = New_strBuff();
char* typeListBuff = strsCopy(buffs, typeList);
char* argListBuff = strsCopy(buffs, argList);
Args* args = New_args(NULL);
while (1) {
char* typeToken = strsPopToken(buffs, typeListBuff, ',');
char* argToken = strsPopToken(buffs, argListBuff, ',');
if ((0 == argToken[0]) || (0 == typeToken[0])) {
/* arg or type poped finised */
break;
}
char* typeName = strsGetFirstToken(buffs, typeToken, ':');
char* typeVal = getTypeVal(buffs, typeToken);
char* argPath = argToken;
char* typeName = strsGetFirstToken(buffs, typeToken, ':');
char* typeVal = getTypeVal(buffs, typeToken);
char* argPath = argToken;
if (0 != loadArgByType(self, typeName, typeVal, argPath, args)) {
args_deinit(args);
args_deinit(buffs);
return NULL;
if (0 != loadArgByType(self, typeName, typeVal, argPath, args)) {
args_deinit(args);
args_deinit(buffs);
return NULL;
}
}
}
args_deinit(buffs);
return args;
args_deinit(buffs);
return args;
}
static Args* getArgsBySentence(PikaObj* self, char* typeList, char* argList) {
if (strIsContain(argList, '=')) {
return getArgsByNameMatch(self, typeList, argList);
}
return getArgsBySort(self, typeList, argList);
if (strIsContain(argList, '=')) {
return getArgsByNameMatch(self, typeList, argList);
}
return getArgsBySort(self, typeList, argList);
}
static char* getMethodDeclearation(PikaObj* obj, char* methodName) {
Args* buffs = New_strBuff();
char* methodDeclearationPath = strsAppend(buffs, "[md]", methodName);
char* res = obj_getStr(obj, methodDeclearationPath);
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
char* methodDeclearationPath = strsAppend(buffs, "[md]", methodName);
char* res = obj_getStr(obj, methodDeclearationPath);
args_deinit(buffs);
return res;
}
static void* getMethodPtr(PikaObj* methodHost, char* methodName) {
Args* buffs = New_strBuff();
char* methodPtrPath = strsAppend(buffs, "[mp]", methodName);
void* res = obj_getPtr(methodHost, methodPtrPath);
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
char* methodPtrPath = strsAppend(buffs, "[mp]", methodName);
void* res = obj_getPtr(methodHost, methodPtrPath);
args_deinit(buffs);
return res;
}
Args* obj_invoke(PikaObj* self, char* cmd) {
/* the Args returned need to be deinit */
Args* res = New_args(NULL);
args_setErrorCode(res, 0);
Args* buffs = New_strBuff();
char* methodToken = strsGetFirstToken(buffs, cmd, '(');
char* methodPath = methodToken;
Args* args = NULL;
/* the Args returned need to be deinit */
Args* res = New_args(NULL);
args_setErrorCode(res, 0);
Args* buffs = New_strBuff();
char* methodToken = strsGetFirstToken(buffs, cmd, '(');
char* methodPath = methodToken;
Args* args = NULL;
PikaObj* methodHostObj = obj_getObj(self, methodPath, 1);
PikaObj* methodHostClass = NULL;
if (NULL == methodHostObj) {
/* error, not found object */
args_setErrorCode(res, 1);
args_setSysOut(res, "[error] runner: object no found.");
goto exit;
}
char* methodName = strsGetLastToken(buffs, methodPath, '.');
void* classPtr = obj_getPtr(methodHostObj, "_clsptr");
char* methodHostClassName =
strsAppend(buffs, "classObj-", obj_getName(methodHostObj));
methodHostClass =
obj_getClassObjByNewFun(methodHostObj, methodHostClassName, classPtr);
/* get method Ptr */
void (*methodPtr)(PikaObj * self, Args * args) =
getMethodPtr(methodHostClass, methodName);
char* methodDecInClass = getMethodDeclearation(methodHostClass, methodName);
/* assert method*/
if ((NULL == methodDecInClass) || (NULL == methodPtr)) {
/* error, method no found */
args_setErrorCode(res, 2);
args_setSysOut(res, "[error] runner: method no found.");
goto exit;
}
char* methodDec = strsCopy(buffs, methodDecInClass);
/* free method host class to save memory */
obj_deinit(methodHostClass);
methodHostClass = NULL;
/* get type list */
char* typeList = strsCut(buffs, methodDec, '(', ')');
if (typeList == NULL) {
/* typeList no found */
args_setErrorCode(res, 3);
args_setSysOut(res, "[error] runner: type list no found.");
goto exit;
}
/* get arg list */
char* argList = strsCut(buffs, cmd, '(', ')');
{
if (argList == NULL) {
/* argL List no found */
args_setErrorCode(res, 4);
args_setSysOut(res, "[error] runner: arg list no found.");
goto exit;
PikaObj* methodHostObj = obj_getObj(self, methodPath, 1);
PikaObj* methodHostClass = NULL;
if (NULL == methodHostObj) {
/* error, not found object */
args_setErrorCode(res, 1);
args_setSysOut(res, "[error] runner: object no found.");
goto exit;
}
}
char* methodName = strsGetLastToken(buffs, methodPath, '.');
/* get return type */
char* returnType = strsGetLastToken(buffs, methodDec, ')');
/* get args */
args = getArgsBySentence(self, typeList, argList);
if (NULL == args) {
/* get args faild */
args_setErrorCode(res, 5);
args_setSysOut(res, "[error] runner: solve arg faild.");
goto exit;
}
obj_setErrorCode(methodHostObj, 0);
obj_setSysOut(methodHostObj, "");
/* run method */
methodPtr(methodHostObj, args);
/* transfer return type */
args_setStr(res, "returnType", returnType);
/* transfer return */
args_copyArgByName(args, "return", res);
/* transfer sysOut */
char* sysOut = obj_getSysOut(methodHostObj);
if (NULL != sysOut) {
args_setSysOut(res, sysOut);
}
/* transfer errCode */
if (0 != obj_getErrorCode(methodHostObj)) {
/* method error */
args_setErrorCode(res, 6);
}
goto exit;
exit:
if (NULL != buffs) {
args_deinit(buffs);
}
if (NULL != methodHostClass) {
void* classPtr = obj_getPtr(methodHostObj, "_clsptr");
char* methodHostClassName =
strsAppend(buffs, "classObj-", obj_getName(methodHostObj));
methodHostClass =
obj_getClassObjByNewFun(methodHostObj, methodHostClassName, classPtr);
/* get method Ptr */
void (*methodPtr)(PikaObj * self, Args * args) =
getMethodPtr(methodHostClass, methodName);
char* methodDecInClass = getMethodDeclearation(methodHostClass, methodName);
/* assert method*/
if ((NULL == methodDecInClass) || (NULL == methodPtr)) {
/* error, method no found */
args_setErrorCode(res, 2);
args_setSysOut(res, "[error] runner: method no found.");
goto exit;
}
char* methodDec = strsCopy(buffs, methodDecInClass);
/* free method host class to save memory */
obj_deinit(methodHostClass);
}
if (NULL != args) {
args_deinit(args);
}
return res;
methodHostClass = NULL;
/* get type list */
char* typeList = strsCut(buffs, methodDec, '(', ')');
if (typeList == NULL) {
/* typeList no found */
args_setErrorCode(res, 3);
args_setSysOut(res, "[error] runner: type list no found.");
goto exit;
}
/* get arg list */
char* argList = strsCut(buffs, cmd, '(', ')');
{
if (argList == NULL) {
/* argL List no found */
args_setErrorCode(res, 4);
args_setSysOut(res, "[error] runner: arg list no found.");
goto exit;
}
}
/* get return type */
char* returnType = strsGetLastToken(buffs, methodDec, ')');
/* get args */
args = getArgsBySentence(self, typeList, argList);
if (NULL == args) {
/* get args faild */
args_setErrorCode(res, 5);
args_setSysOut(res, "[error] runner: solve arg faild.");
goto exit;
}
obj_setErrorCode(methodHostObj, 0);
obj_setSysOut(methodHostObj, "");
/* run method */
methodPtr(methodHostObj, args);
/* transfer return type */
args_setStr(res, "returnType", returnType);
/* transfer return */
args_copyArgByName(args, "return", res);
/* transfer sysOut */
char* sysOut = obj_getSysOut(methodHostObj);
if (NULL != sysOut) {
args_setSysOut(res, sysOut);
}
/* transfer errCode */
if (0 != obj_getErrorCode(methodHostObj)) {
/* method error */
args_setErrorCode(res, 6);
}
goto exit;
exit:
if (NULL != buffs) {
args_deinit(buffs);
}
if (NULL != methodHostClass) {
obj_deinit(methodHostClass);
}
if (NULL != args) {
args_deinit(args);
}
return res;
}

7
demo/stm32g030c8/pikascript/pikascript-core/PikaInvoke.h
View File

@ -1,4 +1,9 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _invoke__H
#define _invoke__H
Args* obj_invoke(PikaObj* self, char* cmd);
#endif
#endif

1043
demo/stm32g030c8/pikascript/pikascript-core/PikaObj.c
View File

File diff suppressed because it is too large Load Diff

9
demo/stm32g030c8/pikascript/pikascript-core/PikaObj.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _Process__H
#define _Process__H
#include "dataArgs.h"
@ -9,8 +14,8 @@ typedef PikaObj* (*NewFun)(Args* args);
typedef PikaObj* (*InitFun)(PikaObj* self, Args* args);
struct PikaObj_t {
/* list */
Args* attributeList;
/* list */
Args* attributeList;
};
/* operation */

51
demo/stm32g030c8/pikascript/pikascript-core/PikaWhile.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include <stdarg.h>
#include "PikaBlock.h"
#include "PikaObj.h"
@ -7,36 +12,36 @@
#include "dataStrs.h"
void while_setAssert(PikaObj* self, char* line) {
Args* buffs = New_strBuff();
char* assert = strsRemovePrefix(buffs, line, "while ");
assert = strsGetFirstToken(buffs, assert, ':');
block_setAssert(self, assert);
block_setMode(self, "while");
args_deinit(buffs);
Args* buffs = New_strBuff();
char* assert = strsRemovePrefix(buffs, line, "while ");
assert = strsGetFirstToken(buffs, assert, ':');
block_setAssert(self, assert);
block_setMode(self, "while");
args_deinit(buffs);
}
void while_pushLine(PikaObj* self, char* line) {
Args* buffs = New_strBuff();
char* bodyLine = strsRemovePrefix(buffs, line, " ");
block_pushLine(self, bodyLine);
goto exit;
Args* buffs = New_strBuff();
char* bodyLine = strsRemovePrefix(buffs, line, " ");
block_pushLine(self, bodyLine);
goto exit;
exit:
args_deinit(buffs);
return;
args_deinit(buffs);
return;
}
void while_run(PikaObj* self) {
Args* buffs = New_strBuff();
char* body = strsCopy(buffs, block_getBody(self));
uint16_t lineSize = block_getLineSize(self);
while (block_checkAssert(self)) {
PikaObj* host = obj_getContext(self);
for (int i = 0; i < lineSize; i++) {
char* line = block_popLine(self);
obj_run(host, line);
Args* buffs = New_strBuff();
char* body = strsCopy(buffs, block_getBody(self));
uint16_t lineSize = block_getLineSize(self);
while (block_checkAssert(self)) {
PikaObj* host = obj_getContext(self);
for (int i = 0; i < lineSize; i++) {
char* line = block_popLine(self);
obj_run(host, line);
}
block_setBody(self, body);
}
block_setBody(self, body);
}
exit:
args_deinit(buffs);
args_deinit(buffs);
}

7
demo/stm32g030c8/pikascript/pikascript-core/PikaWhile.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _pikaWhile__H
#define _pikaWhile__H
#include "PikaObj.h"
@ -6,4 +11,4 @@ void while_setAssert(PikaObj* self, char* line);
void while_pushLine(PikaObj* self, char* line);
void while_run(PikaObj* self);
#endif
#endif

35
demo/stm32g030c8/pikascript/pikascript-core/TinyObj.c
View File

@ -1,29 +1,34 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "PikaObj.h"
void _UpdateHandle(PikaObj* self) {
// override the handle function here
// override the handle function here
}
void _beforDinit(PikaObj* self) {
/* override in user code */
/* override in user code */
}
PikaObj* New_TinyObj(Args* args) {
PikaObj* self = pikaMalloc(sizeof(PikaObj));
PikaObj* self = pikaMalloc(sizeof(PikaObj));
/* List */
self->attributeList = New_args(NULL);
/* List */
self->attributeList = New_args(NULL);
/* attribute */
obj_setPtr(self, "_ctx", self);
obj_setStr(self, "_n", "root");
/* attribute */
obj_setPtr(self, "_ctx", self);
obj_setStr(self, "_n", "root");
/* load */
if (NULL != args) {
obj_load(self, args, "_n");
obj_load(self, args, "_ctx");
}
/* load */
if (NULL != args) {
obj_load(self, args, "_n");
obj_load(self, args, "_ctx");
}
/* hard attribute */
return self;
/* hard attribute */
return self;
}

5
demo/stm32g030c8/pikascript/pikascript-core/TinyObj.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef __TYNYOBJ__H
#define __TYNYOBJ__H
#include "PikaObj.h"

387
demo/stm32g030c8/pikascript/pikascript-core/dataArg.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataArg.h"
#include <stdint.h>
@ -8,35 +13,35 @@
#include "stdlib.h"
void arg_deinit(Arg* self) {
arg_freeContent(self);
arg_freeContent(self);
}
uint16_t arg_getTotleSize(Arg* self) {
return content_totleSize(self);
return content_totleSize(self);
}
uint16_t content_sizeOffset(uint8_t* self) {
const uint8_t nextLength = sizeof(uint8_t*);
return nextLength;
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;
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* 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,
@ -44,279 +49,279 @@ uint8_t* content_init(char* name,
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);
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;
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);
}
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;
}
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;
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;
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);
}
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;
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);
return (char*)self + content_nameOffset(self);
}
uint8_t* content_deinit(uint8_t* self) {
uint16_t totleSize = content_totleSize(self);
pikaFree(self, totleSize);
return 0;
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;
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;
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;
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;
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);
return content_setContent(self, content, size);
}
Arg* arg_setName(Arg* self, char* name) {
return content_setName(self, name);
return content_setName(self, name);
}
Arg* arg_setType(Arg* self, char* type) {
return content_setType(self, type);
return content_setType(self, type);
}
char* content_getType(uint8_t* self) {
return (char*)self + content_typeOffset(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;
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;
return 0;
}
uint8_t* content_getNext(uint8_t* self) {
uint8_t* nextDir = self + content_nextOffset(self);
uint8_t* next = NULL;
uint64_t pointerTemp = 0;
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;
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);
return self + content_contentOffset(self);
}
uint8_t* arg_getContent(Arg* self) {
return content_getContent(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);
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);
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;
}
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;
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);
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);
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;
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;
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);
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;
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);
return content_getName(self);
}
char* arg_getType(Arg* self) {
return content_getType(self);
return content_getType(self);
}
uint16_t arg_getContentSize(Arg* self) {
return content_getSize(self);
return content_getSize(self);
}
Arg* New_arg(void* voidPointer) {
return NULL;
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;
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;
}

5
demo/stm32g030c8/pikascript/pikascript-core/dataArg.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _arg__H
#define _arg__H
#include "dataMemory.h"

705
demo/stm32g030c8/pikascript/pikascript-core/dataArgs.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataArgs.h"
#include <stdarg.h>
#include <stdio.h>
@ -9,489 +14,489 @@
#include "dataStrs.h"
void args_deinit(Args* self) {
link_deinit(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;
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;
}
void* pointer = NULL;
Arg* arg = args_getArg(self, name);
if (NULL == arg) {
return NULL;
}
pointer = arg_getPtr(arg);
return pointer;
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 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;
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);
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);
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) {
if (NULL == self) {
return NULL;
}
Arg* arg = args_getArg(self, name);
if (NULL == arg) {
return NULL;
}
if (NULL == arg_getContent(arg)) {
return NULL;
}
return (char*)arg_getContent(arg);
if (NULL == self) {
return NULL;
}
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;
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);
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);
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);
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);
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);
if (NULL == argToBeCopy) {
return 1;
}
Arg* argCopied = arg_copy(argToBeCopy);
args_setArg(self, argCopied);
return 0;
return 0;
}
int32_t args_copyArgByName(Args* self, char* name, Args* directArgs) {
Arg* argToBeCopy = args_getArg(self, name);
args_copyArg(directArgs, argToBeCopy);
return 0;
Arg* argToBeCopy = args_getArg(self, name);
args_copyArg(directArgs, argToBeCopy);
return 0;
}
int32_t args_isArgExist(Args* self, char* name) {
if (NULL == name) {
if (NULL == name) {
return 0;
}
if (NULL != args_getArg(self, name)) {
return 1;
}
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;
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);
}
if (content_getNext(nodeNow) == NULL) {
// error, node no found
goto exit;
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;
}
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;
content_setNext(priorNode, nodeToUpdate);
goto exit;
}
content_setNext(priorNode, nodeToUpdate);
goto exit;
exit:
arg_deinit(argNew);
return 0;
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);
char* name = arg_getName(arg);
if (!args_isArgExist(self, name)) {
setArgDirect(self, arg);
return 0;
}
updateArg(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;
LinkNode* nodeNow = self->firstNode;
if (NULL == nodeNow) {
return NULL;
}
if (NULL == content_getNext(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);
}
nodeNow = content_getNext(nodeNow);
}
}
Arg* args_getArg(Args* self, char* name) {
LinkNode* node = args_getNode(self, name);
if (NULL == node) {
return NULL;
}
return node;
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;
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);
args_bind(self, "int", name, intPtr);
}
void args_bindFloat(Args* self, char* name, float* floatPtr) {
args_bind(self, "float", name, floatPtr);
args_bind(self, "float", name, floatPtr);
}
void args_bindStr(Args* self, char* name, char** stringPtr) {
args_bind(self, "str", name, stringPtr);
args_bind(self, "str", name, stringPtr);
}
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_setStr(self, printName, printString);
char* res = args_getStr(self, printName);
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
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);
return res;
}
char* getPrintStringFromInt(Args* self, char* name, int32_t val) {
Args* buffs = New_strBuff();
char* res = NULL;
char* valString = strsFormat(buffs, 32, "%d", val);
res = getPrintSring(self, name, valString);
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
char* res = NULL;
char* valString = strsFormat(buffs, 32, "%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, 32, "%f", val);
res = getPrintSring(self, name, valString);
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
char* res = NULL;
char* valString = strsFormat(buffs, 32, "%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, 32, "0x%llx", intVal);
res = getPrintSring(self, name, valString);
args_deinit(buffs);
return res;
Args* buffs = New_strBuff();
char* res = NULL;
uint64_t intVal = (uint64_t)val;
char* valString = strsFormat(buffs, 32, "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 */
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;
}
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;
args_deinit(buffs);
return res;
}
uint8_t args_setLiteral(Args* self, char* targetArgName, char* literal) {
Args* buffs = New_strBuff();
literal = strsGetCleanCmd(buffs, literal);
uint8_t err = 0;
char* directStr = strsGetDirectStr(self, literal);
/* get direct Str ok */
if (NULL != directStr) {
/* direct string value */
args_setStr(self, targetArgName, directStr);
/* ok */
err = 0;
goto exit;
}
/* match bool */
if (strEqu(literal, "True")) {
args_setInt(self, targetArgName, 1);
err = 0;
goto exit;
}
if (strEqu(literal, "False")) {
args_setInt(self, targetArgName, 0);
err = 0;
goto exit;
}
/* match num */
if ((literal[0] >= '0') && (literal[0] <= '9')) {
/* match float num */
if (strIsContain(literal, '.')) {
args_setFloat(self, targetArgName, 0);
args_set(self, targetArgName, literal);
/* succeed */
err = 0;
goto exit;
Args* buffs = New_strBuff();
literal = strsGetCleanCmd(buffs, literal);
uint8_t err = 0;
char* directStr = strsGetDirectStr(self, literal);
/* get direct Str ok */
if (NULL != directStr) {
/* direct string value */
args_setStr(self, targetArgName, directStr);
/* ok */
err = 0;
goto exit;
}
/* match int num */
args_setInt(self, targetArgName, 0);
args_set(self, targetArgName, literal);
/* succeed */
err = 0;
/* match bool */
if (strEqu(literal, "True")) {
args_setInt(self, targetArgName, 1);
err = 0;
goto exit;
}
if (strEqu(literal, "False")) {
args_setInt(self, targetArgName, 0);
err = 0;
goto exit;
}
/* match num */
if ((literal[0] >= '0') && (literal[0] <= '9')) {
/* match float num */
if (strIsContain(literal, '.')) {
args_setFloat(self, targetArgName, 0);
args_set(self, targetArgName, literal);
/* succeed */
err = 0;
goto exit;
}
/* match int num */
args_setInt(self, targetArgName, 0);
args_set(self, targetArgName, literal);
/* succeed */
err = 0;
goto exit;
}
err = 1;
goto exit;
}
err = 1;
goto exit;
exit:
args_deinit(buffs);
return err;
args_deinit(buffs);
return err;
}
int32_t args_set(Args* self, char* name, char* valStr) {
char* type = args_getType(self, name);
Args* buffs = New_strBuff();
int32_t err = 0;
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 (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;
}
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;
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;
}
}
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;
/* type not match */
err = 2;
goto exit;
exit:
args_deinit(buffs);
return err;
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;
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;
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);
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;
if (NULL == nextNode) {
break;
}
nodeNow = nextNode;
}
nodeNow = nextNode;
}
return 0;
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;
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;
Args* self = New_link(NULL);
return self;
}

5
demo/stm32g030c8/pikascript/pikascript-core/dataArgs.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _dataArgs__H
#define _dataArgs__H
#include "dataArg.h"

107
demo/stm32g030c8/pikascript/pikascript-core/dataLink.c
View File

@ -1,82 +1,87 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataLink.h"
#include "dataArg.h"
#include "dataLinkNode.h"
#include "dataMemory.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;
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;
// 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);
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;
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);
}
if (nodeNow == NULL) {
// error, node no found
goto exit;
LinkNode* nextNode = content_getNext(nodeToDelete);
if (nodeToDelete == self->firstNode) {
self->firstNode = content_getNext(nodeToDelete);
}
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;
}
if (NULL == priorNode) {
self->firstNode = nextNode;
content_setNext(priorNode, nextNode);
goto exit;
}
content_setNext(priorNode, nextNode);
goto exit;
// deinit the node
exit:
linkNode_deinit(nodeToDelete);
return;
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;
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;
self->firstNode = NULL;
}
Link* New_link(void* args) {
Link* self = pikaMalloc(sizeof(Link));
link_init(self, args);
return self;
Link* self = pikaMalloc(sizeof(Link));
link_init(self, args);
return self;
}

7
demo/stm32g030c8/pikascript/pikascript-core/dataLink.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _link2__H
#define _link2__H
#include "dataLinkNode.h"
@ -5,7 +10,7 @@
typedef struct Class_link Link;
struct Class_link {
LinkNode* firstNode;
LinkNode* firstNode;
};
void link_deinit(Link* self);

11
demo/stm32g030c8/pikascript/pikascript-core/dataLinkNode.c
View File

@ -1,15 +1,20 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataLinkNode.h"
#include "dataArg.h"
#include "dataMemory.h"
void linkNode_deinit(LinkNode* self) {
arg_deinit(self);
arg_deinit(self);
}
void linkNode_init(LinkNode* self, void* args) {
/* attribute */
/* attribute */
}
LinkNode* New_linkNode(void* args) {
return NULL;
return NULL;
}

5
demo/stm32g030c8/pikascript/pikascript-core/dataLinkNode.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef _linkNode__H
#define _linkNode__H
#include "dataMemory.h"

35
demo/stm32g030c8/pikascript/pikascript-core/dataMemory.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataMemory.h"
#include <stdint.h>
#include <stdlib.h>
@ -5,32 +10,32 @@
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) {
pikaMemInfo.heapUsed += size;
if (pikaMemInfo.heapUsedMax < pikaMemInfo.heapUsed) {
pikaMemInfo.heapUsedMax = pikaMemInfo.heapUsed;
}
}
return mem;
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;
free(mem);
pikaMemInfo.heapUsed -= size;
}
uint16_t pikaMemNow(void) {
return pikaMemInfo.heapUsed;
return pikaMemInfo.heapUsed;
}
uint16_t pikaMemMax(void) {
return pikaMemInfo.heapUsedMax;
return pikaMemInfo.heapUsedMax;
}
void pikaMemMaxReset(void) {
pikaMemInfo.heapUsedMax = 0;
pikaMemInfo.heapUsedMax = 0;
}

9
demo/stm32g030c8/pikascript/pikascript-core/dataMemory.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef __MEMORY_H__
#define __MEMORY_H__
@ -6,8 +11,8 @@
#include <string.h>
typedef struct {
uint32_t heapUsed;
uint32_t heapUsedMax;
uint32_t heapUsed;
uint32_t heapUsedMax;
} PikaMemInfo;
void pikaFree(void* mem, uint32_t size);

335
demo/stm32g030c8/pikascript/pikascript-core/dataString.c
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataString.h"
#include <stdint.h>
#include <stdio.h>
@ -5,240 +10,240 @@
#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;
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;
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;
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++;
}
}
if (isStart && (strIn[i] == endSign)) {
isEnd = 1;
break;
/* add \0 */
strOut[iOut] = 0;
if (isStart && isEnd) {
/* succeed */
return strOut;
}
if (isStart) {
strOut[iOut] = strIn[i];
iOut++;
}
}
/* add \0 */
strOut[iOut] = 0;
if (isStart && isEnd) {
/* succeed */
return strOut;
}
/* faild */
return NULL;
/* 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;
int32_t iOut = 0;
for (int32_t i = 0; i < strGetSize(strIn); i++) {
if (ch == strIn[i]) {
continue;
}
strOut[iOut] = strIn[i];
iOut++;
}
strOut[iOut] = strIn[i];
iOut++;
}
/* add \0 */
strOut[iOut] = 0;
return strOut;
/* add \0 */
strOut[iOut] = 0;
return strOut;
}
char* strDeleteEnter(char* str) {
return strDeleteChar(str, str, '\n');
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;
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;
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++;
int32_t count = 0;
for (int32_t i = 0; i < strGetSize(strIn); i++) {
if (sign == strIn[i]) {
count++;
}
}
}
return count;
return count;
}
int32_t strGetTokenNum(char* strIn, char sign) {
return strCountSign(strIn, sign) + 1;
return strCountSign(strIn, sign) + 1;
}
uint32_t strGetSize(char* pData) {
return strlen(pData);
return strlen(pData);
}
char* strAppend_unlimited(char* strOut, char* pData) {
uint32_t Size = 0;
Size = strGetSize(pData);
return strAppendWithSize_unlimited(strOut, pData, Size);
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++;
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;
}
}
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;
}
}
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;
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;
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;
}
}
if (strIn[i] != sign) {
strOut[iOut++] = strIn[i];
continue;
}
if (strIn[i] == sign) {
getSign = 1;
continue;
}
}
strOut[iOut] = 0;
strIn[iPoped] = 0;
return strOut;
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];
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;
}
}
if (strIn[i] == sign) {
break;
}
}
return strOut;
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++;
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;
}
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;
argc = arg_i + 1;
return argc;
}
char* strAppend(char* strOut, char* pData) {
uint32_t Size = 0;
Size = strGetSize(pData);
return strAppendWithSize(strOut, pData, Size);
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;
if (NULL == str || NULL == strStart) {
/* input is null */
return 0;
}
}
return CMDName_get;
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) {
return !strcmp(str1, str2);
return !strcmp(str1, str2);
}
char* strRemovePrefix(char* inputStr, char* prefix, char* outputStr) {
if (!strIsStartWith(inputStr, prefix)) {
return NULL;
}
if (!strIsStartWith(inputStr, prefix)) {
return NULL;
}
for (int32_t i = strGetSize(prefix); i < strGetSize(inputStr); i++) {
outputStr[i - strGetSize(prefix)] = inputStr[i];
}
return outputStr;
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;
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;
for (int32_t i = 0; i < strGetSize(str); i++) {
if (str[i] == ch) {
return 1;
}
}
}
return 0;
return 0;
}
char* strCopy(char* strBuff, char* strIn) {
memcpy(strBuff, strIn, strGetSize(strIn));
return strBuff;
memcpy(strBuff, strIn, strGetSize(strIn));
return strBuff;
}

5
demo/stm32g030c8/pikascript/pikascript-core/dataString.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef __MY_TEST_TOOLS_H
#define __MY_TEST_TOOLS_H
#include <stdint.h>

123
demo/stm32g030c8/pikascript/pikascript-core/dataStrs.c
View File

@ -1,100 +1,105 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "dataStrs.h"
#include <stdarg.h>
#include <stdio.h>
#include "dataString.h"
Args* New_strBuff(void) {
return New_args(NULL);
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);
int32_t size = strGetSize(inputStr);
char* buff = args_getBuff(buffs, size);
return strRemovePrefix(inputStr, prefix, buff);
}
char* strsGetDirectStr(Args* buffs, char* argPath) {
char* directStr = NULL;
directStr = strsCut(buffs, argPath, '"', '"');
if (NULL != directStr) {
return directStr;
}
directStr = strsCut(buffs, argPath, '\'', '\'');
if (NULL != directStr) {
return directStr;
}
return NULL;
char* directStr = NULL;
directStr = strsCut(buffs, argPath, '"', '"');
if (NULL != directStr) {
return directStr;
}
directStr = strsCut(buffs, argPath, '\'', '\'');
if (NULL != directStr) {
return directStr;
}
return NULL;
}
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;
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);
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);
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);
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);
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);
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);
int32_t size = strGetSize(source);
char* buff = args_getBuff(buffs, size);
return strCopy(buff, source);
}
char* strsFormat(Args* buffs, uint16_t buffSize, const char* fmt, ...) {
va_list args;
va_start(args, fmt);
char* res = args_getBuff(buffs, buffSize);
vsnprintf(res, buffSize, fmt, args);
va_end(args);
return res;
va_list args;
va_start(args, fmt);
char* res = args_getBuff(buffs, buffSize);
vsnprintf(res, buffSize, fmt, args);
va_end(args);
return res;
}
char* strsGetCleanCmd(Args* buffs, char* cmd) {
int32_t size = strGetSize(cmd);
char* strOut = args_getBuff(buffs, size);
int32_t iOut = 0;
char delChar = ' ';
int32_t isInStr = 0;
for (int32_t i = 0; i < strGetSize(cmd); i++) {
if ('\'' == cmd[i] || '\"' == cmd[i]) {
isInStr = !isInStr;
int32_t size = strGetSize(cmd);
char* strOut = args_getBuff(buffs, size);
int32_t iOut = 0;
char delChar = ' ';
int32_t isInStr = 0;
for (int32_t i = 0; i < strGetSize(cmd); i++) {
if ('\'' == cmd[i] || '\"' == cmd[i]) {
isInStr = !isInStr;
}
if ((delChar == cmd[i]) && (!isInStr)) {
/* do not load char */
continue;
}
strOut[iOut] = cmd[i];
iOut++;
}
if ((delChar == cmd[i]) && (!isInStr)) {
/* do not load char */
continue;
}
strOut[iOut] = cmd[i];
iOut++;
}
/* add \0 */
strOut[iOut] = 0;
return strOut;
/* add \0 */
strOut[iOut] = 0;
return strOut;
}

5
demo/stm32g030c8/pikascript/pikascript-core/dataStrs.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef __STR_ARGS__H
#define __STR_ARGS__H
#include "dataArgs.h"

19
demo/stm32g030c8/pikascript/pikascript-core/method.c
View File

@ -1,25 +1,30 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#include "PikaObj.h"
#include "dataArgs.h"
void method_returnStr(Args* args, char* val) {
args_setStr(args, "return", val);
args_setStr(args, "return", val);
}
void method_returnInt(Args* args, int32_t val) {
args_setInt(args, "return", val);
args_setInt(args, "return", val);
}
void method_returnFloat(Args* args, float val) {
args_setFloat(args, "return", val);
args_setFloat(args, "return", val);
}
void method_returnPtr(Args* args, void* val) {
args_setPtr(args, "return", val);
args_setPtr(args, "return", val);
}
int32_t method_getInt(Args* args, char* argName) {
return args_getInt(args, argName);
return args_getInt(args, argName);
}
float method_getFloat(Args* args, char* argName) {
return args_getFloat(args, argName);
return args_getFloat(args, argName);
}
char* method_getStr(Args* args, char* argName) {
return args_getStr(args, argName);
return args_getStr(args, argName);
}

5
demo/stm32g030c8/pikascript/pikascript-core/method.h
View File

@ -1,3 +1,8 @@
/*
Author: lyon
Tencent QQ: 645275593
*/
#ifndef METHOD__H
#define METHOD__H
#include "dataArgs.h"

BIN
demo/stm32g030c8/pikascript/pikascript-core/pikascript-core.lib
View File

Binary file not shown.