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

update cmsis-pack

Browse Source
This commit is contained in:
Lyon 2022-09-16 21:01:18 +08:00
parent 5706d29ac1
commit 43978e8e72
38 changed files with 2556 additions and 990 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
port/cmsis-pack/PikaTech.PikaScript.pdsc
View File

@ -243,6 +243,7 @@
<file attr="config" category="header" name="pikascript-api/PikaStdData.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_ByteArray.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_Dict.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_dict_items.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_dict_keys.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_FILEIO.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_List.h" />

4
port/cmsis-pack/pikascript/PikaObj.pyi
View File

@ -14,6 +14,10 @@ class any:
...
class int64:
...
def printNoEnd(val: any): ...
def abstractmethod(fn): ...
def PIKA_C_MACRO_IF(fn): ...

14
port/cmsis-pack/pikascript/PikaStdData.pyi
View File

@ -20,6 +20,9 @@ class Tuple:
def __str__(self) -> str: ...
def __len__(self) -> int: ...
def __contains__(self, val: any) -> int:
""" support val in list """
class List(Tuple):
def __init__(self): ...
@ -59,8 +62,12 @@ class Dict:
def __del__(self): ...
def __str__(self) -> str: ...
def keys(self) -> dict_keys: ...
def items(self) -> dict_items: ...
def __len__(self) -> int: ...
def __contains__(self, val: any) -> int:
""" support val in list """
class dict_keys:
def __iter__(self) -> any: ...
@ -68,6 +75,11 @@ class dict_keys:
def __str__(self) -> str: ...
def __len__(self) -> int: ...
class dict_items:
def __iter__(self) -> any: ...
def __next__(self) -> any: ...
def __str__(self) -> str: ...
def __len__(self) -> int: ...
class String:
def __init__(self, s: str): ...
@ -82,7 +94,7 @@ class String:
# support str()
def __str__(self) -> str: ...
def __len__(self) -> int: ...
def encode(self) -> bytes: ...
def encode(self, *encoding) -> bytes: ...
def startswith(self, prefix: str) -> int: ...
def endswith(self, suffix: str) -> int: ...
def isdigit(self) -> int: ...

21
port/cmsis-pack/pikascript/PikaStdLib.pyi
View File

@ -1,5 +1,6 @@
from PikaObj import *
class MemChecker:
def max(self): ...
def now(self): ...
@ -15,9 +16,6 @@ class MemChecker:
class SysObj:
@staticmethod
def type(arg: any) -> any: ...
@staticmethod
def int(arg: any) -> int: ...
@ -31,14 +29,10 @@ class SysObj:
def iter(arg: any) -> any: ...
@staticmethod
def range(a1: int, a2: int) -> any: ...
def range(*ax) -> any: ...
@staticmethod
def print(*val): ...
@staticmethod
@PIKA_C_MACRO_IF("!PIKA_NANO_ENABLE")
def printNoEnd(val: any): ...
def print(*val, **ops): ...
@staticmethod
def __setitem__(obj: any, key: any, val: any) -> any: ...
@ -46,6 +40,10 @@ class SysObj:
@staticmethod
def __getitem__(obj: any, key: any) -> any: ...
@staticmethod
@PIKA_C_MACRO_IF("!PIKA_NANO_ENABLE")
def type(arg: any) -> any: ...
@staticmethod
@PIKA_C_MACRO_IF("PIKA_BUILTIN_STRUCT_ENABLE")
def __slice__(obj: any, start: any, end: any, step: int) -> any: ...
@ -105,6 +103,10 @@ class SysObj:
@PIKA_C_MACRO_IF("!PIKA_NANO_ENABLE")
def setattr(obj: object, name: str, val: any): ...
@staticmethod
@PIKA_C_MACRO_IF("!PIKA_NANO_ENABLE")
def exit(): ...
@PIKA_C_MACRO_IF("0")
class RangeObj:
@ -114,4 +116,3 @@ class RangeObj:
@PIKA_C_MACRO_IF("0")
class StringObj:
def __next__(self) -> any: ...

1
port/cmsis-pack/pikascript/PikaTech.PikaScript.pdsc
View File

@ -243,6 +243,7 @@
<file attr="config" category="header" name="pikascript-api/PikaStdData.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_ByteArray.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_Dict.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_dict_items.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_dict_keys.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_FILEIO.h" />
<file attr="config" category="header" name="pikascript-api/PikaStdData_List.h" />

1
port/cmsis-pack/pikascript/clean.bat
View File

@ -8,6 +8,7 @@
@del "pikascript-api\PikaStdData.h"
@del "pikascript-api\PikaStdData_ByteArray.h"
@del "pikascript-api\PikaStdData_Dict.h"
@del "pikascript-api\PikaStdData_dict_items.h"
@del "pikascript-api\PikaStdData_dict_keys.h"
@del "pikascript-api\PikaStdData_FILEIO.h"
@del "pikascript-api\PikaStdData_List.h"

1
port/cmsis-pack/pikascript/pikascript-api/PikaStdData.h
View File

@ -24,6 +24,7 @@ Arg* PikaStdData_List(PikaObj *self);
Arg* PikaStdData_String(PikaObj *self);
Arg* PikaStdData_Tuple(PikaObj *self);
Arg* PikaStdData_Utils(PikaObj *self);
Arg* PikaStdData_dict_items(PikaObj *self);
Arg* PikaStdData_dict_keys(PikaObj *self);
#endif

2
port/cmsis-pack/pikascript/pikascript-api/PikaStdData_Dict.h
View File

@ -17,6 +17,7 @@
PikaObj *New_PikaStdData_Dict(Args *args);
int PikaStdData_Dict___contains__(PikaObj *self, Arg* val);
void PikaStdData_Dict___del__(PikaObj *self);
Arg* PikaStdData_Dict___getitem__(PikaObj *self, Arg* __key);
void PikaStdData_Dict___init__(PikaObj *self);
@ -26,6 +27,7 @@ Arg* PikaStdData_Dict___next__(PikaObj *self);
void PikaStdData_Dict___setitem__(PikaObj *self, Arg* __key, Arg* __val);
char* PikaStdData_Dict___str__(PikaObj *self);
Arg* PikaStdData_Dict_get(PikaObj *self, char* key);
PikaObj* PikaStdData_Dict_items(PikaObj *self);
PikaObj* PikaStdData_Dict_keys(PikaObj *self);
void PikaStdData_Dict_remove(PikaObj *self, char* key);
void PikaStdData_Dict_set(PikaObj *self, char* key, Arg* arg);

2
port/cmsis-pack/pikascript/pikascript-api/PikaStdData_String.h
View File

@ -24,7 +24,7 @@ int PikaStdData_String___len__(PikaObj *self);
Arg* PikaStdData_String___next__(PikaObj *self);
void PikaStdData_String___setitem__(PikaObj *self, Arg* __key, Arg* __val);
char* PikaStdData_String___str__(PikaObj *self);
Arg* PikaStdData_String_encode(PikaObj *self);
Arg* PikaStdData_String_encode(PikaObj *self, PikaTuple* encoding);
int PikaStdData_String_endswith(PikaObj *self, char* suffix);
char* PikaStdData_String_get(PikaObj *self);
int PikaStdData_String_isalnum(PikaObj *self);

1
port/cmsis-pack/pikascript/pikascript-api/PikaStdData_Tuple.h
View File

@ -17,6 +17,7 @@
PikaObj *New_PikaStdData_Tuple(Args *args);
int PikaStdData_Tuple___contains__(PikaObj *self, Arg* val);
void PikaStdData_Tuple___del__(PikaObj *self);
Arg* PikaStdData_Tuple___getitem__(PikaObj *self, Arg* __key);
void PikaStdData_Tuple___init__(PikaObj *self);

25
port/cmsis-pack/pikascript/pikascript-api/PikaStdData_dict_items.h Normal file
View File

@ -0,0 +1,25 @@
/*
* [Warning!] This file is auto-generated by pika compiler.
* Do not edit it manually.
* The source code is *.pyi file.
* More details:
* English Doc:
* https://pikadoc.readthedocs.io/en/latest/PikaScript%20%E6%A8%A1%E5%9D%97%E6%A6%82%E8%BF%B0.html
* Chinese Doc:
* https://pikadoc.readthedocs.io/zh/latest/PikaScript%20%E6%A8%A1%E5%9D%97%E6%A6%82%E8%BF%B0.html
*/
#ifndef __PikaStdData_dict_items__H
#define __PikaStdData_dict_items__H
#include <stdio.h>
#include <stdlib.h>
#include "PikaObj.h"
PikaObj *New_PikaStdData_dict_items(Args *args);
Arg* PikaStdData_dict_items___iter__(PikaObj *self);
int PikaStdData_dict_items___len__(PikaObj *self);
Arg* PikaStdData_dict_items___next__(PikaObj *self);
char* PikaStdData_dict_items___str__(PikaObj *self);
#endif

6
port/cmsis-pack/pikascript/pikascript-api/PikaStdLib_SysObj.h
View File

@ -26,6 +26,7 @@ char* PikaStdLib_SysObj_chr(PikaObj *self, int val);
Arg* PikaStdLib_SysObj_dict(PikaObj *self);
PikaObj* PikaStdLib_SysObj_dir(PikaObj *self, PikaObj* obj);
void PikaStdLib_SysObj_exec(PikaObj *self, char* code);
void PikaStdLib_SysObj_exit(PikaObj *self);
double PikaStdLib_SysObj_float(PikaObj *self, Arg* arg);
Arg* PikaStdLib_SysObj_getattr(PikaObj *self, PikaObj* obj, char* name);
char* PikaStdLib_SysObj_hex(PikaObj *self, int val);
@ -36,9 +37,8 @@ int PikaStdLib_SysObj_len(PikaObj *self, Arg* arg);
Arg* PikaStdLib_SysObj_list(PikaObj *self);
PikaObj* PikaStdLib_SysObj_open(PikaObj *self, char* path, char* mode);
int PikaStdLib_SysObj_ord(PikaObj *self, char* val);
void PikaStdLib_SysObj_print(PikaObj *self, PikaTuple* val);
void PikaStdLib_SysObj_printNoEnd(PikaObj *self, Arg* val);
Arg* PikaStdLib_SysObj_range(PikaObj *self, int a1, int a2);
void PikaStdLib_SysObj_print(PikaObj *self, PikaTuple* val, PikaDict* ops);
Arg* PikaStdLib_SysObj_range(PikaObj *self, PikaTuple* ax);
void PikaStdLib_SysObj_setattr(PikaObj *self, PikaObj* obj, char* name, Arg* val);
char* PikaStdLib_SysObj_str(PikaObj *self, Arg* arg);
Arg* PikaStdLib_SysObj_type(PikaObj *self, Arg* arg);

549
port/cmsis-pack/pikascript/pikascript-api/__pikaBinding.c
View File

@ -35,6 +35,8 @@
#include "TinyObj.h"
#include "PikaStdData_Utils.h"
#include "TinyObj.h"
#include "PikaStdData_dict_items.h"
#include "TinyObj.h"
#include "PikaStdData_dict_keys.h"
#include "TinyObj.h"
#include "PikaStdLib.h"
@ -111,7 +113,7 @@ void PikaDebug_DebugerMethod(PikaObj *self, Args *args){
PikaObj *New_PikaDebug(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineConstructor(self, "Debuger()->any", PikaDebug_DebugerMethod);
class_defineConstructor(self, "Debuger()", PikaDebug_DebugerMethod);
return self;
}
#endif
@ -185,6 +187,11 @@ void PikaStdData_UtilsMethod(PikaObj *self, Args *args){
method_returnArg(args, res);
}
void PikaStdData_dict_itemsMethod(PikaObj *self, Args *args){
Arg* res = PikaStdData_dict_items(self);
method_returnArg(args, res);
}
void PikaStdData_dict_keysMethod(PikaObj *self, Args *args){
Arg* res = PikaStdData_dict_keys(self);
method_returnArg(args, res);
@ -192,14 +199,15 @@ void PikaStdData_dict_keysMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineConstructor(self, "ByteArray()->any", PikaStdData_ByteArrayMethod);
class_defineConstructor(self, "Dict()->any", PikaStdData_DictMethod);
class_defineConstructor(self, "FILEIO()->any", PikaStdData_FILEIOMethod);
class_defineConstructor(self, "List()->any", PikaStdData_ListMethod);
class_defineConstructor(self, "String()->any", PikaStdData_StringMethod);
class_defineConstructor(self, "Tuple()->any", PikaStdData_TupleMethod);
class_defineConstructor(self, "Utils()->any", PikaStdData_UtilsMethod);
class_defineConstructor(self, "dict_keys()->any", PikaStdData_dict_keysMethod);
class_defineConstructor(self, "ByteArray()", PikaStdData_ByteArrayMethod);
class_defineConstructor(self, "Dict()", PikaStdData_DictMethod);
class_defineConstructor(self, "FILEIO()", PikaStdData_FILEIOMethod);
class_defineConstructor(self, "List()", PikaStdData_ListMethod);
class_defineConstructor(self, "String()", PikaStdData_StringMethod);
class_defineConstructor(self, "Tuple()", PikaStdData_TupleMethod);
class_defineConstructor(self, "Utils()", PikaStdData_UtilsMethod);
class_defineConstructor(self, "dict_items()", PikaStdData_dict_itemsMethod);
class_defineConstructor(self, "dict_keys()", PikaStdData_dict_keysMethod);
return self;
}
#endif
@ -244,13 +252,13 @@ void PikaStdData_ByteArray_decodeMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_ByteArray(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__getitem__(__key:int)->int", PikaStdData_ByteArray___getitem__Method);
class_defineMethod(self, "__init__(bytes:any)", PikaStdData_ByteArray___init__Method);
class_defineMethod(self, "__iter__()->any", PikaStdData_ByteArray___iter__Method);
class_defineMethod(self, "__next__()->any", PikaStdData_ByteArray___next__Method);
class_defineMethod(self, "__setitem__(__key:int,__val:int)", PikaStdData_ByteArray___setitem__Method);
class_defineMethod(self, "__str__()->str", PikaStdData_ByteArray___str__Method);
class_defineMethod(self, "decode()->str", PikaStdData_ByteArray_decodeMethod);
class_defineMethod(self, "__getitem__(__key)", PikaStdData_ByteArray___getitem__Method);
class_defineMethod(self, "__init__(bytes)", PikaStdData_ByteArray___init__Method);
class_defineMethod(self, "__iter__()", PikaStdData_ByteArray___iter__Method);
class_defineMethod(self, "__next__()", PikaStdData_ByteArray___next__Method);
class_defineMethod(self, "__setitem__(__key,__val)", PikaStdData_ByteArray___setitem__Method);
class_defineMethod(self, "__str__()", PikaStdData_ByteArray___str__Method);
class_defineMethod(self, "decode()", PikaStdData_ByteArray_decodeMethod);
return self;
}
@ -260,6 +268,12 @@ Arg *PikaStdData_ByteArray(PikaObj *self){
#endif
#ifndef PIKA_MODULE_PIKASTDDATA_DISABLE
void PikaStdData_Dict___contains__Method(PikaObj *self, Args *args){
Arg* val = args_getArg(args, "val");
int res = PikaStdData_Dict___contains__(self, val);
method_returnInt(args, res);
}
void PikaStdData_Dict___del__Method(PikaObj *self, Args *args){
PikaStdData_Dict___del__(self);
}
@ -306,6 +320,11 @@ void PikaStdData_Dict_getMethod(PikaObj *self, Args *args){
method_returnArg(args, res);
}
void PikaStdData_Dict_itemsMethod(PikaObj *self, Args *args){
PikaObj* res = PikaStdData_Dict_items(self);
method_returnObj(args, res);
}
void PikaStdData_Dict_keysMethod(PikaObj *self, Args *args){
PikaObj* res = PikaStdData_Dict_keys(self);
method_returnObj(args, res);
@ -324,18 +343,20 @@ void PikaStdData_Dict_setMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_Dict(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__contains__(val)", PikaStdData_Dict___contains__Method);
class_defineMethod(self, "__del__()", PikaStdData_Dict___del__Method);
class_defineMethod(self, "__getitem__(__key:any)->any", PikaStdData_Dict___getitem__Method);
class_defineMethod(self, "__getitem__(__key)", PikaStdData_Dict___getitem__Method);
class_defineMethod(self, "__init__()", PikaStdData_Dict___init__Method);
class_defineMethod(self, "__iter__()->any", PikaStdData_Dict___iter__Method);
class_defineMethod(self, "__len__()->int", PikaStdData_Dict___len__Method);
class_defineMethod(self, "__next__()->any", PikaStdData_Dict___next__Method);
class_defineMethod(self, "__setitem__(__key:any,__val:any)", PikaStdData_Dict___setitem__Method);
class_defineMethod(self, "__str__()->str", PikaStdData_Dict___str__Method);
class_defineMethod(self, "get(key:str)->any", PikaStdData_Dict_getMethod);
class_defineMethod(self, "keys()->dict_keys", PikaStdData_Dict_keysMethod);
class_defineMethod(self, "remove(key:str)", PikaStdData_Dict_removeMethod);
class_defineMethod(self, "set(key:str,arg:any)", PikaStdData_Dict_setMethod);
class_defineMethod(self, "__iter__()", PikaStdData_Dict___iter__Method);
class_defineMethod(self, "__len__()", PikaStdData_Dict___len__Method);
class_defineMethod(self, "__next__()", PikaStdData_Dict___next__Method);
class_defineMethod(self, "__setitem__(__key,__val)", PikaStdData_Dict___setitem__Method);
class_defineMethod(self, "__str__()", PikaStdData_Dict___str__Method);
class_defineMethod(self, "get(key)", PikaStdData_Dict_getMethod);
class_defineMethod(self, "items()", PikaStdData_Dict_itemsMethod);
class_defineMethod(self, "keys()", PikaStdData_Dict_keysMethod);
class_defineMethod(self, "remove(key)", PikaStdData_Dict_removeMethod);
class_defineMethod(self, "set(key,arg)", PikaStdData_Dict_setMethod);
return self;
}
@ -398,14 +419,14 @@ void PikaStdData_FILEIO_writelinesMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_FILEIO(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "close()", PikaStdData_FILEIO_closeMethod);
class_defineMethod(self, "init(path:str,mode:str)->int", PikaStdData_FILEIO_initMethod);
class_defineMethod(self, "read(size:int)->any", PikaStdData_FILEIO_readMethod);
class_defineMethod(self, "readline()->str", PikaStdData_FILEIO_readlineMethod);
class_defineMethod(self, "readlines()->List", PikaStdData_FILEIO_readlinesMethod);
class_defineMethod(self, "seek(offset:int,*fromwhere)->int", PikaStdData_FILEIO_seekMethod);
class_defineMethod(self, "tell()->int", PikaStdData_FILEIO_tellMethod);
class_defineMethod(self, "write(s:any)->int", PikaStdData_FILEIO_writeMethod);
class_defineMethod(self, "writelines(lines:List)", PikaStdData_FILEIO_writelinesMethod);
class_defineMethod(self, "init(path,mode)", PikaStdData_FILEIO_initMethod);
class_defineMethod(self, "read(size)", PikaStdData_FILEIO_readMethod);
class_defineMethod(self, "readline()", PikaStdData_FILEIO_readlineMethod);
class_defineMethod(self, "readlines()", PikaStdData_FILEIO_readlinesMethod);
class_defineMethod(self, "seek(offset,*fromwhere)", PikaStdData_FILEIO_seekMethod);
class_defineMethod(self, "tell()", PikaStdData_FILEIO_tellMethod);
class_defineMethod(self, "write(s)", PikaStdData_FILEIO_writeMethod);
class_defineMethod(self, "writelines(lines)", PikaStdData_FILEIO_writelinesMethod);
return self;
}
@ -453,13 +474,13 @@ void PikaStdData_List_setMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_List(Args *args){
PikaObj *self = New_PikaStdData_Tuple(args);
class_defineMethod(self, "__add__(others:List)->List", PikaStdData_List___add__Method);
class_defineMethod(self, "__add__(others)", PikaStdData_List___add__Method);
class_defineMethod(self, "__init__()", PikaStdData_List___init__Method);
class_defineMethod(self, "__setitem__(__key:any,__val:any)", PikaStdData_List___setitem__Method);
class_defineMethod(self, "__str__()->str", PikaStdData_List___str__Method);
class_defineMethod(self, "append(arg:any)", PikaStdData_List_appendMethod);
class_defineMethod(self, "__setitem__(__key,__val)", PikaStdData_List___setitem__Method);
class_defineMethod(self, "__str__()", PikaStdData_List___str__Method);
class_defineMethod(self, "append(arg)", PikaStdData_List_appendMethod);
class_defineMethod(self, "reverse()", PikaStdData_List_reverseMethod);
class_defineMethod(self, "set(i:int,arg:any)", PikaStdData_List_setMethod);
class_defineMethod(self, "set(i,arg)", PikaStdData_List_setMethod);
return self;
}
@ -507,7 +528,8 @@ void PikaStdData_String___str__Method(PikaObj *self, Args *args){
}
void PikaStdData_String_encodeMethod(PikaObj *self, Args *args){
Arg* res = PikaStdData_String_encode(self);
PikaTuple* encoding = args_getTuple(args, "encoding");
Arg* res = PikaStdData_String_encode(self, encoding);
method_returnArg(args, res);
}
@ -578,26 +600,26 @@ void PikaStdData_String_stripMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_String(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__getitem__(__key:any)->any", PikaStdData_String___getitem__Method);
class_defineMethod(self, "__init__(s:str)", PikaStdData_String___init__Method);
class_defineMethod(self, "__iter__()->any", PikaStdData_String___iter__Method);
class_defineMethod(self, "__len__()->int", PikaStdData_String___len__Method);
class_defineMethod(self, "__next__()->any", PikaStdData_String___next__Method);
class_defineMethod(self, "__setitem__(__key:any,__val:any)", PikaStdData_String___setitem__Method);
class_defineMethod(self, "__str__()->str", PikaStdData_String___str__Method);
class_defineMethod(self, "encode()->bytes", PikaStdData_String_encodeMethod);
class_defineMethod(self, "endswith(suffix:str)->int", PikaStdData_String_endswithMethod);
class_defineMethod(self, "get()->str", PikaStdData_String_getMethod);
class_defineMethod(self, "isalnum()->int", PikaStdData_String_isalnumMethod);
class_defineMethod(self, "isalpha()->int", PikaStdData_String_isalphaMethod);
class_defineMethod(self, "isdigit()->int", PikaStdData_String_isdigitMethod);
class_defineMethod(self, "islower()->int", PikaStdData_String_islowerMethod);
class_defineMethod(self, "isspace()->int", PikaStdData_String_isspaceMethod);
class_defineMethod(self, "replace(old:str,new:str)->str", PikaStdData_String_replaceMethod);
class_defineMethod(self, "set(s:str)", PikaStdData_String_setMethod);
class_defineMethod(self, "split(s:str)->List", PikaStdData_String_splitMethod);
class_defineMethod(self, "startswith(prefix:str)->int", PikaStdData_String_startswithMethod);
class_defineMethod(self, "strip()->str", PikaStdData_String_stripMethod);
class_defineMethod(self, "__getitem__(__key)", PikaStdData_String___getitem__Method);
class_defineMethod(self, "__init__(s)", PikaStdData_String___init__Method);
class_defineMethod(self, "__iter__()", PikaStdData_String___iter__Method);
class_defineMethod(self, "__len__()", PikaStdData_String___len__Method);
class_defineMethod(self, "__next__()", PikaStdData_String___next__Method);
class_defineMethod(self, "__setitem__(__key,__val)", PikaStdData_String___setitem__Method);
class_defineMethod(self, "__str__()", PikaStdData_String___str__Method);
class_defineMethod(self, "encode(*encoding)", PikaStdData_String_encodeMethod);
class_defineMethod(self, "endswith(suffix)", PikaStdData_String_endswithMethod);
class_defineMethod(self, "get()", PikaStdData_String_getMethod);
class_defineMethod(self, "isalnum()", PikaStdData_String_isalnumMethod);
class_defineMethod(self, "isalpha()", PikaStdData_String_isalphaMethod);
class_defineMethod(self, "isdigit()", PikaStdData_String_isdigitMethod);
class_defineMethod(self, "islower()", PikaStdData_String_islowerMethod);
class_defineMethod(self, "isspace()", PikaStdData_String_isspaceMethod);
class_defineMethod(self, "replace(old,new)", PikaStdData_String_replaceMethod);
class_defineMethod(self, "set(s)", PikaStdData_String_setMethod);
class_defineMethod(self, "split(s)", PikaStdData_String_splitMethod);
class_defineMethod(self, "startswith(prefix)", PikaStdData_String_startswithMethod);
class_defineMethod(self, "strip()", PikaStdData_String_stripMethod);
return self;
}
@ -607,6 +629,12 @@ Arg *PikaStdData_String(PikaObj *self){
#endif
#ifndef PIKA_MODULE_PIKASTDDATA_DISABLE
void PikaStdData_Tuple___contains__Method(PikaObj *self, Args *args){
Arg* val = args_getArg(args, "val");
int res = PikaStdData_Tuple___contains__(self, val);
method_returnInt(args, res);
}
void PikaStdData_Tuple___del__Method(PikaObj *self, Args *args){
PikaStdData_Tuple___del__(self);
}
@ -654,15 +682,16 @@ void PikaStdData_Tuple_lenMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_Tuple(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__contains__(val)", PikaStdData_Tuple___contains__Method);
class_defineMethod(self, "__del__()", PikaStdData_Tuple___del__Method);
class_defineMethod(self, "__getitem__(__key:any)->any", PikaStdData_Tuple___getitem__Method);
class_defineMethod(self, "__getitem__(__key)", PikaStdData_Tuple___getitem__Method);
class_defineMethod(self, "__init__()", PikaStdData_Tuple___init__Method);
class_defineMethod(self, "__iter__()->any", PikaStdData_Tuple___iter__Method);
class_defineMethod(self, "__len__()->int", PikaStdData_Tuple___len__Method);
class_defineMethod(self, "__next__()->any", PikaStdData_Tuple___next__Method);
class_defineMethod(self, "__str__()->str", PikaStdData_Tuple___str__Method);
class_defineMethod(self, "get(i:int)->any", PikaStdData_Tuple_getMethod);
class_defineMethod(self, "len()->int", PikaStdData_Tuple_lenMethod);
class_defineMethod(self, "__iter__()", PikaStdData_Tuple___iter__Method);
class_defineMethod(self, "__len__()", PikaStdData_Tuple___len__Method);
class_defineMethod(self, "__next__()", PikaStdData_Tuple___next__Method);
class_defineMethod(self, "__str__()", PikaStdData_Tuple___str__Method);
class_defineMethod(self, "get(i)", PikaStdData_Tuple_getMethod);
class_defineMethod(self, "len()", PikaStdData_Tuple_lenMethod);
return self;
}
@ -680,7 +709,7 @@ void PikaStdData_Utils_int_to_bytesMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_Utils(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "int_to_bytes(val:int)->bytes", PikaStdData_Utils_int_to_bytesMethod);
class_defineMethod(self, "int_to_bytes(val)", PikaStdData_Utils_int_to_bytesMethod);
return self;
}
@ -689,6 +718,41 @@ Arg *PikaStdData_Utils(PikaObj *self){
}
#endif
#ifndef PIKA_MODULE_PIKASTDDATA_DISABLE
void PikaStdData_dict_items___iter__Method(PikaObj *self, Args *args){
Arg* res = PikaStdData_dict_items___iter__(self);
method_returnArg(args, res);
}
void PikaStdData_dict_items___len__Method(PikaObj *self, Args *args){
int res = PikaStdData_dict_items___len__(self);
method_returnInt(args, res);
}
void PikaStdData_dict_items___next__Method(PikaObj *self, Args *args){
Arg* res = PikaStdData_dict_items___next__(self);
method_returnArg(args, res);
}
void PikaStdData_dict_items___str__Method(PikaObj *self, Args *args){
char* res = PikaStdData_dict_items___str__(self);
method_returnStr(args, res);
}
PikaObj *New_PikaStdData_dict_items(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__iter__()", PikaStdData_dict_items___iter__Method);
class_defineMethod(self, "__len__()", PikaStdData_dict_items___len__Method);
class_defineMethod(self, "__next__()", PikaStdData_dict_items___next__Method);
class_defineMethod(self, "__str__()", PikaStdData_dict_items___str__Method);
return self;
}
Arg *PikaStdData_dict_items(PikaObj *self){
return obj_newObjInPackage(New_PikaStdData_dict_items);
}
#endif
#ifndef PIKA_MODULE_PIKASTDDATA_DISABLE
void PikaStdData_dict_keys___iter__Method(PikaObj *self, Args *args){
Arg* res = PikaStdData_dict_keys___iter__(self);
@ -712,10 +776,10 @@ void PikaStdData_dict_keys___str__Method(PikaObj *self, Args *args){
PikaObj *New_PikaStdData_dict_keys(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__iter__()->any", PikaStdData_dict_keys___iter__Method);
class_defineMethod(self, "__len__()->int", PikaStdData_dict_keys___len__Method);
class_defineMethod(self, "__next__()->any", PikaStdData_dict_keys___next__Method);
class_defineMethod(self, "__str__()->str", PikaStdData_dict_keys___str__Method);
class_defineMethod(self, "__iter__()", PikaStdData_dict_keys___iter__Method);
class_defineMethod(self, "__len__()", PikaStdData_dict_keys___len__Method);
class_defineMethod(self, "__next__()", PikaStdData_dict_keys___next__Method);
class_defineMethod(self, "__str__()", PikaStdData_dict_keys___str__Method);
return self;
}
@ -747,14 +811,14 @@ void PikaStdLib_SysObjMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdLib(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineConstructor(self, "MemChecker()->any", PikaStdLib_MemCheckerMethod);
class_defineConstructor(self, "MemChecker()", PikaStdLib_MemCheckerMethod);
#if 0
class_defineConstructor(self, "RangeObj()->any", PikaStdLib_RangeObjMethod);
class_defineConstructor(self, "RangeObj()", PikaStdLib_RangeObjMethod);
#endif
#if 0
class_defineConstructor(self, "StringObj()->any", PikaStdLib_StringObjMethod);
class_defineConstructor(self, "StringObj()", PikaStdLib_StringObjMethod);
#endif
class_defineConstructor(self, "SysObj()->any", PikaStdLib_SysObjMethod);
class_defineConstructor(self, "SysObj()", PikaStdLib_SysObjMethod);
return self;
}
#endif
@ -785,10 +849,10 @@ void PikaStdLib_MemChecker_resetMaxMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdLib_MemChecker(Args *args){
PikaObj *self = New_TinyObj(args);
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "getMax()->float", PikaStdLib_MemChecker_getMaxMethod);
class_defineMethod(self, "getMax()", PikaStdLib_MemChecker_getMaxMethod);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "getNow()->float", PikaStdLib_MemChecker_getNowMethod);
class_defineMethod(self, "getNow()", PikaStdLib_MemChecker_getNowMethod);
#endif
class_defineMethod(self, "max()", PikaStdLib_MemChecker_maxMethod);
class_defineMethod(self, "now()", PikaStdLib_MemChecker_nowMethod);
@ -811,7 +875,7 @@ void PikaStdLib_RangeObj___next__Method(PikaObj *self, Args *args){
PikaObj *New_PikaStdLib_RangeObj(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__next__()->any", PikaStdLib_RangeObj___next__Method);
class_defineMethod(self, "__next__()", PikaStdLib_RangeObj___next__Method);
return self;
}
@ -828,7 +892,7 @@ void PikaStdLib_StringObj___next__Method(PikaObj *self, Args *args){
PikaObj *New_PikaStdLib_StringObj(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__next__()->any", PikaStdLib_StringObj___next__Method);
class_defineMethod(self, "__next__()", PikaStdLib_StringObj___next__Method);
return self;
}
@ -897,6 +961,10 @@ void PikaStdLib_SysObj_execMethod(PikaObj *self, Args *args){
PikaStdLib_SysObj_exec(self, code);
}
void PikaStdLib_SysObj_exitMethod(PikaObj *self, Args *args){
PikaStdLib_SysObj_exit(self);
}
void PikaStdLib_SysObj_floatMethod(PikaObj *self, Args *args){
Arg* arg = args_getArg(args, "arg");
double res = PikaStdLib_SysObj_float(self, arg);
@ -960,18 +1028,13 @@ void PikaStdLib_SysObj_ordMethod(PikaObj *self, Args *args){
void PikaStdLib_SysObj_printMethod(PikaObj *self, Args *args){
PikaTuple* val = args_getTuple(args, "val");
PikaStdLib_SysObj_print(self, val);
}
void PikaStdLib_SysObj_printNoEndMethod(PikaObj *self, Args *args){
Arg* val = args_getArg(args, "val");
PikaStdLib_SysObj_printNoEnd(self, val);
PikaDict* ops = args_getDict(args, "ops");
PikaStdLib_SysObj_print(self, val, ops);
}
void PikaStdLib_SysObj_rangeMethod(PikaObj *self, Args *args){
int a1 = args_getInt(args, "a1");
int a2 = args_getInt(args, "a2");
Arg* res = PikaStdLib_SysObj_range(self, a1, a2);
PikaTuple* ax = args_getTuple(args, "ax");
Arg* res = PikaStdLib_SysObj_range(self, ax);
method_returnArg(args, res);
}
@ -996,61 +1059,63 @@ void PikaStdLib_SysObj_typeMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdLib_SysObj(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__getitem__(obj:any,key:any)->any", PikaStdLib_SysObj___getitem__Method);
class_defineMethod(self, "__setitem__(obj:any,key:any,val:any)->any", PikaStdLib_SysObj___setitem__Method);
class_defineMethod(self, "__getitem__(obj,key)", PikaStdLib_SysObj___getitem__Method);
class_defineMethod(self, "__setitem__(obj,key,val)", PikaStdLib_SysObj___setitem__Method);
#if PIKA_BUILTIN_STRUCT_ENABLE
class_defineMethod(self, "__slice__(obj:any,start:any,end:any,step:int)->any", PikaStdLib_SysObj___slice__Method);
class_defineMethod(self, "__slice__(obj,start,end,step)", PikaStdLib_SysObj___slice__Method);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "bytes(val:any)->bytes", PikaStdLib_SysObj_bytesMethod);
class_defineMethod(self, "bytes(val)", PikaStdLib_SysObj_bytesMethod);
#endif
#if PIKA_SYNTAX_FORMAT_ENABLE
class_defineMethod(self, "cformat(fmt:str,*var)->str", PikaStdLib_SysObj_cformatMethod);
class_defineMethod(self, "cformat(fmt,*var)", PikaStdLib_SysObj_cformatMethod);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "chr(val:int)->str", PikaStdLib_SysObj_chrMethod);
class_defineMethod(self, "chr(val)", PikaStdLib_SysObj_chrMethod);
#endif
#if PIKA_BUILTIN_STRUCT_ENABLE
class_defineMethod(self, "dict()->any", PikaStdLib_SysObj_dictMethod);
class_defineMethod(self, "dict()", PikaStdLib_SysObj_dictMethod);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "dir(obj:object)->list", PikaStdLib_SysObj_dirMethod);
class_defineMethod(self, "dir(obj)", PikaStdLib_SysObj_dirMethod);
#endif
#if PIKA_EXEC_ENABLE
class_defineMethod(self, "exec(code:str)", PikaStdLib_SysObj_execMethod);
#endif
class_defineMethod(self, "float(arg:any)->float", PikaStdLib_SysObj_floatMethod);
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "getattr(obj:object,name:str)->any", PikaStdLib_SysObj_getattrMethod);
class_defineMethod(self, "exec(code)", PikaStdLib_SysObj_execMethod);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "hex(val:int)->str", PikaStdLib_SysObj_hexMethod);
class_defineMethod(self, "exit()", PikaStdLib_SysObj_exitMethod);
#endif
class_defineMethod(self, "float(arg)", PikaStdLib_SysObj_floatMethod);
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "getattr(obj,name)", PikaStdLib_SysObj_getattrMethod);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "id(obj:any)->int", PikaStdLib_SysObj_idMethod);
class_defineMethod(self, "hex(val)", PikaStdLib_SysObj_hexMethod);
#endif
class_defineMethod(self, "int(arg:any)->int", PikaStdLib_SysObj_intMethod);
class_defineMethod(self, "iter(arg:any)->any", PikaStdLib_SysObj_iterMethod);
class_defineMethod(self, "len(arg:any)->int", PikaStdLib_SysObj_lenMethod);
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "id(obj)", PikaStdLib_SysObj_idMethod);
#endif
class_defineMethod(self, "int(arg)", PikaStdLib_SysObj_intMethod);
class_defineMethod(self, "iter(arg)", PikaStdLib_SysObj_iterMethod);
class_defineMethod(self, "len(arg)", PikaStdLib_SysObj_lenMethod);
#if PIKA_BUILTIN_STRUCT_ENABLE
class_defineMethod(self, "list()->any", PikaStdLib_SysObj_listMethod);
class_defineMethod(self, "list()", PikaStdLib_SysObj_listMethod);
#endif
#if PIKA_FILEIO_ENABLE
class_defineMethod(self, "open(path:str,mode:str)->object", PikaStdLib_SysObj_openMethod);
class_defineMethod(self, "open(path,mode)", PikaStdLib_SysObj_openMethod);
#endif
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "ord(val:str)->int", PikaStdLib_SysObj_ordMethod);
class_defineMethod(self, "ord(val)", PikaStdLib_SysObj_ordMethod);
#endif
class_defineMethod(self, "print(*val)", PikaStdLib_SysObj_printMethod);
class_defineMethod(self, "print(*val,**ops)", PikaStdLib_SysObj_printMethod);
class_defineMethod(self, "range(*ax)", PikaStdLib_SysObj_rangeMethod);
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "printNoEnd(val:any)", PikaStdLib_SysObj_printNoEndMethod);
class_defineMethod(self, "setattr(obj,name,val)", PikaStdLib_SysObj_setattrMethod);
#endif
class_defineMethod(self, "range(a1:int,a2:int)->any", PikaStdLib_SysObj_rangeMethod);
class_defineMethod(self, "str(arg)", PikaStdLib_SysObj_strMethod);
#if !PIKA_NANO_ENABLE
class_defineMethod(self, "setattr(obj:object,name:str,val:any)", PikaStdLib_SysObj_setattrMethod);
class_defineMethod(self, "type(arg)", PikaStdLib_SysObj_typeMethod);
#endif
class_defineMethod(self, "str(arg:any)->str", PikaStdLib_SysObj_strMethod);
class_defineMethod(self, "type(arg:any)->any", PikaStdLib_SysObj_typeMethod);
return self;
}
@ -1067,7 +1132,7 @@ void PikaStdTask_TaskMethod(PikaObj *self, Args *args){
PikaObj *New_PikaStdTask(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineConstructor(self, "Task()->any", PikaStdTask_TaskMethod);
class_defineConstructor(self, "Task()", PikaStdTask_TaskMethod);
return self;
}
#endif
@ -1115,13 +1180,13 @@ PikaObj *New_PikaStdTask_Task(Args *args){
PikaObj *self = New_PikaStdLib_SysObj(args);
obj_newObj(self, "calls", "PikaStdData_List", New_PikaStdData_List);
class_defineMethod(self, "__init__()", PikaStdTask_Task___init__Method);
class_defineMethod(self, "call_always(fun_todo:any)", PikaStdTask_Task_call_alwaysMethod);
class_defineMethod(self, "call_period_ms(fun_todo:any,period_ms:int)", PikaStdTask_Task_call_period_msMethod);
class_defineMethod(self, "call_when(fun_todo:any,fun_when:any)", PikaStdTask_Task_call_whenMethod);
class_defineMethod(self, "call_always(fun_todo)", PikaStdTask_Task_call_alwaysMethod);
class_defineMethod(self, "call_period_ms(fun_todo,period_ms)", PikaStdTask_Task_call_period_msMethod);
class_defineMethod(self, "call_when(fun_todo,fun_when)", PikaStdTask_Task_call_whenMethod);
class_defineMethod(self, "platformGetTick()", PikaStdTask_Task_platformGetTickMethod);
class_defineMethod(self, "run_forever()", PikaStdTask_Task_run_foreverMethod);
class_defineMethod(self, "run_once()", PikaStdTask_Task_run_onceMethod);
class_defineMethod(self, "run_until_ms(until_ms:int)", PikaStdTask_Task_run_until_msMethod);
class_defineMethod(self, "run_until_ms(until_ms)", PikaStdTask_Task_run_until_msMethod);
return self;
}
@ -1291,37 +1356,37 @@ void pika_lvgl_timer_create_basicMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineConstructor(self, "ALIGN()->any", pika_lvgl_ALIGNMethod);
class_defineConstructor(self, "ANIM()->any", pika_lvgl_ANIMMethod);
class_defineConstructor(self, "EVENT()->any", pika_lvgl_EVENTMethod);
class_defineConstructor(self, "OPA()->any", pika_lvgl_OPAMethod);
class_defineConstructor(self, "PALETTE()->any", pika_lvgl_PALETTEMethod);
class_defineConstructor(self, "STATE()->any", pika_lvgl_STATEMethod);
class_defineConstructor(self, "ALIGN()", pika_lvgl_ALIGNMethod);
class_defineConstructor(self, "ANIM()", pika_lvgl_ANIMMethod);
class_defineConstructor(self, "EVENT()", pika_lvgl_EVENTMethod);
class_defineConstructor(self, "OPA()", pika_lvgl_OPAMethod);
class_defineConstructor(self, "PALETTE()", pika_lvgl_PALETTEMethod);
class_defineConstructor(self, "STATE()", pika_lvgl_STATEMethod);
class_defineMethod(self, "__init__()", pika_lvgl___init__Method);
class_defineConstructor(self, "arc()->any", pika_lvgl_arcMethod);
class_defineConstructor(self, "bar()->any", pika_lvgl_barMethod);
class_defineConstructor(self, "btn()->any", pika_lvgl_btnMethod);
class_defineConstructor(self, "checkbox()->any", pika_lvgl_checkboxMethod);
class_defineConstructor(self, "dropdown()->any", pika_lvgl_dropdownMethod);
class_defineMethod(self, "indev_get_act()->indev_t", pika_lvgl_indev_get_actMethod);
class_defineConstructor(self, "indev_t()->any", pika_lvgl_indev_tMethod);
class_defineConstructor(self, "label()->any", pika_lvgl_labelMethod);
class_defineConstructor(self, "lv_color_t()->any", pika_lvgl_lv_color_tMethod);
class_defineConstructor(self, "lv_event()->any", pika_lvgl_lv_eventMethod);
class_defineConstructor(self, "lv_obj()->any", pika_lvgl_lv_objMethod);
class_defineConstructor(self, "lv_timer_t()->any", pika_lvgl_lv_timer_tMethod);
class_defineMethod(self, "obj(parent:lv_obj)->lv_obj", pika_lvgl_objMethod);
class_defineMethod(self, "palette_lighten(p:int,lvl:int)->lv_color_t", pika_lvgl_palette_lightenMethod);
class_defineMethod(self, "palette_main(p:int)->lv_color_t", pika_lvgl_palette_mainMethod);
class_defineConstructor(self, "point_t()->any", pika_lvgl_point_tMethod);
class_defineConstructor(self, "roller()->any", pika_lvgl_rollerMethod);
class_defineMethod(self, "scr_act()->lv_obj", pika_lvgl_scr_actMethod);
class_defineConstructor(self, "slider()->any", pika_lvgl_sliderMethod);
class_defineConstructor(self, "style_t()->any", pika_lvgl_style_tMethod);
class_defineConstructor(self, "switch()->any", pika_lvgl_switchMethod);
class_defineConstructor(self, "table()->any", pika_lvgl_tableMethod);
class_defineConstructor(self, "textarea()->any", pika_lvgl_textareaMethod);
class_defineMethod(self, "timer_create_basic()->lv_timer_t", pika_lvgl_timer_create_basicMethod);
class_defineConstructor(self, "arc()", pika_lvgl_arcMethod);
class_defineConstructor(self, "bar()", pika_lvgl_barMethod);
class_defineConstructor(self, "btn()", pika_lvgl_btnMethod);
class_defineConstructor(self, "checkbox()", pika_lvgl_checkboxMethod);
class_defineConstructor(self, "dropdown()", pika_lvgl_dropdownMethod);
class_defineMethod(self, "indev_get_act()", pika_lvgl_indev_get_actMethod);
class_defineConstructor(self, "indev_t()", pika_lvgl_indev_tMethod);
class_defineConstructor(self, "label()", pika_lvgl_labelMethod);
class_defineConstructor(self, "lv_color_t()", pika_lvgl_lv_color_tMethod);
class_defineConstructor(self, "lv_event()", pika_lvgl_lv_eventMethod);
class_defineConstructor(self, "lv_obj()", pika_lvgl_lv_objMethod);
class_defineConstructor(self, "lv_timer_t()", pika_lvgl_lv_timer_tMethod);
class_defineMethod(self, "obj(parent)", pika_lvgl_objMethod);
class_defineMethod(self, "palette_lighten(p,lvl)", pika_lvgl_palette_lightenMethod);
class_defineMethod(self, "palette_main(p)", pika_lvgl_palette_mainMethod);
class_defineConstructor(self, "point_t()", pika_lvgl_point_tMethod);
class_defineConstructor(self, "roller()", pika_lvgl_rollerMethod);
class_defineMethod(self, "scr_act()", pika_lvgl_scr_actMethod);
class_defineConstructor(self, "slider()", pika_lvgl_sliderMethod);
class_defineConstructor(self, "style_t()", pika_lvgl_style_tMethod);
class_defineConstructor(self, "switch()", pika_lvgl_switchMethod);
class_defineConstructor(self, "table()", pika_lvgl_tableMethod);
class_defineConstructor(self, "textarea()", pika_lvgl_textareaMethod);
class_defineMethod(self, "timer_create_basic()", pika_lvgl_timer_create_basicMethod);
return self;
}
#endif
@ -1528,26 +1593,26 @@ void pika_lvgl_arc_set_valueMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_arc(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_arc___init__Method);
class_defineMethod(self, "get_angle_end()->int", pika_lvgl_arc_get_angle_endMethod);
class_defineMethod(self, "get_angle_start()->int", pika_lvgl_arc_get_angle_startMethod);
class_defineMethod(self, "get_bg_angle_end()->int", pika_lvgl_arc_get_bg_angle_endMethod);
class_defineMethod(self, "get_bg_angle_start()->int", pika_lvgl_arc_get_bg_angle_startMethod);
class_defineMethod(self, "get_max_value()->int", pika_lvgl_arc_get_max_valueMethod);
class_defineMethod(self, "get_min_value()->int", pika_lvgl_arc_get_min_valueMethod);
class_defineMethod(self, "get_mode()->int", pika_lvgl_arc_get_modeMethod);
class_defineMethod(self, "get_value()->int", pika_lvgl_arc_get_valueMethod);
class_defineMethod(self, "set_angles(start:int,end:int)", pika_lvgl_arc_set_anglesMethod);
class_defineMethod(self, "set_bg_angles(start:int,end:int)", pika_lvgl_arc_set_bg_anglesMethod);
class_defineMethod(self, "set_bg_end_angle(angle:int)", pika_lvgl_arc_set_bg_end_angleMethod);
class_defineMethod(self, "set_bg_start_angle(start:int)", pika_lvgl_arc_set_bg_start_angleMethod);
class_defineMethod(self, "set_change_rate(rate:int)", pika_lvgl_arc_set_change_rateMethod);
class_defineMethod(self, "set_end_angle(angle:int)", pika_lvgl_arc_set_end_angleMethod);
class_defineMethod(self, "set_mode(mode:int)", pika_lvgl_arc_set_modeMethod);
class_defineMethod(self, "set_range(min:int,max:int)", pika_lvgl_arc_set_rangeMethod);
class_defineMethod(self, "set_rotation(rotation:int)", pika_lvgl_arc_set_rotationMethod);
class_defineMethod(self, "set_start_angle(start:int)", pika_lvgl_arc_set_start_angleMethod);
class_defineMethod(self, "set_value(value:int)", pika_lvgl_arc_set_valueMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_arc___init__Method);
class_defineMethod(self, "get_angle_end()", pika_lvgl_arc_get_angle_endMethod);
class_defineMethod(self, "get_angle_start()", pika_lvgl_arc_get_angle_startMethod);
class_defineMethod(self, "get_bg_angle_end()", pika_lvgl_arc_get_bg_angle_endMethod);
class_defineMethod(self, "get_bg_angle_start()", pika_lvgl_arc_get_bg_angle_startMethod);
class_defineMethod(self, "get_max_value()", pika_lvgl_arc_get_max_valueMethod);
class_defineMethod(self, "get_min_value()", pika_lvgl_arc_get_min_valueMethod);
class_defineMethod(self, "get_mode()", pika_lvgl_arc_get_modeMethod);
class_defineMethod(self, "get_value()", pika_lvgl_arc_get_valueMethod);
class_defineMethod(self, "set_angles(start,end)", pika_lvgl_arc_set_anglesMethod);
class_defineMethod(self, "set_bg_angles(start,end)", pika_lvgl_arc_set_bg_anglesMethod);
class_defineMethod(self, "set_bg_end_angle(angle)", pika_lvgl_arc_set_bg_end_angleMethod);
class_defineMethod(self, "set_bg_start_angle(start)", pika_lvgl_arc_set_bg_start_angleMethod);
class_defineMethod(self, "set_change_rate(rate)", pika_lvgl_arc_set_change_rateMethod);
class_defineMethod(self, "set_end_angle(angle)", pika_lvgl_arc_set_end_angleMethod);
class_defineMethod(self, "set_mode(mode)", pika_lvgl_arc_set_modeMethod);
class_defineMethod(self, "set_range(min,max)", pika_lvgl_arc_set_rangeMethod);
class_defineMethod(self, "set_rotation(rotation)", pika_lvgl_arc_set_rotationMethod);
class_defineMethod(self, "set_start_angle(start)", pika_lvgl_arc_set_start_angleMethod);
class_defineMethod(self, "set_value(value)", pika_lvgl_arc_set_valueMethod);
return self;
}
@ -1612,16 +1677,16 @@ void pika_lvgl_bar_set_valueMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_bar(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_bar___init__Method);
class_defineMethod(self, "get_max_value()->int", pika_lvgl_bar_get_max_valueMethod);
class_defineMethod(self, "get_min_value()->int", pika_lvgl_bar_get_min_valueMethod);
class_defineMethod(self, "get_mode()->int", pika_lvgl_bar_get_modeMethod);
class_defineMethod(self, "get_start_value()->int", pika_lvgl_bar_get_start_valueMethod);
class_defineMethod(self, "get_value()->int", pika_lvgl_bar_get_valueMethod);
class_defineMethod(self, "set_mode(mode:int)", pika_lvgl_bar_set_modeMethod);
class_defineMethod(self, "set_range(min:int,max:int)", pika_lvgl_bar_set_rangeMethod);
class_defineMethod(self, "set_start_value(start_value:int,anim:int)", pika_lvgl_bar_set_start_valueMethod);
class_defineMethod(self, "set_value(value:int,anim:int)", pika_lvgl_bar_set_valueMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_bar___init__Method);
class_defineMethod(self, "get_max_value()", pika_lvgl_bar_get_max_valueMethod);
class_defineMethod(self, "get_min_value()", pika_lvgl_bar_get_min_valueMethod);
class_defineMethod(self, "get_mode()", pika_lvgl_bar_get_modeMethod);
class_defineMethod(self, "get_start_value()", pika_lvgl_bar_get_start_valueMethod);
class_defineMethod(self, "get_value()", pika_lvgl_bar_get_valueMethod);
class_defineMethod(self, "set_mode(mode)", pika_lvgl_bar_set_modeMethod);
class_defineMethod(self, "set_range(min,max)", pika_lvgl_bar_set_rangeMethod);
class_defineMethod(self, "set_start_value(start_value,anim)", pika_lvgl_bar_set_start_valueMethod);
class_defineMethod(self, "set_value(value,anim)", pika_lvgl_bar_set_valueMethod);
return self;
}
@ -1638,7 +1703,7 @@ void pika_lvgl_btn___init__Method(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_btn(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_btn___init__Method);
class_defineMethod(self, "__init__(parent)", pika_lvgl_btn___init__Method);
return self;
}
@ -1670,10 +1735,10 @@ void pika_lvgl_checkbox_set_text_staticMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_checkbox(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_checkbox___init__Method);
class_defineMethod(self, "get_text()->str", pika_lvgl_checkbox_get_textMethod);
class_defineMethod(self, "set_text(txt:str)", pika_lvgl_checkbox_set_textMethod);
class_defineMethod(self, "set_text_static(txt:str)", pika_lvgl_checkbox_set_text_staticMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_checkbox___init__Method);
class_defineMethod(self, "get_text()", pika_lvgl_checkbox_get_textMethod);
class_defineMethod(self, "set_text(txt)", pika_lvgl_checkbox_set_textMethod);
class_defineMethod(self, "set_text_static(txt)", pika_lvgl_checkbox_set_text_staticMethod);
return self;
}
@ -1789,27 +1854,27 @@ void pika_lvgl_dropdown_set_textMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_dropdown(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_dropdown___init__Method);
class_defineMethod(self, "add_option(option:str,pos:int)", pika_lvgl_dropdown_add_optionMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_dropdown___init__Method);
class_defineMethod(self, "add_option(option,pos)", pika_lvgl_dropdown_add_optionMethod);
class_defineMethod(self, "clear_options()", pika_lvgl_dropdown_clear_optionsMethod);
class_defineMethod(self, "close()", pika_lvgl_dropdown_closeMethod);
class_defineMethod(self, "get_dir()->int", pika_lvgl_dropdown_get_dirMethod);
class_defineMethod(self, "get_option_cnt()->int", pika_lvgl_dropdown_get_option_cntMethod);
class_defineMethod(self, "get_option_index(option:str)->int", pika_lvgl_dropdown_get_option_indexMethod);
class_defineMethod(self, "get_options()->str", pika_lvgl_dropdown_get_optionsMethod);
class_defineMethod(self, "get_selected()->int", pika_lvgl_dropdown_get_selectedMethod);
class_defineMethod(self, "get_selected_highlight()->int", pika_lvgl_dropdown_get_selected_highlightMethod);
class_defineMethod(self, "get_selected_str()->str", pika_lvgl_dropdown_get_selected_strMethod);
class_defineMethod(self, "get_symbol()->int", pika_lvgl_dropdown_get_symbolMethod);
class_defineMethod(self, "get_text()->str", pika_lvgl_dropdown_get_textMethod);
class_defineMethod(self, "is_open()->int", pika_lvgl_dropdown_is_openMethod);
class_defineMethod(self, "get_dir()", pika_lvgl_dropdown_get_dirMethod);
class_defineMethod(self, "get_option_cnt()", pika_lvgl_dropdown_get_option_cntMethod);
class_defineMethod(self, "get_option_index(option)", pika_lvgl_dropdown_get_option_indexMethod);
class_defineMethod(self, "get_options()", pika_lvgl_dropdown_get_optionsMethod);
class_defineMethod(self, "get_selected()", pika_lvgl_dropdown_get_selectedMethod);
class_defineMethod(self, "get_selected_highlight()", pika_lvgl_dropdown_get_selected_highlightMethod);
class_defineMethod(self, "get_selected_str()", pika_lvgl_dropdown_get_selected_strMethod);
class_defineMethod(self, "get_symbol()", pika_lvgl_dropdown_get_symbolMethod);
class_defineMethod(self, "get_text()", pika_lvgl_dropdown_get_textMethod);
class_defineMethod(self, "is_open()", pika_lvgl_dropdown_is_openMethod);
class_defineMethod(self, "open()", pika_lvgl_dropdown_openMethod);
class_defineMethod(self, "set_dir(dir:int)", pika_lvgl_dropdown_set_dirMethod);
class_defineMethod(self, "set_options(options:str)", pika_lvgl_dropdown_set_optionsMethod);
class_defineMethod(self, "set_selected(sel_opt:int)", pika_lvgl_dropdown_set_selectedMethod);
class_defineMethod(self, "set_selected_hightlight(en:int)", pika_lvgl_dropdown_set_selected_hightlightMethod);
class_defineMethod(self, "set_symbol(symbol:str)", pika_lvgl_dropdown_set_symbolMethod);
class_defineMethod(self, "set_text(txt:str)", pika_lvgl_dropdown_set_textMethod);
class_defineMethod(self, "set_dir(dir)", pika_lvgl_dropdown_set_dirMethod);
class_defineMethod(self, "set_options(options)", pika_lvgl_dropdown_set_optionsMethod);
class_defineMethod(self, "set_selected(sel_opt)", pika_lvgl_dropdown_set_selectedMethod);
class_defineMethod(self, "set_selected_hightlight(en)", pika_lvgl_dropdown_set_selected_hightlightMethod);
class_defineMethod(self, "set_symbol(symbol)", pika_lvgl_dropdown_set_symbolMethod);
class_defineMethod(self, "set_text(txt)", pika_lvgl_dropdown_set_textMethod);
return self;
}
@ -1826,7 +1891,7 @@ void pika_lvgl_indev_t_get_vectMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_indev_t(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "get_vect(point:point_t)", pika_lvgl_indev_t_get_vectMethod);
class_defineMethod(self, "get_vect(point)", pika_lvgl_indev_t_get_vectMethod);
return self;
}
@ -1864,11 +1929,11 @@ void pika_lvgl_label_set_textMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_label(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_label___init__Method);
class_defineMethod(self, "set_long_mode(mode:int)", pika_lvgl_label_set_long_modeMethod);
class_defineMethod(self, "set_recolor(en:int)", pika_lvgl_label_set_recolorMethod);
class_defineMethod(self, "set_style_text_align(value:int,selector:int)", pika_lvgl_label_set_style_text_alignMethod);
class_defineMethod(self, "set_text(txt:str)", pika_lvgl_label_set_textMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_label___init__Method);
class_defineMethod(self, "set_long_mode(mode)", pika_lvgl_label_set_long_modeMethod);
class_defineMethod(self, "set_recolor(en)", pika_lvgl_label_set_recolorMethod);
class_defineMethod(self, "set_style_text_align(value,selector)", pika_lvgl_label_set_style_text_alignMethod);
class_defineMethod(self, "set_text(txt)", pika_lvgl_label_set_textMethod);
return self;
}
@ -1901,8 +1966,8 @@ void pika_lvgl_lv_event_get_targetMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_lv_event(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "get_code()->int", pika_lvgl_lv_event_get_codeMethod);
class_defineMethod(self, "get_target()->lv_obj", pika_lvgl_lv_event_get_targetMethod);
class_defineMethod(self, "get_code()", pika_lvgl_lv_event_get_codeMethod);
class_defineMethod(self, "get_target()", pika_lvgl_lv_event_get_targetMethod);
return self;
}
@ -1979,17 +2044,17 @@ void pika_lvgl_lv_obj_update_layoutMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_lv_obj(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "add_event_cb(event_cb:any,filter:int,user_data:pointer)", pika_lvgl_lv_obj_add_event_cbMethod);
class_defineMethod(self, "add_state(state:int)", pika_lvgl_lv_obj_add_stateMethod);
class_defineMethod(self, "add_style(style:style_t,selector:int)", pika_lvgl_lv_obj_add_styleMethod);
class_defineMethod(self, "align(align:int,x_ofs:int,y_ofs:int)", pika_lvgl_lv_obj_alignMethod);
class_defineMethod(self, "add_event_cb(event_cb,filter,user_data)", pika_lvgl_lv_obj_add_event_cbMethod);
class_defineMethod(self, "add_state(state)", pika_lvgl_lv_obj_add_stateMethod);
class_defineMethod(self, "add_style(style,selector)", pika_lvgl_lv_obj_add_styleMethod);
class_defineMethod(self, "align(align,x_ofs,y_ofs)", pika_lvgl_lv_obj_alignMethod);
class_defineMethod(self, "center()", pika_lvgl_lv_obj_centerMethod);
class_defineMethod(self, "get_x()->int", pika_lvgl_lv_obj_get_xMethod);
class_defineMethod(self, "get_y()->int", pika_lvgl_lv_obj_get_yMethod);
class_defineMethod(self, "set_hight(h:int)", pika_lvgl_lv_obj_set_hightMethod);
class_defineMethod(self, "set_pos(x:int,y:int)", pika_lvgl_lv_obj_set_posMethod);
class_defineMethod(self, "set_size(size_x:int,size_y:int)", pika_lvgl_lv_obj_set_sizeMethod);
class_defineMethod(self, "set_width(w:int)", pika_lvgl_lv_obj_set_widthMethod);
class_defineMethod(self, "get_x()", pika_lvgl_lv_obj_get_xMethod);
class_defineMethod(self, "get_y()", pika_lvgl_lv_obj_get_yMethod);
class_defineMethod(self, "set_hight(h)", pika_lvgl_lv_obj_set_hightMethod);
class_defineMethod(self, "set_pos(x,y)", pika_lvgl_lv_obj_set_posMethod);
class_defineMethod(self, "set_size(size_x,size_y)", pika_lvgl_lv_obj_set_sizeMethod);
class_defineMethod(self, "set_width(w)", pika_lvgl_lv_obj_set_widthMethod);
class_defineMethod(self, "update_layout()", pika_lvgl_lv_obj_update_layoutMethod);
return self;
}
@ -2017,8 +2082,8 @@ void pika_lvgl_lv_timer_t_set_periodMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_lv_timer_t(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "_del()", pika_lvgl_lv_timer_t__delMethod);
class_defineMethod(self, "set_cb(cb:any)", pika_lvgl_lv_timer_t_set_cbMethod);
class_defineMethod(self, "set_period(period:int)", pika_lvgl_lv_timer_t_set_periodMethod);
class_defineMethod(self, "set_cb(cb)", pika_lvgl_lv_timer_t_set_cbMethod);
class_defineMethod(self, "set_period(period)", pika_lvgl_lv_timer_t_set_periodMethod);
return self;
}
@ -2062,9 +2127,9 @@ void pika_lvgl_roller_set_visible_row_countMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_roller(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_roller___init__Method);
class_defineMethod(self, "set_options(options:str,mode:int)", pika_lvgl_roller_set_optionsMethod);
class_defineMethod(self, "set_visible_row_count(row_cnt:int)", pika_lvgl_roller_set_visible_row_countMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_roller___init__Method);
class_defineMethod(self, "set_options(options,mode)", pika_lvgl_roller_set_optionsMethod);
class_defineMethod(self, "set_visible_row_count(row_cnt)", pika_lvgl_roller_set_visible_row_countMethod);
return self;
}
@ -2081,7 +2146,7 @@ void pika_lvgl_slider___init__Method(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_slider(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_slider___init__Method);
class_defineMethod(self, "__init__(parent)", pika_lvgl_slider___init__Method);
return self;
}
@ -2148,15 +2213,15 @@ PikaObj *New_pika_lvgl_style_t(Args *args){
PikaObj *self = New_TinyObj(args);
class_defineMethod(self, "__init__()", pika_lvgl_style_t___init__Method);
class_defineMethod(self, "init()", pika_lvgl_style_t_initMethod);
class_defineMethod(self, "set_bg_color(color:lv_color_t)", pika_lvgl_style_t_set_bg_colorMethod);
class_defineMethod(self, "set_bg_opa(opa:int)", pika_lvgl_style_t_set_bg_opaMethod);
class_defineMethod(self, "set_outline_color(color:lv_color_t)", pika_lvgl_style_t_set_outline_colorMethod);
class_defineMethod(self, "set_outline_pad(pad:int)", pika_lvgl_style_t_set_outline_padMethod);
class_defineMethod(self, "set_outline_width(w:int)", pika_lvgl_style_t_set_outline_widthMethod);
class_defineMethod(self, "set_radius(radius:int)", pika_lvgl_style_t_set_radiusMethod);
class_defineMethod(self, "set_shadow_color(color:lv_color_t)", pika_lvgl_style_t_set_shadow_colorMethod);
class_defineMethod(self, "set_shadow_spread(s:int)", pika_lvgl_style_t_set_shadow_spreadMethod);
class_defineMethod(self, "set_shadow_width(w:int)", pika_lvgl_style_t_set_shadow_widthMethod);
class_defineMethod(self, "set_bg_color(color)", pika_lvgl_style_t_set_bg_colorMethod);
class_defineMethod(self, "set_bg_opa(opa)", pika_lvgl_style_t_set_bg_opaMethod);
class_defineMethod(self, "set_outline_color(color)", pika_lvgl_style_t_set_outline_colorMethod);
class_defineMethod(self, "set_outline_pad(pad)", pika_lvgl_style_t_set_outline_padMethod);
class_defineMethod(self, "set_outline_width(w)", pika_lvgl_style_t_set_outline_widthMethod);
class_defineMethod(self, "set_radius(radius)", pika_lvgl_style_t_set_radiusMethod);
class_defineMethod(self, "set_shadow_color(color)", pika_lvgl_style_t_set_shadow_colorMethod);
class_defineMethod(self, "set_shadow_spread(s)", pika_lvgl_style_t_set_shadow_spreadMethod);
class_defineMethod(self, "set_shadow_width(w)", pika_lvgl_style_t_set_shadow_widthMethod);
return self;
}
@ -2173,7 +2238,7 @@ void pika_lvgl_switch___init__Method(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_switch(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_switch___init__Method);
class_defineMethod(self, "__init__(parent)", pika_lvgl_switch___init__Method);
return self;
}
@ -2197,8 +2262,8 @@ void pika_lvgl_table_set_cell_valueMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_table(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_table___init__Method);
class_defineMethod(self, "set_cell_value(row:int,col:int,txt:str)", pika_lvgl_table_set_cell_valueMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_table___init__Method);
class_defineMethod(self, "set_cell_value(row,col,txt)", pika_lvgl_table_set_cell_valueMethod);
return self;
}
@ -2220,8 +2285,8 @@ void pika_lvgl_textarea_set_one_lineMethod(PikaObj *self, Args *args){
PikaObj *New_pika_lvgl_textarea(Args *args){
PikaObj *self = New_pika_lvgl_lv_obj(args);
class_defineMethod(self, "__init__(parent:lv_obj)", pika_lvgl_textarea___init__Method);
class_defineMethod(self, "set_one_line(en:int)", pika_lvgl_textarea_set_one_lineMethod);
class_defineMethod(self, "__init__(parent)", pika_lvgl_textarea___init__Method);
class_defineMethod(self, "set_one_line(en)", pika_lvgl_textarea_set_one_lineMethod);
return self;
}

2
port/cmsis-pack/pikascript/pikascript-api/pikaScript.c
View File

@ -17,7 +17,7 @@ PikaObj *__pikaMain;
PikaObj *pikaScriptInit(void){
__platform_printf("======[pikascript packages installed]======\r\n");
pks_printVersion();
__platform_printf("PikaStdLib==v1.10.6\r\n");
__platform_printf("PikaStdLib==v1.11.0\r\n");
__platform_printf("pika_lvgl==v0.2.0\r\n");
__platform_printf("===========================================\r\n");
__pikaMain = newRootObj("pikaMain", New_PikaMain);

104
port/cmsis-pack/pikascript/pikascript-core/PikaObj.c
View File

@ -47,12 +47,12 @@ static const uint64_t __talbe_fast_atoi[][10] = {
{0, 1e9, 2e9, 3e9, 4e9, 5e9, 6e9, 7e9, 8e9, 9e9},
};
int fast_atoi(char* src) {
int64_t fast_atoi(char* src) {
const char* p = src;
uint16_t size = strGetSize(src);
p = p + size - 1;
if (*p) {
int s = 0;
int64_t s = 0;
const uint64_t* n = __talbe_fast_atoi[0];
while (p != src) {
s += n[(*p - '0')];
@ -192,13 +192,13 @@ int64_t obj_getInt(PikaObj* self, char* argPath) {
return -999999999;
}
char* argName = strPointToLastToken(argPath, '.');
int res = args_getInt(obj->list, argName);
int64_t res = args_getInt(obj->list, argName);
return res;
}
Arg* obj_getArg(PikaObj* self, char* argPath) {
PIKA_BOOL isClass = PIKA_FALSE;
PikaObj* obj = obj_getHostObjWithIsClass(self, argPath, &isClass);
PikaObj* obj = obj_getHostObjWithIsTemp(self, argPath, &isClass);
if (NULL == obj) {
return NULL;
}
@ -434,10 +434,33 @@ exit:
return res;
}
PikaObj* _arg_to_obj(Arg* self, PIKA_BOOL* pIsTemp) {
if (argType_isObject(arg_getType(self))) {
return arg_getPtr(self);
}
#if !PIKA_NANO_ENABLE
if (arg_getType(self) == ARG_TYPE_STRING) {
PikaObj* New_PikaStdData_String(Args * args);
PikaObj* obj = newNormalObj(New_PikaStdData_String);
obj_setStr(obj, "str", arg_getStr(self));
*pIsTemp = PIKA_TRUE;
return obj;
}
if (arg_getType(self) == ARG_TYPE_BYTES) {
PikaObj* New_PikaStdData_ByteArray(Args * args);
PikaObj* obj = newNormalObj(New_PikaStdData_ByteArray);
obj_setArg(obj, "raw", self);
*pIsTemp = PIKA_TRUE;
return obj;
}
#endif
return NULL;
}
static PikaObj* __obj_getObjDirect(PikaObj* self,
char* name,
PIKA_BOOL* pIsClass) {
*pIsClass = PIKA_FALSE;
PIKA_BOOL* pIsTemp) {
*pIsTemp = PIKA_FALSE;
if (NULL == self) {
return NULL;
}
@ -451,10 +474,11 @@ static PikaObj* __obj_getObjDirect(PikaObj* self,
if (argType_isObject(type)) {
return args_getPtr(self->list, name);
}
#if !PIKA_NANO_ENABLE
/* found class */
if (type == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR ||
type == ARG_TYPE_METHOD_CONSTRUCTOR) {
*pIsClass = PIKA_TRUE;
*pIsTemp = PIKA_TRUE;
PikaObj* method_args_obj = New_TinyObj(NULL);
Arg* cls_obj_arg = obj_runMethodArg(self, method_args_obj,
args_getArg(self->list, name));
@ -466,12 +490,13 @@ static PikaObj* __obj_getObjDirect(PikaObj* self,
arg_deinit(cls_obj_arg);
return res;
}
return NULL;
#endif
return _arg_to_obj(args_getArg(self->list, name), pIsTemp);
}
static PikaObj* __obj_getObjWithKeepDeepth(PikaObj* self,
char* objPath,
PIKA_BOOL* pIsClass,
PIKA_BOOL* pIsTemp,
int32_t keepDeepth) {
char objPath_buff[PIKA_PATH_BUFF_SIZE];
__platform_memcpy(objPath_buff, objPath, strGetSize(objPath) + 1);
@ -480,7 +505,7 @@ static PikaObj* __obj_getObjWithKeepDeepth(PikaObj* self,
PikaObj* obj = self;
for (int32_t i = 0; i < token_num - keepDeepth; i++) {
char* token = strPopToken(token_buff, objPath_buff, '.');
obj = __obj_getObjDirect(obj, token, pIsClass);
obj = __obj_getObjDirect(obj, token, pIsTemp);
if (obj == NULL) {
goto exit;
}
@ -500,10 +525,10 @@ PikaObj* obj_getHostObj(PikaObj* self, char* objPath) {
return __obj_getObjWithKeepDeepth(self, objPath, &isClass, 1);
}
PikaObj* obj_getHostObjWithIsClass(PikaObj* self,
char* objPath,
PIKA_BOOL* pIsClass) {
return __obj_getObjWithKeepDeepth(self, objPath, pIsClass, 1);
PikaObj* obj_getHostObjWithIsTemp(PikaObj* self,
char* objPath,
PIKA_BOOL* pIsTemp) {
return __obj_getObjWithKeepDeepth(self, objPath, pIsTemp, 1);
}
Method methodArg_getPtr(Arg* method_arg) {
@ -588,18 +613,18 @@ static void obj_saveMethodInfo(PikaObj* self, MethodInfo* method_info) {
}
static int32_t __class_defineMethodWithType(PikaObj* self,
char* declearation,
char* declareation,
Method method_ptr,
ArgType method_type,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame) {
int32_t size = strGetSize(declearation);
int32_t size = strGetSize(declareation);
int32_t res = 0;
Args buffs = {0};
char* clean_declearation =
strDeleteChar(args_getBuff(&buffs, size), declearation, ' ');
char* clean_declareation =
strDeleteChar(args_getBuff(&buffs, size), declareation, ' ');
char* method_path =
strGetFirstToken(args_getBuff(&buffs, size), clean_declearation, '(');
strGetFirstToken(args_getBuff(&buffs, size), clean_declareation, '(');
PikaObj* method_host = obj_getHostObj(self, method_path);
MethodInfo method_info = {0};
@ -610,7 +635,7 @@ static int32_t __class_defineMethodWithType(PikaObj* self,
goto exit;
}
method_name = strPointToLastToken(method_path, '.');
method_info.dec = clean_declearation;
method_info.dec = clean_declareation;
method_info.name = method_name;
method_info.ptr = (void*)method_ptr;
method_info.type = method_type;
@ -626,50 +651,50 @@ exit:
/* define a constructor method */
int32_t class_defineConstructor(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr) {
return __class_defineMethodWithType(self, declearation, methodPtr,
return __class_defineMethodWithType(self, declareation, methodPtr,
ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR,
NULL, NULL);
}
/* define a native method as default */
int32_t class_defineMethod(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr) {
return __class_defineMethodWithType(self, declearation, methodPtr,
return __class_defineMethodWithType(self, declareation, methodPtr,
ARG_TYPE_METHOD_NATIVE, NULL, NULL);
}
/* define object method, object method is which startwith (self) */
int32_t class_defineRunTimeConstructor(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame) {
return __class_defineMethodWithType(self, declearation, methodPtr,
return __class_defineMethodWithType(self, declareation, methodPtr,
ARG_TYPE_METHOD_CONSTRUCTOR,
def_context, bytecode_frame);
}
/* define object method, object method is which startwith (self) */
int32_t class_defineObjectMethod(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame) {
return __class_defineMethodWithType(self, declearation, methodPtr,
return __class_defineMethodWithType(self, declareation, methodPtr,
ARG_TYPE_METHOD_OBJECT, def_context,
bytecode_frame);
}
/* define a static method as default */
int32_t class_defineStaticMethod(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame) {
return __class_defineMethodWithType(self, declearation, methodPtr,
return __class_defineMethodWithType(self, declareation, methodPtr,
ARG_TYPE_METHOD_STATIC, def_context,
bytecode_frame);
}
@ -930,7 +955,7 @@ void method_returnStr(Args* args, char* val) {
args_setStr(args, "return", val);
}
void method_returnInt(Args* args, int32_t val) {
void method_returnInt(Args* args, int64_t val) {
args_setInt(args, "return", val);
}
@ -954,7 +979,7 @@ void method_returnArg(Args* args, Arg* arg) {
args_setArg(args, arg);
}
int32_t method_getInt(Args* args, char* argName) {
int64_t method_getInt(Args* args, char* argName) {
return args_getInt(args, argName);
}
@ -975,11 +1000,16 @@ PikaObj* New_PikaObj(void) {
return self;
}
Arg* arg_setRef(Arg* self, char* name, PikaObj* obj) {
obj_refcntInc(obj);
Arg* arg_setObj(Arg* self, char* name, PikaObj* obj) {
return arg_setPtr(self, name, ARG_TYPE_OBJECT, obj);
}
Arg* arg_setRef(Arg* self, char* name, PikaObj* obj) {
pika_assert(NULL != obj);
obj_refcntInc(obj);
return arg_setObj(self, name, obj);
}
int32_t obj_newDirectObj(PikaObj* self, char* objName, NewFun newFunPtr) {
Arg* new_obj = arg_newDirectObj(newFunPtr);
new_obj = arg_setName(new_obj, objName);
@ -1181,9 +1211,9 @@ void pks_printVersion(void) {
PIKA_VERSION_MINOR, PIKA_VERSION_MICRO, PIKA_EDIT_TIME);
}
void pks_getVersion(char *buff)
{
__platform_sprintf(buff, "%d.%d.%d", PIKA_VERSION_MAJOR, PIKA_VERSION_MINOR, PIKA_VERSION_MICRO);
void pks_getVersion(char* buff) {
__platform_sprintf(buff, "%d.%d.%d", PIKA_VERSION_MAJOR, PIKA_VERSION_MINOR,
PIKA_VERSION_MICRO);
}
void* obj_getStruct(PikaObj* self, char* name) {

24
port/cmsis-pack/pikascript/pikascript-core/PikaObj.h
View File

@ -127,7 +127,7 @@ int32_t obj_load(PikaObj* self, Args* args, char* name);
int32_t obj_addOther(PikaObj* self, char* subObjectName, void* new_projcetFun);
PikaObj* obj_getObj(PikaObj* self, char* objPath);
PikaObj* obj_getHostObj(PikaObj* self, char* objPath);
PikaObj* obj_getHostObjWithIsClass(PikaObj* self,
PikaObj* obj_getHostObjWithIsTemp(PikaObj* self,
char* objPath,
PIKA_BOOL* pIsClass);
@ -135,26 +135,26 @@ PikaObj* obj_getHostObjWithIsClass(PikaObj* self,
int32_t obj_freeObj(PikaObj* self, char* subObjectName);
/* method */
int32_t class_defineMethod(PikaObj* self, char* declearation, Method methodPtr);
int32_t class_defineMethod(PikaObj* self, char* declareation, Method methodPtr);
int32_t class_defineObjectMethod(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame);
int32_t class_defineStaticMethod(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame);
int32_t class_defineConstructor(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr);
int32_t class_defineRunTimeConstructor(PikaObj* self,
char* declearation,
char* declareation,
Method methodPtr,
PikaObj* def_context,
ByteCodeFrame* bytecode_frame);
@ -182,11 +182,11 @@ uint8_t obj_getAnyArg(PikaObj* self,
Args* targetArgs);
void method_returnStr(Args* args, char* val);
void method_returnInt(Args* args, int32_t val);
void method_returnInt(Args* args, int64_t val);
void method_returnFloat(Args* args, double val);
void method_returnPtr(Args* args, void* val);
void method_returnObj(Args* args, void* val);
int32_t method_getInt(Args* args, char* argName);
int64_t method_getInt(Args* args, char* argName);
double method_getFloat(Args* args, char* argName);
char* method_getStr(Args* args, char* argName);
void method_returnArg(Args* args, Arg* arg);
@ -202,7 +202,7 @@ VMParameters* obj_runDirect(PikaObj* self, char* cmd);
PikaObj* New_PikaObj(void);
/* tools */
int fast_atoi(char* src);
int64_t fast_atoi(char* src);
char* fast_itoa(char* buf, uint32_t val);
/* shell */
@ -231,10 +231,10 @@ Arg* obj_newObjInPackage(NewFun newObjFun);
PikaObj* newNormalObj(NewFun newObjFun);
Arg* arg_setRef(Arg* self, char* name, PikaObj* obj);
Arg* arg_setWeakRef(Arg* self, char* name, PikaObj* obj);
Arg* arg_setObj(Arg* self, char* name, PikaObj* obj);
#define arg_newObj(obj) arg_setObj(NULL, "", (obj))
#define arg_newRef(obj) arg_setRef(NULL, "", (obj))
#define arg_newWeakRef(obj) arg_setWeakRef(NULL, "", (obj))
PikaObj* obj_importModuleWithByteCodeFrame(PikaObj* self,
char* name,
@ -307,6 +307,8 @@ void* obj_getStruct(PikaObj* self, char* name);
while (1)
char* obj_cacheStr(PikaObj* self, char* str);
PikaObj* _arg_to_obj(Arg* self, PIKA_BOOL* pIsTemp);
char* __printBytes(PikaObj* self, Arg* arg);
#define PIKASCRIPT_VERSION_TO_NUM(majer, minor, micro) \
majer * 100 * 100 + minor * 100 + micro

997
port/cmsis-pack/pikascript/pikascript-core/PikaParser.c
View File

File diff suppressed because it is too large Load Diff

8
port/cmsis-pack/pikascript/pikascript-core/PikaPlatform.c
View File

@ -110,6 +110,14 @@ PIKA_WEAK void* __platform_memcpy(void* dir, const void* src, size_t size) {
return memcpy(dir, src, size);
}
PIKA_WEAK int __platform_memcmp(const void* s1, const void* s2, size_t n) {
return memcmp(s1, s2, n);
}
PIKA_WEAK void* __platform_memmove(void* s1, void* s2, size_t n) {
return memmove(s1, s2, n);
}
PIKA_WEAK char __platform_getchar(void) {
#if defined(__linux) || defined(_WIN32)
return getchar();

2
port/cmsis-pack/pikascript/pikascript-core/PikaPlatform.h
View File

@ -137,6 +137,8 @@ void* __platform_malloc(size_t size);
void __platform_free(void* ptr);
void* __platform_memset(void* mem, int ch, size_t size);
void* __platform_memcpy(void* dir, const void* src, size_t size);
int __platform_memcmp(const void* s1, const void* s2, size_t n);
void* __platform_memmove(void* s1, void* s2, size_t n);
void* __user_malloc(size_t size);
void __user_free(void* ptr, size_t size);

631
port/cmsis-pack/pikascript/pikascript-core/PikaVM.c
View File

File diff suppressed because it is too large Load Diff

21
port/cmsis-pack/pikascript/pikascript-core/PikaVM.h
View File

@ -57,8 +57,8 @@ typedef enum {
TRY_RESULT_RAISE,
} TRY_RESULT;
typedef struct TryInfo TryInfo;
struct TryInfo {
typedef struct RunState RunState;
struct RunState {
TRY_STATE try_state;
TRY_RESULT try_result;
};
@ -76,9 +76,10 @@ struct VMState {
uint8_t line_error_code;
uint8_t try_error_code;
uint32_t ins_cnt;
PIKA_BOOL in_super;
PikaObj* lreg[PIKA_REGIST_SIZE];
PIKA_BOOL ireg[PIKA_REGIST_SIZE];
TryInfo* try_info;
RunState* run_state;
};
typedef struct OperatorInfo OperatorInfo;
@ -97,6 +98,17 @@ struct OperatorInfo {
VMState* vm;
};
typedef enum VM_SIGNAL_CTRL {
VM_SIGNAL_CTRL_NONE = 0,
VM_SIGNAL_CTRL_EXIT,
} VM_SIGNAL_CTRL;
typedef struct VMSignal VMSignal;
struct VMSignal {
VM_SIGNAL_CTRL signal_ctrl;
int vm_cnt;
};
VMParameters* pikaVM_run(PikaObj* self, char* pyLine);
VMParameters* pikaVM_runAsm(PikaObj* self, char* pikaAsm);
VMParameters* pikaVM_runByteCodeFrame(PikaObj* self,
@ -192,5 +204,8 @@ void __vm_List_append(PikaObj* self, Arg* arg);
void __vm_List___init__(PikaObj* self);
void __vm_Dict_set(PikaObj* self, Arg* arg, char* key);
void __vm_Dict___init__(PikaObj* self);
VM_SIGNAL_CTRL VMSignal_getCtrl(void);
void pks_vm_exit(void);
void pks_vmSignal_setCtrlElear(void);
#endif

6
port/cmsis-pack/pikascript/pikascript-core/PikaVersion.h
View File

@ -1,5 +1,5 @@
#define PIKA_VERSION_MAJOR 1
#define PIKA_VERSION_MINOR 10
#define PIKA_VERSION_MICRO 6
#define PIKA_VERSION_MINOR 11
#define PIKA_VERSION_MICRO 0
#define PIKA_EDIT_TIME "2022/08/30 18:40:40"
#define PIKA_EDIT_TIME "2022/09/16 15:33:53"

2
port/cmsis-pack/pikascript/pikascript-core/__instruction_table.cfg
View File

@ -94,3 +94,5 @@ def_ins(SLC)
def_ins(ASS)
/* expect */
def_ins(EXP)
/* jump no zero */
def_ins(JNZ)

72
port/cmsis-pack/pikascript/pikascript-core/dataArg.c
View File

@ -57,6 +57,7 @@ static Arg* arg_init_hash(Hash nameHash,
self->size = size;
self->name_hash = nameHash;
self->type = type;
self->flag = 0;
arg_setSerialized(self, PIKA_TRUE);
arg_setIsKeyword(self, PIKA_FALSE);
__platform_memset(arg_getContent(self), 0,
@ -64,7 +65,7 @@ static Arg* arg_init_hash(Hash nameHash,
if (NULL != content) {
__platform_memcpy(arg_getContent(self), content, size);
}
pika_assert(self->flag < ARG_FLAG_MAX);
return self;
}
@ -82,6 +83,7 @@ void arg_init_stack(Arg* self, uint8_t* buffer, uint32_t size) {
self->size = size;
self->type = ARG_TYPE_UNDEF;
self->name_hash = 0;
self->flag = 0;
arg_setSerialized(self, PIKA_FALSE);
arg_setIsKeyword(self, PIKA_FALSE);
}
@ -129,6 +131,7 @@ Arg* arg_setNameHash(Arg* self, Hash nameHash) {
}
Arg* arg_setName(Arg* self, char* name) {
pika_assert(NULL != name);
return arg_setNameHash(self, hash_time33(name));
}
@ -157,6 +160,7 @@ Arg* arg_setBytes(Arg* self, char* name, uint8_t* src, size_t size) {
if (NULL != src) {
__platform_memcpy((void*)((uintptr_t)dir + sizeof(size_t)), src, size);
}
pika_assert(self->flag < ARG_FLAG_MAX);
return self;
}
@ -170,14 +174,26 @@ uint8_t* arg_getBytes(Arg* self) {
return arg_getContent(self) + sizeof(size_t);
}
void arg_printBytes(Arg* self) {
size_t bytes_size = arg_getBytesSize(self);
uint8_t* bytes = arg_getBytes(self);
__platform_printf("b\'");
char* __printBytes(PikaObj* self, Arg* arg) {
Args buffs = {0};
size_t bytes_size = arg_getBytesSize(arg);
uint8_t* bytes = arg_getBytes(arg);
Arg* str_arg = arg_newStr("b\'");
for (size_t i = 0; i < bytes_size; i++) {
__platform_printf("\\x%02x", bytes[i]);
char* str_item = strsFormat(&buffs, 16, "\\x%02x", bytes[i]);
str_arg = arg_strAppend(str_arg, str_item);
}
__platform_printf("\'\r\n");
str_arg = arg_strAppend(str_arg, "\'");
char* str_res = obj_cacheStr(self, arg_getStr(str_arg));
strsDeinit(&buffs);
arg_deinit(str_arg);
return str_res;
}
void arg_printBytes(Arg* self) {
PikaObj* obj = New_PikaObj();
__platform_printf("%s\r\n", __printBytes(obj, self));
obj_deinit(obj);
}
size_t arg_getBytesSize(Arg* self) {
@ -279,6 +295,9 @@ int64_t arg_getInt(Arg* self) {
}
void* arg_getPtr(Arg* self) {
if (arg_getType(self) == ARG_TYPE_NONE) {
return NULL;
}
if (NULL == arg_getContent(self)) {
return NULL;
}
@ -314,16 +333,18 @@ Arg* arg_copy(Arg* arg_src) {
if (NULL == arg_src) {
return NULL;
}
pika_assert(arg_src->flag < ARG_FLAG_MAX);
ArgType arg_type = arg_getType(arg_src);
if (ARG_TYPE_OBJECT == arg_type) {
obj_refcntInc((PikaObj*)arg_getPtr(arg_src));
}
Arg* argCopied = New_arg(NULL);
argCopied = arg_setContent(argCopied, arg_getContent(arg_src),
arg_getContentSize(arg_src));
argCopied = arg_setNameHash(argCopied, arg_getNameHash(arg_src));
argCopied = arg_setType(argCopied, arg_getType(arg_src));
return argCopied;
Arg* arg_dict = New_arg(NULL);
arg_dict = arg_setContent(arg_dict, arg_getContent(arg_src),
arg_getContentSize(arg_src));
arg_dict = arg_setNameHash(arg_dict, arg_getNameHash(arg_src));
arg_dict = arg_setType(arg_dict, arg_getType(arg_src));
arg_setIsKeyword(arg_dict, arg_getIsKeyword(arg_src));
return arg_dict;
}
Arg* arg_copy_noalloc(Arg* arg_src, Arg* arg_dict) {
@ -346,6 +367,7 @@ Arg* arg_copy_noalloc(Arg* arg_src, Arg* arg_dict) {
arg_getContentSize(arg_src));
arg_dict = arg_setNameHash(arg_dict, arg_getNameHash(arg_src));
arg_dict = arg_setType(arg_dict, arg_getType(arg_src));
arg_setIsKeyword(arg_dict, arg_getIsKeyword(arg_src));
return arg_dict;
}
@ -431,3 +453,27 @@ void arg_deinit(Arg* self) {
/* free the ref */
arg_freeContent(self);
}
PIKA_BOOL arg_isEqual(Arg* self, Arg* other) {
if (NULL == self || NULL == other) {
return PIKA_FALSE;
}
if (arg_getType(self) != arg_getType(other)) {
return PIKA_FALSE;
}
if (arg_getType(self) == ARG_TYPE_OBJECT) {
if (arg_getPtr(self) != arg_getPtr(other)) {
return PIKA_FALSE;
}
}
if (arg_getType(self) == ARG_TYPE_STRING) {
if (strEqu(arg_getStr(self), arg_getStr(other))) {
return PIKA_TRUE;
}
}
if (0 != __platform_memcmp(arg_getContent(self), arg_getContent(other),
arg_getContentSize(self))) {
return PIKA_FALSE;
}
return PIKA_TRUE;
}

6
port/cmsis-pack/pikascript/pikascript-core/dataArg.h
View File

@ -65,8 +65,8 @@ typedef union {
struct Arg {
_arg_union _;
uint32_t size;
uint8_t type;
PIKA_BOOL flag;
ArgType type;
uint8_t flag;
Hash name_hash;
uint8_t content[];
};
@ -133,6 +133,7 @@ uint8_t argType_isObject(ArgType type);
#define ARG_FLAG_MASK_SERIALIZED 0x01
#define ARG_FLAG_MASK_IsKeyword 0x02
#define ARG_FLAG_MAX 0x04
#define arg_getNext(self) ((self)->_.next)
#define arg_getSize(self) ((self)->size)
@ -170,3 +171,4 @@ uint8_t argType_isObject(ArgType type);
arg_init_stack(&__name, __##__name##_buff, __size)
void arg_init_stack(Arg* self, uint8_t* buffer, uint32_t size);
PIKA_BOOL arg_isEqual(Arg* self, Arg* other);

19
port/cmsis-pack/pikascript/pikascript-core/dataArgs.c
View File

@ -34,6 +34,7 @@
#include "dataStrs.h"
void args_deinit(Args* self) {
pika_assert(self != NULL);
link_deinit(self);
}
@ -87,6 +88,9 @@ PIKA_RES args_setStr(Args* self, char* name, char* strIn) {
}
PIKA_RES args_pushArg(Args* self, Arg* arg) {
if (NULL == arg) {
return PIKA_RES_ERR_ARG_NO_FOUND;
}
Arg* new_arg = NULL;
if (!arg_getSerialized(arg)) {
new_arg = arg_copy(arg);
@ -368,6 +372,7 @@ Arg* args_getArg_hash(Args* self, Hash nameHash) {
}
Arg* args_getArg(Args* self, char* name) {
pika_assert(NULL != self);
LinkNode* node = args_getNode(self, name);
if (NULL == node) {
return NULL;
@ -582,6 +587,9 @@ void* list_getPtr(PikaList* self, int index) {
}
PIKA_RES list_append(PikaList* self, Arg* arg) {
if (NULL == arg) {
return PIKA_RES_ERR_ARG_NO_FOUND;
}
int top = args_getInt(&self->super, "top");
char buff[11];
char* topStr = fast_itoa(buff, top);
@ -593,10 +601,12 @@ PIKA_RES list_append(PikaList* self, Arg* arg) {
}
size_t list_getSize(PikaList* self) {
pika_assert(NULL != self);
return args_getInt(&self->super, "top");
}
void list_reverse(PikaList* self) {
pika_assert(NULL != self);
int top = list_getSize(self);
for (int i = 0; i < top / 2; i++) {
Arg* arg_i = arg_copy(list_getArg(self, i));
@ -695,12 +705,19 @@ exit:
return res;
}
/* tuple */
PikaTuple* args_getTuple(Args* self, char* name) {
PikaObj* tuple_obj = args_getPtr(self, name);
return obj_getPtr(tuple_obj, "list");
}
char* args_cacheStr(Args* self, char* str){
/* dict */
PikaDict* args_getDict(Args* self, char* name) {
PikaObj* tuple_obj = args_getPtr(self, name);
return obj_getPtr(tuple_obj, "dict");
}
char* args_cacheStr(Args* self, char* str) {
args_setStr(self, "__str_cache", str);
return args_getStr(self, "__str_cache");
}

1
port/cmsis-pack/pikascript/pikascript-core/dataArgs.h
View File

@ -185,6 +185,7 @@ char* strsFormatArg(Args* out_buffs, char* fmt, Arg* arg);
PikaList* New_list(void);
PikaTuple* New_tuple(void);
PikaTuple* args_getTuple(Args* self, char* name);
PikaDict* args_getDict(Args* self, char* name);
char* strsFormatList(Args* out_buffs, char* fmt, PikaList* list);
char* args_cacheStr(Args* self, char* str);

1
port/cmsis-pack/pikascript/pikascript-core/dataLink.c
View File

@ -41,6 +41,7 @@ void __link_deinit_pyload(Link* self) {
}
void link_deinit(Link* self) {
pika_assert(self != NULL);
__link_deinit_pyload(self);
pikaFree(self, sizeof(Link));
}

2
port/cmsis-pack/pikascript/pikascript-core/dataMemory.c
View File

@ -29,7 +29,7 @@
#include "dataMemory.h"
#include "PikaPlatform.h"
PikaMemInfo pikaMemInfo = {0};
volatile PikaMemInfo pikaMemInfo = {0};
void* pikaMalloc(uint32_t size) {
/* pika memory lock */

15
port/cmsis-pack/pikascript/pikascript-core/dataStack.c
View File

@ -60,7 +60,7 @@ int32_t stack_deinit(Stack* stack) {
return 0;
}
void stack_pushPyload(Stack* stack, Arg* content, size_t size) {
void stack_pushPyload(Stack* stack, Arg* in, size_t size) {
size_t stack_size_after_push =
size + (stack->sp - arg_getContent(stack->stack_pyload));
if (stack_size_after_push > stack->stack_totle_size) {
@ -74,14 +74,14 @@ void stack_pushPyload(Stack* stack, Arg* content, size_t size) {
while (1) {
}
}
if (arg_getSerialized(content)) {
__platform_memcpy(stack->sp, content, size);
Arg* top = (Arg*)stack->sp;
if (arg_getSerialized(in)) {
__platform_memcpy(top, in, size);
} else {
__platform_memcpy(stack->sp, content, sizeof(Arg));
__platform_memcpy(stack->sp + sizeof(Arg), content->_.buffer,
size - sizeof(Arg));
__platform_memcpy(top, in, sizeof(Arg));
__platform_memcpy(top->content, in->_.buffer, size - sizeof(Arg));
/* transfer to serialized form */
arg_setSerialized((Arg*)stack->sp, PIKA_TRUE);
arg_setSerialized(top, PIKA_TRUE);
}
stack->sp += size;
}
@ -144,6 +144,7 @@ Arg* _stack_popArg(Stack* stack, Arg* arg_dict, PIKA_BOOL is_alloc) {
if (argType_isObject(type)) {
obj_refcntDec((PikaObj*)arg_getPtr(arg));
}
pika_assert(arg->flag < ARG_FLAG_MAX);
return arg;
}

11
port/cmsis-pack/pikascript/pikascript-core/pika_config_valid.h
View File

@ -64,6 +64,12 @@
#ifndef PIKA_SYNTAX_LEVEL
#define PIKA_SYNTAX_LEVEL PIKA_SYNTAX_LEVEL_MINIMAL
#endif
#ifndef PIKA_STRING_UTF8_ENABLE
#define PIKA_STRING_UTF8_ENABLE 0
#endif
#endif
/* default optimize */
@ -290,6 +296,11 @@
#define PIKA_EXEC_ENABLE 1
#endif
/* support for UTF-8 in PikaStdData_String */
#ifndef PIKA_STRING_UTF8_ENABLE
#define PIKA_STRING_UTF8_ENABLE 1
#endif
/* configuration validation */
#endif

86
port/cmsis-pack/pikascript/pikascript-lib/PikaStdLib/PikaStdData_Dict.c
View File

@ -1,6 +1,8 @@
#include "PikaStdData_Dict.h"
#include "BaseObj.h"
#include "PikaObj.h"
#include "PikaStdData_Tuple.h"
#include "PikaStdData_dict_items.h"
#include "PikaStdData_dict_keys.h"
#include "PikaStdLib_SysObj.h"
#include "dataStrs.h"
@ -59,7 +61,9 @@ void PikaStdData_Dict___del__(PikaObj* self) {
PikaDict* dict = obj_getPtr(self, "dict");
PikaDict* keys = obj_getPtr(self, "_keys");
dict_deinit(dict);
dict_deinit(keys);
if (NULL != keys) {
dict_deinit(keys);
}
}
void PikaStdData_dict_keys___init__(PikaObj* self, PikaObj* dict) {
@ -72,6 +76,12 @@ PikaObj* PikaStdData_Dict_keys(PikaObj* self) {
return dict_keys;
}
PikaObj* PikaStdData_Dict_items(PikaObj* self) {
PikaObj* dict_items = newNormalObj(New_PikaStdData_dict_items);
PikaStdData_dict_keys___init__(dict_items, self);
return dict_items;
}
Arg* PikaStdData_dict_keys___iter__(PikaObj* self) {
obj_setInt(self, "__iter_i", 0);
return arg_newRef(self);
@ -170,3 +180,77 @@ int PikaStdData_dict_keys___len__(PikaObj* self) {
PikaDict* keys = obj_getPtr(dictptr, "_keys");
return args_getSize(&keys->super);
}
int dict_contains(PikaDict* dict, Arg* key) {
int i = 0;
while (PIKA_TRUE) {
Arg* item = args_getArgByidex(&dict->super, i);
if (NULL == item) {
break;
}
if (arg_isEqual(item, key)) {
return PIKA_TRUE;
}
i++;
}
return PIKA_FALSE;
}
int PikaStdData_Dict___contains__(PikaObj* self, Arg* val) {
PikaDict* dict = obj_getPtr(self, "_keys");
return dict_contains(dict, val);
}
Arg* PikaStdData_dict_items___iter__(PikaObj* self) {
obj_setInt(self, "__iter_i", 0);
return arg_newRef(self);
}
int PikaStdData_dict_items___len__(PikaObj* self) {
PikaObj* dictptr = obj_getPtr(self, "dictptr");
PikaDict* keys = obj_getPtr(dictptr, "_keys");
return args_getSize(&keys->super);
}
Arg* PikaStdData_dict_items___next__(PikaObj* self) {
int __iter_i = args_getInt(self->list, "__iter_i");
PikaObj* dictptr = obj_getPtr(self, "dictptr");
PikaDict* keys = obj_getPtr(dictptr, "_keys");
PikaDict* dict = obj_getPtr(dictptr, "dict");
Arg* key = args_getArgByidex(&keys->super, __iter_i);
Arg* val = args_getArgByidex(&dict->super, __iter_i);
if (NULL == key) {
return arg_newNull();
}
PikaObj* tuple = newNormalObj(New_PikaStdData_Tuple);
PikaStdData_Tuple___init__(tuple);
PikaList* list = obj_getPtr(tuple, "list");
list_append(list, key);
list_append(list, val);
args_setInt(self->list, "__iter_i", __iter_i + 1);
return arg_newObj(tuple);
}
char* PikaStdData_dict_items___str__(PikaObj* self) {
Arg* str_arg = arg_newStr("dict_items([");
int i = 0;
obj_setInt(self, "__iter_i", 0);
while (PIKA_TRUE) {
Arg* item = PikaStdData_dict_items___next__(self);
if (arg_getType(item) == ARG_TYPE_NONE) {
arg_deinit(item);
break;
}
if (i != 0) {
str_arg = arg_strAppend(str_arg, ", ");
}
char* item_str = PikaStdLib_SysObj_str(self, item);
str_arg = arg_strAppend(str_arg, item_str);
i++;
arg_deinit(item);
}
str_arg = arg_strAppend(str_arg, "])");
obj_setStr(self, "_buf", arg_getStr(str_arg));
arg_deinit(str_arg);
return obj_getStr(self, "_buf");
}

793
port/cmsis-pack/pikascript/pikascript-lib/PikaStdLib/PikaStdData_String.c
View File

@ -3,74 +3,168 @@
#include "PikaStdData_String_Util.h"
#include "dataStrs.h"
Arg* PikaStdData_String___iter__(PikaObj* self) {
char* _strlwr(char *str);
Arg *PikaStdData_String___iter__(PikaObj *self)
{
obj_setInt(self, "__iter_i", 0);
return arg_newRef(self);
}
void PikaStdData_String_set(PikaObj* self, char* s) {
void PikaStdData_String_set(PikaObj *self, char *s)
{
#if PIKA_STRING_UTF8_ENABLE
int r = _valid_utf8(s, -1);
if (r >= 0)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error invaliad character %x\r\n", s[r]);
return;
}
#endif
obj_setStr(self, "str", s);
}
void PikaStdData_String___init__(PikaObj* self, char* s) {
void PikaStdData_String___init__(PikaObj *self, char *s)
{
#if PIKA_STRING_UTF8_ENABLE
int r = _valid_utf8(s, -1);
if (r >= 0)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error invaliad character %x\r\n", s[r]);
return;
}
#endif
PikaStdData_String_set(self, s);
}
char* PikaStdData_String_get(PikaObj* self) {
char *PikaStdData_String_get(PikaObj *self)
{
return obj_getStr(self, "str");
}
Arg* PikaStdData_String___next__(PikaObj* self) {
Arg *PikaStdData_String___next__(PikaObj *self)
{
int __iter_i = args_getInt(self->list, "__iter_i");
char* str = obj_getStr(self, "str");
char *str = obj_getStr(self, "str");
uint16_t len = strGetSize(str);
Arg* res = NULL;
#if PIKA_STRING_UTF8_ENABLE
char char_buff[5];
int r = _utf8_get(str, len, __iter_i, char_buff);
if (r < 0)
{
return arg_newNull();
}
args_setInt(self->list, "__iter_i", __iter_i + 1);
return arg_newStr((char *)char_buff);
#else
Arg *res = NULL;
char char_buff[] = " ";
if (__iter_i < len) {
if (__iter_i < len)
{
char_buff[0] = str[__iter_i];
res = arg_newStr((char*)char_buff);
} else {
res = arg_newStr((char *)char_buff);
}
else
{
return arg_newNull();
}
args_setInt(self->list, "__iter_i", __iter_i + 1);
return res;
#endif
}
Arg* PikaStdData_String___getitem__(PikaObj* self, Arg* __key) {
Arg *PikaStdData_String___getitem__(PikaObj *self, Arg *__key)
{
int key_i = arg_getInt(__key);
char* str = obj_getStr(self, "str");
if (key_i < 0){
key_i = PikaStdData_String___len__(self) + key_i;
}
char *str = obj_getStr(self, "str");
uint16_t len = strGetSize(str);
char char_buff[] = " ";
if (key_i < len) {
char_buff[0] = str[key_i];
return arg_newStr((char*)char_buff);
} else {
#if PIKA_STRING_UTF8_ENABLE
char char_buff[5];
int r = _utf8_get(str, len, key_i, char_buff);
if (r < 0)
{
return arg_newNull();
}
return arg_newStr((char *)char_buff);
#else
char char_buff[] = " ";
if (key_i < len)
{
char_buff[0] = str[key_i];
return arg_newStr((char *)char_buff);
}
else
{
return arg_newNull();
}
#endif
}
void PikaStdData_String___setitem__(PikaObj* self, Arg* __key, Arg* __val) {
void PikaStdData_String___setitem__(PikaObj *self, Arg *__key, Arg *__val)
{
int key_i = arg_getInt(__key);
char* str = obj_getStr(self, "str");
char* val = arg_getStr(__val);
char *str = obj_getStr(self, "str");
char *val = arg_getStr(__val);
uint16_t len = strGetSize(str);
if (key_i >= len) {
#if PIKA_STRING_UTF8_ENABLE
int len2 = strlen(val);
int is_invalid = _valid_utf8(val, len2);
if (is_invalid >= 0)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error String invalid\r\n");
return;
}
int ulen_val = _utf8_strlen(val, len2);
if (ulen_val != 1)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error String invalid char\r\n");
return;
}
int char_len;
int repl_at = _utf8_get_offset(str, len, key_i, &char_len);
if (repl_at < 0)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error String Overflow\r\n");
return;
}
int ok = __str_repl(self, str, len, repl_at, char_len, val, len2);
if (ok < 0)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error. Internal error(-%d)\r\n", __LINE__);
return;
}
#else
if (key_i >= len)
{
obj_setErrorCode(self, 1);
__platform_printf("Error String Overflow\r\n");
return;
}
str[key_i] = val[0];
#endif
}
char* PikaStdData_String___str__(PikaObj* self) {
char *PikaStdData_String___str__(PikaObj *self)
{
return obj_getStr(self, "str");
}
int PikaStdData_String_startswith(PikaObj* self, char* prefix) {
char* str = obj_getStr(self, "str");
char* p = prefix;
int PikaStdData_String_startswith(PikaObj *self, char *prefix)
{
char *str = obj_getStr(self, "str");
char *p = prefix;
int i = 0;
while (*p != '\0') {
while (*p != '\0')
{
if (*p != str[i])
return 0;
p++;
@ -79,11 +173,13 @@ int PikaStdData_String_startswith(PikaObj* self, char* prefix) {
return 1;
}
int PikaStdData_String_endswith(PikaObj* self, char* suffix) {
char* str = obj_getStr(self, "str");
int PikaStdData_String_endswith(PikaObj *self, char *suffix)
{
char *str = obj_getStr(self, "str");
int len1 = strlen(str);
int len2 = strlen(suffix);
while (len2 >= 1) {
while (len2 >= 1)
{
if (suffix[len2 - 1] != str[len1 - 1])
return 0;
len2--;
@ -92,10 +188,12 @@ int PikaStdData_String_endswith(PikaObj* self, char* suffix) {
return 1;
}
int PikaStdData_String_isdigit(PikaObj* self) {
char* str = obj_getStr(self, "str");
int PikaStdData_String_isdigit(PikaObj *self)
{
char *str = obj_getStr(self, "str");
int i = 0;
while (str[i] != '\0') {
while (str[i] != '\0')
{
if (!isdigit((int)str[i]))
return 0;
i++;
@ -103,10 +201,12 @@ int PikaStdData_String_isdigit(PikaObj* self) {
return 1;
}
int PikaStdData_String_islower(PikaObj* self) {
char* str = obj_getStr(self, "str");
int PikaStdData_String_islower(PikaObj *self)
{
char *str = obj_getStr(self, "str");
int i = 0;
while (str[i] != '\0') {
while (str[i] != '\0')
{
if (!islower((int)str[i]))
return 0;
i++;
@ -114,10 +214,12 @@ int PikaStdData_String_islower(PikaObj* self) {
return 1;
}
int PikaStdData_String_isalnum(PikaObj* self) {
char* str = obj_getStr(self, "str");
int PikaStdData_String_isalnum(PikaObj *self)
{
char *str = obj_getStr(self, "str");
int i = 0;
while (str[i] != '\0') {
while (str[i] != '\0')
{
if (!isalnum((int)str[i]))
return 0;
i++;
@ -125,10 +227,12 @@ int PikaStdData_String_isalnum(PikaObj* self) {
return 1;
}
int PikaStdData_String_isalpha(PikaObj* self) {
char* str = obj_getStr(self, "str");
int PikaStdData_String_isalpha(PikaObj *self)
{
char *str = obj_getStr(self, "str");
int i = 0;
while (str[i] != '\0') {
while (str[i] != '\0')
{
if (!isalpha((int)str[i]))
return 0;
i++;
@ -136,10 +240,12 @@ int PikaStdData_String_isalpha(PikaObj* self) {
return 1;
}
int PikaStdData_String_isspace(PikaObj* self) {
char* str = obj_getStr(self, "str");
int PikaStdData_String_isspace(PikaObj *self)
{
char *str = obj_getStr(self, "str");
int i = 0;
while (str[i] != '\0') {
while (str[i] != '\0')
{
if (!isspace((int)str[i]))
return 0;
i++;
@ -147,22 +253,24 @@ int PikaStdData_String_isspace(PikaObj* self) {
return 1;
}
PikaObj* PikaStdData_String_split(PikaObj* self, char* s) {
PikaObj *PikaStdData_String_split(PikaObj *self, char *s)
{
/* 创建 list 对象 */
PikaObj* list = newNormalObj(New_PikaStdData_List);
PikaObj *list = newNormalObj(New_PikaStdData_List);
/* 初始化 list */
PikaStdData_List___init__(list);
Args buffs = {0};
char* str = strsCopy(&buffs, obj_getStr(self, "str"));
char *str = strsCopy(&buffs, obj_getStr(self, "str"));
char sign = s[0];
int token_num = strCountSign(str, sign) + 1;
for (int i = 0; i < token_num; i++) {
char* token = strsPopToken(&buffs, str, sign);
for (int i = 0; i < token_num; i++)
{
char *token = strsPopToken(&buffs, str, sign);
/* 用 arg_set<type> 的 api 创建 arg */
Arg* token_arg = arg_newStr(token);
Arg *token_arg = arg_newStr(token);
/* 添加到 list 对象 */
PikaStdData_List_append(list, token_arg);
/* 销毁 arg */
@ -173,25 +281,42 @@ PikaObj* PikaStdData_String_split(PikaObj* self, char* s) {
return list;
}
int PikaStdData_String___len__(PikaObj* self) {
char* str = obj_getStr(self, "str");
int PikaStdData_String___len__(PikaObj *self)
{
char *str = obj_getStr(self, "str");
#if PIKA_STRING_UTF8_ENABLE
int n = _utf8_strlen(str, -1);
if (n < 0)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error. Internal error(%d)\r\n", __LINE__);
return n;
}
return n;
#else
return strGetSize(str);
#endif
}
char* PikaStdData_String_strip(PikaObj* self) {
char *PikaStdData_String_strip(PikaObj *self)
{
Args buffs = {0};
char* str = strsCopy(&buffs, obj_getStr(self, "str"));
char *str = strsCopy(&buffs, obj_getStr(self, "str"));
/* strip */
char* str_start = str;
for (size_t i = 0; i < strGetSize(str); i++) {
if (str[i] != ' ') {
str_start = (char*)(str + i);
char *str_start = str;
for (size_t i = 0; i < strGetSize(str); i++)
{
if (str[i] != ' ')
{
str_start = (char *)(str + i);
break;
}
}
for (int i = strGetSize(str) - 1; i >= 0; i--) {
if (str[i] != ' ') {
for (int i = strGetSize(str) - 1; i >= 0; i--)
{
if (str[i] != ' ')
{
str[i + 1] = '\0';
break;
}
@ -202,17 +327,553 @@ char* PikaStdData_String_strip(PikaObj* self) {
return obj_getStr(self, "_buf");
}
char* PikaStdData_String_replace(PikaObj* self, char* old, char* new) {
char *PikaStdData_String_replace(PikaObj *self, char *old, char *new)
{
Args buffs = {0};
char* str = strsCopy(&buffs, obj_getStr(self, "str"));
char *str = strsCopy(&buffs, obj_getStr(self, "str"));
str = strsReplace(&buffs, str, old, new);
obj_setStr(self, "_buf", str);
strsDeinit(&buffs);
return obj_getStr(self, "_buf");
}
Arg* PikaStdData_String_encode(PikaObj* self) {
char* str = obj_getStr(self, "str");
Arg* arg = arg_newBytes((uint8_t*)str, strGetSize(str));
return arg;
Arg *PikaStdData_String_encode(PikaObj *self, PikaTuple *encoding)
{
char *str = obj_getStr(self, "str");
#if PIKA_STRING_UTF8_ENABLE
char *to_code = NULL;
int argn = tuple_getSize(encoding);
if (argn < 1)
{
return arg_newBytes((uint8_t *)str, strGetSize(str));
}
Arg *arg_i = tuple_getArg(encoding, 0);
if (arg_getType(arg_i) != ARG_TYPE_STRING)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error invaliad arguments\r\n");
return NULL;
}
to_code = arg_getStr(arg_i);
_strlwr(to_code);
Arg *res = _str_encode(str, to_code);
if (!res)
{
obj_setErrorCode(self, __LINE__);
__platform_printf("Error internal error\r\n");
return NULL;
}
return res;
#else
return arg_newBytes((uint8_t *)str, strGetSize(str));
#endif
}
#if PIKA_STRING_UTF8_ENABLE
static const uint8_t _pcre_utf8_table4[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5};
const char mask1 = 0x80;
const char mask2 = 0xc0;
const char mask3 = 0xe0;
const char mask4 = 0xf0;
const char nmask1 = 0x3f;
const char nmask2 = 0x1f;
const char nmask3 = 0x0f;
const char nmask4 = 0x07;
int _valid_utf8(const char *string, int length)
{
const uint8_t *p;
if (length < 0)
{
length = strlen(string);
}
for (p = (const uint8_t *)string; length-- > 0; p++)
{
int ab;
int c = *p;
if (!(c & 0x80))
continue;
if (c < 0xc0)
return (uintptr_t)p - (uintptr_t)string;
ab = _pcre_utf8_table4[c & 0x3f];
if (length < ab || ab > 3)
return (uintptr_t)p - (uintptr_t)string;
length -= ab;
if ((*(++p) & 0xc0) != 0x80)
return (uintptr_t)p - (uintptr_t)string;
switch (ab)
{
case 1:
if ((c & 0x3e) == 0)
return (uintptr_t)p - (uintptr_t)string;
continue;
case 2:
if ((c == 0xe0 && (*p & 0x20) == 0) ||
(c == 0xed && *p >= 0xa0))
return (uintptr_t)p - (uintptr_t)string;
break;
case 3:
if ((c == 0xf0 && (*p & 0x30) == 0) ||
(c > 0xf4) ||
(c == 0xf4 && *p > 0x8f))
return (uintptr_t)p - (uintptr_t)string;
break;
}
while (--ab > 0)
{
if ((*(++p) & 0xc0) != 0x80)
return (uintptr_t)p - (uintptr_t)string;
}
}
return -1;
}
int _utf8_get(const char *string, int length, int at, char *out_buf)
{
const uint8_t *p;
int ab, c;
if (length < 0)
{
length = strlen(string);
}
if (at < 0 || at >= length)
return -1;
for (p = (const uint8_t *)string; length > 0 && at; p++, at--)
{
c = *p;
if (!(c & 0x80))
{
length--;
continue;
}
ab = _pcre_utf8_table4[c & 0x3f];
p += ab++;
length -= ab;
}
if (at || length <= 0)
return -2;
c = *p;
if (!(c & 0x80))
{
*out_buf = c;
out_buf[1] = 0;
return 1;
};
ab = _pcre_utf8_table4[c & 0x3f] + 1;
__platform_memcpy(out_buf, p, ab);
out_buf[ab] = '\0';
return ab;
}
int _utf8_get_offset(const char *string, int length, int at, int *out_char_len)
{
const uint8_t *p;
int ab, c;
if (length < 0)
{
length = strlen(string);
}
if (at < 0 || at >= length)
return -1;
for (p = (const uint8_t *)string; length > 0 && at; p++, at--)
{
c = *p;
if (!(c & 0x80))
{
length--;
continue;
}
ab = _pcre_utf8_table4[c & 0x3f];
p += ab++;
length -= ab;
}
if (at)
return -2;
c = *p;
if (!(c & 0x80))
{
if (out_char_len)
*out_char_len = 1;
return (uintptr_t)p - (uintptr_t)string;
};
ab = _pcre_utf8_table4[c & 0x3f] + 1;
if (out_char_len)
*out_char_len = ab;
return (uintptr_t)p - (uintptr_t)string;
}
int _utf8_strlen(const char *string, int length)
{
const uint8_t *p;
int i, ab, c;
if (length < 0)
{
length = strlen(string);
}
for (i = 0, p = (const uint8_t *)string; length > 0; i++, p++)
{
c = *p;
if (!(c & 0x80))
{
length--;
continue;
}
ab = _pcre_utf8_table4[c & 0x3f];
p += ab++;
length -= ab;
}
if (length < 0)
return -1;
return i;
}
int __str_repl(PikaObj *self, char *str, int str_len, int repl_at, int repl_len, char *val, int val_len)
{
if (val_len > repl_len)
{
str[repl_at] = 0;
Arg *s_new = arg_newStr(str);
if (!s_new)
return -1;
s_new = arg_strAppend(s_new, val);
s_new = arg_strAppend(s_new, str + repl_at + repl_len);
obj_removeArg(self, "str");
int rs = obj_setArg(self, "str", s_new);
arg_deinit(s_new);
if (rs)
return -rs;
return 0;
}
char *s = str + repl_at;
__platform_memcpy(s, val, val_len);
__platform_memmove(s + val_len, s + repl_len, str_len - repl_at - repl_len + 1);
return 0;
}
int __utf8_to_utf32_char_LE(const char *utf8, char *out_buf)
{
char c = *utf8;
if (!(c & mask1))
{
*out_buf = c;
out_buf[1] = 0;
out_buf[2] = 0;
out_buf[3] = 0;
return 1;
}
int left_length = _pcre_utf8_table4[c & 0x3f];
char a, b, d;
switch (left_length)
{
case 1:
a = c & nmask2;
b = utf8[1] & nmask1;
out_buf[0] = b | a << 6;
out_buf[1] = a >> 2;
out_buf[2] = 0;
out_buf[3] = 0;
return 2;
case 2:
a = c & nmask3;
b = utf8[1] & nmask1;
c = utf8[2] & nmask1;
out_buf[0] = c | b << 6;
out_buf[1] = b >> 2 | a << 4;
out_buf[2] = 0;
out_buf[3] = 0;
return 3;
case 3:
a = c & nmask4;
b = utf8[1] & nmask1;
c = utf8[2] & nmask1;
d = utf8[3] & nmask1;
out_buf[0] = d | c << 6;
out_buf[1] = c >> 2 | b << 4;
out_buf[2] = b >> 4 | a << 2;
out_buf[3] = 0;
return 4;
default:
return 0;
}
}
int __utf8_to_utf32_LE_noBOM_get_size(const char *utf8, int len)
{
char *p = (char*) utf8;
char buf[4];
int space_sum = 0;
while (len > 0)
{
int size = __utf8_to_utf32_char_LE(p, buf);
if (!size)
return -1;
p += size;
len -= size;
space_sum++;
}
return space_sum * 4;
}
int __utf8_to_utf32_LE_noBOM(const char *utf8, int len, char *out_buf)
{
char *q = out_buf;
char *p = (char*) utf8;
while (len > 0)
{
int size = __utf8_to_utf32_char_LE(p, q);
if (!size)
return -1;
p += size;
len -= size;
q += 4;
}
return q - out_buf;
}
int __utf8_to_utf32_LE_withBOM(const char *utf8, int len, char *out_buf)
{
int size = __utf8_to_utf32_LE_noBOM(utf8, len, out_buf + 4);
if (size < 0)
{
return size;
}
out_buf[0] = '\xff';
out_buf[1] = '\xfe';
out_buf[2] = 0;
out_buf[3] = 0;
return size + 4;
}
int32_t __utf8_decode(const char *utf8, int left_length)
{
int ucode = -1;
char c = *utf8;
if (!(c & mask1))
{
return c;
}
char a, b, d;
switch (left_length)
{
case 1:
a = c & nmask2;
b = utf8[1] & nmask1;
ucode = b | (a & 0x03) << 6;
ucode |= (a >> 2) << 8;
break;
case 2:
a = c & nmask3;
b = utf8[1] & nmask1;
c = utf8[2] & nmask1;
ucode = c | (b & 0x03) << 6;
ucode |= (b >> 2 | a << 4) << 8;
break;
case 3:
a = c & nmask4;
b = utf8[1] & nmask1;
c = utf8[2] & nmask1;
d = utf8[3] & nmask1;
ucode = d | (c & 0x03) << 6;
ucode |= (c >> 2 | (b & 0x0f) << 4) << 8;
ucode |= (b >> 4 | a << 2) << 16;
break;
default:
return -1;
}
return ucode;
}
int __unicode_to_utf16_char_LE(int32_t u, char *out_buf)
{
if (!(u & 0xffff0000))
{
out_buf[0] = u & 0xff;
out_buf[1] = (u & 0xff00) >> 8;
return 2;
}
int32_t d = u - 0x10000;
int32_t L = d & 0x3ff;
int32_t U = d >> 10;
L = L | 0xdc00;
U = U | 0xd800;
out_buf[0] = U & 0xff;
out_buf[1] = (U & 0xff00) >> 8;
out_buf[2] = L & 0xff;
out_buf[3] = (L & 0xff00) >> 8;
return 4;
}
int __utf8_to_utf16_LE_noBOM(const char *utf8, int len, char *out_buf)
{
char *q = out_buf;
char *p = (char*) utf8;
while (len > 0)
{
char c = *p;
int32_t ucode;
if (!(c & mask1))
{
ucode = c;
p++;
len--;
}
else
{
int left_size = _pcre_utf8_table4[c & 0x3f];
ucode = __utf8_decode(p, left_size++);
if (ucode < 0)
return ucode;
p += left_size;
len -= left_size;
}
int size = __unicode_to_utf16_char_LE(ucode, q);
q += size;
}
return q - out_buf;
}
int __utf8_to_utf16_LE_noBOM_get_size(const char *utf8, int len)
{
char out_buf[4];
char *p = (char*) utf8;
int need_space = 0;
while (len > 0)
{
char c = *p;
int32_t ucode;
if (!(c & mask1))
{
ucode = c;
p++;
len--;
}
else
{
int left_size = _pcre_utf8_table4[c & 0x3f];
ucode = __utf8_decode(p, left_size++);
if (ucode < 0)
return ucode;
p += left_size;
len -= left_size;
}
int size = __unicode_to_utf16_char_LE(ucode, out_buf);
need_space += size;
}
return need_space;
}
int __utf8_to_utf16_LE_withBOM(const char *utf8, int len, char *out_buf)
{
int size = __utf8_to_utf16_LE_noBOM(utf8, len, out_buf + 2);
if (size < 0)
{
return size;
}
out_buf[0] = '\xff';
out_buf[1] = '\xfe';
return size + 2;
}
Arg *_str_encode(char *str, char *encoding)
{
if (strEqu(encoding, "utf-8"))
{
return arg_newBytes((uint8_t *)str, strGetSize(str));
}
int len = strlen(str);
if (strEqu(encoding, "ascii"))
{
int ulen = _utf8_strlen(str, len);
if (ulen == len)
{
return arg_newBytes((uint8_t *)str, strGetSize(str));
}
__platform_printf("Warning there is non-ascii characters\r\n");
char *b = (char *)pikaMalloc(len + 1);
if (!b)
{
return NULL;
}
char *p = str;
char *q = b;
char c = *p++;
while (c)
{
if (!(c & 0x80))
{
*q++ = c;
}
c = *p++;
}
*q = 0;
Arg *arg = arg_newBytes((uint8_t *)b, strGetSize(b));
pikaFree(b, len + 1);
return arg;
}
if (strEqu(encoding, "utf-16"))
{
int size_needed = __utf8_to_utf16_LE_noBOM_get_size(str, len);
if (size_needed <= 0)
{
return NULL;
}
size_needed += 2;
char *b = (char *)pikaMalloc(size_needed);
if (!b)
{
return NULL;
}
int ok = __utf8_to_utf16_LE_withBOM(str, len, b);
if (ok < 0)
{
pikaFree(b, size_needed);
return NULL;
}
Arg *arg = arg_newBytes((uint8_t *)b, size_needed);
pikaFree(b, size_needed);
return arg;
}
if (strEqu(encoding, "utf-32"))
{
int size_needed = __utf8_to_utf32_LE_noBOM_get_size(str, len);
if (size_needed <= 0)
{
return NULL;
}
size_needed += 4;
char *b = (char *)pikaMalloc(size_needed);
if (!b)
{
return NULL;
}
int ok = __utf8_to_utf32_LE_withBOM(str, len, b);
if (ok < 0)
{
pikaFree(b, size_needed);
return NULL;
}
Arg *arg = arg_newBytes((uint8_t *)b, size_needed);
pikaFree(b, size_needed);
return arg;
}
return NULL;
}
char* _strlwr(char *str)
{
int i = 0;
while (str[i] != '\0')
{
str[i] = tolower((int)str[i]);
i++;
}
return str;
}
#endif

21
port/cmsis-pack/pikascript/pikascript-lib/PikaStdLib/PikaStdData_String_Util.h
View File

@ -1 +1,20 @@
#include<ctype.h>
#include <ctype.h>
#if PIKA_STRING_UTF8_ENABLE
int _valid_utf8(const char *string, int length);
int _utf8_get(const char *string, int length, int at, char *out_buf);
int _utf8_get_offset(const char *string, int length, int at, int *out_char_len);
int _utf8_strlen(const char *string, int length);
int __str_repl(PikaObj *self, char *str, int str_len, int repl_at, int repl_len, char *val, int val_len);
int __utf8_to_utf32_LE_withBOM(const char *utf8, int len, char *out_buf);
int __utf8_to_utf32_LE_noBOM(const char *utf8, int len, char *out_buf);
int __utf8_to_utf32_LE_noBOM_get_size(const char *utf8, int len);
int __utf8_to_utf16_LE_withBOM(const char *utf8, int len, char *out_buf);
int __utf8_to_utf16_LE_noBOM(const char *utf8, int len, char *out_buf);
int __utf8_to_utf16_LE_noBOM_get_size(const char *utf8, int len);
Arg* _str_encode(char*str, char*encoding);
#endif

11
port/cmsis-pack/pikascript/pikascript-lib/PikaStdLib/PikaStdData_Tuple.c
View File

@ -74,3 +74,14 @@ char* PikaStdData_Tuple___str__(PikaObj* self) {
int PikaStdData_Tuple___len__(PikaObj* self) {
return PikaStdData_Tuple_len(self);
}
int PikaStdData_Tuple___contains__(PikaObj* self, Arg* val) {
PikaList* list = obj_getPtr(self, "list");
for (size_t i = 0; i < list_getSize(list); i++) {
Arg* arg = list_getArg(list, i);
if (arg_isEqual(arg, val)) {
return 1;
}
}
return 0;
}

12
port/cmsis-pack/pikascript/pikascript-lib/PikaStdLib/PikaStdLib_RangeObj.c
View File

@ -1,14 +1,10 @@
#include "PikaObj.h"
Arg* PikaStdLib_RangeObj___next__(PikaObj* self) {
int a1 = args_getInt(self->list, "a1");
int a2 = args_getInt(self->list, "a2");
int start = 0;
int end = 0;
int foot = 1;
int start = args_getInt(self->list, "_start");
int end = args_getInt(self->list, "_end");
int step = args_getInt(self->list, "_step");
/* only start and end */
start = a1;
end = a2;
/* start */
int iter_i = args_getInt(self->list, "iter_i");
/* iter_i is not inited */
@ -19,6 +15,6 @@ Arg* PikaStdLib_RangeObj___next__(PikaObj* self) {
if (iter_i >= end) {
return arg_newNull();
}
args_setInt(self->list, "iter_i", iter_i + foot);
args_setInt(self->list, "iter_i", iter_i + step);
return arg_newInt(iter_i);
}

71
port/cmsis-pack/pikascript/pikascript-lib/PikaStdLib/PikaStdLib_SysObj.c
View File

@ -184,11 +184,30 @@ Arg* PikaStdLib_SysObj_iter(PikaObj* self, Arg* arg) {
return arg_newNull();
}
Arg* PikaStdLib_SysObj_range(PikaObj* self, int a1, int a2) {
Arg* PikaStdLib_SysObj_range(PikaObj* self, PikaTuple* ax) {
/* set template arg to create rangeObj */
Arg* obj_arg = arg_newDirectObj(New_PikaStdLib_RangeObj);
obj_setInt(arg_getPtr(obj_arg), "a1", a1);
obj_setInt(arg_getPtr(obj_arg), "a2", a2);
PikaObj* range_obj = arg_getPtr(obj_arg);
if (tuple_getSize(ax) == 1) {
int start = 0;
int end = arg_getInt(tuple_getArg(ax, 0));
obj_setInt(range_obj, "_start", start);
obj_setInt(range_obj, "_end", end);
obj_setInt(range_obj, "_step", 1);
} else if (tuple_getSize(ax) == 2) {
int start = arg_getInt(tuple_getArg(ax, 0));
int end = arg_getInt(tuple_getArg(ax, 1));
obj_setInt(range_obj, "_start", start);
obj_setInt(range_obj, "_end", end);
obj_setInt(range_obj, "_step", 1);
} else if (tuple_getSize(ax) == 3) {
int start = arg_getInt(tuple_getArg(ax, 0));
int end = arg_getInt(tuple_getArg(ax, 1));
int step = arg_getInt(tuple_getArg(ax, 2));
obj_setInt(range_obj, "_start", start);
obj_setInt(range_obj, "_end", end);
obj_setInt(range_obj, "_step", step);
}
return obj_arg;
}
@ -363,20 +382,18 @@ Arg* PikaStdLib_SysObj___slice__(PikaObj* self,
return __vm_slice(self, end, obj, start, step);
}
static void __print_arg(PikaObj* self, Arg* val) {
static char* __print_arg(PikaObj* self, Arg* val) {
obj_setErrorCode(self, 0);
ArgType arg_type = arg_getType(val);
if (NULL != val) {
if (arg_getType(val) == ARG_TYPE_BYTES) {
arg_printBytes(val);
return;
return __printBytes(self, val);
}
}
if (argType_isObject(arg_type)) {
char* to_str = obj_toStr(arg_getPtr(val));
if (NULL != to_str) {
__platform_printf("%s\r\n", to_str);
return;
return obj_cacheStr(self, to_str);
}
}
Args* print_args = New_args(NULL);
@ -387,51 +404,39 @@ static void __print_arg(PikaObj* self, Arg* val) {
obj_setSysOut(self, "Error: can not print val");
obj_setErrorCode(self, 1);
args_deinit(print_args);
return;
return NULL;
}
obj_setStr(self, "_buf", res);
res = obj_cacheStr(self, res);
args_deinit(print_args);
return res;
}
void PikaStdLib_SysObj_print(PikaObj* self, PikaTuple* val) {
void PikaStdLib_SysObj_print(PikaObj* self, PikaTuple* val, PikaDict* ops) {
int arg_size = tuple_getSize(val);
Arg* print_out_arg = arg_newStr("");
PIKA_BOOL is_get_print = PIKA_FALSE;
for (int i = 0; i < arg_size; i++) {
Arg* arg = tuple_getArg(val, i);
__print_arg(self, arg);
char* item = obj_getStr(self, "_buf");
char* item = __print_arg(self, arg);
if (NULL != item) {
is_get_print = PIKA_TRUE;
print_out_arg = arg_strAppend(print_out_arg, item);
if (i < arg_size - 1) {
print_out_arg = arg_strAppend(print_out_arg, " ");
}
obj_removeArg(self, "_buf");
}
}
char* end = dict_getStr(ops, "end");
if (NULL == end) {
/* default */
end = "\r\n";
}
if (PIKA_TRUE == is_get_print) {
__platform_printf("%s\r\n", arg_getStr(print_out_arg));
__platform_printf("%s%s", arg_getStr(print_out_arg), end);
}
arg_deinit(print_out_arg);
}
void PikaStdLib_SysObj_printNoEnd(PikaObj* self, Arg* val) {
obj_setErrorCode(self, 0);
Args* print_args = New_args(NULL);
args_setArg(print_args, arg_copy(val));
char* res = args_print(print_args, "val");
if (NULL == res) {
obj_setSysOut(self, "Error: print: can not print val");
obj_setErrorCode(self, 1);
args_deinit(print_args);
return;
}
/* not empty */
__platform_printf("%s", res);
args_deinit(print_args);
}
char* PikaStdLib_SysObj_cformat(PikaObj* self, char* fmt, PikaTuple* var) {
#if PIKA_SYNTAX_FORMAT_ENABLE
Args buffs = {0};
@ -533,3 +538,7 @@ void PikaStdLib_SysObj_setattr(PikaObj* self,
exit:
return;
}
void PikaStdLib_SysObj_exit(PikaObj *self){
pks_vm_exit();
}

BIN
port/cmsis-pack/pikascript/rust-msc-latest-win10.exe
View File

Binary file not shown.