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 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 var_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_INT_CONST ClassData[] = { // add Array as available
{"var", VirtualType_KonohaClass, (uintptr_t)CT_(TY_var)},
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(ClassData), trace);
return true;
}
static kbool_t float_ExportNameSpace(KonohaContext *kctx, kNameSpace *ns, kNameSpace *exportNS, int option, KTraceInfo *trace)
{
if(sizeof(kfloat_t) == sizeof(double)) {
KDEFINE_INT_CONST ClassData[] = { // add Array as available
{"double", VirtualType_KonohaClass, (uintptr_t)CT_Float},
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, exportNS, KonohaConst_(ClassData), false/*isOverride*/, trace);
}
return true;
}
static kbool_t float_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
if(CT_Float == NULL) {
KDEFINE_CLASS defFloat = {0};
SETUNBOXNAME(defFloat, float);
defFloat.cstruct_size = sizeof(kFloat);
defFloat.cflag = CFLAG_int;
defFloat.init = Float_Init;
defFloat.p = Float_p;
CT_Float = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defFloat, trace);
}
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, trace);
KDEFINE_FLOAT_CONST FloatData[] = {
{"FLOAT_EPSILON", TY_float, DBL_EPSILON},
{"Infinity", TY_float, INFINITY},
{"NaN", TY_float, NAN},
{NULL} /* sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(FloatData), false/*isOverride*/, trace);
return true;
}
static void path_defineAccessConst(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_INT_CONST intData[] = {
/*for System.access*/
{KDefineConstInt(R_OK)},
{KDefineConstInt(W_OK)},
{KDefineConstInt(X_OK)},
{KDefineConstInt(F_OK)},
{NULL} /* sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(intData), false/*isOverride*/, trace);
}
static kbool_t object_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, 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), false/*isOverride*/, trace);
object_defineMethod(kctx, ns, trace);
subtype_defineSyntax(kctx, ns, trace);
return true;
}
static kbool_t RENAMEME_InitNameSpace(KonohaContext *kctx, kNameSpace *packageNS, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_INT_CONST IntData[] = {
#define DEFINE_KEYWORD(KW) {#KW, TY_int, KW}
DEFINE_KEYWORD(KW_ExprPattern),
DEFINE_KEYWORD(KW_SymbolPattern),
DEFINE_KEYWORD(KW_TextPattern),
DEFINE_KEYWORD(KW_NumberPattern),
DEFINE_KEYWORD(KW_TypePattern),
DEFINE_KEYWORD(KW_ParenthesisGroup),
DEFINE_KEYWORD(KW_BracketGroup),
DEFINE_KEYWORD(KW_BraceGroup),
DEFINE_KEYWORD(KW_BlockPattern),
DEFINE_KEYWORD(KW_ParamPattern),
DEFINE_KEYWORD(KW_TokenPattern),
DEFINE_KEYWORD(TSTMT_UNDEFINED),
DEFINE_KEYWORD(TSTMT_ERR),
DEFINE_KEYWORD(TSTMT_EXPR),
DEFINE_KEYWORD(TSTMT_BLOCK),
DEFINE_KEYWORD(TSTMT_RETURN),
DEFINE_KEYWORD(TSTMT_IF),
DEFINE_KEYWORD(TSTMT_LOOP),
DEFINE_KEYWORD(TSTMT_JUMP),
DEFINE_KEYWORD(TEXPR_CONST),
DEFINE_KEYWORD(TEXPR_NEW),
DEFINE_KEYWORD(TEXPR_NULL),
DEFINE_KEYWORD(TEXPR_NCONST),
DEFINE_KEYWORD(TEXPR_LOCAL),
DEFINE_KEYWORD(TEXPR_BLOCK),
DEFINE_KEYWORD(TEXPR_FIELD),
// DEFINE_KEYWORD(TEXPR_BOX),
// DEFINE_KEYWORD(TEXPR_UNBOX),
DEFINE_KEYWORD(TEXPR_CALL),
DEFINE_KEYWORD(TEXPR_AND),
DEFINE_KEYWORD(TEXPR_OR),
DEFINE_KEYWORD(TEXPR_LET),
DEFINE_KEYWORD(TEXPR_STACKTOP),
DEFINE_KEYWORD(TypeCheckPolicy_NOCHECK),
DEFINE_KEYWORD(TypeCheckPolicy_ALLOWVOID),
DEFINE_KEYWORD(TypeCheckPolicy_COERCION),
DEFINE_KEYWORD(TypeCheckPolicy_CONST),
#undef DEFINE_KEYWORD
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(IntData), trace);
KDEFINE_SYNTAX SYNTAX[] = {
{ SYM_("syntax"), 0, "\"syntax\" $Token*", 0, 0, NULL, NULL, Statement_syntax, NULL, NULL, },
{ KW_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t process_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
kparamtype_t p = {TY_int};
KonohaClass *cintArray = KLIB KonohaClass_Generics(kctx, CT_(TY_Array), TY_void, 1, &p);
#define TY_intArray (cintArray->typeId)
KDEFINE_METHOD MethodData[] = {
_Public|_Static, _F(System_getpid), TY_int, TY_System, MN_("getpid"), 0,
_Public|_Static, _F(System_getppid), TY_int, TY_System, MN_("getppid"), 0,
_Public|_Static, _F(System_getuid), TY_int, TY_System, MN_("getuid"), 0,
_Public|_Static, _F(System_geteuid), TY_int, TY_System, MN_("geteuid"), 0,
_Public|_Static, _F(System_getgid), TY_int, TY_System, MN_("getgid"), 0,
_Public|_Static, _F(System_getegid), TY_int, TY_System, MN_("getegid"), 0,
_Public|_Static, _F(System_getpgid), TY_int, TY_System, MN_("getpgid"), 1, TY_int, FN_("pid"),
_Public|_Static, _F(System_setpgid), TY_int, TY_System, MN_("setpgid"), 2, TY_int, FN_("pid"), TY_int, FN_("pgid"),
_Public|_Static, _F(System_getpriority), TY_int, TY_System, MN_("getpriority"), 2, TY_int, FN_("which"), TY_int, FN_("who"),
_Public|_Static, _F(System_setpriority), TY_int, TY_System, MN_("setpriority"), 3, TY_int, FN_("which"), TY_int, FN_("who"), TY_int, FN_("priority"),
_Public|_Static, _F(System_getgroups), TY_int, TY_System, MN_("getgroups"), 2, TY_int, FN_("size"), TY_intArray, FN_("list[]"),
_Public|_Static, _F(System_setgroups), TY_int, TY_System, MN_("setgroups"), 2, TY_int, FN_("size"), TY_intArray, FN_("*list"),
_Public|_Static, _F(System_fork), TY_int, TY_System, MN_("fork"), 0,
_Public|_Static, _F(System_wait), TY_int, TY_System, MN_("wait"), 0,
_Public|_Static, _F(System_waitpid), TY_int, TY_System, MN_("wait"), 2, TY_int, FN_("pid"), TY_int, FN_("options"),
_Public|_Static, _F(System_setuid), TY_int, TY_System, MN_("setuid"), 1, TY_int, FN_("uid"),
_Public|_Static, _F(System_seteuid), TY_int, TY_System, MN_("seteuid"), 1, TY_int, FN_("euid"),
_Public|_Static, _F(System_setreuid), TY_int, TY_System, MN_("setreuid"), 2, TY_int, FN_("ruid"), TY_int, FN_("euid"),
_Public|_Static, _F(System_setgid), TY_int, TY_System, MN_("setgid"), 1, TY_int, FN_("gid"),
_Public|_Static, _F(System_setegid), TY_int, TY_System, MN_("setguid"), 1, TY_int, FN_("egid"),
_Public|_Static, _F(System_setregid), TY_int, TY_System, MN_("setrguid"), 2, TY_int, FN_("rgid"), TY_int, FN_("egid"),
_Public|_Static, _F(System_setsid), TY_int, TY_System, MN_("setsid"), 0,
_Public|_Static, _F(System_getsid), TY_int, TY_System, MN_("getsid"), 1, TY_int, FN_("pid"),
_Public|_Static, _F(System_sleep), TY_int, TY_System, MN_("sleep"), 1, TY_int, FN_("sec"),
_Public|_Static, _F(System_usleep), TY_boolean, TY_System, MN_("usleep"), 1, TY_int, FN_("usec"),
_Public|_Static, _F(System_system), TY_int, TY_System, MN_("system"), 1, TY_String, FN_("command"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_INT_CONST intData[] = {
{KDefineConstInt(SIGHUP)},
{KDefineConstInt(SIGINT)},
{KDefineConstInt(SIGABRT)},
{KDefineConstInt(SIGKILL)},
/*for System.setpriority*/
{KDefineConstInt(PRIO_PROCESS)},
{KDefineConstInt(PRIO_PGRP)},
{KDefineConstInt(PRIO_USER)},
{}
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(intData), false/*isOverride*/, trace);
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 sugar_ExportNameSpace(KonohaContext *kctx, kNameSpace *ns, kNameSpace *exportNS, int option, KTraceInfo *trace)
{
KDEFINE_INT_CONST IntData[] = {
#define DEFINE_KEYWORD(KW) {#KW, TY_int, KW}
DEFINE_KEYWORD(ErrTag),
DEFINE_KEYWORD(WarnTag),
DEFINE_KEYWORD(NoticeTag),
DEFINE_KEYWORD(InfoTag),
DEFINE_KEYWORD(DebugTag),
#undef DEFINE_KEYWORD
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, exportNS, KonohaConst_(IntData), trace);
return true;
}
static kbool_t array_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
KImportPackageSymbol(ns, "cstyle", "[]", trace);
KDEFINE_INT_CONST ClassData[] = { // add Array as available
{"Array", VirtualType_KonohaClass, (uintptr_t)CT_(TY_Array)},
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(ClassData), false/*isOverride*/, trace);
KonohaClass *CT_ArrayT0 = CT_p0(kctx, CT_Array, TY_0);
kattrtype_t TY_ArrayT0 = CT_ArrayT0->typeId;
kparamtype_t p[] = {{TY_0}};
kattrtype_t TY_FuncMap = (KLIB KonohaClass_Generics(kctx, CT_Func, TY_0 , 1, p))->typeId;
kparamtype_t P_inject[] = {{TY_0},{TY_0}};
kattrtype_t TY_FuncInject = (KLIB KonohaClass_Generics(kctx, CT_Func, TY_0 , 2, P_inject))->typeId;
KDEFINE_METHOD MethodData[] = {
_Public|_Im, _F(Array_get), TY_0, TY_Array, MN_("get"), 1, TY_int, FN_("index"),
_Public, _F(Array_set), TY_void, TY_Array, MN_("set"), 2, TY_int, FN_("index"), TY_0, FN_("value"),
_Public|_Im, _F(Array_removeAt), TY_0, TY_Array, MN_("removeAt"), 1, TY_int, FN_("index"),
_Public|_Const, _F(Array_getSize), TY_int, TY_Array, MN_("getSize"), 0,
_Public|_Const, _F(Array_getSize), TY_int, TY_Array, MN_("getlength"), 0,
_Public, _F(Array_clear), TY_void, TY_Array, MN_("clear"), 0,
_Public, _F(Array_Add1), TY_void, TY_Array, MN_("add"), 1, TY_0, FN_("value"),
_Public, _F(Array_Push), TY_int, TY_Array, MN_("push"), 1, TY_0, FN_("value"),
_Public, _F(Array_Pop), TY_0, TY_Array, MN_("pop"), 0,
_Public, _F(Array_shift), TY_0, TY_Array, MN_("shift"), 0,
_Public, _F(Array_unshift), TY_int, TY_Array, MN_("unshift"), 1, TY_0, FN_("value"),
_Public, _F(Array_reverse), TY_Array, TY_Array, MN_("reverse"), 0,
// _Public|_Im, _F(Array_map), TY_ArrayT0, TY_Array, MN_("map"), 1, TY_FuncMap, FN_("func"),
// _Public|_Im, _F(Array_inject), TY_0, TY_Array, MN_("inject"), 1, TY_FuncInject, FN_("func"),
_Public, _F(Array_concat), TY_ArrayT0, TY_Array, MN_("concat"), 1, TY_ArrayT0, FN_("a1"),
_Public, _F(Array_indexOf), TY_int, TY_Array, MN_("indexOf"), 1, TY_0, FN_("value"),
_Public, _F(Array_lastIndexOf), TY_int, TY_Array, MN_("lastIndexOf"), 1, TY_0, FN_("value"),
// _Public, _F(Array_toString), TY_String, TY_Array, MN_("toString"), 0,
_Public|_Im, _F(Array_new), TY_void, TY_Array, MN_("new"), 1, TY_int, FN_("size"),
_Public, _F(Array_newArray), TY_Array, TY_Array, MN_("newArray"), 1, TY_int, FN_("size"),
_Public|kMethod_Hidden, _F(Array_newList), TY_Array, TY_Array, MN_("[]"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static KonohaClassVar* kNameSpace_DefineClassName(KonohaContext *kctx, kNameSpace *ns, kshortflag_t cflag, kString *name, KTraceInfo *trace)
{
KDEFINE_CLASS defNewClass = {0};
defNewClass.cflag = cflag | kClass_Nullable;
defNewClass.typeId = TY_newid;
defNewClass.baseTypeId = TY_Object;
defNewClass.superTypeId = TY_Object; //superClass->typeId;
defNewClass.init = Object_InitToMakeDefaultValueAsNull; // dummy for first generation of DefaultValueAsNull
KonohaClassVar *definedClass = (KonohaClassVar *)KLIB kNameSpace_DefineClass(kctx, ns, name, &defNewClass, trace);
KDEFINE_CLASS_CONST ClassData[] = {
{S_text(name), VirtualType_KonohaClass, definedClass},
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(ClassData), false/*isOverride*/, true);
return definedClass;
}
static kbool_t fd_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public|_Static, _F(System_lseek), TY_int, TY_System, MN_("lseek"), 3, TY_int, FN_("fd"), TY_int, FN_("offset"), TY_int, FN_("whence"),
_Public|_Static, _F(System_ftruncate), TY_boolean, TY_System, MN_("ftruncate"), 2, TY_int, FN_("fd"), TY_int, FN_("length"),
_Public|_Static, _F(System_fchmod), TY_boolean, TY_System, MN_("fchmod"), 2, TY_int, FN_("fd"), TY_int, FN_("length"),
_Public|_Static, _F(System_flock), TY_boolean, TY_System, MN_("flock"), 2, TY_int, FN_("fd"), TY_int, FN_("operation"),
_Public|_Static, _F(System_sync), TY_boolean, TY_System, MN_("sync"), 1, TY_int, FN_("fd"),
_Public|_Static, _F(System_fchown), TY_boolean, TY_System, MN_("fchown"), 3, TY_int, FN_("pd"), TY_int, FN_("owner"), TY_int, FN_("group"),
_Public|_Static, _F(System_fsync), TY_boolean, TY_System, MN_("fsync"), 1, TY_int, FN_("fd"),
_Public|_Static|_Const|_Im, _F(System_getdtablesize), TY_int, TY_System, MN_("getdtablesize"), 0,
_Public|_Static|_Im, _F(System_open), TY_int, TY_System, MN_("open"), 2, TY_String, FN_("pathname"), TY_int, FN_("flags"),
_Public|_Static|_Im, _F(System_open_mode), TY_int, TY_System, MN_("open"), 3, TY_String, FN_("pathname"), TY_int, FN_("flags"), TY_int, FN_("mode"),
_Public|_Static|_Im, _F(System_fchdir), TY_boolean, TY_System, MN_("fchdir"), 1, TY_int, FN_("fd"),
_Public|_Static|_Im, _F(System_isatty), TY_boolean, TY_System, MN_("isatty"), 1, TY_int, FN_("fd"),
_Public|_Static|_Im, _F(System_ttyname), TY_String, TY_System, MN_("ttyname"), 1, TY_int, FN_("fd"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_INT_CONST intData[] = {
/*for System.lseek*/
{KDefineConstInt(SEEK_SET)},
{KDefineConstInt(SEEK_CUR)},
{KDefineConstInt(SEEK_END)},
/*for System.flock*/
{KDefineConstInt(LOCK_SH)},
{KDefineConstInt(LOCK_EX)},
{KDefineConstInt(LOCK_UN)},
{KDefineConstInt(LOCK_NB)},
/*for System.open*/
{KDefineConstInt(O_RDONLY)},
{KDefineConstInt(O_WRONLY)},
{KDefineConstInt(O_RDWR)},
{KDefineConstInt(O_CREAT)},
{KDefineConstInt(O_EXCL)},
{KDefineConstInt(O_TRUNC)},
{KDefineConstInt(O_APPEND)},
{KDefineConstInt(O_NONBLOCK)},
{KDefineConstInt(O_NDELAY)},
{KDefineConstInt(O_NOCTTY)},
{NULL}, /* sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(intData), 0);
return true;
}
mod->cApache = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &apacheDef, 0);
KDEFINE_INT_CONST IntData[] = {
#define DEFINE_KEYWORD(KW) {#KW, TY_int, KW}
DEFINE_KEYWORD(OK),
DEFINE_KEYWORD(APLOG_EMERG),
DEFINE_KEYWORD(APLOG_ALERT),
DEFINE_KEYWORD(APLOG_CRIT),
DEFINE_KEYWORD(APLOG_ERR),
DEFINE_KEYWORD(APLOG_WARNING),
DEFINE_KEYWORD(APLOG_NOTICE),
DEFINE_KEYWORD(APLOG_INFO),
DEFINE_KEYWORD(APLOG_DEBUG),
{NULL, 0, 0}
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(IntData), false/*isOverride*/, trace);
return true;
}
static kbool_t apache_ExportNameSpace(KonohaContext *kctx, kNameSpace *ns, kNameSpace *exportNS, int option, KTraceInfo *trace)
{
return true;
}
KDEFINE_PACKAGE* apache_Init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("apache", "1.0"),
.PackupNameSpace = apache_PackupNameSpace,
.ExportNameSpace = apache_ExportNameSpace,
};
static kbool_t sugar_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KonohaClass *cSymbol = defineSymbolClass(kctx, ns, trace);
KonohaClass *ccid = loadcidClass(kctx, ns, trace);
KDEFINE_INT_CONST ClassData[] = { // add Array as available
{"Token", VirtualType_KonohaClass, (uintptr_t)CT_Token},
{"Stmt", VirtualType_KonohaClass, (uintptr_t)CT_Stmt},
{"Expr", VirtualType_KonohaClass, (uintptr_t)CT_Expr},
{"Block", VirtualType_KonohaClass, (uintptr_t)CT_Block},
{"Gamma", VirtualType_KonohaClass, (uintptr_t)CT_Gamma},
{"NameSpace", VirtualType_KonohaClass, (uintptr_t)CT_NameSpace},
{"symbol", VirtualType_KonohaClass, (uintptr_t)cSymbol},
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(ClassData), 0);
int TY_Symbol = cSymbol->typeId;
sugar_defineTokenFunc(kctx, ns, TY_Symbol, trace);
sugar_defineMessageMethod(kctx, ns, TY_Symbol, trace);
int FN_buildid = FN_("buildid"), FN_key = FN_("key"), FN_defval = FN_("defval");
int FN_typeid = FN_("typeid"), FN_gma = FN_("gma"), FN_pol = FN_("pol");
int FN_msg = FN_("msg");
int FN_x = FN_("x");
int FN_tokenList = FN_("tokens"), FN_s = FN_("s"), FN_e = FN_("e");
int FN_expr = FN_("expr");
/* Array[String] */
kparamtype_t P_StringArray[] = {{TY_String}};
int TY_StringArray = (KLIB KonohaClass_Generics(kctx, CT_Array, TY_void, 1, P_StringArray))->typeId;
ktype_t TY_symbol = cSymbol->typeId;
ktype_t TY_cid = ccid->typeId;
KDEFINE_METHOD MethodData[] = {
/* Token */
_Public, _F(Token_new), TY_Token, TY_Token, MN_("new"), 1, TY_symbol, FN_key,
_Public, _F(Token_setUnresolvedTokenType), TY_void, TY_Token, MN_("setUnresolvedTokenType"), 1, TY_symbol, FN_x,
_Public, _F(Token_setText), TY_void, TY_Token, MN_("setText"), 1, TY_String, FN_x,
_Public, _F(Token_setSubArray), TY_void, TY_Token, MN_("setSubArray"), 1, TY_StringArray, FN_x,
// _Public, _F(Token_isTypeName), TY_boolean, TY_Token, MN_("isTypeName"), 0,
_Public, _F(Token_isParenthesis), TY_boolean, TY_Token, MN_("isParenthesis"), 0,
_Public, _F(Token_getText), TY_String, TY_Token, MN_("getText"), 0,
_Public, _F(Token_isSymbol), TY_boolean, TY_Token, MN_("isSymbol"), 0,
_Public, _F(Token_newUntypedExpr), TY_Expr, TY_Token, MN_("newUntypedExpr"), 0,
_Public, _F(Token_isBeforeWhiteSpace), TY_boolean, TY_Token, MN_("isBeforeWhiteSpace"), 0,
/* Stmt */
_Public, _F(Stmt_getBuild), TY_int, TY_Stmt, MN_("getBuild"), 0,
_Public, _F(Stmt_setBuild), TY_void, TY_Stmt, MN_("setBuild"), 1, TY_int, FN_buildid,
_Public, _F(Stmt_getBlock), TY_Block, TY_Stmt, MN_("getBlock"), 2, TY_symbol, FN_key, TY_Block, FN_defval,
_Public, _F(Stmt_getToken), TY_Token, TY_Stmt, MN_("getToken"), 2, TY_symbol, FN_key, TY_Token, FN_defval,
_Public, _F(Stmt_getExpr), TY_Expr, TY_Stmt, MN_("getExpr"), 2, TY_symbol, FN_key, TY_Expr, FN_defval,
_Public, _F(Stmt_TypeCheckExpr), TY_boolean, TY_Stmt, MN_("TypeCheckExpr"), 3, TY_symbol, FN_key, TY_Gamma, FN_gma, TY_cid, FN_typeid,
_Public, _F(Stmt_TypeCheckExprPol), TY_boolean, TY_Stmt, MN_("TypeCheckExpr"), 4, TY_symbol, FN_key, TY_Gamma, FN_gma, TY_cid, FN_typeid, TY_int, FN_pol,
_Public, _F(Stmt_Message2rintError), TY_Expr, TY_Stmt, MN_("printError"), 1, TY_String, FN_msg,
_Public, _F(Stmt_newExpr), TY_Expr, TY_Stmt, MN_("newExpr"), 3, TY_TokenArray, FN_tokenList, TY_int, FN_s, TY_int, FN_e,
_Public, _F(Stmt_setType), TY_void, TY_Stmt, MN_("setType"), 1, TY_int, FN_x,
// _Public, _F(kStmt_Message2arsedExpr), TY_Expr, TY_Stmt, MN_("parseExpr"), 3, TY_TokenArray, FN_tokenList, TY_int, FN_s, TY_int, FN_e,
_Public, _F(Stmt_newUntypedCallStyleExpr2), TY_Expr, TY_Stmt, MN_("newUntypedCallStyleExpr"), 2, TY_Token, FN_("token"), TY_Expr, FN_("expr1"),
_Public, _F(Stmt_newUntypedCallStyleExpr3), TY_Expr, TY_Stmt, MN_("newUntypedCallStyleExpr"), 3, TY_Token, FN_("token"), TY_Expr, FN_("expr1"), TY_Expr, FN_("expr2"),
_Public, _F(Stmt_newUntypedCallStyleExpr4), TY_Expr, TY_Stmt, MN_("newUntypedCallStyleExpr"), 4, TY_Token, FN_("token"), TY_Expr, FN_("expr1"), TY_Expr, FN_("expr2"), TY_Expr, FN_("expr3"),
_Public, _F(Stmt_newUntypedCallStyleExpr5), TY_Expr, TY_Stmt, MN_("newUntypedCallStyleExpr"), 5, TY_Token, FN_("token"), TY_Expr, FN_("expr1"), TY_Expr, FN_("expr2"), TY_Expr, FN_("expr3"), TY_Expr, FN_("expr4"),
_Public, _F(Stmt_newUntypedCallStyleExpr6), TY_Expr, TY_Stmt, MN_("newUntypedCallStyleExpr"), 6, TY_Token, FN_("token"), TY_Expr, FN_("expr1"), TY_Expr, FN_("expr2"), TY_Expr, FN_("expr3"), TY_Expr, FN_("expr4"), TY_Expr, FN_("expr5"),
_Public, _F(Stmt_newTypedCallExpr1), TY_Expr, TY_Stmt, MN_("newTypedCallExpr"), 4, TY_Gamma, FN_gma, TY_cid, FN_typeid, TY_symbol, FN_("methodName"), TY_Expr, FN_("firstExpr"),
_Public, _F(Stmt_newTypedCallExpr2), TY_Expr, TY_Stmt, MN_("newTypedCallExpr"), 5, TY_Gamma, FN_gma, TY_cid, FN_typeid, TY_symbol, FN_("methodName"), TY_Expr, FN_("firstExpr"), TY_Expr, FN_("secondExpr"),
_Public, _F(Stmt_rightJoinExpr), TY_Expr, TY_Stmt, MN_("rightJoinExpr"), 4, TY_Expr, FN_expr, TY_TokenArray, FN_tokenList, TY_int, FN_s, TY_int, FN_e,
_Public, _F(Stmt_getTokenList), TY_TokenArray, TY_Stmt, MN_("getTokenList"), 2, TY_symbol, FN_key, TY_TokenArray, FN_defval,
_Public, _F(Stmt_done), TY_void, TY_Stmt, MN_("done"), 0,
_Public, _F(Stmt_setObject), TY_void, TY_Stmt, MN_("setExpr"), 2, TY_symbol, FN_key, TY_Expr, FN_expr,
_Public, _F(Stmt_setObject), TY_void, TY_Stmt, MN_("setBlock"), 2, TY_symbol, FN_key, TY_Block, FN_("block"),
_Public, _F(Stmt_declType), TY_boolean, TY_Stmt, MN_("declType"), 3, TY_Gamma, FN_gma, TY_cid, FN_typeid, TY_Expr, FN_("declExpr"),
_Public, _F(Stmt_newBlock), TY_Block, TY_Stmt, MN_("newBlock"), 1, TY_String, FN_("macro"),
/* Expr */
_Public, _F(Expr_getTermToken), TY_Token, TY_Expr, MN_("getTermToken"), 0,
_Public, _F(Expr_setConstValue), TY_Expr, TY_Expr, MN_("setConstValue"), 1, TY_Object, FN_("value") | FN_COERCION,
_Public, _F(Expr_setVariable), TY_Expr, TY_Expr, MN_("setVariable"), 4, TY_Gamma, FN_gma, TY_int, FN_buildid, TY_cid, FN_typeid, TY_int, FN_("index"),
_Public, _F(Expr_newVariableExpr), TY_Expr, TY_Expr, MN_("new"), 4, TY_Gamma, FN_gma, TY_int, FN_buildid, TY_cid, FN_typeid, TY_int, FN_("index"),
_Public, _F(Expr_new), TY_Expr, TY_Expr, MN_("new"), 1, TY_Object, FN_("value") | FN_COERCION,
_Public, _F(Expr_setType), TY_void, TY_Expr, MN_("setType"), 2, TY_int, FN_buildid, TY_cid, FN_typeid,
_Public, _F(kExpr_AddExpr), TY_Expr, TY_Expr, MN_("addExpr"), 1, TY_Expr, FN_expr,
/* Block */
_Public, _F(Block_TypeCheckAll), TY_boolean, TY_Block, MN_("TypeCheckAll"), 1, TY_Gamma, FN_gma,
/* Gamma */
_Public, _F(Gamma_declareLocalVariable), TY_int, TY_Gamma, MN_("declareLocalVariable"), 2, TY_cid, FN_typeid, TY_symbol, FN_key,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
LoadNameSpaceMethodData(kctx, ns, TY_symbol, trace);
RENAMEME_InitNameSpace(kctx, ns, ns, 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 curl_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
KRequirePackage("konoha.file", trace);
KDEFINE_CLASS defCurl = {
STRUCTNAME(Curl),
.cflag = kClass_Final,
.init = Curl_Init,
.reftrace = Curl_Reftrace,
.free = Curl_Free,
};
KonohaClass *cCurl = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defCurl, trace);
KDEFINE_METHOD MethodData[] = {
_Public, _F(Curl_new), TY_Curl, TY_Curl, MN_("new"), 0,
_Public, _F(Curl_setOptBoolean), TY_void, TY_Curl, MN_("setOpt"), 2, TY_int, FN_("option"), TY_boolean, FN_("data"),
_Public, _F(Curl_setOptInt), TY_void, TY_Curl, MN_("setOpt"), 2, TY_int, FN_("option"), TY_int, FN_("data"),
_Public, _F(Curl_setOptString), TY_void, TY_Curl, MN_("setOpt"), 2, TY_int, FN_("option"), TY_String, FN_("data"),
_Public, _F(Curl_setOptFile), TY_void, TY_Curl, MN_("setOpt"), 2, TY_int, FN_("option"), TY_File, FN_("data"),
_Public, _F(Curl_appendHeader), TY_void, TY_Curl, MN_("appendHeader"), 1, TY_String, FN_("header"),
_Public, _F(Curl_perform), TY_boolean, TY_Curl, MN_("perform"), 0,
_Public, _F(Curl_receiveString), TY_String, TY_Curl, MN_("receiveString"), 0,
_Public|_Im, _F(Curl_getInfo), TY_Object/*FIXME TY_Dynamic*/, TY_Curl, MN_("getInfo"), 1, TY_int, FN_("type"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_INT_CONST IntData[] = {
{KDefineConstInt(CURLOPT_AUTOREFERER)},
{KDefineConstInt(CURLOPT_COOKIESESSION)},
{KDefineConstInt(CURLOPT_CRLF)},
{KDefineConstInt(CURLOPT_DNS_USE_GLOBAL_CACHE)},
{KDefineConstInt(CURLOPT_FAILONERROR)},
{KDefineConstInt(CURLOPT_FILETIME)},
{KDefineConstInt(CURLOPT_FOLLOWLOCATION)},
{KDefineConstInt(CURLOPT_FORBID_REUSE)},
{KDefineConstInt(CURLOPT_FRESH_CONNECT)},
{KDefineConstInt(CURLOPT_FTP_USE_EPRT)},
{KDefineConstInt(CURLOPT_FTP_USE_EPSV)},
{KDefineConstInt(CURLOPT_FTPAPPEND)},
{KDefineConstInt(CURLOPT_FTPLISTONLY)},
{KDefineConstInt(CURLOPT_HEADER)},
{KDefineConstInt(CURLOPT_HTTPGET)},
{KDefineConstInt(CURLOPT_HTTPPROXYTUNNEL)},
{KDefineConstInt(CURLOPT_NETRC)},
{KDefineConstInt(CURLOPT_NOBODY)},
{KDefineConstInt(CURLOPT_NOPROGRESS)},
{KDefineConstInt(CURLOPT_NOSIGNAL)},
{KDefineConstInt(CURLOPT_POST)},
{KDefineConstInt(CURLOPT_PUT)},
{KDefineConstInt(CURLOPT_SSL_VERIFYPEER)},
{KDefineConstInt(CURLOPT_TRANSFERTEXT)},
{KDefineConstInt(CURLOPT_UNRESTRICTED_AUTH)},
{KDefineConstInt(CURLOPT_UPLOAD)},
{KDefineConstInt(CURLOPT_VERBOSE)},
{KDefineConstInt(CURLOPT_BUFFERSIZE)},
{KDefineConstInt(CURLOPT_CLOSEPOLICY)},
{KDefineConstInt(CURLOPT_CONNECTTIMEOUT)},
{KDefineConstInt(CURLOPT_DNS_CACHE_TIMEOUT)},
{KDefineConstInt(CURLOPT_FTPSSLAUTH)},
{KDefineConstInt(CURLOPT_HTTP_VERSION)},
{KDefineConstInt(CURLOPT_HTTPAUTH)},
{KDefineConstInt(CURLAUTH_ANY)},
{KDefineConstInt(CURLAUTH_ANYSAFE)},
{KDefineConstInt(CURLOPT_INFILESIZE)},
{KDefineConstInt(CURLOPT_LOW_SPEED_LIMIT)},
{KDefineConstInt(CURLOPT_LOW_SPEED_TIME)},
{KDefineConstInt(CURLOPT_MAXCONNECTS)},
{KDefineConstInt(CURLOPT_MAXREDIRS)},
{KDefineConstInt(CURLOPT_PORT)},
{KDefineConstInt(CURLOPT_PROXYAUTH)},
{KDefineConstInt(CURLOPT_PROXYPORT)},
{KDefineConstInt(CURLOPT_PROXYTYPE)},
{KDefineConstInt(CURLOPT_RESUME_FROM)},
{KDefineConstInt(CURLOPT_SSL_VERIFYHOST)},
{KDefineConstInt(CURLOPT_SSLVERSION)},
{KDefineConstInt(CURLOPT_TIMECONDITION)},
{KDefineConstInt(CURLOPT_TIMEOUT)},
{KDefineConstInt(CURLOPT_TIMEVALUE)},
{KDefineConstInt(CURLOPT_CAINFO)},
{KDefineConstInt(CURLOPT_CAPATH)},
{KDefineConstInt(CURLOPT_COOKIE)},
{KDefineConstInt(CURLOPT_COOKIEFILE)},
{KDefineConstInt(CURLOPT_COOKIEJAR)},
{KDefineConstInt(CURLOPT_CUSTOMREQUEST)},
{KDefineConstInt(CURLOPT_ENCODING)},
{KDefineConstInt(CURLOPT_FTPPORT)},
{KDefineConstInt(CURLOPT_INTERFACE)},
{KDefineConstInt(CURLOPT_KRB4LEVEL)},
{KDefineConstInt(CURLOPT_POSTFIELDS)},
{KDefineConstInt(CURLOPT_PROXY)},
{KDefineConstInt(CURLOPT_PROXYUSERPWD)},
{KDefineConstInt(CURLOPT_RANDOM_FILE)},
{KDefineConstInt(CURLOPT_RANGE)},
{KDefineConstInt(CURLOPT_REFERER)},
{KDefineConstInt(CURLOPT_SSL_CIPHER_LIST)},
{KDefineConstInt(CURLOPT_SSLCERT)},
{KDefineConstInt(CURLOPT_SSLCERTTYPE)},
{KDefineConstInt(CURLOPT_SSLENGINE)},
{KDefineConstInt(CURLOPT_SSLENGINE_DEFAULT)},
{KDefineConstInt(CURLOPT_SSLKEY)},
{KDefineConstInt(CURLOPT_SSLKEYTYPE)},
{KDefineConstInt(CURLOPT_URL)},
{KDefineConstInt(CURLOPT_USERAGENT)},
{KDefineConstInt(CURLOPT_USERPWD)},
{KDefineConstInt(CURLOPT_FILE)},
{KDefineConstInt(CURLOPT_WRITEDATA)},
{KDefineConstInt(CURLOPT_READDATA)},
{KDefineConstInt(CURLOPT_STDERR)},
{KDefineConstInt(CURLOPT_WRITEHEADER)},
{KDefineConstInt(CURLINFO_HEADER_SIZE)},
{KDefineConstInt(CURLINFO_REQUEST_SIZE)},
{KDefineConstInt(CURLINFO_REDIRECT_TIME)},
{KDefineConstInt(CURLINFO_TOTAL_TIME)},
{KDefineConstInt(CURLINFO_NAMELOOKUP_TIME)},
{KDefineConstInt(CURLINFO_CONNECT_TIME)},
{KDefineConstInt(CURLINFO_PRETRANSFER_TIME)},
{KDefineConstInt(CURLINFO_STARTTRANSFER_TIME)},
{KDefineConstInt(CURLINFO_SIZE_UPLOAD)},
{KDefineConstInt(CURLINFO_SIZE_DOWNLOAD)},
{KDefineConstInt(CURLINFO_SPEED_DOWNLOAD)},
{KDefineConstInt(CURLINFO_SPEED_UPLOAD)},
{KDefineConstInt(CURLINFO_EFFECTIVE_URL)},
{KDefineConstInt(CURLINFO_CONTENT_TYPE)},
{} // end of const data
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(IntData), false/*isOverride*/, trace);
return true;
}
base->cApache = KLIB kNameSpace_defineClass(kctx, ns, NULL, &apacheDef, 0);
KDEFINE_INT_CONST IntData[] = {
#define DEFINE_KEYWORD(KW) {#KW, TY_int, KW}
{"APACHE_OK", TY_int, OK},
{"APLOG_EMERG", TY_int, APLOG_EMERG},
{"APLOG_ALERT", TY_int, APLOG_ALERT},
{"APLOG_CRIT", TY_int, APLOG_CRIT},
{"APLOG_ERR", TY_int, APLOG_ERR},
{"APLOG_WARNING", TY_int, APLOG_WARNING},
{"APLOG_NOTICE", TY_int, APLOG_NOTICE},
{"APLOG_INFO", TY_int, APLOG_INFO},
{"APLOG_DEBUG", TY_int, APLOG_DEBUG},
{NULL, 0, 0}
};
KLIB kNameSpace_loadConstData(kctx, ns, KonohaConst_(IntData), 0);
return true;
}
static kbool_t apache_setupPackage(KonohaContext *kctx, kNameSpace *ns, isFirstTime_t isFirstTime, KTraceInfo *trace)
{
return true;
}
KDEFINE_PACKAGE* apache_init(void)
{
static KDEFINE_PACKAGE d = {
KPACKNAME("apache", "1.0"),
.initPackage = apache_initPackage,
.setupPackage = apache_setupPackage,
};
