static void MPIData_extend(KonohaContext *kctx, kMPIData *p, int size) {
size_t newSize = p->offset + size;
if(p->size < newSize) {
switch(p->typeId) {
case KMPI_BYTES: {
kBytes *b = (kBytes *)KLIB new_kObjectDontUseThis(kctx, CT_Bytes, (uintptr_t)newSize, OnStack);
memcpy(b->buf, p->b->buf, p->size);
p->b = b;
p->size = newSize;
break;
}
case KMPI_FARRAY: {
kfloat_t *fa = KCalloc_UNTRACE(sizeof(kfloat_t), newSize);
memcpy(fa, p->fa, p->size * sizeof(kfloat_t));
KFree(p->fa, p->size * sizeof(kfloat_t));
p->fa = fa;
p->size = newSize;
break;
}
case KMPI_IARRAY: {
kint_t *ia = KCalloc_UNTRACE(sizeof(kint_t), newSize);
memcpy(ia, p->ia, p->size * sizeof(kint_t));
KFree(p->ia, p->size * sizeof(kint_t));
p->ia = ia;
p->size = newSize;
break;
}
default:
abort();
}
}
}
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;
}
static void KRuntimeContext_Init(KonohaContext *kctx, KonohaContextVar *ctx, size_t stacksize)
{
size_t i;
KRuntimeContextVar *base = (KRuntimeContextVar *)KCalloc_UNTRACE(sizeof(KRuntimeContextVar), 1);
base->stacksize = stacksize;
base->stack = (KonohaStack *)KCalloc_UNTRACE(sizeof(KonohaStack), stacksize);
assert(stacksize>64);
base->stack_uplimit = base->stack + (stacksize - 64);
for(i = 0; i < stacksize; i++) {
KUnsafeFieldInit(base->stack[i].asObject, K_NULL);
}
KUnsafeFieldInit(base->ContextConstList, new_(Array, 8, OnField));
KUnsafeFieldInit(base->ThrownException, (kException *)K_NULL);
base->gcStack = new_(Array, K_PAGESIZE/sizeof(void *), base->ContextConstList);
KLIB KArray_Init(kctx, &base->cwb, K_PAGESIZE * 4);
ctx->esp = base->stack;
ctx->stack = base;
}
static struct KVirtualCode *CompileVirtualCode(KonohaContext *kctx, KBuilder *builder, bblock_t beginId, bblock_t returnId)
{
KVirtualCode *vcode;
ByteCodeWriter writer = {NULL, 0, builder->InstructionSize * sizeof(KVirtualCode)};
BasicBlock_Optimize(kctx, beginId, &writer);
DBG_P(">>>>>> codesize=%d", writer.codesize);
DBG_ASSERT(writer.codesize != 0);
vcode = (KVirtualCode *)KCalloc_UNTRACE(writer.codesize, 1);
writer.current = vcode;
BasicBlock_WriteByteCode(kctx, beginId, &writer);
BasicBlock_WriteByteCode(kctx, returnId, &writer);
BasicBlock_SetJumpAddr(kctx, BasicBlock_FindById(kctx, beginId), (char *)vcode);
vcode = MakeThreadedCode(kctx, builder, vcode, writer.codesize);
DumpVirtualCode(kctx, vcode);
return vcode;
}
static KMETHOD Array_newArray(KonohaContext *kctx, KonohaStack *sfp)
{
kArrayVar *a = (kArrayVar *)sfp[0].asObject;
size_t asize = (size_t)sfp[1].intValue;
a->bytemax = asize * sizeof(uintptr_t);
kArray_SetSize(a, asize);
a->ObjectItems = (kObject**)KCalloc_UNTRACE(a->bytemax, 1);
if(!kArray_isUnboxData(a)) {
size_t i;
kObject *null = KLIB Knull(kctx, CT_(O_p0(a)));
for(i = 0; i < asize; i++) {
KFieldSet(a, a->ObjectItems[i], null);
}
}
KReturn(a);
}
static void SugarModule_Setup(KonohaContext *kctx, struct KRuntimeModel *def, int newctx)
{
if(!newctx && kctx->localContexts[ParserModelIndex] == NULL) {
KParserContext *base = (KParserContext *)KCalloc_UNTRACE(sizeof(KParserContext), 1);
base->h.reftrace = KParserContext_Reftrace;
base->h.free = KParserContext_Free;
base->errorMessageCount = 0;
base->preparedTokenList = new_(TokenArray, K_PAGESIZE/sizeof(void *), OnContextConstList);
base->errorMessageList = new_(StringArray, 8, OnContextConstList);
base->definedMethodList = new_(MethodArray, 8, OnContextConstList);
KLIB KArray_Init(kctx, &base->errorMessageBuffer, K_PAGESIZE);
kctx->localContexts[ParserModelIndex] = (KModelContext *)base;
}
}
static void SugarModule_Setup(KonohaContext *kctx, struct KonohaModule *def, int newctx)
{
if(!newctx && kctx->modlocal[MOD_sugar] == NULL) {
SugarContext *base = (SugarContext *)KCalloc_UNTRACE(sizeof(SugarContext), 1);
base->h.reftrace = SugarContext_Reftrace;
base->h.free = SugarContext_Free;
base->errorMessageCount = 0;
base->preparedTokenList = new_(TokenArray, K_PAGESIZE/sizeof(void *), OnContextConstList);
base->errorMessageList = new_(StringArray, 8, OnContextConstList);
base->definedMethodList = new_(MethodArray, 8, OnContextConstList);
base->preparedGamma = new_(Gamma, NULL, OnContextConstList);
KLIB Karray_Init(kctx, &base->errorMessageBuffer, K_PAGESIZE);
kctx->modlocal[MOD_sugar] = (KonohaModuleContext *)base;
}
}
static KVirtualCode *KonohaVirtualMachine_tryJump(KonohaContext *kctx, KonohaStack *sfp, KVirtualCode *pc)
{
int jmpresult;
INIT_GCSTACK();
KRuntimeContextVar *base = kctx->stack;
jmpbuf_i lbuf = {0};
if(base->evaljmpbuf == NULL) {
base->evaljmpbuf = (jmpbuf_i *)KCalloc_UNTRACE(sizeof(jmpbuf_i), 1);
}
memcpy(&lbuf, base->evaljmpbuf, sizeof(jmpbuf_i));
if((jmpresult = PLATAPI setjmp_i(*base->evaljmpbuf)) == 0) {
pc = MiniVM_RunVirtualMachine(kctx, sfp, pc);
}
else {
DBG_P("Catch eval exception jmpresult=%d", jmpresult);
//KSETv(sfp[exceptionIdx].e, ..);
pc = NULL;
}
memcpy(base->evaljmpbuf, &lbuf, sizeof(jmpbuf_i));
RESET_GCSTACK();
return pc;
}
static void KonohaClass_InitField(KonohaContext *kctx, KonohaClassVar *definedClass, KonohaClass *superClass, size_t fieldInitSize)
{
size_t fieldsize = superClass->fieldsize + fieldInitSize;
definedClass->cstruct_size = size64((fieldsize * sizeof(kObject *)) + sizeof(KonohaObjectHeader));
DBG_P("superClass->fieldsize=%d, definedFieldSize=%d, cstruct_size=%d", superClass->fieldsize, fieldInitSize, definedClass->cstruct_size);
if(fieldsize > 0) {
definedClass->fieldItems = (KonohaClassField *)KCalloc_UNTRACE(fieldsize, sizeof(KonohaClassField));
definedClass->fieldAllocSize = fieldsize;
definedClass->fieldsize = superClass->fieldsize; /* supsize */
if(superClass->fieldsize > 0) {
memcpy(definedClass->fieldItems, superClass->fieldItems, sizeof(KonohaClassField) * superClass->fieldsize);
}
}
definedClass->fnull(kctx, definedClass); // first generation of DefaultValueAsNull
superClass->fnull(kctx, superClass); // ensure default value of super class
memcpy(definedClass->defaultNullValueVar_OnGlobalConstList->fieldObjectItems, superClass->defaultNullValueVar_OnGlobalConstList->fieldObjectItems, sizeof(kObject *) * superClass->fieldsize);
definedClass->init = ObjectField_Init;
definedClass->reftrace = ObjectField_Reftrace;
definedClass->superTypeId = superClass->typeId;
definedClass->searchSuperMethodClassNULL = superClass;
// add other functions
}
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));
}
STRUCTNAME(AprTable),
.init = AprTable_init,
.free = AprTable_free,
};
static KDEFINE_CLASS aprTableEntryDef = {
STRUCTNAME(AprTableEntry),
.init = AprTableEntry_init,
.free = AprTableEntry_free,
};
static KDEFINE_CLASS apacheDef = {
STRUCTNAME(Apache),
};
kapacheshare_t *base = (kapacheshare_t *)KCalloc_UNTRACE(sizeof(kapacheshare_t), 1);
base->h.name = "apache";
base->h.setup = kapacheshare_setup;
base->h.reftrace = kapacheshare_reftrace;
base->h.free = kapacheshare_free;
KLIB KonohaRuntime_setModule(kctx, MOD_APACHE, &base->h, trace);
base->cRequest = KLIB kNameSpace_defineClass(kctx, ns, NULL, &Def, 0);
base->cAprTable = KLIB kNameSpace_defineClass(kctx, ns, NULL, &aprTableDef, 0);
base->cAprTableEntry = KLIB kNameSpace_defineClass(kctx, ns, NULL, &aprTableEntryDef, 0);
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},
STRUCTNAME(AprTable),
.init = AprTable_Init,
.free = AprTable_Free,
};
static KDEFINE_CLASS aprTableEntryDef = {
STRUCTNAME(AprTableEntry),
.init = AprTableEntry_Init,
.free = AprTableEntry_Free,
};
static KDEFINE_CLASS apacheDef = {
STRUCTNAME(Apache),
};
KModuleApache *mod = (KModuleApache *)KCalloc_UNTRACE(sizeof(KModuleApache), 1);
mod->h.name = "apache";
mod->h.allocSize = sizeof(KModuleApache);
mod->h.setupModuleContext = ApacheModule_Setup;
mod->h.freeModule = ApacheModule_Free;
KLIB KonohaRuntime_setModule(kctx, MOD_APACHE, (KonohaModule *)mod, trace);
mod->cRequest = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &Def, 0);
mod->cAprTable = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &aprTableDef, 0);
mod->cAprTableEntry = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &aprTableEntryDef, 0);
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),
/* ------------------------------------------------------------------------ */
static void SockAddr_Init(KonohaContext *kctx, kObject *o, void *conf)
{
struct _kSockAddr *sa = (struct _kSockAddr *)o;
sa->sockaddr_in = (struct sockaddr_in *)KCalloc_UNTRACE(sizeof(struct sockaddr_in), 1);
}
static kbool_t regexp_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
kregexpshare_t *base = (kregexpshare_t *)KCalloc_UNTRACE(sizeof(kregexpshare_t), 1);
base->h.name = "regexp";
base->h.setup = kregexpshare_setup;
base->h.reftrace = kregexpshare_reftrace;
base->h.free = kregexpshare_free;
KLIB KonohaRuntime_setModule(kctx, MOD_REGEXP, &base->h, trace);
KDEFINE_CLASS RegExpDef = {
STRUCTNAME(RegExp),
.cflag = 0,
.init = RegExp_init,
.free = RegExp_free,
.p = RegExp_p,
};
base->cRegExp = KLIB kNameSpace_defineClass(kctx, ns, NULL, &RegExpDef, trace);
ktype_t TY_StringArray0 = CT_StringArray0->typeId;
KDEFINE_METHOD MethodData[] = {
/*JS*/_Public|_Const|_Im, _F(RegExp_getglobal), TY_boolean, TY_RegExp, MN_("getglobal"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getignoreCase), TY_boolean, TY_RegExp, MN_("getignoreCase"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getmultiline), TY_boolean, TY_RegExp, MN_("getmultiline"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getsource), TY_String, TY_RegExp, MN_("getsource"), 0,
/*JS*/_Public|_Const|_Im, _F(RegExp_getlastIndex), TY_int, TY_RegExp, MN_("getlastIndex"), 0,
/*JS*/_Public|_Im, _F(String_match), TY_StringArray0, TY_String, MN_("match"), 1, TY_RegExp, FN_("regexp"),
/*JS*/_Public|_Const|_Im, _F(String_replace), TY_String, TY_String, MN_("replace"), 2, TY_RegExp, FN_("searchvalue"), TY_String, FN_("newvalue"),
/*JS*/_Public|_Const|_Im, _F(String_search), TY_int, TY_String, MN_("search"), 1, TY_RegExp, FN_("searchvalue"),
/*JS*/_Public|_Im, _F(String_split), TY_StringArray0, TY_String, MN_("split"), 1, TY_RegExp, FN_("separator"),
/*JS*/_Public|_Im, _F(String_splitWithLimit), TY_StringArray0, TY_String, MN_("split"), 2, TY_RegExp, FN_("separator"), TY_int, FN_("limit"),
/*JS*/_Public|_Const, _F(RegExp_new), TY_RegExp, TY_RegExp, MN_("new"), 1, TY_String, FN_("pattern"),
/*JS*/_Public|_Const, _F(RegExp_new2), TY_RegExp, TY_RegExp, MN_("new"), 2, TY_String, FN_("pattern"), TY_String, FN_("option"),
/*JS*/_Public|_Const, _F(RegExp_exec), TY_StringArray0, TY_RegExp, MN_("exec"), 1, TY_String, FN_("str"),
/*JS*/_Public|_Const|_Im, _F(RegExp_test), TY_boolean, TY_RegExp, MN_("test"), 1, TY_String, FN_("str"),
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static KMETHOD TokenFunc_JavaScriptRegExp(KonohaContext *kctx, KonohaStack *sfp)
{
kTokenVar *tk = (kTokenVar *)sfp[1].asObject;
int ch, prev = '/', pos = 1;
const char *source = S_text(sfp[2].asString);
if(source[pos] == '*' || source[pos] == '/') {
KReturnUnboxValue(0);
}
/*FIXME: we need to care about context sensitive case*/
//int tokenListize = kArray_size(tenv->tokenList);
//if(tokenListize > 0) {
// kToken *tkPrev = tenv->tokenList->TokenItems[tokenListize - 1];
// if(tkPrev->unresolvedTokenType == TokenType_INT ||
// (tkPrev->topCharHint != '(' && tkPrev->unresolvedTokenType == TokenType_SYMBOL)) {
// KReturnUnboxValue(0);
// }
//}
while((ch = source[pos++]) != 0) {
if(ch == '\n') {
break;
}
if(ch == '/' && prev != '\\') {
int pos0 = pos;
while(isalpha(source[pos])) pos++;
if(IS_NOTNULL(tk)) {
kArray *a = (kArray *)KLIB new_kObject(kctx, OnField, CT_StringArray0, 2); // FIXME
KFieldSet(tk, tk->subTokenList, a);
KLIB new_kString(kctx, a, source + 1, (pos0-2), 0);
KLIB new_kString(kctx, a, source + pos0, pos-pos0, 0);
tk->unresolvedTokenType = SYM_("$RegExp");
}
KReturnUnboxValue(pos);
}
prev = ch;
}
if(IS_NOTNULL(tk)) {
SUGAR kToken_printMessage(kctx, tk, ErrTag, "must close with %s", "/");
}
KReturnUnboxValue(pos-1);
}
void MODSUGAR_Init(KonohaContext *kctx, KonohaContextVar *ctx)
{
KParserModel *mod = (KParserModel *)KCalloc_UNTRACE(sizeof(KParserModel), 1);
mod->h.name = "sugar";
mod->h.allocSize = sizeof(KParserModel);
mod->h.setupModelContext = SugarModule_Setup;
KLIB KRuntime_SetModule(kctx, ParserModelIndex, (KRuntimeModel *)mod, 0);
KonohaLibVar *l = (KonohaLibVar *)ctx->klib;
l->kNameSpace_GetClassByFullName = kNameSpace_GetClassByFullName;
l->kNameSpace_DefineClass = kNameSpace_DefineClass;
l->kNameSpace_LoadMethodData = kNameSpace_LoadMethodData;
l->kNameSpace_SetConstData = kNameSpace_SetConstData;
l->kNameSpace_LoadConstData = kNameSpace_LoadConstData;
l->kNameSpace_GetGetterMethodNULL = kNameSpace_GetGetterMethodNULL;
l->kNameSpace_GetSetterMethodNULL = kNameSpace_GetSetterMethodNULL;
l->kNameSpace_GetCoercionMethodNULL = kNameSpace_GetCoercionMethodNULL;
l->kNameSpace_GetMethodByParamSizeNULL = kNameSpace_GetMethodByParamSizeNULL;
l->kNameSpace_GetMethodBySignatureNULL = kNameSpace_GetMethodBySignatureNULL;
l->kMethod_DoLazyCompilation = kMethod_DoLazyCompilation;
l->kNameSpace_FreeSugarExtension = kNameSpace_FreeSugarExtension;
l->Konoha_LoadScript = Konoha_LoadScript;
l->Konoha_Eval = Konoha_Eval;
l->kMethod_GenCode = kMethod_GenCode;
l->kMethod_SetFunc = kMethod_SetFunc;
KDEFINE_CLASS defSymbol = {0};
defSymbol.structname = "Symbol";
defSymbol.typeId = KTypeAttr_NewId;
defSymbol.cflag = KClassFlag_int;
defSymbol.init = KClass_(KType_Int)->init;
defSymbol.unbox = KClass_(KType_Int)->unbox;
defSymbol.format = kSymbol_format;
KDEFINE_CLASS defSyntax = {0};
SETSTRUCTNAME(defSyntax, Syntax);
defSyntax.init = kSyntax_Init;
//defSyntax.format = kSyntax_format;
KDEFINE_CLASS defToken = {0};
SETSTRUCTNAME(defToken, Token);
defToken.init = kToken_Init;
defToken.reftrace = kToken_Reftrace;
defToken.format = kToken_format;
KDEFINE_CLASS defNode = {0};
SETSTRUCTNAME(defNode, Node);
defNode.init = kUntypedNode_Init;
defNode.reftrace = kUntypedNode_Reftrace;
defNode.format = kUntypedNode_format;
InitNodeClass(kctx, mod);
mod->cSymbol = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defSymbol, 0);
mod->cSyntax = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defSyntax, 0);
mod->cToken = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defToken, 0);
mod->cNode = KLIB KClass_define(kctx, PackageId_sugar, NULL, &defNode, 0);
mod->cTokenArray = KClass_p0(kctx, KClass_Array, mod->cToken->typeId);
KLIB Knull(kctx, mod->cToken);
KLIB Knull(kctx, mod->cNode);
SugarModule_Setup(kctx, &mod->h, 0);
KDEFINE_INT_CONST ClassData[] = { // konoha defined class
{"void", VirtualType_KClass, (uintptr_t)KClass_void},
{"boolean", VirtualType_KClass, (uintptr_t)KClass_Boolean},
{"int", VirtualType_KClass, (uintptr_t)KClass_Int},
{"String", VirtualType_KClass, (uintptr_t)KClass_String},
{"Func", VirtualType_KClass, (uintptr_t)KClass_Func},
{"System", VirtualType_KClass, (uintptr_t)KClass_System},
{NULL},
};
kNameSpace_LoadConstData(kctx, KNULL(NameSpace), KConst_(ClassData), 0);
l->Tokenize = Tokenize;
l->ApplyMacroData = ApplyMacroData;
l->SetMacroData = SetMacroData;
l->Preprocess = Preprocess;
l->EvalTokenList = EvalTokenList;
l->ParseTypePattern = ParseTypePattern;
l->kToken_ToBraceGroup = kToken_ToBraceGroup;
l->kUntypedNode_AddParsedObject = kUntypedNode_AddParsedObject;
l->FindEndOfStatement = FindEndOfStatement;
l->kUntypedNode_ParseFlag = kUntypedNode_ParseFlag;
l->kUntypedNode_GetToken = kUntypedNode_GetToken;
l->kUntypedNode_GetNode = kUntypedNode_GetNode;
l->kUntypedNode_SetConst = kUntypedNode_SetConst;
l->kUntypedNode_SetUnboxConst = kUntypedNode_SetUnboxConst;
l->kUntypedNode_SetVariable = kUntypedNode_SetVariable;
l->TypeCheckNodeAt = TypeCheckNodeAt;
l->TypeCheckNodeByName = TypeCheckNodeByName;
l->TypeCheckMethodParam = TypeCheckMethodParam;
l->new_MethodNode = new_MethodNode;
l->AddLocalVariable = AddLocalVariable;
l->kUntypedNode_DeclType = kUntypedNode_DeclType;
l->TypeVariableNULL = TypeVariableNULL;
l->kNameSpace_DefineSyntax = kNameSpace_DefineSyntax;
l->kNameSpace_GetSyntax = kNameSpace_GetSyntax;
l->kSyntax_AddPattern = kSyntax_AddPattern;
l->kNameSpace_AddSyntax = kNameSpace_AddSyntax;
l->kNameSpace_UseDefaultVirtualMachine = kNameSpace_UseDefaultVirtualMachine;
l->kUntypedNode_InsertAfter = kUntypedNode_InsertAfter;
l->kUntypedNode_AddNode = kUntypedNode_AddNode;
l->kUntypedNode_Op = kUntypedNode_Op;
l->ParseSyntaxNode = ParseSyntaxNode;
l->ParseNode = ParseNode;
l->ParseNewNode = ParseNewNode;
l->AppendParsedNode = AppendParsedNode;
l->kToken_ToError = kToken_ToError;
l->MessageNode = MessageNode;
l->VisitNode = VisitNode;
#ifndef USE_SMALLBUILD
l->dumpToken = dumpToken;
l->dumpTokenArray = dumpTokenArray;
#endif
DefineDefaultSyntax(kctx, KNULL(NameSpace));
}
