public SUGAR_P ( ReportLevel pe, |
||
pe | ReportLevel | |
line | ||
lpos | int | |
format | string | |
return | uint |
// static kbool_t Stmt_parseSyntaxRule(CTX, kStmt *stmt, kArray *tls, int s, int e) public bool parseSyntaxRule(Context ctx, IList<Token> tls, int s, int e) { bool ret = false; Syntax syn = this.ks.GetSyntaxRule(tls, s, e); //Debug.Assert(syn != null); if (syn != null && syn.SyntaxRule != null) { this.syn = syn; ret = (matchSyntaxRule(ctx, syn.SyntaxRule, this.ULine, tls, s, e, false) != -1); } else { ctx.SUGAR_P(ReportLevel.ERR, this.ULine, 0, "undefined syntax rule for '{0}'", syn.KeyWord.ToString()); } return ret; }
// static kExpr* Stmt_newExpr2(CTX, kStmt *stmt, kArray *tls, int s, int e) public KonohaExpr newExpr2(Context ctx, IList<Token> tls, int s, int e) { if(s < e) { Syntax syn = null; int idx = findBinaryOp(ctx, tls, s, e, ref syn); if(idx != -1) { Console.WriteLine("** Found BinaryOp: s={0}, idx={1}, e={2}, '{3}' **", s, idx, e, tls[idx].Text); return ParseExpr(ctx, syn, tls, s, idx, e); } int c = s; syn = ks.GetSyntax(tls[c].Keyword); Debug.Assert(syn != null); return ParseExpr(ctx, syn, tls, c, c, e); } else { if (0 < s - 1) { ctx.SUGAR_P(ReportLevel.ERR, ULine, -1, "expected expression after {0}", tls[s-1].Text); } else if(e < tls.Count) { ctx.SUGAR_P(ReportLevel.ERR, ULine, -1, "expected expression before {0}", tls[e].Text); } else { ctx.SUGAR_P(ReportLevel.ERR, ULine, 0, "expected expression"); } return null; } }
// static int matchSyntaxRule(CTX, kStmt *stmt, kArray *rules, kline_t /*parent*/uline, kArray *tls, int s, int e, int optional) public int matchSyntaxRule(Context ctx, IList<Token> rules, LineInfo /*parent*/uline, IList<Token> tls, int s, int e, bool optional) { int ri, ti, rule_size = rules.Count; ti = s; for (ri = 0; ri < rule_size && ti < e; ri++) { Token rule = rules[ri]; Token tk = tls[ti]; uline = tk.ULine; Console.WriteLine("matching rule={0},{1},{2} token={3},{4},{5}", ri, rule.Type, rule.Keyword, ti - s, tk.Type, tk.Text); if (rule.Type == TokenType.CODE) { if (rule.Keyword != tk.Keyword) { if (optional) { return s; } tk.Print(ctx, ReportLevel.ERR, "{0} needs '{1}'", this.syn.KeyWord, rule.Keyword); return -1; } ti++; continue; } else if (rule.Type == TokenType.METANAME) { Syntax syn = this.ks.GetSyntax(rule.Keyword); if (syn == null || syn.ParseStmt == null) { tk.Print(ctx, ReportLevel.ERR, "unknown syntax pattern: {0}", rule.Keyword); return -1; } int c = e; if (ri + 1 < rule_size && rules[ri + 1].Type == TokenType.CODE) { c = lookAheadKeyword(tls, ti + 1, e, rules[ri + 1]); if (c == -1) { if (optional) { return s; } tk.Print(ctx, ReportLevel.ERR, "{0} needs '{1}'", this.syn.KeyWord, rule.Keyword); return -1; } ri++; } int err_count = ctx.ctxsugar.err_count; int next = ParseStmt(ctx, syn, rule.nameid, tls, ti, c); Console.WriteLine("matched '{0}' nameid='{1}', next={2}=>{3}", rule.Keyword, rule.nameid.Name, ti, next); if (next == -1) { if (optional) { return s; } if (err_count == ctx.sugarerr_count) { tk.Print(ctx, ReportLevel.ERR, "unknown syntax pattern: {0}", this.syn.KeyWord, rule.Keyword, tk.Text); } return -1; } ////XXX Why??? //optional = 0; ti = (c == e) ? next : c + 1; continue; } else if (rule.Type == TokenType.AST_OPTIONAL) { int next = matchSyntaxRule(ctx, rule.Sub, uline, tls, ti, e, true); if (next == -1) { return -1; } ti = next; continue; } else if (rule.Type == TokenType.AST_PARENTHESIS || rule.Type == TokenType.AST_BRACE || rule.Type == TokenType.AST_BRANCET) { if (tk.Type == rule.Type && rule.TopChar == tk.TopChar) { int next = matchSyntaxRule(ctx, rule.Sub, uline, tk.Sub, 0, tk.Sub.Count, false); if (next == -1) { return -1; } ti++; } else { if (optional) { return s; } tk.Print(ctx, ReportLevel.ERR, "{0} needs '{1}'", this.syn.KeyWord, rule.TopChar); return -1; } } } if (!optional) { for (; ri < rules.Count; ri++) { Token rule = rules[ri]; if (rule.Type != TokenType.AST_OPTIONAL) { ctx.SUGAR_P(ReportLevel.ERR, uline, -1, "{0} needs syntax pattern: {1}", this.syn.KeyWord, rule.Keyword); return -1; } } //WARN_Ignored(_ctx, tls, ti, e); } return ti; }
// 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; }
internal Token ResolveType(Context ctx, Token tkP) { int i; // 型引数の取得 int size = tkP.Sub.Count; var p = new List<KonohaParam>(); for (i = 0; i < size; i++) { Token tkT = (tkP.Sub[i]); if (tkT.Keyword == KeywordType.Type) { p.Add(new KonohaParam() { Type = tkT.Type }); } } throw new NotImplementedException(); // 以下未実装 KonohaClass ct; if (p.Count > 0) { ct = null;// this.ctx.share.ca.cts[(int)this.Type]; if (ct.cparam == KonohaParam.NULL) { ctx.SUGAR_P(ReportLevel.ERR, this.ULine, 0, "not generic type: %s", this.KType.ToString()); return this; } //ct = kClassTable_Generics(ct, TY_void, p.Count, p); } else { //ct = CT_P0(_ctx, CT_Array, this_type(this)); } this.Type = (TokenType)ct.cid; return this; }
public void Print(Context ctx, ReportLevel pe, string fmt, params object[] ap) { ctx.SUGAR_P(pe, this.ULine, 0, fmt, ap); }