Esempio n. 1
0
void MODSUGAR_Init(KonohaContext *kctx, KonohaContextVar *ctx)
{
	KModuleSugar *mod = (KModuleSugar *)KCalloc_UNTRACE(sizeof(KModuleSugar), 1);
	mod->h.name     = "sugar";
	mod->h.allocSize = sizeof(KModuleSugar);
	mod->h.setupModuleContext    = SugarModule_Setup;
	KLIB KonohaRuntime_setModule(kctx, MOD_sugar, (KonohaModule *)mod, 0);

	KonohaLibVar* l = (KonohaLibVar *)ctx->klib;
	l->kNameSpace_GetClass       = kNameSpace_GetClass;
	l->kNameSpace_DefineClass    = kNameSpace_DefineClass;
	l->kNameSpace_LoadMethodData = kNameSpace_LoadMethodData;
	l->kNameSpace_SetConstData   = kNameSpace_SetConstData;
	l->kNameSpace_LoadConstData  = kNameSpace_LoadConstData;
	l->kNameSpace_GetGetterMethodNULL  = kNameSpace_GetGetterMethodNULL;
	l->kNameSpace_GetSetterMethodNULL  = kNameSpace_GetSetterMethodNULL;
	l->kNameSpace_GetCoercionMethodNULL = kNameSpace_GetCoercionMethodNULL;
	l->kNameSpace_GetMethodByParamSizeNULL  = kNameSpace_GetMethodByParamSizeNULL;
	l->kNameSpace_GetMethodBySignatureNULL  = kNameSpace_GetMethodBySignatureNULL;
	l->kMethod_DoLazyCompilation = kMethod_DoLazyCompilation;
//	l->kNameSpace_compileAllDefinedMethods  = kNameSpace_compileAllDefinedMethods;
	l->kNameSpace_FreeSugarExtension =  kNameSpace_FreeSugarExtension;
	l->Konoha_LoadScript = Konoha_LoadScript;
	l->Konoha_Eval       = Konoha_Eval;
	l->kMethod_GenCode   = kMethod_GenCode;
	l->kMethod_setFunc   = kMethod_setFunc;

	KDEFINE_CLASS defToken = {0};
	SETSTRUCTNAME(defToken, Token);
	defToken.init = kToken_Init;
	defToken.reftrace = kToken_Reftrace;
	defToken.p = kToken_p;
	
	KDEFINE_CLASS defExpr = {0};
	SETSTRUCTNAME(defExpr, Expr);
	defExpr.init = kExpr_Init;
	defExpr.reftrace = kExpr_Reftrace;
	defExpr.p        = kExpr_p;
	
	KDEFINE_CLASS defStmt = {0};
	SETSTRUCTNAME(defStmt, Stmt);
	defStmt.init = kStmt_Init;
	defStmt.reftrace = kStmt_Reftrace;
	defStmt.p        = kStmt_p;
	
	KDEFINE_CLASS defBlock = {0};
	SETSTRUCTNAME(defBlock, Block);
	defBlock.init = kBlock_Init;
	defBlock.reftrace = kBlock_Reftrace;
	
	KDEFINE_CLASS defGamma = {0};
	SETSTRUCTNAME(defGamma, Gamma);
	defGamma.init = Gamma_Init;

	mod->cToken =     KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defToken, 0);
	mod->cExpr  =     KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defExpr, 0);
	mod->cStmt  =     KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defStmt, 0);
	mod->cBlock =     KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defBlock, 0);
	mod->cGamma =     KLIB KonohaClass_define(kctx, PackageId_sugar, NULL, &defGamma, 0);
	mod->cTokenArray = CT_p0(kctx, CT_Array, mod->cToken->typeId);

	KLIB Knull(kctx, mod->cToken);
	KLIB Knull(kctx, mod->cExpr);
	kStmtVar *NullStmt = (kStmtVar *)KLIB Knull(kctx, mod->cStmt);
	KFieldSet(NullStmt, NullStmt->parentBlockNULL, (kBlock *)KLIB Knull(kctx, mod->cBlock));

	SugarModule_Setup(kctx, &mod->h, 0);

	KDEFINE_INT_CONST ClassData[] = {   // minikonoha defined class
		{"void", VirtualType_KonohaClass, (uintptr_t)CT_void},
		{"boolean", VirtualType_KonohaClass, (uintptr_t)CT_Boolean},
		{"int",    VirtualType_KonohaClass, (uintptr_t)CT_Int},
		{"String", VirtualType_KonohaClass, (uintptr_t)CT_String},
		{"Func",   VirtualType_KonohaClass, (uintptr_t)CT_Func},
		{"System", VirtualType_KonohaClass, (uintptr_t)CT_System},
		{NULL},
	};
	kNameSpace_LoadConstData(kctx, KNULL(NameSpace), KonohaConst_(ClassData), 0);

	mod->kNameSpace_SetTokenFunc       = kNameSpace_SetTokenFunc;
	mod->TokenSeq_Tokenize        = TokenSeq_Tokenize;
	mod->TokenSeq_ApplyMacro      = TokenSeq_ApplyMacro;
	mod->kNameSpace_SetMacroData       = kNameSpace_SetMacroData;
	mod->TokenSeq_Resolve        = TokenSeq_Resolve;
	mod->TokenSeq_Eval            = TokenSeq_Eval;
	mod->TokenUtils_ParseTypePattern     = TokenUtils_ParseTypePattern;
	mod->kToken_ToBraceGroup = kToken_ToBraceGroup;
	mod->kStmt_AddParsedObject      = kStmt_AddParsedObject;
	mod->kNameSpace_FindEndOfStatement = kNameSpace_FindEndOfStatement;
	mod->kStmt_ParseFlag            = kStmt_ParseFlag;
	mod->kStmt_GetToken             = kStmt_GetToken;
	mod->kStmt_GetBlock             = kStmt_GetBlock;
	mod->kStmt_GetExpr              = kStmt_GetExpr;
	mod->kStmt_GetText              = kStmt_GetText;
	mod->kExpr_SetConstValue        = kExpr_SetConstValue;
	mod->kExpr_SetUnboxConstValue   = kExpr_SetUnboxConstValue;
	mod->kExpr_SetVariable          = kExpr_SetVariable;
	mod->kStmt_TypeCheckExprAt        = kStmt_TypeCheckExprAt;
	mod->kStmt_TypeCheckByName        = kStmt_TypeCheckByName;
	mod->kBlock_TypeCheckAll          = kBlock_TypeCheckAll;
	mod->kStmtkExpr_TypeCheckCallParam = kStmtkExpr_TypeCheckCallParam;
	mod->new_TypedCallExpr          = new_TypedCallExpr;
	mod->kGamma_AddLocalVariable = kGamma_AddLocalVariable;
	mod->kStmt_DeclType             = kStmt_DeclType;
	mod->kStmt_TypeCheckVariableNULL  = kStmt_TypeCheckVariableNULL;

	mod->kNameSpace_DefineSyntax    = kNameSpace_DefineSyntax;
	mod->kNameSpace_GetSyntax       = kNameSpace_GetSyntax;
	mod->kArray_AddSyntaxRule       = kArray_AddSyntaxPattern;
//	mod->kNameSpace_SetSugarFunc    = kNameSpace_SetSugarFunc;
	mod->kNameSpace_AddSugarFunc    = kNameSpace_AddSugarFunc;
	mod->new_kBlock                 = new_kBlock;
	mod->new_kStmt                  = new_kStmt;
	mod->kBlock_InsertAfter         = kBlock_InsertAfter;
	mod->new_UntypedTermExpr        = new_UntypedTermExpr;
	mod->new_UntypedCallStyleExpr   = new_UntypedCallStyleExpr;
	mod->kStmt_ParseOperatorExpr    = kStmt_ParseOperatorExpr;
	mod->kStmt_ParseExpr            = kStmt_ParseExpr;
	mod->kStmt_AddExprParam         = kStmt_AddExprParam;
	mod->kStmt_RightJoinExpr        = kStmt_RightJoinExpr;
	mod->kToken_ToError        = kToken_ToError;
	mod->kStmt_Message2        = kStmt_Message2;

	mod->VisitStmt                  = VisitStmt;
	mod->VisitExpr                  = VisitExpr;
	mod->VisitBlock                 = VisitBlock;

#ifndef USE_SMALLBUILD
	mod->dumpToken      = dumpToken;
	mod->dumpTokenArray = dumpTokenArray;
	mod->dumpExpr       = dumpExpr;
#endif

	DefineDefaultSyntax(kctx, KNULL(NameSpace));
}
Esempio n. 2
0
void MODSUGAR_Init(KonohaContext *kctx, KonohaContextVar *ctx)
{
	KParserModel *mod = (KParserModel *)KCalloc_UNTRACE(sizeof(KParserModel), 1);
	mod->h.name     = "sugar";
	mod->h.allocSize = sizeof(KParserModel);
	mod->h.setupModelContext    = SugarModule_Setup;
	KLIB KRuntime_SetModule(kctx, ParserModelIndex, (KRuntimeModel *)mod, 0);

	KonohaLibVar *l = (KonohaLibVar *)ctx->klib;
	l->kNameSpace_GetClassByFullName  = kNameSpace_GetClassByFullName;
	l->kNameSpace_DefineClass    = kNameSpace_DefineClass;
	l->kNameSpace_LoadMethodData = kNameSpace_LoadMethodData;
	l->kNameSpace_SetConstData   = kNameSpace_SetConstData;
	l->kNameSpace_LoadConstData  = kNameSpace_LoadConstData;
	l->kNameSpace_GetGetterMethodNULL  = kNameSpace_GetGetterMethodNULL;
	l->kNameSpace_GetSetterMethodNULL  = kNameSpace_GetSetterMethodNULL;
	l->kNameSpace_GetCoercionMethodNULL = kNameSpace_GetCoercionMethodNULL;
	l->kNameSpace_GetMethodByParamSizeNULL  = kNameSpace_GetMethodByParamSizeNULL;
	l->kNameSpace_GetMethodBySignatureNULL  = kNameSpace_GetMethodBySignatureNULL;
	l->kMethod_DoLazyCompilation = kMethod_DoLazyCompilation;
	l->kNameSpace_FreeSugarExtension =  kNameSpace_FreeSugarExtension;
	l->Konoha_LoadScript = Konoha_LoadScript;
	l->Konoha_Eval       = Konoha_Eval;
	l->kMethod_GenCode   = kMethod_GenCode;
	l->kMethod_SetFunc   = kMethod_SetFunc;

	KDEFINE_CLASS defSymbol = {0};
	defSymbol.structname = "Symbol";
	defSymbol.typeId = KTypeAttr_NewId;
	defSymbol.cflag = KClassFlag_int;
	defSymbol.init = KClass_(KType_Int)->init;
	defSymbol.unbox = KClass_(KType_Int)->unbox;
	defSymbol.format = kSymbol_format;

	KDEFINE_CLASS defSyntax = {0};
	SETSTRUCTNAME(defSyntax, Syntax);
	defSyntax.init = kSyntax_Init;
	//defSyntax.format = kSyntax_format;

	KDEFINE_CLASS defToken = {0};
	SETSTRUCTNAME(defToken, Token);
	defToken.init = kToken_Init;
	defToken.reftrace = kToken_Reftrace;
	defToken.format = kToken_format;

	KDEFINE_CLASS defNode = {0};
	SETSTRUCTNAME(defNode, Node);
	defNode.init = kUntypedNode_Init;
	defNode.reftrace = kUntypedNode_Reftrace;
	defNode.format        = kUntypedNode_format;

	InitNodeClass(kctx, mod);

	mod->cSymbol =    KLIB KClass_define(kctx, PackageId_sugar, NULL, &defSymbol, 0);
	mod->cSyntax =    KLIB KClass_define(kctx, PackageId_sugar, NULL, &defSyntax, 0);
	mod->cToken =     KLIB KClass_define(kctx, PackageId_sugar, NULL, &defToken, 0);
	mod->cNode  =     KLIB KClass_define(kctx, PackageId_sugar, NULL, &defNode, 0);
	mod->cTokenArray = KClass_p0(kctx, KClass_Array, mod->cToken->typeId);

	KLIB Knull(kctx, mod->cToken);
	KLIB Knull(kctx, mod->cNode);
	SugarModule_Setup(kctx, &mod->h, 0);

	KDEFINE_INT_CONST ClassData[] = {   // konoha defined class
		{"void", VirtualType_KClass,    (uintptr_t)KClass_void},
		{"boolean", VirtualType_KClass, (uintptr_t)KClass_Boolean},
		{"int",    VirtualType_KClass,  (uintptr_t)KClass_Int},
		{"String", VirtualType_KClass,  (uintptr_t)KClass_String},
		{"Func",   VirtualType_KClass,  (uintptr_t)KClass_Func},
		{"System", VirtualType_KClass,  (uintptr_t)KClass_System},
		{NULL},
	};
	kNameSpace_LoadConstData(kctx, KNULL(NameSpace), KConst_(ClassData), 0);

	l->Tokenize              = Tokenize;
	l->ApplyMacroData        = ApplyMacroData;
	l->SetMacroData          = SetMacroData;
	l->Preprocess            = Preprocess;
	l->EvalTokenList         = EvalTokenList;
	l->ParseTypePattern      = ParseTypePattern;
	l->kToken_ToBraceGroup   = kToken_ToBraceGroup;
	l->kUntypedNode_AddParsedObject = kUntypedNode_AddParsedObject;
	l->FindEndOfStatement    = FindEndOfStatement;
	l->kUntypedNode_ParseFlag       = kUntypedNode_ParseFlag;
	l->kUntypedNode_GetToken        = kUntypedNode_GetToken;
	l->kUntypedNode_GetNode         = kUntypedNode_GetNode;
	l->kUntypedNode_SetConst        = kUntypedNode_SetConst;
	l->kUntypedNode_SetUnboxConst   = kUntypedNode_SetUnboxConst;
	l->kUntypedNode_SetVariable     = kUntypedNode_SetVariable;
	l->TypeCheckNodeAt       = TypeCheckNodeAt;
	l->TypeCheckNodeByName   = TypeCheckNodeByName;
	l->TypeCheckMethodParam  = TypeCheckMethodParam;
	l->new_MethodNode        = new_MethodNode;
	l->AddLocalVariable      = AddLocalVariable;
	l->kUntypedNode_DeclType        = kUntypedNode_DeclType;
	l->TypeVariableNULL      = TypeVariableNULL;

	l->kNameSpace_DefineSyntax = kNameSpace_DefineSyntax;
	l->kNameSpace_GetSyntax    = kNameSpace_GetSyntax;
	l->kSyntax_AddPattern      = kSyntax_AddPattern;
	l->kNameSpace_AddSyntax    = kNameSpace_AddSyntax;
	l->kNameSpace_UseDefaultVirtualMachine = kNameSpace_UseDefaultVirtualMachine;
	l->kUntypedNode_InsertAfter       = kUntypedNode_InsertAfter;
	l->kUntypedNode_AddNode           = kUntypedNode_AddNode;
	l->kUntypedNode_Op                = kUntypedNode_Op;
	l->ParseSyntaxNode         = ParseSyntaxNode;
	l->ParseNode               = ParseNode;
	l->ParseNewNode            = ParseNewNode;
	l->AppendParsedNode        = AppendParsedNode;
	l->kToken_ToError          = kToken_ToError;
	l->MessageNode             = MessageNode;
	l->VisitNode               = VisitNode;

#ifndef USE_SMALLBUILD
	l->dumpToken      = dumpToken;
	l->dumpTokenArray = dumpTokenArray;
#endif

	DefineDefaultSyntax(kctx, KNULL(NameSpace));
}