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)); }