Example #1
0
        private Syntax.Expression ParseUnaryExpr()
        {
            Syntax.UnaryOperator node = null;

            switch (scan.Peek().type)
            {
                case Token.Type.OP_INC:
                case Token.Type.OP_DEC:
                case Token.Type.OP_BIT_AND:
                case Token.Type.OP_STAR:
                case Token.Type.OP_PLUS:
                case Token.Type.OP_SUB:
                case Token.Type.OP_TILDE:
                case Token.Type.OP_NOT:
                    node = new Syntax.UnaryOperator(scan.Read());
                    node.SetOperand(this.ParseUnaryExpr());
                    return node;

                case Token.Type.LPAREN:
                    Syntax.Expression res = null;
                    Token t = scan.Read();

                    if (IsType(scan.Peek()))
                    {
                        res = new Syntax.Cast(t);
                        Symbols.ParamVar var = ParseParameterDeclaration(); //this is hack
                        ((Syntax.Cast)res).SetTypeCast(var.GetType());
                        CheckToken(scan.Peek(), Token.Type.RPAREN, true);
                        ((Syntax.Cast)res).SetOperand(ParseUnaryExpr());
                        return res;
                    }

                    res = ParseExpression();
                    CheckToken(scan.Peek(), Token.Type.RPAREN, true);
                    return ParsePostfixExpr(res);

                case Token.Type.KW_SIZEOF:
                    node = new Syntax.UnaryOperator(scan.Read());

                    if (scan.Peek().type != Token.Type.LPAREN)
                    {
                        node.SetOperand(ParseUnaryExpr());
                        return node;
                    }

                    scan.Read();
                    if (IsType(scan.Peek()))
                    {
                        ((Syntax.UnaryOperator)node).SetOperand(new Syntax.Identifier(scan.Read()));
                    }
                    else
                    {
                        node.SetOperand(ParseExpression());
                    }

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

                default:
                    return ParsePostfixExpr();
            }
        }
Example #2
0
        private Syntax.Expression ParseUnaryExpr()
        {
            Syntax.UnaryOperator node = null;

            switch (scan.Peek().type)
            {
            case Token.Type.OP_INC:
            case Token.Type.OP_DEC:
            case Token.Type.OP_BIT_AND:
            case Token.Type.OP_STAR:
            case Token.Type.OP_PLUS:
            case Token.Type.OP_SUB:
            case Token.Type.OP_TILDE:
            case Token.Type.OP_NOT:
                node = new Syntax.UnaryOperator(scan.Read());
                node.SetOperand(this.ParseUnaryExpr());
                return(node);

            case Token.Type.LPAREN:
                Syntax.Expression res = null;
                Token             t   = scan.Read();

                if (IsType(scan.Peek()))
                {
                    res = new Syntax.Cast(t);
                    Symbols.ParamVar var = ParseParameterDeclaration();                             //this is hack
                    ((Syntax.Cast)res).SetTypeCast(var.GetType());
                    CheckToken(scan.Peek(), Token.Type.RPAREN, true);
                    ((Syntax.Cast)res).SetOperand(ParseUnaryExpr());
                    return(res);
                }

                res = ParseExpression();
                CheckToken(scan.Peek(), Token.Type.RPAREN, true);
                return(ParsePostfixExpr(res));

            case Token.Type.KW_SIZEOF:
                node = new Syntax.UnaryOperator(scan.Read());

                if (scan.Peek().type != Token.Type.LPAREN)
                {
                    node.SetOperand(ParseUnaryExpr());
                    return(node);
                }

                scan.Read();
                if (IsType(scan.Peek()))
                {
                    ((Syntax.UnaryOperator)node).SetOperand(new Syntax.Identifier(scan.Read()));
                }
                else
                {
                    node.SetOperand(ParseExpression());
                }

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

            default:
                return(ParsePostfixExpr());
            }
        }