static kMethod *CompileClosure(KonohaContext *kctx, kNameSpace *ns, kNode *expr, KClass *envCt, kToken *typeTk, kNode **texprRef)
{
INIT_GCSTACK();
kParam *pa = kNode_GetParamNULL(kctx, expr, typeTk, ns);
kMethodVar *mtd = (kMethodVar *) KLIB new_kMethod(kctx, _GcStack, 0, envCt->typeId, 0/*mn*/, NULL);
KLIB kMethod_SetParam(kctx, mtd, pa->rtype, pa->psize, (kparamtype_t *)pa->paramtypeItems);
int errorCount = KGetParserContext(kctx)->errorMessageCount;
KGammaStackDecl lvarItems[32] = {};
struct KGammaLocalData newgma = {};
newgma.flag = 0;
newgma.currentWorkingMethod = mtd;
newgma.thisClass = envCt;
newgma.localScope.varItems = lvarItems;
newgma.localScope.capacity = 32;
newgma.localScope.varsize = 0;
newgma.localScope.allocsize = 0;
kNameSpace_InitParam(kctx, ns, &newgma, pa, envCt);
KPushGammaStack(ns, &newgma);
*texprRef = SUGAR TypeCheckNodeByName(kctx, expr, KSymbol_BlockPattern, ns, KClass_var, TypeCheckPolicy_AllowVoid);
kNode *block = SUGAR kNode_GetNode(kctx, expr, KSymbol_BlockPattern, NULL);
KLIB kMethod_GenCode(kctx, mtd, block, HatedLazyCompile);
KPopGammaStack(ns, &newgma);
kMethod_Set(StaticError, mtd, KGetParserContext(kctx)->errorMessageCount > errorCount);
RESET_GCSTACK();
return mtd;
}
static kstatus_t MODSUGAR_loadScript(KonohaContext *kctx, const char *path, size_t len, KTraceInfo *trace)
{
if(KGetParserContext(kctx) == NULL) {
KPARSERM->h.setupModelContext(kctx, (KRuntimeModel *)KPARSERM, 0/*lazy*/);
}
INIT_GCSTACK();
kpackageId_t packageId = KLIB KpackageId(kctx, "main", sizeof("main")-1, 0, _NEWID);
kNameSpace *ns = new_PackageNameSpace(kctx, packageId);
kstatus_t result = (kstatus_t)kNameSpace_LoadScript(kctx, ns, path, trace);
RESET_GCSTACK();
return result;
}
static kstatus_t kNameSpace_Eval(KonohaContext *kctx, kNameSpace *ns, const char *script, kfileline_t uline, KTraceInfo *trace)
{
kstatus_t result;
KPARSERM->h.setupModelContext(kctx, (KRuntimeModel *)KPARSERM, 0/*lazy*/);
INIT_GCSTACK();
{
KTokenSeq tokens = {ns, KGetParserContext(kctx)->preparedTokenList};
KTokenSeq_Push(kctx, tokens);
Tokenize(kctx, ns, script, uline, 0, tokens.tokenList);
KTokenSeq_End(kctx, tokens);
result = KLIB EvalTokenList(kctx, &tokens, trace);
KTokenSeq_Pop(kctx, tokens);
}
RESET_GCSTACK();
return result;
}
static KMETHOD TypeCheck_Defined(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck2(stmt, expr, ns, reqc);
size_t i;
kbool_t isDefined = true;
KParserContext *sugarContext = KGetParserContext(kctx);
int popIsBlockingErrorMessage = sugarContext->isBlockedErrorMessage;
sugarContext->isBlockedErrorMessage = true;
for(i = 1; i < kArray_size(expr->NodeList); i++) {
kNode *typedNode = SUGAR TypeCheckNodeAt(kctx, expr, i, ns, KClass_INFER, TypeCheckPolicy_AllowVoid);
if(kNode_IsError(typedNode)) {
isDefined = false;
break;
}
}
sugarContext->isBlockedErrorMessage = popIsBlockingErrorMessage;
KReturn(SUGAR kNode_SetUnboxConst(kctx, expr, KType_Boolean, isDefined));
}
static KMETHOD Statement_namespace(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, ns, reqc);
kstatus_t result = K_CONTINUE;
kToken *tk = SUGAR kNode_GetToken(kctx, stmt, KSymbol_BlockPattern, NULL);
if(tk != NULL && tk->resolvedSyntaxInfo->keyword == TokenType_LazyBlock) {
INIT_GCSTACK();
kNameSpace *ns = new_(NameSpace, kNode_ns(stmt), _GcStack);
KTokenSeq range = {ns, KGetParserContext(kctx)->preparedTokenList};
KTokenSeq_Push(kctx, range);
SUGAR Tokenize(kctx, ns, kString_text(tk->text), tk->uline, tk->indent, range.tokenList);
KTokenSeq_End(kctx, range);
result = SUGAR EvalTokenList(kctx, &range, NULL/*trace*/);
KTokenSeq_Pop(kctx, range);
RESET_GCSTACK();
kNode_Type(kctx, stmt, KNode_Done, KType_void);
}
KReturnUnboxValue(result == K_CONTINUE);
}
static kNode *ParseSource(KonohaContext *kctx, kNameSpace *ns, const char *script, size_t len)
{
KBuffer wb;
KLIB KBuffer_Init(&(kctx->stack->cwb), &wb);
KLIB KBuffer_Write(kctx, &wb, "(", 1);
KLIB KBuffer_Write(kctx, &wb, script, len);
KLIB KBuffer_Write(kctx, &wb, ")", 1);
KTokenSeq tokens = {ns, KGetParserContext(kctx)->preparedTokenList};
KTokenSeq_Push(kctx, tokens);
const char *buf = KLIB KBuffer_text(kctx, &wb, EnsureZero);
SUGAR Tokenize(kctx, ns, buf, 0, 0, tokens.tokenList);
KTokenSeq_End(kctx, tokens);
KTokenSeq step2 = {ns, tokens.tokenList, kArray_size(tokens.tokenList)};
SUGAR Preprocess(kctx, ns, RangeTokenSeq(tokens), NULL, step2.tokenList);
KTokenSeq_End(kctx, step2);
kNode *newexpr = SUGAR ParseNewNode(kctx, ns, step2.tokenList, &step2.beginIdx, step2.endIdx, 0, NULL);
KTokenSeq_Pop(kctx, tokens);
KLIB KBuffer_Free(&wb);
return newexpr;
}
