// @SmartReturn Object Prototype.get(Symbol symbol)
static KMETHOD Prototype_get(KonohaContext *kctx, KonohaStack *sfp)
{
KClass *targetClass = KGetReturnType(sfp);
DBG_P("requesting type=%s", KClass_text(targetClass));
ksymbol_t symbol = sfp[1].intValue;
KKeyValue *kvs = KLIB kObjectProto_GetKeyValue(kctx, sfp[0].asObject, symbol);
if(kvs != NULL) {
KClass *c = KClass_(kvs->attrTypeId);
if(targetClass == c) {
if(KClass_Is(UnboxType, targetClass)) {
KReturnUnboxValue(kvs->unboxValue);
}
else {
KReturnField(kvs->ObjectValue);
}
}
DBG_P("requesting type=%s instanceof %s ? %d", KClass_text(c), KClass_text(targetClass), c->isSubType(kctx, c, targetClass));
if(c->isSubType(kctx, c, targetClass)) {
if(KClass_Is(UnboxType, c)) {
if(KClass_Is(UnboxType, targetClass)) {
KReturnUnboxValue(kvs->unboxValue);
}
else {
DBG_P("boxing type=%s instanceof %s ? %d", KClass_text(c), KClass_text(targetClass), c->isSubType(kctx, c, targetClass));
KReturn(KLIB new_kObject(kctx, OnStack, c, kvs->unboxValue));
}
}
KReturnField(kvs->ObjectValue);
}
}
KReturnUnboxValue(0); // return default value
}
static void DumpOpArgument(KonohaContext *kctx, KBuffer *wb, KVirtualCodeType type, KVirtualCode *c, size_t i, KVirtualCode *vcode_start)
{
switch(type) {
case VMT_VOID: break;
case VMT_ADDR:
KLIB KBuffer_printf(kctx, wb, " L%d", (int)((KVirtualCode *)c->p[i] - vcode_start));
break;
case VMT_UL: {
kfileline_t uline = (kfileline_t)c->data[i];
KLIB KBuffer_printf(kctx, wb, " (%s:%d)", PLATAPI shortFilePath(KFileLine_textFileName(uline)), (khalfword_t)uline);
break;
}
case VMT_R: {
KLIB KBuffer_printf(kctx, wb, " sfp[%d,r=%d]", (int)c->data[i]/2, (int)c->data[i]);
break;
}
case VMT_FX: {
khalfword_t index = (khalfword_t)c->data[i];
khalfword_t xindex = (khalfword_t)(c->data[i] >> (sizeof(khalfword_t)*8));
KLIB KBuffer_printf(kctx, wb, " sfp[%d,r=%d][%d]", (int)index/2, (int)index, (int)xindex);
break;
}
case VMT_U:
KLIB KBuffer_printf(kctx, wb, " i%ld", (long)c->data[i]); break;
case VMT_C:
case VMT_TY:
KLIB KBuffer_printf(kctx, wb, "(%s)", KClass_text(c->ct[i])); break;
case VMT_F:
KLIB KBuffer_printf(kctx, wb, " function(%p)", c->p[i]); break;
case VMT_Object: {
kObject *o = c->o[i];
if(IS_Method(o)) {
kMethod *mtd = (kMethod *)o;
KLIB KBuffer_printf(kctx, wb, " %s.%s%s", KType_text(mtd->typeId), KMethodName_Fmt2(mtd->mn));
}
else {
KLIB KBuffer_printf(kctx, wb, " (%s)", KClass_text(kObject_class(o)));
KLIB kObject_WriteToBuffer(kctx, o, 0, wb, NULL, 0);
}
break;
}
case VMT_HCACHE:
break;
}/*switch*/
}
static KMETHOD Statement_class(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, ns, reqc);
kToken *tokenClassName = SUGAR kNode_GetToken(kctx, stmt, KSymbol_("$ClassName"), NULL);
int isNewlyDefinedClass = false;
KClassVar *definedClass = (KClassVar *)KLIB kNameSpace_GetClassByFullName(kctx, ns, kString_text(tokenClassName->text), kString_size(tokenClassName->text), NULL);
if(definedClass == NULL) { // Already defined
kshortflag_t cflag = kNode_ParseClassFlag(kctx, stmt, KClassFlag_Virtual);
KMakeTraceUL(trace, sfp, kNode_uline(stmt));
definedClass = kNameSpace_DefineClassName(kctx, ns, cflag, tokenClassName->text, trace);
isNewlyDefinedClass = true;
}
kNode *block = kNode_ParseClassNodeNULL(kctx, stmt, tokenClassName);
size_t declsize = kNode_countFieldSize(kctx, block);
if(isNewlyDefinedClass) { // Already defined
KClass *superClass = KClass_Object;
kToken *tokenSuperClass= SUGAR kNode_GetToken(kctx, stmt, KSymbol_("extends"), NULL);
if(tokenSuperClass != NULL) {
DBG_ASSERT(Token_isVirtualTypeLiteral(tokenSuperClass));
superClass = KClass_(Token_typeLiteral(tokenSuperClass));
if(KClass_Is(Final, superClass)) {
KReturn(SUGAR MessageNode(kctx, stmt, NULL, ns, ErrTag, "%s is final", KClass_text(superClass)));
}
if(KClass_Is(Virtual, superClass)) {
KReturn(SUGAR MessageNode(kctx, stmt, NULL, ns, ErrTag, "%s is still virtual", KClass_text(superClass)));
}
}
size_t initsize = (block != NULL) ? declsize : initFieldSizeOfVirtualClass(superClass);
KClass_InitField(kctx, definedClass, superClass, initsize);
}
else {
if(declsize > 0 && !KClass_Is(Virtual, definedClass)) {
KReturn(SUGAR MessageNode(kctx, stmt, NULL, ns, ErrTag, "%s has already defined", KClass_text(definedClass)));
}
}
if(block != NULL) {
if(!kNode_declClassField(kctx, block, ns, definedClass)) {
KReturnUnboxValue(false);
}
KClass_Set(Virtual, definedClass, false);
}
kToken_SetTypeId(kctx, tokenClassName, ns, definedClass->typeId);
kNode_AddMethodDeclNode(kctx, block, tokenClassName, stmt);
KReturn(kNode_Type(kctx, stmt, KNode_Done, KType_void));
}
static KMETHOD TypeCheck_to(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck2(stmt, expr, ns, reqc);
kNode *targetNode = SUGAR TypeCheckNodeAt(kctx, expr, 2, ns, KClass_INFER, 0);
kNode *selfNode = SUGAR TypeCheckNodeAt(kctx, expr, 1, ns, KClass_(targetNode->attrTypeId), TypeCheckPolicy_NoCheck);
if(selfNode != K_NULLNODE && targetNode != K_NULLNODE) {
KClass *selfClass = KClass_(selfNode->attrTypeId), *targetClass = KClass_(targetNode->attrTypeId);
if(selfNode->attrTypeId == targetNode->attrTypeId || selfClass->isSubType(kctx, selfClass, targetClass)) {
SUGAR MessageNode(kctx, selfNode, NULL, ns, InfoTag, "no need: %s to %s", KType_text(selfNode->attrTypeId), KType_text(targetNode->attrTypeId));
KReturn(selfNode);
}
kNameSpace *ns = kNode_ns(stmt);
kMethod *mtd = KLIB kNameSpace_GetCoercionMethodNULL(kctx, ns, selfClass, targetClass);
if(mtd == NULL) {
mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, selfClass, KMethodName_("to"), 0, KMethodMatch_CamelStyle);
DBG_ASSERT(mtd != NULL); // because Object.to is found.
if(mtd->typeId != selfClass->typeId) {
KReturn(SUGAR MessageNode(kctx, selfNode, NULL, ns, ErrTag, "undefined coercion: %s to %s", KClass_text(selfClass), KClass_text(targetClass)));
}
}
KReturn(SUGAR TypeCheckMethodParam(kctx, mtd, expr, ns, targetClass));
}
}
