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

Merge branch 'master' of https://github.com/mimilib/pikascript

Browse Source
This commit is contained in:
graduateDesign 2021-09-11 00:09:11 +08:00
commit c8a81fc21e
40 changed files with 3166 additions and 3645 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
LICENSE
View File

@ -1,6 +1,6 @@
MIT License
Copyright (c) 2021 mimilib
Copyright (c) 2021 Lyon
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal

3
src/.vscode/settings.json vendored
View File

@ -1,5 +1,6 @@
{
"files.associations": {
"pikaobj.h": "c"
"pikaobj.h": "c",
"stdbool.h": "c"
}
}

263
src/package/pikascript/pikascript-core/BaseObj.c
View File

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

13
src/package/pikascript/pikascript-core/BaseObj.h
View File

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

118
src/package/pikascript/pikascript-core/PikaBlock.c
View File

@ -1,95 +1,83 @@
#include "PikaBlock.h"
#include <stdarg.h>
#include "PikaObj.h"
#include "TinyObj.h"
#include "dataArgs.h"
#include "dataMemory.h"
#include "dataString.h"
#include "dataStrs.h"
#include <stdarg.h>
#include "PikaBlock.h"
#include "TinyObj.h"
void block_deinit(PikaObj *self)
{
obj_deinit(self);
void block_deinit(PikaObj* 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* 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;
}
char *block_getBody(PikaObj *self)
{
return obj_getStr(self, "body");
char* block_getBody(PikaObj* self) {
return obj_getStr(self, "body");
}
void block_setBody(PikaObj *self, char *body)
{
obj_setStr(self, "body", body);
void block_setBody(PikaObj* self, char* 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;
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;
}
uint16_t block_getLineSize(PikaObj *self)
{
return obj_getInt(self, "lineSize");
uint16_t block_getLineSize(PikaObj* self) {
return obj_getInt(self, "lineSize");
}
void block_setAssert(PikaObj *self, char *assert)
{
obj_setStr(self, "assert", assert);
void block_setAssert(PikaObj* self, char* assert) {
obj_setStr(self, "assert", assert);
}
char *block_getAssert(PikaObj *self)
{
return obj_getStr(self, "assert");
char* block_getAssert(PikaObj* self) {
return obj_getStr(self, "assert");
}
void block_setMode(PikaObj *self, char *mode)
{
obj_setStr(self, "mode", mode);
void block_setMode(PikaObj* self, char* mode) {
obj_setStr(self, "mode", mode);
}
char *block_getMode(PikaObj *self)
{
return obj_getStr(self, "mode");
char* block_getMode(PikaObj* self) {
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);
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);
}
char *block_popLine(PikaObj *self)
{
Args *buffs = New_strBuff();
char *body = obj_getStr(self, "body");
char *line = strsPopToken(buffs, body, '\n');
char* block_popLine(PikaObj* self) {
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");
}

24
src/package/pikascript/pikascript-core/PikaBlock.h
View File

@ -2,16 +2,16 @@
#define _pikaBlock__H
#include "PikaObj.h"
void block_deinit(PikaObj *self);
PikaObj *block_init(Args *args);
char *block_popLine(PikaObj *self);
void block_pushLine(PikaObj *self, char *line);
char *block_getBody(PikaObj *self);
char *block_getAssert(PikaObj *self);
void block_setAssert(PikaObj *self, char *assert);
uint8_t block_checkAssert(PikaObj *self);
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);
void block_deinit(PikaObj* self);
PikaObj* block_init(Args* args);
char* block_popLine(PikaObj* self);
void block_pushLine(PikaObj* self, char* line);
char* block_getBody(PikaObj* self);
char* block_getAssert(PikaObj* self);
void block_setAssert(PikaObj* self, char* assert);
uint8_t block_checkAssert(PikaObj* self);
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

51
src/package/pikascript/pikascript-core/PikaIf.c
View File

@ -1,39 +1,34 @@
#include "dataStrs.h"
#include "PikaIf.h"
#include <stdarg.h>
#include "PikaBlock.h"
#include "TinyObj.h"
#include "PikaIf.h"
#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);
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);
}
void if_pushLine(PikaObj *self, char *line)
{
Args *buffs = New_strBuff();
char *bodyLine = strsRemovePrefix(buffs, line, " ");
block_pushLine(self, bodyLine);
goto exit;
void if_pushLine(PikaObj* self, char* line) {
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);
}
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);
}
}
}

7
src/package/pikascript/pikascript-core/PikaIf.h
View File

@ -2,8 +2,7 @@
#define _pikaIf__H
#include "PikaObj.h"
void if_pushLine(PikaObj *self, char *line);
void if_setAssert(PikaObj *self, char *line);
void if_run(PikaObj *self);
void if_pushLine(PikaObj* self, char* line);
void if_setAssert(PikaObj* self, char* line);
void if_run(PikaObj* self);
#endif

583
src/package/pikascript/pikascript-core/PikaInvoke.c
View File

@ -1,338 +1,291 @@
#include <stdarg.h>
#include "PikaObj.h"
#include "dataArgs.h"
#include "dataMemory.h"
#include "dataString.h"
#include "dataStrs.h"
#include <stdarg.h>
static int32_t loadArgByType(PikaObj *self,
char *definedName,
char *definedType,
char *sourceArgPath,
Args *args)
{
if (strEqu(definedType, "any"))
{
if (0 == obj_getAnyArg(self, definedName, sourceArgPath, args))
{
return 0;
}
/* solve arg faild */
return 3;
static int32_t loadArgByType(PikaObj* self,
char* definedName,
char* definedType,
char* sourceArgPath,
Args* args) {
if (strEqu(definedType, "any")) {
if (0 == obj_getAnyArg(self, definedName, sourceArgPath, args)) {
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;
/* 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, "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;
/* reference value */
char* refStr = obj_getStr(self, sourceArgPath);
if (NULL == refStr) {
/* faild */
return 1;
}
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;
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, "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;
/* reference value */
if (!obj_isArgExist(self, sourceArgPath)) {
/* can not get reference */
return 3;
}
/* type match faild */
return 2;
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;
}
char *getTypeVal(Args *buffs, char *typeToken)
{
if (!strIsContain(typeToken, ':'))
{
return strsCopy(buffs, "");
}
return strsGetLastToken(buffs, typeToken, ':');
char* getTypeVal(Args* buffs, char* 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);
while (1)
{
char *argToken = strsPopToken(buffs, argListBuff, ',');
char *argName = strsGetFirstToken(buffs, argToken, '=');
char *argVal = strsGetLastToken(buffs, argToken, '=');
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;
}
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;
}
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;
}
}
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);
}
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;
}
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 *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;
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;
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;
}
/* 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;
}
}
char* typeName = strsGetFirstToken(buffs, typeToken, ':');
char* typeVal = getTypeVal(buffs, typeToken);
/* get return type */
char *returnType = strsGetLastToken(buffs, methodDec, ')');
char* argListBuff = strsCopy(buffs, argList);
while (1) {
char* argToken = strsPopToken(buffs, argListBuff, ',');
char* argName = strsGetFirstToken(buffs, argToken, '=');
char* argVal = strsGetLastToken(buffs, argToken, '=');
/* 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);
if (0 == argToken[0]) {
/* arg poped finised */
break;
}
/* 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)
{
if (!strEqu(typeName, argName)) {
/* name not match */
continue;
}
if (0 != loadArgByType(self, typeName, typeVal, argVal, args)) {
args_deinit(args);
args_deinit(buffs);
return NULL;
}
}
return res;
}
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;
}
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;
}
}
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);
}
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;
}
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* 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;
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;
}
}
/* 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;
}

2
src/package/pikascript/pikascript-core/PikaInvoke.h
View File

@ -1,4 +1,4 @@
#ifndef _invoke__H
#define _invoke__H
Args *obj_invoke(PikaObj *self, char *cmd);
Args* obj_invoke(PikaObj* self, char* cmd);
#endif

1415
src/package/pikascript/pikascript-core/PikaObj.c
View File

File diff suppressed because it is too large Load Diff

119
src/package/pikascript/pikascript-core/PikaObj.h
View File

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

61
src/package/pikascript/pikascript-core/PikaWhile.c
View File

@ -1,47 +1,42 @@
#include <stdarg.h>
#include "PikaBlock.h"
#include "PikaObj.h"
#include "dataArgs.h"
#include "dataMemory.h"
#include "dataString.h"
#include "dataStrs.h"
#include "PikaBlock.h"
#include <stdarg.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);
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);
}
void while_pushLine(PikaObj *self, char *line)
{
Args *buffs = New_strBuff();
char *bodyLine = strsRemovePrefix(buffs, line, " ");
block_pushLine(self, bodyLine);
goto exit;
void while_pushLine(PikaObj* self, char* line) {
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);
}
block_setBody(self, body);
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);
}
block_setBody(self, body);
}
exit:
args_deinit(buffs);
args_deinit(buffs);
}

6
src/package/pikascript/pikascript-core/PikaWhile.h
View File

@ -2,8 +2,8 @@
#define _pikaWhile__H
#include "PikaObj.h"
void while_setAssert(PikaObj *self, char *line);
void while_pushLine(PikaObj *self, char *line);
void while_run(PikaObj *self);
void while_setAssert(PikaObj* self, char* line);
void while_pushLine(PikaObj* self, char* line);
void while_run(PikaObj* self);
#endif

40
src/package/pikascript/pikascript-core/TinyObj.c
View File

@ -1,33 +1,29 @@
#include "PikaObj.h"
void _UpdateHandle(PikaObj *self)
{
// override the handle function here
void _UpdateHandle(PikaObj* self) {
// override the handle function here
}
void _beforDinit(PikaObj *self)
{
/* override in user code */
void _beforDinit(PikaObj* self) {
/* override in user code */
}
PikaObj *New_TinyObj(Args *args)
{
PikaObj *self = pikaMalloc(sizeof(PikaObj));
PikaObj* New_TinyObj(Args* args) {
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;
}

2
src/package/pikascript/pikascript-core/TinyObj.h
View File

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

657
src/package/pikascript/pikascript-core/dataArg.c
View File

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

84
src/package/pikascript/pikascript-core/dataArg.h
View File

@ -4,53 +4,57 @@
typedef uint8_t Arg;
uint16_t content_typeOffset(uint8_t *content);
uint16_t content_contentOffset(uint8_t *content);
uint16_t content_sizeOffset(uint8_t *self);
uint16_t content_contentOffset(uint8_t *self);
uint16_t content_nextOffset(uint8_t *self);
uint8_t content_nameOffset(uint8_t *self);
uint16_t content_typeOffset(uint8_t* content);
uint16_t content_contentOffset(uint8_t* content);
uint16_t content_sizeOffset(uint8_t* self);
uint16_t content_contentOffset(uint8_t* self);
uint16_t content_nextOffset(uint8_t* self);
uint8_t content_nameOffset(uint8_t* self);
char *content_getName(uint8_t *content);
char *content_getType(uint8_t *content);
uint8_t *content_getNext(uint8_t *self);
uint16_t content_getSize(uint8_t *self);
uint8_t *content_getContent(uint8_t *content);
char* content_getName(uint8_t* content);
char* content_getType(uint8_t* content);
uint8_t* content_getNext(uint8_t* self);
uint16_t content_getSize(uint8_t* self);
uint8_t* content_getContent(uint8_t* content);
uint16_t content_totleSize(uint8_t *self);
uint16_t content_totleSize(uint8_t* self);
uint8_t *content_init(char *name, char *type, uint8_t *content, uint16_t size, uint8_t *next);
uint8_t *content_deinit(uint8_t *self);
uint8_t *content_setName(uint8_t *self, char *name);
uint8_t *content_setType(uint8_t *self, char *type);
uint8_t *content_setContent(uint8_t *self, uint8_t *content, uint16_t size);
void content_setNext(uint8_t *self, uint8_t *next);
uint8_t* content_init(char* name,
char* type,
uint8_t* content,
uint16_t size,
uint8_t* next);
uint8_t* content_deinit(uint8_t* self);
uint8_t* content_setName(uint8_t* self, char* name);
uint8_t* content_setType(uint8_t* self, char* type);
uint8_t* content_setContent(uint8_t* self, uint8_t* content, uint16_t size);
void content_setNext(uint8_t* self, uint8_t* next);
uint16_t arg_getTotleSize(Arg *self);
void arg_freeContent(Arg *self);
uint16_t arg_getTotleSize(Arg* self);
void arg_freeContent(Arg* self);
Arg *arg_setName(Arg *self, char *name);
Arg *arg_setContent(Arg *self, uint8_t *content, uint32_t size);
Arg *arg_newContent(Arg *self, uint32_t size);
Arg *arg_setType(Arg *self, char *type);
char *arg_getName(Arg *self);
char *arg_getType(Arg *self);
uint8_t *arg_getContent(Arg *self);
uint16_t arg_getContentSize(Arg *self);
Arg* arg_setName(Arg* self, char* name);
Arg* arg_setContent(Arg* self, uint8_t* content, uint32_t size);
Arg* arg_newContent(Arg* self, uint32_t size);
Arg* arg_setType(Arg* self, char* type);
char* arg_getName(Arg* self);
char* arg_getType(Arg* self);
uint8_t* arg_getContent(Arg* self);
uint16_t arg_getContentSize(Arg* self);
Arg *arg_setInt(Arg *self, char *name, int64_t val);
Arg *arg_setFloat(Arg *self, char *name, float val);
Arg *arg_setPtr(Arg *self, char *name, char *type, void *pointer);
Arg *arg_setStr(Arg *self, char *name, char *string);
Arg* arg_setInt(Arg* self, char* name, int64_t val);
Arg* arg_setFloat(Arg* self, char* name, float val);
Arg* arg_setPtr(Arg* self, char* name, char* type, void* pointer);
Arg* arg_setStr(Arg* self, char* name, char* string);
int64_t arg_getInt(Arg *self);
float arg_getFloat(Arg *self);
void *arg_getPtr(Arg *self);
char *arg_getStr(Arg *self);
Arg *arg_copy(Arg *argToBeCopy);
int64_t arg_getInt(Arg* self);
float arg_getFloat(Arg* self);
void* arg_getPtr(Arg* self);
char* arg_getStr(Arg* self);
Arg* arg_copy(Arg* argToBeCopy);
Arg *arg_init(Arg *self, void *voidPointer);
void arg_deinit(Arg *self);
Arg* arg_init(Arg* self, void* voidPointer);
void arg_deinit(Arg* self);
Arg *New_arg(void *voidPointer);
Arg* New_arg(void* voidPointer);
#endif

940
src/package/pikascript/pikascript-core/dataArgs.c
View File

File diff suppressed because it is too large Load Diff

82
src/package/pikascript/pikascript-core/dataArgs.h
View File

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

129
src/package/pikascript/pikascript-core/dataLink.c
View File

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

19
src/package/pikascript/pikascript-core/dataLink.h
View File

@ -4,17 +4,16 @@
#include "dataMemory.h"
typedef struct Class_link Link;
struct Class_link
{
LinkNode *firstNode;
struct Class_link {
LinkNode* firstNode;
};
void link_deinit(Link *self);
void link_init(Link *self, void *args);
void link_addNode(Link *self, void *content);
void link_removeNode(Link *self, void *content);
LinkNode *link_getNode(Link *self, int64_t id);
int32_t link_getSize(Link *self);
void link_deinit(Link* self);
void link_init(Link* self, void* args);
void link_addNode(Link* self, void* content);
void link_removeNode(Link* self, void* content);
LinkNode* link_getNode(Link* self, int64_t id);
int32_t link_getSize(Link* self);
Link *New_link(void *args);
Link* New_link(void* args);
#endif

17
src/package/pikascript/pikascript-core/dataLinkNode.c
View File

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

6
src/package/pikascript/pikascript-core/dataLinkNode.h
View File

@ -3,8 +3,8 @@
#include "dataMemory.h"
typedef uint8_t LinkNode;
void linkNode_deinit(LinkNode *self);
void linkNode_init(LinkNode *self, void *args);
void linkNode_deinit(LinkNode* self);
void linkNode_init(LinkNode* self, void* args);
LinkNode *New_linkNode(void *args);
LinkNode* New_linkNode(void* args);
#endif

48
src/package/pikascript/pikascript-core/dataMemory.c
View File

@ -4,41 +4,33 @@
PikaMemInfo pikaMemInfo = {0};
void *pikaMalloc(uint32_t size)
{
pikaMemInfo.heapUsed += size;
if (pikaMemInfo.heapUsedMax < pikaMemInfo.heapUsed)
{
pikaMemInfo.heapUsedMax = pikaMemInfo.heapUsed;
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) {
}
void *mem = malloc(size);
if (NULL == mem)
{
printf("[error]: No heap space!\r\n");
while (1)
{
}
}
return mem;
}
return mem;
}
void pikaFree(void *mem, uint32_t size)
{
free(mem);
pikaMemInfo.heapUsed -= size;
void pikaFree(void* mem, uint32_t size) {
free(mem);
pikaMemInfo.heapUsed -= size;
}
uint16_t pikaMemNow(void)
{
return pikaMemInfo.heapUsed;
uint16_t pikaMemNow(void) {
return pikaMemInfo.heapUsed;
}
uint16_t pikaMemMax(void)
{
return pikaMemInfo.heapUsedMax;
uint16_t pikaMemMax(void) {
return pikaMemInfo.heapUsedMax;
}
void pikaMemMaxReset(void)
{
pikaMemInfo.heapUsedMax = 0;
void pikaMemMaxReset(void) {
pikaMemInfo.heapUsedMax = 0;
}

11
src/package/pikascript/pikascript-core/dataMemory.h
View File

@ -5,14 +5,13 @@
#include <stdio.h>
#include <string.h>
typedef struct
{
uint32_t heapUsed;
uint32_t heapUsedMax;
typedef struct {
uint32_t heapUsed;
uint32_t heapUsedMax;
} PikaMemInfo;
void pikaFree(void *mem, uint32_t size);
void *pikaMalloc(uint32_t size);
void pikaFree(void* mem, uint32_t size);
void* pikaMalloc(uint32_t size);
uint16_t pikaMemNow(void);
uint16_t pikaMemMax(void);
void pikaMemMaxReset(void);

473
src/package/pikascript/pikascript-core/dataString.c
View File

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

38
src/package/pikascript/pikascript-core/dataString.h
View File

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

198
src/package/pikascript/pikascript-core/dataStrs.c
View File

@ -1,118 +1,100 @@
#include "dataStrs.h"
#include "dataString.h"
#include <stdio.h>
#include <stdarg.h>
#include <stdio.h>
#include "dataString.h"
Args *New_strBuff(void)
{
return New_args(NULL);
Args* New_strBuff(void) {
return New_args(NULL);
}
char *strsRemovePrefix(Args *buffs, char *inputStr, char *prefix)
{
int32_t size = strGetSize(inputStr);
char *buff = args_getBuff(buffs, size);
return strRemovePrefix(inputStr, prefix, buff);
char* strsRemovePrefix(Args* buffs, char* inputStr, char* prefix) {
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;
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* strsAppend(Args* buffs, char* strOrigin, char* strToAppend) {
int32_t size = strGetSize(strOrigin) + strGetSize(strToAppend);
char* buff = args_getBuff(buffs, size);
char* strOut = strCopy(buff, strOrigin);
strAppend(strOut, strToAppend);
return strOut;
}
char* strsGetLastToken(Args* buffs, char* argPath, char sign) {
int32_t size = strGetSize(argPath);
char* buff = args_getBuff(buffs, size);
return strGetLastToken(buff, argPath, sign);
}
char* strsCut(Args* buffs, char* strIn, char startSign, char endSign) {
int32_t size = strGetSize(strIn);
char* buff = args_getBuff(buffs, size);
return strCut(buff, strIn, startSign, endSign);
}
char* strsDeleteChar(Args* buffs, char* strIn, char ch) {
int32_t size = strGetSize(strIn);
return strDeleteChar(args_getBuff(buffs, size), strIn, ch);
}
char* strsGetFirstToken(Args* buffs, char* strIn, char sign) {
int32_t size = strGetSize(strIn);
return strGetFirstToken(args_getBuff(buffs, size), strIn, sign);
}
char* strsPopToken(Args* buffs, char* tokens, char sign) {
int32_t size = strGetSize(tokens);
char* buff = args_getBuff(buffs, size);
return strPopToken(buff, tokens, sign);
}
char* strsCopy(Args* buffs, char* source) {
int32_t size = strGetSize(source);
char* buff = args_getBuff(buffs, size);
return strCopy(buff, source);
}
char* strsFormat(Args* buffs, 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;
}
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;
}
directStr = strsCut(buffs, argPath, '\'', '\'');
if (NULL != directStr)
{
return directStr;
if ((delChar == cmd[i]) && (!isInStr)) {
/* do not load char */
continue;
}
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;
}
char *strsGetLastToken(Args *buffs, char *argPath, char sign)
{
int32_t size = strGetSize(argPath);
char *buff = args_getBuff(buffs, size);
return strGetLastToken(buff, argPath, sign);
}
char *strsCut(Args *buffs, char *strIn, char startSign, char endSign)
{
int32_t size = strGetSize(strIn);
char *buff = args_getBuff(buffs, size);
return strCut(buff, strIn, startSign, endSign);
}
char *strsDeleteChar(Args *buffs, char *strIn, char ch)
{
int32_t size = strGetSize(strIn);
return strDeleteChar(args_getBuff(buffs, size), strIn, ch);
}
char *strsGetFirstToken(Args *buffs, char *strIn, char sign)
{
int32_t size = strGetSize(strIn);
return strGetFirstToken(args_getBuff(buffs, size), strIn, sign);
}
char *strsPopToken(Args *buffs, char *tokens, char sign)
{
int32_t size = strGetSize(tokens);
char *buff = args_getBuff(buffs, size);
return strPopToken(buff, tokens, sign);
}
char *strsCopy(Args *buffs, char *source)
{
int32_t size = strGetSize(source);
char *buff = args_getBuff(buffs, size);
return strCopy(buff, source);
}
char *strsFormat(Args *buffs, 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;
}
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;
}
if ((delChar == cmd[i]) && (!isInStr))
{
/* do not load char */
continue;
}
strOut[iOut] = cmd[i];
iOut++;
}
/* add \0 */
strOut[iOut] = 0;
return strOut;
strOut[iOut] = cmd[i];
iOut++;
}
/* add \0 */
strOut[iOut] = 0;
return strOut;
}

24
src/package/pikascript/pikascript-core/dataStrs.h
View File

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

35
src/package/pikascript/pikascript-core/method.c
View File

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

14
src/package/pikascript/pikascript-core/method.h
View File

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

95
src/test/arg-test.cpp
View File

@ -1,68 +1,61 @@
#include "gtest/gtest.h"
extern "C"
{
extern "C" {
#include "dataArg.h"
#include "dataString.h"
}
static int mem;
TEST(arg_test, int_)
{
Arg *arg = New_arg(NULL);
arg = arg_setInt(arg, (char *)"test", 1);
int a = arg_getInt(arg);
EXPECT_EQ(a, 1);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
TEST(arg_test, int_) {
Arg* arg = New_arg(NULL);
arg = arg_setInt(arg, (char*)"test", 1);
int a = arg_getInt(arg);
EXPECT_EQ(a, 1);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(arg_test, float_)
{
Arg *arg = New_arg(NULL);
arg = arg_setFloat(arg, (char *)"test", 1.01);
float a = arg_getFloat(arg);
EXPECT_EQ(a, (float)1.01);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
TEST(arg_test, float_) {
Arg* arg = New_arg(NULL);
arg = arg_setFloat(arg, (char*)"test", 1.01);
float a = arg_getFloat(arg);
EXPECT_EQ(a, (float)1.01);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(arg_test, str_)
{
Arg *arg = New_arg(NULL);
arg = arg_setStr(arg, (char *)"test", (char *)"test str");
char *a = arg_getStr(arg);
EXPECT_EQ(strEqu(a, (char *)"test str"), 1);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
TEST(arg_test, str_) {
Arg* arg = New_arg(NULL);
arg = arg_setStr(arg, (char*)"test", (char*)"test str");
char* a = arg_getStr(arg);
EXPECT_EQ(strEqu(a, (char*)"test str"), 1);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(arg_test, ptr)
{
Arg *arg = New_arg(NULL);
int a = 1;
arg = arg_setPtr(arg, (char *)"test", (char *)"pointer", &a);
int *pa = (int *)arg_getPtr(arg);
EXPECT_EQ(*pa, 1);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
TEST(arg_test, ptr) {
Arg* arg = New_arg(NULL);
int a = 1;
arg = arg_setPtr(arg, (char*)"test", (char*)"pointer", &a);
int* pa = (int*)arg_getPtr(arg);
EXPECT_EQ(*pa, 1);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(arg_test, name)
{
Arg *arg = New_arg(NULL);
arg = arg_setName(arg, (char *)"test");
char *name = arg_getName(arg);
EXPECT_STREQ((char *)"test", name);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
TEST(arg_test, name) {
Arg* arg = New_arg(NULL);
arg = arg_setName(arg, (char*)"test");
char* name = arg_getName(arg);
EXPECT_STREQ((char*)"test", name);
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(arg_test, type)
{
Arg *arg = New_arg(NULL);
arg = arg_setType(arg, (char *)"test");
char *type = arg_getType(arg);
EXPECT_EQ(1, strEqu((char *)"test", type));
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
TEST(arg_test, type) {
Arg* arg = New_arg(NULL);
arg = arg_setType(arg, (char*)"test");
char* type = arg_getType(arg);
EXPECT_EQ(1, strEqu((char*)"test", type));
arg_deinit(arg);
EXPECT_EQ(pikaMemNow(), 0);
}

290
src/test/args-test.cpp
View File

@ -1,192 +1,176 @@
#include "gtest/gtest.h"
extern "C"
{
extern "C" {
#include "dataArgs.h"
#include "dataString.h"
}
static int mem;
TEST(args, test1)
{
mem = pikaMemNow();
Args *args = New_args(NULL);
args_setInt(args, (char *)"a", 1);
int a = args_getInt(args, (char *)"a");
EXPECT_EQ(a, 1);
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test1) {
mem = pikaMemNow();
Args* args = New_args(NULL);
args_setInt(args, (char*)"a", 1);
int a = args_getInt(args, (char*)"a");
EXPECT_EQ(a, 1);
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test4)
{
int32_t testint = 12333;
Args *args = New_args(NULL);
args_setInt(args, (char *)"testint", testint);
EXPECT_EQ(12333, args_getInt(args, (char *)"testint"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test4) {
int32_t testint = 12333;
Args* args = New_args(NULL);
args_setInt(args, (char*)"testint", testint);
EXPECT_EQ(12333, args_getInt(args, (char*)"testint"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test2)
{
Args *args = New_args(NULL);
float floatOut = 0;
int64_t int64Out = 0;
void *pointer = NULL;
char *strOut = NULL;
args_setInt(args, (char *)"int64Test", (int64_t)22221);
args_setPtr(args, (char *)"pointerTest", (void *)2222322);
args_setStr(args, (char *)"strTest", (char *)"teeeds");
TEST(args, test2) {
Args* args = New_args(NULL);
float floatOut = 0;
int64_t int64Out = 0;
void* pointer = NULL;
char* strOut = NULL;
args_setInt(args, (char*)"int64Test", (int64_t)22221);
args_setPtr(args, (char*)"pointerTest", (void*)2222322);
args_setStr(args, (char*)"strTest", (char*)"teeeds");
int64Out = args_getInt(args, (char *)"int64Test");
pointer = args_getPtr(args, (char *)"pointerTest");
strOut = args_getStr(args, (char *)"strTest");
int64Out = args_getInt(args, (char*)"int64Test");
pointer = args_getPtr(args, (char*)"pointerTest");
strOut = args_getStr(args, (char*)"strTest");
EXPECT_EQ(int64Out, 22221);
EXPECT_EQ((uint64_t)pointer, 2222322);
EXPECT_EQ(1, strEqu((char *)"teeeds", strOut));
EXPECT_EQ(0, strcmp("int", args_getType(args, (char *)"int64Test")));
EXPECT_EQ(0, strcmp("pointer", args_getType(args, (char *)"pointerTest")));
EXPECT_EQ(0, strcmp("str", args_getType(args, (char *)"strTest")));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
EXPECT_EQ(int64Out, 22221);
EXPECT_EQ((uint64_t)pointer, 2222322);
EXPECT_EQ(1, strEqu((char*)"teeeds", strOut));
EXPECT_EQ(0, strcmp("int", args_getType(args, (char*)"int64Test")));
EXPECT_EQ(0, strcmp("pointer", args_getType(args, (char*)"pointerTest")));
EXPECT_EQ(0, strcmp("str", args_getType(args, (char*)"strTest")));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test3)
{
Args *args1 = New_args(NULL);
Args *args2 = New_args(NULL);
TEST(args, test3) {
Args* args1 = New_args(NULL);
Args* args2 = New_args(NULL);
args_setFloat(args1, (char *)"argtest1", 2.883);
args_setStr(args1, (char *)"strtest1", (char *)"teststr");
args_copyArgByName(args1, (char *)"argtest1", args2);
args_copyArgByName(args1, (char *)"strtest1", args2);
args_setFloat(args1, (char*)"argtest1", 2.883);
args_setStr(args1, (char*)"strtest1", (char*)"teststr");
args_copyArgByName(args1, (char*)"argtest1", args2);
args_copyArgByName(args1, (char*)"strtest1", args2);
EXPECT_EQ(2.8830f, args_getFloat(args1, (char *)"argtest1"));
args_deinit(args1);
args_deinit(args2);
EXPECT_EQ(pikaMemNow(), 0);
EXPECT_EQ(2.8830f, args_getFloat(args1, (char*)"argtest1"));
args_deinit(args1);
args_deinit(args2);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, buff)
{
Args *buffs = New_args(NULL);
char *buff = args_getBuff(buffs, 256);
args_deinit(buffs);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, buff) {
Args* buffs = New_args(NULL);
char* buff = args_getBuff(buffs, 256);
args_deinit(buffs);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, update)
{
Args *args = New_args(NULL);
args_setInt(args, (char *)"testInt", 124);
args_setInt(args, (char *)"testInt", 125);
EXPECT_EQ(125, args_getInt(args, (char *)"testInt"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, update) {
Args* args = New_args(NULL);
args_setInt(args, (char*)"testInt", 124);
args_setInt(args, (char*)"testInt", 125);
EXPECT_EQ(125, args_getInt(args, (char*)"testInt"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, print_int)
{
Args *args = New_args(NULL);
args_setInt(args, (char *)"testInt", 124);
EXPECT_STREQ((char *)"124", args_print(args, (char *)"testInt"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, print_int) {
Args* args = New_args(NULL);
args_setInt(args, (char*)"testInt", 124);
EXPECT_STREQ((char*)"124", args_print(args, (char*)"testInt"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test5)
{
int32_t testInt = 124;
Args *args = New_args(NULL);
args_bind(args, (char *)"int", (char *)"testInt", &testInt);
char *type = args_getType(args, (char *)"testInt");
args_print(args, (char *)"testInt");
EXPECT_STREQ((char *)"124", args_print(args, (char *)"testInt"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test5) {
int32_t testInt = 124;
Args* args = New_args(NULL);
args_bind(args, (char*)"int", (char*)"testInt", &testInt);
char* type = args_getType(args, (char*)"testInt");
args_print(args, (char*)"testInt");
EXPECT_STREQ((char*)"124", args_print(args, (char*)"testInt"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test6)
{
Args *args = New_args(NULL);
args_setFloat(args, (char *)"testfloat", 1.42);
EXPECT_STREQ((char *)"1.420000", args_print(args, (char *)"testfloat"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test6) {
Args* args = New_args(NULL);
args_setFloat(args, (char*)"testfloat", 1.42);
EXPECT_STREQ((char*)"1.420000", args_print(args, (char*)"testfloat"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test7)
{
Args *args = New_args(NULL);
float floatBindTest = 2.314;
args_bind(args, (char *)"float", (char *)"floatBind", &floatBindTest);
EXPECT_STREQ((char *)"2.314000", args_print(args, (char *)"floatBind"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test7) {
Args* args = New_args(NULL);
float floatBindTest = 2.314;
args_bind(args, (char*)"float", (char*)"floatBind", &floatBindTest);
EXPECT_STREQ((char*)"2.314000", args_print(args, (char*)"floatBind"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test8)
{
Args *args = New_args(NULL);
args_setStr(args, (char *)"testString", (char *)"test string print");
EXPECT_STREQ((char *)"test string print", args_print(args, (char *)"testString"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test8) {
Args* args = New_args(NULL);
args_setStr(args, (char*)"testString", (char*)"test string print");
EXPECT_STREQ((char*)"test string print",
args_print(args, (char*)"testString"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test9)
{
Args *args = New_args(NULL);
char strBindTest[] = "test string bind";
args_bindStr(args, (char *)"testStringBind", (char **)&strBindTest);
EXPECT_STREQ((char *)"test string bind", args_print(args, (char *)"testStringBind"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test9) {
Args* args = New_args(NULL);
char strBindTest[] = "test string bind";
args_bindStr(args, (char*)"testStringBind", (char**)&strBindTest);
EXPECT_STREQ((char*)"test string bind",
args_print(args, (char*)"testStringBind"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test10)
{
Args *args = New_args(NULL);
args_setInt(args, (char *)"testInt", 1);
char *printOutBefore = args_print(args, (char *)"testInt");
EXPECT_TRUE(strEqu(printOutBefore, (char *)"1"));
args_set(args, (char *)"testInt", (char *)"4");
char *printOutAfter = args_print(args, (char *)"testInt");
EXPECT_TRUE(strEqu(printOutAfter, (char *)"4"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test10) {
Args* args = New_args(NULL);
args_setInt(args, (char*)"testInt", 1);
char* printOutBefore = args_print(args, (char*)"testInt");
EXPECT_TRUE(strEqu(printOutBefore, (char*)"1"));
args_set(args, (char*)"testInt", (char*)"4");
char* printOutAfter = args_print(args, (char*)"testInt");
EXPECT_TRUE(strEqu(printOutAfter, (char*)"4"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test11)
{
Args *args = New_args(NULL);
char testStrBind[256] = "testtest";
args_bindStr(args, (char *)"testStr", (char **)&testStrBind);
char *printOutBefore = args_print(args, (char *)"testStr");
EXPECT_TRUE(strEqu(printOutBefore, (char *)"testtest"));
args_set(args, (char *)"testStr", (char *)"ttww");
char *printOutAfter = args_print(args, (char *)"testStr");
EXPECT_TRUE(strEqu(printOutAfter, (char *)"ttww"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test11) {
Args* args = New_args(NULL);
char testStrBind[256] = "testtest";
args_bindStr(args, (char*)"testStr", (char**)&testStrBind);
char* printOutBefore = args_print(args, (char*)"testStr");
EXPECT_TRUE(strEqu(printOutBefore, (char*)"testtest"));
args_set(args, (char*)"testStr", (char*)"ttww");
char* printOutAfter = args_print(args, (char*)"testStr");
EXPECT_TRUE(strEqu(printOutAfter, (char*)"ttww"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, test12)
{
Args *args = New_args(NULL);
args_setInt(args, (char *)"test", 13);
args_setInt(args, (char *)"kw", 25);
EXPECT_EQ(2, args_getSize(args));
EXPECT_EQ(13, (int)args_getInt(args, (char *)"test"));
args_removeArg(args, (char *)"test");
EXPECT_EQ(1, args_getSize(args));
EXPECT_EQ(-999999999, (int)args_getInt(args, (char *)"test"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, test12) {
Args* args = New_args(NULL);
args_setInt(args, (char*)"test", 13);
args_setInt(args, (char*)"kw", 25);
EXPECT_EQ(2, args_getSize(args));
EXPECT_EQ(13, (int)args_getInt(args, (char*)"test"));
args_removeArg(args, (char*)"test");
EXPECT_EQ(1, args_getSize(args));
EXPECT_EQ(-999999999, (int)args_getInt(args, (char*)"test"));
args_deinit(args);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(args, mem)
{
EXPECT_EQ(pikaMemNow(), mem);
EXPECT_EQ(pikaMemNow(), 0);
TEST(args, mem) {
EXPECT_EQ(pikaMemNow(), mem);
EXPECT_EQ(pikaMemNow(), 0);
}

196
src/test/block-test.cpp
View File

@ -1,125 +1,115 @@
#include "gtest/gtest.h"
extern "C"
{
#include "PikaBlock.h"
#include "dataStrs.h"
#include "PikaIf.h"
#include "TinyObj.h"
extern "C" {
#include "BaseObj.h"
#include "PikaBlock.h"
#include "PikaIf.h"
#include "PikaObj.h"
#include "TinyObj.h"
#include "dataStrs.h"
}
TEST(block, init)
{
PikaObj *block = block_init(NULL);
block_deinit(block);
EXPECT_EQ(pikaMemNow(), 0);
TEST(block, init) {
PikaObj* block = block_init(NULL);
block_deinit(block);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(block, push)
{
PikaObj *block = block_init(NULL);
block_pushLine(block, (char *)"line1");
block_pushLine(block, (char *)"line2");
block_deinit(block);
EXPECT_EQ(pikaMemNow(), 0);
TEST(block, push) {
PikaObj* block = block_init(NULL);
block_pushLine(block, (char*)"line1");
block_pushLine(block, (char*)"line2");
block_deinit(block);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(block, pop)
{
PikaObj *block = block_init(NULL);
block_pushLine(block, (char *)"line1");
block_pushLine(block, (char *)"line2");
char *line1 = block_popLine(block);
ASSERT_STREQ(line1, (char *)"line1");
char *line2 = block_popLine(block);
ASSERT_STREQ(line2, (char *)"line2");
char *line3 = block_popLine(block);
ASSERT_STREQ(line3, (char *)"");
block_deinit(block);
EXPECT_EQ(pikaMemNow(), 0);
TEST(block, pop) {
PikaObj* block = block_init(NULL);
block_pushLine(block, (char*)"line1");
block_pushLine(block, (char*)"line2");
char* line1 = block_popLine(block);
ASSERT_STREQ(line1, (char*)"line1");
char* line2 = block_popLine(block);
ASSERT_STREQ(line2, (char*)"line2");
char* line3 = block_popLine(block);
ASSERT_STREQ(line3, (char*)"");
block_deinit(block);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(block, assert1)
{
PikaObj *block = block_init(NULL);
{
block_setAssert(block, (char *)"1");
int res = block_checkAssert(block);
ASSERT_EQ(1, res);
}
{
block_setAssert(block, (char *)"0");
int res = block_checkAssert(block);
ASSERT_EQ(0, res);
}
block_deinit(block);
}
TEST(block, if1)
{
PikaObj *block = block_init(NULL);
if_setAssert(block, (char *)"if 1 :");
if_pushLine(block, (char *)" print('hello')");
if_pushLine(block, (char *)" print('hello2')");
char *assert = block_getAssert(block);
ASSERT_STREQ((char *)"1 ", assert);
TEST(block, assert1) {
PikaObj* block = block_init(NULL);
{
block_setAssert(block, (char*)"1");
int res = block_checkAssert(block);
char *line1 = block_popLine(block);
ASSERT_STREQ((char *)"print('hello')", line1);
char *line2 = block_popLine(block);
ASSERT_STREQ((char *)"print('hello2')", line2);
ASSERT_EQ(1, res);
block_deinit(block);
}
{
block_setAssert(block, (char*)"0");
int res = block_checkAssert(block);
ASSERT_EQ(0, res);
}
block_deinit(block);
}
TEST(block, if2)
{
PikaObj *obj = New_TinyObj(NULL);
obj_run(obj, (char *)"if 1 :");
obj_deinit(obj);
TEST(block, if1) {
PikaObj* block = block_init(NULL);
if_setAssert(block, (char*)"if 1 :");
if_pushLine(block, (char*)" print('hello')");
if_pushLine(block, (char*)" print('hello2')");
char* assert = block_getAssert(block);
ASSERT_STREQ((char*)"1 ", assert);
int res = block_checkAssert(block);
char* line1 = block_popLine(block);
ASSERT_STREQ((char*)"print('hello')", line1);
char* line2 = block_popLine(block);
ASSERT_STREQ((char*)"print('hello2')", line2);
ASSERT_EQ(1, res);
block_deinit(block);
}
TEST(block, if3)
{
PikaObj *obj = New_TinyObj(NULL);
obj_run(obj, (char *)"if 1 :");
obj_run(obj, (char *)" print('hello')");
obj_run(obj, (char *)" print('hello2')");
PikaObj *block = obj_getObj(obj, (char *)"_block", 0);
char *mode = block_getMode(block);
ASSERT_STREQ((char *)"if", mode);
char *assert = block_getAssert(block);
ASSERT_STREQ((char *)"1 ", assert);
char *line1 = block_popLine(block);
ASSERT_STREQ((char *)"print('hello')", line1);
char *line2 = block_popLine(block);
ASSERT_STREQ((char *)"print('hello2')", line2);
obj_deinit(obj);
TEST(block, if2) {
PikaObj* obj = New_TinyObj(NULL);
obj_run(obj, (char*)"if 1 :");
obj_deinit(obj);
}
TEST(block, ifrun1)
{
PikaObj *obj = newRootObj((char *)"root", New_BaseObj);
obj_run(obj, (char *)"if 1 :");
obj_run(obj, (char *)" a = 1");
obj_run(obj, (char *)" b = 2");
obj_run(obj, (char *)"");
int a = obj_getInt(obj, (char *)"a");
int b = obj_getInt(obj, (char *)"b");
ASSERT_EQ(a, 1);
ASSERT_EQ(b, 2);
obj_deinit(obj);
TEST(block, if3) {
PikaObj* obj = New_TinyObj(NULL);
obj_run(obj, (char*)"if 1 :");
obj_run(obj, (char*)" print('hello')");
obj_run(obj, (char*)" print('hello2')");
PikaObj* block = obj_getObj(obj, (char*)"_block", 0);
char* mode = block_getMode(block);
ASSERT_STREQ((char*)"if", mode);
char* assert = block_getAssert(block);
ASSERT_STREQ((char*)"1 ", assert);
char* line1 = block_popLine(block);
ASSERT_STREQ((char*)"print('hello')", line1);
char* line2 = block_popLine(block);
ASSERT_STREQ((char*)"print('hello2')", line2);
obj_deinit(obj);
}
TEST(block, ifrun2)
{
PikaObj *obj = newRootObj((char *)"root", New_BaseObj);
obj_run(obj, (char *)"if 0 :");
PikaObj *block = obj_getObj(obj, (char *)"_block", 0);
char *assert = block_getAssert(block);
uint8_t res = block_checkAssert(block);
ASSERT_EQ(res, 0);
obj_deinit(obj);
TEST(block, ifrun1) {
PikaObj* obj = newRootObj((char*)"root", New_BaseObj);
obj_run(obj, (char*)"if 1 :");
obj_run(obj, (char*)" a = 1");
obj_run(obj, (char*)" b = 2");
obj_run(obj, (char*)"");
int a = obj_getInt(obj, (char*)"a");
int b = obj_getInt(obj, (char*)"b");
ASSERT_EQ(a, 1);
ASSERT_EQ(b, 2);
obj_deinit(obj);
}
TEST(block, ifrun2) {
PikaObj* obj = newRootObj((char*)"root", New_BaseObj);
obj_run(obj, (char*)"if 0 :");
PikaObj* block = obj_getObj(obj, (char*)"_block", 0);
char* assert = block_getAssert(block);
uint8_t res = block_checkAssert(block);
ASSERT_EQ(res, 0);
obj_deinit(obj);
}

163
src/test/content-test.cpp
View File

@ -1,108 +1,103 @@
#include "gtest/gtest.h"
extern "C"
{
extern "C" {
#include "dataArg.h"
#include "dataString.h"
#include "dataString.h"
}
static int mem;
TEST(content, init)
{
uint8_t contentIn[4] = {0};
contentIn[0] = 1;
contentIn[1] = 2;
contentIn[2] = 3;
contentIn[3] = 4;
uint16_t sizeIn = 4;
uint8_t *self = content_init((char *)"name", (char *)"type", contentIn, 4, NULL);
TEST(content, init) {
uint8_t contentIn[4] = {0};
contentIn[0] = 1;
contentIn[1] = 2;
contentIn[2] = 3;
contentIn[3] = 4;
uint16_t sizeIn = 4;
uint8_t* self =
content_init((char*)"name", (char*)"type", contentIn, 4, NULL);
uint16_t typeOffset = content_typeOffset(self);
uint16_t sizeOffset = content_sizeOffset(self);
uint16_t contentOffset = content_contentOffset(self);
uint16_t totleSize = content_totleSize(self);
uint16_t typeOffset = content_typeOffset(self);
uint16_t sizeOffset = content_sizeOffset(self);
uint16_t contentOffset = content_contentOffset(self);
uint16_t totleSize = content_totleSize(self);
char *name = content_getName(self);
char *type = content_getType(self);
uint16_t size = content_getSize(self);
uint8_t *content = content_getContent(self);
char* name = content_getName(self);
char* type = content_getType(self);
uint16_t size = content_getSize(self);
uint8_t* content = content_getContent(self);
ASSERT_EQ(contentOffset, 15);
ASSERT_EQ(typeOffset, 19);
ASSERT_EQ(sizeOffset, 8);
ASSERT_EQ(size, 4);
ASSERT_EQ(content[0], 1);
ASSERT_EQ(content[1], 2);
ASSERT_EQ(content[2], 3);
ASSERT_EQ(content[3], 4);
ASSERT_EQ(totleSize, 24);
ASSERT_EQ(contentOffset, 15);
ASSERT_EQ(typeOffset, 19);
ASSERT_EQ(sizeOffset, 8);
ASSERT_EQ(size, 4);
ASSERT_EQ(content[0], 1);
ASSERT_EQ(content[1], 2);
ASSERT_EQ(content[2], 3);
ASSERT_EQ(content[3], 4);
ASSERT_EQ(totleSize, 24);
ASSERT_STREQ((char *)"name", name);
ASSERT_STREQ((char *)"type", type);
ASSERT_STREQ((char*)"name", name);
ASSERT_STREQ((char*)"type", type);
content_deinit(self);
EXPECT_EQ(pikaMemNow(), 0);
content_deinit(self);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(content, set)
{
uint8_t contentIn[4] = {0};
contentIn[0] = 1;
contentIn[1] = 2;
contentIn[2] = 3;
contentIn[3] = 4;
uint8_t *self = content_init((char *)"", (char *)"", NULL, 0, NULL);
self = content_setName(self, (char *)"name");
self = content_setType(self, (char *)"type");
self = content_setContent(self, contentIn, 4);
TEST(content, set) {
uint8_t contentIn[4] = {0};
contentIn[0] = 1;
contentIn[1] = 2;
contentIn[2] = 3;
contentIn[3] = 4;
uint8_t* self = content_init((char*)"", (char*)"", NULL, 0, NULL);
self = content_setName(self, (char*)"name");
self = content_setType(self, (char*)"type");
self = content_setContent(self, contentIn, 4);
uint16_t typeOffset = content_typeOffset(self);
uint16_t sizeOffset = content_sizeOffset(self);
uint16_t contentOffset = content_contentOffset(self);
uint16_t totleSize = content_totleSize(self);
uint16_t typeOffset = content_typeOffset(self);
uint16_t sizeOffset = content_sizeOffset(self);
uint16_t contentOffset = content_contentOffset(self);
uint16_t totleSize = content_totleSize(self);
char *name = content_getName(self);
char *type = content_getType(self);
uint16_t size = content_getSize(self);
uint8_t *content = content_getContent(self);
char* name = content_getName(self);
char* type = content_getType(self);
uint16_t size = content_getSize(self);
uint8_t* content = content_getContent(self);
ASSERT_EQ(contentOffset, 15);
ASSERT_EQ(typeOffset, 19);
ASSERT_EQ(sizeOffset, 8);
ASSERT_EQ(size, 4);
ASSERT_EQ(content[0], 1);
ASSERT_EQ(content[1], 2);
ASSERT_EQ(content[2], 3);
ASSERT_EQ(content[3], 4);
ASSERT_EQ(totleSize, 24);
ASSERT_EQ(contentOffset, 15);
ASSERT_EQ(typeOffset, 19);
ASSERT_EQ(sizeOffset, 8);
ASSERT_EQ(size, 4);
ASSERT_EQ(content[0], 1);
ASSERT_EQ(content[1], 2);
ASSERT_EQ(content[2], 3);
ASSERT_EQ(content[3], 4);
ASSERT_EQ(totleSize, 24);
ASSERT_STREQ("name", name);
ASSERT_STREQ("type", type);
ASSERT_STREQ("name", name);
ASSERT_STREQ("type", type);
content_deinit(self);
EXPECT_EQ(pikaMemNow(), 0);
content_deinit(self);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(content, next)
{
uint8_t *c1 = content_init((char *)"c1", (char *)"type", NULL, 0, NULL);
uint8_t *c2 = content_init((char *)"c2", (char *)"type", NULL, 0, c1);
uint8_t *c3 = content_getNext(c2);
TEST(content, next) {
uint8_t* c1 = content_init((char*)"c1", (char*)"type", NULL, 0, NULL);
uint8_t* c2 = content_init((char*)"c2", (char*)"type", NULL, 0, c1);
uint8_t* c3 = content_getNext(c2);
ASSERT_EQ(c3, c1);
content_deinit(c1);
content_deinit(c2);
EXPECT_EQ(pikaMemNow(), 0);
ASSERT_EQ(c3, c1);
content_deinit(c1);
content_deinit(c2);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(content, setNext)
{
uint8_t *c1 = content_init((char *)"c1", (char *)"type", NULL, 0, NULL);
content_setNext(c1, content_init((char *)"c2", (char *)"type", NULL, 0, NULL));
uint8_t *c2 = content_getNext(c1);
char *c2Name = content_getName(c2);
EXPECT_STREQ(c2Name, (char *)"c2");
content_deinit(c1);
content_deinit(c2);
EXPECT_EQ(pikaMemNow(), 0);
TEST(content, setNext) {
uint8_t* c1 = content_init((char*)"c1", (char*)"type", NULL, 0, NULL);
content_setNext(c1, content_init((char*)"c2", (char*)"type", NULL, 0, NULL));
uint8_t* c2 = content_getNext(c1);
char* c2Name = content_getName(c2);
EXPECT_STREQ(c2Name, (char*)"c2");
content_deinit(c1);
content_deinit(c2);
EXPECT_EQ(pikaMemNow(), 0);
}

6
src/test/main.cpp
View File

@ -1,6 +1,6 @@
#include "gtest/gtest.h"
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

383
src/test/object-test.cpp
View File

@ -1,261 +1,240 @@
#include "gtest/gtest.h"
extern "C"
{
extern "C" {
#include "BaseObj.h"
#include "PikaStdLib_SysObj.h"
#include "TinyObj.h"
#include "BaseObj.h"
}
void testFloat(PikaObj *obj, Args *args)
{
float val1 = args_getFloat(args, (char *)"val1");
float val2 = args_getFloat(args, (char *)"val2");
int32_t isShow = args_getInt(args, (char *)"isShow");
if (isShow)
{
printf("the float val1 is: %f\r\n", val1);
printf("the float val2 is: %f\r\n", val2);
}
method_returnFloat(args, val1 + val2);
void testFloat(PikaObj* obj, Args* args) {
float val1 = args_getFloat(args, (char*)"val1");
float val2 = args_getFloat(args, (char*)"val2");
int32_t isShow = args_getInt(args, (char*)"isShow");
if (isShow) {
printf("the float val1 is: %f\r\n", val1);
printf("the float val2 is: %f\r\n", val2);
}
method_returnFloat(args, val1 + val2);
}
void hello2(PikaObj *obj, Args *args)
{
char *name1 = args_getStr(args, (char *)"name1");
char *name2 = args_getStr(args, (char *)"name2");
char *name3 = args_getStr(args, (char *)"name3");
char *myName = obj_getStr(obj, (char *)"_n");
int32_t isShow = args_getInt(args, (char *)"isShow");
if (isShow)
{
printf("hello, %s, %s and %s!\r\n", name1, name2, name3);
printf("my name is %s.\r\n", myName);
}
void hello2(PikaObj* obj, Args* args) {
char* name1 = args_getStr(args, (char*)"name1");
char* name2 = args_getStr(args, (char*)"name2");
char* name3 = args_getStr(args, (char*)"name3");
char* myName = obj_getStr(obj, (char*)"_n");
int32_t isShow = args_getInt(args, (char*)"isShow");
if (isShow) {
printf("hello, %s, %s and %s!\r\n", name1, name2, name3);
printf("my name is %s.\r\n", myName);
}
}
void hello(PikaObj *obj, Args *args)
{
char *name = args_getStr(args, (char *)"name");
int32_t isShow = args_getInt(args, (char *)"isShow");
if (isShow)
{
printf("hello, %s!\r\n", name);
}
void hello(PikaObj* obj, Args* args) {
char* name = args_getStr(args, (char*)"name");
int32_t isShow = args_getInt(args, (char*)"isShow");
if (isShow) {
printf("hello, %s!\r\n", name);
}
}
void add(PikaObj *obj, Args *args)
{
int32_t val1 = args_getInt(args, (char *)"val1");
int32_t val2 = args_getInt(args, (char *)"val2");
method_returnInt(args, val1 + val2);
void add(PikaObj* obj, Args* args) {
int32_t val1 = args_getInt(args, (char*)"val1");
int32_t val2 = args_getInt(args, (char*)"val2");
method_returnInt(args, val1 + val2);
}
PikaObj *New_PikaObj_test(Args *args)
{
PikaObj *self = New_PikaStdLib_SysObj(args);
class_defineMethod(self, (char *)"hello(name:str, isShow:int)", hello);
class_defineMethod(self, (char *)"hello2(name1:str, name2:str, name3:str, isShow:int)", hello2);
class_defineMethod(self, (char *)"testFloat(val1:float, val2:float, isShow:int)->float", testFloat);
class_defineMethod(self, (char *)"add(val1:int, val2:int)->int", add);
return self;
PikaObj* New_PikaObj_test(Args* args) {
PikaObj* self = New_PikaStdLib_SysObj(args);
class_defineMethod(self, (char*)"hello(name:str, isShow:int)", hello);
class_defineMethod(
self, (char*)"hello2(name1:str, name2:str, name3:str, isShow:int)",
hello2);
class_defineMethod(
self, (char*)"testFloat(val1:float, val2:float, isShow:int)->float",
testFloat);
class_defineMethod(self, (char*)"add(val1:int, val2:int)->int", add);
return self;
}
void sendMethod(PikaObj *self, Args *args)
{
char *data = args_getStr(args, (char *)"data");
/* send to com1 */
printf("[com1]: %s\r\n", data);
void sendMethod(PikaObj* self, Args* args) {
char* data = args_getStr(args, (char*)"data");
/* send to com1 */
printf("[com1]: %s\r\n", data);
}
PikaObj *New_USART(Args *args)
{
/* Derive from the tiny object class.
Tiny object can not import sub object.
Tiny object is the smallest object. */
PikaObj *self = New_TinyObj(args);
PikaObj* New_USART(Args* args) {
/* Derive from the tiny object class.
Tiny object can not import sub object.
Tiny object is the smallest object. */
PikaObj* self = New_TinyObj(args);
/* bind the method */
class_defineMethod(self, (char *)"send(data:str)", sendMethod);
/* bind the method */
class_defineMethod(self, (char*)"send(data:str)", sendMethod);
/* return the object */
return self;
/* return the object */
return self;
}
PikaObj *New_MYROOT1(Args *args)
{
/* Derive from the base object class .
BaseObj is the smallest object that can
import sub object. */
PikaObj *self = New_BaseObj(args);
PikaObj* New_MYROOT1(Args* args) {
/* Derive from the base object class .
BaseObj is the smallest object that can
import sub object. */
PikaObj* self = New_BaseObj(args);
/* import LED class */
obj_import(self, (char *)"USART", New_USART);
/* import LED class */
obj_import(self, (char*)"USART", New_USART);
/* new led object bellow root object */
obj_newObj(self, (char *)"usart", (char *)"USART");
/* new led object bellow root object */
obj_newObj(self, (char*)"usart", (char*)"USART");
/* return the object */
return self;
/* return the object */
return self;
}
TEST(object_test, test1)
{
PikaObj *process = newRootObj((char *)"sys", New_PikaStdLib_SysObj);
float floatTest = 12.231;
obj_bindFloat(process, (char *)"testFloatBind", &floatTest);
EXPECT_TRUE(strEqu((char *)"12.231000", obj_print(process, (char *)"testFloatBind")));
obj_deinit(process);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test1) {
PikaObj* process = newRootObj((char*)"sys", New_PikaStdLib_SysObj);
float floatTest = 12.231;
obj_bindFloat(process, (char*)"testFloatBind", &floatTest);
EXPECT_TRUE(
strEqu((char*)"12.231000", obj_print(process, (char*)"testFloatBind")));
obj_deinit(process);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test2)
{
int isShow = 1;
PikaObj *obj = newRootObj((char *)"test", New_PikaObj_test);
obj_setInt(obj, (char *)"isShow", isShow);
obj_run(obj, (char *)"hello(name = 'world', isShow = isShow)");
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test2) {
int isShow = 1;
PikaObj* obj = newRootObj((char*)"test", New_PikaObj_test);
obj_setInt(obj, (char*)"isShow", isShow);
obj_run(obj, (char*)"hello(name = 'world', isShow = isShow)");
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test3)
{
int isShow = 1;
PikaObj *obj = newRootObj((char *)"test", New_PikaObj_test);
obj_setInt(obj, (char *)"isShow", isShow);
obj_run(obj, (char *)"hello2(name2='tom', name1='john', name3='cat', isShow=isShow) ");
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test3) {
int isShow = 1;
PikaObj* obj = newRootObj((char*)"test", New_PikaObj_test);
obj_setInt(obj, (char*)"isShow", isShow);
obj_run(
obj,
(char*)"hello2(name2='tom', name1='john', name3='cat', isShow=isShow) ");
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test4)
{
int isShow = 1;
PikaObj *obj = newRootObj((char *)"test", New_PikaObj_test);
obj_setInt(obj, (char *)"isShow", isShow);
obj_setFloat(obj, (char *)"val2", 3.11);
obj_run(obj, (char *)"res = testFloat(val1 = 3.22,val2 = val2,isShow = isShow)");
float res = obj_getFloat(obj, (char *)"res");
EXPECT_FLOAT_EQ(res, 6.33);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test4) {
int isShow = 1;
PikaObj* obj = newRootObj((char*)"test", New_PikaObj_test);
obj_setInt(obj, (char*)"isShow", isShow);
obj_setFloat(obj, (char*)"val2", 3.11);
obj_run(obj,
(char*)"res = testFloat(val1 = 3.22,val2 = val2,isShow = isShow)");
float res = obj_getFloat(obj, (char*)"res");
EXPECT_FLOAT_EQ(res, 6.33);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test5)
{
PikaObj *obj = newRootObj((char *)"test", New_PikaObj_test);
obj_run(obj, (char *)"res = add(val1 = 1, val2 = 2)");
int32_t res = obj_getInt(obj, (char *)"res");
EXPECT_EQ(3, res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test5) {
PikaObj* obj = newRootObj((char*)"test", New_PikaObj_test);
obj_run(obj, (char*)"res = add(val1 = 1, val2 = 2)");
int32_t res = obj_getInt(obj, (char*)"res");
EXPECT_EQ(3, res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test6)
{
PikaObj *obj = newRootObj((char *)"test", New_PikaObj_test);
obj_run(obj, (char *)"res = add(1, 2)");
int32_t res = obj_getInt(obj, (char *)"res");
EXPECT_EQ(3, res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test6) {
PikaObj* obj = newRootObj((char*)"test", New_PikaObj_test);
obj_run(obj, (char*)"res = add(1, 2)");
int32_t res = obj_getInt(obj, (char*)"res");
EXPECT_EQ(3, res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test7)
{
PikaObj *sys = newRootObj((char *)"sys", New_PikaStdLib_SysObj);
int32_t a = 0;
obj_bind(sys, (char *)"int", (char *)"a", &a);
obj_run(sys, (char *)"set('a', 1)");
obj_deinit(sys);
EXPECT_EQ(1, a);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test7) {
PikaObj* sys = newRootObj((char*)"sys", New_PikaStdLib_SysObj);
int32_t a = 0;
obj_bind(sys, (char*)"int", (char*)"a", &a);
obj_run(sys, (char*)"set('a', 1)");
obj_deinit(sys);
EXPECT_EQ(1, a);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test8)
{
PikaObj *sys = newRootObj((char *)"sys", New_PikaStdLib_SysObj);
obj_run(sys, (char *)"set('a', 1)");
obj_run(sys, (char *)"remove('a')");
obj_deinit(sys);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test8) {
PikaObj* sys = newRootObj((char*)"sys", New_PikaStdLib_SysObj);
obj_run(sys, (char*)"set('a', 1)");
obj_run(sys, (char*)"remove('a')");
obj_deinit(sys);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test9)
{
PikaObj *sys = newRootObj((char *)"sys", New_PikaStdLib_SysObj);
obj_run(sys, (char *)"ls()");
obj_setPtr(sys, (char *)"baseClass", (void *)New_TinyObj);
obj_run(sys, (char *)"ls()");
obj_deinit(sys);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test9) {
PikaObj* sys = newRootObj((char*)"sys", New_PikaStdLib_SysObj);
obj_run(sys, (char*)"ls()");
obj_setPtr(sys, (char*)"baseClass", (void*)New_TinyObj);
obj_run(sys, (char*)"ls()");
obj_deinit(sys);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, test10)
{
PikaObj *root = newRootObj((char *)"root", New_MYROOT1);
obj_run(root, (char *)"res = usart.send('hello world')");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, test10) {
PikaObj* root = newRootObj((char*)"root", New_MYROOT1);
obj_run(root, (char*)"res = usart.send('hello world')");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, newObject)
{
PikaObj *root = newRootObj((char *)"root", New_MYROOT1);
obj_newObj(root, (char *)"newUart", (char *)"USART");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, newObject) {
PikaObj* root = newRootObj((char*)"root", New_MYROOT1);
obj_newObj(root, (char*)"newUart", (char*)"USART");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, newObjectAndSetStr)
{
PikaObj *root = newRootObj((char *)"root", New_MYROOT1);
obj_newObj(root, (char *)"newUart", (char *)"USART");
obj_setStr(root, (char *)"newUart.name", (char *)"testName");
char *name = obj_getStr(root, (char *)"newUart.name");
printf("the name is %s\r\n", name);
EXPECT_TRUE(strEqu((char *)"testName", name));
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, newObjectAndSetStr) {
PikaObj* root = newRootObj((char*)"root", New_MYROOT1);
obj_newObj(root, (char*)"newUart", (char*)"USART");
obj_setStr(root, (char*)"newUart.name", (char*)"testName");
char* name = obj_getStr(root, (char*)"newUart.name");
printf("the name is %s\r\n", name);
EXPECT_TRUE(strEqu((char*)"testName", name));
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, noMethod)
{
PikaObj *root = newRootObj((char *)"root", New_MYROOT1);
obj_runNoRes(root, (char *)"noDefindMethod()");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, noMethod) {
PikaObj* root = newRootObj((char*)"root", New_MYROOT1);
obj_runNoRes(root, (char*)"noDefindMethod()");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, a_b)
{
PikaObj *root = newRootObj((char *)"root", New_MYROOT1);
obj_runNoRes(root, (char *)"a=b");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, a_b) {
PikaObj* root = newRootObj((char*)"root", New_MYROOT1);
obj_runNoRes(root, (char*)"a=b");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, voidRun)
{
PikaObj *root = newRootObj((char *)"root", New_MYROOT1);
obj_run(root, (char *)"");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, voidRun) {
PikaObj* root = newRootObj((char*)"root", New_MYROOT1);
obj_run(root, (char*)"");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, printa)
{
PikaObj *root = newRootObj((char *)"root", New_BaseObj);
obj_run(root, (char *)"a = 2");
obj_run(root, (char *)"print(a)");
char *sysOut = obj_getSysOut(root);
ASSERT_STREQ(sysOut, "2");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, printa) {
PikaObj* root = newRootObj((char*)"root", New_BaseObj);
obj_run(root, (char*)"a = 2");
obj_run(root, (char*)"print(a)");
char* sysOut = obj_getSysOut(root);
ASSERT_STREQ(sysOut, "2");
obj_deinit(root);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(object_test, mem)
{
EXPECT_EQ(pikaMemNow(), 0);
EXPECT_EQ(pikaMemNow(), 0);
TEST(object_test, mem) {
EXPECT_EQ(pikaMemNow(), 0);
EXPECT_EQ(pikaMemNow(), 0);
}

116
src/test/strs-test.cpp
View File

@ -1,81 +1,73 @@
#include "gtest/gtest.h"
extern "C"
{
#include "dataStrs.h"
#include "dataString.h"
extern "C" {
#include "dataArgs.h"
#include "dataMemory.h"
#include "dataString.h"
#include "dataStrs.h"
}
static void printInfo(const char *argName, char *argVal)
{
printf("\t\t[info] %s: \"%s\"\r\n", argName, argVal);
static void printInfo(const char* argName, char* argVal) {
printf("\t\t[info] %s: \"%s\"\r\n", argName, argVal);
}
static int mem;
TEST(strs, append)
{
Args *buffs = New_strBuff();
char *res = strsAppend(buffs, (char *)"a", (char *)"b");
EXPECT_STREQ((char *)"ab", res);
args_deinit(buffs);
EXPECT_EQ(pikaMemNow(), 0);
TEST(strs, append) {
Args* buffs = New_strBuff();
char* res = strsAppend(buffs, (char*)"a", (char*)"b");
EXPECT_STREQ((char*)"ab", res);
args_deinit(buffs);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(strs, formatInt)
{
Args *buffs = New_strBuff();
char *res = strsFormat(buffs, 32, "test: %d", 3);
args_deinit(buffs);
EXPECT_EQ(pikaMemNow(), 0);
TEST(strs, formatInt) {
Args* buffs = New_strBuff();
char* res = strsFormat(buffs, 32, "test: %d", 3);
args_deinit(buffs);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(strs, analizeDef)
{
mem = pikaMemNow();
Args *buffs = New_args(NULL);
char currentClassName[] = "Compiler";
char line[] = " def analizeFile(pythonApiPath: str):";
printInfo("currentClassName", currentClassName);
char *defSentenceWithBlock = strsRemovePrefix(buffs, line, (char *)" def ");
char *defSentence = strsDeleteChar(buffs, defSentenceWithBlock, ' ');
printInfo("defSentence", defSentence);
char *methodName = strsGetFirstToken(buffs, defSentence, '(');
printInfo("methodName", methodName);
char *methodObjPath = strsAppend(buffs, strsAppend(buffs, currentClassName, (char *)"."), methodName);
printInfo("methodObjPath", methodObjPath);
char *returnType = strsCut(buffs, defSentence, '>', ':');
printInfo("returnType", returnType);
TEST(strs, analizeDef) {
mem = pikaMemNow();
Args* buffs = New_args(NULL);
char currentClassName[] = "Compiler";
char line[] = " def analizeFile(pythonApiPath: str):";
printInfo("currentClassName", currentClassName);
char* defSentenceWithBlock = strsRemovePrefix(buffs, line, (char*)" def ");
char* defSentence = strsDeleteChar(buffs, defSentenceWithBlock, ' ');
printInfo("defSentence", defSentence);
char* methodName = strsGetFirstToken(buffs, defSentence, '(');
printInfo("methodName", methodName);
char* methodObjPath = strsAppend(
buffs, strsAppend(buffs, currentClassName, (char*)"."), methodName);
printInfo("methodObjPath", methodObjPath);
char* returnType = strsCut(buffs, defSentence, '>', ':');
printInfo("returnType", returnType);
char *typeList = strsCut(buffs, defSentence, '(', ')');
printInfo("typeList", typeList);
if (0 != strGetSize(typeList))
{
int argNum = strCountSign(typeList, ',') + 1;
char *typeListBuff = strsCopy(buffs, typeList);
for (int i = 0; i < argNum; i++)
{
char *typeDeclearation = strsPopToken(buffs, typeListBuff, ',');
printInfo("typeDeclearation", typeDeclearation);
char *argName = strsGetFirstToken(buffs, typeDeclearation, ':');
printInfo("argName", argName);
char *argType = strsGetLastToken(buffs, typeDeclearation, ':');
printInfo("argType", argType);
}
char* typeList = strsCut(buffs, defSentence, '(', ')');
printInfo("typeList", typeList);
if (0 != strGetSize(typeList)) {
int argNum = strCountSign(typeList, ',') + 1;
char* typeListBuff = strsCopy(buffs, typeList);
for (int i = 0; i < argNum; i++) {
char* typeDeclearation = strsPopToken(buffs, typeListBuff, ',');
printInfo("typeDeclearation", typeDeclearation);
char* argName = strsGetFirstToken(buffs, typeDeclearation, ':');
printInfo("argName", argName);
char* argType = strsGetLastToken(buffs, typeDeclearation, ':');
printInfo("argType", argType);
}
args_deinit(buffs);
return;
}
args_deinit(buffs);
return;
}
TEST(strs, format)
{
Args *buffs = New_args(NULL);
char *fmt = strsFormat(buffs, 128, "test int: %d, float %f", 1, 34.2);
EXPECT_TRUE(strEqu((char *)"test int: 1, float 34.200000", fmt));
args_deinit(buffs);
TEST(strs, format) {
Args* buffs = New_args(NULL);
char* fmt = strsFormat(buffs, 128, "test int: %d, float %f", 1, 34.2);
EXPECT_TRUE(strEqu((char*)"test int: 1, float 34.200000", fmt));
args_deinit(buffs);
}
TEST(strs, mem)
{
EXPECT_EQ(pikaMemNow(), mem);
TEST(strs, mem) {
EXPECT_EQ(pikaMemNow(), mem);
}

78
src/test/sysObj-test.cpp
View File

@ -1,51 +1,47 @@
#include "gtest/gtest.h"
extern "C"
{
extern "C" {
#include "BaseObj.h"
#include "PikaStdLib_SysObj.h"
#include "TinyObj.h"
#include "BaseObj.h"
}
TEST(sysObj, print)
{
PikaObj *obj = newRootObj((char *)"test", New_PikaStdLib_SysObj);
Args *res = obj_runDirect(obj, (char *)"print('hello world')");
char *sysOut = args_getSysOut(res);
int errCode = args_getErrorCode(res);
printf("sysout = %s\r\n", sysOut);
ASSERT_STREQ((char *)"hello world", sysOut);
ASSERT_EQ(0, errCode);
args_deinit(res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(sysObj, print) {
PikaObj* obj = newRootObj((char*)"test", New_PikaStdLib_SysObj);
Args* res = obj_runDirect(obj, (char*)"print('hello world')");
char* sysOut = args_getSysOut(res);
int errCode = args_getErrorCode(res);
printf("sysout = %s\r\n", sysOut);
ASSERT_STREQ((char*)"hello world", sysOut);
ASSERT_EQ(0, errCode);
args_deinit(res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(sysObj, set)
{
PikaObj *obj = newRootObj((char *)"test", New_PikaStdLib_SysObj);
Args *res = obj_runDirect(obj, (char *)"set('a', 1)");
int a = obj_getInt(obj, (char *)"a");
char *sysOut = args_getSysOut(res);
int errCode = args_getErrorCode(res);
printf("sysout = %s\r\n", sysOut);
ASSERT_EQ(1, strEqu((char *)"", sysOut));
ASSERT_EQ(0, errCode);
ASSERT_EQ(1, a);
args_deinit(res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(sysObj, set) {
PikaObj* obj = newRootObj((char*)"test", New_PikaStdLib_SysObj);
Args* res = obj_runDirect(obj, (char*)"set('a', 1)");
int a = obj_getInt(obj, (char*)"a");
char* sysOut = args_getSysOut(res);
int errCode = args_getErrorCode(res);
printf("sysout = %s\r\n", sysOut);
ASSERT_EQ(1, strEqu((char*)"", sysOut));
ASSERT_EQ(0, errCode);
ASSERT_EQ(1, a);
args_deinit(res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}
TEST(sysObj, noMethod)
{
PikaObj *obj = newRootObj((char *)"test", New_PikaStdLib_SysObj);
Args *res = obj_runDirect(obj, (char *)"printttt('hello world')");
char *sysOut = args_getSysOut(res);
int errCode = args_getErrorCode(res);
printf("sysout = %s\r\n", sysOut);
ASSERT_EQ(1, strEqu((char *)"[error] runner: method no found.", sysOut));
ASSERT_EQ(2, errCode);
args_deinit(res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
TEST(sysObj, noMethod) {
PikaObj* obj = newRootObj((char*)"test", New_PikaStdLib_SysObj);
Args* res = obj_runDirect(obj, (char*)"printttt('hello world')");
char* sysOut = args_getSysOut(res);
int errCode = args_getErrorCode(res);
printf("sysout = %s\r\n", sysOut);
ASSERT_EQ(1, strEqu((char*)"[error] runner: method no found.", sysOut));
ASSERT_EQ(2, errCode);
args_deinit(res);
obj_deinit(obj);
EXPECT_EQ(pikaMemNow(), 0);
}