static KMETHOD Statement_do(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, ns, reqc);
//DBG_P("do statement .. ");
kNode *exprNode = SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_ExprPattern, ns, KClass_Boolean, 0);
if(kNode_IsError(exprNode)) {
KReturn(exprNode);
}
kNode_Set(CatchContinue, stmt, true); // set before TypeCheck Block
kNode_Set(CatchBreak, stmt, true);
SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_BlockPattern, ns, KClass_void, 0);
KReturn(kNode_Type(kctx, stmt, KNode_DoWhile, KType_void));
}
static KMETHOD Statement_ConstDecl(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, ns, reqc);
kToken *symbolToken = SUGAR kNode_GetToken(kctx, stmt, KSymbol_SymbolPattern, NULL);
ksymbol_t unboxKey = symbolToken->symbol;
kNode *constNode = SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_ExprPattern, ns, KClass_INFER, TypeCheckPolicy_CONST);
if(!kNode_IsError(constNode)) {
KClass *constClass = KClass_(constNode->attrTypeId);
ktypeattr_t type = constClass->typeId;
uintptr_t unboxValue;
kbool_t result = false;
if(kNode_node(constNode) == KNode_Null) { // const C = String
type = VirtualType_KClass;
unboxValue = (uintptr_t)constClass;
result = true;
}
else if(kNode_node(constNode) == KNode_Const) { // const C = "1"
unboxValue = (uintptr_t)constNode->ObjectConstValue;
result = true;
}
else if(kNode_node(constNode) == KNode_UnboxConst) { // const c = 1
unboxValue = constNode->unboxConstValue;
result = true;
}
if(result) {
KMakeTraceUL(trace, sfp, kNode_uline(stmt));
result = KLIB kNameSpace_SetConstData(kctx, ns, unboxKey, type, unboxValue, trace);
}
else {
kNode_Message(kctx, stmt, ErrTag, "constant value is expected: %s%s", KSymbol_Fmt2(unboxKey));
}
constNode = kNode_Type(kctx, stmt, KNode_Done, KType_void);
}
KReturn(constNode);
}
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 KMETHOD Statement_CStyleFor(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, ns, reqc);
int KSymbol_InitNode = KSymbol_("init"), KSymbol_IteratorNode = KSymbol_("Iterator");
KDump(stmt);
kNode *initNode = SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_InitNode, ns, KClass_void, TypeCheckPolicy_AllowEmpty);
if(initNode != NULL) {
kNode_Set(OpenBlock, initNode, true);
}
SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_IteratorNode, ns, KClass_void, TypeCheckPolicy_AllowEmpty);
SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_ExprPattern, ns, KClass_Boolean, 0);
kNode_Set(CatchContinue, stmt, true); // set before TypeCheckAll
kNode_Set(CatchBreak, stmt, true);
//kNode_Set(RedoLoop, stmt, true);
SUGAR TypeCheckNodeByName(kctx, stmt, KSymbol_BlockPattern, ns, KClass_void, 0);
KReturn(kNode_Type(kctx, stmt, KNode_For, KType_void));
}
//## Node Node.TypeCheckNode(Symbol key, Object type, int policy);
static KMETHOD Node_TypeCheckNode(KonohaContext *kctx, KonohaStack *sfp)
{
kNode *node = sfp[0].asNode;
ksymbol_t key = (ksymbol_t)sfp[1].intValue;
KClass *type = kObject_class(sfp[2].asObject);
int policy = sfp[3].intValue;
KReturn(SUGAR TypeCheckNodeByName(kctx, node, key, kNode_ns(node), type, policy));
}
