static KonohaContextVar* new_KonohaContext(KonohaContext *kctx, PlatformApi *platApi)
{
KonohaContextVar *newctx;
static volatile size_t ctxid_counter = 0;
ctxid_counter++;
if(kctx == NULL) { // NULL means first one
KonohaLibVar *klib = (KonohaLibVar *)calloc(sizeof(KonohaLib) + sizeof(KonohaContextVar), 1);
klib_Init(klib);
klib->KRuntime_SetModule = KRuntime_SetModule;
klib->KonohaContext_Init = new_KonohaContext;
klib->KonohaContext_Free = KonohaContext_Free;
klib->ReftraceAll = ReftraceAll;
klib->KonohaFactory_CreateKonoha = KonohaFactory_CreateKonoha;
klib->Konoha_Destroy = Konoha_Destroy;
newctx = (KonohaContextVar *)(klib + 1);
newctx->klib = (KonohaLib *)klib;
newctx->platApi = platApi;
kctx = (KonohaContext *)newctx;
newctx->runtimeModels = (KRuntimeModel**)calloc(sizeof(KRuntimeModel *), KRuntimeModel_MAXSIZE);
newctx->localContexts = (KModelContext**)calloc(sizeof(KModelContext *), KRuntimeModel_MAXSIZE);
DBG_ASSERT(PLATAPI GCModule.InitGcContext != NULL);
PLATAPI GCModule.InitGcContext(newctx);
PLATAPI JsonModule.InitJsonContext(newctx);
KRuntime_Init(kctx, newctx);
}
else { // others take ctx as its parent
newctx = (KonohaContextVar *)KCalloc_UNTRACE(sizeof(KonohaContextVar), 1);
newctx->klib = kctx->klib;
newctx->platApi = kctx->platApi;
newctx->share = kctx->share;
newctx->runtimeModels = kctx->runtimeModels;
newctx->localContexts = (KModelContext**)KCalloc_UNTRACE(sizeof(KModelContext *), KRuntimeModel_MAXSIZE);
PLATAPI GCModule.InitGcContext(kctx);
PLATAPI JsonModule.InitJsonContext(newctx);
}
KRuntimeContext_Init(kctx, newctx, platApi->stacksize);
if(IS_RootKonohaContext(newctx)) {
MODSUGAR_Init(kctx, newctx);
LoadDefaultMethod(kctx, KNULL(NameSpace));
LoadDefaultSugarMethod(kctx, KNULL(NameSpace));
}
else {
int i;
for(i = 0; i < KRuntimeModel_MAXSIZE; i++) {
KRuntimeModel *mod = newctx->runtimeModels[i];
if(mod == NULL) continue;
if(mod->setupModelContext != NULL) {
mod->setupModelContext((KonohaContext *)newctx, mod, true);
}
}
}
return newctx;
}
//## String DIR.readPath()
static KMETHOD DIR_readPath(KonohaContext *kctx, KonohaStack *sfp)
{
kDir *dir = (kDir *)sfp[0].asObject;
if(dir->dirp != NULL) {
KMakeTrace(trace, sfp);
struct dirent entry, *result;
int ret = readdir_r(dir->dirp, &entry, &result);
if(result != NULL) {
char *d_name = result->d_name, delim[2] = {'/', 0};
KBuffer wb;
KLIB KBuffer_Init(&(kctx->stack->cwb), &wb);
KLIB KBuffer_Write(kctx, &wb, kString_text(dir->PathInfoNULL), kString_size(dir->PathInfoNULL));
KLIB KBuffer_Write(kctx, &wb, delim, 1);
if(dir->readerIconv != ICONV_NULL) {
KLIB KBuffer_Write(kctx, &wb, d_name, strlen(d_name));
}
else {
KLIB KBuffer_iconv(kctx, &wb, dir->readerIconv, d_name, strlen(d_name), trace);
}
KReturn(KLIB KBuffer_Stringfy(kctx, &wb, OnStack, StringPolicy_FreeKBuffer));
}
if(ret == -1) {
KTraceErrorPoint(trace, SystemFault, "readdir", LogErrno);
}
kDir_close(kctx, dir);
}
KReturn(KNULL(String));
}
//## String DIR.readFileName()
static KMETHOD DIR_readFileName(KonohaContext *kctx, KonohaStack *sfp)
{
kDir *dir = (kDir *)sfp[0].asObject;
if(dir->dirp != NULL) {
KMakeTrace(trace, sfp);
struct dirent entry, *result;
int ret = readdir_r(dir->dirp, &entry, &result);
if(result != NULL) {
char *d_name = result->d_name;
if(dir->readerIconv == ICONV_NULL) {
KReturn(KLIB new_kString(kctx, OnStack, d_name, strlen(d_name), StringPolicy_SystemInfo));
}
else {
KBuffer wb;
KLIB KBuffer_Init(&(kctx->stack->cwb), &wb);
KLIB KBuffer_iconv(kctx, &wb, dir->readerIconv, d_name, strlen(d_name), trace);
KReturn(KLIB KBuffer_Stringfy(kctx, &wb, OnStack, StringPolicy_FreeKBuffer));
}
}
if(ret == -1) {
KTraceErrorPoint(trace, SystemFault, "readdir", LogErrno);
}
kDir_close(kctx, dir);
}
KReturn(KNULL(String));
}
//## String Json.getString(String key);
static KMETHOD Json_getString(KonohaContext *kctx, KonohaStack *sfp)
{
json_t* obj = ((struct _kJson *)sfp[0].asObject)->obj;
CHECK_JSON(obj, KReturn(KNULL(String)));
const char *key = S_text(sfp[1].asString);
json_t* ret = json_object_get(obj, key);
if(!json_is_string(ret)) {
KReturn(KNULL(String));
}
ret = json_incref(ret);
const char* str = json_string_value(ret);
if(str == NULL) {
KReturn(KNULL(String));
}
KReturn(KLIB new_kString(kctx, str, strlen(str), 0));
}
// ## String Request.getArgs();
static KMETHOD Request_getArgs(KonohaContext *kctx, KonohaStack *sfp)
{
kRequest *self = (kRequest *) sfp[0].asObject;
if(self->r->args == NULL) {
KReturn(KNULL(String));
}
KReturn(KLIB new_kString(kctx, OnStack, self->r->args, strlen(self->r->args), 0));
}
static void RegExp_Init(KonohaContext *kctx, kObject *o, void *conf)
{
kRegExp *re = (kRegExp *)o;
re->reg = NULL;
re->eflags = 0;
re->pattern = KNULL(String);
re->lastIndex = 0;
}
static void Person_Init(KonohaContext *kctx, kObject *o, void *conf)
{
/* This function is called when generating the instance of this class.
* Moreover, it is called when generating the Null object of this class. */
struct Person *p = (struct Person *) o;
p->name = KNULL(String);
p->age = 0;
}
//## String System.getenv(String name)
static KMETHOD System_getenv(KonohaContext *kctx, KonohaStack *sfp)
{
const char *name = kString_text(sfp[1].asString);
char *ret = getenv(name);
if(ret == NULL) {
KReturn(KNULL(String));
}
KReturn(KLIB new_kString(kctx, OnStack, ret, strlen(ret), 0));
}
//## String Json.dump();
static KMETHOD Json_dump(KonohaContext *kctx, KonohaStack *sfp)
{
json_t* obj = ((struct _kJson *)sfp[0].asObject)->obj;
CHECK_JSON(obj, KReturnDefaultObjectValue());
char* data = json_dumps(obj, JSON_ENSURE_ASCII);
if(data == NULL) {
KReturn(KNULL(String));
}
KReturn(KLIB new_kString(kctx, data, strlen(data), 0));
}
static void konoha_import(CTX, char *packagename)
{
size_t len = strlen(packagename)+1;
char bufname[len];
memcpy(bufname, packagename, len);
if(!KREQUIRE_PACKAGE(bufname, 0)) {
PLAT exit_i(EXIT_FAILURE);
}
KEXPORT_PACKAGE(bufname, KNULL(NameSpace), 0);
}
kbool_t Konoha_Eval(KonohaContext* kctx, const char *script, kfileline_t uline)
{
KBeginKonohaContext();
if(verbose_sugar) {
DUMP_P("\n>>>----\n'%s'\n------\n", script);
}
kmodsugar->h.setupModuleContext(kctx, (KonohaModule *)kmodsugar, 0/*lazy*/);
kbool_t res = (kNameSpace_Eval(kctx, KNULL(NameSpace), script, uline, NULL/*trace*/) == K_CONTINUE); // FIXME
KEndKonohaContext();
return res;
}
KONOHA_EXPORT(kbool_t) Konoha_Eval(KonohaContext* kctx, const char *script, kfileline_t uline)
{
KBeginKonohaContext();
if(verbose_sugar) {
DUMP_P("\n>>>----\n'%s'\n------\n", script);
}
KPARSERM->h.setupModelContext(kctx, (KRuntimeModel *)KPARSERM, 0/*lazy*/);
kbool_t res = (kNameSpace_Eval(kctx, KNULL(NameSpace), script, uline, NULL/*trace*/) == K_CONTINUE); // FIXME
KEndKonohaContext();
return res;
}
static kbool_t StringInterpolation_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
#define PATTERN(X) KSymbol_##X##Pattern
kSyntax *textSyntax = kSyntax_(KNULL(NameSpace), PATTERN(Text));
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_TextPattern, SYNFLAG_CParseFunc, 0, 0, {SUGARFUNC Expression_ExtendedTextLiteral}, {textSyntax->TypeFuncNULL}, },
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
//## Array Json.getArray();
static KMETHOD Json_getArray(KonohaContext *kctx, KonohaStack *sfp)
{
json_t* obj = ((struct _kJson *)sfp[0].asObject)->obj;
CHECK_JSON(obj, KReturn(KNULL(Array)));
const char *key = S_text(sfp[1].asString);
json_t* ja;
if(key == NULL) {
ja = ((struct _kJson *)sfp[0].asObject)->obj;
ja = json_incref(ja);
}
else {
ja = json_object_get(obj, key);
ja = json_incref(ja);
}
if(!json_is_array(ja)) {
KReturn(KNULL(Array));
}
kArrayVar* a = (kArrayVar *)KLIB new_kObjectDontUseThis(kctx, CT_Array, 0);
a->ObjectItems= (kObject**)ja;
KReturn(a);
}
static kbool_t untyped_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequirePackage("Type.StaticVar", trace);
kSyntax *assignSyntax = kSyntax_(KNULL(NameSpace), KSymbol_LET);
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("="), SYNFLAG_NodeLeftJoinOp2, assignSyntax->precedence_op2, assignSyntax->precedence_op1,
{assignSyntax->ParseFuncNULL}, {KSugarFunc(ns, TypeCheck_UntypedAssign)}},
{ KSymbol_END, }, /* sentinental */
};
KLIB kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
//## Node Node.newMethodNode(Object type, Symbol keyword, Node expr1);
static KMETHOD Node_newMethodNode1(KonohaContext *kctx, KonohaStack *sfp)
{
kNameSpace *ns = kNode_ns(sfp[0].asNode);
KClass *type = kObject_class(sfp[1].asObject);
ksymbol_t keyword = (ksymbol_t)sfp[2].intValue;
kNode *expr1 = sfp[3].asNode;
kMethod *mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, type, keyword, 0, KMethodMatch_NoOption);
if(mtd == NULL) {
KReturn(KNULL(Node));
}
KReturn(SUGAR new_MethodNode(kctx, ns, type, mtd, 1, expr1));
}
//## void Console.readLine(String prompt)
static KMETHOD Console_readLine(KonohaContext *kctx, KonohaStack *sfp)
{
kString *s;
char *p = CONSOLEAPI InputUserText(kctx, kString_text(sfp[1].asString), 0);
if(p != NULL) {
s = KLIB new_kString(kctx, OnStack, p, strlen(p), 0);
free(p);
}
else {
s = KNULL(String);
}
KReturn(s);
}
//## Expr Stmt.newTypedCallExpr(Gamma gma, cid typeId, symbol methodName, Expr firstExpr);
static KMETHOD Stmt_newTypedCallExpr1(KonohaContext *kctx, KonohaStack *sfp)
{
kStmt *stmt = sfp[0].asStmt;
kGamma *gma = sfp[1].asGamma;
ktype_t cid = (ktype_t)sfp[2].intValue;
ksymbol_t methodName = (ksymbol_t)sfp[3].intValue;
kExpr *firstExpr = sfp[4].asExpr;
kMethod *method = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, Stmt_ns(stmt), cid, methodName, 1);
if(method == NULL) {
KReturn(KNULL(Expr));
}
KReturn(SUGAR new_TypedCallExpr(kctx, stmt, gma, cid, method, 1, firstExpr));
}
static kString* kConsole_inputUserPassword(KonohaContext *kctx, const char *message)
{
kString *s;
char *p = CONSOLEAPI InputUserPassword(kctx, message);
if(p != NULL) {
s = KLIB new_kString(kctx, OnStack, p, strlen(p), 0);
free(p);
}
else {
s = KNULL(String);
}
return s;
}
static void konoha_define(CTX, char *keyvalue)
{
char *p = strchr(keyvalue, '=');
if(p != NULL) {
if(isdigit(p[1])) {
long n = strtol(p+1, NULL, 0);
KDEFINE_INT_CONST ConstData[] = {
{keyvalue, TY_Int, n}, {}
};
kNameSpace_loadConstData(KNULL(NameSpace), ConstData, 0);
}
else {
KDEFINE_TEXT_CONST ConstData[] = {
{keyvalue, TY_TEXT, p+1}, {}
};
kNameSpace_loadConstData(KNULL(NameSpace), ConstData, 0);
}
}
else {
fprintf(stdout, "invalid define option: use -D<key>=<value>\n");
}
}
//## String File.readLine();
static KMETHOD File_readLine(KonohaContext *kctx, KonohaStack *sfp)
{
kFile *file = (kFile *)sfp[0].asObject;
if(file->fp != NULL) {
KBuffer wb;
KLIB KBuffer_Init(&(kctx->stack->cwb), &wb);
int ch, pos = 0, hasUTF8 = false, bufferCount = 0, policy = StringPolicy_ASCII;
char buffer[K_PAGESIZE];
KMakeTrace(trace, sfp);
while((ch = TRACE_fgetc(kctx, file, trace)) != EOF) {
//DBG_P("ch='%c', pos=%d", ch, pos);
if(ch == '\r') continue;
if(ch == '\n') {
if(bufferCount == 0 && (!hasUTF8 || file->readerIconv == ICONV_NULL)) {
KReturn(KLIB new_kString(kctx, OnStack, buffer, pos, policy));
}
break;
}
if(ch > 127) {
hasUTF8 = true;
policy = StringPolicy_UTF8;
}
buffer[pos] = ch; pos++;
if(!(pos < K_PAGESIZE)) {
if(hasUTF8 && file->readerIconv != ICONV_NULL) {
KLIB KBuffer_iconv(kctx, &wb, file->readerIconv, buffer, pos, trace);
}
else {
KLIB KBuffer_Write(kctx, &wb, buffer, pos);
}
bufferCount++;
hasUTF8 = false;
pos = 0;
}
}
if(pos > 0) {
if(hasUTF8 && file->readerIconv != ICONV_NULL) {
KLIB KBuffer_iconv(kctx, &wb, file->readerIconv, buffer, pos, trace);
}
else {
KLIB KBuffer_Write(kctx, &wb, buffer, pos);
}
}
kFile_CheckEOF(kctx, file, trace);
KReturn(KLIB KBuffer_Stringfy(kctx, &wb, OnStack, policy | StringPolicy_FreeKBuffer));
}
else {
KReturn(KNULL(String));
}
}
//## String[] Json.getKeys();
static KMETHOD Json_getKeys(KonohaContext *kctx, KonohaStack *sfp)
{
json_t* obj = ((struct _kJson *)sfp[0].asObject)->obj;
kArray *a = (kArray *)KLIB new_kObjectDontUseThis(kctx, CT_StringArray0, 0);
CHECK_JSON(obj, KReturn(KNULL(Array)));
const char* key;
void* iter = json_object_iter(obj);
while(iter) {
key = json_object_iter_key(iter);
iter = json_object_iter_next(obj, iter);
KLIB kArray_add(kctx, a, KLIB new_kString(kctx, key, strlen(key), StringPolicy_POOL|StringPolicy_ASCII));
}
KReturn(a);
}
static void konoha_commandline(CTX, int argc, char** argv)
{
kclass_t *CT_StringArray0 = CT_p0(_ctx, CT_Array, TY_String);
kArray *a = (kArray*)new_kObject(CT_StringArray0, NULL);
int i;
for(i = 0; i < argc; i++) {
DBG_P("argv=%d, '%s'", i, argv[i]);
kArray_add(a, new_kString(argv[i], strlen(argv[i]), SPOL_TEXT));
}
KDEFINE_OBJECT_CONST ConstData[] = {
{"SCRIPT_ARGV", CT_StringArray0->cid, (kObject*)a},
{}
};
kNameSpace_loadConstData(KNULL(NameSpace), ConstData, 0);
}
//## String getcwd()
static KMETHOD System_getcwd(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char filepath[K_PATHMAX] = {0};
char *cwd = getcwd(filepath, K_PATHMAX);
if(cwd != NULL) {
char buffer[K_PATHMAX] = {0};
const char *konohaPath = PLATAPI I18NModule.formatKonohaPath(kctx, buffer, sizeof(buffer), cwd, strlen(cwd), trace);
KReturn(KLIB new_kString(kctx, OnStack, konohaPath, strlen(konohaPath), 0));
}
else {
KTraceErrorPoint(trace, SystemFault, "getcwd", LogErrno);
KReturn(KNULL(String));
}
}
//## String System.realpath(String path)
static KMETHOD System_realpath(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX], filepath[K_PATHMAX] = {0};
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
char *cwd = realpath(systemPath, filepath);
if(cwd != NULL) {
const char *konohaPath = PLATAPI I18NModule.formatKonohaPath(kctx, buffer, sizeof(buffer), cwd, strlen(cwd), trace);
KReturn(KLIB new_kString(kctx, OnStack, konohaPath, strlen(konohaPath), 0));
}
else {
KTraceErrorPoint(trace, SystemFault, "realpath", LogFileName(kString_text(path)), LogErrno);
KReturn(KNULL(String));
}
}
static KMETHOD System_readlink(KonohaContext *kctx, KonohaStack *sfp)
{
KMakeTrace(trace, sfp);
char buffer[K_PATHMAX];
kString *path = sfp[1].asString;
const char *systemPath = PLATAPI I18NModule.formatSystemPath(kctx, buffer, sizeof(buffer), kString_text(path), kString_size(path), trace);
char pathbuf[K_PATHMAX];
ssize_t ret = readlink(systemPath, pathbuf, K_PATHMAX);
if(ret == -1) {
int fault = KLIB DiagnosisFaultType(kctx, kString_GuessUserFault(path)|SystemError, trace);
KTraceErrorPoint(trace, fault, "readlink", LogFileName(kString_text(path)), LogErrno);
KReturn(KNULL(String));
}
else {
const char *konohaPath = PLATAPI I18NModule.formatKonohaPath(kctx, buffer, sizeof(buffer), pathbuf, strlen(pathbuf), trace);
KReturn(KLIB new_kString(kctx, OnStack, konohaPath, strlen(konohaPath), 0));
}
}
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;
}
static int konoha_handler(request_rec *r)
{
//konoha_config_t *conf = ap_get_module_config(
// r->server->module_config, &konoha_module);
if(strcmp(r->handler, "konoha-script")) {
return DECLINED;
}
// if(r->method_number != M_GET) {
// TODO
// return HTTP_METHOD_NOT_ALLOWED;
// }
KonohaClass *cRequest;
verbose_debug = 1;
KonohaContext* konoha = konoha_create(&cRequest);
//assert(cRequest != NULL);
r->content_encoding = "utf-8";
ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "filename=%s", r->filename);
if(Konoha_LoadScript(konoha, r->filename)) {
return DECLINED;
}
KonohaContext *kctx = konoha;
kNameSpace *ns = KNULL(NameSpace);
kMethod *mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, TY_System, MN_("handler"), -1); // fixme
if(mtd == NULL) {
ap_log_rerror(APLOG_MARK, APLOG_CRIT, 0, r, "System.handler() not found");
return -1;
}
/* XXX: We assume Request Object may not be freed by GC */
kObject *req_obj = KLIB new_kObject(kctx, OnStack, cRequest, (uintptr_t)r);
BEGIN_LOCAL(lsfp, K_CALLDELTA + 1);
KUnsafeFieldSet(lsfp[K_CALLDELTA+0].asObject, K_NULL);
KUnsafeFieldSet(lsfp[K_CALLDELTA+1].asObject, req_obj);
{
KonohaStack *sfp = lsfp + K_CALLDELTA;
KSetMethodCallStack(sfp, 0/*UL*/, mtd, 1, KLIB Knull(kctx, CT_Int));
KonohaRuntime_callMethod(kctx, sfp);
}
END_LOCAL();
int ret = lsfp[0].intValue;
Konoha_Destroy(konoha);
return ret;
}
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;
}
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));
}
