//## Node.LookupNode(keyword key)
static KMETHOD Node_LookupNode(KonohaContext *kctx, KonohaStack *sfp)
{
kNode *stmt = sfp[0].asNode;
ksymbol_t keyword = (ksymbol_t)sfp[1].intValue;
kNode *ret = kNode_LookupNodeNULL(kctx, stmt, keyword);
KReturn((!kNode_IsError(ret) ? ret : K_NULLNODE));
}
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 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));
}
/* copied from src/parser/import/typecheck.h */
static kNode *CallTypeFunc(KonohaContext *kctx, kFunc *fo, kNode *expr, kNameSpace *ns, kObject *reqType)
{
INIT_GCSTACK();
BEGIN_UnusedStack(lsfp);
KUnsafeFieldSet(lsfp[1].asNode, expr);
KUnsafeFieldSet(lsfp[2].asNameSpace, ns);
KUnsafeFieldSet(lsfp[3].asObject, reqType);
CallSugarMethod(kctx, lsfp, fo, 4, UPCAST(K_NULLNODE));
END_UnusedStack();
RESET_GCSTACK();
if(kNode_IsError(expr)) return expr;
if(lsfp[K_RTNIDX].asNode == K_NULLNODE) {
DBG_ASSERT(expr->attrTypeId == KType_var); // untyped
}
DBG_ASSERT(IS_Node(lsfp[K_RTNIDX].asObject));
return (kNode *)lsfp[K_RTNIDX].asObject;
}
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));
}
