static kbool_t konoha_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_CLASS defKonohaFactory = {0};
SETSTRUCTNAME(defKonohaFactory, KonohaFactory);
defKonohaFactory.init = kKonohaFactory_Init;
defKonohaFactory.free = kKonohaFactory_Free;
KDEFINE_CLASS defKonoha = {0};
SETSTRUCTNAME(defKonoha, Konoha);
defKonoha.init = kKonoha_Init;
defKonoha.free = kKonoha_Free;
KClass *cKonohaFactory = KLIB KClass_define(kctx, ns->packageId, NULL, &defKonohaFactory, trace);
KClass *cKonoha = KLIB KClass_define(kctx, ns->packageId, NULL, &defKonoha, trace);
int KType_KonohaFactory = cKonohaFactory->typeId, KType_Konoha = cKonoha->typeId;
KDEFINE_METHOD MethodData[] = {
kMethod_Public, _F(KonohaFactory_new), KType_KonohaFactory, KType_KonohaFactory, KMethodName_("new"), 0,
kMethod_Public, _F(KonohaFactory_loadModule), KType_Boolean, KType_KonohaFactory, KMethodName_("loadModule"), 1, KType_String, KFieldName_("name"),
kMethod_Public, _F(KonohaFactory_create), KType_Konoha, KType_KonohaFactory, KMethodName_("create"), 0,
kMethod_Public, _F(Konoha_loadScript), KType_Boolean, KType_Konoha, KMethodName_("loadScript"), 1, KType_String, KFieldName_("filename"),
kMethod_Public, _F(Konoha_eval), KType_Konoha, KType_Konoha, KMethodName_("eval"), 1, KType_String, KFieldName_("script"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t Libevent_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
/* Class Definition */
KDEFINE_CLASS defLibevent = {0};
SETSTRUCTNAME(defLibevent, Libevent);
defLibevent.cflag = KClassFlag_Final;
defLibevent.init = Libevent_Init;
defLibevent.free = Libevent_Free;
KClass *LibeventClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defLibevent, trace);
int KType_Libevent = LibeventClass->typeId;
KDEFINE_METHOD MethodData[] = {
_Public, _F(Libevent_new), KType_Libevent, KType_Libevent, KMethodName_("new"), 0,
_Public, _F(Libevent_dispatch), KType_Libevent, KType_Libevent, KMethodName_("dispatch"), 0,
_Public, _F(Libevent_event_add), KType_Int, KType_Libevent, KMethodName_("event_add"), 2, KType_Object, KFieldName_("timeval"),
_Public, _F(Libevent_event_del), KType_Int, KType_Libevent, KMethodName_("event_del"), 1,
#ifdef CUTCUT
_Public, _F(Person_say), KType_String, KType_Person, KMethodName_("say"), 0,
#endif
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t bytes_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
//KImportPackageSymbol(ns, "cstyle", "$SingleQuotedChar", trace);
if(KClass_Bytes == NULL) {
KDEFINE_CLASS defBytes = {0};
SETSTRUCTNAME(defBytes, Bytes);
defBytes.cflag = KClassFlag_Final;
defBytes.free = kBytes_Free;
defBytes.init = kBytes_Init;
defBytes.format = kBytes_format;
KClass_Bytes = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defBytes, trace);
}
int FN_index = KFieldName_("index");
int FN_c = KFieldName_("c");
int FN_size = KFieldName_("size");
KDEFINE_METHOD MethodData[] = {
_Public, _F(Bytes_new), KType_Bytes, KType_Bytes, KMethodName_("new"), 1, KType_Int, FN_size,
_Public|_Im, _F(Bytes_getSize), KType_Int, KType_Bytes, KMethodName_("getSize"), 0,
_Public|_Im, _F(Bytes_get), KType_Int, KType_Bytes, KMethodName_("get"), 1, KType_Int, FN_index,
_Public, _F(Bytes_Set), KType_void, KType_Bytes, KMethodName_("set"), 2, KType_Int, FN_index, KType_Int, FN_c,
_Public, _F(Bytes_SetAll), KType_void, KType_Bytes, KMethodName_("setAll"), 1, KType_Int, FN_c,
_Public|_Im|_Coercion, _F(String_toBytes), KType_Bytes, KType_String, KMethodName_To(KType_Bytes), 0,
//_Public|_Im|_Coercion, _F(Bytes_toString), KType_String, KType_Bytes, KMethodName_To(KType_String), 0,
//_Public|_Const, _F(Bytes_encodeTo), KType_Bytes, KType_Bytes, KMethodName_("encodeTo"), 1, KType_String, FN_encoding,
//_Public|_Const, _F(Bytes_decodeFrom), KType_String, KType_Bytes, KMethodName_("decodeFrom"), 1, KType_String, FN_encoding,
_Public, _F(String_new_fromBytes_withDefaultDecode), KType_String, KType_String, KMethodName_("new"), 1, KType_Bytes, KFieldName_("ba"),
_Public, _F(String_new_fromBytes_withSpecifiedDecode), KType_String, KType_String, KMethodName_("new"), 2, KType_Bytes, KFieldName_("ba"), KType_String, KFieldName_("charset"),
_Public, _F(String_new_fromSubBytes_withDefaultDecode), KType_String, KType_String, KMethodName_("new"), 3, KType_Bytes, KFieldName_("ba"), KType_Int, KFieldName_("offset"), KType_Int, KFieldName_("length"),
_Public, _F(String_new_fromSubBytes_withSpecifiedDecode), KType_String, KType_String, KMethodName_("new"), 4, KType_Bytes, KFieldName_("ba"), KType_Int, KFieldName_("offset"), KType_Int, KFieldName_("length"), KType_String, KFieldName_("charset"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t iterator_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
if(CT_Iterator == NULL) {
kparamtype_t IteratorParam = {TY_Object};
KDEFINE_CLASS defIterator = {0};
SETSTRUCTNAME(defIterator, Iterator);
defIterator.cflag = CFLAG_Iterator;
defIterator.init = Iterator_Init;
defIterator.cparamsize = 1;
defIterator.cParamItems = &IteratorParam;
CT_Iterator = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defIterator, trace);
CT_StringIterator = CT_p0(kctx, CT_Iterator, TY_String);
CT_GenericIterator = CT_p0(kctx, CT_Iterator, TY_0);
}
KDEFINE_METHOD MethodData[] = {
_Public, _F(Iterator_hasNext), TY_boolean, TY_Iterator, MN_("hasNext"), 0,
_Public, _F(Iterator_next), TY_0, TY_Iterator, MN_("next"), 0,
_Public, _F(Array_toIterator), TY_GenericIterator, TY_Array, MN_("toIterator"), 0,
_Public, _F(String_toIterator), TY_StringIterator, TY_String, MN_("toIterator"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t HelloWorld_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
/* Class Definition */
/* If you want to create Generic class like Array<T>, see konoha.map package */
KDEFINE_CLASS defPerson = {0};
SETSTRUCTNAME(defPerson, Person);
defPerson.cflag = kClass_Final;
defPerson.init = Person_Init;
defPerson.p = Person_p;
defPerson.reftrace = Person_Reftrace;
defPerson.free = Person_Free;
KonohaClass *PersonClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defPerson, trace);
/* You can define methods with the following procedures. */
int TY_Person = PersonClass->typeId;
int FN_x = FN_("x");
int FN_y = FN_("y");
KDEFINE_METHOD MethodData[] = {
_Public, _F(Person_new), TY_Person, TY_Person, MN_("new"), 2, TY_String, FN_x, TY_int, FN_y,
_Public, _F(Person_say), TY_String, TY_Person, MN_("say"), 0,
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
/* You can define constant variable with the following procedures. */
KDEFINE_INT_CONST IntData[] = {
{"NARUTO_AGE", TY_int, 18},
{} /* <= sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(IntData), false/*isOverride*/, trace);
return true;
}
static kbool_t console_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_CLASS defConsole = {0};
SETSTRUCTNAME(defConsole, Console);
defConsole.cflag = KClassFlag_Final | KClassFlag_Singleton;
KClass *cConsole = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defConsole, trace);
int KType_Console = cConsole->typeId;
KDEFINE_METHOD MethodData[] = {
_Public|_Static, _F(Console_notify), KType_void, KType_Console, KMethodName_("notify"), 1, KType_String, KFieldName_("message"),
_Public|_Static, _F(Console_readLine), KType_String, KType_Console, KMethodName_("readLine"), 1, KType_String, KFieldName_("message"),
_Public|_Static, _F(Console_inputUserApproval), KType_Boolean, KType_Console, KMethodName_("inputUserApproval"), 4,
KType_String, KFieldName_("message"), KType_String, KFieldName_("yes"), KType_String, KFieldName_("no"), KType_Boolean, KFieldName_("defval"),
_Public|_Static, _F(Console_inputUserPassword), KType_String, KType_Console, KMethodName_("inputUserPassword"), 1, KType_String, KFieldName_("message"),
_Public|_Static, _F(Console_inputUserPassword0), KType_String, KType_Console, KMethodName_("inputUserPassword"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
void MODSUGAR_Init(KonohaContext *kctx, KonohaContextVar *ctx)
{
KModuleSugar *mod = (KModuleSugar *)KCalloc_UNTRACE(sizeof(KModuleSugar), 1);
mod->h.name = "sugar";
mod->h.allocSize = sizeof(KModuleSugar);
mod->h.setupModuleContext = SugarModule_Setup;
KLIB KonohaRuntime_setModule(kctx, MOD_sugar, (KonohaModule *)mod, 0);
KonohaLibVar* l = (KonohaLibVar *)ctx->klib;
l->kNameSpace_GetClass = kNameSpace_GetClass;
l->kNameSpace_DefineClass = kNameSpace_DefineClass;
l->kNameSpace_LoadMethodData = kNameSpace_LoadMethodData;
l->kNameSpace_SetConstData = kNameSpace_SetConstData;
l->kNameSpace_LoadConstData = kNameSpace_LoadConstData;
l->kNameSpace_GetGetterMethodNULL = kNameSpace_GetGetterMethodNULL;
l->kNameSpace_GetSetterMethodNULL = kNameSpace_GetSetterMethodNULL;
l->kNameSpace_GetCoercionMethodNULL = kNameSpace_GetCoercionMethodNULL;
l->kNameSpace_GetMethodByParamSizeNULL = kNameSpace_GetMethodByParamSizeNULL;
l->kNameSpace_GetMethodBySignatureNULL = kNameSpace_GetMethodBySignatureNULL;
l->kMethod_DoLazyCompilation = kMethod_DoLazyCompilation;
// l->kNameSpace_compileAllDefinedMethods = kNameSpace_compileAllDefinedMethods;
l->kNameSpace_FreeSugarExtension = kNameSpace_FreeSugarExtension;
l->Konoha_LoadScript = Konoha_LoadScript;
l->Konoha_Eval = Konoha_Eval;
l->kMethod_GenCode = kMethod_GenCode;
l->kMethod_setFunc = kMethod_setFunc;
KDEFINE_CLASS defToken = {0};
SETSTRUCTNAME(defToken, Token);
defToken.init = kToken_Init;
defToken.reftrace = kToken_Reftrace;
defToken.p = kToken_p;
KDEFINE_CLASS defExpr = {0};
SETSTRUCTNAME(defExpr, Expr);
defExpr.init = kExpr_Init;
defExpr.reftrace = kExpr_Reftrace;
defExpr.p = kExpr_p;
KDEFINE_CLASS defStmt = {0};
SETSTRUCTNAME(defStmt, Stmt);
defStmt.init = kStmt_Init;
defStmt.reftrace = kStmt_Reftrace;
defStmt.p = kStmt_p;
KDEFINE_CLASS defBlock = {0};
SETSTRUCTNAME(defBlock, Block);
defBlock.init = kBlock_Init;
defBlock.reftrace = kBlock_Reftrace;
KDEFINE_CLASS defGamma = {0};
SETSTRUCTNAME(defGamma, Gamma);
defGamma.init = Gamma_Init;
mod->cToken = KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defToken, 0);
mod->cExpr = KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defExpr, 0);
mod->cStmt = KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defStmt, 0);
mod->cBlock = KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defBlock, 0);
mod->cGamma = KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defGamma, 0);
mod->cTokenArray = CT_p0(kctx, CT_Array, mod->cToken->typeId);
KLIB Knull(kctx, mod->cToken);
KLIB Knull(kctx, mod->cExpr);
kStmtVar *NullStmt = (kStmtVar *)KLIB Knull(kctx, mod->cStmt);
KFieldSet(NullStmt, NullStmt->parentBlockNULL, (kBlock *)KLIB Knull(kctx, mod->cBlock));
SugarModule_Setup(kctx, &mod->h, 0);
KDEFINE_INT_CONST ClassData[] = { // minikonoha defined class
{"void", VirtualType_KonohaClass, (uintptr_t)CT_void},
{"boolean", VirtualType_KonohaClass, (uintptr_t)CT_Boolean},
{"int", VirtualType_KonohaClass, (uintptr_t)CT_Int},
{"String", VirtualType_KonohaClass, (uintptr_t)CT_String},
{"Func", VirtualType_KonohaClass, (uintptr_t)CT_Func},
{"System", VirtualType_KonohaClass, (uintptr_t)CT_System},
{NULL},
};
kNameSpace_LoadConstData(kctx, KNULL(NameSpace), KonohaConst_(ClassData), 0);
mod->kNameSpace_SetTokenFunc = kNameSpace_SetTokenFunc;
mod->TokenSeq_Tokenize = TokenSeq_Tokenize;
mod->TokenSeq_ApplyMacro = TokenSeq_ApplyMacro;
mod->kNameSpace_SetMacroData = kNameSpace_SetMacroData;
mod->TokenSeq_Resolve = TokenSeq_Resolve;
mod->TokenSeq_Eval = TokenSeq_Eval;
mod->TokenUtils_ParseTypePattern = TokenUtils_ParseTypePattern;
mod->kToken_ToBraceGroup = kToken_ToBraceGroup;
mod->kStmt_AddParsedObject = kStmt_AddParsedObject;
mod->kNameSpace_FindEndOfStatement = kNameSpace_FindEndOfStatement;
mod->kStmt_ParseFlag = kStmt_ParseFlag;
mod->kStmt_GetToken = kStmt_GetToken;
mod->kStmt_GetBlock = kStmt_GetBlock;
mod->kStmt_GetExpr = kStmt_GetExpr;
mod->kStmt_GetText = kStmt_GetText;
mod->kExpr_SetConstValue = kExpr_SetConstValue;
mod->kExpr_SetUnboxConstValue = kExpr_SetUnboxConstValue;
mod->kExpr_SetVariable = kExpr_SetVariable;
mod->kStmt_TypeCheckExprAt = kStmt_TypeCheckExprAt;
mod->kStmt_TypeCheckByName = kStmt_TypeCheckByName;
mod->kBlock_TypeCheckAll = kBlock_TypeCheckAll;
mod->kStmtkExpr_TypeCheckCallParam = kStmtkExpr_TypeCheckCallParam;
mod->new_TypedCallExpr = new_TypedCallExpr;
mod->kGamma_AddLocalVariable = kGamma_AddLocalVariable;
mod->kStmt_DeclType = kStmt_DeclType;
mod->kStmt_TypeCheckVariableNULL = kStmt_TypeCheckVariableNULL;
mod->kNameSpace_DefineSyntax = kNameSpace_DefineSyntax;
mod->kNameSpace_GetSyntax = kNameSpace_GetSyntax;
mod->kArray_AddSyntaxRule = kArray_AddSyntaxPattern;
// mod->kNameSpace_SetSugarFunc = kNameSpace_SetSugarFunc;
mod->kNameSpace_AddSugarFunc = kNameSpace_AddSugarFunc;
mod->new_kBlock = new_kBlock;
mod->new_kStmt = new_kStmt;
mod->kBlock_InsertAfter = kBlock_InsertAfter;
mod->new_UntypedTermExpr = new_UntypedTermExpr;
mod->new_UntypedCallStyleExpr = new_UntypedCallStyleExpr;
mod->kStmt_ParseOperatorExpr = kStmt_ParseOperatorExpr;
mod->kStmt_ParseExpr = kStmt_ParseExpr;
mod->kStmt_AddExprParam = kStmt_AddExprParam;
mod->kStmt_RightJoinExpr = kStmt_RightJoinExpr;
mod->kToken_ToError = kToken_ToError;
mod->kStmt_Message2 = kStmt_Message2;
mod->VisitStmt = VisitStmt;
mod->VisitExpr = VisitExpr;
mod->VisitBlock = VisitBlock;
#ifndef USE_SMALLBUILD
mod->dumpToken = dumpToken;
mod->dumpTokenArray = dumpTokenArray;
mod->dumpExpr = dumpExpr;
#endif
DefineDefaultSyntax(kctx, KNULL(NameSpace));
}
static kbool_t Complex_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequirePackage("Type.Float", trace);
KDEFINE_CLASS defComplex = {0};
SETSTRUCTNAME(defComplex, Complex);
defComplex.cflag = KClassFlag_Final;
defComplex.init = kComplex_Init;
defComplex.free = kComplex_Free;
KClass *ComplexClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defComplex, trace);
int KType_Complex = ComplexClass->typeId;
KDEFINE_METHOD MethodData[] = {
_Public, _F(Complex_new), KType_Complex, KType_Complex, KMethodName_("new"), 2, KType_float, KFieldName_("real"), KType_float, KFieldName_("imaginary"),
_Public, _F(Complex_csin), KType_float, KType_Complex, KMethodName_("csin"), 0,
_Public, _F(Complex_csinf), KType_float, KType_Complex, KMethodName_("csinf"), 0,
_Public, _F(Complex_csinl), KType_float, KType_Complex, KMethodName_("csinl"), 0,
_Public, _F(Complex_ccos), KType_float, KType_Complex, KMethodName_("ccos"), 0,
_Public, _F(Complex_ccosf), KType_float, KType_Complex, KMethodName_("ccosf"), 0,
_Public, _F(Complex_ccosl), KType_float, KType_Complex, KMethodName_("ccosl"), 0,
_Public, _F(Complex_ctan), KType_float, KType_Complex, KMethodName_("ctan"), 0,
_Public, _F(Complex_ctanf), KType_float, KType_Complex, KMethodName_("ctanf"), 0,
_Public, _F(Complex_ctanl), KType_float, KType_Complex, KMethodName_("ctanl"), 0,
_Public, _F(Complex_casin), KType_float, KType_Complex, KMethodName_("casin"), 0,
_Public, _F(Complex_casinf), KType_float, KType_Complex, KMethodName_("casinf"), 0,
_Public, _F(Complex_casinl), KType_float, KType_Complex, KMethodName_("casinl"), 0,
_Public, _F(Complex_cacos), KType_float, KType_Complex, KMethodName_("cacos"), 0,
_Public, _F(Complex_cacosf), KType_float, KType_Complex, KMethodName_("cacosf"), 0,
_Public, _F(Complex_cacosl), KType_float, KType_Complex, KMethodName_("cacosl"), 0,
_Public, _F(Complex_catan), KType_float, KType_Complex, KMethodName_("catan"), 0,
_Public, _F(Complex_catanf), KType_float, KType_Complex, KMethodName_("catanf"), 0,
_Public, _F(Complex_catanl), KType_float, KType_Complex, KMethodName_("catanl"), 0,
_Public, _F(Complex_csinh), KType_float, KType_Complex, KMethodName_("csinh"), 0,
_Public, _F(Complex_csinhf), KType_float, KType_Complex, KMethodName_("csinhf"), 0,
_Public, _F(Complex_csinhl), KType_float, KType_Complex, KMethodName_("csinhl"), 0,
_Public, _F(Complex_ccosh), KType_float, KType_Complex, KMethodName_("ccosh"), 0,
_Public, _F(Complex_ccoshf), KType_float, KType_Complex, KMethodName_("ccoshf"), 0,
_Public, _F(Complex_ccoshl), KType_float, KType_Complex, KMethodName_("ccoshl"), 0,
_Public, _F(Complex_ctanh), KType_float, KType_Complex, KMethodName_("ctanh"), 0,
_Public, _F(Complex_ctanhf), KType_float, KType_Complex, KMethodName_("ctanhf"), 0,
_Public, _F(Complex_ctanhl), KType_float, KType_Complex, KMethodName_("ctanhl"), 0,
_Public, _F(Complex_casinh), KType_float, KType_Complex, KMethodName_("casinh"), 0,
_Public, _F(Complex_casinhf), KType_float, KType_Complex, KMethodName_("casinhf"), 0,
_Public, _F(Complex_casinhl), KType_float, KType_Complex, KMethodName_("casinhl"), 0,
_Public, _F(Complex_cacosh), KType_float, KType_Complex, KMethodName_("cacosh"), 0,
_Public, _F(Complex_cacoshf), KType_float, KType_Complex, KMethodName_("cacoshf"), 0,
_Public, _F(Complex_cacoshl), KType_float, KType_Complex, KMethodName_("cacoshl"), 0,
_Public, _F(Complex_catanh), KType_float, KType_Complex, KMethodName_("catanh"), 0,
_Public, _F(Complex_catanhf), KType_float, KType_Complex, KMethodName_("catanhf"), 0,
_Public, _F(Complex_catanhl), KType_float, KType_Complex, KMethodName_("catanhl"), 0,
_Public, _F(Complex_cexp), KType_float, KType_Complex, KMethodName_("cexp"), 0,
_Public, _F(Complex_cexpf), KType_float, KType_Complex, KMethodName_("cexpf"), 0,
_Public, _F(Complex_cexpl), KType_float, KType_Complex, KMethodName_("cexpl"), 0,
_Public, _F(Complex_clog), KType_float, KType_Complex, KMethodName_("clog"), 0,
_Public, _F(Complex_clogf), KType_float, KType_Complex, KMethodName_("clogf"), 0,
_Public, _F(Complex_clogl), KType_float, KType_Complex, KMethodName_("clogl"), 0,
_Public, _F(Complex_cabs), KType_float, KType_Complex, KMethodName_("cabs"), 0,
_Public, _F(Complex_cabsf), KType_float, KType_Complex, KMethodName_("cabsf"), 0,
_Public, _F(Complex_cabsl), KType_float, KType_Complex, KMethodName_("cabsl"), 0,
_Public, _F(Complex_csqrt), KType_float, KType_Complex, KMethodName_("csqrt"), 0,
_Public, _F(Complex_csqrtf), KType_float, KType_Complex, KMethodName_("csqrtf"), 0,
_Public, _F(Complex_csqrtl), KType_float, KType_Complex, KMethodName_("csqrtl"), 0,
_Public, _F(Complex_cpow), KType_float, KType_Complex, KMethodName_("cpow"), 2, KType_float, KFieldName_("real"), KType_float, KFieldName_("imaginary"),
_Public, _F(Complex_cpowf), KType_float, KType_Complex, KMethodName_("cpowf"), 2, KType_float, KFieldName_("real"), KType_float, KFieldName_("imaginary"),
_Public, _F(Complex_cpowl), KType_float, KType_Complex, KMethodName_("cpowl"), 2, KType_float, KFieldName_("real"), KType_float, KFieldName_("imaginary"),
_Public, _F(Complex_creal), KType_float, KType_Complex, KMethodName_("creal"), 0,
_Public, _F(Complex_crealf), KType_float, KType_Complex, KMethodName_("crealf"), 0,
_Public, _F(Complex_creall), KType_float, KType_Complex, KMethodName_("creall"), 0,
_Public, _F(Complex_cimag), KType_float, KType_Complex, KMethodName_("cimag"), 0,
_Public, _F(Complex_cimagf), KType_float, KType_Complex, KMethodName_("cimagf"), 0,
_Public, _F(Complex_cimagl), KType_float, KType_Complex, KMethodName_("cimagl"), 0,
_Public, _F(Complex_carg), KType_float, KType_Complex, KMethodName_("carg"), 0,
_Public, _F(Complex_cargf), KType_float, KType_Complex, KMethodName_("cargf"), 0,
_Public, _F(Complex_cargl), KType_float, KType_Complex, KMethodName_("cargl"), 0,
_Public, _F(Complex_conj), KType_Complex, KType_Complex, KMethodName_("conj"), 0,
_Public, _F(Complex_conjf), KType_Complex, KType_Complex, KMethodName_("conjf"), 0,
_Public, _F(Complex_conjl), KType_Complex, KType_Complex, KMethodName_("conjl"), 0,
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t date_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_CLASS defDate = {0};
SETSTRUCTNAME(defDate, Date);
defDate.cflag = KClassFlag_Final;
KClass *cDate = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defDate, trace);
KDEFINE_METHOD MethodData[] = {
_Public, _F(Date_new0), KType_Date, KType_Date, KMethodName_("new"), 0,
_Public, _F(Date_new1), KType_Date, KType_Date, KMethodName_("new"), 1, KType_Int, KFieldName_("milliseconds"),
// _Public, _F(Date_new2), KType_Date, KType_Date, KMethodName_("new"), 1, KType_String, KFieldName_("dateString"),
_Public, _F(Date_new3), KType_Date, KType_Date, KMethodName_("new"), 7, KType_Int, KFieldName_("year"), KType_Int, KFieldName_("month"), KType_Int, KFieldName_("day"), KType_Int, KFieldName_("hour"), KType_Int, KFieldName_("minutes"), KType_Int, KFieldName_("seconds"), KType_Int, KFieldName_("milliseconds"),
_Public|_Im, _F(Date_getDate), KType_Int, KType_Date, KMethodName_("getDate"), 0,
_Public|_Im, _F(Date_getDay), KType_Int, KType_Date, KMethodName_("getDay"), 0,
_Public|_Im, _F(Date_getFullYear), KType_Int, KType_Date, KMethodName_("getFullYear"), 0,
_Public|_Im, _F(Date_getHours), KType_Int, KType_Date, KMethodName_("getHours"), 0,
_Public|_Im, _F(Date_getMilliseconds), KType_Int, KType_Date, KMethodName_("getMilliseconds"), 0,
_Public|_Im, _F(Date_getMinutes), KType_Int, KType_Date, KMethodName_("getMinutes"), 0,
_Public|_Im, _F(Date_getMonth), KType_Int, KType_Date, KMethodName_("getMonth"), 0,
_Public|_Im, _F(Date_getSeconds), KType_Int, KType_Date, KMethodName_("getSeconds"), 0,
_Public|_Im, _F(Date_getTime), KType_Int, KType_Date, KMethodName_("getTime"), 0,
_Public|_Im, _F(Date_getTimezoneOffset), KType_Int, KType_Date, KMethodName_("getTimezoneOffset"), 0,
_Public|_Im, _F(Date_getUTCDate), KType_Int, KType_Date, KMethodName_("getUTCDate"), 0,
_Public|_Im, _F(Date_getUTCDay), KType_Int, KType_Date, KMethodName_("getUTCDay"), 0,
_Public|_Im, _F(Date_getUTCFullYear), KType_Int, KType_Date, KMethodName_("getUTCFullYear"), 0,
_Public|_Im, _F(Date_getUTCHours), KType_Int, KType_Date, KMethodName_("getUTCHours"), 0,
_Public|_Im, _F(Date_getUTCMilliseconds), KType_Int, KType_Date, KMethodName_("getUTCMilliseconds"), 0,
_Public|_Im, _F(Date_getUTCMinutes), KType_Int, KType_Date, KMethodName_("getUTCMinutes"), 0,
_Public|_Im, _F(Date_getUTCMonth), KType_Int, KType_Date, KMethodName_("getUTCMonth"), 0,
_Public|_Im, _F(Date_getUTCSeconds), KType_Int, KType_Date, KMethodName_("getUTCSeconds"), 0,
_Public|_Im, _F(Date_getYear), KType_Int, KType_Date, KMethodName_("getYear"), 0,
// _Public|_Static, _F(Date_Parse), KType_Int, KType_Date, KMethodName_("parse"), 1, KType_String, KFieldName_("dateString"),
_Public, _F(Date_SetDate), KType_Int, KType_Date, KMethodName_("setDate"), 1, KType_Int, KFieldName_("date"),
_Public, _F(Date_SetFullYear), KType_Int, KType_Date, KMethodName_("setFullYear"), 1, KType_Int, KFieldName_("year"),
_Public, _F(Date_SetHours), KType_Int, KType_Date, KMethodName_("setHours"), 1, KType_Int, KFieldName_("hours"),
_Public, _F(Date_SetMilliseconds), KType_Int, KType_Date, KMethodName_("setMilliseconds"), 1, KType_Int, KFieldName_("milliseconds"),
_Public, _F(Date_SetMinutes), KType_Int, KType_Date, KMethodName_("setMinutes"), 1, KType_Int, KFieldName_("minutes"),
_Public, _F(Date_SetMonth), KType_Int, KType_Date, KMethodName_("setMonth"), 1, KType_Int, KFieldName_("month"),
_Public, _F(Date_SetSeconds), KType_Int, KType_Date, KMethodName_("setSeconds"), 1, KType_Int, KFieldName_("seconds"),
_Public, _F(Date_SetTime), KType_Int, KType_Date, KMethodName_("setTime"), 1, KType_Int, KFieldName_("milliseconds"),
_Public, _F(Date_SetUTCDate), KType_Int, KType_Date, KMethodName_("setUTCDate"), 1, KType_Int, KFieldName_("date"),
_Public, _F(Date_SetUTCFullYear), KType_Int, KType_Date, KMethodName_("setUTCFullYear"), 1, KType_Int, KFieldName_("year"),
_Public, _F(Date_SetUTCHours), KType_Int, KType_Date, KMethodName_("setUTCHours"), 1, KType_Int, KFieldName_("hours"),
_Public, _F(Date_SetUTCMilliseconds), KType_Int, KType_Date, KMethodName_("setUTCMilliseconds"), 1, KType_Int, KFieldName_("milliseconds"),
_Public, _F(Date_SetUTCMinutes), KType_Int, KType_Date, KMethodName_("setUTCMinutes"), 1, KType_Int, KFieldName_("minutes"),
_Public, _F(Date_SetUTCMonth), KType_Int, KType_Date, KMethodName_("setUTCMonth"), 1, KType_Int, KFieldName_("month"),
_Public, _F(Date_SetUTCSeconds), KType_Int, KType_Date, KMethodName_("setUTCSeconds"), 1, KType_Int, KFieldName_("seconds"),
_Public, _F(Date_SetYear), KType_Int, KType_Date, KMethodName_("setYear"), 1, KType_Int, KFieldName_("year"),
_Public, _F(Date_toDateString), KType_String, KType_Date, KMethodName_("toDateString"), 0,
_Public, _F(Date_toGMTString), KType_String, KType_Date, KMethodName_("toGMTString"), 0,
_Public, _F(Date_toISOString), KType_String, KType_Date, KMethodName_("toISOString"), 0,
// _Public, _F(Date_toJSON), KType_Json, KType_Date, KMethodName_("toJSON"), 0,
_Public, _F(Date_toLocaleDateString), KType_String, KType_Date, KMethodName_("toLocaleDateString"), 0,
_Public, _F(Date_toLocaleTimeString), KType_String, KType_Date, KMethodName_("toLocaleTimeString"), 0,
_Public, _F(Date_toLocaleString), KType_String, KType_Date, KMethodName_("toLocaleString"), 0,
_Public, _F(Date_toLocaleString), KType_String, KType_Date, KMethodName_("toString"), 0,
_Public, _F(Date_toLocaleTimeString), KType_String, KType_Date, KMethodName_("toTimeString"), 0,
_Public, _F(Date_toGMTString), KType_String, KType_Date, KMethodName_("toUTCString"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
void MODSUGAR_Init(KonohaContext *kctx, KonohaContextVar *ctx)
{
KParserModel *mod = (KParserModel *)KCalloc_UNTRACE(sizeof(KParserModel), 1);
mod->h.name = "sugar";
mod->h.allocSize = sizeof(KParserModel);
mod->h.setupModelContext = SugarModule_Setup;
KLIB KRuntime_SetModule(kctx, ParserModelIndex, (KRuntimeModel *)mod, 0);
KonohaLibVar *l = (KonohaLibVar *)ctx->klib;
l->kNameSpace_GetClassByFullName = kNameSpace_GetClassByFullName;
l->kNameSpace_DefineClass = kNameSpace_DefineClass;
l->kNameSpace_LoadMethodData = kNameSpace_LoadMethodData;
l->kNameSpace_SetConstData = kNameSpace_SetConstData;
l->kNameSpace_LoadConstData = kNameSpace_LoadConstData;
l->kNameSpace_GetGetterMethodNULL = kNameSpace_GetGetterMethodNULL;
l->kNameSpace_GetSetterMethodNULL = kNameSpace_GetSetterMethodNULL;
l->kNameSpace_GetCoercionMethodNULL = kNameSpace_GetCoercionMethodNULL;
l->kNameSpace_GetMethodByParamSizeNULL = kNameSpace_GetMethodByParamSizeNULL;
l->kNameSpace_GetMethodBySignatureNULL = kNameSpace_GetMethodBySignatureNULL;
l->kMethod_DoLazyCompilation = kMethod_DoLazyCompilation;
l->kNameSpace_FreeSugarExtension = kNameSpace_FreeSugarExtension;
l->Konoha_LoadScript = Konoha_LoadScript;
l->Konoha_Eval = Konoha_Eval;
l->kMethod_GenCode = kMethod_GenCode;
l->kMethod_SetFunc = kMethod_SetFunc;
KDEFINE_CLASS defSymbol = {0};
defSymbol.structname = "Symbol";
defSymbol.typeId = KTypeAttr_NewId;
defSymbol.cflag = KClassFlag_int;
defSymbol.init = KClass_(KType_Int)->init;
defSymbol.unbox = KClass_(KType_Int)->unbox;
defSymbol.format = kSymbol_format;
KDEFINE_CLASS defSyntax = {0};
SETSTRUCTNAME(defSyntax, Syntax);
defSyntax.init = kSyntax_Init;
//defSyntax.format = kSyntax_format;
KDEFINE_CLASS defToken = {0};
SETSTRUCTNAME(defToken, Token);
defToken.init = kToken_Init;
defToken.reftrace = kToken_Reftrace;
defToken.format = kToken_format;
KDEFINE_CLASS defNode = {0};
SETSTRUCTNAME(defNode, Node);
defNode.init = kUntypedNode_Init;
defNode.reftrace = kUntypedNode_Reftrace;
defNode.format = kUntypedNode_format;
InitNodeClass(kctx, mod);
mod->cSymbol = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defSymbol, 0);
mod->cSyntax = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defSyntax, 0);
mod->cToken = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defToken, 0);
mod->cNode = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defNode, 0);
mod->cTokenArray = KClass_p0(kctx, KClass_Array, mod->cToken->typeId);
KLIB Knull(kctx, mod->cToken);
KLIB Knull(kctx, mod->cNode);
SugarModule_Setup(kctx, &mod->h, 0);
KDEFINE_INT_CONST ClassData[] = { // konoha defined class
{"void", VirtualType_KClass, (uintptr_t)KClass_void},
{"boolean", VirtualType_KClass, (uintptr_t)KClass_Boolean},
{"int", VirtualType_KClass, (uintptr_t)KClass_Int},
{"String", VirtualType_KClass, (uintptr_t)KClass_String},
{"Func", VirtualType_KClass, (uintptr_t)KClass_Func},
{"System", VirtualType_KClass, (uintptr_t)KClass_System},
{NULL},
};
kNameSpace_LoadConstData(kctx, KNULL(NameSpace), KConst_(ClassData), 0);
l->Tokenize = Tokenize;
l->ApplyMacroData = ApplyMacroData;
l->SetMacroData = SetMacroData;
l->Preprocess = Preprocess;
l->EvalTokenList = EvalTokenList;
l->ParseTypePattern = ParseTypePattern;
l->kToken_ToBraceGroup = kToken_ToBraceGroup;
l->kUntypedNode_AddParsedObject = kUntypedNode_AddParsedObject;
l->FindEndOfStatement = FindEndOfStatement;
l->kUntypedNode_ParseFlag = kUntypedNode_ParseFlag;
l->kUntypedNode_GetToken = kUntypedNode_GetToken;
l->kUntypedNode_GetNode = kUntypedNode_GetNode;
l->kUntypedNode_SetConst = kUntypedNode_SetConst;
l->kUntypedNode_SetUnboxConst = kUntypedNode_SetUnboxConst;
l->kUntypedNode_SetVariable = kUntypedNode_SetVariable;
l->TypeCheckNodeAt = TypeCheckNodeAt;
l->TypeCheckNodeByName = TypeCheckNodeByName;
l->TypeCheckMethodParam = TypeCheckMethodParam;
l->new_MethodNode = new_MethodNode;
l->AddLocalVariable = AddLocalVariable;
l->kUntypedNode_DeclType = kUntypedNode_DeclType;
l->TypeVariableNULL = TypeVariableNULL;
l->kNameSpace_DefineSyntax = kNameSpace_DefineSyntax;
l->kNameSpace_GetSyntax = kNameSpace_GetSyntax;
l->kSyntax_AddPattern = kSyntax_AddPattern;
l->kNameSpace_AddSyntax = kNameSpace_AddSyntax;
l->kNameSpace_UseDefaultVirtualMachine = kNameSpace_UseDefaultVirtualMachine;
l->kUntypedNode_InsertAfter = kUntypedNode_InsertAfter;
l->kUntypedNode_AddNode = kUntypedNode_AddNode;
l->kUntypedNode_Op = kUntypedNode_Op;
l->ParseSyntaxNode = ParseSyntaxNode;
l->ParseNode = ParseNode;
l->ParseNewNode = ParseNewNode;
l->AppendParsedNode = AppendParsedNode;
l->kToken_ToError = kToken_ToError;
l->MessageNode = MessageNode;
l->VisitNode = VisitNode;
#ifndef USE_SMALLBUILD
l->dumpToken = dumpToken;
l->dumpTokenArray = dumpTokenArray;
#endif
DefineDefaultSyntax(kctx, KNULL(NameSpace));
}
static kbool_t Libevent_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
/* Class Definition */
/* If you want to create Generic class like Array<T>, see konoha.map package */
// cevent_base
KDEFINE_CLASS defcevent_base = {0};
SETSTRUCTNAME(defcevent_base, cevent_base);
defcevent_base.cflag = KClassFlag_Final; //must be final in C
defcevent_base.init = cevent_base_Init;
defcevent_base.free = cevent_base_Free;
KClass *cevent_baseClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defcevent_base, trace);
// cevent
KDEFINE_CLASS defcevent = {0};
SETSTRUCTNAME(defcevent, cevent);
defcevent.cflag = KClassFlag_Final;
defcevent.init = cevent_Init;
// defcevent.reftrace = cevent_Reftrace;
defcevent.free = cevent_Free;
KClass *ceventClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defcevent, trace);
// cbufferevent
KDEFINE_CLASS defcbufferevent = {0};
SETSTRUCTNAME(defcbufferevent, cbufferevent);
defcbufferevent.cflag = KClassFlag_Final;
defcbufferevent.init = cbufferevent_Init;
// defcbufferevent.reftrace = cbufferevent_Reftrace;
defcbufferevent.free = cbufferevent_Free;
KClass *cbuffereventClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defcbufferevent, trace);
// eventCBArg
KDEFINE_CLASS defeventCBArg = {0};
SETSTRUCTNAME(defeventCBArg, eventCBArg);
defeventCBArg.cflag = KClassFlag_Final;
defeventCBArg.init = eventCBArg_Init;
defeventCBArg.reftrace = eventCBArg_Reftrace;
defeventCBArg.free = eventCBArg_Free;
KClass *eventCBArgClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defeventCBArg, trace);
// buffereventCBArg
KDEFINE_CLASS defbuffereventCBArg = {0};
SETSTRUCTNAME(defbuffereventCBArg, buffereventCBArg);
defbuffereventCBArg.cflag = KClassFlag_Final;
defbuffereventCBArg.init = buffereventCBArg_Init;
defbuffereventCBArg.reftrace = buffereventCBArg_Reftrace;
defbuffereventCBArg.free = buffereventCBArg_Free;
KClass *buffereventCBArgClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defbuffereventCBArg, trace);
// ctimeval
KDEFINE_CLASS defctimeval = {0};
SETSTRUCTNAME(defctimeval, ctimeval);
defctimeval.cflag = KClassFlag_Final;
defctimeval.init = ctimeval_Init;
KClass *ctimevalClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defctimeval, trace);
// Sockaddr_in
KDEFINE_CLASS defSockaddr_in = {0};
SETSTRUCTNAME(defSockaddr_in, Sockaddr_in);
defSockaddr_in.cflag = KClassFlag_Final;
defSockaddr_in.init = Sockaddr_in_Init;
KClass *Sockaddr_inClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defSockaddr_in, trace);
/* You can define methods with the following procedures. */
int KType_cevent_base = cevent_baseClass->typeId;
int KType_cevent = ceventClass->typeId;
int KType_cbufferevent = cbuffereventClass->typeId;
int KType_eventCBArg = eventCBArgClass->typeId;
int KType_buffereventCBArg = buffereventCBArgClass->typeId;
int KType_ctimeval = ctimevalClass->typeId;
int KType_Sockaddr_in = Sockaddr_inClass->typeId;
/* define Generics parameter for callback method */
//eventCB_p
kparamtype_t eventCB_p[] = {{KType_Int, 0}, {KType_Int, 0}, {KType_Object, 0}};
KClass *ceventCBfunc = KLIB KClass_Generics(kctx, KClass_Func, KType_void, 3, eventCB_p);
int KType_ceventCBfunc = ceventCBfunc->typeId;
//bev_dataCB_p
kparamtype_t bev_dataCB_p[] = {{KType_cbufferevent, 0}, {KType_Object, 0}};
KClass *Cbev_dataCBfunc = KLIB KClass_Generics(kctx, KClass_Func, KType_void, 2, bev_dataCB_p);
int KType_Cbev_dataCBfunc = Cbev_dataCBfunc->typeId;
//bev_eventCB_p
kparamtype_t bev_eventCB_p[] = {{KType_cbufferevent, 0}, {KType_Int, 0}, {KType_Object, 0}};
KClass *Cbev_eventCBfunc = KLIB KClass_Generics(kctx, KClass_Func, KType_void, 3, bev_eventCB_p);
int KType_Cbev_eventCBfunc = Cbev_eventCBfunc->typeId;
KDEFINE_METHOD MethodData[] = {
// System class
_Public|_Static, _F(System_evutil_make_socket_nonblocking), KType_Int, KType_System, KMethodName_("evutil_make_socket_nonblocking"), 1, KType_Int, KFieldName_("fd"),
// cevent_base
_Public, _F(cevent_base_new), KType_cevent_base, KType_cevent_base, KMethodName_("new"), 0,
_Public, _F(cevent_base_event_dispatch), KType_Int, KType_cevent_base, KMethodName_("event_dispatch"), 0,
// cevent
_Public, _F(cevent_new), KType_cevent, KType_cevent, KMethodName_("new"), 4, KType_cevent_base, KFieldName_("cevent_base"), KType_Int, KFieldName_("evd"), KType_Int, KFieldName_("event"), KType_eventCBArg, KFieldName_("CBarg"),
_Public, _F(cevent_event_add), KType_Int, KType_cevent, KMethodName_("event_add"), 1, KType_ctimeval, KFieldName_("timeval"),
_Public, _F(cevent_event_del), KType_Int, KType_cevent, KMethodName_("event_del"), 0,
_Public, _F(cevent_getID), KType_Int, KType_cevent, KMethodName_("getID"), 0,
_Public, _F(cevent_getEvents), KType_Int, KType_cevent, KMethodName_("getEvents"), 0,
// cbufferevent
_Public, _F(cbufferevent_new), KType_cbufferevent, KType_cbufferevent, KMethodName_("new"), 3, KType_cevent_base, KFieldName_("cevent_base"), KType_Int, KFieldName_("evd"), KType_Int, KFieldName_("options"),
_Public, _F(cbufferevent_setcb), KType_void, KType_cbufferevent, KMethodName_("bufferevent_setcb"), 1, KType_buffereventCBArg, KFieldName_("buffereventCBArg"),
_Public, _F(cbufferevent_socket_connect), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_socket_connect"), 1, KType_Sockaddr_in, KFieldName_("sockaddr"),
_Public, _F(cbufferevent_enable), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_enable"), 1, KType_Int, KFieldName_("event"),
_Public, _F(cbufferevent_write), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_write"), 1, KType_Bytes, KFieldName_("writebuffer"),
_Public, _F(cbufferevent_read), KType_Int, KType_cbufferevent, KMethodName_("bufferevent_read"), 1, KType_Bytes, KFieldName_("readbuffer"),
// eventCBArg
_Public, _F(eventCBArg_new), KType_eventCBArg, KType_eventCBArg, KMethodName_("new"), 2, KType_ceventCBfunc, KFieldName_("konoha_CB"), KType_Object, KFieldName_("CBarg"),
// buffereventCBArg
_Public, _F(buffereventCBArg_new), KType_buffereventCBArg, KType_buffereventCBArg, KMethodName_("new"), 4, KType_Cbev_dataCBfunc, KFieldName_("readCB"), KType_Cbev_dataCBfunc, KFieldName_("writeCB"), KType_Cbev_eventCBfunc, KFieldName_("eventCB"), KType_Object, KFieldName_("CBarg"),
// ctimeval
_Public, _F(ctimeval_new), KType_ctimeval, KType_ctimeval, KMethodName_("new"), 2, KType_Int, KFieldName_("tv_sec"), KType_Int, KFieldName_("tv_usec"),
// Sockaddr_in
_Public, _F(Sockaddr_in_new), KType_Sockaddr_in, KType_Sockaddr_in, KMethodName_("new"), 3, KType_Int, KFieldName_("family"), KType_Int, KFieldName_("addr"), KType_Int, KFieldName_("port"),
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_INT_CONST IntData[] = {
// === for event_new() ===
{KDefineConstInt(EV_TIMEOUT)},
{KDefineConstInt(EV_READ)},
{KDefineConstInt(EV_WRITE)},
{KDefineConstInt(EV_SIGNAL)},
{KDefineConstInt(EV_PERSIST)},
{KDefineConstInt(EV_ET)},
// === for bufferevent ===
// bufferevent.h
{KDefineConstInt(BEV_EVENT_READING)},
{KDefineConstInt(BEV_EVENT_WRITING)},
{KDefineConstInt(BEV_EVENT_EOF)},
{KDefineConstInt(BEV_EVENT_ERROR)},
{KDefineConstInt(BEV_EVENT_TIMEOUT)},
{KDefineConstInt(BEV_EVENT_CONNECTED)},
// bufferevent.h: enum bufferevent_options
{KDefineConstInt(BEV_OPT_CLOSE_ON_FREE)},
{KDefineConstInt(BEV_OPT_THREADSAFE)},
{KDefineConstInt(BEV_OPT_DEFER_CALLBACKS)},
{KDefineConstInt(BEV_OPT_UNLOCK_CALLBACKS)},
{KDefineConstInt(AF_INET)},// TODO should be implement in posix.socket package
{} /* <= sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KConst_(IntData), trace);
return true;
}
