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 void DeclVariable(KonohaContext *kctx, kNode *stmt, kNameSpace *ns, ktypeattr_t ty, kNode *termNode)
{
DBG_ASSERT(kNode_isSymbolTerm(termNode));
kToken *termToken = termNode->TermToken;
if(kNameSpace_IsTopLevel(ns)) {
if(ns->globalObjectNULL == NULL) {
kNodeToken_Message(kctx, stmt, termToken, ErrTag, "unavailable global variable");
return;
}
kNodeToken_Message(kctx, stmt, termToken, InfoTag, "global variable %s%s has type %s", KSymbol_Fmt2(termToken->symbol), KType_text(ty));
KLIB KClass_AddField(kctx, kObject_class(ns->globalObjectNULL), ty, termToken->symbol);
}
else {
kNodeToken_Message(kctx, stmt, termToken, InfoTag, "%s%s has type %s", KSymbol_Fmt2(termToken->symbol), KType_text(ty));
KLIB AddLocalVariable(kctx, ns, ty, termToken->symbol);
}
}
static size_t kNode_countFieldSize(KonohaContext *kctx, kNode *bk)
{
size_t i, c = 0;
if(bk != NULL) {
for(i = 0; i < kNode_GetNodeListSize(kctx, bk); i++) {
kNode *stmt = bk->NodeList->NodeItems[i];
DBG_P("stmt->keyword=%s%s", KSymbol_Fmt2(stmt->syn->keyword));
if(stmt->syn->keyword == KSymbol_TypeDeclPattern) {
kNode *expr = SUGAR kNode_GetNode(kctx, stmt, KSymbol_ExprPattern, NULL);
if(expr->syn->keyword == KSymbol_COMMA) {
c += (kNode_GetNodeListSize(kctx, expr) - 1);
}
else if(expr->syn->keyword == KSymbol_LET || kNode_IsTerm(expr)) {
c++;
}
}
}
}
return c;
}
static void kNode_AddMethodDeclNode(KonohaContext *kctx, kNode *bk, kToken *tokenClassName, kNode *classNode)
{
if(bk == NULL) {
return;
}
size_t i;
kNameSpace *ns = kNode_ns(classNode);
kMethod *AddMethod = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, KClass_NameSpace, KMethodName_("AddMethodDecl"), 1, KMethodMatch_NoOption);
for(i = 0; i < kNode_GetNodeListSize(kctx, bk); i++) {
kNode *stmt = bk->NodeList->NodeItems[i];
if(stmt->syn->keyword == KSymbol_TypeDeclPattern)
continue;
if(stmt->syn->keyword == KSymbol_MethodDeclPattern) {
KLIB kObjectProto_SetObject(kctx, stmt, KSymbol_("ClassName"), KType_Token, tokenClassName);
kNodeVar *classParentBlock = kNode_GetParentNULL(classNode);
if(classParentBlock == NULL) {
classParentBlock = KNewNode(ns);
SUGAR kNode_AddNode(kctx, classParentBlock, classNode);
kNode_Type(kctx, classParentBlock, KNode_Block, KType_void);
}
/* Create 'NameSpace.AddMethodDecl(stmt)' */
kNode *arg0 = new_ConstNode(kctx, ns, NULL, UPCAST(ns));
kNode *arg1 = new_ConstNode(kctx, ns, NULL, UPCAST(stmt));
kNode *callNode = SUGAR new_MethodNode(kctx, ns, KClass_NameSpace, AddMethod, 2, arg0, arg1);
SUGAR kNode_AddNode(kctx, classParentBlock, callNode);
}
else {
SUGAR MessageNode(kctx, stmt, NULL, NULL, WarnTag, "%s is not available within the class clause", KSymbol_Fmt2(stmt->syn->keyword));
}
}
}
