Example #1
0
        private Syntax.Expression ParsePostfixExpr(Syntax.Expression expr_node = null)
        {
            Syntax.Expression node = expr_node == null?this.ParsePrimaryExpr() : expr_node, res = null;

            while (true)
            {
                switch (scan.Peek().type)
                {
                case Token.Type.OP_INC:
                case Token.Type.OP_DEC:
                    res = new Syntax.UnaryOperator(scan.Read(), false);
                    ((Syntax.UnaryOperator)res).SetOperand(node);
                    break;

                case Token.Type.OP_DOT:
                case Token.Type.OP_REF:
                    res = new Syntax.Refference(scan.Read());
                    ((Syntax.Refference)res).SetExpression(node);
                    CheckToken(scan.Peek(), Token.Type.IDENTIFICATOR);
                    ((Syntax.Refference)res).SetRefference(new Syntax.Identifier(scan.Read()));
                    break;

                case Token.Type.LPAREN:
                    res = new Syntax.Call(scan.Read());
                    ((Syntax.Call)res).SetOperand(node);
                    try
                    {
                        if (scan.Peek().type == Token.Type.RPAREN)
                        {
                            ((Syntax.Call)res).SetArgumentList(new List <Syntax.Expression>());
                            scan.Read();
                            break;
                        }
                        ((Syntax.Call)res).SetArgumentList(this.ParseArgExpressionList());
                    }
                    catch (Symbols.Exception e)
                    {
                        this.logger.Add(e);
                    }

                    CheckToken(scan.Peek(), Token.Type.RPAREN, true);
                    break;

                case Token.Type.LBRACKET:
                    res = new Syntax.Refference(scan.Read());
                    ((Syntax.Refference)res).SetExpression(node);
                    ((Syntax.Refference)res).SetRefference(this.ParseExpression());
                    CheckToken(scan.Peek(), Token.Type.RBRACKET, true);
                    break;

                default:
                    return(res == null? node: res);
                }

                if (res != null)
                {
                    node = res;
                }
            }
        }
Example #2
0
        private Syntax.Expression ParsePostfixExpr(Syntax.Expression expr_node = null)
        {
            Syntax.Expression node = expr_node == null? this.ParsePrimaryExpr(): expr_node, res = null;

            while(true){
                switch (scan.Peek().type)
                {
                    case Token.Type.OP_INC:
                    case Token.Type.OP_DEC:
                        res = new Syntax.UnaryOperator(scan.Read(), false);
                        ((Syntax.UnaryOperator)res).SetOperand(node);
                        break;

                    case Token.Type.OP_DOT:
                    case Token.Type.OP_REF:
                        res = new Syntax.Refference(scan.Read());
                        ((Syntax.Refference)res).SetExpression(node);
                        CheckToken(scan.Peek(), Token.Type.IDENTIFICATOR);
                        ((Syntax.Refference)res).SetRefference(new Syntax.Identifier(scan.Read()));
                        break;

                    case Token.Type.LPAREN:
                        res = new Syntax.Call(scan.Read());
                        ((Syntax.Call)res).SetOperand(node);
                        try
                        {
                            if (scan.Peek().type == Token.Type.RPAREN)
                            {
                                ((Syntax.Call)res).SetArgumentList(new List<Syntax.Expression>());
                                scan.Read();
                                break;
                            }
                            ((Syntax.Call)res).SetArgumentList(this.ParseArgExpressionList());
                        }
                        catch (Symbols.Exception e)
                        {
                            this.logger.Add(e);
                        }

                        CheckToken(scan.Peek(), Token.Type.RPAREN, true);
                        break;

                    case Token.Type.LBRACKET:
                        res = new Syntax.Refference(scan.Read());
                        ((Syntax.Refference)res).SetExpression(node);
                        ((Syntax.Refference)res).SetRefference(this.ParseExpression());
                        CheckToken(scan.Peek(), Token.Type.RBRACKET, true);
                        break;

                    default:
                        return res == null? node: res;
                }

                if (res != null)
                {
                    node = res;
                }
            }
        }