KDEFINE_PACKAGE *Curl_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("curl", "1.0"),
.PackupNameSpace = curl_PackupNameSpace,
.ExportNameSpace = curl_ExportNameSpace,
};
KDEFINE_PACKAGE *Python_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("python", "1.0"),
.PackupNameSpace = python_PackupNameSpace,
.ExportNameSpace = python_ExportNameSpace,
};
KDEFINE_PACKAGE *File_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("konoha", "1.0"),
.PackupNameSpace = file_PackupNameSpace,
.ExportNameSpace = file_ExportNameSpace,
};
KDEFINE_PACKAGE *stat_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("posix", "1.0"),
.PackupNameSpace = stat_PackupNameSpace,
.ExportNameSpace = stat_ExportNameSpace,
};
KDEFINE_PACKAGE* JSON_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("JSON", "1.0"),
.initPackage = JSON_initPackage,
.setupPackage = JSON_setupPackage,
};
KDEFINE_PACKAGE *process_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("process", "1.0"),
KPACKLIB("POSIX.1", "1.0"),
.PackupNameSpace = process_PackupNameSpace,
.ExportNameSpace = process_ExportNameSpace,
};
KDEFINE_PACKAGE* konoha_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("konoha", "1.0"),
.initPackage = konoha_initPackage,
.setupPackage = konoha_setupPackage,
.initKonohaSpace = konoha_initKonohaSpace,
.setupKonohaSpace = konoha_setupKonohaSpace,
};
KDEFINE_PACKAGE* string_init(void)
{
static const KDEFINE_PACKAGE d = {
KPACKNAME("String", "1.0"),
.initPackage = string_initPackage,
.setupPackage = string_setupPackage,
.initNameSpace = string_initNameSpace,
.setupNameSpace = string_setupNameSpace,
};
KDEFINE_PACKAGE* curl_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("curl", "1.0"),
.initPackage = curl_initPackage,
.setupPackage = curl_setupPackage,
.initKonohaSpace = curl_initKonohaSpace,
.setupKonohaSpace = curl_setupKonohaSpace,
};
KDEFINE_PACKAGE* while_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("C-compatible while", "1.0"),
.initPackage = while_initPackage,
.setupPackage = while_setupPackage,
.initNameSpace = while_initNameSpace,
.setupNameSpace = while_setupNameSpace,
};
KDEFINE_PACKAGE* math_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("math", "1.0"),
.initPackage = math_initPackage,
.setupPackage = math_setupPackage,
.initNameSpace = math_initNameSpace,
.setupNameSpace = math_setupNameSpace,
};
KDEFINE_PACKAGE* python_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("python", "1.0"),
.initPackage = python_initPackage,
.setupPackage = python_setupPackage,
.initNameSpace = python_initNameSpace,
.setupNameSpace = python_setupNameSpace,
};
KDEFINE_PACKAGE* array_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("array", "1.0"),
.initPackage = array_initPackage,
.setupPackage = array_setupPackage,
.initKonohaSpace = array_initKonohaSpace,
.setupKonohaSpace = array_setupKonohaSpace,
};
KDEFINE_PACKAGE* float_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("float", "1.0"),
.initPackage = float_initPackage,
.setupPackage = float_setupPackage,
.initKonohaSpace = float_initKonohaSpace,
.setupKonohaSpace = float_setupKonohaSpace,
};
static kbool_t openssl_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
static const char *names[] = {
"MD5",
"SHA1",
};
KonohaClass *tbls[2];
static KDEFINE_CLASS Def = {
.structname = "",
.typeId = TY_newid,
.init = RawPtr_Init,
.free = RawPtr_Free,
};
#define TY_MD5 tbls[0]->typeId
#define TY_SHA1 tbls[1]->typeId
int i;
for (i = 0; i < 2; i++) {
Def.structname = names[i];
tbls[i] = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &Def, trace);
}
int FN_x = FN_("x");
KDEFINE_METHOD MethodData[] = {
_P, _F(kMD5_Init), TY_SHA1, TY_MD5, MN_("new"), 0,
_P, _F(kMD5_Update), TY_int, TY_MD5, MN_("update"), 1, TY_String, FN_x,
_P, _F(kMD5_Final), TY_String, TY_MD5, MN_("final"), 0,
_P, _F(kSHA1_Init), TY_SHA1, TY_SHA1, MN_("new"), 0,
_P, _F(kSHA1_Update), TY_int, TY_SHA1, MN_("update"), 1, TY_String, FN_x,
_P, _F(kSHA1_Final), TY_String, TY_SHA1, MN_("final"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t openssl_ExportNameSpace(KonohaContext *kctx, kNameSpace *ns, kNameSpace *exportNS, int option, KTraceInfo *trace)
{
return true;
}
KDEFINE_PACKAGE *openssl_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("openssl", "1.0"),
.PackupNameSpace = openssl_PackupNameSpace,
.ExportNameSpace = openssl_ExportNameSpace,
};
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 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;
}
