a199fb1229
Expanding all macros in the printf/absl::StrFormat format string before conversion could easily break code if those macros are expanded change their definition between builds. It's important for this check to expand the <inttypes.h> PRI macros though, so let's ensure that the presence of any other macros in the format string causes the check to emit a warning and not perform any conversion.
127 lines
5.0 KiB
C++
127 lines
5.0 KiB
C++
//===--- FormatStringConverter.h - clang-tidy--------------------*- C++ -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// Declaration of the FormatStringConverter class which is used to convert
|
|
/// printf format strings to C++ std::formatter format strings.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
|
|
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
|
|
|
|
#include "clang/AST/ASTContext.h"
|
|
#include "clang/AST/FormatString.h"
|
|
#include "clang/ASTMatchers/ASTMatchers.h"
|
|
#include <string>
|
|
|
|
namespace clang::tidy::utils {
|
|
|
|
/// Convert a printf-style format string to a std::formatter-style one, and
|
|
/// prepare any casts that are required to wrap the arguments to retain printf
|
|
/// compatibility. This class is expecting to work on the already-cooked format
|
|
/// string (i.e. all the escapes have been converted) so we have to convert them
|
|
/// back. This means that we might not convert them back using the same form.
|
|
class FormatStringConverter
|
|
: public clang::analyze_format_string::FormatStringHandler {
|
|
public:
|
|
using ConversionSpecifier = clang::analyze_format_string::ConversionSpecifier;
|
|
using PrintfSpecifier = analyze_printf::PrintfSpecifier;
|
|
|
|
struct Configuration {
|
|
bool StrictMode = false;
|
|
bool AllowTrailingNewlineRemoval = false;
|
|
};
|
|
|
|
FormatStringConverter(ASTContext *Context, const CallExpr *Call,
|
|
unsigned FormatArgOffset, Configuration Config,
|
|
const LangOptions &LO, SourceManager &SM,
|
|
Preprocessor &PP);
|
|
|
|
bool canApply() const { return ConversionNotPossibleReason.empty(); }
|
|
const std::string &conversionNotPossibleReason() const {
|
|
return ConversionNotPossibleReason;
|
|
}
|
|
void applyFixes(DiagnosticBuilder &Diag, SourceManager &SM);
|
|
bool usePrintNewlineFunction() const { return UsePrintNewlineFunction; }
|
|
|
|
private:
|
|
ASTContext *Context;
|
|
const Configuration Config;
|
|
const bool CastMismatchedIntegerTypes;
|
|
const Expr *const *Args;
|
|
const unsigned NumArgs;
|
|
unsigned ArgsOffset;
|
|
const LangOptions &LangOpts;
|
|
std::string ConversionNotPossibleReason;
|
|
bool FormatStringNeededRewriting = false;
|
|
bool UsePrintNewlineFunction = false;
|
|
size_t PrintfFormatStringPos = 0U;
|
|
StringRef PrintfFormatString;
|
|
|
|
/// Lazily-created c_str() call matcher
|
|
std::optional<clang::ast_matchers::StatementMatcher>
|
|
StringCStrCallExprMatcher;
|
|
|
|
const StringLiteral *FormatExpr;
|
|
std::string StandardFormatString;
|
|
|
|
/// Casts to be used to wrap arguments to retain printf compatibility.
|
|
struct ArgumentFix {
|
|
unsigned ArgIndex;
|
|
std::string Fix;
|
|
|
|
// We currently need this for emplace_back. Roll on C++20.
|
|
explicit ArgumentFix(unsigned ArgIndex, std::string Fix)
|
|
: ArgIndex(ArgIndex), Fix(std::move(Fix)) {}
|
|
};
|
|
|
|
std::vector<ArgumentFix> ArgFixes;
|
|
std::vector<clang::ast_matchers::BoundNodes> ArgCStrRemovals;
|
|
|
|
// Argument rotations to cope with the fact that std::print puts the value to
|
|
// be formatted first and the width and precision afterwards whereas printf
|
|
// puts the width and preicision first.
|
|
std::vector<std::tuple<unsigned, unsigned>> ArgRotates;
|
|
|
|
void emitAlignment(const PrintfSpecifier &FS, std::string &FormatSpec);
|
|
void emitSign(const PrintfSpecifier &FS, std::string &FormatSpec);
|
|
void emitAlternativeForm(const PrintfSpecifier &FS, std::string &FormatSpec);
|
|
void emitFieldWidth(const PrintfSpecifier &FS, std::string &FormatSpec);
|
|
void emitPrecision(const PrintfSpecifier &FS, std::string &FormatSpec);
|
|
void emitStringArgument(unsigned ArgIndex, const Expr *Arg);
|
|
bool emitIntegerArgument(ConversionSpecifier::Kind ArgKind, const Expr *Arg,
|
|
unsigned ArgIndex, std::string &FormatSpec);
|
|
|
|
bool emitType(const PrintfSpecifier &FS, const Expr *Arg,
|
|
std::string &FormatSpec);
|
|
bool convertArgument(const PrintfSpecifier &FS, const Expr *Arg,
|
|
std::string &StandardFormatString);
|
|
|
|
void maybeRotateArguments(const PrintfSpecifier &FS);
|
|
|
|
bool HandlePrintfSpecifier(const PrintfSpecifier &FS,
|
|
const char *StartSpecifier, unsigned SpecifierLen,
|
|
const TargetInfo &Target) override;
|
|
|
|
void appendFormatText(StringRef Text);
|
|
void finalizeFormatText();
|
|
static std::optional<StringRef>
|
|
formatStringContainsUnreplaceableMacro(const CallExpr *CallExpr,
|
|
const StringLiteral *FormatExpr,
|
|
SourceManager &SM, Preprocessor &PP);
|
|
bool conversionNotPossible(std::string Reason) {
|
|
ConversionNotPossibleReason = std::move(Reason);
|
|
return false;
|
|
}
|
|
};
|
|
|
|
} // namespace clang::tidy::utils
|
|
|
|
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
|