mirror of
https://gitee.com/Lyon1998/pikapython.git
synced 2025-01-15 17:02:53 +08:00
1064 lines
27 KiB
C
1064 lines
27 KiB
C
#include "MimiObj.h"
|
|
#include "dataArgs.h"
|
|
#include "dataMemory.h"
|
|
#include "dataString.h"
|
|
#include "dataStrs.h"
|
|
#include "sysObj.h"
|
|
|
|
int deinitEachSubObj(Arg *argEach, Args *handleArgs)
|
|
{
|
|
if (NULL != handleArgs)
|
|
{
|
|
/* error: tOhis handle not need handle args */
|
|
return 1;
|
|
}
|
|
char *type = arg_getType(argEach);
|
|
if (strIsStartWith(type, "_class"))
|
|
{
|
|
MimiObj *subObj = arg_getPtr(argEach);
|
|
if (NULL != subObj)
|
|
{
|
|
obj_deinit(subObj);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void deinitAllSubObj(MimiObj *self)
|
|
{
|
|
Args *args = self->attributeList;
|
|
args_foreach(args, deinitEachSubObj, NULL);
|
|
}
|
|
|
|
int obj_deinit(MimiObj *self)
|
|
{
|
|
self->_beforDinit(self);
|
|
deinitAllSubObj(self);
|
|
args_deinit(self->attributeList);
|
|
DynMemPut(self->mem);
|
|
self = NULL;
|
|
return 0;
|
|
}
|
|
|
|
int obj_update(MimiObj *self)
|
|
{
|
|
// return if is not enable
|
|
if (0 == obj_getInt(self, "isEnable"))
|
|
{
|
|
return 1;
|
|
}
|
|
self->_updateHandle(self);
|
|
return 0;
|
|
}
|
|
void _UpdateHandle(MimiObj *self)
|
|
{
|
|
// override the handle function here
|
|
}
|
|
|
|
int obj_enable(MimiObj *self)
|
|
{
|
|
obj_setInt(self, "isEnable", 1);
|
|
return 0;
|
|
}
|
|
|
|
int obj_disable(MimiObj *self)
|
|
{
|
|
obj_setInt(self, "isEnable", 0);
|
|
return 0;
|
|
}
|
|
|
|
int obj_setInt(MimiObj *self, char *argPath, long long val)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
/* [error] object no found */
|
|
return 1;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *name = strsGetLastToken(buffs, argPath, '.');
|
|
args_setInt(obj->attributeList, name, val);
|
|
args_deinit(buffs);
|
|
return 0;
|
|
}
|
|
|
|
int obj_setPtr(MimiObj *self, char *argPath, void *pointer)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return 1;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *name = strsGetLastToken(buffs, argPath, '.');
|
|
args_setPtr(obj->attributeList,
|
|
name, pointer);
|
|
args_deinit(buffs);
|
|
return 0;
|
|
}
|
|
|
|
int obj_setFloat(MimiObj *self, char *argPath, float value)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return 1;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *name = strsGetLastToken(buffs, argPath, '.');
|
|
args_setFloat(obj->attributeList,
|
|
name, value);
|
|
args_deinit(buffs);
|
|
return 0;
|
|
}
|
|
|
|
int obj_setStr(MimiObj *self, char *argPath, char *str)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return 1;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *name = strsGetLastToken(buffs, argPath, '.');
|
|
args_setStr(obj->attributeList,
|
|
name, str);
|
|
args_deinit(buffs);
|
|
return 0;
|
|
}
|
|
|
|
long long obj_getInt(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return -999999999;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
args_deinit(buffs);
|
|
return args_getInt(obj->attributeList,
|
|
argName);
|
|
}
|
|
|
|
Arg *obj_getArg(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return NULL;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
Arg *res = args_getArg(obj->attributeList, argName);
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
int obj_setArg(MimiObj *self, char *argPath, Arg *arg)
|
|
{
|
|
/* setArg would copy arg */
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
/* object no found */
|
|
return 1;
|
|
}
|
|
args_copyArg(obj->attributeList, arg);
|
|
return 0;
|
|
}
|
|
|
|
void *obj_getPtr(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return NULL;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
void *res = args_getPtr(obj->attributeList, argName);
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
float obj_getFloat(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return -999.999;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
float res = args_getFloat(obj->attributeList,
|
|
argName);
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
char *obj_getStr(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
return NULL;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
char *res = args_getStr(obj->attributeList,
|
|
argName);
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
int obj_load(MimiObj *self, Args *args, char *name)
|
|
{
|
|
args_copyArgByName(args, name, self->attributeList);
|
|
return 0;
|
|
}
|
|
|
|
void _beforDinit(MimiObj *self)
|
|
{
|
|
/* override in user code */
|
|
}
|
|
|
|
int obj_setObjWithoutClass(MimiObj *self, char *objName, void *newFun)
|
|
{
|
|
/* class means subprocess init */
|
|
Args *buffs = New_strBuff();
|
|
char *mataObjName = strsAppend(buffs, "[mate]", objName);
|
|
obj_setPtr(self, mataObjName, newFun);
|
|
/* add void object Ptr, no inited */
|
|
args_setObjectWithClass(self->attributeList, objName, "none", NULL);
|
|
args_deinit(buffs);
|
|
return 0;
|
|
}
|
|
|
|
int obj_addOther(MimiObj *self, char *subObjectName, void *new_ObjectFun)
|
|
{
|
|
Args *initArgs = New_args(NULL);
|
|
args_setPtr(initArgs, "context", self);
|
|
void *(*new_Object)(Args * initArgs) = (void *(*)(Args *))new_ObjectFun;
|
|
void *subObject = new_Object(initArgs);
|
|
obj_setPtr(self, subObjectName, subObject);
|
|
args_deinit(initArgs);
|
|
return 0;
|
|
}
|
|
|
|
int obj_freeObj(MimiObj *self, char *objPath)
|
|
{
|
|
MimiObj *obj = obj_getPtr(self, objPath);
|
|
obj_deinit(obj);
|
|
return 0;
|
|
}
|
|
|
|
int obj_bind(MimiObj *self, char *type, char *name, void *pointer)
|
|
{
|
|
args_bind(self->attributeList, type, name, pointer);
|
|
return 0;
|
|
}
|
|
|
|
char *obj_print(MimiObj *self, char *name)
|
|
{
|
|
if (NULL == self)
|
|
{
|
|
return NULL;
|
|
}
|
|
return args_print(self->attributeList, name);
|
|
}
|
|
|
|
int obj_bindInt(MimiObj *self, char *name, int *valPtr)
|
|
{
|
|
args_bindInt(self->attributeList, name, valPtr);
|
|
return 0;
|
|
}
|
|
|
|
int obj_bindFloat(MimiObj *self, char *name, float *valPtr)
|
|
{
|
|
args_bindFloat(self->attributeList, name, valPtr);
|
|
return 0;
|
|
}
|
|
|
|
int obj_bindString(MimiObj *self, char *name, char **valPtr)
|
|
{
|
|
args_bindStr(self->attributeList, name, valPtr);
|
|
return 0;
|
|
}
|
|
|
|
int obj_set(MimiObj *self, char *argPath, char *valStr)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
if (NULL == obj)
|
|
{
|
|
/* cant get object */
|
|
return 3;
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
int res = args_set(obj->attributeList, argName, valStr);
|
|
args_deinit(buffs);
|
|
if (res == 1)
|
|
{
|
|
/* do not get arg */
|
|
return 1;
|
|
}
|
|
if (res == 2)
|
|
{
|
|
/* type not match */
|
|
return 2;
|
|
}
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
|
|
int removeEachMethodInfo(Arg *argNow, Args *argList)
|
|
{
|
|
if (strIsStartWith(arg_getName(argNow), "[md]"))
|
|
{
|
|
args_removeArg(argList, arg_getName(argNow));
|
|
return 0;
|
|
}
|
|
if (strIsStartWith(arg_getName(argNow), "[mp]"))
|
|
{
|
|
args_removeArg(argList, arg_getName(argNow));
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
MimiObj *removeMethodInfo(MimiObj *thisClass)
|
|
{
|
|
args_foreach(thisClass->attributeList, removeEachMethodInfo, thisClass->attributeList);
|
|
return thisClass;
|
|
}
|
|
|
|
MimiObj *obj_getClassObjByNewFun(MimiObj *context, char *name, void *(*newClassFun)(Args *initArgs))
|
|
{
|
|
Args *initArgs = New_args(NULL);
|
|
args_setPtr(initArgs, "context", context);
|
|
args_setStr(initArgs, "name", name);
|
|
MimiObj *thisClass = newClassFun(initArgs);
|
|
obj_setPtr(thisClass, "classPtr", newClassFun);
|
|
args_deinit(initArgs);
|
|
return thisClass;
|
|
}
|
|
|
|
char *obj_getClassPath(MimiObj *objHost, Args *buffs, char *objName)
|
|
{
|
|
Arg *objArg = obj_getArg(objHost, objName);
|
|
char *objType = arg_getType(objArg);
|
|
char *classPath = strsRemovePrefix(buffs, objType, "_class-");
|
|
return classPath;
|
|
}
|
|
|
|
void *getNewObjFunByClass(MimiObj *obj, char *classPath)
|
|
{
|
|
MimiObj *classHost = args_getPtr(obj->attributeList, "classLoader");
|
|
if (NULL == classHost)
|
|
{
|
|
return NULL;
|
|
}
|
|
void *(*newObjFun)(Args * initArgs) = args_getPtr(classHost->attributeList, classPath);
|
|
return newObjFun;
|
|
}
|
|
|
|
void *getNewClassObjFunByName(MimiObj *obj, char *name)
|
|
{
|
|
Args *buffs = New_strBuff();
|
|
char *classPath = strsAppend(buffs, "[mate]", name);
|
|
/* init the subprocess */
|
|
void *(*newClassObjFun)(Args * initArgs) = args_getPtr(obj->attributeList, classPath);
|
|
args_deinit(buffs);
|
|
return newClassObjFun;
|
|
}
|
|
|
|
MimiObj *newRootObj(char *name, void *newObjFun)
|
|
{
|
|
MimiObj *thisClass = obj_getClassObjByNewFun(NULL, name, newObjFun);
|
|
MimiObj *newObj = removeMethodInfo(thisClass);
|
|
return newObj;
|
|
}
|
|
|
|
static void removeClassLoader(MimiObj *obj)
|
|
{
|
|
MimiObj *classObj = args_getPtr(obj->attributeList, "classLoader");
|
|
if (NULL != classObj)
|
|
{
|
|
obj_deinit(classObj);
|
|
args_removeArg(obj->attributeList, "classLoader");
|
|
}
|
|
}
|
|
|
|
MimiObj *initObj(MimiObj *obj, char *name)
|
|
{
|
|
MimiObj *res = NULL;
|
|
void *(*newObjFun)(Args * initArgs) = getNewClassObjFunByName(obj, name);
|
|
Args *buffs = New_args(NULL);
|
|
if (NULL == newObjFun)
|
|
{
|
|
/* no such object */
|
|
res = NULL;
|
|
goto exit;
|
|
}
|
|
MimiObj *thisClass = obj_getClassObjByNewFun(obj, name, newObjFun);
|
|
MimiObj *newObj = removeMethodInfo(thisClass);
|
|
/* delete [mate]<objName> */
|
|
obj_removeArg(obj, strsAppend(buffs, "[mate]", name));
|
|
/* delete "classLoader" object */
|
|
removeClassLoader(newObj);
|
|
|
|
char *type = args_getType(obj->attributeList, name);
|
|
args_setPtrWithType(obj->attributeList, name, type, newObj);
|
|
res = obj_getPtr(obj, name);
|
|
goto exit;
|
|
exit:
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
MimiObj *obj_getObjDirect(MimiObj *self, char *name)
|
|
{
|
|
if (NULL == self)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/* check subprocess */
|
|
if (NULL == args_getPtr(self->attributeList, name))
|
|
{
|
|
/* no inited subprocess, check subprocess init fun*/
|
|
return initObj(self, name);
|
|
}
|
|
|
|
/* finded subscribe, check type*/
|
|
char *type = args_getType(self->attributeList,
|
|
name);
|
|
if (!strIsStartWith(type, "_class"))
|
|
{
|
|
/* type error, could not found subprocess */
|
|
return NULL;
|
|
}
|
|
return obj_getPtr(self, name);
|
|
}
|
|
|
|
MimiObj *obj_getObj(MimiObj *self, char *objPath, int keepDeepth)
|
|
{
|
|
Args *buffs = New_strBuff();
|
|
char *objPathBuff = strsCopy(buffs, objPath);
|
|
int tokenNum = strGetTokenNum(objPath, '.');
|
|
MimiObj *obj = self;
|
|
for (int i = 0; i < tokenNum - keepDeepth; i++)
|
|
{
|
|
char *token = strsPopToken(buffs, objPathBuff, '.');
|
|
obj = obj_getObjDirect(obj, token);
|
|
if (obj == NULL)
|
|
{
|
|
goto exit;
|
|
}
|
|
}
|
|
goto exit;
|
|
exit:
|
|
args_deinit(buffs);
|
|
return obj;
|
|
}
|
|
|
|
void loadMethodInfo(MimiObj *methodHost, char *methodName, char *methodDeclearation, void *methodPtr)
|
|
{
|
|
Args *buffs = New_strBuff();
|
|
char *methodPtrPath = strsAppend(buffs, "[mp]", methodName);
|
|
char *methodDeclearationPath = strsAppend(buffs, "[md]", methodName);
|
|
obj_setPtr(methodHost, methodPtrPath, methodPtr);
|
|
obj_setStr(methodHost, methodDeclearationPath, methodDeclearation);
|
|
args_deinit(buffs);
|
|
}
|
|
|
|
static char *getMethodDeclearation(MimiObj *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(MimiObj *methodHost, char *methodName)
|
|
{
|
|
Args *buffs = New_strBuff();
|
|
char *methodPtrPath = strsAppend(buffs, "[mp]", methodName);
|
|
void *res = obj_getPtr(methodHost, methodPtrPath);
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
int class_defineMethod(MimiObj *self,
|
|
char *declearation,
|
|
void (*methodPtr)(MimiObj *self, Args *args))
|
|
{
|
|
int size = strGetSize(declearation);
|
|
int res = 0;
|
|
Args *buffs = New_strBuff();
|
|
char *cleanDeclearation = strDeleteChar(args_getBuff(buffs, size), declearation, ' ');
|
|
char *methodPath = strGetFirstToken(args_getBuff(buffs, size), cleanDeclearation, '(');
|
|
|
|
MimiObj *methodHost = obj_getObj(self, methodPath, 1);
|
|
if (NULL == methodHost)
|
|
{
|
|
/* no found method object */
|
|
res = 1;
|
|
goto exit;
|
|
}
|
|
char *methodName = strsGetLastToken(buffs, methodPath, '.');
|
|
|
|
loadMethodInfo(methodHost, methodName, cleanDeclearation, methodPtr);
|
|
res = 0;
|
|
goto exit;
|
|
exit:
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
char *getDirectStr(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;
|
|
}
|
|
|
|
static int loadArgByType(MimiObj *self,
|
|
char *definedName,
|
|
char *definedType,
|
|
char *argPath,
|
|
Args *args)
|
|
{
|
|
if (strEqu(definedType, "any"))
|
|
{
|
|
char *directStr = getDirectStr(args, argPath);
|
|
if (NULL != directStr)
|
|
{
|
|
/* direct string value */
|
|
args_setStr(args, definedName, directStr);
|
|
/* ok */
|
|
return 0;
|
|
}
|
|
if ((argPath[0] >= '0') && (argPath[0] <= '9'))
|
|
{
|
|
/* direct number value */
|
|
char *argName = argPath;
|
|
if (strIsContain(argName, '.'))
|
|
{
|
|
args_setFloat(args, definedName, 0);
|
|
args_set(args, definedName, argPath);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
args_setInt(args, definedName, 0);
|
|
args_set(args, definedName, argPath);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
/* get reference arg */
|
|
Arg *arg = obj_getArg(self, argPath);
|
|
if (arg == NULL)
|
|
{
|
|
/* can not get arg */
|
|
return 3;
|
|
}
|
|
Arg *argCopied = arg_copy(arg);
|
|
arg_setName(argCopied, definedName);
|
|
args_setArg(args, argCopied);
|
|
return 0;
|
|
}
|
|
if (strEqu(definedType, "string"))
|
|
{
|
|
/* solve the string type */
|
|
char *directStr = getDirectStr(args, argPath);
|
|
if (NULL != directStr)
|
|
{
|
|
/* direct value */
|
|
args_setStr(args, definedName, directStr);
|
|
/* ok */
|
|
return 0;
|
|
}
|
|
/* reference value */
|
|
char *refStr = obj_getStr(self, argPath);
|
|
if (NULL == refStr)
|
|
{
|
|
/* faild */
|
|
return 1;
|
|
}
|
|
args_setStr(args, definedName, refStr);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
if (strEqu(definedType, "int"))
|
|
{
|
|
/* solve the int type */
|
|
args_setInt(args, definedName, 0);
|
|
if ((argPath[0] >= '0') && (argPath[0] <= '9'))
|
|
{
|
|
/* direct value */
|
|
args_set(args, definedName, argPath);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
/* reference value */
|
|
if (!obj_isArgExist(self, argPath))
|
|
{
|
|
/* can not get reference */
|
|
return 3;
|
|
}
|
|
int referenceVal = obj_getInt(self, argPath);
|
|
args_setInt(args, definedName, referenceVal);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
if (strEqu(definedType, "float"))
|
|
{
|
|
/* solve the float type */
|
|
args_setFloat(args, definedName, 0);
|
|
if ((argPath[0] >= '0') && (argPath[0] <= '9'))
|
|
{
|
|
/* direct value */
|
|
args_set(args, definedName, argPath);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
/* reference value */
|
|
if (!obj_isArgExist(self, argPath))
|
|
{
|
|
/* can not get reference */
|
|
return 3;
|
|
}
|
|
float referenceVal = obj_getFloat(self, argPath);
|
|
args_setFloat(args, definedName, referenceVal);
|
|
/* succeed */
|
|
return 0;
|
|
}
|
|
if (strEqu(definedType, "pointer"))
|
|
{
|
|
/* only support reference value */
|
|
if (!obj_isArgExist(self, argPath))
|
|
{
|
|
/* can not get reference */
|
|
return 3;
|
|
}
|
|
void *ptr = obj_getPtr(self, argPath);
|
|
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, ':');
|
|
}
|
|
|
|
static Args *getArgsBySort(MimiObj *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 *getArgsByNameMatch(MimiObj *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 *getArgsBySentence(MimiObj *self, char *typeList, char *argList)
|
|
{
|
|
if (strIsContain(argList, '='))
|
|
{
|
|
return getArgsByNameMatch(self, typeList, argList);
|
|
}
|
|
return getArgsBySort(self, typeList, argList);
|
|
}
|
|
|
|
static void transferReturnVal(MimiObj *self, char *returnType, char *returnName, Args *args)
|
|
{
|
|
if (strEqu("->int", returnType))
|
|
{
|
|
obj_setInt(self, returnName, args_getInt(args, "return"));
|
|
}
|
|
if (strEqu("->float", returnType))
|
|
{
|
|
obj_setFloat(self, returnName, args_getFloat(args, "return"));
|
|
}
|
|
if (strEqu("->string", returnType))
|
|
{
|
|
obj_setStr(self, returnName, args_getStr(args, "return"));
|
|
}
|
|
}
|
|
|
|
char *getMethodPath(Args *buffs, char *methodToken)
|
|
{
|
|
if (strIsContain(methodToken, '='))
|
|
{
|
|
return strsGetLastToken(buffs, methodToken, '=');
|
|
}
|
|
else
|
|
{
|
|
return methodToken;
|
|
}
|
|
}
|
|
|
|
static char *getCleanCmd(Args *buffs, char *cmd)
|
|
{
|
|
int size = strGetSize(cmd);
|
|
char *strOut = args_getBuff(buffs, size);
|
|
int iOut = 0;
|
|
char delChar = ' ';
|
|
int isInStr = 0;
|
|
for (int i = 0; i < strGetSize(cmd); i++)
|
|
{
|
|
if ('\'' == 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;
|
|
}
|
|
|
|
Args *obj_runDirect(MimiObj *self, char *cmd)
|
|
{
|
|
/* the Args returned need to be deinit */
|
|
Args *res = New_args(NULL);
|
|
args_setInt(res, "errCode", 0);
|
|
Args *buffs = New_strBuff();
|
|
char *cleanCmd = getCleanCmd(buffs, cmd);
|
|
char *methodToken = strsGetFirstToken(buffs, cleanCmd, '(');
|
|
char *methodPath = getMethodPath(buffs, methodToken);
|
|
|
|
MimiObj *methodHostObj = obj_getObj(self, methodPath, 1);
|
|
MimiObj *methodHostClass = NULL;
|
|
if (NULL == methodHostObj)
|
|
{
|
|
/* error, not found object */
|
|
args_setInt(res, "errCode", 1);
|
|
method_sysOut(res, "[error] runner: object no found.");
|
|
goto exit;
|
|
}
|
|
char *methodName = strsGetLastToken(buffs, methodPath, '.');
|
|
|
|
void *classPtr = obj_getPtr(methodHostObj, "classPtr");
|
|
char *methodHostClassName = strsAppend(buffs, "classObj-", methodHostObj->name);
|
|
methodHostClass = obj_getClassObjByNewFun(methodHostObj, methodHostClassName, classPtr);
|
|
/* get method Ptr */
|
|
void (*methodPtr)(MimiObj * self, Args * args) = getMethodPtr(methodHostClass, methodName);
|
|
char *methodDecInClass = getMethodDeclearation(methodHostClass, methodName);
|
|
/* assert method*/
|
|
if ((NULL == methodDecInClass) || (NULL == methodPtr))
|
|
{
|
|
/* error, method no found */
|
|
args_setInt(res, "errCode", 2);
|
|
method_sysOut(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_setInt(res, "errCode", 3);
|
|
method_sysOut(res, "[error] runner: type list no found.");
|
|
goto exit;
|
|
}
|
|
|
|
/* get arg list */
|
|
char *argList = strsCut(buffs, cleanCmd, '(', ')');
|
|
{
|
|
if (argList == NULL)
|
|
{
|
|
/* argL List no found */
|
|
args_setInt(res, "errCode", 4);
|
|
method_sysOut(res, "[error] runner: arg list no found.");
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
/* get return type */
|
|
char *returnType = strsGetLastToken(buffs, methodDec, ')');
|
|
/* get args */
|
|
Args *args = getArgsBySentence(self, typeList, argList);
|
|
if (NULL == args)
|
|
{
|
|
/* get args faild */
|
|
args_setInt(res, "errCode", 5);
|
|
method_sysOut(res, "[error] runner: solve arg faild.");
|
|
goto exit;
|
|
}
|
|
/* transfer return */
|
|
Args *returnBuffs = NULL;
|
|
char *returnName = NULL;
|
|
if (strIsContain(methodToken, '='))
|
|
{
|
|
returnBuffs = New_args(NULL);
|
|
returnName = strsGetFirstToken(returnBuffs, methodToken, '=');
|
|
}
|
|
/* run method */
|
|
args_deinit(buffs);
|
|
buffs = NULL;
|
|
methodPtr(methodHostObj, args);
|
|
/* transfer return */
|
|
if (NULL != returnBuffs)
|
|
{
|
|
transferReturnVal(self, returnType, returnName, args);
|
|
args_deinit(returnBuffs);
|
|
}
|
|
/* transfer sysOut */
|
|
char *sysOut = args_getStr(args, "sysOut");
|
|
if (NULL != sysOut)
|
|
{
|
|
args_setStr(res, "sysOut", args_getStr(args, "sysOut"));
|
|
}
|
|
args_deinit(args);
|
|
/* solve errCode */
|
|
if (!args_isArgExist(args, "errCode"))
|
|
{
|
|
goto exit;
|
|
}
|
|
int errCode = args_getInt(args, "errCode");
|
|
if (0 != errCode)
|
|
{
|
|
/* method error */
|
|
args_setInt(res, "errCode", 6);
|
|
}
|
|
goto exit;
|
|
exit:
|
|
if (NULL != buffs)
|
|
{
|
|
args_deinit(buffs);
|
|
}
|
|
if (NULL != methodHostClass)
|
|
{
|
|
obj_deinit(methodHostClass);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
int obj_removeArg(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *objHost = obj_getObj(self, argPath, 1);
|
|
MimiObj *obj = obj_getObj(self, argPath, 0);
|
|
if (NULL != obj)
|
|
{
|
|
obj_deinit(obj);
|
|
}
|
|
Args *buffs = New_strBuff();
|
|
int err = 0;
|
|
if (NULL == objHost)
|
|
{
|
|
/* [error] object no found */
|
|
err = 1;
|
|
goto exit;
|
|
}
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
int res = args_removeArg(objHost->attributeList, argName);
|
|
if (1 == res)
|
|
{
|
|
/*[error] not found arg*/
|
|
err = 2;
|
|
goto exit;
|
|
}
|
|
goto exit;
|
|
exit:
|
|
args_deinit(buffs);
|
|
return err;
|
|
}
|
|
|
|
int obj_isArgExist(MimiObj *self, char *argPath)
|
|
{
|
|
MimiObj *obj = obj_getObj(self, argPath, 1);
|
|
Args *buffs = New_strBuff();
|
|
int res = 0;
|
|
if (NULL == obj)
|
|
{
|
|
/* [error] object no found */
|
|
res = 1;
|
|
goto exit;
|
|
}
|
|
char *argName = strsGetLastToken(buffs, argPath, '.');
|
|
Arg *arg = args_getArg(obj->attributeList, argName);
|
|
if (NULL == arg)
|
|
{
|
|
/* no found arg */
|
|
res = 0;
|
|
goto exit;
|
|
}
|
|
/* found arg */
|
|
res = 1;
|
|
goto exit;
|
|
|
|
exit:
|
|
args_deinit(buffs);
|
|
return res;
|
|
}
|
|
|
|
void obj_runNoRes(MimiObj *slef, char *cmd)
|
|
{
|
|
/* unsafe, nothing would happend when error occord */
|
|
args_deinit(obj_runDirect(slef, cmd));
|
|
}
|
|
|
|
void obj_run(MimiObj *self, char *cmd)
|
|
{
|
|
/* safe, stop when error occord and error info would be print */
|
|
Args *res = obj_runDirect(self, cmd);
|
|
char *sysOut = args_getStr(res, "sysOut");
|
|
if (NULL != sysOut)
|
|
{
|
|
// printf("%s\r\n", sysOut);
|
|
}
|
|
if (0 != args_getInt(res, "errCode"))
|
|
{
|
|
// printf("[info] input commond: %s\r\n", cmd);
|
|
while (1)
|
|
;
|
|
}
|
|
if (NULL != res)
|
|
{
|
|
args_deinit(res);
|
|
}
|
|
}
|
|
|
|
MimiObj *New_TinyObj(Args *args)
|
|
{
|
|
/* request memory */
|
|
DMEM *mem = DynMemGet(sizeof(MimiObj));
|
|
if (NULL == mem)
|
|
{
|
|
// printf("[error] memory is empty!");
|
|
while (1)
|
|
;
|
|
}
|
|
MimiObj *self = (void *)(mem->addr);
|
|
self->mem = mem;
|
|
|
|
/* List */
|
|
self->attributeList = New_args(NULL);
|
|
|
|
/* override */
|
|
self->_updateHandle = _UpdateHandle;
|
|
self->_beforDinit = _beforDinit;
|
|
|
|
/* attribute */
|
|
obj_setPtr(self, "context", self);
|
|
obj_setStr(self, "name", "root");
|
|
|
|
/* load */
|
|
if (NULL != args)
|
|
{
|
|
obj_load(self, args, "name");
|
|
obj_load(self, args, "context");
|
|
}
|
|
|
|
/* hard attribute */
|
|
self->name = obj_getStr(self, "name");
|
|
return self;
|
|
}
|