static void Method_p(CTX, ksfp_t *sfp, int pos, kwb_t *wb, int level)
{
kMethod *mtd = sfp[pos].mtd;
kParam *pa = kMethod_param(mtd);
DBG_ASSERT(IS_Method(mtd));
if(level != 0) {
MethodAttribute_p(_ctx, mtd, wb);
}
kwb_printf(wb, "%s %s.%s%s", TY_t(pa->rtype), TY_t(mtd->cid), T_mn(mtd->mn));
if(level != 0) {
size_t i;
kwb_putc(wb, '(');
for(i = 0; i < pa->psize; i++) {
if(i > 0) {
kwb_putc(wb, ',', ' ');
}
if(FN_isCOERCION(pa->p[i].fn)) {
kwb_printf(wb, "@Coercion ");
}
kwb_printf(wb, "%s %s", TY_t(pa->p[i].ty), SYM_t(pa->p[i].fn));
}
// if(Param_isVARGs(DP(mtd)->mp)) {
// knh_write_delimdots(_ctx, w);
// }
kwb_putc(wb, ')');
}
}
static void kMethod_WriteToBuffer(KonohaContext *kctx, kMethod *mtd, KGrowingBuffer *wb)
{
kParam *pa = Method_param(mtd);
Method_WriteAttributeToBuffer(kctx, mtd, wb);
KLIB Kwb_printf(kctx, wb, "%s %s.%s%s", TY_t(pa->rtype), TY_t(mtd->typeId), MethodName_t(mtd->mn));
{
size_t i;
KLIB Kwb_Write(kctx, wb, "(", 1);
for(i = 0; i < pa->psize; i++) {
if(i > 0) {
KLIB Kwb_Write(kctx, wb, ", ", 2);
}
if(FN_isCOERCION(pa->paramtypeItems[i].fn)) {
KLIB Kwb_printf(kctx, wb, "@Coercion ");
}
KLIB Kwb_printf(kctx, wb, "%s %s", TY_t(pa->paramtypeItems[i].ty), SYM_t(pa->paramtypeItems[i].fn));
}
KLIB Kwb_Write(kctx, wb, ")", 1);
}
}
static void dumpEval(CTX, kwb_t *wb)
{
kstack_t *base = _ctx->stack;
ktype_t ty = base->evalty;
if(ty != TY_void) {
ksfp_t *lsfp = base->stack + base->evalidx;
CT_(ty)->p(_ctx, lsfp, 0, wb, P_DUMP);
fflush(stdout);
fprintf(stdout, "TYPE=%s EVAL=%s\n", TY_t(ty), kwb_top(wb,1));
}
}
static KMETHOD NameSpace_man(KonohaContext *kctx, KonohaStack *sfp)
{
INIT_GCSTACK();
kArray *list = kctx->stack->gcstack_OnContextConstList;
size_t start = kArray_size(list);
kNameSpace *ns = sfp[0].asNameSpace;
KonohaClass *ct = O_ct(sfp[1].asObject);
DBG_P("*** man %s", TY_t(ct->typeId));
while(ns != NULL) {
copyMethodList(kctx, ct->typeId, ns->methodList_OnList, list);
ns = ns->parentNULL;
}
copyMethodList(kctx, ct->typeId, ct->methodList_OnGlobalConstList, list);
dumpMethodList(kctx, sfp, start, list);
RESET_GCSTACK();
}
static void DumpVisitor_init(KonohaContext *kctx, struct IRBuilder *builder, kMethod *mtd)
{
unsigned i;
KGrowingBuffer wb;
KLIB Kwb_init(&(kctx->stack->cwb), &wb);
kParam *pa = Method_param(mtd);
KLIB Kwb_printf(kctx, &wb, "METHOD %s%s(", T_mn(mtd->mn));
for (i = 0; i < pa->psize; i++) {
if(i != 0) {
KLIB Kwb_write(kctx, &wb, ", ", 2);
}
KLIB Kwb_printf(kctx, &wb, "%s %s", TY_t(pa->paramtypeItems[i].ty), SYM_t(pa->paramtypeItems[i].fn));
}
emit_string(KLIB Kwb_top(kctx, &wb, 1), "", ") {", 0);
builder->local_fields = (void *) KMalloc_UNTRACE(sizeof(int));
DUMPER(builder)->indent = 0;
}
static KMETHOD TypeCheck_to(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, expr, gma, reqty);
kExpr *targetExpr = SUGAR kStmt_TypeCheckExprAt(kctx, stmt, expr, 2, gma, TY_var, 0);
kExpr *selfExpr = SUGAR kStmt_TypeCheckExprAt(kctx, stmt, expr, 1, gma, targetExpr->ty, TypeCheckPolicy_NOCHECK);
if(selfExpr != K_NULLEXPR && targetExpr != K_NULLEXPR) {
KonohaClass *selfClass = CT_(selfExpr->ty), *targetClass = CT_(targetExpr->ty);
if(selfExpr->ty == targetExpr->ty || selfClass->isSubType(kctx, selfClass, targetClass)) {
kStmtExpr_Message(kctx, stmt, selfExpr, InfoTag, "no need: %s to %s", TY_t(selfExpr->ty), TY_t(targetExpr->ty));
KReturn(selfExpr);
}
kNameSpace *ns = Stmt_ns(stmt);
kMethod *mtd = KLIB kNameSpace_GetCoercionMethodNULL(kctx, ns, selfExpr->ty, targetExpr->ty);
if(mtd == NULL) {
mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, selfExpr->ty, MN_("to"), 0);
DBG_ASSERT(mtd != NULL); // because Object.to is found.
if(mtd->typeId != selfExpr->ty) {
KReturn(kStmtExpr_Message(kctx, stmt, selfExpr, ErrTag, "undefined coercion: %s to %s", TY_t(selfExpr->ty), TY_t(targetExpr->ty)));
}
}
KReturn(SUGAR kStmtkExpr_TypeCheckCallParam(kctx, stmt, expr, mtd, gma, targetClass->typeId));
}
}
static void LETEXPR_asm(KonohaContext *kctx, kStmt *stmt, int a, kExpr *expr, int shift, int espidx)
{
kExpr *leftHandExpr = kExpr_at(expr, 1);
kExpr *rightHandExpr = kExpr_at(expr, 2);
DBG_P("LET (%s) a=%d, shift=%d, espidx=%d", TY_t(expr->ty), a, shift, espidx);
if(leftHandExpr->build == TEXPR_LOCAL) {
EXPR_asm(kctx, stmt, leftHandExpr->index, rightHandExpr, shift, espidx);
if(expr->ty != TY_void && a != leftHandExpr->index) {
NMOV_asm(kctx, a, leftHandExpr->ty, leftHandExpr->index);
}
}
else if(leftHandExpr->build == TEXPR_STACKTOP) {
DBG_P("LET TEXPR_STACKTOP a=%d, leftHandExpr->index=%d, espidx=%d", a, leftHandExpr->index, espidx);
EXPR_asm(kctx, stmt, leftHandExpr->index + shift, rightHandExpr, shift, espidx);
if(expr->ty != TY_void && a != leftHandExpr->index + shift) {
NMOV_asm(kctx, a, leftHandExpr->ty, leftHandExpr->index + shift);
}
}
else{
assert(leftHandExpr->build == TEXPR_FIELD);
EXPR_asm(kctx, stmt, espidx, rightHandExpr, shift, espidx);
kshort_t index = (kshort_t)leftHandExpr->index;
kshort_t xindex = (kshort_t)(leftHandExpr->index >> (sizeof(kshort_t)*8));
if(TY_isUnbox(rightHandExpr->ty)) {
ASM(XNMOV, OC_(index), xindex, NC_(espidx), CT_(leftHandExpr->ty));
if(expr->ty != TY_void) {
ASM(NMOVx, NC_(a), OC_(index), xindex, CT_(leftHandExpr->ty));
}
}
else {
ASM(XNMOV, OC_(index), xindex, OC_(espidx), CT_(leftHandExpr->ty));
if(expr->ty != TY_void) {
ASM(NMOVx, OC_(a), OC_(index), xindex, CT_(leftHandExpr->ty));
}
}
}
}
static void dumpMethodList(CTX, ksfp_t *sfp, size_t start, kArray *list)
{
size_t i;
for(i = start; i < kArray_size(list); i++) {
dumpMethod(_ctx, sfp, list->methods[i]);
}
}
KMETHOD KonohaSpace_man(CTX, ksfp_t *sfp _RIX)
{
INIT_GCSTACK();
kArray *list = _ctx->stack->gcstack;
size_t start = kArray_size(list);
kKonohaSpace *ks = sfp[0].ks;
kclass_t *ct = O_ct(sfp[1].o);
DBG_P("*** man %s", TY_t(ct->cid));
while(ks != NULL) {
copyMethodList(_ctx, ct->cid, ks->methods, list);
ks = ks->parentNULL;
}
copyMethodList(_ctx, ct->cid, ct->methods, list);
dumpMethodList(_ctx, sfp, start, list);
RESET_GCSTACK();
}
// --------------------------------------------------------------------------
#define _Public kMethod_Public
#define _Const kMethod_Const
#define _Coercion kMethod_Coercion
#define _F(F) (intptr_t)(F)
static KMETHOD TypeCheck_as(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, expr, gma, reqty);
kExpr *targetExpr = SUGAR kStmt_TypeCheckExprAt(kctx, stmt, expr, 2, gma, TY_var, 0);
kExpr *selfExpr = SUGAR kStmt_TypeCheckExprAt(kctx, stmt, expr, 1, gma, targetExpr->ty, TypeCheckPolicy_NOCHECK);
if(selfExpr != K_NULLEXPR && targetExpr != K_NULLEXPR) {
KonohaClass *selfClass = CT_(selfExpr->ty), *targetClass = CT_(targetExpr->ty);
if(selfExpr->ty == targetExpr->ty || selfClass->isSubType(kctx, selfClass, targetClass)) {
KReturn(selfExpr);
}
if(selfClass->isSubType(kctx, targetClass, selfClass)) {
kNameSpace *ns = Stmt_ns(stmt);
kMethod *mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, TY_Object, MN_("as"), 0);
DBG_ASSERT(mtd != NULL);
KReturn(SUGAR kStmtkExpr_TypeCheckCallParam(kctx, stmt, expr, mtd, gma, targetClass->typeId));
}
KReturn(kStmtExpr_Message(kctx, stmt, selfExpr, ErrTag, "unable to downcast: %s as %s", TY_t(selfExpr->ty), TY_t(targetExpr->ty)));
}
}
