static inline bool isUnaryOp(TokenKind token) {
    return (token == tSUB) || (token == tNOT);
}

static inline bool isBinaryOp(TokenKind token) {
    return (token >= tADD && token <= tMOD) ||
           (token == tRANGE) ||
           (token >= tEQ && token <= tLE) ||
           (token == tAND  || token == tOR ||
            token == tAAND || token == tAOR || token == tAXOR);
}

AstNode* Parser::parseUnary() {
    if (isUnaryOp(currentToken())) {
        TokenKind op = currentToken();
        consumeToken();
        return new UnaryOpNode(_currentTokenIndex, op, parseUnary());
    } else if (currentToken() == tIDENT && lookaheadToken(1) == tLPAREN) {
        AstNode* expr = parseCall();
        return expr;
    } else if (currentToken() == tIDENT) {
        AstVar* var = _currentScope->lookupVariable(currentTokenValue());
        if (var == 0) {
            error("undeclared atom: %s", currentTokenValue().c_str());
        }
        LoadNode* result = new LoadNode(_currentTokenIndex, var);
        consumeToken();
        return result;
    } else if (currentToken() == tDOUBLE) {
        DoubleLiteralNode* result =
            new DoubleLiteralNode(_currentTokenIndex,
                                  parseDouble(currentTokenValue()));
        consumeToken();
        return result;
    } else if (currentToken() == tINT) {
        IntLiteralNode* result =
            new IntLiteralNode(_currentTokenIndex,
                               parseInt(currentTokenValue()));
        consumeToken();
        return result;
    } else if (currentToken() == tSTRING) {
        StringLiteralNode* result =
            new StringLiteralNode(_currentTokenIndex,
                                  currentTokenValue());
        consumeToken();
        return result;
    } else if (currentToken() == tLPAREN) {
        consumeToken();
        AstNode* expr = parseExpression();
        ensureToken(tRPAREN);
        return expr;
    } else {
        error("Unexpected token: %s", tokenStr(currentToken()));
        return 0;
    }
}

AstNode* Parser::parseBinary(int minPrecedence) {
    AstNode* left = parseUnary();
    int precedence = tokenPrecedence(currentToken());

    while (precedence >= minPrecedence) {
        while (tokenPrecedence(currentToken()) == precedence) {
            TokenKind op = currentToken();
            uint32_t op_pos = _currentTokenIndex;
            consumeToken();
            AstNode* right = parseBinary(precedence + 1);
            left = new BinaryOpNode(op_pos, op, left, right);
        }
        precedence--;
    }
    return left;
}