llvm/clang-tools-extra/clang-tidy/modernize/IntegralLiteralExpressionMatcher.cpp

//===--- IntegralLiteralExpressionMatcher.cpp - clang-tidy ----------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "IntegralLiteralExpressionMatcher.h"

#include <algorithm>
#include <cctype>

namespace clang::tidy::modernize {

// Validate that this literal token is a valid integer literal.  A literal token
// could be a floating-point token, which isn't acceptable as a value for an
// enumeration.  A floating-point token must either have a decimal point or an
// exponent ('E' or 'P').
static bool isIntegralConstant(const Token &Token) { … }

bool IntegralLiteralExpressionMatcher::advance() { … }

bool IntegralLiteralExpressionMatcher::consume(tok::TokenKind Kind) { … }

template <typename NonTerminalFunctor, typename IsKindFunctor>
bool IntegralLiteralExpressionMatcher::nonTerminalChainedExpr(
    const NonTerminalFunctor &NonTerminal, const IsKindFunctor &IsKind) { … }

template <tok::TokenKind Kind, typename NonTerminalFunctor>
bool IntegralLiteralExpressionMatcher::nonTerminalChainedExpr(
    const NonTerminalFunctor &NonTerminal) { … }

template <tok::TokenKind K1, tok::TokenKind K2, tok::TokenKind... Ks,
          typename NonTerminalFunctor>
bool IntegralLiteralExpressionMatcher::nonTerminalChainedExpr(
    const NonTerminalFunctor &NonTerminal) { … }

// Advance over unary operators.
bool IntegralLiteralExpressionMatcher::unaryOperator() { … }

static LiteralSize literalTokenSize(const Token &Tok) { … }

static bool operator<(LiteralSize LHS, LiteralSize RHS) { … }

bool IntegralLiteralExpressionMatcher::unaryExpr() { … }

bool IntegralLiteralExpressionMatcher::multiplicativeExpr() { … }

bool IntegralLiteralExpressionMatcher::additiveExpr() { … }

bool IntegralLiteralExpressionMatcher::shiftExpr() { … }

bool IntegralLiteralExpressionMatcher::compareExpr() { … }

bool IntegralLiteralExpressionMatcher::relationalExpr() { … }

bool IntegralLiteralExpressionMatcher::equalityExpr() { … }

bool IntegralLiteralExpressionMatcher::andExpr() { … }

bool IntegralLiteralExpressionMatcher::exclusiveOrExpr() { … }

bool IntegralLiteralExpressionMatcher::inclusiveOrExpr() { … }

bool IntegralLiteralExpressionMatcher::logicalAndExpr() { … }

bool IntegralLiteralExpressionMatcher::logicalOrExpr() { … }

bool IntegralLiteralExpressionMatcher::conditionalExpr() { … }

bool IntegralLiteralExpressionMatcher::commaExpr() { … }

bool IntegralLiteralExpressionMatcher::expr() { … }

bool IntegralLiteralExpressionMatcher::match() { … }

LiteralSize IntegralLiteralExpressionMatcher::largestLiteralSize() const { … }

} // namespace clang::tidy::modernize