예제 #1
0
        private Types.Object EvaluateLoopWhile(Node.LoopWhile node)
        {
            Types.List list = new Types.List();

            list.AppendElement(Evaluate(node.Loop));
            while (Evaluate(node.Test).True())
            {
                list.Concatenate(Evaluate(node.Loop));
            }
            return(list);
        }
예제 #2
0
            public static Node.Expression Parse()
            {
                Node.Expression n;

                if (IsLookahead(1, Tokens.Keyword, Lexemes.If))
                {
                    Match(Tokens.Keyword, Lexemes.If);
                    Node.Expression test = Parser.Expression.Parse();
                    Match(Tokens.Keyword, Lexemes.Then);
                    Node.Expression expIf = Parser.Expression.Parse();

                    if (IsLookahead(1, Tokens.Keyword, Lexemes.Else))
                    {
                        Match(Tokens.Keyword, Lexemes.Else);
                        Node.Expression expElse = Parser.Expression.Parse();

                        n = new Node.IfThenElse
                        {
                            Test = test,
                            If   = expIf,
                            Else = expElse
                        };
                    }
                    else
                    {
                        n = new Node.IfThen
                        {
                            Test = test,
                            If   = expIf
                        }
                    };
                }
                else if (IsLookahead(1, Tokens.Keyword, Lexemes.While))
                {
                    Match(Tokens.Keyword, Lexemes.While);
                    Node.Expression test = Parser.Expression.Parse();
                    Match(Tokens.Keyword, Lexemes.Loop);
                    Node.Expression exp = Parser.Expression.Parse();

                    n = new Node.WhileLoop
                    {
                        Test = test,
                        Loop = exp
                    };
                }
                else if (IsLookahead(1, Tokens.Keyword, Lexemes.Loop))
                {
                    Match(Tokens.Keyword, Lexemes.Loop);
                    Node.Expression exp = Parser.Expression.Parse();
                    Match(Tokens.Keyword, Lexemes.While);
                    Node.Expression test = Parser.Expression.Parse();

                    n = new Node.LoopWhile
                    {
                        Test = test,
                        Loop = exp
                    };
                }
                else if (IsLookahead(1, Tokens.Keyword, Lexemes.Do))
                {
                    Match(Tokens.Keyword, Lexemes.Do);

                    n = new Node.Do
                    {
                        E = Parser.Expression.Parse()
                    };
                }
                else if (IsLookahead(1, Tokens.Keyword, Lexemes.Async))
                {
                    Match(Tokens.Keyword, Lexemes.Async);

                    n = new Node.Async
                    {
                        E = Parser.Expression.Parse()
                    };
                }
                else if (IsLookahead(1, Tokens.Identifier) ||
                         IsLookahead(1, Tokens.Number) ||
                         IsLookahead(1, Tokens.Keyword, Lexemes.Function) ||
                         IsLookahead(1, Tokens.Operator, Lexemes.BrackOpen) ||
                         IsLookahead(1, Tokens.Operator, Lexemes.BraceOpen) ||
                         IsLookahead(1, Tokens.Keyword, Lexemes.Undefined))
                {
                    n = new Node.Structured
                    {
                        V = Parser.Value.Parse(),
                        C = Parser.Continuation.Parse()
                    };
                }
                else
                {
                    throw new Exceptions.Parser.UnexpectedLookahead("Parse(Expression)", Lexer.Lookahead(1), 1);
                }

                return(n);
            }