Ejemplo n.º 1
0
 // 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);
 }
Ejemplo n.º 2
0
 private static void TopStmtTyCheck_ParamsDecl(KStatement stmt, Syntax syn, KGamma gma)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 3
0
 public static void ExprTyCheck_Expr(KStatement stmt, Syntax syn, KGamma gma)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 4
0
 // 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;
 }
Ejemplo n.º 5
0
 // 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;
 }
Ejemplo n.º 6
0
 // 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);
 }
Ejemplo n.º 7
0
 // 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;
     }
 }
Ejemplo n.º 8
0
 private static void ExprTyCheck_MethodCall(KStatement stmt, Syntax syn, KGamma gma)
 {
     throw new NotImplementedException();
 }
Ejemplo n.º 9
0
 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);
 }
Ejemplo n.º 10
0
 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;
 }
Ejemplo n.º 11
0
        //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;
        }
Ejemplo n.º 12
0
 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;
 }
Ejemplo n.º 13
0
 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;
 }
Ejemplo n.º 14
0
 // 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;
 }
Ejemplo n.º 15
0
 // 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);
 }
Ejemplo n.º 16
0
 // 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);
     }
 }
Ejemplo n.º 17
0
 //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;
 }
Ejemplo n.º 18
0
 // 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;
 }