//## Node Node.message(int error, String msg);
static KMETHOD Node_Message(KonohaContext *kctx, KonohaStack *sfp)
{
kNode *node = sfp[0].asNode;
kinfotag_t level = (kinfotag_t)sfp[1].intValue;
kString *msg = sfp[2].asString;
KReturn(SUGAR MessageNode(kctx, node, NULL, kNode_ns(node), level, "%s", kString_text(msg)));
}
//## Node Node.message(int error, Token tk, String msg);
static KMETHOD NodeToken_Message(KonohaContext *kctx, KonohaStack *sfp)
{
kNode *stmt = sfp[0].asNode;
kinfotag_t level = (kinfotag_t)sfp[1].intValue;
kString *msg = sfp[3].asString;
KReturn(SUGAR MessageNode(kctx, stmt, sfp[2].asToken, kNode_ns(stmt), level, "%s", kString_text(msg)));
}
static void kNode_AddMethodDeclNode(KonohaContext *kctx, kNode *bk, kToken *tokenClassName, kNode *classNode)
{
if(bk == NULL) {
return;
}
size_t i;
kNameSpace *ns = kNode_ns(classNode);
kMethod *AddMethod = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, KClass_NameSpace, KMethodName_("AddMethodDecl"), 1, KMethodMatch_NoOption);
for(i = 0; i < kNode_GetNodeListSize(kctx, bk); i++) {
kNode *stmt = bk->NodeList->NodeItems[i];
if(stmt->syn->keyword == KSymbol_TypeDeclPattern)
continue;
if(stmt->syn->keyword == KSymbol_MethodDeclPattern) {
KLIB kObjectProto_SetObject(kctx, stmt, KSymbol_("ClassName"), KType_Token, tokenClassName);
kNodeVar *classParentBlock = kNode_GetParentNULL(classNode);
if(classParentBlock == NULL) {
classParentBlock = KNewNode(ns);
SUGAR kNode_AddNode(kctx, classParentBlock, classNode);
kNode_Type(kctx, classParentBlock, KNode_Block, KType_void);
}
/* Create 'NameSpace.AddMethodDecl(stmt)' */
kNode *arg0 = new_ConstNode(kctx, ns, NULL, UPCAST(ns));
kNode *arg1 = new_ConstNode(kctx, ns, NULL, UPCAST(stmt));
kNode *callNode = SUGAR new_MethodNode(kctx, ns, KClass_NameSpace, AddMethod, 2, arg0, arg1);
SUGAR kNode_AddNode(kctx, classParentBlock, callNode);
}
else {
SUGAR MessageNode(kctx, stmt, NULL, NULL, WarnTag, "%s is not available within the class clause", KSymbol_Fmt2(stmt->syn->keyword));
}
}
}
static KMETHOD TypeCheck_Getter(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck2(stmt, expr, ns, reqc);
kToken *fieldToken = expr->NodeList->TokenItems[0];
ksymbol_t fn = fieldToken->symbol;
kNode *self = KLIB TypeCheckNodeAt(kctx, expr, 1, ns, KClass_INFER, 0);
if(self != K_NULLNODE) {
kMethod *mtd = KLIB kNameSpace_GetGetterMethodNULL(kctx, ns, KClass_(self->typeAttr), fn);
if(mtd != NULL) {
KFieldSet(expr->NodeList, expr->NodeList->MethodItems[0], mtd);
KReturn(KLIB TypeCheckMethodParam(kctx, mtd, expr, ns, reqc));
}
else { // dynamic field o.name => o.get(name)
kparamtype_t p[1] = {{KType_Symbol}};
kparamId_t paramdom = KLIB Kparamdom(kctx, 1, p);
mtd = KLIB kNameSpace_GetMethodBySignatureNULL(kctx, ns, KClass_(self->typeAttr), KMethodNameAttr_Getter, paramdom, 1, p);
if(mtd != NULL) {
KFieldSet(expr->NodeList, expr->NodeList->MethodItems[0], mtd);
KLIB kArray_Add(kctx, expr->NodeList, new_UnboxConstNode(kctx, ns, KType_Symbol, KSymbol_Unmask(fn)));
KReturn(KLIB TypeCheckMethodParam(kctx, mtd, expr, ns, reqc));
}
}
KLIB MessageNode(kctx, stmt, fieldToken, ns, ErrTag, "undefined field: %s", kString_text(fieldToken->text));
}
}
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 kbool_t kNode_AddClassField(KonohaContext *kctx, kNode *stmt, kNameSpace *ns, KClassVar *definedClass, ktypeattr_t ty, kNode *expr)
{
if(expr->syn->keyword == KSymbol_LET) { // String name = "naruto";
kNode *lexpr = kNode_At(expr, 1);
if(kNode_IsTerm(lexpr)) {
kString *name = lexpr->TermToken->text;
ksymbol_t symbol = KAsciiSymbol(kString_text(name), kString_size(name), KSymbol_NewId);
kNode *vexpr = SUGAR TypeCheckNodeAt(kctx, expr, 2, ns, KClass_(ty), 0);
if(vexpr == K_NULLNODE) return false;
if(vexpr->node == KNode_Const) {
KLIB KClass_AddField(kctx, definedClass, ty, symbol);
KClass_SetClassFieldObjectValue(kctx, definedClass, symbol, vexpr->ObjectConstValue);
}
else if(vexpr->node == KNode_UnboxConst) {
KLIB KClass_AddField(kctx, definedClass, ty, symbol);
KClass_SetClassFieldUnboxValue(kctx, definedClass, symbol, vexpr->unboxConstValue);
}
else if(vexpr->node == KNode_Null) {
KLIB KClass_AddField(kctx, definedClass, ty, symbol);
}
else {
SUGAR MessageNode(kctx, stmt, lexpr->TermToken, ns, ErrTag, "field initial value must be const: %s", kString_text(name));
return false;
}
return true;
}
} else if(expr->syn->keyword == KSymbol_COMMA) { // String (firstName = naruto, lastName)
size_t i;
for(i = 1; i < kNode_GetNodeListSize(kctx, expr); i++) {
if(!kNode_AddClassField(kctx, stmt, ns, definedClass, ty, kNode_At(expr, i))) return false;
}
return true;
}
else if(kNode_IsTerm(expr)) { // String name
kString *name = expr->TermToken->text;
ksymbol_t symbol = KAsciiSymbol(kString_text(name), kString_size(name), KSymbol_NewId);
KLIB KClass_AddField(kctx, definedClass, ty, symbol);
return true;
}
SUGAR MessageNode(kctx, stmt, NULL, ns, ErrTag, "field name is expected");
return false;
}
static KMETHOD Statement_continue(KonohaContext *kctx, KonohaStack *sfp)
{
VAR_TypeCheck(stmt, ns, reqc);
kNode *p = stmt;
while(p != NULL) {
if(kNode_Is(CatchContinue, p)) {
KLIB kObjectProto_SetObject(kctx, stmt, KSymbol_("continue"), KType_Node, p);
KReturn(kNode_Type(kctx, stmt, KNode_Continue, KType_void));
}
p = kNode_GetParentNULL(p);
}
KReturn(SUGAR MessageNode(kctx, stmt, NULL, ns, ErrTag, "continue statement not within a loop"));
}
void NetlinkProtocol::stop()
{
running_ = false;
try
{
if (messages_.empty())
{
messages_.push(MessageNode(std::make_unique<tnt::message::StopMessage>()));
}
}
catch (...) { }
}
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));
}
}
std::future<void> AsyncProtocol::send(std::unique_ptr<Message>&& message)
{
std::promise<void> promise;
auto future = promise.get_future();
if (running_)
{
messages_.push(MessageNode(std::move(message), std::move(promise)));
}
else
{
promise.set_exception(std::make_exception_ptr(ProtocolException(tnt::get_name(*this) + " is not running.")));
}
return future;
}
void AsyncProtocol::stop()
{
try
{
running_ = false;
if (messages_.empty())
{
messages_.push(MessageNode(std::make_unique<message::StopMessage>()));
}
if (io_)
{
io_->reset();
}
}
catch (...) {}
}
static KMETHOD TypeCheck_as(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(selfClass->typeId == targetClass->typeId || selfClass->isSubType(kctx, selfClass, targetClass)) {
KReturn(selfNode);
}
if(selfClass->isSubType(kctx, targetClass, selfClass)) {
kNameSpace *ns = kNode_ns(stmt);
kMethod *mtd = KLIB kNameSpace_GetMethodByParamSizeNULL(kctx, ns, KClass_Object, KMethodName_("as"), 0, KMethodMatch_CamelStyle);
DBG_ASSERT(mtd != NULL);
KReturn(SUGAR TypeCheckMethodParam(kctx, mtd, expr, ns, targetClass));
}
KReturn(SUGAR MessageNode(kctx, selfNode, NULL, ns, ErrTag, "unable to downcast: %s as %s", KType_text(selfNode->attrTypeId), KType_text(targetNode->attrTypeId)));
}
}