static kbool_t exception_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, kfileline_t pline)
{
KonohaExceptionModule *mod = (KonohaExceptionModule*)KCALLOC(sizeof(KonohaExceptionModule), 1);
mod->h.name = "exception";
mod->h.setup = kModuleException_setup;
mod->h.reftrace = kModuleException_reftrace;
mod->h.free = kModuleException_free;
KLIB Konoha_setModule(kctx, MOD_exception, &mod->h, pline);
KDEFINE_CLASS defException = {
STRUCTNAME(Exception),
.cflag = CFLAG_Exception,
.init = Exception_init,
.reftrace = Exception_reftrace,
.p = Exception_p,
};
mod->cException = KLIB Konoha_defineClass(kctx, ns->packageId, PN_konoha, NULL, &defException, pline);
KDEFINE_METHOD MethodData[] = {
_Public|_Hidden, _F(System_throw), TY_void, TY_System, MN_("throw"), 1, TY_Exception, FN_("e"),
_Public|_Hidden, _F(System_getThrownException), TY_Exception, TY_System, MN_("getThrownException"), 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t float_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, kfileline_t pline)
{
KonohaFloatModule *base = (KonohaFloatModule*)KCALLOC(sizeof(KonohaFloatModule), 1);
base->h.name = "float";
base->h.setup = kmodfloat_setup;
base->h.reftrace = kmodfloat_reftrace;
base->h.free = kmodfloat_free;
KLIB Konoha_setModule(kctx, MOD_float, &base->h, pline);
KDEFINE_CLASS defFloat = {
STRUCTNAME(Float),
.cflag = CFLAG_Int,
.init = Float_init,
.p = Float_p,
};
base->cFloat = KLIB Konoha_defineClass(kctx, ns->packageId, PN_konoha, NULL, &defFloat, pline);
int FN_x = FN_("x");
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Im, _F(Float_opPlus), TY_Float, TY_Float, MN_("+"), 0,
_Public|_Const|_Im, _F(Float_opADD), TY_Float, TY_Float, MN_("+"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opADD), TY_Float, TY_Int, MN_("+"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opSUB), TY_Float, TY_Float, MN_("-"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opSUB), TY_Float, TY_Int, MN_("-"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opMUL), TY_Float, TY_Float, MN_("*"), 1, TY_Float, FN_x,
_Public|_Im, _F(Float_opDIV), TY_Float, TY_Float, MN_("/"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opEQ), TY_Boolean, TY_Float, MN_("=="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opNEQ), TY_Boolean, TY_Float, MN_("!="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opLT), TY_Boolean, TY_Float, MN_("<"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opLTE), TY_Boolean, TY_Float, MN_("<="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opGT), TY_Boolean, TY_Float, MN_(">"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Float_opGTE), TY_Boolean, TY_Float, MN_(">="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opMUL), TY_Float, TY_Int, MN_("*"), 1, TY_Float, FN_x,
_Public|_Im, _F(Int_opDIV), TY_Float, TY_Int, MN_("/"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opEQ), TY_Boolean, TY_Int, MN_("=="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opNEQ), TY_Boolean, TY_Int, MN_("!="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opLT), TY_Boolean, TY_Int, MN_("<"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opLTE), TY_Boolean, TY_Int, MN_("<="), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opGT), TY_Boolean, TY_Int, MN_(">"), 1, TY_Float, FN_x,
_Public|_Const|_Im, _F(Int_opGTE), TY_Boolean, TY_Int, MN_(">="), 1, TY_Float, FN_x,
_Public|_Const|_Im|_Coercion, _F(Float_toInt), TY_Int, TY_Float, MN_to(TY_Int), 0,
_Public|_Const|_Im|_Coercion, _F(Int_toFloat), TY_Float, TY_Int, MN_to(TY_Float), 0,
_Public|_Const|_Im, _F(Float_toString), TY_String, TY_Float, MN_to(TY_String), 0,
_Public|_Const|_Im, _F(String_toFloat), TY_Float, TY_String, MN_to(TY_Float), 0,
_Public|_Const|_Im, _F(Float_opMINUS), TY_Float, TY_Float, MN_("-"), 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
KDEFINE_FLOAT_CONST FloatData[] = {
{"FLOAT_EPSILON", TY_Float, DBL_EPSILON},
{"Infinity", TY_Float, INFINITY},
{"NaN", TY_Float, NAN},
{}
};
KLIB kNameSpace_loadConstData(kctx, ns, KonohaConst_(FloatData), pline);
return true;
}
static kbool_t object_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, KTraceInfo *trace)
{
KRequirePackage("konoha.subtype", trace);
KDEFINE_INT_CONST ClassData[] = { // add Object as available
{"Object", VirtualType_KonohaClass, (uintptr_t)CT_(TY_Object)},
{NULL},
};
KLIB kNameSpace_loadConstData(kctx, ns, KonohaConst_(ClassData), 0);
KDEFINE_METHOD MethodData[] = {
_Public|_Const, _F(Object_getTypeId), TY_int, TY_Object, MN_("getTypeId"), 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t JSON_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, KTraceInfo *trace)
{
KRequirePackage("konoha.float", trace);
KDEFINE_CLASS JSONDef = {
STRUCTNAME(JSON),
.cflag = kClass_Final,
.init = kJSON_init,
.free = kJSON_free,
.p = kJSON_p,
};
KonohaClass *cJSON = KLIB kNameSpace_defineClass(kctx, ns, NULL, &JSONDef, trace);
kparamtype_t ps = {TY_JSON, FN_("json")};
KonohaClass *CT_JSONArray = KLIB KonohaClass_Generics(kctx, CT_Array, TY_JSON, 1, &ps);
ktype_t TY_JSONArray = CT_JSONArray->typeId;
int FN_key = FN_("key");
int FN_v = FN_("v");
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Static, _F(kJSON_parse), TY_JSON, TY_JSON, MN_("parse"), 1, TY_String, FN_("data"),
_Public|_Const|_Im, _F(kJSON_get), TY_JSON, TY_JSON, MN_("get"), 1, TY_String, FN_key,
_Public|_Const|_Im, _F(kJSON_getArray), TY_JSONArray, TY_JSON, MN_("getArray"), 1, TY_String, FN_key,
_Public|_Const|_Im, _F(kJSON_getBool), TY_boolean, TY_JSON, MN_("getBool"), 1, TY_String, FN_key,
_Public|_Const|_Im, _F(kJSON_getFloat), TY_float, TY_JSON, MN_("getFloat"), 1, TY_String, FN_key,
_Public|_Const|_Im, _F(kJSON_getInt), TY_int, TY_JSON, MN_("getInt"), 1, TY_String, FN_key,
_Public|_Const|_Im, _F(kJSON_getString), TY_String, TY_JSON, MN_("getString"), 1, TY_String, FN_key,
_Public, _F(kJSON_new), TY_JSON, TY_JSON, MN_("new"), 0,
_Public, _F(kJSON_set), TY_void, TY_JSON, MN_("set"), 2, TY_String, FN_key, TY_JSON, FN_("value"),
_Public|_Const|_Im, _F(kJSONArray_get), TY_JSON, TY_JSONArray, MN_("get"), 1, TY_int, FN_("index"),
_Public, _F(kJSONArray_append), TY_void, TY_JSONArray, MN_("add"), 1, TY_JSON, FN_v,
_Public, _F(kJSONArray_append), TY_void, TY_JSONArray, MN_("append"), 1, TY_JSON, FN_v,
_Public|_Const|_Im, _F(kJSONArray_getSize),TY_int, TY_JSONArray, MN_("getSize"),0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t jansson_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, KTraceInfo *trace)
{
KRequirePackage("konoha.float", trace);
KDEFINE_CLASS JsonDef = {
.structname = "Json",
.typeId = TY_newid,
.cflag = kClass_Final,
.init = Jansson_init,
.free = Jansson_free,
.p = Jansson_p,
};
KonohaClass *cJson = KLIB kNameSpace_defineClass(kctx, ns, NULL, &JsonDef, trace);
ktype_t TY_JsonArray = CT_JsonArray->typeId;
ktype_t TY_StringArray0 = CT_StringArray0->typeId;
int FN_k = FN_("key");
int FN_v = FN_("value");
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Im, _F(Json_dump), TY_String, TY_Json, MN_("dump"), 0,
_Public|_Const|_Im, _F(Json_getJson), TY_Json, TY_Json, MN_("getJson"), 1, TY_String, FN_k,
_Public|_Const|_Im, _F(Json_getArray), TY_JsonArray, TY_Json, MN_("getArray"), 1, TY_String, FN_k,
_Public|_Const|_Im, _F(Json_getBool), TY_boolean, TY_Json, MN_("getBool"), 1, TY_String, FN_k,
_Public|_Const|_Im, _F(Json_getFloat), TY_float, TY_Json, MN_("getFloat"), 1, TY_String, FN_k,
_Public|_Const|_Im, _F(Json_getInt), TY_int, TY_Json, MN_("getInt"), 1, TY_String, FN_k,
_Public|_Const|_Im, _F(Json_getString), TY_String, TY_Json, MN_("getString"), 1, TY_String, FN_k,
_Public, _F(Json_new), TY_Json, TY_Json, MN_("new"), 0,
_Public|_Static|_Const|_Im, _F(Json_parse), TY_Json, TY_Json, MN_("parse"), 1, TY_String, FN_v,
_Public, _F(Json_setJson), TY_void, TY_Json, MN_("setJson"), 2, TY_String, FN_k, TY_Json, FN_v,
_Public, _F(Json_setArray), TY_void, TY_Json, MN_("setArray"), 2, TY_String, FN_k, TY_JsonArray, FN_v,
_Public, _F(Json_setBool), TY_void, TY_Json, MN_("setBool"), 2, TY_String, FN_k, TY_boolean, FN_v,
_Public, _F(Json_setFloat), TY_void, TY_Json, MN_("setFloat"), 2, TY_String, FN_k, TY_float, FN_v,
_Public, _F(Json_setInt), TY_void, TY_Json, MN_("setInt"), 2, TY_String, FN_k, TY_int, FN_v,
_Public, _F(Json_setString), TY_void, TY_Json, MN_("setString"), 2, TY_String, FN_k, TY_String, FN_v,
_Public|_Const|_Im, _F(Json_getKeys), TY_StringArray0, TY_Json, MN_("getKeys"), 0,
_Public|_Const|_Im, _F(Json_dump), TY_String, TY_JsonArray, MN_("dump"), 0,
_Public, _F(JsonArray_newArray), TY_JsonArray, TY_JsonArray, MN_("newArray"), 1, TY_int, FN_("size"),
_Public|_Const|_Im, _F(JsonArray_get), TY_Json, TY_JsonArray, MN_("get"), 1, TY_int, FN_("idx"),
_Public, _F(JsonArray_add), TY_void, TY_JsonArray, MN_("add"), 1, TY_Json, FN_v,
_Public|_Const|_Im, _F(JsonArray_getSize), TY_int, TY_JsonArray, MN_("getSize"), 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t jansson_setupPackage(KonohaContext *kctx, kNameSpace *ns, isFirstTime_t isFirstTime, KTraceInfo *trace)
{
return true;
}
KDEFINE_PACKAGE* jansson_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("jansson", "1.0"),
.initPackage = jansson_initPackage,
.setupPackage = jansson_setupPackage,
};
return &d;
}
static kbool_t logpool_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, kfileline_t pline)
{
int i;
static KDEFINE_CLASS Def0 = {
.structname = "LogPool"/*structname*/,
.typeId = TY_newid/*cid*/,
.init = RawPtr_init,
.free = Logpool_free,
};
KonohaClass *ct0 = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def0, pline);
static KDEFINE_CLASS Def1 = {
.structname = "Log"/*structname*/,
.typeId = TY_newid/*cid*/,
.init = RawPtr_init,
.free = Log_free,
.p = Log_p,
};
KonohaClass *ct1 = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def1, pline);
static KDEFINE_CLASS Def2 = {
.structname = "PoolPlugin",
.typeId = TY_newid,
.init = RawPtr_init,
.free = RawPtr_free,
};
KonohaClass *ct2 = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def2, pline);
#define TY_Plugin ct2->typeId
static KDEFINE_CLASS Def3 = {
.structname = "",
.typeId = TY_newid,
.init = RawPtr_init,
.free = RawPtr_free,
};
Def3.superTypeId = ct2->typeId;
static const char *names[] = {
"Printer",
"KeyFilter",
"ValFilter",
"React",
"Timer",
"Statics",
"Copy",
"Response",
};
KonohaClass *tbls[8];
#define TY_Printer tbls[0]->typeId
#define TY_KeyFilter tbls[1]->typeId
#define TY_ValFilter tbls[2]->typeId
#define TY_React tbls[3]->typeId
#define TY_Timer tbls[4]->typeId
#define TY_Statics tbls[5]->typeId
#define TY_Copy tbls[6]->typeId
#define TY_Response tbls[7]->typeId
for (i = 0; i < 8; i++) {
Def3.structname = names[i];
tbls[i] = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &Def3, pline);
}
int FN_x = FN_("x");
int FN_y = FN_("y");
int FN_z = FN_("z");
KDEFINE_METHOD MethodData[] = {
_P|_C, _F(LogPool_new), TY_Logpool, TY_Logpool, MN_("new"), 2, TY_String, FN_x, TY_Int, FN_y,
_P|_C, _F(LogPool_get), TY_Log, TY_Logpool, MN_("get"), 0,
_P|_C, _F(LogPool_loadFile), TY_void, TY_Logpool, MN_("loadFile"), 2, TY_String, FN_x, TY_String, FN_y,
_P|_C, _F(Log_get_), TY_String, TY_Log, MN_("get"), 1, TY_String, FN_x,
_P|_S, _F(Printer_create ), TY_Plugin, TY_Printer , MN_("create"), 0,
_P|_S, _F(KeyFilter_create), TY_Plugin, TY_KeyFilter, MN_("create"), 1, TY_String, FN_x,
_P|_S, _F(ValFilter_create), TY_Plugin, TY_ValFilter, MN_("create"), 3, TY_String, FN_x, TY_String, FN_y, TY_String, FN_z,
_P|_S, _F(React_create ), TY_Plugin, TY_React , MN_("create"), 2, TY_String, FN_x, TY_String, FN_y,
_P|_S, _F(Timer_create ), TY_Plugin, TY_Timer , MN_("create"), 3, TY_Int, FN_x, TY_Int, FN_y, TY_Int, FN_z,
_P|_S, _F(Statics_create ), TY_Plugin, TY_Statics , MN_("create"), 3, TY_Func, FN_x, TY_Func, FN_y, TY_Func, FN_z,
_P|_S, _F(Copy_create ), TY_Plugin, TY_Copy , MN_("create"), 0,
_P|_S, _F(Response_create ), TY_Plugin, TY_Response , MN_("create"), 1, TY_Object, FN_x,
_P , _F(PoolPlugin_apply ), TY_void, TY_Plugin , MN_("apply"), 1, TY_Plugin, FN_x,
_P , _F(PoolPlugin_failed), TY_void, TY_Plugin , MN_("failed"), 1, TY_Plugin, FN_x,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t logpool_setupPackage(KonohaContext *kctx, kNameSpace *ns, isFirstTime_t isFirstTime, kfileline_t pline)
{
return true;
}
static kbool_t logpool_initNameSpace(KonohaContext *kctx, kNameSpace *ns, kfileline_t pline)
{
return true;
}
static kbool_t logpool_setupNameSpace(KonohaContext *kctx, kNameSpace *ns, kfileline_t pline)
{
return true;
}
KDEFINE_PACKAGE* logpool_init(void)
{
logpool_global_init(LOGPOOL_DEFAULT);
static KDEFINE_PACKAGE d = {
KPACKNAME("logpool", "1.0"),
.initPackage = logpool_initPackage,
.setupPackage = logpool_setupPackage,
.initNameSpace = logpool_initNameSpace,
.setupNameSpace = logpool_setupNameSpace,
};
return &d;
}
static kbool_t python_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, kfileline_t pline)
{
python_init_count++;
if(python_init_count == 1) {
Py_Initialize();
}
static KDEFINE_CLASS PythonDef = {
STRUCTNAME(PyObject),
.cflag = 0,
.init = PyObject_init,
.free = PyObject_free,
.p = PyObject_p,
};
KonohaClass *cPython = KLIB Konoha_defineClass(kctx, ns->packageId, ns->packageDomain, NULL, &PythonDef, pline);
int TY_PyObject = cPython->typeId;
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Im|_Coercion, _F(PyObject_toBoolean), TY_Boolean, TY_PyObject, MN_to(TY_Boolean), 0,
_Public|_Const|_Im|_Coercion, _F(Boolean_toPyObject), TY_PyObject, TY_Boolean, MN_to(TY_PyObject), 0,
_Public|_Const|_Im|_Coercion, _F(PyObject_toInt), TY_Int, TY_PyObject, MN_to(TY_Int), 0,
_Public|_Const|_Im|_Coercion, _F(Int_toPyObject), TY_PyObject, TY_Int, MN_to(TY_PyObject), 0,
_Public|_Const|_Im|_Coercion, _F(PyObject_toString), TY_String, TY_PyObject, MN_to(TY_String), 0,
_Public|_Const|_Im|_Coercion, _F(String_toPyObject), TY_PyObject, TY_String, MN_to(TY_PyObject), 0,
_Public|_Const|_Im|_Coercion, _F(PyObject_toString), TY_String, TY_PyObject, MN_("toString"), 0,
//_Public, _F(Array_add), TY_void, TY_Array, MN_("add"), 1, TY_0, FN_("value"),
// [TODO] add following konoha class.
//_Public|_Const|_Im|_Coercion, _F(PyObject_toList), TY_Array, TY_PyObject, MN_to(TY_Array), 0,
//_Public|_Const|_Im|_Coercion, _F(Array_toPyObject), TY_PyObject, TY_Array, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toComplex), TY_Complex, TY_PyObject, MN_to(TY_Complex), 0,
//_Public|_Const|_Im|_Coercion, _F(Complex_toPyObject), TY_PyObject, TY_Complex, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toBuffer), TY_Buffer, TY_PyObject, MN_to(TY_Buffer), 0,
//_Public|_Const|_Im|_Coercion, _F(Buffer_toPyObject), TY_PyObject, TY_Buffer, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toTuple), TY_Tuple, TY_PyObject, MN_to(TY_Tuple), 0,
//_Public|_Const|_Im|_Coercion, _F(Tuple_toPyObject), TY_PyObject, TY_Tuple, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toDict), TY_Dict, TY_PyObject, MN_to(TY_Dict), 0,
//_Public|_Const|_Im|_Coercion, _F(Dict_toPyObject), TY_PyObject, TY_Dict, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toClass), TY_Class, TY_PyObject, MN_to(TY_Class), 0,
//_Public|_Const|_Im|_Coercion, _F(Class_toPyObject), TY_PyObject, TY_Class, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_asFunction), TY_Function, TY_PyObject, MN_to(TY_Function), 0,
//_Public|_Const|_Im|_Coercion, _F(Function_toPyObject), TY_PyObject, TY_Function, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_asMethod), TY_Method, TY_PyObject, MN_to(TY_Method), 0,
//_Public|_Const|_Im|_Coercion, _F(Method_toPyObject), TY_PyObject, TY_Method, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toFile), TY_File, TY_PyObject, MN_to(TY_File), 0,
//_Public|_Const|_Im|_Coercion, _F(File_toPyObject), TY_PyObject, TY_File, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toModule), TY_Module, TY_PyObject, MN_to(TY_Module), 0,
//_Public|_Const|_Im|_Coercion, _F(Module_toPyObject), TY_PyObject, TY_Module, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toSeqIter), TY_SeqIter, TY_PyObject, MN_to(TY_SeqIter), 0,
//_Public|_Const|_Im|_Coercion, _F(SeqIter_toPyObject), TY_PyObject, TY_SeqIter, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toSlice), TY_Slice, TY_PyObject, MN_to(TY_Slice), 0,
//_Public|_Const|_Im|_Coercion, _F(Slice_toPyObject), TY_PyObject, TY_Slice, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toWeakref), TY_Weakref, TY_PyObject, MN_to(TY_Weakref), 0,
//_Public|_Const|_Im|_Coercion, _F(Weakref_toPyObject), TY_PyObject, TY_Weakref, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toCapsule), TY_Capsule, TY_PyObject, MN_to(TY_Capsule), 0,
//_Public|_Const|_Im|_Coercion, _F(Capsule_toPyObject), TY_PyObject, TY_Capsule, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toCell), TY_Cell, TY_PyObject, MN_to(TY_Cell), 0,
//_Public|_Const|_Im|_Coercion, _F(Cell_toPyObject), TY_PyObject, TY_Cell, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toGen), TY_Gen, TY_PyObject, MN_to(TY_Gen), 0,
//_Public|_Const|_Im|_Coercion, _F(Gen_toPyObject), TY_PyObject, TY_Gen, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(Date_toPyObject), TY_PyObject, TY_Date, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toDate), TY_Date, TY_PyObject, MN_to(TY_Date), 0,
//_Public|_Const|_Im|_Coercion, _F(Set_toPyObject), TY_PyObject, TY_Set, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toSet), TY_Set, TY_PyObject, MN_to(TY_Set), 0,
//_Public|_Const|_Im|_Coercion, _F(Code_toPyObject), TY_PyObject, TY_Code, MN_to(TY_PyObject), 0,
//_Public|_Const|_Im|_Coercion, _F(PyObject_toCode), TY_Code, TY_PyObject, MN_to(TY_Code), 0,
_Public|_Im, _F(Python_eval), TY_Boolean, TY_System, FN_("pyEval"), 1, TY_String, FN_("script"),
_Public|_Im, _F(PyObject_import), TY_PyObject, TY_PyObject, FN_("import"), 1, TY_String, FN_("name"),
_Public|_Im, _F(PyObject_), TY_PyObject, TY_PyObject, 0, 1, TY_PyObject, 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
if(IS_DefinedFloat()) {
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Im|_Coercion, _F(PyObject_toFloat), TY_Float, TY_PyObject, MN_to(TY_Float), 0,
_Public|_Const|_Im|_Coercion, _F(Float_toPyObject), TY_PyObject, TY_Float, MN_to(TY_PyObject), 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
}
return true;
}
static kbool_t regexp_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
kregexpshare_t *base = (kregexpshare_t *)KCalloc_UNTRACE(sizeof(kregexpshare_t), 1);
base->h.name = "regexp";
base->h.setup = kregexpshare_setup;
base->h.reftrace = kregexpshare_reftrace;
base->h.free = kregexpshare_free;
KLIB KonohaRuntime_setModule(kctx, MOD_REGEXP, &base->h, trace);
KDEFINE_CLASS RegExpDef = {
STRUCTNAME(RegExp),
.cflag = 0,
.init = RegExp_init,
.free = RegExp_free,
.p = RegExp_p,
};
base->cRegExp = KLIB kNameSpace_defineClass(kctx, ns, NULL, &RegExpDef, trace);
ktype_t TY_StringArray0 = CT_StringArray0->typeId;
KDEFINE_METHOD MethodData[] = {
/*JS*/_Public|_Const|_Im, _F(RegExp_getglobal), TY_boolean, TY_RegExp, MN_("getglobal"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getignoreCase), TY_boolean, TY_RegExp, MN_("getignoreCase"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getmultiline), TY_boolean, TY_RegExp, MN_("getmultiline"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getsource), TY_String, TY_RegExp, MN_("getsource"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getlastIndex), TY_int, TY_RegExp, MN_("getlastIndex"), 0,
/*JS*/_Public|_Im, _F(String_match), TY_StringArray0, TY_String, MN_("match"), 1, TY_RegExp, FN_("regexp"),
/*JS*/_Public|_Const|_Im, _F(String_replace), TY_String, TY_String, MN_("replace"), 2, TY_RegExp, FN_("searchvalue"), TY_String, FN_("newvalue"),
/*JS*/_Public|_Const|_Im, _F(String_search), TY_int, TY_String, MN_("search"), 1, TY_RegExp, FN_("searchvalue"),
/*JS*/_Public|_Im, _F(String_split), TY_StringArray0, TY_String, MN_("split"), 1, TY_RegExp, FN_("separator"),
/*JS*/_Public|_Im, _F(String_splitWithLimit), TY_StringArray0, TY_String, MN_("split"), 2, TY_RegExp, FN_("separator"), TY_int, FN_("limit"),
/*JS*/_Public|_Const, _F(RegExp_new), TY_RegExp, TY_RegExp, MN_("new"), 1, TY_String, FN_("pattern"),
/*JS*/_Public|_Const, _F(RegExp_new2), TY_RegExp, TY_RegExp, MN_("new"), 2, TY_String, FN_("pattern"), TY_String, FN_("option"),
/*JS*/_Public|_Const, _F(RegExp_exec), TY_StringArray0, TY_RegExp, MN_("exec"), 1, TY_String, FN_("str"),
/*JS*/_Public|_Const|_Im, _F(RegExp_test), TY_boolean, TY_RegExp, MN_("test"), 1, TY_String, FN_("str"),
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static KMETHOD TokenFunc_JavaScriptRegExp(KonohaContext *kctx, KonohaStack *sfp)
{
kTokenVar *tk = (kTokenVar *)sfp[1].asObject;
int ch, prev = '/', pos = 1;
const char *source = S_text(sfp[2].asString);
if(source[pos] == '*' || source[pos] == '/') {
KReturnUnboxValue(0);
}
/*FIXME: we need to care about context sensitive case*/
//int tokenListize = kArray_size(tenv->tokenList);
//if(tokenListize > 0) {
// kToken *tkPrev = tenv->tokenList->TokenItems[tokenListize - 1];
// if(tkPrev->unresolvedTokenType == TokenType_INT ||
// (tkPrev->topCharHint != '(' && tkPrev->unresolvedTokenType == TokenType_SYMBOL)) {
// KReturnUnboxValue(0);
// }
//}
while((ch = source[pos++]) != 0) {
if(ch == '\n') {
break;
}
if(ch == '/' && prev != '\\') {
int pos0 = pos;
while(isalpha(source[pos])) pos++;
if(IS_NOTNULL(tk)) {
kArray *a = (kArray *)KLIB new_kObject(kctx, OnField, CT_StringArray0, 2); // FIXME
KFieldSet(tk, tk->subTokenList, a);
KLIB new_kString(kctx, a, source + 1, (pos0-2), 0);
KLIB new_kString(kctx, a, source + pos0, pos-pos0, 0);
tk->unresolvedTokenType = SYM_("$RegExp");
}
KReturnUnboxValue(pos);
}
prev = ch;
}
if(IS_NOTNULL(tk)) {
SUGAR kToken_printMessage(kctx, tk, ErrTag, "must close with %s", "/");
}
KReturnUnboxValue(pos-1);
}
