/*

* This file is part of the PikaPython project.

* http://github.com/pikastech/pikapython

*

* MIT License

*

* Copyright (c) 2021 lyon liang6516@outlook.com

* Copyright (c) 2023 Gorgon Meducer embedded_zhuroan@hotmail.com

*

* Permission is hereby granted, free of charge, to any person obtaining a

* copy of this software and associated documentation files (the "Software"),

* to deal in the Software without restriction, including without limitation

* the rights to use, copy, modify, merge, publish, distribute, sublicense,

* and/or sell copies of the Software, and to permit persons to whom the

* Software is furnished to do so, subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included in

* all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

* DEALINGS IN THE SOFTWARE.

*/

#include "PikaObj.h"

#include <stdint.h>

#include <inttypes.h>

#include "BaseObj.h"

#include "PikaCompiler.h"

#include "PikaParser.h"

#include "PikaPlatform.h"

#include "dataArg.h"

#include "dataArgs.h"

#include "dataMemory.h"

#include "dataQueue.h"

#include "dataString.h"

#include "dataStrs.h"

#if __linux

#include "signal.h"

#include "termios.h"

#include "unistd.h"

#endif

extern volatile VMState g_PikaVMState;

volatile PikaObjState g_PikaObjState = {

.helpModulesCmodule = NULL,

.inRootObj = pika_false,

#if PIKA_GC_MARK_SWEEP_ENABLE

.objCnt = 0,

.objCntMax = 0,

.objCntLastGC = 0,

.gcChain = NULL,

.markSweepBusy = 0,

#endif

};

extern volatile PikaObj* __pikaMain;

static volatile ShellConfig g_REPL;

PikaObj* New_PikaStdData_Dict(Args* args);

PikaObj* New_PikaStdData_dict_keys(Args* args);

PikaObj* New_PikaStdData_List(Args* args);

PikaObj* New_PikaStdData_Tuple(Args* args);

void PikaStdData_Tuple___init__(PikaObj* self);

void PikaStdData_List___init__(PikaObj* self);

void PikaStdData_List_append(PikaObj* self, Arg* arg);

void PikaStdData_Dict_set(PikaObj* self, char* key, Arg* value);

void PikaStdData_Dict___init__(PikaObj* self);

void _mem_cache_deinit(void);

void _VMEvent_deinit(void);

void pikaGC_markObj(PikaGC* gc, PikaObj* self);

void _pikaGC_mark(PikaGC* gc);

void obj_dump(PikaObj* self);

void Locals_deinit(PikaObj* self);

#if __linux

static void disable_raw_mode(void);

#endif

static enum shellCTRL __obj_shellLineHandler_REPL(PikaObj* self,

char* input_line,

ShellConfig* shell);

static const uint64_t __talbe_fast_atoi[][10] = {

{0, 1e0, 2e0, 3e0, 4e0, 5e0, 6e0, 7e0, 8e0, 9e0},

{0, 1e1, 2e1, 3e1, 4e1, 5e1, 6e1, 7e1, 8e1, 9e1},

{0, 1e2, 2e2, 3e2, 4e2, 5e2, 6e2, 7e2, 8e2, 9e2},

{0, 1e3, 2e3, 3e3, 4e3, 5e3, 6e3, 7e3, 8e3, 9e3},

{0, 1e4, 2e4, 3e4, 4e4, 5e4, 6e4, 7e4, 8e4, 9e4},

{0, 1e5, 2e5, 3e5, 4e5, 5e5, 6e5, 7e5, 8e5, 9e5},

{0, 1e6, 2e6, 3e6, 4e6, 5e6, 6e6, 7e6, 8e6, 9e6},

{0, 1e7, 2e7, 3e7, 4e7, 5e7, 6e7, 7e7, 8e7, 9e7},

{0, 1e8, 2e8, 3e8, 4e8, 5e8, 6e8, 7e8, 8e8, 9e8},

{0, 1e9, 2e9, 3e9, 4e9, 5e9, 6e9, 7e9, 8e9, 9e9},

};

int64_t fast_atoi(char* src) {

const char* p = src;

uint16_t size = strGetSize(src);

p = p + size - 1;

if (*p) {

int64_t s = 0;

const uint64_t* n = __talbe_fast_atoi[0];

while (p != src) {

s += n[(*p - '0')];

n += 10;

p--;

}

if (*p == '-') {

return -s;

}

return s + n[(*p - '0')];

}

return 0;

}

PIKA_RES fast_atoi_safe(char* src, int64_t* out) {

// Check is digit

char* p = src;

while (*p) {

if (*p < '0' || *p > '9') {

return PIKA_RES_ERR_INVALID_PARAM;

}

p++;

}

*out = fast_atoi(src);

return PIKA_RES_OK;

}

static uint16_t const str100p[100] = {

0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830,

0x3930, 0x3031, 0x3131, 0x3231, 0x3331, 0x3431, 0x3531, 0x3631, 0x3731,

0x3831, 0x3931, 0x3032, 0x3132, 0x3232, 0x3332, 0x3432, 0x3532, 0x3632,

0x3732, 0x3832, 0x3932, 0x3033, 0x3133, 0x3233, 0x3333, 0x3433, 0x3533,

0x3633, 0x3733, 0x3833, 0x3933, 0x3034, 0x3134, 0x3234, 0x3334, 0x3434,

0x3534, 0x3634, 0x3734, 0x3834, 0x3934, 0x3035, 0x3135, 0x3235, 0x3335,

0x3435, 0x3535, 0x3635, 0x3735, 0x3835, 0x3935, 0x3036, 0x3136, 0x3236,

0x3336, 0x3436, 0x3536, 0x3636, 0x3736, 0x3836, 0x3936, 0x3037, 0x3137,

0x3237, 0x3337, 0x3437, 0x3537, 0x3637, 0x3737, 0x3837, 0x3937, 0x3038,

0x3138, 0x3238, 0x3338, 0x3438, 0x3538, 0x3638, 0x3738, 0x3838, 0x3938,

0x3039, 0x3139, 0x3239, 0x3339, 0x3439, 0x3539, 0x3639, 0x3739, 0x3839,

0x3939,

};

char* fast_itoa(char* buf, uint32_t val) {

char* p = &buf[10];

*p = '\0';

while (val >= 100) {

uint32_t const old = val;

p -= 2;

val /= 100;

pika_platform_memcpy(p, &str100p[old - (val * 100)], sizeof(uint16_t));

}

p -= 2;

pika_platform_memcpy(p, &str100p[val], sizeof(uint16_t));

return &p[val < 10];

}

static int32_t obj_deinit_no_del(PikaObj* self) {

/* free the list */

Locals_deinit(self);

args_deinit_ex(self->list, pika_true);

#if PIKA_KERNAL_DEBUG_ENABLE

if (NULL != self->aName) {

arg_deinit(self->aName);

}

#endif

/* remove self from gc chain */

obj_removeGcChain(self);

/* free the pointer */

pikaFree(self, sizeof(PikaObj));

if (self == (PikaObj*)__pikaMain) {

__pikaMain = NULL;

}

return 0;

}

int obj_GC(PikaObj* self) {

if (!obj_checkAlive(self)) {

return 0;

}

if (obj_getFlag(self, OBJ_FLAG_IN_DEL)) {

/* in __del__, skip gc */

return 0;

}

obj_refcntDec(self);

int ref_cnt = obj_refcntNow(self);

if (ref_cnt <= 0) {

obj_deinit(self);

}

return 0;

}

int32_t obj_deinit(PikaObj* self) {

pikaGC_lock();

pika_bool bisRoot = pika_false;

#if PIKA_KERNAL_DEBUG_ENABLE

self->isAlive = pika_false;

#endif

Arg* del = obj_getMethodArgWithFullPath(self, "__del__");

if (NULL != del) {

obj_setFlag(self, OBJ_FLAG_IN_DEL);

Arg* aRes = obj_runMethodArg0(self, del);

if (NULL != aRes) {

arg_deinit(aRes);

}

}

extern volatile PikaObj* __pikaMain;

if (self == (PikaObj*)__pikaMain) {

bisRoot = pika_true;

_mem_cache_deinit();

#if PIKA_EVENT_ENABLE

_VMEvent_deinit();

#endif

if (NULL != g_PikaObjState.helpModulesCmodule) {

arg_deinit(g_PikaObjState.helpModulesCmodule);

g_PikaObjState.helpModulesCmodule = NULL;

}

}

int32_t ret = obj_deinit_no_del(self);

pikaGC_unlock();

if (bisRoot) {

pikaGC_markSweep();

shConfig_deinit((ShellConfig*)&g_REPL);

#if __linux

disable_raw_mode();

pika_GIL_deinit();

#endif

}

return ret;

}

PIKA_RES obj_setInt(PikaObj* self, char* argPath, int64_t val) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

/* [error] object no found */

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

args_setInt(obj->list, name, val);

return PIKA_RES_OK;

}

PIKA_RES obj_setPtr(PikaObj* self, char* argPath, void* pointer) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

/* [error] object no found */

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

args_setPtr(obj->list, name, pointer);

return PIKA_RES_OK;

}

PIKA_RES obj_setRef(PikaObj* self, char* argPath, PikaObj* pointer) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

/* [error] object no found */

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

args_setRef(obj->list, name, pointer);

return PIKA_RES_OK;

}

PIKA_RES obj_setFloat(PikaObj* self, char* argPath, pika_float value) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

/* [error] object no found */

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

args_setFloat(obj->list, name, value);

return PIKA_RES_OK;

}

PIKA_RES obj_setStr(PikaObj* self, char* argPath, char* str) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

return args_setStr(obj->list, name, str);

}

PIKA_RES obj_setNone(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

args_setNone(obj->list, name);

return PIKA_RES_OK;

}

PIKA_RES obj_setBytes(PikaObj* self, char* argPath, uint8_t* src, size_t size) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* name = strPointToLastToken(argPath, '.');

args_setBytes(obj->list, name, src, size);

return PIKA_RES_OK;

}

int64_t obj_getInt(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return _PIKA_INT_ERR;

}

char* argName = strPointToLastToken(argPath, '.');

int64_t res = args_getInt(obj->list, argName);

return res;

}

pika_bool obj_getBool(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return pika_false;

}

char* argName = strPointToLastToken(argPath, '.');

pika_bool res = args_getBool(obj->list, argName);

return res;

}

Arg* obj_getArg(PikaObj* self, char* argPath) {

pika_assert(obj_checkAlive(self));

pika_bool is_temp = pika_false;

PikaObj* obj = obj_getHostObjWithIsTemp(self, argPath, &is_temp);

if (NULL == obj) {

return NULL;

}

Arg* res = NULL;

char* argName = strPointToLastToken(argPath, '.');

res = args_getArg(obj->list, argName);

if (is_temp) {

obj_setArg(self, "_buf", res);

res = obj_getArg(self, "_buf");

obj_deinit(obj);

}

return res;

}

uint8_t* obj_getBytes(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return NULL;

}

char* argName = strPointToLastToken(argPath, '.');

return args_getBytes(obj->list, argName);

}

size_t obj_getBytesSize(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return 0;

}

char* argName = strPointToLastToken(argPath, '.');

return args_getBytesSize(obj->list, argName);

}

size_t obj_loadBytes(PikaObj* self, char* argPath, uint8_t* out_buff) {

size_t size_mem = obj_getBytesSize(self, argPath);

void* src = obj_getBytes(self, argPath);

if (0 == size_mem) {

return 0;

}

if (NULL == src) {

return 0;

}

pika_platform_memcpy(out_buff, src, size_mem);

return size_mem;

}

void obj_setName(PikaObj* self, char* name) {

#if !PIKA_KERNAL_DEBUG_ENABLE

return;

#else

if (strEqu(name, "self")) {

return;

}

if (NULL != self->aName) {

if (!strstr(self->name, name)) {

self->aName = arg_strAppend(self->aName, "|");

self->aName = arg_strAppend(self->aName, name);

}

} else {

self->aName = arg_newStr(name);

}

self->name = arg_getStr(self->aName);

#endif

}

static PIKA_RES _obj_setArg(PikaObj* self,

char* argPath,

Arg* arg,

uint8_t is_copy) {

pika_assert(obj_checkAlive(self));

/* setArg would copy arg */

PikaObj* host = obj_getHostObj(self, argPath);

PikaObj* oNew = NULL;

pika_bool bNew = pika_false;

if (NULL == host) {

/* object no found */

return PIKA_RES_ERR_ARG_NO_FOUND;

}

char* sArgName = strPointToLastToken(argPath, '.');

Arg* aNew;

if (is_copy) {

aNew = arg_copy(arg);

} else {

aNew = arg;

}

aNew = arg_setName(aNew, sArgName);

if (arg_isObject(aNew)) {

oNew = arg_getPtr(aNew);

bNew = pika_true;

pika_assert(obj_checkAlive(oNew));

#if PIKA_KERNAL_DEBUG_ENABLE

if (host != oNew) {

/* skip self ref */

oNew->parent = host;

}

#endif

obj_setName(oNew, sArgName);

}

#if 0

if (argType_isObjectMethodActive(arg_getType(arg))) {

PikaObj* host_self = methodArg_getHostObj(arg);

obj_refcntInc(host_self);

}

#endif

args_setArg(host->list, aNew);

/* enable mark sweep to collect this object */

if (bNew) {

/* only enable mark sweep after setArg */

obj_enableGC(oNew);

}

return PIKA_RES_OK;

}

PIKA_RES obj_setArg(PikaObj* self, char* argPath, Arg* arg) {

return _obj_setArg(self, argPath, arg, 1);

};

PIKA_RES obj_setArg_noCopy(PikaObj* self, char* argPath, Arg* arg) {

return _obj_setArg(self, argPath, arg, 0);

}

PIKA_RES obj_setObj(PikaObj* self, char* argPath, PikaObj* obj) {

Arg* arg = arg_newObj(obj);

return obj_setArg_noCopy(self, argPath, arg);

}

void* obj_getPtr(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return NULL;

}

char* argName = strPointToLastToken(argPath, '.');

void* res = args_getPtr(obj->list, argName);

return res;

}

pika_float obj_getFloat(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return -999.999;

}

char* argName = strPointToLastToken(argPath, '.');

pika_float res = args_getFloat(obj->list, argName);

return res;

}

char* obj_getStr(PikaObj* self, char* argPath) {

PikaObj* obj = obj_getHostObj(self, argPath);

if (NULL == obj) {

return NULL;

}

char* argName = strPointToLastToken(argPath, '.');

char* res = args_getStr(obj->list, argName);

return res;

}

PikaObj* obj_newObjFromConstructor(PikaObj* context,

char* name,

NewFun constructor) {

PikaObj* self = constructor(NULL);

self->constructor = constructor;

self->refcnt = 1;

return self;

}

static PikaObj* _pika_new_obj_with_args(PikaObj* (*constructor)(),

void (*init_func)(PikaObj*),

int num_args,

va_list args) {

PikaObj* obj = newNormalObj(constructor);

init_func(obj);

if (constructor == New_PikaStdData_Tuple ||

constructor == New_PikaStdData_List) {

for (int i = 0; i < num_args; i++) {

Arg* arg = va_arg(args, Arg*);

if (num_args == 1 && NULL == arg) {

/* empty tuple */

return obj;

}

pikaList_append(obj, arg);

}

} else if (constructor == New_PikaStdData_Dict) {

if (num_args == 1) {

/* empty dict */

return obj;

}

for (int i = 0; i + 1 < num_args; i += 2) {

Arg* aKey = va_arg(args, Arg*);

char* sKey = arg_getStr(aKey);

Arg* value = va_arg(args, Arg*);

pikaDict_set(obj, sKey, value);

arg_deinit(aKey);

}

}

return obj;

}

PikaObj* _pika_tuple_new(int num_args, ...) {

va_list args;

va_start(args, num_args);

PikaObj* tuple = _pika_new_obj_with_args(

New_PikaStdData_Tuple, PikaStdData_Tuple___init__, num_args, args);

va_end(args);

return tuple;

}

PikaObj* _pika_list_new(int num_args, ...) {

va_list args;

va_start(args, num_args);

PikaObj* list = _pika_new_obj_with_args(

New_PikaStdData_List, PikaStdData_List___init__, num_args, args);

va_end(args);

return list;

}

PikaObj* _pika_dict_new(int num_args, ...) {

va_list args;

va_start(args, num_args);

PikaObj* dict = _pika_new_obj_with_args(

New_PikaStdData_Dict, PikaStdData_Dict___init__, num_args, args);

va_end(args);

return dict;

}

NativeProperty* obj_getProp(PikaObj* self) {

Arg* aProp = obj_getArg(self, "@p_");

PikaObj* class_obj = NULL;

if (NULL == aProp) {

if (NULL != self->constructor) {

class_obj = obj_getClassObj(self);

aProp = obj_getArg(class_obj, "@p_");

}

}

NativeProperty* prop = NULL;

if (aProp == NULL) {

goto __exit;

}

if (arg_getType(aProp) != ARG_TYPE_POINTER) {

goto __exit;

}

prop = (NativeProperty*)arg_getPtr(aProp);

__exit:

if (NULL != class_obj) {

obj_deinit_no_del(class_obj);

}

return prop;

}

Arg* _obj_getPropArg(PikaObj* obj, char* name) {

NativeProperty* prop = obj_getProp(obj);

Hash method_hash = hash_time33(name);

Arg* aMethod = NULL;

while (1) {

if (prop == NULL) {

break;

}

int size = prop->methodGroupCount;

pika_assert(size >= 0);

/* binary search */

if (size == 0) {

goto __next;

}

#if !PIKA_NANO_ENABLE

if (size > 16) {

int left = 0;

int right = size - 1;

int mid = 0;

while (1) {

if (left > right) {

break;

}

mid = (right + left) >> 1;

Arg* prop_this = (Arg*)(prop->methodGroup + mid);

if (prop_this->name_hash == method_hash) {

aMethod = prop_this;

goto __exit;

} else if (prop_this->name_hash < method_hash) {

left = mid + 1;

} else {

right = mid - 1;

}

}

goto __next;

}

#endif

for (int i = 0; i < (int)prop->methodGroupCount; i++) {

Arg* prop_this = (Arg*)(prop->methodGroup + i);

if (prop_this->name_hash == method_hash) {

aMethod = prop_this;

goto __exit;

}

}

goto __next;

__next:

prop = (NativeProperty*)prop->super;

}

__exit:

return aMethod;

}

Arg* _obj_getMethodArg(PikaObj* obj, char* methodName, Arg* arg_reg) {

Arg* aMethod = NULL;

aMethod = obj_getArg(obj, methodName);

if (NULL != aMethod) {

aMethod = arg_copy_noalloc(aMethod, arg_reg);

goto __exit;

}

aMethod = _obj_getPropArg(obj, methodName);

__exit:

return aMethod;

}

Arg* _obj_getMethodArgWithFullPath(PikaObj* obj,

char* methodPath,

Arg* arg_reg) {

char* methodName = strPointToLastToken(methodPath, '.');

return _obj_getMethodArg(obj, methodName, arg_reg);

}

Arg* obj_getMethodArgWithFullPath(PikaObj* obj, char* methodPath) {

return _obj_getMethodArgWithFullPath(obj, methodPath, NULL);

}

Arg* obj_getMethodArgWithFullPath_noalloc(PikaObj* obj,

char* methodPath,

Arg* arg_reg) {

return _obj_getMethodArgWithFullPath(obj, methodPath, arg_reg);

}

Arg* obj_getMethodArg(PikaObj* obj, char* methodName) {

return _obj_getMethodArg(obj, methodName, NULL);

}

Arg* obj_getMethodArg_noalloc(PikaObj* obj, char* methodName, Arg* arg_reg) {

return _obj_getMethodArg(obj, methodName, arg_reg);

}

NewFun obj_getClass(PikaObj* obj) {

return (NewFun)obj->constructor;

}

PikaObj* obj_getClassObj(PikaObj* obj) {

NewFun classPtr = obj_getClass(obj);

if (NULL == classPtr) {

return NULL;

}

PikaObj* classObj = obj_newObjFromConstructor(obj, "", classPtr);

return classObj;

}

void* getNewClassObjFunByName(PikaObj* obj, char* name) {

char* classPath = name;

/* init the subprocess */

void* newClassObjFun = args_getPtr(obj->list, classPath);

return newClassObjFun;

}

PikaObj* removeMethodInfo(PikaObj* thisClass) {

#if PIKA_METHOD_CACHE_ENABLE

#else

args_removeArg(thisClass->list, args_getArg(thisClass->list, "@p_"));

#endif

return thisClass;

}

PikaObj* newNormalObj(NewFun newObjFun) {

PikaObj* thisClass = obj_newObjFromConstructor(NULL, "", newObjFun);

obj_setFlag(thisClass, OBJ_FLAG_ALREADY_INIT);

return removeMethodInfo(thisClass);

}

#ifdef __linux

#include <errno.h>

#include <stdio.h>

#include <termios.h>

#include <unistd.h>

#define ECHOFLAGS (ECHO | ECHOE | ECHOK | ECHONL)

static int set_disp_mode(int fd, int option) {

int err;

struct termios term;

if (tcgetattr(fd, &term) == -1) {

perror("Cannot get the attribution of the terminal");

return 1;

}

if (option)

term.c_lflag |= ECHOFLAGS;

else

term.c_lflag &= ~ECHOFLAGS;

err = tcsetattr(fd, TCSAFLUSH, &term);

if (err == -1) {

perror("Cannot set the attribution of the terminal");

return 1;

}

return 0;

}

#endif

static volatile uint8_t logo_printed = 0;

#if __linux

struct termios original_termios;

static void enable_raw_mode(void) {

struct termios raw;

tcgetattr(STDIN_FILENO, &original_termios);

raw = original_termios;

raw.c_lflag &= ~(ECHO | ICANON);

tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);

}

static void disable_raw_mode(void) {

tcsetattr(STDIN_FILENO, TCSAFLUSH, &original_termios);

printf("\n");

}

static void signal_handler(int sig) {

if (sig == SIGSEGV) {

printf("Segmentation fault");

} else if (sig == SIGINT) {

printf("Ctrl+C");

} else if (sig == SIGTERM) {

printf("SIGTERM");

} else if (sig == SIGHUP) {

printf("SIGHUP");

} else if (sig == SIGABRT) {

printf("Aborted");

}

disable_raw_mode();

exit(1);

}

#endif

extern volatile PikaObj* __pikaMain;

PikaObj* newRootObj(char* name, NewFun newObjFun) {

g_PikaObjState.inRootObj = pika_true;

#if PIKA_POOL_ENABLE

mem_pool_init();

#endif

#ifdef __linux

signal(SIGTERM, signal_handler);

signal(SIGHUP, signal_handler);

signal(SIGSEGV, signal_handler);

signal(SIGABRT, signal_handler);

signal(SIGQUIT, signal_handler);

signal(SIGTRAP, signal_handler);

signal(SIGHUP, signal_handler);

enable_raw_mode();

#endif

PikaObj* newObj = newNormalObj(newObjFun);

if (!logo_printed) {

logo_printed = 1;

pika_platform_printf("\r\n");

pika_platform_printf("~~~/ POWERED BY \\~~~\r\n");

pika_platform_printf("~ pikapython.com ~\r\n");

pika_platform_printf("~~~~~~~~~~~~~~~~~~~~\r\n");

}

if (NULL != __pikaMain) {

pika_platform_printf("Error: root object already exists\r\n");

pika_platform_panic_handle();

return NULL;

}

__pikaMain = newObj;

obj_setName(newObj, name);

g_PikaObjState.inRootObj = pika_false;

return newObj;

}

Arg* arg_newMetaObj(NewFun new_obj_fun) {

Arg* arg_new = New_arg(NULL);

/* m means meta-object */

arg_new = arg_setPtr(arg_new, "", ARG_TYPE_OBJECT_META, (void*)new_obj_fun);

return arg_new;

}

Arg* arg_newDirectObj(NewFun new_obj_fun) {

PikaObj* newObj = newNormalObj(new_obj_fun);

Arg* arg_new = arg_newPtr(ARG_TYPE_OBJECT_NEW, newObj);

return arg_new;

}

Arg* obj_newObjInPackage(NewFun new_obj_fun) {

return arg_newDirectObj(new_obj_fun);

}

static PikaObj* _obj_initMetaObj(PikaObj* obj, char* name) {

PikaObj* res = NULL;

NewFun constructor = (NewFun)getNewClassObjFunByName(obj, name);

Args buffs = {0};

PikaObj* thisClass;

PikaObj* oNew;

if (NULL == constructor) {

/* no such object */

res = NULL;

goto __exit;

}

thisClass = obj_newObjFromConstructor(obj, name, constructor);

oNew = removeMethodInfo(thisClass);

obj_setName(oNew, name);

obj_runNativeMethod(oNew, "__init__", NULL);

args_setPtrWithType(obj->list, name, ARG_TYPE_OBJECT, oNew);

res = obj_getPtr(obj, name);

// pikaGC_enable(res);

goto __exit;

__exit:

strsDeinit(&buffs);

return res;

}

PikaObj* _arg_to_obj(Arg* self, pika_bool* pIsTemp) {

if (NULL == self) {

return NULL;

}

if (arg_isObject(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));

if (NULL != pIsTemp) {

*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);

if (NULL != pIsTemp) {

*pIsTemp = pika_true;

}

return obj;

}

#endif

return NULL;

}

static PikaObj* _obj_getObjDirect(PikaObj* self,

char* name,

pika_bool* pIsTemp) {

*pIsTemp = pika_false;

if (NULL == self) {

return NULL;

}

/* finded object, check type*/

Arg* aObj = args_getArg(self->list, name);

ArgType type = ARG_TYPE_NONE;

if (NULL == aObj) {

aObj = _obj_getPropArg(self, name);

}

if (NULL == aObj) {

return NULL;

}

type = arg_getType(aObj);

/* found meta Object */

if (type == ARG_TYPE_OBJECT_META) {

return _obj_initMetaObj(self, name);

}

/* found Objcet */

if (argType_isObject(type)) {

return arg_getPtr(aObj);

}

#if !PIKA_NANO_ENABLE

/* found class */

if (type == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR ||

type == ARG_TYPE_METHOD_CONSTRUCTOR) {

*pIsTemp = pika_true;

PikaObj* oMethodArgs = New_TinyObj(NULL);

Arg* aClsObj = obj_runMethodArg(self, oMethodArgs, aObj);

obj_deinit(oMethodArgs);

Args* args = New_args(NULL);

if (type == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR) {

obj_runNativeMethod(arg_getPtr(aClsObj), "__init__", args);

}

PikaObj* res = arg_getPtr(aClsObj);

arg_deinit(aClsObj);

args_deinit(args);

return res;

}

#endif

return _arg_to_obj(aObj, pIsTemp);

}

static PikaObj* _obj_getObjWithKeepDeepth(PikaObj* self,

char* objPath,

pika_bool* pIsTemp,

int32_t keepDeepth) {

char objPath_buff[PIKA_PATH_BUFF_SIZE];

char* objPath_ptr = objPath_buff;

pika_assert(NULL != objPath);

if ('.' == objPath[0] && '\0' == objPath[1]) {

return self;

}

pika_assert(strGetSize(objPath) < PIKA_PATH_BUFF_SIZE);

strcpy(objPath_buff, objPath);

int32_t token_num = strGetTokenNum(objPath, '.');

PikaObj* objThis = self;

PikaObj* objNext = NULL;

pika_bool bThisIsTemp = pika_false;

for (int32_t i = 0; i < token_num - keepDeepth; i++) {

char* token = strPopFirstToken(&objPath_ptr, '.');

objNext = _obj_getObjDirect(objThis, token, pIsTemp);

if (objNext == NULL) {

objThis = NULL;

goto __exit;

}

if (bThisIsTemp) {

if (*pIsTemp == pika_false) {

obj_refcntInc(objNext);

*pIsTemp = pika_true;

}

obj_deinit(objThis);

}

pika_assert_obj_alive(objNext);

objThis = objNext;

bThisIsTemp = *pIsTemp;

}

goto __exit;

__exit:

if (NULL != objThis) {

pika_assert(obj_checkAlive(objThis));

}

return objThis;

}

PikaObj* obj_getObj(PikaObj* self, char* objPath) {

pika_assert(NULL != objPath);

pika_bool is_temp = pika_false;

return _obj_getObjWithKeepDeepth(self, objPath, &is_temp, 0);

}

PikaObj* obj_getHostObj(PikaObj* self, char* objPath) {

pika_assert(NULL != objPath);

pika_bool is_temp = pika_false;

return _obj_getObjWithKeepDeepth(self, objPath, &is_temp, 1);

}

PikaObj* obj_getHostObjWithIsTemp(PikaObj* self,

char* objPath,

pika_bool* pIsTemp) {

return _obj_getObjWithKeepDeepth(self, objPath, pIsTemp, 1);

}

Method methodArg_getPtr(Arg* method_arg) {

MethodProp* method_store = (MethodProp*)arg_getContent(method_arg);

return (Method)method_store->ptr;

}

Arg* _get_return_arg(PikaObj* locals);

NativeProperty* methodArg_toProp(Arg* method_arg) {

pika_assert(arg_getType(method_arg) == ARG_TYPE_METHOD_NATIVE_CONSTRUCTOR);

PikaObj* locals = New_TinyObj(NULL);

MethodProp* method_store = (MethodProp*)arg_getContent(method_arg);

Method fMethod = (Method)method_store->ptr;

fMethod(NULL, locals->list);

Arg* aReturn = _get_return_arg(locals);

if (arg_getType(aReturn) == ARG_TYPE_OBJECT_NEW) {

arg_setType(aReturn, ARG_TYPE_OBJECT);

}