//## void Token.setKeyword(symbol keyword);
static KMETHOD Token_setUnresolvedTokenType(KonohaContext *kctx, KonohaStack *sfp)
{
kTokenVar *tk = (kTokenVar *) sfp[0].asToken;
ksymbol_t keyword = (ksymbol_t)sfp[1].intValue;
tk->unresolvedTokenType = keyword;
DBG_P("setkeyword=%s%s", PSYM_t(keyword));
KReturnVoid();
}
static size_t kBlock_countFieldSize(KonohaContext *kctx, kBlock *bk)
{
size_t i, c = 0;
if(bk != NULL) {
for(i = 0; i < kArray_size(bk->StmtList); i++) {
kStmt *stmt = bk->StmtList->StmtItems[i];
DBG_P("stmt->keyword=%s%s", PSYM_t(stmt->syn->keyword));
if(stmt->syn->keyword == KW_TypeDeclPattern) {
kExpr *expr = SUGAR kStmt_GetExpr(kctx, stmt, KW_ExprPattern, NULL);
if(expr->syn->keyword == KW_COMMA) {
c += (kArray_size(expr->cons) - 1);
}
else if(expr->syn->keyword == KW_LET || Expr_isTerm(expr)) {
c++;
}
}
}
}
return c;
}
static KMETHOD Statement_syntax(KonohaContext *kctx, KonohaStack *sfp)
{
kbool_t r = 0;
VAR_Statement(stmt, gma);
kTokenArray *tokenList = (kTokenArray *)kStmt_GetObject(kctx, stmt, KW_TokenPattern, NULL);
if(tokenList == NULL) {
SUGAR kStmt_Message2(kctx, stmt, NULL, ErrTag, "empty syntax");
}
if(tokenList != NULL) {
if(!IS_Array(tokenList)) { // create tokenList from a Token
kTokenArray *a = new_(TokenArray, 0, OnGcStack);
KLIB kArray_Add(kctx, a, tokenList);
tokenList = a;
}
DBG_ASSERT(IS_Array(tokenList));
kNameSpace *ns = Stmt_ns(stmt);
SugarSyntaxVar *syn = kNameSpace_guessSyntaxFromTokenList(kctx, ns, tokenList);
if(syn != NULL) {
if(syn->syntaxPatternListNULL_OnList != NULL) {
SUGAR kStmt_Message2(kctx, stmt, NULL, InfoTag, "oveloading syntax: %s%s", PSYM_t(syn->keyword));
}
else {
syn->syntaxPatternListNULL_OnList = new_(TokenArray, 0, ns->NameSpaceConstList);
}
TokenSeq tokens = {ns, tokenList, 0, kArray_size(tokenList)};
// Referred to kNameSpace_ParseSyntaxPattern in ast.h.
kArray *patternList = syn->syntaxPatternListNULL_OnList;
size_t firstPatternIdx = kArray_size(patternList);
SUGAR kArray_AddSyntaxRule(kctx, patternList, &tokens);
if(firstPatternIdx < kArray_size(patternList)) {
kToken *firstPattern = patternList->TokenItems[firstPatternIdx];
if(kToken_isFirstPattern(firstPattern)) {
kNameSpace_AppendArrayRef(kctx, ns, &((kNameSpaceVar *)ns)->stmtPatternListNULL_OnList, UPCAST(firstPattern));
}
}
r = 1;
}
kStmt_done(kctx, stmt);
}
KReturnUnboxValue(r);
}
static KMETHOD Statement_ConstDecl(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_Statement(stmt, gma);
kNameSpace *ns = Stmt_ns(stmt);
kToken *SymbolToken = SUGAR kStmt_GetToken(kctx, stmt, KW_SymbolPattern, NULL);
ksymbol_t unboxKey = SymbolToken->resolvedSymbol;
kbool_t result = SUGAR kStmt_TypeCheckByName(kctx, stmt, KW_ExprPattern, gma, TY_var, TypeCheckPolicy_CONST);
if(result) {
kExpr *ConstExpr = SUGAR kStmt_GetExpr(kctx, stmt, KW_ExprPattern, NULL);
ktype_t type = ConstExpr->ty;
uintptr_t unboxValue;
result = false;
if(ConstExpr->build == TEXPR_NULL) { // const C = String
type = VirtualType_KonohaClass;
unboxValue = (uintptr_t)(CT_(ConstExpr->ty));
result = true;
}
else if(ConstExpr->build == TEXPR_CONST) { // const C = "1"
unboxValue = (uintptr_t)ConstExpr->objectConstValue;
result = true;
}
else if(ConstExpr->build == TEXPR_NCONST) { // const c = 1
unboxValue = ConstExpr->unboxConstValue;
result = true;
}
if(result) {
KMakeTraceUL(trace, sfp, stmt->uline);
result = KLIB kNameSpace_SetConstData(kctx, ns, unboxKey, type, unboxValue, trace);
}
else {
kStmt_Message(kctx, stmt, ErrTag, "constant value is expected: %s%s", PSYM_t(unboxKey));
}
}
kStmt_done(kctx, stmt);
KReturnUnboxValue(result);
}
static void kSymbol_p(KonohaContext *kctx, KonohaValue *v, int pos, KGrowingBuffer *wb)
{
ksymbol_t symbol = (ksymbol_t)v[pos].unboxValue;
KLIB Kwb_printf(kctx, wb, "%s%s", PSYM_t(symbol));
}
static void kcid_p(KonohaContext *kctx, KonohaValue *v, int pos, KGrowingBuffer *wb)
{
ktype_t cid = (ktype_t)v[pos].intValue;
DBG_P(">>> Class=%s, cid=%d", SYM_t(CT_(cid)->classNameSymbol), cid);
KLIB Kwb_printf(kctx, wb, "%s%s", PSYM_t(CT_(cid)->classNameSymbol));
}
static void kBlock_AddMethodDeclStmt(KonohaContext *kctx, kBlock *bk, kToken *tokenClassName, kStmt *classStmt)
{
if(bk != NULL) {
size_t i;
for(i = 0; i < kArray_size(bk->StmtList); i++) {
kStmt *stmt = bk->StmtList->StmtItems[i];
if(stmt->syn->keyword == KW_TypeDeclPattern) continue;
if(stmt->syn->keyword == KW_MethodDeclPattern) {
kStmt *lastStmt = classStmt;
KLIB kObject_setObject(kctx, stmt, SYM_("ClassName"), TY_Token, tokenClassName);
SUGAR kBlock_InsertAfter(kctx, lastStmt->parentBlockNULL, lastStmt, stmt);
lastStmt = stmt;
}
else {
SUGAR kStmt_Message2(kctx, stmt, NULL, WarnTag, "%s is not available within the class clause", PSYM_t(stmt->syn->keyword));
}
}
}
}
