static kbool_t subtype_defineSyntax(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ SYM_("<:"), 0, NULL, Precedence_CStyleMUL, 0, NULL, NULL, NULL, NULL, TypeCheck_InstanceOf, },
{ SYM_("as"), 0, NULL, Precedence_CStyleMUL, 0, NULL, NULL, NULL, NULL, TypeCheck_as},
{ SYM_("to"), 0, NULL, Precedence_CStyleMUL, 0, NULL, NULL, NULL, NULL, TypeCheck_to},
{ KW_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t class_defineSyntax(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("$ClassName"), SYNFLAG_CFunc, 0, 0, {SUGARFUNC PatternMatch_ClassName}, {NULL}},
{ KSymbol_("class"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_class}},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("class")), "\"class\" $ClassName [\"extends\" extends: $Type] [$Block]", 0, trace);
return true;
}
static kbool_t subtype_defineSyntax(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("instanceof"), SYNFLAG_CTypeFunc, Precedence_CStyleMUL, 0, {SUGAR opParseFunc}, {SUGARFUNC TypeCheck_InstanceOf}},
{ KSymbol_("as"), SYNFLAG_CTypeFunc, Precedence_CStyleMUL, 0, {SUGAR opParseFunc}, {SUGARFUNC TypeCheck_as}},
{ KSymbol_("to"), SYNFLAG_CTypeFunc, Precedence_CStyleMUL, 0, {SUGAR opParseFunc}, {SUGARFUNC TypeCheck_to}},
{ KSymbol_END, },
};
KLIB kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t StringInterpolation_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
#define PATTERN(X) KSymbol_##X##Pattern
kSyntax *textSyntax = kSyntax_(KNULL(NameSpace), PATTERN(Text));
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_TextPattern, SYNFLAG_CParseFunc, 0, 0, {SUGARFUNC Expression_ExtendedTextLiteral}, {textSyntax->TypeFuncNULL}, },
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t float_defineSyntax(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
/* Use Syntax.Number package's Parser to parsing FloatLiteral */
KImportPackage(ns, "Syntax.Number", trace);
kSyntax *numberSyntax = kSyntax_(ns, KSymbol_NumberPattern);
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("$Float"), SYNFLAG_CTypeFunc, 0, 0, {numberSyntax->ParseFuncNULL}, {SUGARFUNC TypeCheck_Float}, KonohaChar_Digit, {numberSyntax->TokenFuncNULL}},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t untyped_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequirePackage("Type.StaticVar", trace);
kSyntax *assignSyntax = kSyntax_(KNULL(NameSpace), KSymbol_LET);
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("="), SYNFLAG_NodeLeftJoinOp2, assignSyntax->precedence_op2, assignSyntax->precedence_op1,
{assignSyntax->ParseFuncNULL}, {KSugarFunc(ns, TypeCheck_UntypedAssign)}},
{ KSymbol_END, }, /* sentinental */
};
KLIB kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t RENAMEME_InitNameSpace(KonohaContext *kctx, kNameSpace *packageNS, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_INT_CONST IntData[] = {
#define DEFINE_KEYWORD(KW) {#KW, TY_int, KW}
DEFINE_KEYWORD(KW_ExprPattern),
DEFINE_KEYWORD(KW_SymbolPattern),
DEFINE_KEYWORD(KW_TextPattern),
DEFINE_KEYWORD(KW_NumberPattern),
DEFINE_KEYWORD(KW_TypePattern),
DEFINE_KEYWORD(KW_ParenthesisGroup),
DEFINE_KEYWORD(KW_BracketGroup),
DEFINE_KEYWORD(KW_BraceGroup),
DEFINE_KEYWORD(KW_BlockPattern),
DEFINE_KEYWORD(KW_ParamPattern),
DEFINE_KEYWORD(KW_TokenPattern),
DEFINE_KEYWORD(TSTMT_UNDEFINED),
DEFINE_KEYWORD(TSTMT_ERR),
DEFINE_KEYWORD(TSTMT_EXPR),
DEFINE_KEYWORD(TSTMT_BLOCK),
DEFINE_KEYWORD(TSTMT_RETURN),
DEFINE_KEYWORD(TSTMT_IF),
DEFINE_KEYWORD(TSTMT_LOOP),
DEFINE_KEYWORD(TSTMT_JUMP),
DEFINE_KEYWORD(TEXPR_CONST),
DEFINE_KEYWORD(TEXPR_NEW),
DEFINE_KEYWORD(TEXPR_NULL),
DEFINE_KEYWORD(TEXPR_NCONST),
DEFINE_KEYWORD(TEXPR_LOCAL),
DEFINE_KEYWORD(TEXPR_BLOCK),
DEFINE_KEYWORD(TEXPR_FIELD),
// DEFINE_KEYWORD(TEXPR_BOX),
// DEFINE_KEYWORD(TEXPR_UNBOX),
DEFINE_KEYWORD(TEXPR_CALL),
DEFINE_KEYWORD(TEXPR_AND),
DEFINE_KEYWORD(TEXPR_OR),
DEFINE_KEYWORD(TEXPR_LET),
DEFINE_KEYWORD(TEXPR_STACKTOP),
DEFINE_KEYWORD(TypeCheckPolicy_NOCHECK),
DEFINE_KEYWORD(TypeCheckPolicy_ALLOWVOID),
DEFINE_KEYWORD(TypeCheckPolicy_COERCION),
DEFINE_KEYWORD(TypeCheckPolicy_CONST),
#undef DEFINE_KEYWORD
{NULL},
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(IntData), trace);
KDEFINE_SYNTAX SYNTAX[] = {
{ SYM_("syntax"), 0, "\"syntax\" $Token*", 0, 0, NULL, NULL, Statement_syntax, NULL, NULL, },
{ KW_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t namespace_defineSyntax(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("namespace"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_namespace}},
{ KSymbol_("const"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_ConstDecl}},
{ KSymbol_("defined"), SYNFLAG_CFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_Defined}, {SUGARFUNC TypeCheck_Defined},},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("namespace")), "\"namespace\" $Expr", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("const")), "\"const\" $Symbol = $Expr", 0, trace);
return true;
}
static kbool_t cstyle_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
kFunc *nullTypeFunc = KSugarFunc(ns, TypeCheck_null);
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("null"), 0, 0, 0, {SUGAR termParseFunc}, {nullTypeFunc}, },
{ KSymbol_("NULL"), 0, 0, 0, {SUGAR termParseFunc}, {nullTypeFunc}, },
{ KSymbol_("=="), 0, Precedence_CStyleEquals, 0, {KSugarFunc(ns, Expression_isNull)}, {SUGAR methodTypeFunc}},
{ KSymbol_("!="), 0, Precedence_CStyleEquals, 0, {KSugarFunc(ns, Expression_isNotNull)}, {SUGAR methodTypeFunc}},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
/* ------------------------------------------------------------------------ */
static kbool_t Lisp_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KImportPackage(ns, "Syntax.CStyleBitwiseOperator", trace);
KDEFINE_SYNTAX SYNTAX[] = {
#define TOKEN(T) KSymbol_##T
{ TOKEN(ADD), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(SUB), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(MUL), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(DIV), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ TOKEN(MOD), SYNFLAG_CParseFunc,0, Precedence_CStylePrefixOperator, {SUGARFUNC Expression_LispOperator}, {SUGAR methodTypeFunc},},
{ KSymbol_END, }, /* sentinental */
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
return true;
}
static kbool_t cstyle_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("break"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_break}},
{ KSymbol_("continue"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_continue}},
{ KSymbol_("while"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_while} },
{ KSymbol_("do"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_do} },
{ KSymbol_END, }, /* sentinental */
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("while")), "\"while\" \"(\" $Expr \")\" $Block", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("do")), "\"do\" $Block \"while\" \"(\" $Expr \")\"", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("break")), "\"break\"", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("continue")), "\"continue\"", 0, trace);
return true;
}
// --------------------------------------------------------------------------
static kbool_t ClosureModel_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("function"), SYNFLAG_CTypeFunc, 0, Precedence_CStyleAssign, {SUGAR patternParseFunc}, {SUGARFUNC TypeCheck_Closure}},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("function")), "\"function\" $Param [$Type] $Block", 0, NULL);
KDEFINE_METHOD MethodData[] = {
_Public|_Hidden, _F(Func_Create), KType_Func, KType_Func, KMethodName_("_Create"), 2, KType_Object, KFieldName_("env"), KType_Method, KFieldName_("mtd"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t cstyle_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("$ForStmt"), SYNFLAG_CParseFunc, 0, 0, {SUGARFUNC PatternMatch_ForStmt}, },
{ KSymbol_("for"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_CStyleFor} },
/* copied from CStyleWhile */
{ KSymbol_("break"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_break}},
{ KSymbol_("continue"), SYNFLAG_CTypeFunc, 0, Precedence_Statement, {SUGAR patternParseFunc}, {SUGARFUNC Statement_continue}},
{ KSymbol_END, }, /* sentinental */
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("for")), "\"for\" \"(\" $ForStmt \")\" $Block", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("break")), "\"break\"", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("continue")), "\"continue\"", 0, trace);
return true;
}
static kbool_t Exception_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public, _F(Exception_new), KType_Exception, KType_Exception, KMethodName_("new"), 0, _Public|_Hidden, _F(System_throw), KType_void, KType_System, KMethodName_("throw"), 1, KType_Exception, KFieldName_("e"),
_Public|_Hidden, _F(System_getThrownException), KType_Exception, KType_System, KMethodName_("getThrownException"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
KDEFINE_SYNTAX SYNTAX[] = {
{ KSymbol_("try"), SYNFLAG_CTypeFunc, 0, 0, {SUGAR patternParseFunc}, {SUGARFUNC Statement_try}},
{ KSymbol_("catch"), SYNFLAG_CTypeFunc, 0, 0, {SUGAR patternParseFunc}, {SUGARFUNC Statement_catch}},
{ KSymbol_("finally"), SYNFLAG_CTypeFunc, 0, 0, {SUGAR patternParseFunc}, {SUGARFUNC Statement_finally}},
{ KSymbol_END, },
};
SUGAR kNameSpace_DefineSyntax(kctx, ns, SYNTAX, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("try")), "\"try\" $Node [ \"catch\" \"(\" $Type $Symbol \")\" catch: $Node ] [ \"finally\" finally: $Node ]", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("catch")), "\"catch\" \"(\" $Type $Symbol \")\" $Node", 0, trace);
SUGAR kSyntax_AddPattern(kctx, kSyntax_(ns, KSymbol_("finally")), "\"finally\" $Node", 0, trace);
return true;
}