static kbool_t MiniVM_VisitAssignNode(KonohaContext *kctx, KBuilder *builder, kUntypedNode *node, void *thunk)
{
/*
* [LetExpr] := lhs = rhs
* expr->NodeList = [NULL, lhs, rhs]
**/
intptr_t dst = -1;
kUntypedNode *left = kUntypedNode_At(node, 1);
kUntypedNode *right = kUntypedNode_At(node, 2);
ktypeattr_t type = left->typeAttr;
ksymbol_t symbol;
assert(IS_Token(left->TermToken));
symbol = left->TermToken->symbol;
if(kUntypedNode_node(left) == KNode_Local) {
if((dst = MiniVMBuilder_FindLocalVar(kctx, builder, symbol, type, left->index)) == -1) {
dst = AddLocal(kctx, builder, left->index, symbol, type);
}
KLIB VisitNode(kctx, builder, right, thunk);
CreateUpdate(kctx, builder, type, dst, MiniVM_getExpression(builder));
builder->Value = dst;
}
else {
khalfword_t index = (khalfword_t)left->index;
khalfword_t xindex = (khalfword_t)(left->index >> (sizeof(khalfword_t)*8));
KClass *lhsClass = KClass_(left->typeAttr);
KClass *rhsClass = KClass_(right->typeAttr);
assert(kUntypedNode_node(left) == KNode_Field);
if((dst = MiniVMBuilder_FindLocalVar(kctx, builder, symbol, KType_Object, index)) == -1) {
dst = AddLocal(kctx, builder, index, symbol, KType_Object);
}
KLIB VisitNode(kctx, builder, right, thunk);
ASM(XNMOV, OC_(index), xindex, TC_(MiniVM_getExpression(builder), rhsClass), lhsClass);
if(node->typeAttr != KType_void) {
builder->Value = builder->stackbase;
ASM(NMOVx, TC_(builder->stackbase, rhsClass), OC_(index), xindex, lhsClass);
}
}
return true;
}
static kbool_t KBuilder_VisitAssignNode(KonohaContext *kctx, KBuilder *builder, kNode *expr, void *thunk)
{
kNode *leftHandNode = kNode_At(expr, 1);
kNode *rightHandNode = kNode_At(expr, 2);
//DBG_P("LET (%s) a=%d, shift=%d, espidx=%d", KType_text(expr->attrTypeId), a, shift, espidx);
if(kNode_node(leftHandNode) == KNode_Local) {
kshort_t a = AssignStack(thunk);
SUGAR VisitNode(kctx, builder, rightHandNode, &(leftHandNode->index));
if(expr->attrTypeId != KType_void && a != leftHandNode->index) {
AsmMOV(kctx, builder, a, KClass_(leftHandNode->attrTypeId), leftHandNode->index);
}
}
else if(kNode_node(leftHandNode) == KNode_Field) {
intptr_t espidx = expr->stackbase;
SUGAR VisitNode(kctx, builder, rightHandNode, &espidx);
kshort_t index = (kshort_t)leftHandNode->index;
kshort_t xindex = (kshort_t)(leftHandNode->index >> (sizeof(kshort_t)*8));
KClass *lhsClass = KClass_(leftHandNode->attrTypeId), *rhClass = KClass_(rightHandNode->attrTypeId);
ASM(XNMOV, OC_(index), xindex, TC_(espidx, rhClass), lhsClass);
if(expr->attrTypeId != KType_void) {
kshort_t a = AssignStack(thunk);
ASM(NMOVx, TC_(a, rhClass), OC_(index), xindex, lhsClass);
}
}
static kbool_t MiniVM_VisitFieldNode(KonohaContext *kctx, KBuilder *builder, kUntypedNode *node, void *thunk)
{
ksymbol_t symbol;
intptr_t src;
KClass *ty;
khalfword_t index = (khalfword_t)(node->index);
khalfword_t xindex = (khalfword_t)(node->index >> (sizeof(khalfword_t)*8));
assert(IS_Token(node->TermToken));
symbol = node->TermToken->symbol;
if((src = MiniVMBuilder_FindLocalVar(kctx, builder, symbol, KType_Object, index)) == -1) {
src = AddLocal(kctx, builder, index, symbol, KType_Object);
}
ty = KClass_(node->typeAttr);
ASM(NMOVx, TC_(builder->stackbase, ty), OC_(src), xindex, ty);
builder->Value = builder->stackbase;
return true;
}
static void ASM_NMOV(KonohaContext *kctx, KBuilder *builder, KClass *Ty, int dst, int src)
{
if(dst != src) {
ASM(NMOV, TC_(dst, Ty), TC_(src, Ty), Ty);
}
}
void TC_(doneIterBag)( WordBag* bag )
{
TC_(doneIterFM)( bag->fm );
}
Bool TC_(nextIterBag)( WordBag* bag, /*OUT*/Word* pVal, /*OUT*/Word* pCount )
{
return TC_(nextIterFM)( bag->fm, pVal, pCount );
}
void TC_(initIterBag)( WordBag* bag )
{
TC_(initIterFM)(bag->fm);
}
Bool TC_(isEmptyBag)( WordBag* bag )
{
return TC_(sizeFM)(bag->fm) == 0;
}
Word TC_(sizeUniqueBag) ( WordBag* bag )
{
return TC_(sizeFM)( bag->fm );
}
static void AsmMOV(KonohaContext *kctx, KBuilder *builder, int a, KClass *ty, int b)
{
ASM(NMOV, TC_(a, ty), TC_(b, ty), ty);
}
