static kbool_t class_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KImportPackage(ns, "MiniKonoha.ObjectModel", trace);
class_defineSyntax(kctx, ns, trace);
class_defineMethod(kctx, ns, trace);
return true;
}
static kbool_t float_defineSyntax(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
/* Use Syntax.Number package's Parser to parsing FloatLiteral */
KImportPackage(ns, "Syntax.Number", trace);
kSyntax *numberSyntax = kSyntax_(ns, KSymbol_NumberPattern);
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("$Float"), SYNFLAG_CTypeFunc, 0, 0, {numberSyntax->ParseFuncNULL}, {SUGARFUNC TypeCheck_Float}, KonohaChar_Digit, {numberSyntax->TokenFuncNULL}},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
/* ------------------------------------------------------------------------ */
static kbool_t Lisp_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KImportPackage(ns, "Syntax.CStyleBitwiseOperator", trace);
KDEFINE_SYNTAX SYNTAX[] = {
#define TOKEN(T) KSymbol_##T
{ TOKEN(ADD), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(SUB), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(MUL), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(DIV), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(MOD), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ KSymbol_END, }, /* sentinental */
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
KonohaContext* konoha_create(KonohaClass **cRequest)
{
struct KonohaFactory factory = {};
int argc = 0;
char *argv[1] = {0};
KonohaFactory_SetDefaultFactory(&factory, PosixFactory, argc, argv);
ApacheFactory(&factory);
KonohaContext* kctx = KonohaFactory_CreateKonoha(&factory);
KBaseTrace(trace);
kNameSpace *ns = KNULL(NameSpace);
KImportPackage(ns, "apache", trace);
*cRequest = CT_Request;
#define _P kMethod_Public
#define _F(F) (intptr_t)(F)
#define TY_Req (CT_Request->typeId)
#define TY_Tbl (CT_AprTable->typeId)
#define TY_TblEntry (CT_AprTableEntry->typeId)
KonohaClass *CT_TblEntryArray = CT_p0(kctx, CT_Array, TY_TblEntry);
ktype_t TY_TblEntryArray = CT_TblEntryArray->typeId;
int FN_x = FN_("x");
KDEFINE_METHOD MethodData[] = {
_P, _F(Request_puts), TY_void, TY_Req, MN_("puts"), 1, TY_String, FN_x,
_P, _F(Request_getMethod), TY_String, TY_Req, MN_("getMethod"), 0,
_P, _F(Request_getArgs), TY_String, TY_Req, MN_("getArgs"), 0,
_P, _F(Request_getUri), TY_String, TY_Req, MN_("getUri"), 0,
_P, _F(Request_getPathInfo), TY_String, TY_Req, MN_("getPathInfo"), 0,
_P, _F(Request_getHandler), TY_String, TY_Req, MN_("getHandler"), 0,
_P, _F(Request_setContentType), TY_void, TY_Req, MN_("setContentType"), 1, TY_String, FN_("type"),
_P, _F(Request_setContentEncoding), TY_void, TY_Req, MN_("setContentEncoding"), 1, TY_String, FN_("enc"),
_P, _F(Request_logError), TY_void, TY_Req, MN_("logError"), 3, TY_int, FN_("level"), TY_int, FN_("status"), TY_String, FN_("msg"),
_P, _F(Request_getHeadersIn), TY_Tbl, TY_Req, MN_("getHeadersIn"), 0,
_P, _F(Request_getHeadersOut), TY_Tbl, TY_Req, MN_("getHeadersOut"), 0,
_P, _F(AprTable_Add), TY_void, TY_Tbl, MN_("add"), 2, TY_String, FN_("key"), TY_String, FN_("val"),
_P, _F(AprTable_set), TY_void, TY_Tbl, MN_("set"), 2, TY_String, FN_("key"), TY_String, FN_("val"),
_P, _F(AprTable_getElts), TY_TblEntryArray, TY_Tbl, MN_("getElts"), 0,
_P, _F(AprTableEntry_getKey), TY_String, TY_TblEntry, MN_("getKey"), 0,
_P, _F(AprTableEntry_getVal), TY_String, TY_TblEntry, MN_("getVal"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return kctx;
}
KonohaContext* konoha_create(KClass **cRequest, int verbose_debug)
{
struct KonohaFactory factory = {};
factory.verbose_debug = verbose_debug;
int argc = 0;
char *argv[1] = {0};
KonohaFactory_SetDefaultFactory(&factory, PosixFactory, argc, argv);
ApacheFactory(&factory);
KonohaContext* kctx = KonohaFactory_CreateKonoha(&factory);
KBaseTrace(trace);
kNameSpace *ns = KNULL(NameSpace);
KImportPackage(ns, "Lib.Apache", trace);
*cRequest = KClass_Request;
#define KType_Req (KClass_Request->typeId)
#define KType_Tbl (KClass_AprTable->typeId)
#define KType_TblEntry (KClass_AprTableEntry->typeId)
KClass *KClass_TblEntryArray = KClass_p0(kctx, KClass_Array, KType_TblEntry);
ktypeattr_t KType_TblEntryArray = KClass_TblEntryArray->typeId;
int FN_x = KFieldName_("x");
KDEFINE_METHOD MethodData[] = {
_Public, _F(Request_puts), KType_void, KType_Req, KMethodName_("puts"), 1, KType_String, FN_x,
_Public, _F(Request_getMethod), KType_String, KType_Req, KMethodName_("getMethod"), 0,
_Public, _F(Request_getArgs), KType_String, KType_Req, KMethodName_("getArgs"), 0,
_Public, _F(Request_getUri), KType_String, KType_Req, KMethodName_("getUri"), 0,
_Public, _F(Request_getPathInfo), KType_String, KType_Req, KMethodName_("getPathInfo"), 0,
_Public, _F(Request_getHandler), KType_String, KType_Req, KMethodName_("getHandler"), 0,
_Public, _F(Request_SetContentType), KType_void, KType_Req, KMethodName_("setContentType"), 1, KType_String, KFieldName_("type"),
_Public, _F(Request_SetContentEncoding), KType_void, KType_Req, KMethodName_("setContentEncoding"), 1, KType_String, KFieldName_("enc"),
_Public, _F(Request_logError), KType_void, KType_Req, KMethodName_("logError"), 3, KType_Int, KFieldName_("level"), KType_Int, KFieldName_("status"), KType_String, KFieldName_("msg"),
_Public, _F(Request_getHeadersIn), KType_Tbl, KType_Req, KMethodName_("getHeadersIn"), 0,
_Public, _F(Request_getHeadersOut), KType_Tbl, KType_Req, KMethodName_("getHeadersOut"), 0,
_Public, _F(AprTable_Add), KType_void, KType_Tbl, KMethodName_("add"), 2, KType_String, KFieldName_("key"), KType_String, KFieldName_("val"),
_Public, _F(AprTable_Set), KType_void, KType_Tbl, KMethodName_("set"), 2, KType_String, KFieldName_("key"), KType_String, KFieldName_("val"),
_Public, _F(AprTable_getElts), KType_TblEntryArray, KType_Tbl, KMethodName_("getElts"), 0,
_Public, _F(AprTableEntry_getKey), KType_String, KType_TblEntry, KMethodName_("getKey"), 0,
_Public, _F(AprTableEntry_getVal), KType_String, KType_TblEntry, KMethodName_("getVal"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return kctx;
}
static kbool_t global_ExportNameSpace(KonohaContext *kctx, kNameSpace *ns, kNameSpace *exportNS, int option, KTraceInfo *trace)
{
KImportPackage(exportNS, "konoha.field", trace);
return kNameSpace_InitGlobalObject(kctx, exportNS, trace);
}