Exemplo n.º 1
0
        int GetUpvalueIndex(Scope baseScope, string name)
        {
            Scope   s  = baseScope.Outter;
            FuncLit fl = Scope2FuncLitNode(s, Parent);

            for (int i = 0; i < fl.UpValues.Count; i++)
            {
                if (fl.UpValues[i].Name == name)
                {
                    return(i);
                }
            }

            return(-1);
        }
Exemplo n.º 2
0
        Expr ParseOperand(bool lhs)
        {
            var defPos = CurrTokenPos;

            switch (CurrTokenType)
            {
            case TokenType.Identifier:     // a = b
            {
                var x = ParseIdent();

                ScopeMgr.Resolve(x);

                return(x);
            }

            case TokenType.Base:     // a= base.foo()
            {
                Next();

                return(new BaseLit(defPos));
            }

            case TokenType.Number:
            case TokenType.QuotedString:
            {
                var x = new BasicLit(_token.Value, CurrTokenType, CurrTokenPos);
                Next();
                return(x);
            }

            case TokenType.LParen:     // () 括号表达式
            {
                Next();

                var x = ParseExpr(false);

                var rparenPos = CurrTokenPos;
                Expect(TokenType.RParen);

                return(new ParenExpr(x, defPos, rparenPos));
            }

            case TokenType.LBracket:     // a = [] 数组初始化
            {
                Next();

                List <Expr> values = new List <Expr>();

                while (CurrTokenType != TokenType.RBracket &&
                       CurrTokenType != TokenType.EOF)
                {
                    values.Add(ParseOperand(false));


                    if (CurrTokenType == TokenType.RBracket ||
                        CurrTokenType == TokenType.EOF)
                    {
                        break;
                    }

                    Expect(TokenType.Comma);
                }


                var rPos = CurrTokenPos;
                Expect(TokenType.RBracket);

                return(new ArrayExpr(values, defPos, rPos));
            }

            case TokenType.LBrace:     // a = {} Map初始化
            {
                Next();

                Dictionary <BasicLit, Expr> mapValues = new Dictionary <BasicLit, Expr>();

                while (CurrTokenType != TokenType.RBrace &&
                       CurrTokenType != TokenType.EOF)
                {
                    var key = ParseBasicLit();

                    Expect(TokenType.Colon);

                    var value = ParseRHS();

                    mapValues.Add(key, value);

                    if (CurrTokenType == TokenType.RBrace ||
                        CurrTokenType == TokenType.EOF)
                    {
                        break;
                    }

                    Expect(TokenType.Comma);
                }


                var rPos = CurrTokenPos;
                Expect(TokenType.RBrace);

                return(new MapExpr(mapValues, defPos, rPos));
            }

            case TokenType.Func:     // a = func( ) {}
            {
                Next();

                var scope     = ScopeMgr.OpenScope(ScopeType.Closure, defPos);
                var paramlist = ParseParameters(scope, false);

                var body = ParseBody(scope);

                var funclit = new FuncLit(body, new FuncType(defPos, paramlist, scope));

                return(funclit);
            }
            }

            throw new CompileException("Unknown operand", CurrTokenPos);
        }