static kBlock* kStmt_ParseClassBlockNULL(KonohaContext *kctx, kStmt *stmt, kToken *tokenClassName)
{
kBlock *bk = NULL;
kToken *blockToken = (kToken *)kStmt_GetObject(kctx, stmt, KW_BlockPattern, NULL);
if(blockToken != NULL && blockToken->resolvedSyntaxInfo->keyword == KW_BlockPattern) {
const char *cname = S_text(tokenClassName->text);
TokenSeq range = {Stmt_ns(stmt), GetSugarContext(kctx)->preparedTokenList};
TokenSeq_Push(kctx, range);
SUGAR TokenSeq_Tokenize(kctx, &range, S_text(blockToken->text), blockToken->uline);
{
TokenSeq sourceRange = {range.ns, range.tokenList, range.endIdx};
kToken *prevToken = blockToken;
int i;
for(i = range.beginIdx; i < range.endIdx; i++) {
kToken *tk = range.tokenList->TokenItems[i];
if(tk->hintChar == '(' && prevToken->unresolvedTokenType == TokenType_SYMBOL && strcmp(cname, S_text(prevToken->text)) == 0) {
kTokenVar *newToken = new_(TokenVar, TokenType_SYMBOL, sourceRange.tokenList);
KFieldSet(newToken, newToken->text, SYM_s(MN_new));
}
KLIB kArray_Add(kctx, sourceRange.tokenList, tk);
prevToken = tk;
}
TokenSeq_end(kctx, (&sourceRange));
bk = SUGAR new_kBlock(kctx, stmt/*parent*/, NULL, &sourceRange);
KLIB kObject_setObject(kctx, stmt, KW_BlockPattern, TY_Block, bk);
}
TokenSeq_Pop(kctx, range);
}
return bk;
}
static void LoopStmt_asm(KonohaContext *kctx, kStmt *stmt, int shift, int espidx)
{
kBasicBlock* lbCONTINUE = new_BasicBlockLABEL(kctx);
kBasicBlock* lbBREAK = new_BasicBlockLABEL(kctx);
// BUILD_pushLABEL(kctx, stmt, lbCONTINUE, lbBREAK);
KLIB kObject_setObject(kctx, stmt, SYM_("continue"), TY_BasicBlock, lbCONTINUE);
KLIB kObject_setObject(kctx, stmt, SYM_("break"), TY_BasicBlock, lbBREAK);
ASM_LABEL(kctx, lbCONTINUE);
ASM_SAFEPOINT(kctx, espidx);
EXPR_asmJMPIF(kctx, stmt, espidx, SUGAR kStmt_getExpr(kctx, stmt, KW_ExprPattern, NULL), 0/*FALSE*/, lbBREAK, shift, espidx);
//BLOCK_asm(kctx, SUGAR kStmt_getBlock(kctx, stmt, KW_("iteration"), K_NULLBLOCK));
BLOCK_asm(kctx, SUGAR kStmt_getBlock(kctx, stmt, NULL/*DefaultNameSpace*/, KW_BlockPattern, K_NULLBLOCK), shift);
ASM_JMP(kctx, lbCONTINUE);
ASM_LABEL(kctx, lbBREAK);
// BUILD_popLABEL(kctx);
}
static KMETHOD PatternMatch_ClassName(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_PatternMatch(stmt, name, tokenList, beginIdx, endIdx);
kTokenVar *tk = tokenList->TokenVarItems[beginIdx];
int returnIdx = -1;
if(tk->resolvedSyntaxInfo->keyword == KW_SymbolPattern || tk->resolvedSyntaxInfo->keyword == KW_TypePattern) {
KLIB kObject_setObject(kctx, stmt, name, O_typeId(tk), tk);
returnIdx = beginIdx + 1;
}
KReturnUnboxValue(returnIdx);
}
static kStmt* TypeDeclAndMakeSetter(KonohaContext *kctx, kStmt *stmt, kGamma *gma, ktype_t ty, kExpr *termExpr, kExpr *valueExpr, kObject *scr)
{
kNameSpace *ns = Stmt_ns(stmt);
kMethod *mtd = Object_newProtoSetterNULL(kctx, stmt, scr, ty, termExpr->termToken->resolvedSymbol);
if(mtd != NULL) {
kExpr *recvExpr = new_ConstValueExpr(kctx, O_typeId(scr), scr);
kExpr *setterExpr = SUGAR new_TypedCallExpr(kctx, stmt, gma, TY_void, mtd, 2, recvExpr, valueExpr);
kStmt *newstmt = new_(Stmt, stmt->uline, OnGcStack);
kStmt_setsyn(newstmt, SYN_(ns, KW_ExprPattern));
KLIB kObject_setObject(kctx, newstmt, KW_ExprPattern, TY_Expr, setterExpr);
return newstmt;
}
return NULL;
}
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));
}
}
}
}
static KMETHOD Statement_import(KonohaContext *kctx, KonohaStack *sfp)
{
int ret = false;
VAR_Statement(stmt, gma);
kTokenArray *tokenList = (kTokenArray *) kStmt_GetObjectNULL(kctx, stmt, KW_TokenPattern);
if(tokenList == NULL) {
KReturnUnboxValue(false);
}
kNameSpace *ns = Stmt_ns(stmt);
SugarSyntaxVar *syn = (SugarSyntaxVar *) SYN_(ns, KW_ExprMethodCall);
kExpr *expr;
kTokenVar *tkImport = /*G*/new_(TokenVar, 0, OnGcStack);
tkImport->resolvedSymbol = MN_("import");
if(IS_Token(tokenList)) {
kTokenArray *list = ((kToken *) tokenList)->subTokenList;
if(IS_String(list)) {
/* case: import cstyle; */
kString *pkgname = (kString *) list;
expr = CreateImportCall(kctx, syn, tkImport, ns, pkgname);
}
else if(kArray_size(list) == 1) {
/* case : import("konoha.import"); */
kExpr *param0 = makeStringConstValue(kctx, list->TokenItems[0]->text);
expr = SUGAR new_UntypedCallStyleExpr(kctx, syn, 3,
tkImport, new_ConstValueExpr(kctx, O_typeId(ns), UPCAST(ns)), param0);
}
else if(kArray_size(list) == 2) {
/* case : import("konoha.import", "import"); */
kExpr *param0 = makeStringConstValue(kctx, list->TokenItems[0]->text);
kExpr *param1 = makeStringConstValue(kctx, list->TokenItems[1]->text);
expr = SUGAR new_UntypedCallStyleExpr(kctx, syn, 4,
tkImport, new_ConstValueExpr(kctx, O_typeId(ns), UPCAST(ns)),
param0, param1);
} else {
KReturnUnboxValue(false);
}
} else {
KGrowingBuffer wb;
KLIB Kwb_Init(&(kctx->stack->cwb), &wb);
/* case : import konoha.import */
ksymbol_t star = SYM_("*");
size_t i = 0;
if(i + 2 < kArray_size(tokenList)) {
for (; i < kArray_size(tokenList)-1; i+=2) {
/* name . */
kToken *tk = tokenList->TokenItems[i+0];
if(i+2 < kArray_size(tokenList)) {
kToken *startTk = tokenList->TokenItems[i+2];
if(startTk->resolvedSyntaxInfo->keyword == star) {
break;
}
}
KLIB Kwb_Write(kctx, &wb, S_text(tk->text), S_size(tk->text));
KLIB Kwb_Write(kctx, &wb, ".", 1);
}
}
kString *name = tokenList->TokenItems[i]->text;
KLIB Kwb_Write(kctx, &wb, S_text(name), S_size(name));
kString *pkgname = KLIB new_kString(kctx, OnGcStack, KLIB Kwb_top(kctx, &wb, 1), Kwb_bytesize(&wb), 0);
expr = CreateImportCall(kctx, syn, tkImport, ns, pkgname);
}
KLIB kObject_setObject(kctx, stmt, KW_ExprPattern, TY_Expr, expr);
ret = SUGAR kStmt_TypeCheckByName(kctx, stmt, KW_ExprPattern, gma, TY_void, TypeCheckPolicy_ALLOWVOID);
if(ret) {
kStmt_typed(stmt, EXPR);
}
KReturnUnboxValue(ret);
}
