C++ Expression::drop方法代码示例

expressions::Expression* Parser::parseExpression()
{
    Expression* lhs = parsePrimaryExpression();

    if(!lhs)
        return NULL;

    Expression* expr =  parseBinaryOperationRHS(0, lhs);

    if(lhs != expr)
        lhs->drop();

    return expr;
}

expressions::ArrayIndexExpression* Parser::parseArrayIndexExpression(expressions::Expression* array)
{
    array->grab();
    readNextToken(true); // Eat the '['.

    Expression* index = parseExpression(); // Parse the index.

    expect(TokenRightSquareBracket); // Expect a ']'.

    // Create the expression.
    ArrayIndexExpression* expr = new ArrayIndexExpression(array, index);

    // Drop temps.
    array->drop(); // We made a copy, drop our copy.
    index->drop();

    return expr;
}

expressions::Expression* Parser::parsePrimaryExpression()
{
    if(isEndOfStream())
        return NULL;

    if(m_currentToken == TokenMinusSign)
    {
        readNextToken(true); // Eat the '-'.

        Expression* expr = parseExpression();

        NegativeExpression* result = new NegativeExpression(expr);

        expr->drop();

        return result;
    }
    if(m_currentToken.getType() == Token::TokenType::NumericLiteral) // Check for a numeric literal.
    {
        return parseNumericLiteralExpression();
    }
    else if(m_currentToken.getType() == Token::TokenType::StringLiteral) // Check for a string literal.
    {
        return parseStringLiteralExpression();
    }
    else if(m_currentToken.getType() == Token::TokenType::Word) // Check for a word.
    {
        return parseWordExpression();
    }
    else if(Token::Compare(m_strCmp, m_currentToken, TokenLeftParenthesis)) // Check for a parentheses expression.
    {
        return parseParenthesesExpression();
    }
    else // Unexpected token.
    {
        onError("unexpected token");
        return nullptr;
    }

}

expressions::Expression* Parser::parseWordExpression()
{
    std::string first = m_currentToken.getValue();

    readNextToken(false); // Eat the identifier.

    if(m_currentToken == TokenPeriod)
    {
        readNextToken(true); // Eat the '.'.

        // Parse the name.
        while(1)
        {
            if((m_currentToken.getType() == Token::TokenType::Word))
                first += "." + m_currentToken.getValue();
            else
            {
                break;
            }

            readNextToken(true); // Eat the last part of the name.

            if(m_currentToken == TokenPeriod)
            {
                readNextToken(true);
                continue;
            }
            else if((m_currentToken == TokenLeftParenthesis))
                break;
        }
    }

    // It has a '(', it is a function call expression.
    if(m_currentToken == TokenLeftParenthesis)
    {
        std::vector<Expression*> args;

        parseFunctionCall(args); // Parse the argument list.

        // Create the function call expression.
        Expression* expr = new FunctionCallExpression(first, args);

        // Check if we're indexing an item from the return value.
        if(m_currentToken == TokenLeftSquareBracket)
        {
            ArrayIndexExpression* indexExpr = parseArrayIndexExpression(expr);

            expr->drop(); // Drop the old expression.

            expr = indexExpr; // The expression is now the new index expression.
        }

        // Drop the argument list.
        for(unsigned int i=0; i<args.size(); i++)
            args[i]->drop();

        return expr;
    }

    Expression* expr = new VariableExpression(first);

    while(m_currentToken == TokenLeftSquareBracket)
    {
        Expression* array = expr;

        expr = parseArrayIndexExpression(array);

        array->drop();
    }

    return expr;
}

expressions::Expression* Parser::parseBinaryOperationRHS(int expressionPrecedence, expressions::Expression* lhs)
{
    Expression* origLHS = lhs;

    while(1)
    {
        int tokPrec = getOperatorPrecedence(m_currentToken);

        if(tokPrec < expressionPrecedence)
            return lhs;

        Token op = m_currentToken;
        readNextToken(true);

        Expression* rhs = parsePrimaryExpression();

        if(!rhs) return nullptr;

        int nextPrec = getOperatorPrecedence(m_currentToken);

        if(tokPrec < nextPrec)
        {
            Expression* oldRHS = rhs;

            rhs = parseBinaryOperationRHS(tokPrec+1, rhs);

            oldRHS->drop();

            if(!rhs) return nullptr;
        }

        Expression* oldLHS = lhs;

        // Check the operator.
        if(op == TokenPlusSign)
        {
            lhs = new AdditionExpression(lhs, rhs); // Operator is addition.
        }
        else if(op == TokenMinusSign)
        {
            lhs = new SubtractionExpression(lhs, rhs); // Operator is subtraction.
        }
        else if(op == TokenMulSign)
        {
            lhs = new MultipicationExpression(lhs, rhs); // Operator is multipication.
        }
        else if(op == TokenDivSign)
        {
            lhs = new DivisionExpression(lhs, rhs); // Operator is division.
        }
        else if(op == TokenEquals)
        {
            lhs = new EqualExpression(lhs, rhs);    // Operator is equal comparison.
        }
        else if(op == TokenLessThan)
        {
            lhs = new LessThanExpression(lhs, rhs);  // Operator is less than.
        }
        else if(op == TokenGreaterThan)
        {
            lhs = new GreaterThanExpression(lhs, rhs); // Operator is greater than.
        }
        else if(op == TokenLessThanOrEqualTo)
        {
            lhs = new LessThanOrEqualToExpression(lhs, rhs); // Operator is less than or equal to.
        }
        else if(op == TokenGreaterThenOrEqualTo)
        {
            lhs = new GreaterThanOrEqualToExpression(lhs, rhs); // Operator is greater than or equal to.
        }
        else if(op == TokenNotEquals)
        {
            lhs = new NotEqualExpression(lhs, rhs);   // Operator is not equal.
        }
        else if(Token::Compare(m_strCmp, op, TokenAnd))
        {
            lhs = new AndExpression(lhs, rhs);
        }
        else if(Token::Compare(m_strCmp, op, TokenOr))
        {
            lhs = new OrExpression(lhs, rhs);
        }
        else
        {
            onError("undefined operator '" + op.getValue() + "'");
            return nullptr;
        }

        if(oldLHS !=origLHS)
            oldLHS->drop(); // TODO:

        rhs->drop();

    }
}

statements::Statement* Parser::parseIdentifierStatement()
{
    std::string first = m_currentToken.getValue();

    // Attempt to read a token.
    if(readNextToken(false))
    {
        if(m_currentToken == TokenColon) // The statement is a label.
        {
            readNextToken(true); // Eat the ':'.

            expectEOL(); // Expect a new line.

            return new LabelStatement(first);
        }


        if(m_currentToken == TokenPeriod)
        {
            readNextToken(true); // Eat the '.'.

            // Parse the name.
            while(1)
            {
                if((m_currentToken.getType() == Token::TokenType::Word))
                    first += "." + m_currentToken.getValue();
                else
                {
                    onError("expected identifier, '.', '=' or '('");
                    return nullptr;
                }

                readNextToken(true); // Eat the last part of the name.

                if(m_currentToken == TokenPeriod)
                {
                    readNextToken(true);
                    continue;
                }
                else if((m_currentToken == TokenLeftParenthesis) || (m_currentToken == TokenEquals))
                    break;
            }
        }

        // The statement is a function call statement.
        if(m_currentToken == TokenLeftParenthesis)
        {
            std::vector<Expression*> args; // The arguments to the function.

            parseFunctionCall(args); // Parse the function call.

            expectEOL(); // Expect an EOL.

            FunctionCallStatement* statement = new FunctionCallStatement(first, args);

            // Drop the argument list.
            for(unsigned int i=0; i<args.size(); i++)
                args[i]->drop();

            return statement;
        }

        Expression* lhs = new VariableExpression(first);

        while(m_currentToken == TokenLeftSquareBracket)
        {
            Expression* array = lhs;

            lhs = parseArrayIndexExpression(array);

            array->drop();
        }

        if(m_currentToken == TokenEquals) // The statement is in the form 'x = y'.
        {
            readNextToken(true); // Eat the '='.

            Expression* rhs = parseExpression();

            expectEOL();

            AssignmentStatement* statement = new AssignmentStatement(lhs, rhs);

            rhs->drop();

            return statement;
        }
    }


    onError("expected '(', '=' or ':'");

    return nullptr;
}