// static kExpr *ParseExpr(CTX, ksyntax_t *syn, kStmt *stmt, kArray *tls, int s, int c, int e) public KonohaExpr ParseExpr(Context ctx, Syntax syn, IList<Token> tls, int s, int c, int e) { Debug.Assert(syn != null); if (syn.ParseExpr != null) { return syn.ParseExpr(ctx, syn, this, tls, s, c, e); } return KModSugar.UndefinedParseExpr(ctx, syn, this, tls, s, c, e); }
private static void TopStmtTyCheck_ParamsDecl(KStatement stmt, Syntax syn, KGamma gma) { throw new NotImplementedException(); }
public static void ExprTyCheck_Expr(KStatement stmt, Syntax syn, KGamma gma) { throw new NotImplementedException(); }
// static KMETHOD ParseStmt_Params(CTX, ksfp_t *sfp _RIX) private static int ParseStmt_Params(Context ctx, KStatement stmt, Syntax syn, Symbol name, IList<Token> tokens, int s, int e) { int r = -1; Token tk = tokens[s]; if (tk.Type == TokenType.AST_PARENTHESIS) { var tls = tk.Sub; int ss = 0; int ee = tls.Count; if (0 < ee && tls[0].Keyword == KeywordType.Void) ss = 1; // f(void) = > f() BlockExpr bk = new Parser(ctx, stmt.ks).CreateBlock(stmt, tls, ss, ee, ','); stmt.map.Add(name, bk); r = s + 1; } return r; }
// static KMETHOD ParseStmt_Toks(CTX, ksfp_t *sfp _RIX) private static int ParseStmt_Toks(Context ctx, KStatement stmt, Syntax syn, Symbol name, IList<Token> tls, int s, int e) { if (s < e) { var a = new List<Token>(); while (s < e) { a.Add(tls[s]); s++; } //kObject_setObject(stmt, name, a); //stmt.map.Add(name, a); throw new NotImplementedException(); return e; } return -1; }
// static KMETHOD ParseExpr_Term(CTX, ksfp_t *sfp _RIX) public static KonohaExpr ParseExpr_Term(Context ctx, Syntax syn, KStatement stmt, IList<Token> tls, int s, int c, int e) { Debug.Assert(s == c); Token tk = tls[c]; KonohaExpr expr = new TermExpr(); //new_W(Expr, SYN_(kStmt_ks(stmt), tk->kw)); //Expr_setTerm(expr, 1); expr.tk = tk; return Expr_rightJoin(ctx, expr, stmt, tls, s + 1, c + 1, e); }
// static KMETHOD ParseStmt_Block(CTX, ksfp_t *sfp _RIX) private static int ParseStmt_Block(Context ctx, KStatement stmt, Syntax syn, Symbol name, IList<Token> tls, int s, int e) { //Console.WriteLine("ParseStmt_Block name:" + name.Name); Token tk = tls[s]; if(tk.Type == TokenType.CODE) { stmt.map.Add(name, new CodeExpr(tk)); return s + 1; } var parser = new Parser(ctx, stmt.ks); if (tk.Type == TokenType.AST_BRACE) { BlockExpr bk = parser.CreateBlock(stmt, tk.Sub, 0, tk.Sub.Count, ';'); stmt.map.Add(name, bk); return s + 1; } else { BlockExpr bk = parser.CreateBlock(stmt, tls, s, e, ';'); stmt.map.Add(name, bk); return e; } }
private static void ExprTyCheck_MethodCall(KStatement stmt, Syntax syn, KGamma gma) { throw new NotImplementedException(); }
private static KonohaExpr ParseExpr_Dot(Context ctx, Syntax syn, KStatement stmt, IList<Token> tls, int s, int c, int e) { Console.WriteLine("s={0}, c={1}", s, c); Debug.Assert(s < c); if (isFieldName(tls, c, e)) { KonohaExpr expr = stmt.newExpr2(ctx, tls, s, c); expr = new ConsExpr(ctx, syn, tls[c + 1], expr); return KModSugar.Expr_rightJoin(ctx, expr, stmt, tls, c + 2, c + 2, e); } if (c + 1 < e) c++; return new ConsExpr(ctx, syn, tls[c], ReportLevel.ERR, "expected field name: not " + tls[c].Text); }
public static int ParseStmt_Usymbol(Context ctx, KStatement stmt, Syntax syn, Symbol name, IList<Token> tls, int s, int e) { int r = -1; Token tk = tls[s]; if (tk.Type == TokenType.USYMBOL) { stmt.map.Add(name, new SingleTokenExpr(tk)); r = s + 1; } return r; }
//KonohaSpace_syntax internal Syntax GetSyntax(KeywordType keyword, bool isnew) { Syntax syntaxParent = null; for (KonohaSpace ks = this; ks != null; ks = ks.parent) { if (ks.syntaxMap != null && ks.syntaxMap.ContainsKey(keyword)) { syntaxParent = ks.syntaxMap[keyword]; break; } } if (isnew == true) { Console.WriteLine("creating new syntax {0} old={1}", keyword.ToString(), syntaxParent); if (this.syntaxMap == null) { this.syntaxMap = new Dictionary<KeywordType, Syntax>(); } this.syntaxMap[keyword] = new Syntax(); if (syntaxParent != null) { // TODO: RCGC this.syntaxMap[keyword] = syntaxParent; } else { var syn = new Syntax() { KeyWord = keyword, Type = KonohaType.Unknown, Op1 = null, Op2 = null, ParseExpr = KModSugar.UndefinedParseExpr, TopStmtTyCheck = ctx.kmodsugar.UndefinedStmtTyCheck, StmtTyCheck = ctx.kmodsugar.UndefinedStmtTyCheck, ExprTyCheck = ctx.kmodsugar.UndefinedExprTyCheck, }; this.syntaxMap[keyword] = syn; } this.syntaxMap[keyword].Parent = syntaxParent; return this.syntaxMap[keyword]; } return syntaxParent; }
public static int ParseStmt_Type(Context ctx, KStatement stmt, Syntax syn, Symbol name, IList<Token> tls, int s, int e) { int r = -1; Token tk = tls[s]; if (tk.IsType) { //kObject_setObject(stmt, name, tk); stmt.map.Add(name, new SingleTokenExpr(tk)); r = s + 1; } return r; }
public static int ParseStmt_Expr(Context ctx, KStatement stmt, Syntax syn, Symbol name, IList<Token> tls, int s, int e) { int r = -1; var expr = stmt.newExpr2(ctx, tls, s, e); if (expr != null) { //dumpExpr(_ctx, 0, 0, expr); //kObject_setObject(stmt, name, expr); stmt.map.Add(name, expr); r = e; } return r; }
// ast.h // static KMETHOD UndefinedParseExpr(CTX, ksfp_t *sfp _RIX) public static KonohaExpr UndefinedParseExpr(Context ctx, Syntax syn, KStatement stmt, IList<Token> tls, int start, int c, int end) { Token tk = tls[c]; ctx.SUGAR_P(ReportLevel.ERR, tk.ULine, 0, "undefined expression parser for '{0}'", tk.Text); return null; }
// static int ParseStmt(CTX, ksyntax_t *syn, kStmt *stmt, ksymbol_t name, kArray *tls, int s, int e) public int ParseStmt(Context ctx, Syntax syn, Symbol name, IList<Token> tls, int s, int e) { //Console.WriteLine("ParseStmt {0}, {0}", name.Name, tls[s].Text); return syn.ParseStmt(ctx, this, syn, name, tls, s, e); }
// static KMETHOD ParseExpr_Parenthesis(CTX, ksfp_t *sfp _RIX) private static KonohaExpr ParseExpr_Parenthesis(Context ctx, Syntax syn, KStatement stmt, IList<Token> tls, int s, int c, int e) { Token tk = tls[c]; if(s == c) { KonohaExpr expr = stmt.newExpr2(ctx, tk.Sub, 0, tk.Sub.Count); return KModSugar.Expr_rightJoin(ctx, expr, stmt, tls, s + 1, c + 1, e); } else { KonohaExpr lexpr = stmt.newExpr2(ctx, tls, s, c); if(lexpr == null) { return null; } if (lexpr.syn == null) { lexpr.syn = stmt.ks.GetSyntax(lexpr.tk.Keyword); } if(lexpr.syn.KeyWord == KeywordType.DOT) { lexpr.syn = stmt.ks.GetSyntax(KeywordType.ExprMethodCall); // CALL } else if(lexpr.syn.KeyWord != KeywordType.ExprMethodCall) { Console.WriteLine("function calls .. "); syn = stmt.ks.GetSyntax(KeywordType.Parenthesis); // (f null ()) lexpr = new ConsExpr(ctx, syn, lexpr, null); } stmt.addExprParams(ctx, lexpr, tk.Sub, 0, tk.Sub.Count, true/*allowEmpty*/); return KModSugar.Expr_rightJoin(ctx, lexpr, stmt, tls, s + 1, c + 1, e); } }
//static int Stmt_findBinaryOp(CTX, kStmt *stmt, kArray *tls, int s, int e, ksyntax_t **synRef) int findBinaryOp(Context ctx, IList<Token> tls, int s, int e, ref Syntax synRef) { int idx = -1; int prif = 0; for(int i = skipUnaryOp(ctx, tls, s, e) + 1; i < e; i++) { Token tk = tls[i]; Syntax syn = ks.GetSyntax(tk.Keyword); // if(syn != NULL && syn->op2 != 0) { if(syn.priority > 0) { if (prif < syn.priority || (prif == syn.priority && syn.Flag != SynFlag.ExprLeftJoinOp2)) { prif = syn.priority; idx = i; synRef = syn; } if(syn.Flag != SynFlag.ExprPostfixOp2) { /* check if real binary operator to parse f() + 1 */ i = skipUnaryOp(ctx, tls, i+1, e) - 1; } } } return idx; }
// static KMETHOD ParseExpr_Op(CTX, ksfp_t *sfp _RIX) public static KonohaExpr ParseExpr_Op(Context ctx, Syntax syn, KStatement stmt, IList<Token> tls, int s, int c, int e) { Token tk = tls[c]; KonohaExpr expr = null; KonohaExpr rexpr = stmt.newExpr2(ctx, tls, c + 1, e); KMethod mn = (s == c) ? syn.Op1 : syn.Op2; if (mn != null && syn.ExprTyCheck == ctx.kmodsugar.UndefinedExprTyCheck) { //kToken_setmn(tk, mn, (s == c) ? MNTYPE_unary: MNTYPE_binary); syn = stmt.ks.GetSyntax(KeywordType.ExprMethodCall); // switch type checker } if (s == c) { // unary operator expr = new ConsExpr(ctx, syn, tk, rexpr); } else { // binary operator KonohaExpr lexpr = stmt.newExpr2(ctx, tls, s, c); expr = new ConsExpr(ctx, syn, tk, lexpr, rexpr); } return expr; }