[clang] 476bc22 - [clang] clang-format functionality related to format string parsing (NFC) (#195644)
via cfe-commits
cfe-commits at lists.llvm.org
Mon May 4 08:11:39 PDT 2026
Author: Sergei Barannikov
Date: 2026-05-04T18:11:33+03:00
New Revision: 476bc22e852be2e3d3991d299b591392386d908b
URL: https://github.com/llvm/llvm-project/commit/476bc22e852be2e3d3991d299b591392386d908b
DIFF: https://github.com/llvm/llvm-project/commit/476bc22e852be2e3d3991d299b591392386d908b.diff
LOG: [clang] clang-format functionality related to format string parsing (NFC) (#195644)
This should help reduce diff in #169803.
Added:
Modified:
clang/include/clang/AST/FormatString.h
clang/lib/AST/FormatString.cpp
clang/lib/AST/FormatStringParsing.h
clang/lib/AST/PrintfFormatString.cpp
clang/lib/AST/ScanfFormatString.cpp
clang/lib/Sema/SemaChecking.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/FormatString.h b/clang/include/clang/AST/FormatString.h
index 56474e8e115fb..586d9f0f8feb0 100644
--- a/clang/include/clang/AST/FormatString.h
+++ b/clang/include/clang/AST/FormatString.h
@@ -51,10 +51,11 @@ class OptionalFlag {
// Overloaded operators for bool like qualities
explicit operator bool() const { return flag; }
- OptionalFlag& operator=(const bool &rhs) {
+ OptionalFlag &operator=(const bool &rhs) {
flag = rhs;
- return *this; // Return a reference to myself.
+ return *this; // Return a reference to myself.
}
+
private:
const char *representation;
const char *position;
@@ -66,46 +67,42 @@ class LengthModifier {
public:
enum Kind {
None,
- AsChar, // 'hh'
- AsShort, // 'h'
- AsShortLong, // 'hl' (OpenCL float/int vector element)
- AsLong, // 'l'
- AsLongLong, // 'll'
- AsQuad, // 'q' (BSD, deprecated, for 64-bit integer types)
- AsIntMax, // 'j'
- AsSizeT, // 'z'
- AsPtrDiff, // 't'
- AsInt32, // 'I32' (MSVCRT, like __int32)
- AsInt3264, // 'I' (MSVCRT, like __int3264 from MIDL)
- AsInt64, // 'I64' (MSVCRT, like __int64)
- AsLongDouble, // 'L'
- AsAllocate, // for '%as', GNU extension to C90 scanf
- AsMAllocate, // for '%ms', GNU extension to scanf
- AsWide, // 'w' (MSVCRT, like l but only for c, C, s, S, or Z
+ AsChar, // 'hh'
+ AsShort, // 'h'
+ AsShortLong, // 'hl' (OpenCL float/int vector element)
+ AsLong, // 'l'
+ AsLongLong, // 'll'
+ AsQuad, // 'q' (BSD, deprecated, for 64-bit integer types)
+ AsIntMax, // 'j'
+ AsSizeT, // 'z'
+ AsPtrDiff, // 't'
+ AsInt32, // 'I32' (MSVCRT, like __int32)
+ AsInt3264, // 'I' (MSVCRT, like __int3264 from MIDL)
+ AsInt64, // 'I64' (MSVCRT, like __int64)
+ AsLongDouble, // 'L'
+ AsAllocate, // for '%as', GNU extension to C90 scanf
+ AsMAllocate, // for '%ms', GNU extension to scanf
+ AsWide, // 'w' (MSVCRT, like l but only for c, C, s, S, or Z
AsWideChar = AsLong // for '%ls', only makes sense for printf
};
- LengthModifier()
- : Position(nullptr), kind(None) {}
- LengthModifier(const char *pos, Kind k)
- : Position(pos), kind(k) {}
+ LengthModifier() : Position(nullptr), kind(None) {}
+ LengthModifier(const char *pos, Kind k) : Position(pos), kind(k) {}
- const char *getStart() const {
- return Position;
- }
+ const char *getStart() const { return Position; }
unsigned getLength() const {
switch (kind) {
- default:
- return 1;
- case AsLongLong:
- case AsChar:
- return 2;
- case AsInt32:
- case AsInt64:
- return 3;
- case None:
- return 0;
+ default:
+ return 1;
+ case AsLongLong:
+ case AsChar:
+ return 2;
+ case AsInt32:
+ case AsInt64:
+ return 3;
+ case None:
+ return 0;
}
}
@@ -203,31 +200,27 @@ class ConversionSpecifier {
};
ConversionSpecifier(bool isPrintf = true)
- : IsPrintf(isPrintf), Position(nullptr), EndScanList(nullptr),
- kind(InvalidSpecifier) {}
+ : IsPrintf(isPrintf), Position(nullptr), EndScanList(nullptr),
+ kind(InvalidSpecifier) {}
ConversionSpecifier(bool isPrintf, const char *pos, Kind k)
- : IsPrintf(isPrintf), Position(pos), EndScanList(nullptr), kind(k) {}
+ : IsPrintf(isPrintf), Position(pos), EndScanList(nullptr), kind(k) {}
- const char *getStart() const {
- return Position;
- }
+ const char *getStart() const { return Position; }
- StringRef getCharacters() const {
- return StringRef(getStart(), getLength());
- }
+ StringRef getCharacters() const { return StringRef(getStart(), getLength()); }
bool consumesDataArgument() const {
switch (kind) {
- case PrintErrno:
- assert(IsPrintf);
- return false;
- case PercentArg:
- return false;
- case InvalidSpecifier:
- return false;
- default:
- return true;
+ case PrintErrno:
+ assert(IsPrintf);
+ return false;
+ case PercentArg:
+ return false;
+ case InvalidSpecifier:
+ return false;
+ default:
+ return true;
}
}
@@ -238,8 +231,10 @@ class ConversionSpecifier {
}
void setEndScanList(const char *pos) { EndScanList = pos; }
- bool isIntArg() const { return (kind >= IntArgBeg && kind <= IntArgEnd) ||
- kind == FreeBSDrArg || kind == FreeBSDyArg; }
+ bool isIntArg() const {
+ return (kind >= IntArgBeg && kind <= IntArgEnd) || kind == FreeBSDrArg ||
+ kind == FreeBSDyArg;
+ }
bool isUIntArg() const { return kind >= UIntArgBeg && kind <= UIntArgEnd; }
bool isAnyIntArg() const { return kind >= IntArgBeg && kind <= UIntArgEnd; }
bool isDoubleArg() const {
@@ -264,8 +259,17 @@ class ConversionSpecifier {
class ArgType {
public:
- enum Kind { UnknownTy, InvalidTy, SpecificTy, ObjCPointerTy, CPointerTy,
- AnyCharTy, CStrTy, WCStrTy, WIntTy };
+ enum Kind {
+ UnknownTy,
+ InvalidTy,
+ SpecificTy,
+ ObjCPointerTy,
+ CPointerTy,
+ AnyCharTy,
+ CStrTy,
+ WCStrTy,
+ WIntTy
+ };
/// How well a given conversion specifier matches its argument.
enum MatchKind {
@@ -315,7 +319,7 @@ class ArgType {
bool isPtr
diff T() const { return TK == TypeKind::Ptr
diff T; }
/// Create an ArgType which corresponds to the type pointer to A.
- static ArgType PtrTo(const ArgType& A) {
+ static ArgType PtrTo(const ArgType &A) {
assert(A.K >= InvalidTy && "ArgType cannot be pointer to invalid/unknown");
ArgType Res = A;
Res.Ptr = true;
@@ -351,25 +355,21 @@ class OptionalAmount {
public:
enum HowSpecified { NotSpecified, Constant, Arg, Invalid };
- OptionalAmount(HowSpecified howSpecified,
- unsigned amount,
- const char *amountStart,
- unsigned amountLength,
+ OptionalAmount(HowSpecified howSpecified, unsigned amount,
+ const char *amountStart, unsigned amountLength,
bool usesPositionalArg)
- : start(amountStart), length(amountLength), hs(howSpecified), amt(amount),
- UsesPositionalArg(usesPositionalArg), UsesDotPrefix(false) {}
+ : start(amountStart), length(amountLength), hs(howSpecified), amt(amount),
+ UsesPositionalArg(usesPositionalArg), UsesDotPrefix(false) {}
OptionalAmount(bool valid = true)
- : start(nullptr),length(0), hs(valid ? NotSpecified : Invalid), amt(0),
- UsesPositionalArg(false), UsesDotPrefix(false) {}
+ : start(nullptr), length(0), hs(valid ? NotSpecified : Invalid), amt(0),
+ UsesPositionalArg(false), UsesDotPrefix(false) {}
explicit OptionalAmount(unsigned Amount)
- : start(nullptr), length(0), hs(Constant), amt(Amount),
- UsesPositionalArg(false), UsesDotPrefix(false) {}
+ : start(nullptr), length(0), hs(Constant), amt(Amount),
+ UsesPositionalArg(false), UsesDotPrefix(false) {}
- bool isInvalid() const {
- return hs == Invalid;
- }
+ bool isInvalid() const { return hs == Invalid; }
HowSpecified getHowSpecified() const { return hs; }
void setHowSpecified(HowSpecified h) { hs = h; }
@@ -400,7 +400,7 @@ class OptionalAmount {
void toString(raw_ostream &os) const;
- bool usesPositionalArg() const { return (bool) UsesPositionalArg; }
+ bool usesPositionalArg() const { return (bool)UsesPositionalArg; }
unsigned getPositionalArgIndex() const {
assert(hasDataArgument());
return amt + 1;
@@ -418,7 +418,6 @@ class OptionalAmount {
bool UsesDotPrefix;
};
-
class FormatSpecifier {
protected:
LengthModifier LM;
@@ -431,48 +430,31 @@ class FormatSpecifier {
/// http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
bool UsesPositionalArg;
unsigned argIndex;
+
public:
FormatSpecifier(bool isPrintf)
- : CS(isPrintf), VectorNumElts(false),
- UsesPositionalArg(false), argIndex(0) {}
+ : CS(isPrintf), VectorNumElts(false), UsesPositionalArg(false),
+ argIndex(0) {}
- void setLengthModifier(LengthModifier lm) {
- LM = lm;
- }
+ void setLengthModifier(LengthModifier lm) { LM = lm; }
void setUsesPositionalArg() { UsesPositionalArg = true; }
- void setArgIndex(unsigned i) {
- argIndex = i;
- }
+ void setArgIndex(unsigned i) { argIndex = i; }
- unsigned getArgIndex() const {
- return argIndex;
- }
+ unsigned getArgIndex() const { return argIndex; }
- unsigned getPositionalArgIndex() const {
- return argIndex + 1;
- }
+ unsigned getPositionalArgIndex() const { return argIndex + 1; }
- const LengthModifier &getLengthModifier() const {
- return LM;
- }
+ const LengthModifier &getLengthModifier() const { return LM; }
- const OptionalAmount &getFieldWidth() const {
- return FieldWidth;
- }
+ const OptionalAmount &getFieldWidth() const { return FieldWidth; }
- void setVectorNumElts(const OptionalAmount &Amt) {
- VectorNumElts = Amt;
- }
+ void setVectorNumElts(const OptionalAmount &Amt) { VectorNumElts = Amt; }
- const OptionalAmount &getVectorNumElts() const {
- return VectorNumElts;
- }
+ const OptionalAmount &getVectorNumElts() const { return VectorNumElts; }
- void setFieldWidth(const OptionalAmount &Amt) {
- FieldWidth = Amt;
- }
+ void setFieldWidth(const OptionalAmount &Amt) { FieldWidth = Amt; }
bool usesPositionalArg() const { return UsesPositionalArg; }
@@ -493,25 +475,26 @@ class FormatSpecifier {
LengthModifier &LM);
};
-} // end analyze_format_string namespace
+} // namespace analyze_format_string
//===----------------------------------------------------------------------===//
/// Pieces specific to fprintf format strings.
namespace analyze_printf {
-class PrintfConversionSpecifier :
- public analyze_format_string::ConversionSpecifier {
+class PrintfConversionSpecifier
+ : public analyze_format_string::ConversionSpecifier {
public:
PrintfConversionSpecifier()
- : ConversionSpecifier(true, nullptr, InvalidSpecifier) {}
+ : ConversionSpecifier(true, nullptr, InvalidSpecifier) {}
PrintfConversionSpecifier(const char *pos, Kind k)
- : ConversionSpecifier(true, pos, k) {}
+ : ConversionSpecifier(true, pos, k) {}
bool isObjCArg() const { return kind >= ObjCBeg && kind <= ObjCEnd; }
- bool isDoubleArg() const { return kind >= DoubleArgBeg &&
- kind <= DoubleArgEnd; }
+ bool isDoubleArg() const {
+ return kind >= DoubleArgBeg && kind <= DoubleArgEnd;
+ }
static bool classof(const analyze_format_string::ConversionSpecifier *CS) {
return CS->isPrintfKind();
@@ -525,11 +508,11 @@ using analyze_format_string::OptionalFlag;
class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
OptionalFlag HasThousandsGrouping; // ''', POSIX extension.
- OptionalFlag IsLeftJustified; // '-'
- OptionalFlag HasPlusPrefix; // '+'
- OptionalFlag HasSpacePrefix; // ' '
- OptionalFlag HasAlternativeForm; // '#'
- OptionalFlag HasLeadingZeroes; // '0'
+ OptionalFlag IsLeftJustified; // '-'
+ OptionalFlag HasPlusPrefix; // '+'
+ OptionalFlag HasSpacePrefix; // ' '
+ OptionalFlag HasAlternativeForm; // '#'
+ OptionalFlag HasLeadingZeroes; // '0'
OptionalFlag HasObjCTechnicalTerm; // '[tt]'
OptionalFlag IsPrivate; // '{private}'
OptionalFlag IsPublic; // '{public}'
@@ -549,10 +532,8 @@ class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
static PrintfSpecifier Parse(const char *beg, const char *end);
- // Methods for incrementally constructing the PrintfSpecifier.
- void setConversionSpecifier(const PrintfConversionSpecifier &cs) {
- CS = cs;
- }
+ // Methods for incrementally constructing the PrintfSpecifier.
+ void setConversionSpecifier(const PrintfConversionSpecifier &cs) { CS = cs; }
void setHasThousandsGrouping(const char *position) {
HasThousandsGrouping.setPosition(position);
}
@@ -581,7 +562,7 @@ class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
}
void setUsesPositionalArg() { UsesPositionalArg = true; }
- // Methods for querying the format specifier.
+ // Methods for querying the format specifier.
const PrintfConversionSpecifier &getConversionSpecifier() const {
return cast<PrintfConversionSpecifier>(CS);
@@ -592,9 +573,7 @@ class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
Precision.setUsesDotPrefix();
}
- const OptionalAmount &getPrecision() const {
- return Precision;
- }
+ const OptionalAmount &getPrecision() const { return Precision; }
bool consumesDataArgument() const {
return getConversionSpecifier().consumesDataArgument();
@@ -608,14 +587,16 @@ class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
ArgType getArgType(ASTContext &Ctx, bool IsObjCLiteral) const;
const OptionalFlag &hasThousandsGrouping() const {
- return HasThousandsGrouping;
+ return HasThousandsGrouping;
}
const OptionalFlag &isLeftJustified() const { return IsLeftJustified; }
const OptionalFlag &hasPlusPrefix() const { return HasPlusPrefix; }
const OptionalFlag &hasAlternativeForm() const { return HasAlternativeForm; }
const OptionalFlag &hasLeadingZeros() const { return HasLeadingZeroes; }
const OptionalFlag &hasSpacePrefix() const { return HasSpacePrefix; }
- const OptionalFlag &hasObjCTechnicalTerm() const { return HasObjCTechnicalTerm; }
+ const OptionalFlag &hasObjCTechnicalTerm() const {
+ return HasObjCTechnicalTerm;
+ }
const OptionalFlag &isPrivate() const { return IsPrivate; }
const OptionalFlag &isPublic() const { return IsPublic; }
const OptionalFlag &isSensitive() const { return IsSensitive; }
@@ -643,21 +624,21 @@ class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
bool hasValidPrecision() const;
bool hasValidFieldWidth() const;
};
-} // end analyze_printf namespace
+} // namespace analyze_printf
//===----------------------------------------------------------------------===//
/// Pieces specific to fscanf format strings.
namespace analyze_scanf {
-class ScanfConversionSpecifier :
- public analyze_format_string::ConversionSpecifier {
+class ScanfConversionSpecifier
+ : public analyze_format_string::ConversionSpecifier {
public:
ScanfConversionSpecifier()
- : ConversionSpecifier(false, nullptr, InvalidSpecifier) {}
+ : ConversionSpecifier(false, nullptr, InvalidSpecifier) {}
ScanfConversionSpecifier(const char *pos, Kind k)
- : ConversionSpecifier(false, pos, k) {}
+ : ConversionSpecifier(false, pos, k) {}
static bool classof(const analyze_format_string::ConversionSpecifier *CS) {
return !CS->isPrintfKind();
@@ -672,9 +653,8 @@ using analyze_format_string::OptionalFlag;
class ScanfSpecifier : public analyze_format_string::FormatSpecifier {
OptionalFlag SuppressAssignment; // '*'
public:
- ScanfSpecifier() :
- FormatSpecifier(/* isPrintf = */ false),
- SuppressAssignment("*") {}
+ ScanfSpecifier()
+ : FormatSpecifier(/* isPrintf = */ false), SuppressAssignment("*") {}
void setSuppressAssignment(const char *position) {
SuppressAssignment.setPosition(position);
@@ -684,9 +664,7 @@ class ScanfSpecifier : public analyze_format_string::FormatSpecifier {
return SuppressAssignment;
}
- void setConversionSpecifier(const ScanfConversionSpecifier &cs) {
- CS = cs;
- }
+ void setConversionSpecifier(const ScanfConversionSpecifier &cs) { CS = cs; }
const ScanfConversionSpecifier &getConversionSpecifier() const {
return cast<ScanfConversionSpecifier>(CS);
@@ -706,7 +684,7 @@ class ScanfSpecifier : public analyze_format_string::FormatSpecifier {
static ScanfSpecifier Parse(const char *beg, const char *end);
};
-} // end analyze_scanf namespace
+} // namespace analyze_scanf
//===----------------------------------------------------------------------===//
// Parsing and processing of format strings (both fprintf and fscanf).
@@ -738,15 +716,15 @@ class FormatStringHandler {
virtual void HandleInvalidObjCModifierFlag(const char *startFlag,
unsigned flagLen) {}
- virtual void HandleObjCFlagsWithNonObjCConversion(const char *flagsStart,
- const char *flagsEnd,
- const char *conversionPosition) {}
+ virtual void
+ HandleObjCFlagsWithNonObjCConversion(const char *flagsStart,
+ const char *flagsEnd,
+ const char *conversionPosition) {}
// Printf-specific handlers.
virtual bool HandleInvalidPrintfConversionSpecifier(
- const analyze_printf::PrintfSpecifier &FS,
- const char *startSpecifier,
- unsigned specifierLen) {
+ const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier,
+ unsigned specifierLen) {
return true;
}
@@ -760,10 +738,10 @@ class FormatStringHandler {
/// Handle mask types whose sizes are not between one and eight bytes.
virtual void handleInvalidMaskType(StringRef MaskType) {}
- // Scanf-specific handlers.
+ // Scanf-specific handlers.
- virtual bool HandleInvalidScanfConversionSpecifier(
- const analyze_scanf::ScanfSpecifier &FS,
+ virtual bool
+ HandleInvalidScanfConversionSpecifier(const analyze_scanf::ScanfSpecifier &FS,
const char *startSpecifier,
unsigned specifierLen) {
return true;
@@ -778,16 +756,15 @@ class FormatStringHandler {
virtual void HandleIncompleteScanList(const char *start, const char *end) {}
};
-bool ParsePrintfString(FormatStringHandler &H,
- const char *beg, const char *end, const LangOptions &LO,
- const TargetInfo &Target, bool isFreeBSDKPrintf);
+bool ParsePrintfString(FormatStringHandler &H, const char *beg, const char *end,
+ const LangOptions &LO, const TargetInfo &Target,
+ bool isFreeBSDKPrintf);
bool ParseFormatStringHasSArg(const char *beg, const char *end,
const LangOptions &LO, const TargetInfo &Target);
-bool ParseScanfString(FormatStringHandler &H,
- const char *beg, const char *end, const LangOptions &LO,
- const TargetInfo &Target);
+bool ParseScanfString(FormatStringHandler &H, const char *beg, const char *end,
+ const LangOptions &LO, const TargetInfo &Target);
/// Return true if the given string has at least one formatting specifier.
bool parseFormatStringHasFormattingSpecifiers(const char *Begin,
@@ -795,6 +772,6 @@ bool parseFormatStringHasFormattingSpecifiers(const char *Begin,
const LangOptions &LO,
const TargetInfo &Target);
-} // end analyze_format_string namespace
-} // end clang namespace
+} // namespace analyze_format_string
+} // namespace clang
#endif
diff --git a/clang/lib/AST/FormatString.cpp b/clang/lib/AST/FormatString.cpp
index 6eb93598033f6..7e1ac0de6dcaf 100644
--- a/clang/lib/AST/FormatString.cpp
+++ b/clang/lib/AST/FormatString.cpp
@@ -18,11 +18,11 @@
#include <optional>
using clang::analyze_format_string::ArgType;
-using clang::analyze_format_string::FormatStringHandler;
+using clang::analyze_format_string::ConversionSpecifier;
using clang::analyze_format_string::FormatSpecifier;
+using clang::analyze_format_string::FormatStringHandler;
using clang::analyze_format_string::LengthModifier;
using clang::analyze_format_string::OptionalAmount;
-using clang::analyze_format_string::ConversionSpecifier;
using namespace clang;
// Key function to FormatStringHandler.
@@ -33,15 +33,15 @@ FormatStringHandler::~FormatStringHandler() {}
// scanf format strings.
//===----------------------------------------------------------------------===//
-OptionalAmount
-clang::analyze_format_string::ParseAmount(const char *&Beg, const char *E) {
+OptionalAmount clang::analyze_format_string::ParseAmount(const char *&Beg,
+ const char *E) {
const char *I = Beg;
- UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+ UpdateOnReturn<const char *> UpdateBeg(Beg, I);
unsigned accumulator = 0;
bool hasDigits = false;
- for ( ; I != E; ++I) {
+ for (; I != E; ++I) {
char c = *I;
if (c >= '0' && c <= '9') {
hasDigits = true;
@@ -51,7 +51,7 @@ clang::analyze_format_string::ParseAmount(const char *&Beg, const char *E) {
if (hasDigits)
return OptionalAmount(OptionalAmount::Constant, accumulator, Beg, I - Beg,
- false);
+ false);
break;
}
@@ -59,10 +59,8 @@ clang::analyze_format_string::ParseAmount(const char *&Beg, const char *E) {
return OptionalAmount();
}
-OptionalAmount
-clang::analyze_format_string::ParseNonPositionAmount(const char *&Beg,
- const char *E,
- unsigned &argIndex) {
+OptionalAmount clang::analyze_format_string::ParseNonPositionAmount(
+ const char *&Beg, const char *E, unsigned &argIndex) {
if (*Beg == '*') {
++Beg;
return OptionalAmount(OptionalAmount::Arg, argIndex++, Beg, 0, false);
@@ -71,12 +69,9 @@ clang::analyze_format_string::ParseNonPositionAmount(const char *&Beg,
return ParseAmount(Beg, E);
}
-OptionalAmount
-clang::analyze_format_string::ParsePositionAmount(FormatStringHandler &H,
- const char *Start,
- const char *&Beg,
- const char *E,
- PositionContext p) {
+OptionalAmount clang::analyze_format_string::ParsePositionAmount(
+ FormatStringHandler &H, const char *Start, const char *&Beg, const char *E,
+ PositionContext p) {
if (*Beg == '*') {
const char *I = Beg + 1;
const OptionalAmount &Amt = ParseAmount(I, E);
@@ -117,21 +112,15 @@ clang::analyze_format_string::ParsePositionAmount(FormatStringHandler &H,
return ParseAmount(Beg, E);
}
-
-bool
-clang::analyze_format_string::ParseFieldWidth(FormatStringHandler &H,
- FormatSpecifier &CS,
- const char *Start,
- const char *&Beg, const char *E,
- unsigned *argIndex) {
+bool clang::analyze_format_string::ParseFieldWidth(
+ FormatStringHandler &H, FormatSpecifier &CS, const char *Start,
+ const char *&Beg, const char *E, unsigned *argIndex) {
// FIXME: Support negative field widths.
if (argIndex) {
CS.setFieldWidth(ParseNonPositionAmount(Beg, E, *argIndex));
- }
- else {
- const OptionalAmount Amt =
- ParsePositionAmount(H, Start, Beg, E,
- analyze_format_string::FieldWidthPos);
+ } else {
+ const OptionalAmount Amt = ParsePositionAmount(
+ H, Start, Beg, E, analyze_format_string::FieldWidthPos);
if (Amt.isInvalid())
return true;
@@ -140,12 +129,11 @@ clang::analyze_format_string::ParseFieldWidth(FormatStringHandler &H,
return false;
}
-bool
-clang::analyze_format_string::ParseArgPosition(FormatStringHandler &H,
- FormatSpecifier &FS,
- const char *Start,
- const char *&Beg,
- const char *E) {
+bool clang::analyze_format_string::ParseArgPosition(FormatStringHandler &H,
+ FormatSpecifier &FS,
+ const char *Start,
+ const char *&Beg,
+ const char *E) {
const char *I = Beg;
const OptionalAmount &Amt = ParseAmount(I, E);
@@ -177,12 +165,11 @@ clang::analyze_format_string::ParseArgPosition(FormatStringHandler &H,
return false;
}
-bool
-clang::analyze_format_string::ParseVectorModifier(FormatStringHandler &H,
- FormatSpecifier &FS,
- const char *&I,
- const char *E,
- const LangOptions &LO) {
+bool clang::analyze_format_string::ParseVectorModifier(FormatStringHandler &H,
+ FormatSpecifier &FS,
+ const char *&I,
+ const char *E,
+ const LangOptions &LO) {
if (!LO.OpenCL)
return false;
@@ -207,86 +194,102 @@ clang::analyze_format_string::ParseVectorModifier(FormatStringHandler &H,
return false;
}
-bool
-clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS,
- const char *&I,
- const char *E,
- const LangOptions &LO,
- bool IsScanf) {
+bool clang::analyze_format_string::ParseLengthModifier(FormatSpecifier &FS,
+ const char *&I,
+ const char *E,
+ const LangOptions &LO,
+ bool IsScanf) {
LengthModifier::Kind lmKind = LengthModifier::None;
const char *lmPosition = I;
switch (*I) {
- default:
- return false;
- case 'h':
+ default:
+ return false;
+ case 'h':
+ ++I;
+ if (I != E && *I == 'h') {
++I;
- if (I != E && *I == 'h') {
- ++I;
- lmKind = LengthModifier::AsChar;
- } else if (I != E && *I == 'l' && LO.OpenCL) {
- ++I;
- lmKind = LengthModifier::AsShortLong;
- } else {
- lmKind = LengthModifier::AsShort;
- }
- break;
- case 'l':
+ lmKind = LengthModifier::AsChar;
+ } else if (I != E && *I == 'l' && LO.OpenCL) {
+ ++I;
+ lmKind = LengthModifier::AsShortLong;
+ } else {
+ lmKind = LengthModifier::AsShort;
+ }
+ break;
+ case 'l':
+ ++I;
+ if (I != E && *I == 'l') {
++I;
- if (I != E && *I == 'l') {
- ++I;
- lmKind = LengthModifier::AsLongLong;
- } else {
- lmKind = LengthModifier::AsLong;
+ lmKind = LengthModifier::AsLongLong;
+ } else {
+ lmKind = LengthModifier::AsLong;
+ }
+ break;
+ case 'j':
+ lmKind = LengthModifier::AsIntMax;
+ ++I;
+ break;
+ case 'z':
+ lmKind = LengthModifier::AsSizeT;
+ ++I;
+ break;
+ case 't':
+ lmKind = LengthModifier::AsPtrDiff;
+ ++I;
+ break;
+ case 'L':
+ lmKind = LengthModifier::AsLongDouble;
+ ++I;
+ break;
+ case 'q':
+ lmKind = LengthModifier::AsQuad;
+ ++I;
+ break;
+ case 'a':
+ if (IsScanf && !LO.C99 && !LO.CPlusPlus11) {
+ // For scanf in C90, look at the next character to see if this should
+ // be parsed as the GNU extension 'a' length modifier. If not, this
+ // will be parsed as a conversion specifier.
+ ++I;
+ if (I != E && (*I == 's' || *I == 'S' || *I == '[')) {
+ lmKind = LengthModifier::AsAllocate;
+ break;
}
+ --I;
+ }
+ return false;
+ case 'm':
+ if (IsScanf) {
+ lmKind = LengthModifier::AsMAllocate;
+ ++I;
break;
- case 'j': lmKind = LengthModifier::AsIntMax; ++I; break;
- case 'z': lmKind = LengthModifier::AsSizeT; ++I; break;
- case 't': lmKind = LengthModifier::AsPtrDiff; ++I; break;
- case 'L': lmKind = LengthModifier::AsLongDouble; ++I; break;
- case 'q': lmKind = LengthModifier::AsQuad; ++I; break;
- case 'a':
- if (IsScanf && !LO.C99 && !LO.CPlusPlus11) {
- // For scanf in C90, look at the next character to see if this should
- // be parsed as the GNU extension 'a' length modifier. If not, this
- // will be parsed as a conversion specifier.
- ++I;
- if (I != E && (*I == 's' || *I == 'S' || *I == '[')) {
- lmKind = LengthModifier::AsAllocate;
- break;
- }
- --I;
- }
- return false;
- case 'm':
- if (IsScanf) {
- lmKind = LengthModifier::AsMAllocate;
- ++I;
+ }
+ return false;
+ // printf: AsInt64, AsInt32, AsInt3264
+ // scanf: AsInt64
+ case 'I':
+ if (I + 1 != E && I + 2 != E) {
+ if (I[1] == '6' && I[2] == '4') {
+ I += 3;
+ lmKind = LengthModifier::AsInt64;
break;
}
- return false;
- // printf: AsInt64, AsInt32, AsInt3264
- // scanf: AsInt64
- case 'I':
- if (I + 1 != E && I + 2 != E) {
- if (I[1] == '6' && I[2] == '4') {
- I += 3;
- lmKind = LengthModifier::AsInt64;
- break;
- }
- if (IsScanf)
- return false;
+ if (IsScanf)
+ return false;
- if (I[1] == '3' && I[2] == '2') {
- I += 3;
- lmKind = LengthModifier::AsInt32;
- break;
- }
+ if (I[1] == '3' && I[2] == '2') {
+ I += 3;
+ lmKind = LengthModifier::AsInt32;
+ break;
}
- ++I;
- lmKind = LengthModifier::AsInt3264;
- break;
- case 'w':
- lmKind = LengthModifier::AsWide; ++I; break;
+ }
+ ++I;
+ lmKind = LengthModifier::AsInt3264;
+ break;
+ case 'w':
+ lmKind = LengthModifier::AsWide;
+ ++I;
+ break;
}
LengthModifier lm(lmPosition, lmKind);
FS.setLengthModifier(lm);
@@ -409,258 +412,257 @@ ArgType::matchesType(ASTContext &C, QualType argTy) const {
argTy = OBT->getUnderlyingType();
switch (K) {
- case InvalidTy:
- llvm_unreachable("ArgType must be valid");
+ case InvalidTy:
+ llvm_unreachable("ArgType must be valid");
- case UnknownTy:
- return Match;
+ case UnknownTy:
+ return Match;
- case AnyCharTy: {
- if (const auto *ED = argTy->getAsEnumDecl()) {
- // If the enum is incomplete we know nothing about the underlying type.
- // Assume that it's 'int'. Do not use the underlying type for a scoped
- // enumeration.
- if (!ED->isComplete())
- return NoMatch;
- if (!ED->isScoped())
- argTy = ED->getIntegerType();
- }
+ case AnyCharTy: {
+ if (const auto *ED = argTy->getAsEnumDecl()) {
+ // If the enum is incomplete we know nothing about the underlying type.
+ // Assume that it's 'int'. Do not use the underlying type for a scoped
+ // enumeration.
+ if (!ED->isComplete())
+ return NoMatch;
+ if (!ED->isScoped())
+ argTy = ED->getIntegerType();
+ }
- if (const auto *BT = argTy->getAs<BuiltinType>()) {
- // The types are perfectly matched?
+ if (const auto *BT = argTy->getAs<BuiltinType>()) {
+ // The types are perfectly matched?
+ switch (BT->getKind()) {
+ default:
+ break;
+ case BuiltinType::Char_S:
+ case BuiltinType::SChar:
+ case BuiltinType::UChar:
+ case BuiltinType::Char_U:
+ return Match;
+ case BuiltinType::Bool:
+ if (!Ptr)
+ return Match;
+ break;
+ }
+ // "Partially matched" because of promotions?
+ if (!Ptr) {
switch (BT->getKind()) {
default:
break;
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- case BuiltinType::UChar:
- case BuiltinType::Char_U:
- return Match;
- case BuiltinType::Bool:
- if (!Ptr)
- return Match;
- break;
- }
- // "Partially matched" because of promotions?
- if (!Ptr) {
- switch (BT->getKind()) {
- default:
- break;
- case BuiltinType::Int:
- case BuiltinType::UInt:
- return MatchPromotion;
- case BuiltinType::Short:
- case BuiltinType::UShort:
- case BuiltinType::WChar_S:
- case BuiltinType::WChar_U:
- return NoMatchPromotionTypeConfusion;
- }
+ case BuiltinType::Int:
+ case BuiltinType::UInt:
+ return MatchPromotion;
+ case BuiltinType::Short:
+ case BuiltinType::UShort:
+ case BuiltinType::WChar_S:
+ case BuiltinType::WChar_U:
+ return NoMatchPromotionTypeConfusion;
}
}
- return NoMatch;
}
+ return NoMatch;
+ }
- case SpecificTy: {
- if (TK != TypeKind::DontCare) {
- return matchesSizeTPtr
diff T(C, argTy, T);
- }
+ case SpecificTy: {
+ if (TK != TypeKind::DontCare) {
+ return matchesSizeTPtr
diff T(C, argTy, T);
+ }
- if (const auto *ED = argTy->getAsEnumDecl()) {
- // If the enum is incomplete we know nothing about the underlying type.
- // Assume that it's 'int'. Do not use the underlying type for a scoped
- // enumeration as that needs an exact match.
- if (!ED->isComplete())
- argTy = C.IntTy;
- else if (!ED->isScoped())
- argTy = ED->getIntegerType();
- }
+ if (const auto *ED = argTy->getAsEnumDecl()) {
+ // If the enum is incomplete we know nothing about the underlying type.
+ // Assume that it's 'int'. Do not use the underlying type for a scoped
+ // enumeration as that needs an exact match.
+ if (!ED->isComplete())
+ argTy = C.IntTy;
+ else if (!ED->isScoped())
+ argTy = ED->getIntegerType();
+ }
- if (argTy->isSaturatedFixedPointType())
- argTy = C.getCorrespondingUnsaturatedType(argTy);
+ if (argTy->isSaturatedFixedPointType())
+ argTy = C.getCorrespondingUnsaturatedType(argTy);
- argTy = C.getCanonicalType(argTy).getUnqualifiedType();
+ argTy = C.getCanonicalType(argTy).getUnqualifiedType();
- if (T == argTy)
- return Match;
- if (const auto *BT = argTy->getAs<BuiltinType>()) {
- // Check if the only
diff erence between them is signed vs unsigned
- // if true, return match signedness.
+ if (T == argTy)
+ return Match;
+ if (const auto *BT = argTy->getAs<BuiltinType>()) {
+ // Check if the only
diff erence between them is signed vs unsigned
+ // if true, return match signedness.
+ switch (BT->getKind()) {
+ default:
+ break;
+ case BuiltinType::Bool:
+ if (Ptr && (T == C.UnsignedCharTy || T == C.SignedCharTy))
+ return NoMatch;
+ [[fallthrough]];
+ case BuiltinType::Char_S:
+ case BuiltinType::SChar:
+ if (T == C.UnsignedShortTy || T == C.ShortTy)
+ return NoMatchTypeConfusion;
+ if (T == C.UnsignedCharTy)
+ return NoMatchSignedness;
+ if (T == C.SignedCharTy)
+ return Match;
+ break;
+ case BuiltinType::Char_U:
+ case BuiltinType::UChar:
+ if (T == C.UnsignedShortTy || T == C.ShortTy)
+ return NoMatchTypeConfusion;
+ if (T == C.UnsignedCharTy)
+ return Match;
+ if (T == C.SignedCharTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::Short:
+ if (T == C.UnsignedShortTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::UShort:
+ if (T == C.ShortTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::Int:
+ if (T == C.UnsignedIntTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::UInt:
+ if (T == C.IntTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::Long:
+ if (T == C.UnsignedLongTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::ULong:
+ if (T == C.LongTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::LongLong:
+ if (T == C.UnsignedLongLongTy)
+ return NoMatchSignedness;
+ break;
+ case BuiltinType::ULongLong:
+ if (T == C.LongLongTy)
+ return NoMatchSignedness;
+ break;
+ }
+ // "Partially matched" because of promotions?
+ if (!Ptr) {
switch (BT->getKind()) {
- default:
- break;
- case BuiltinType::Bool:
- if (Ptr && (T == C.UnsignedCharTy || T == C.SignedCharTy))
- return NoMatch;
- [[fallthrough]];
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- if (T == C.UnsignedShortTy || T == C.ShortTy)
- return NoMatchTypeConfusion;
- if (T == C.UnsignedCharTy)
- return NoMatchSignedness;
- if (T == C.SignedCharTy)
- return Match;
- break;
- case BuiltinType::Char_U:
- case BuiltinType::UChar:
- if (T == C.UnsignedShortTy || T == C.ShortTy)
- return NoMatchTypeConfusion;
- if (T == C.UnsignedCharTy)
- return Match;
- if (T == C.SignedCharTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::Short:
- if (T == C.UnsignedShortTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::UShort:
- if (T == C.ShortTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::Int:
- if (T == C.UnsignedIntTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::UInt:
- if (T == C.IntTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::Long:
- if (T == C.UnsignedLongTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::ULong:
- if (T == C.LongTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::LongLong:
- if (T == C.UnsignedLongLongTy)
- return NoMatchSignedness;
- break;
- case BuiltinType::ULongLong:
- if (T == C.LongLongTy)
- return NoMatchSignedness;
- break;
- }
- // "Partially matched" because of promotions?
- if (!Ptr) {
- switch (BT->getKind()) {
- default:
- break;
- case BuiltinType::Bool:
- if (T == C.IntTy || T == C.UnsignedIntTy)
- return MatchPromotion;
- break;
- case BuiltinType::Int:
- case BuiltinType::UInt:
- if (T == C.SignedCharTy || T == C.UnsignedCharTy ||
- T == C.ShortTy || T == C.UnsignedShortTy || T == C.WCharTy ||
- T == C.WideCharTy)
- return MatchPromotion;
- break;
- case BuiltinType::Char_U:
- if (T == C.UnsignedIntTy)
- return MatchPromotion;
- if (T == C.UnsignedShortTy)
- return NoMatchPromotionTypeConfusion;
- break;
- case BuiltinType::Char_S:
- if (T == C.IntTy)
- return MatchPromotion;
- if (T == C.ShortTy)
- return NoMatchPromotionTypeConfusion;
- break;
- case BuiltinType::Half:
- case BuiltinType::Float:
- if (T == C.DoubleTy)
- return MatchPromotion;
- break;
- case BuiltinType::Short:
- case BuiltinType::UShort:
- if (T == C.SignedCharTy || T == C.UnsignedCharTy)
- return NoMatchPromotionTypeConfusion;
- break;
- case BuiltinType::WChar_U:
- case BuiltinType::WChar_S:
- if (T != C.WCharTy && T != C.WideCharTy)
- return NoMatchPromotionTypeConfusion;
- }
- }
+ default:
+ break;
+ case BuiltinType::Bool:
+ if (T == C.IntTy || T == C.UnsignedIntTy)
+ return MatchPromotion;
+ break;
+ case BuiltinType::Int:
+ case BuiltinType::UInt:
+ if (T == C.SignedCharTy || T == C.UnsignedCharTy || T == C.ShortTy ||
+ T == C.UnsignedShortTy || T == C.WCharTy || T == C.WideCharTy)
+ return MatchPromotion;
+ break;
+ case BuiltinType::Char_U:
+ if (T == C.UnsignedIntTy)
+ return MatchPromotion;
+ if (T == C.UnsignedShortTy)
+ return NoMatchPromotionTypeConfusion;
+ break;
+ case BuiltinType::Char_S:
+ if (T == C.IntTy)
+ return MatchPromotion;
+ if (T == C.ShortTy)
+ return NoMatchPromotionTypeConfusion;
+ break;
+ case BuiltinType::Half:
+ case BuiltinType::Float:
+ if (T == C.DoubleTy)
+ return MatchPromotion;
+ break;
+ case BuiltinType::Short:
+ case BuiltinType::UShort:
+ if (T == C.SignedCharTy || T == C.UnsignedCharTy)
+ return NoMatchPromotionTypeConfusion;
+ break;
+ case BuiltinType::WChar_U:
+ case BuiltinType::WChar_S:
+ if (T != C.WCharTy && T != C.WideCharTy)
+ return NoMatchPromotionTypeConfusion;
+ }
}
- return NoMatch;
}
+ return NoMatch;
+ }
- case CStrTy:
- if (const auto *PT = argTy->getAs<PointerType>();
- PT && PT->getPointeeType()->isCharType())
- return Match;
- return NoMatch;
+ case CStrTy:
+ if (const auto *PT = argTy->getAs<PointerType>();
+ PT && PT->getPointeeType()->isCharType())
+ return Match;
+ return NoMatch;
- case WCStrTy:
- if (const auto *PT = argTy->getAs<PointerType>();
- PT &&
- C.hasSameUnqualifiedType(PT->getPointeeType(), C.getWideCharType()))
- return Match;
- return NoMatch;
+ case WCStrTy:
+ if (const auto *PT = argTy->getAs<PointerType>();
+ PT &&
+ C.hasSameUnqualifiedType(PT->getPointeeType(), C.getWideCharType()))
+ return Match;
+ return NoMatch;
- case WIntTy: {
- QualType WInt = C.getCanonicalType(C.getWIntType()).getUnqualifiedType();
+ case WIntTy: {
+ QualType WInt = C.getCanonicalType(C.getWIntType()).getUnqualifiedType();
- if (C.getCanonicalType(argTy).getUnqualifiedType() == WInt)
- return Match;
+ if (C.getCanonicalType(argTy).getUnqualifiedType() == WInt)
+ return Match;
- QualType PromoArg = C.isPromotableIntegerType(argTy)
- ? C.getPromotedIntegerType(argTy)
- : argTy;
- PromoArg = C.getCanonicalType(PromoArg).getUnqualifiedType();
+ QualType PromoArg = C.isPromotableIntegerType(argTy)
+ ? C.getPromotedIntegerType(argTy)
+ : argTy;
+ PromoArg = C.getCanonicalType(PromoArg).getUnqualifiedType();
- // If the promoted argument is the corresponding signed type of the
- // wint_t type, then it should match.
- if (PromoArg->hasSignedIntegerRepresentation() &&
- C.getCorrespondingUnsignedType(PromoArg) == WInt)
- return Match;
+ // If the promoted argument is the corresponding signed type of the
+ // wint_t type, then it should match.
+ if (PromoArg->hasSignedIntegerRepresentation() &&
+ C.getCorrespondingUnsignedType(PromoArg) == WInt)
+ return Match;
+
+ return WInt == PromoArg ? Match : NoMatch;
+ }
- return WInt == PromoArg ? Match : NoMatch;
+ case CPointerTy:
+ if (const auto *PT = argTy->getAs<PointerType>()) {
+ QualType PointeeTy = PT->getPointeeType();
+ if (PointeeTy->isVoidType() || (!Ptr && PointeeTy->isCharType()))
+ return Match;
+ return NoMatchPedantic;
}
- case CPointerTy:
- if (const auto *PT = argTy->getAs<PointerType>()) {
- QualType PointeeTy = PT->getPointeeType();
- if (PointeeTy->isVoidType() || (!Ptr && PointeeTy->isCharType()))
- return Match;
- return NoMatchPedantic;
- }
+ // nullptr_t* is not a double pointer, so reject when something like
+ // void** is expected.
+ // In C++, nullptr is promoted to void*. In C23, va_arg(ap, void*) is not
+ // undefined when the next argument is of type nullptr_t.
+ if (!Ptr && argTy->isNullPtrType())
+ return C.getLangOpts().CPlusPlus ? MatchPromotion : Match;
- // nullptr_t* is not a double pointer, so reject when something like
- // void** is expected.
- // In C++, nullptr is promoted to void*. In C23, va_arg(ap, void*) is not
- // undefined when the next argument is of type nullptr_t.
- if (!Ptr && argTy->isNullPtrType())
- return C.getLangOpts().CPlusPlus ? MatchPromotion : Match;
+ if (argTy->isObjCObjectPointerType() || argTy->isBlockPointerType())
+ return NoMatchPedantic;
- if (argTy->isObjCObjectPointerType() || argTy->isBlockPointerType())
- return NoMatchPedantic;
+ return NoMatch;
- return NoMatch;
+ case ObjCPointerTy: {
+ if (argTy->getAs<ObjCObjectPointerType>() ||
+ argTy->getAs<BlockPointerType>())
+ return Match;
- case ObjCPointerTy: {
- if (argTy->getAs<ObjCObjectPointerType>() ||
- argTy->getAs<BlockPointerType>())
+ // Handle implicit toll-free bridging.
+ if (const PointerType *PT = argTy->getAs<PointerType>()) {
+ // Things such as CFTypeRef are really just opaque pointers
+ // to C structs representing CF types that can often be bridged
+ // to Objective-C objects. Since the compiler doesn't know which
+ // structs can be toll-free bridged, we just accept them all.
+ QualType pointee = PT->getPointeeType();
+ if (pointee->isStructureType() || pointee->isVoidType())
return Match;
-
- // Handle implicit toll-free bridging.
- if (const PointerType *PT = argTy->getAs<PointerType>()) {
- // Things such as CFTypeRef are really just opaque pointers
- // to C structs representing CF types that can often be bridged
- // to Objective-C objects. Since the compiler doesn't know which
- // structs can be toll-free bridged, we just accept them all.
- QualType pointee = PT->getPointeeType();
- if (pointee->isStructureType() || pointee->isVoidType())
- return Match;
- }
- return NoMatch;
}
+ return NoMatch;
+ }
}
llvm_unreachable("Invalid ArgType Kind!");
@@ -775,36 +777,36 @@ ArgType ArgType::makeVectorType(ASTContext &C, unsigned NumElts) const {
QualType ArgType::getRepresentativeType(ASTContext &C) const {
QualType Res;
switch (K) {
- case InvalidTy:
- llvm_unreachable("No representative type for Invalid ArgType");
- case UnknownTy:
- llvm_unreachable("No representative type for Unknown ArgType");
- case AnyCharTy:
- Res = C.CharTy;
- break;
- case SpecificTy:
- if (TK == TypeKind::Ptr
diff T || TK == TypeKind::SizeT)
- // Using Name as name, so no need to show the uglified name.
- Res = T->getCanonicalTypeInternal();
- else
- Res = T;
- break;
- case CStrTy:
- Res = C.getPointerType(C.CharTy);
- break;
- case WCStrTy:
- Res = C.getPointerType(C.getWideCharType());
- break;
- case ObjCPointerTy:
- Res = C.ObjCBuiltinIdTy;
- break;
- case CPointerTy:
- Res = C.VoidPtrTy;
- break;
- case WIntTy: {
- Res = C.getWIntType();
- break;
- }
+ case InvalidTy:
+ llvm_unreachable("No representative type for Invalid ArgType");
+ case UnknownTy:
+ llvm_unreachable("No representative type for Unknown ArgType");
+ case AnyCharTy:
+ Res = C.CharTy;
+ break;
+ case SpecificTy:
+ if (TK == TypeKind::Ptr
diff T || TK == TypeKind::SizeT)
+ // Using Name as name, so no need to show the uglified name.
+ Res = T->getCanonicalTypeInternal();
+ else
+ Res = T;
+ break;
+ case CStrTy:
+ Res = C.getPointerType(C.CharTy);
+ break;
+ case WCStrTy:
+ Res = C.getPointerType(C.getWideCharType());
+ break;
+ case ObjCPointerTy:
+ Res = C.ObjCBuiltinIdTy;
+ break;
+ case CPointerTy:
+ Res = C.VoidPtrTy;
+ break;
+ case WIntTy: {
+ Res = C.getWIntType();
+ break;
+ }
}
if (Ptr)
@@ -820,7 +822,7 @@ std::string ArgType::getRepresentativeTypeName(ASTContext &C) const {
Alias = Name;
if (Ptr) {
// If ArgType is actually a pointer to T, append an asterisk.
- Alias += (Alias[Alias.size()-1] == '*') ? "*" : " *";
+ Alias += (Alias[Alias.size() - 1] == '*') ? "*" : " *";
}
// If Alias is the same as the underlying type, e.g. wchar_t, then drop it.
if (S == Alias)
@@ -832,7 +834,6 @@ std::string ArgType::getRepresentativeTypeName(ASTContext &C) const {
return std::string("'") + S + "'";
}
-
//===----------------------------------------------------------------------===//
// Methods on OptionalAmount.
//===----------------------------------------------------------------------===//
@@ -846,8 +847,7 @@ analyze_format_string::OptionalAmount::getArgType(ASTContext &Ctx) const {
// Methods on LengthModifier.
//===----------------------------------------------------------------------===//
-const char *
-analyze_format_string::LengthModifier::toString() const {
+const char *analyze_format_string::LengthModifier::toString() const {
switch (kind) {
case AsChar:
return "hh";
@@ -893,53 +893,88 @@ analyze_format_string::LengthModifier::toString() const {
const char *ConversionSpecifier::toString() const {
switch (kind) {
- case bArg: return "b";
- case BArg: return "B";
- case dArg: return "d";
- case DArg: return "D";
- case iArg: return "i";
- case oArg: return "o";
- case OArg: return "O";
- case uArg: return "u";
- case UArg: return "U";
- case xArg: return "x";
- case XArg: return "X";
- case fArg: return "f";
- case FArg: return "F";
- case eArg: return "e";
- case EArg: return "E";
- case gArg: return "g";
- case GArg: return "G";
- case aArg: return "a";
- case AArg: return "A";
- case cArg: return "c";
- case sArg: return "s";
- case pArg: return "p";
+ case bArg:
+ return "b";
+ case BArg:
+ return "B";
+ case dArg:
+ return "d";
+ case DArg:
+ return "D";
+ case iArg:
+ return "i";
+ case oArg:
+ return "o";
+ case OArg:
+ return "O";
+ case uArg:
+ return "u";
+ case UArg:
+ return "U";
+ case xArg:
+ return "x";
+ case XArg:
+ return "X";
+ case fArg:
+ return "f";
+ case FArg:
+ return "F";
+ case eArg:
+ return "e";
+ case EArg:
+ return "E";
+ case gArg:
+ return "g";
+ case GArg:
+ return "G";
+ case aArg:
+ return "a";
+ case AArg:
+ return "A";
+ case cArg:
+ return "c";
+ case sArg:
+ return "s";
+ case pArg:
+ return "p";
case PArg:
return "P";
- case nArg: return "n";
- case PercentArg: return "%";
- case ScanListArg: return "[";
- case InvalidSpecifier: return nullptr;
+ case nArg:
+ return "n";
+ case PercentArg:
+ return "%";
+ case ScanListArg:
+ return "[";
+ case InvalidSpecifier:
+ return nullptr;
// POSIX unicode extensions.
- case CArg: return "C";
- case SArg: return "S";
+ case CArg:
+ return "C";
+ case SArg:
+ return "S";
// Objective-C specific specifiers.
- case ObjCObjArg: return "@";
+ case ObjCObjArg:
+ return "@";
// FreeBSD kernel specific specifiers.
- case FreeBSDbArg: return "b";
- case FreeBSDDArg: return "D";
- case FreeBSDrArg: return "r";
- case FreeBSDyArg: return "y";
+ case FreeBSDbArg:
+ return "b";
+ case FreeBSDDArg:
+ return "D";
+ case FreeBSDrArg:
+ return "r";
+ case FreeBSDyArg:
+ return "y";
// GlibC specific specifiers.
- case PrintErrno: return "m";
+ case PrintErrno:
+ return "m";
// MS specific specifiers.
- case ZArg: return "Z";
+ case ZArg:
+ return "Z";
// ISO/IEC TR 18037 (fixed-point) specific specifiers.
case rArg:
@@ -988,7 +1023,7 @@ void OptionalAmount::toString(raw_ostream &os) const {
return;
case Arg:
if (UsesDotPrefix)
- os << ".";
+ os << ".";
if (usesPositionalArg())
os << "*" << getPositionalArgIndex() << "$";
else
@@ -996,7 +1031,7 @@ void OptionalAmount::toString(raw_ostream &os) const {
break;
case Constant:
if (UsesDotPrefix)
- os << ".";
+ os << ".";
os << amt;
break;
}
@@ -1005,260 +1040,260 @@ void OptionalAmount::toString(raw_ostream &os) const {
bool FormatSpecifier::hasValidLengthModifier(const TargetInfo &Target,
const LangOptions &LO) const {
switch (LM.getKind()) {
- case LengthModifier::None:
- return true;
+ case LengthModifier::None:
+ return true;
- // Handle most integer flags
- case LengthModifier::AsShort:
- // Length modifier only applies to FP vectors.
- if (LO.OpenCL && CS.isDoubleArg())
- return !VectorNumElts.isInvalid();
+ // Handle most integer flags
+ case LengthModifier::AsShort:
+ // Length modifier only applies to FP vectors.
+ if (LO.OpenCL && CS.isDoubleArg())
+ return !VectorNumElts.isInvalid();
- if (CS.isFixedPointArg())
- return true;
+ if (CS.isFixedPointArg())
+ return true;
- if (Target.getTriple().isOSMSVCRT()) {
- switch (CS.getKind()) {
- case ConversionSpecifier::cArg:
- case ConversionSpecifier::CArg:
- case ConversionSpecifier::sArg:
- case ConversionSpecifier::SArg:
- case ConversionSpecifier::ZArg:
- return true;
- default:
- break;
- }
- }
- [[fallthrough]];
- case LengthModifier::AsChar:
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- case LengthModifier::AsIntMax:
- case LengthModifier::AsSizeT:
- case LengthModifier::AsPtrDiff:
+ if (Target.getTriple().isOSMSVCRT()) {
switch (CS.getKind()) {
- case ConversionSpecifier::bArg:
- case ConversionSpecifier::BArg:
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::DArg:
- case ConversionSpecifier::iArg:
- case ConversionSpecifier::oArg:
- case ConversionSpecifier::OArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::UArg:
- case ConversionSpecifier::xArg:
- case ConversionSpecifier::XArg:
- case ConversionSpecifier::nArg:
- return true;
- case ConversionSpecifier::FreeBSDrArg:
- case ConversionSpecifier::FreeBSDyArg:
- return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS();
- default:
- return false;
- }
-
- case LengthModifier::AsShortLong:
- return LO.OpenCL && !VectorNumElts.isInvalid();
-
- // Handle 'l' flag
- case LengthModifier::AsLong: // or AsWideChar
- if (CS.isDoubleArg()) {
- // Invalid for OpenCL FP scalars.
- if (LO.OpenCL && VectorNumElts.isInvalid())
- return false;
+ case ConversionSpecifier::cArg:
+ case ConversionSpecifier::CArg:
+ case ConversionSpecifier::sArg:
+ case ConversionSpecifier::SArg:
+ case ConversionSpecifier::ZArg:
return true;
+ default:
+ break;
}
+ }
+ [[fallthrough]];
+ case LengthModifier::AsChar:
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ case LengthModifier::AsIntMax:
+ case LengthModifier::AsSizeT:
+ case LengthModifier::AsPtrDiff:
+ switch (CS.getKind()) {
+ case ConversionSpecifier::bArg:
+ case ConversionSpecifier::BArg:
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::DArg:
+ case ConversionSpecifier::iArg:
+ case ConversionSpecifier::oArg:
+ case ConversionSpecifier::OArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::UArg:
+ case ConversionSpecifier::xArg:
+ case ConversionSpecifier::XArg:
+ case ConversionSpecifier::nArg:
+ return true;
+ case ConversionSpecifier::FreeBSDrArg:
+ case ConversionSpecifier::FreeBSDyArg:
+ return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS();
+ default:
+ return false;
+ }
- if (CS.isFixedPointArg())
- return true;
-
- switch (CS.getKind()) {
- case ConversionSpecifier::bArg:
- case ConversionSpecifier::BArg:
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::DArg:
- case ConversionSpecifier::iArg:
- case ConversionSpecifier::oArg:
- case ConversionSpecifier::OArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::UArg:
- case ConversionSpecifier::xArg:
- case ConversionSpecifier::XArg:
- case ConversionSpecifier::nArg:
- case ConversionSpecifier::cArg:
- case ConversionSpecifier::sArg:
- case ConversionSpecifier::ScanListArg:
- case ConversionSpecifier::ZArg:
- return true;
- case ConversionSpecifier::FreeBSDrArg:
- case ConversionSpecifier::FreeBSDyArg:
- return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS();
- default:
- return false;
- }
-
- case LengthModifier::AsLongDouble:
- switch (CS.getKind()) {
- case ConversionSpecifier::aArg:
- case ConversionSpecifier::AArg:
- case ConversionSpecifier::fArg:
- case ConversionSpecifier::FArg:
- case ConversionSpecifier::eArg:
- case ConversionSpecifier::EArg:
- case ConversionSpecifier::gArg:
- case ConversionSpecifier::GArg:
- return true;
- // GNU libc extension.
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::iArg:
- case ConversionSpecifier::oArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::xArg:
- case ConversionSpecifier::XArg:
- return !Target.getTriple().isOSDarwin() &&
- !Target.getTriple().isOSWindows();
- default:
- return false;
- }
-
- case LengthModifier::AsAllocate:
- switch (CS.getKind()) {
- case ConversionSpecifier::sArg:
- case ConversionSpecifier::SArg:
- case ConversionSpecifier::ScanListArg:
- return true;
- default:
- return false;
- }
+ case LengthModifier::AsShortLong:
+ return LO.OpenCL && !VectorNumElts.isInvalid();
- case LengthModifier::AsMAllocate:
- switch (CS.getKind()) {
- case ConversionSpecifier::cArg:
- case ConversionSpecifier::CArg:
- case ConversionSpecifier::sArg:
- case ConversionSpecifier::SArg:
- case ConversionSpecifier::ScanListArg:
- return true;
- default:
- return false;
- }
- case LengthModifier::AsInt32:
- case LengthModifier::AsInt3264:
- case LengthModifier::AsInt64:
- switch (CS.getKind()) {
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::iArg:
- case ConversionSpecifier::oArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::xArg:
- case ConversionSpecifier::XArg:
- return Target.getTriple().isOSMSVCRT();
- default:
- return false;
- }
- case LengthModifier::AsWide:
- switch (CS.getKind()) {
- case ConversionSpecifier::cArg:
- case ConversionSpecifier::CArg:
- case ConversionSpecifier::sArg:
- case ConversionSpecifier::SArg:
- case ConversionSpecifier::ZArg:
- return Target.getTriple().isOSMSVCRT();
- default:
- return false;
- }
- }
- llvm_unreachable("Invalid LengthModifier Kind!");
-}
+ // Handle 'l' flag
+ case LengthModifier::AsLong: // or AsWideChar
+ if (CS.isDoubleArg()) {
+ // Invalid for OpenCL FP scalars.
+ if (LO.OpenCL && VectorNumElts.isInvalid())
+ return false;
+ return true;
+ }
-bool FormatSpecifier::hasStandardLengthModifier() const {
- switch (LM.getKind()) {
- case LengthModifier::None:
- case LengthModifier::AsChar:
- case LengthModifier::AsShort:
- case LengthModifier::AsLong:
- case LengthModifier::AsLongLong:
- case LengthModifier::AsIntMax:
- case LengthModifier::AsSizeT:
- case LengthModifier::AsPtrDiff:
- case LengthModifier::AsLongDouble:
+ if (CS.isFixedPointArg())
return true;
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsQuad:
- case LengthModifier::AsInt32:
- case LengthModifier::AsInt3264:
- case LengthModifier::AsInt64:
- case LengthModifier::AsWide:
- case LengthModifier::AsShortLong: // ???
- return false;
- }
- llvm_unreachable("Invalid LengthModifier Kind!");
-}
-bool FormatSpecifier::hasStandardConversionSpecifier(
- const LangOptions &LangOpt) const {
- switch (CS.getKind()) {
+ switch (CS.getKind()) {
case ConversionSpecifier::bArg:
case ConversionSpecifier::BArg:
- case ConversionSpecifier::cArg:
case ConversionSpecifier::dArg:
+ case ConversionSpecifier::DArg:
case ConversionSpecifier::iArg:
case ConversionSpecifier::oArg:
+ case ConversionSpecifier::OArg:
case ConversionSpecifier::uArg:
+ case ConversionSpecifier::UArg:
case ConversionSpecifier::xArg:
case ConversionSpecifier::XArg:
+ case ConversionSpecifier::nArg:
+ case ConversionSpecifier::cArg:
+ case ConversionSpecifier::sArg:
+ case ConversionSpecifier::ScanListArg:
+ case ConversionSpecifier::ZArg:
+ return true;
+ case ConversionSpecifier::FreeBSDrArg:
+ case ConversionSpecifier::FreeBSDyArg:
+ return Target.getTriple().isOSFreeBSD() || Target.getTriple().isPS();
+ default:
+ return false;
+ }
+
+ case LengthModifier::AsLongDouble:
+ switch (CS.getKind()) {
+ case ConversionSpecifier::aArg:
+ case ConversionSpecifier::AArg:
case ConversionSpecifier::fArg:
case ConversionSpecifier::FArg:
case ConversionSpecifier::eArg:
case ConversionSpecifier::EArg:
case ConversionSpecifier::gArg:
case ConversionSpecifier::GArg:
- case ConversionSpecifier::aArg:
- case ConversionSpecifier::AArg:
+ return true;
+ // GNU libc extension.
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::iArg:
+ case ConversionSpecifier::oArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::xArg:
+ case ConversionSpecifier::XArg:
+ return !Target.getTriple().isOSDarwin() &&
+ !Target.getTriple().isOSWindows();
+ default:
+ return false;
+ }
+
+ case LengthModifier::AsAllocate:
+ switch (CS.getKind()) {
case ConversionSpecifier::sArg:
- case ConversionSpecifier::pArg:
- case ConversionSpecifier::nArg:
- case ConversionSpecifier::ObjCObjArg:
+ case ConversionSpecifier::SArg:
case ConversionSpecifier::ScanListArg:
- case ConversionSpecifier::PercentArg:
- case ConversionSpecifier::PArg:
return true;
+ default:
+ return false;
+ }
+
+ case LengthModifier::AsMAllocate:
+ switch (CS.getKind()) {
+ case ConversionSpecifier::cArg:
case ConversionSpecifier::CArg:
+ case ConversionSpecifier::sArg:
+ case ConversionSpecifier::SArg:
+ case ConversionSpecifier::ScanListArg:
+ return true;
+ default:
+ return false;
+ }
+ case LengthModifier::AsInt32:
+ case LengthModifier::AsInt3264:
+ case LengthModifier::AsInt64:
+ switch (CS.getKind()) {
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::iArg:
+ case ConversionSpecifier::oArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::xArg:
+ case ConversionSpecifier::XArg:
+ return Target.getTriple().isOSMSVCRT();
+ default:
+ return false;
+ }
+ case LengthModifier::AsWide:
+ switch (CS.getKind()) {
+ case ConversionSpecifier::cArg:
+ case ConversionSpecifier::CArg:
+ case ConversionSpecifier::sArg:
case ConversionSpecifier::SArg:
- return LangOpt.ObjC;
- case ConversionSpecifier::InvalidSpecifier:
- case ConversionSpecifier::FreeBSDbArg:
- case ConversionSpecifier::FreeBSDDArg:
- case ConversionSpecifier::FreeBSDrArg:
- case ConversionSpecifier::FreeBSDyArg:
- case ConversionSpecifier::PrintErrno:
- case ConversionSpecifier::DArg:
- case ConversionSpecifier::OArg:
- case ConversionSpecifier::UArg:
case ConversionSpecifier::ZArg:
+ return Target.getTriple().isOSMSVCRT();
+ default:
return false;
- case ConversionSpecifier::rArg:
- case ConversionSpecifier::RArg:
- case ConversionSpecifier::kArg:
- case ConversionSpecifier::KArg:
- return LangOpt.FixedPoint;
+ }
+ }
+ llvm_unreachable("Invalid LengthModifier Kind!");
+}
+
+bool FormatSpecifier::hasStandardLengthModifier() const {
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ case LengthModifier::AsChar:
+ case LengthModifier::AsShort:
+ case LengthModifier::AsLong:
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsIntMax:
+ case LengthModifier::AsSizeT:
+ case LengthModifier::AsPtrDiff:
+ case LengthModifier::AsLongDouble:
+ return true;
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsQuad:
+ case LengthModifier::AsInt32:
+ case LengthModifier::AsInt3264:
+ case LengthModifier::AsInt64:
+ case LengthModifier::AsWide:
+ case LengthModifier::AsShortLong: // ???
+ return false;
+ }
+ llvm_unreachable("Invalid LengthModifier Kind!");
+}
+
+bool FormatSpecifier::hasStandardConversionSpecifier(
+ const LangOptions &LangOpt) const {
+ switch (CS.getKind()) {
+ case ConversionSpecifier::bArg:
+ case ConversionSpecifier::BArg:
+ case ConversionSpecifier::cArg:
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::iArg:
+ case ConversionSpecifier::oArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::xArg:
+ case ConversionSpecifier::XArg:
+ case ConversionSpecifier::fArg:
+ case ConversionSpecifier::FArg:
+ case ConversionSpecifier::eArg:
+ case ConversionSpecifier::EArg:
+ case ConversionSpecifier::gArg:
+ case ConversionSpecifier::GArg:
+ case ConversionSpecifier::aArg:
+ case ConversionSpecifier::AArg:
+ case ConversionSpecifier::sArg:
+ case ConversionSpecifier::pArg:
+ case ConversionSpecifier::nArg:
+ case ConversionSpecifier::ObjCObjArg:
+ case ConversionSpecifier::ScanListArg:
+ case ConversionSpecifier::PercentArg:
+ case ConversionSpecifier::PArg:
+ return true;
+ case ConversionSpecifier::CArg:
+ case ConversionSpecifier::SArg:
+ return LangOpt.ObjC;
+ case ConversionSpecifier::InvalidSpecifier:
+ case ConversionSpecifier::FreeBSDbArg:
+ case ConversionSpecifier::FreeBSDDArg:
+ case ConversionSpecifier::FreeBSDrArg:
+ case ConversionSpecifier::FreeBSDyArg:
+ case ConversionSpecifier::PrintErrno:
+ case ConversionSpecifier::DArg:
+ case ConversionSpecifier::OArg:
+ case ConversionSpecifier::UArg:
+ case ConversionSpecifier::ZArg:
+ return false;
+ case ConversionSpecifier::rArg:
+ case ConversionSpecifier::RArg:
+ case ConversionSpecifier::kArg:
+ case ConversionSpecifier::KArg:
+ return LangOpt.FixedPoint;
}
llvm_unreachable("Invalid ConversionSpecifier Kind!");
}
bool FormatSpecifier::hasStandardLengthConversionCombination() const {
if (LM.getKind() == LengthModifier::AsLongDouble) {
- switch(CS.getKind()) {
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::iArg:
- case ConversionSpecifier::oArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::xArg:
- case ConversionSpecifier::XArg:
- return false;
- default:
- return true;
+ switch (CS.getKind()) {
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::iArg:
+ case ConversionSpecifier::oArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::xArg:
+ case ConversionSpecifier::XArg:
+ return false;
+ default:
+ return true;
}
}
return true;
diff --git a/clang/lib/AST/FormatStringParsing.h b/clang/lib/AST/FormatStringParsing.h
index 764e5d46394d7..401528481a9d6 100644
--- a/clang/lib/AST/FormatStringParsing.h
+++ b/clang/lib/AST/FormatStringParsing.h
@@ -15,24 +15,22 @@
#define LLVM_CLANG_LIB_ANALYSIS_FORMATSTRINGPARSING_H
#include "clang/AST/ASTContext.h"
-#include "clang/AST/Type.h"
#include "clang/AST/FormatString.h"
+#include "clang/AST/Type.h"
namespace clang {
class LangOptions;
-template <typename T>
-class UpdateOnReturn {
+template <typename T> class UpdateOnReturn {
T &ValueToUpdate;
const T &ValueToCopy;
+
public:
UpdateOnReturn(T &valueToUpdate, const T &valueToCopy)
- : ValueToUpdate(valueToUpdate), ValueToCopy(valueToCopy) {}
+ : ValueToUpdate(valueToUpdate), ValueToCopy(valueToCopy) {}
- ~UpdateOnReturn() {
- ValueToUpdate = ValueToCopy;
- }
+ ~UpdateOnReturn() { ValueToUpdate = ValueToCopy; }
};
namespace analyze_format_string {
@@ -41,21 +39,19 @@ OptionalAmount ParseAmount(const char *&Beg, const char *E);
OptionalAmount ParseNonPositionAmount(const char *&Beg, const char *E,
unsigned &argIndex);
-OptionalAmount ParsePositionAmount(FormatStringHandler &H,
- const char *Start, const char *&Beg,
- const char *E, PositionContext p);
+OptionalAmount ParsePositionAmount(FormatStringHandler &H, const char *Start,
+ const char *&Beg, const char *E,
+ PositionContext p);
-bool ParseFieldWidth(FormatStringHandler &H,
- FormatSpecifier &CS,
+bool ParseFieldWidth(FormatStringHandler &H, FormatSpecifier &CS,
const char *Start, const char *&Beg, const char *E,
unsigned *argIndex);
-bool ParseArgPosition(FormatStringHandler &H,
- FormatSpecifier &CS, const char *Start,
- const char *&Beg, const char *E);
+bool ParseArgPosition(FormatStringHandler &H, FormatSpecifier &CS,
+ const char *Start, const char *&Beg, const char *E);
-bool ParseVectorModifier(FormatStringHandler &H,
- FormatSpecifier &FS, const char *&Beg, const char *E,
+bool ParseVectorModifier(FormatStringHandler &H, FormatSpecifier &FS,
+ const char *&Beg, const char *E,
const LangOptions &LO);
/// Returns true if a LengthModifier was parsed and installed in the
@@ -73,12 +69,11 @@ template <typename T> class SpecifierResult {
T FS;
const char *Start;
bool Stop;
+
public:
- SpecifierResult(bool stop = false)
- : Start(nullptr), Stop(stop) {}
- SpecifierResult(const char *start,
- const T &fs)
- : FS(fs), Start(start), Stop(false) {}
+ SpecifierResult(bool stop = false) : Start(nullptr), Stop(stop) {}
+ SpecifierResult(const char *start, const T &fs)
+ : FS(fs), Start(start), Stop(false) {}
const char *getStart() const { return Start; }
bool shouldStop() const { return Stop; }
@@ -90,7 +85,7 @@ template <typename T> class SpecifierResult {
const T &getValue() { return FS; }
};
-} // end analyze_format_string namespace
-} // end clang namespace
+} // namespace analyze_format_string
+} // namespace clang
#endif
diff --git a/clang/lib/AST/PrintfFormatString.cpp b/clang/lib/AST/PrintfFormatString.cpp
index 855550475721a..6610a2de9e083 100644
--- a/clang/lib/AST/PrintfFormatString.cpp
+++ b/clang/lib/AST/PrintfFormatString.cpp
@@ -18,16 +18,16 @@
#include "llvm/Support/Regex.h"
using clang::analyze_format_string::ArgType;
+using clang::analyze_format_string::ConversionSpecifier;
using clang::analyze_format_string::FormatStringHandler;
using clang::analyze_format_string::LengthModifier;
using clang::analyze_format_string::OptionalAmount;
-using clang::analyze_format_string::ConversionSpecifier;
using clang::analyze_printf::PrintfSpecifier;
using namespace clang;
typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
- PrintfSpecifierResult;
+ PrintfSpecifierResult;
//===----------------------------------------------------------------------===//
// Methods for parsing format strings.
@@ -41,8 +41,8 @@ static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
if (argIndex) {
FS.setPrecision(ParseNonPositionAmount(Beg, E, *argIndex));
} else {
- const OptionalAmount Amt = ParsePositionAmount(H, Start, Beg, E,
- analyze_format_string::PrecisionPos);
+ const OptionalAmount Amt = ParsePositionAmount(
+ H, Start, Beg, E, analyze_format_string::PrecisionPos);
if (Amt.isInvalid())
return true;
FS.setPrecision(Amt);
@@ -52,40 +52,37 @@ static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
static bool ParseObjCFlags(FormatStringHandler &H, PrintfSpecifier &FS,
const char *FlagBeg, const char *E, bool Warn) {
- StringRef Flag(FlagBeg, E - FlagBeg);
- // Currently there is only one flag.
- if (Flag == "tt") {
- FS.setHasObjCTechnicalTerm(FlagBeg);
- return false;
- }
- // Handle either the case of no flag or an invalid flag.
- if (Warn) {
- if (Flag == "")
- H.HandleEmptyObjCModifierFlag(FlagBeg, E - FlagBeg);
- else
- H.HandleInvalidObjCModifierFlag(FlagBeg, E - FlagBeg);
- }
- return true;
+ StringRef Flag(FlagBeg, E - FlagBeg);
+ // Currently there is only one flag.
+ if (Flag == "tt") {
+ FS.setHasObjCTechnicalTerm(FlagBeg);
+ return false;
+ }
+ // Handle either the case of no flag or an invalid flag.
+ if (Warn) {
+ if (Flag == "")
+ H.HandleEmptyObjCModifierFlag(FlagBeg, E - FlagBeg);
+ else
+ H.HandleInvalidObjCModifierFlag(FlagBeg, E - FlagBeg);
+ }
+ return true;
}
-static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
- const char *&Beg,
- const char *E,
- unsigned &argIndex,
- const LangOptions &LO,
- const TargetInfo &Target,
- bool Warn,
- bool isFreeBSDKPrintf) {
+static PrintfSpecifierResult
+ParsePrintfSpecifier(FormatStringHandler &H, const char *&Beg, const char *E,
+ unsigned &argIndex, const LangOptions &LO,
+ const TargetInfo &Target, bool Warn,
+ bool isFreeBSDKPrintf) {
using namespace clang::analyze_format_string;
using namespace clang::analyze_printf;
const char *I = Beg;
const char *Start = nullptr;
- UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+ UpdateOnReturn<const char *> UpdateBeg(Beg, I);
// Look for a '%' character that indicates the start of a format specifier.
- for ( ; I != E ; ++I) {
+ for (; I != E; ++I) {
char c = *I;
if (c == '\0') {
// Detect spurious null characters, which are likely errors.
@@ -93,7 +90,7 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
return true;
}
if (c == '%') {
- Start = I++; // Record the start of the format specifier.
+ Start = I++; // Record the start of the format specifier.
break;
}
}
@@ -190,18 +187,30 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
// Look for flags (if any).
bool hasMore = true;
- for ( ; I != E; ++I) {
+ for (; I != E; ++I) {
switch (*I) {
- default: hasMore = false; break;
- case '\'':
- // FIXME: POSIX specific. Always accept?
- FS.setHasThousandsGrouping(I);
- break;
- case '-': FS.setIsLeftJustified(I); break;
- case '+': FS.setHasPlusPrefix(I); break;
- case ' ': FS.setHasSpacePrefix(I); break;
- case '#': FS.setHasAlternativeForm(I); break;
- case '0': FS.setHasLeadingZeros(I); break;
+ default:
+ hasMore = false;
+ break;
+ case '\'':
+ // FIXME: POSIX specific. Always accept?
+ FS.setHasThousandsGrouping(I);
+ break;
+ case '-':
+ FS.setIsLeftJustified(I);
+ break;
+ case '+':
+ FS.setHasPlusPrefix(I);
+ break;
+ case ' ':
+ FS.setHasSpacePrefix(I);
+ break;
+ case '#':
+ FS.setHasAlternativeForm(I);
+ break;
+ case '0':
+ FS.setHasLeadingZeros(I);
+ break;
}
if (!hasMore)
break;
@@ -264,8 +273,7 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
// later if the conversion specifier isn't '@'. This
// enables better recovery, and we don't know if
// these flags are applicable until later.
- const char *ObjCModifierFlagsStart = nullptr,
- *ObjCModifierFlagsEnd = nullptr;
+ const char *ObjCModifierFlagsStart = nullptr, *ObjCModifierFlagsEnd = nullptr;
if (*I == '[') {
ObjCModifierFlagsStart = I;
++I;
@@ -300,105 +308,149 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
const char *conversionPosition = I++;
ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
switch (*conversionPosition) {
- default:
- break;
- // C99: 7.19.6.1 (section 8).
- case '%': k = ConversionSpecifier::PercentArg; break;
- case 'A': k = ConversionSpecifier::AArg; break;
- case 'E': k = ConversionSpecifier::EArg; break;
- case 'F': k = ConversionSpecifier::FArg; break;
- case 'G': k = ConversionSpecifier::GArg; break;
- case 'X': k = ConversionSpecifier::XArg; break;
- case 'a': k = ConversionSpecifier::aArg; break;
- case 'c': k = ConversionSpecifier::cArg; break;
- case 'd': k = ConversionSpecifier::dArg; break;
- case 'e': k = ConversionSpecifier::eArg; break;
- case 'f': k = ConversionSpecifier::fArg; break;
- case 'g': k = ConversionSpecifier::gArg; break;
- case 'i': k = ConversionSpecifier::iArg; break;
- case 'n':
- // Not handled, but reserved in OpenCL.
- if (!LO.OpenCL)
- k = ConversionSpecifier::nArg;
- break;
- case 'o': k = ConversionSpecifier::oArg; break;
- case 'p': k = ConversionSpecifier::pArg; break;
- case 's': k = ConversionSpecifier::sArg; break;
- case 'u': k = ConversionSpecifier::uArg; break;
- case 'x': k = ConversionSpecifier::xArg; break;
- // C23.
- case 'b':
- if (isFreeBSDKPrintf)
- k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
- else
- k = ConversionSpecifier::bArg;
- break;
- case 'B': k = ConversionSpecifier::BArg; break;
- // POSIX specific.
- case 'C': k = ConversionSpecifier::CArg; break;
- case 'S': k = ConversionSpecifier::SArg; break;
- // Apple extension for os_log
- case 'P':
- k = ConversionSpecifier::PArg;
- break;
- // Objective-C.
- case '@': k = ConversionSpecifier::ObjCObjArg; break;
- // Glibc specific.
- case 'm': k = ConversionSpecifier::PrintErrno; break;
- case 'r':
- if (isFreeBSDKPrintf)
- k = ConversionSpecifier::FreeBSDrArg; // int
- else if (LO.FixedPoint)
- k = ConversionSpecifier::rArg;
- break;
- case 'y':
- if (isFreeBSDKPrintf)
- k = ConversionSpecifier::FreeBSDyArg; // int
- break;
- // Apple-specific.
- case 'D':
- if (isFreeBSDKPrintf)
- k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
- else if (Target.getTriple().isOSDarwin())
- k = ConversionSpecifier::DArg;
- break;
- case 'O':
- if (Target.getTriple().isOSDarwin())
- k = ConversionSpecifier::OArg;
- break;
- case 'U':
- if (Target.getTriple().isOSDarwin())
- k = ConversionSpecifier::UArg;
- break;
- // MS specific.
- case 'Z':
- if (Target.getTriple().isOSMSVCRT())
- k = ConversionSpecifier::ZArg;
- break;
- // ISO/IEC TR 18037 (fixed-point) specific.
- // NOTE: 'r' is handled up above since FreeBSD also supports %r.
- case 'k':
- if (LO.FixedPoint)
- k = ConversionSpecifier::kArg;
- break;
- case 'K':
- if (LO.FixedPoint)
- k = ConversionSpecifier::KArg;
- break;
- case 'R':
- if (LO.FixedPoint)
- k = ConversionSpecifier::RArg;
- break;
+ default:
+ break;
+ // C99: 7.19.6.1 (section 8).
+ case '%':
+ k = ConversionSpecifier::PercentArg;
+ break;
+ case 'A':
+ k = ConversionSpecifier::AArg;
+ break;
+ case 'E':
+ k = ConversionSpecifier::EArg;
+ break;
+ case 'F':
+ k = ConversionSpecifier::FArg;
+ break;
+ case 'G':
+ k = ConversionSpecifier::GArg;
+ break;
+ case 'X':
+ k = ConversionSpecifier::XArg;
+ break;
+ case 'a':
+ k = ConversionSpecifier::aArg;
+ break;
+ case 'c':
+ k = ConversionSpecifier::cArg;
+ break;
+ case 'd':
+ k = ConversionSpecifier::dArg;
+ break;
+ case 'e':
+ k = ConversionSpecifier::eArg;
+ break;
+ case 'f':
+ k = ConversionSpecifier::fArg;
+ break;
+ case 'g':
+ k = ConversionSpecifier::gArg;
+ break;
+ case 'i':
+ k = ConversionSpecifier::iArg;
+ break;
+ case 'n':
+ // Not handled, but reserved in OpenCL.
+ if (!LO.OpenCL)
+ k = ConversionSpecifier::nArg;
+ break;
+ case 'o':
+ k = ConversionSpecifier::oArg;
+ break;
+ case 'p':
+ k = ConversionSpecifier::pArg;
+ break;
+ case 's':
+ k = ConversionSpecifier::sArg;
+ break;
+ case 'u':
+ k = ConversionSpecifier::uArg;
+ break;
+ case 'x':
+ k = ConversionSpecifier::xArg;
+ break;
+ // C23.
+ case 'b':
+ if (isFreeBSDKPrintf)
+ k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
+ else
+ k = ConversionSpecifier::bArg;
+ break;
+ case 'B':
+ k = ConversionSpecifier::BArg;
+ break;
+ // POSIX specific.
+ case 'C':
+ k = ConversionSpecifier::CArg;
+ break;
+ case 'S':
+ k = ConversionSpecifier::SArg;
+ break;
+ // Apple extension for os_log
+ case 'P':
+ k = ConversionSpecifier::PArg;
+ break;
+ // Objective-C.
+ case '@':
+ k = ConversionSpecifier::ObjCObjArg;
+ break;
+ // Glibc specific.
+ case 'm':
+ k = ConversionSpecifier::PrintErrno;
+ break;
+ case 'r':
+ if (isFreeBSDKPrintf)
+ k = ConversionSpecifier::FreeBSDrArg; // int
+ else if (LO.FixedPoint)
+ k = ConversionSpecifier::rArg;
+ break;
+ case 'y':
+ if (isFreeBSDKPrintf)
+ k = ConversionSpecifier::FreeBSDyArg; // int
+ break;
+ // Apple-specific.
+ case 'D':
+ if (isFreeBSDKPrintf)
+ k = ConversionSpecifier::FreeBSDDArg; // void * followed by char *
+ else if (Target.getTriple().isOSDarwin())
+ k = ConversionSpecifier::DArg;
+ break;
+ case 'O':
+ if (Target.getTriple().isOSDarwin())
+ k = ConversionSpecifier::OArg;
+ break;
+ case 'U':
+ if (Target.getTriple().isOSDarwin())
+ k = ConversionSpecifier::UArg;
+ break;
+ // MS specific.
+ case 'Z':
+ if (Target.getTriple().isOSMSVCRT())
+ k = ConversionSpecifier::ZArg;
+ break;
+ // ISO/IEC TR 18037 (fixed-point) specific.
+ // NOTE: 'r' is handled up above since FreeBSD also supports %r.
+ case 'k':
+ if (LO.FixedPoint)
+ k = ConversionSpecifier::kArg;
+ break;
+ case 'K':
+ if (LO.FixedPoint)
+ k = ConversionSpecifier::KArg;
+ break;
+ case 'R':
+ if (LO.FixedPoint)
+ k = ConversionSpecifier::RArg;
+ break;
}
// Check to see if we used the Objective-C modifier flags with
// a conversion specifier other than '@'.
if (k != ConversionSpecifier::ObjCObjArg &&
- k != ConversionSpecifier::InvalidSpecifier &&
- ObjCModifierFlagsStart) {
- H.HandleObjCFlagsWithNonObjCConversion(ObjCModifierFlagsStart,
- ObjCModifierFlagsEnd + 1,
- conversionPosition);
+ k != ConversionSpecifier::InvalidSpecifier && ObjCModifierFlagsStart) {
+ H.HandleObjCFlagsWithNonObjCConversion(
+ ObjCModifierFlagsStart, ObjCModifierFlagsEnd + 1, conversionPosition);
return true;
}
@@ -423,20 +475,16 @@ static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
return PrintfSpecifierResult(Start, FS);
}
-bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
- const char *I,
- const char *E,
- const LangOptions &LO,
- const TargetInfo &Target,
- bool isFreeBSDKPrintf) {
+bool clang::analyze_format_string::ParsePrintfString(
+ FormatStringHandler &H, const char *I, const char *E, const LangOptions &LO,
+ const TargetInfo &Target, bool isFreeBSDKPrintf) {
unsigned argIndex = 0;
// Keep looking for a format specifier until we have exhausted the string.
while (I != E) {
- const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
- LO, Target, true,
- isFreeBSDKPrintf);
+ const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(
+ H, I, E, argIndex, LO, Target, true, isFreeBSDKPrintf);
// Did a fail-stop error of any kind occur when parsing the specifier?
// If so, don't do any more processing.
if (FSR.shouldStop())
@@ -454,19 +502,17 @@ bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
return false;
}
-bool clang::analyze_format_string::ParseFormatStringHasSArg(const char *I,
- const char *E,
- const LangOptions &LO,
- const TargetInfo &Target) {
+bool clang::analyze_format_string::ParseFormatStringHasSArg(
+ const char *I, const char *E, const LangOptions &LO,
+ const TargetInfo &Target) {
unsigned argIndex = 0;
// Keep looking for a %s format specifier until we have exhausted the string.
FormatStringHandler H;
while (I != E) {
- const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
- LO, Target, false,
- false);
+ const PrintfSpecifierResult &FSR =
+ ParsePrintfSpecifier(H, I, E, argIndex, LO, Target, false, false);
// Did a fail-stop error of any kind occur when parsing the specifier?
// If so, don't do any more processing.
if (FSR.shouldStop())
@@ -477,7 +523,8 @@ bool clang::analyze_format_string::ParseFormatStringHasSArg(const char *I,
continue;
const analyze_printf::PrintfSpecifier &FS = FSR.getValue();
// Return true if this a %s format specifier.
- if (FS.getConversionSpecifier().getKind() == ConversionSpecifier::Kind::sArg)
+ if (FS.getConversionSpecifier().getKind() ==
+ ConversionSpecifier::Kind::sArg)
return true;
}
return false;
@@ -508,89 +555,94 @@ ArgType PrintfSpecifier::getScalarArgType(ASTContext &Ctx,
bool IsObjCLiteral) const {
if (CS.getKind() == ConversionSpecifier::cArg)
switch (LM.getKind()) {
- case LengthModifier::None:
+ case LengthModifier::None:
+ return Ctx.IntTy;
+ case LengthModifier::AsLong:
+ case LengthModifier::AsWide:
+ return ArgType(ArgType::WIntTy, "wint_t");
+ case LengthModifier::AsShort:
+ if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
return Ctx.IntTy;
- case LengthModifier::AsLong:
- case LengthModifier::AsWide:
- return ArgType(ArgType::WIntTy, "wint_t");
- case LengthModifier::AsShort:
- if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
- return Ctx.IntTy;
- [[fallthrough]];
- default:
- return ArgType::Invalid();
+ [[fallthrough]];
+ default:
+ return ArgType::Invalid();
}
if (CS.isIntArg())
switch (LM.getKind()) {
- case LengthModifier::AsLongDouble:
- // GNU extension.
- return Ctx.LongLongTy;
- case LengthModifier::None:
- case LengthModifier::AsShortLong:
- return Ctx.IntTy;
- case LengthModifier::AsInt32:
- return ArgType(Ctx.IntTy, "__int32");
- case LengthModifier::AsChar:
- return ArgType::AnyCharTy;
- case LengthModifier::AsShort: return Ctx.ShortTy;
- case LengthModifier::AsLong: return Ctx.LongTy;
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- return Ctx.LongLongTy;
- case LengthModifier::AsInt64:
- return ArgType(Ctx.LongLongTy, "__int64");
- case LengthModifier::AsIntMax:
- return ArgType(Ctx.getIntMaxType(), "intmax_t");
- case LengthModifier::AsSizeT:
- return ArgType::makeSizeT(
- ArgType(Ctx.getSignedSizeType(), "signed size_t"));
- case LengthModifier::AsInt3264:
- return Ctx.getTargetInfo().getTriple().isArch64Bit()
- ? ArgType(Ctx.LongLongTy, "__int64")
- : ArgType(Ctx.IntTy, "__int32");
- case LengthModifier::AsPtrDiff:
- return ArgType::makePtr
diff T(
- ArgType(Ctx.getPointerDiffType(), "ptr
diff _t"));
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsWide:
- return ArgType::Invalid();
+ case LengthModifier::AsLongDouble:
+ // GNU extension.
+ return Ctx.LongLongTy;
+ case LengthModifier::None:
+ case LengthModifier::AsShortLong:
+ return Ctx.IntTy;
+ case LengthModifier::AsInt32:
+ return ArgType(Ctx.IntTy, "__int32");
+ case LengthModifier::AsChar:
+ return ArgType::AnyCharTy;
+ case LengthModifier::AsShort:
+ return Ctx.ShortTy;
+ case LengthModifier::AsLong:
+ return Ctx.LongTy;
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ return Ctx.LongLongTy;
+ case LengthModifier::AsInt64:
+ return ArgType(Ctx.LongLongTy, "__int64");
+ case LengthModifier::AsIntMax:
+ return ArgType(Ctx.getIntMaxType(), "intmax_t");
+ case LengthModifier::AsSizeT:
+ return ArgType::makeSizeT(
+ ArgType(Ctx.getSignedSizeType(), "signed size_t"));
+ case LengthModifier::AsInt3264:
+ return Ctx.getTargetInfo().getTriple().isArch64Bit()
+ ? ArgType(Ctx.LongLongTy, "__int64")
+ : ArgType(Ctx.IntTy, "__int32");
+ case LengthModifier::AsPtrDiff:
+ return ArgType::makePtr
diff T(
+ ArgType(Ctx.getPointerDiffType(), "ptr
diff _t"));
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsWide:
+ return ArgType::Invalid();
}
if (CS.isUIntArg())
switch (LM.getKind()) {
- case LengthModifier::AsLongDouble:
- // GNU extension.
- return Ctx.UnsignedLongLongTy;
- case LengthModifier::None:
- case LengthModifier::AsShortLong:
- return Ctx.UnsignedIntTy;
- case LengthModifier::AsInt32:
- return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
- case LengthModifier::AsChar: return Ctx.UnsignedCharTy;
- case LengthModifier::AsShort: return Ctx.UnsignedShortTy;
- case LengthModifier::AsLong: return Ctx.UnsignedLongTy;
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- return Ctx.UnsignedLongLongTy;
- case LengthModifier::AsInt64:
- return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
- case LengthModifier::AsIntMax:
- return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
- case LengthModifier::AsSizeT:
- return ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t"));
- case LengthModifier::AsInt3264:
- return Ctx.getTargetInfo().getTriple().isArch64Bit()
- ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
- : ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
- case LengthModifier::AsPtrDiff:
- return ArgType::makePtr
diff T(
- ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptr
diff _t"));
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsWide:
- return ArgType::Invalid();
+ case LengthModifier::AsLongDouble:
+ // GNU extension.
+ return Ctx.UnsignedLongLongTy;
+ case LengthModifier::None:
+ case LengthModifier::AsShortLong:
+ return Ctx.UnsignedIntTy;
+ case LengthModifier::AsInt32:
+ return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
+ case LengthModifier::AsChar:
+ return Ctx.UnsignedCharTy;
+ case LengthModifier::AsShort:
+ return Ctx.UnsignedShortTy;
+ case LengthModifier::AsLong:
+ return Ctx.UnsignedLongTy;
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ return Ctx.UnsignedLongLongTy;
+ case LengthModifier::AsInt64:
+ return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
+ case LengthModifier::AsIntMax:
+ return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
+ case LengthModifier::AsSizeT:
+ return ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t"));
+ case LengthModifier::AsInt3264:
+ return Ctx.getTargetInfo().getTriple().isArch64Bit()
+ ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
+ : ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
+ case LengthModifier::AsPtrDiff:
+ return ArgType::makePtr
diff T(
+ ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptr
diff _t"));
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsWide:
+ return ArgType::Invalid();
}
if (CS.isDoubleArg()) {
@@ -613,36 +665,36 @@ ArgType PrintfSpecifier::getScalarArgType(ASTContext &Ctx,
if (CS.getKind() == ConversionSpecifier::nArg) {
switch (LM.getKind()) {
- case LengthModifier::None:
- return ArgType::PtrTo(Ctx.IntTy);
- case LengthModifier::AsChar:
- return ArgType::PtrTo(Ctx.SignedCharTy);
- case LengthModifier::AsShort:
- return ArgType::PtrTo(Ctx.ShortTy);
- case LengthModifier::AsLong:
- return ArgType::PtrTo(Ctx.LongTy);
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- return ArgType::PtrTo(Ctx.LongLongTy);
- case LengthModifier::AsIntMax:
- return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
- case LengthModifier::AsSizeT:
- return ArgType::PtrTo(ArgType::makeSizeT(
- ArgType(Ctx.getSignedSizeType(), "signed size_t")));
- case LengthModifier::AsPtrDiff:
- return ArgType::PtrTo(ArgType::makePtr
diff T(
- ArgType(Ctx.getPointerDiffType(), "ptr
diff _t")));
- case LengthModifier::AsLongDouble:
- return ArgType(); // FIXME: Is this a known extension?
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsInt32:
- case LengthModifier::AsInt3264:
- case LengthModifier::AsInt64:
- case LengthModifier::AsWide:
- return ArgType::Invalid();
- case LengthModifier::AsShortLong:
- llvm_unreachable("only used for OpenCL which doesn not handle nArg");
+ case LengthModifier::None:
+ return ArgType::PtrTo(Ctx.IntTy);
+ case LengthModifier::AsChar:
+ return ArgType::PtrTo(Ctx.SignedCharTy);
+ case LengthModifier::AsShort:
+ return ArgType::PtrTo(Ctx.ShortTy);
+ case LengthModifier::AsLong:
+ return ArgType::PtrTo(Ctx.LongTy);
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ return ArgType::PtrTo(Ctx.LongLongTy);
+ case LengthModifier::AsIntMax:
+ return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
+ case LengthModifier::AsSizeT:
+ return ArgType::PtrTo(ArgType::makeSizeT(
+ ArgType(Ctx.getSignedSizeType(), "signed size_t")));
+ case LengthModifier::AsPtrDiff:
+ return ArgType::PtrTo(ArgType::makePtr
diff T(
+ ArgType(Ctx.getPointerDiffType(), "ptr
diff _t")));
+ case LengthModifier::AsLongDouble:
+ return ArgType(); // FIXME: Is this a known extension?
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsInt32:
+ case LengthModifier::AsInt3264:
+ case LengthModifier::AsInt64:
+ case LengthModifier::AsWide:
+ return ArgType::Invalid();
+ case LengthModifier::AsShortLong:
+ llvm_unreachable("only used for OpenCL which doesn not handle nArg");
}
}
@@ -650,91 +702,89 @@ ArgType PrintfSpecifier::getScalarArgType(ASTContext &Ctx,
return ArgType::Invalid();
switch (CS.getKind()) {
- case ConversionSpecifier::sArg:
- if (LM.getKind() == LengthModifier::AsWideChar) {
- if (IsObjCLiteral)
- return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
- "const unichar *");
- return ArgType(ArgType::WCStrTy, "wchar_t *");
- }
- if (LM.getKind() == LengthModifier::AsWide)
- return ArgType(ArgType::WCStrTy, "wchar_t *");
- return ArgType::CStrTy;
- case ConversionSpecifier::SArg:
+ case ConversionSpecifier::sArg:
+ if (LM.getKind() == LengthModifier::AsWideChar) {
if (IsObjCLiteral)
return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
"const unichar *");
- if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
- LM.getKind() == LengthModifier::AsShort)
- return ArgType::CStrTy;
return ArgType(ArgType::WCStrTy, "wchar_t *");
- case ConversionSpecifier::CArg:
- if (IsObjCLiteral)
- return ArgType(Ctx.UnsignedShortTy, "unichar");
- if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
- LM.getKind() == LengthModifier::AsShort)
- return Ctx.IntTy;
- return ArgType(Ctx.WideCharTy, "wchar_t");
- case ConversionSpecifier::pArg:
- case ConversionSpecifier::PArg:
- return ArgType::CPointerTy;
- case ConversionSpecifier::ObjCObjArg:
- return ArgType::ObjCPointerTy;
- case ConversionSpecifier::kArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return Ctx.AccumTy;
- case LengthModifier::AsShort:
- return Ctx.ShortAccumTy;
- case LengthModifier::AsLong:
- return Ctx.LongAccumTy;
- default:
- return ArgType::Invalid();
- }
- case ConversionSpecifier::KArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return Ctx.UnsignedAccumTy;
- case LengthModifier::AsShort:
- return Ctx.UnsignedShortAccumTy;
- case LengthModifier::AsLong:
- return Ctx.UnsignedLongAccumTy;
- default:
- return ArgType::Invalid();
- }
- case ConversionSpecifier::rArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return Ctx.FractTy;
- case LengthModifier::AsShort:
- return Ctx.ShortFractTy;
- case LengthModifier::AsLong:
- return Ctx.LongFractTy;
- default:
- return ArgType::Invalid();
- }
- case ConversionSpecifier::RArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return Ctx.UnsignedFractTy;
- case LengthModifier::AsShort:
- return Ctx.UnsignedShortFractTy;
- case LengthModifier::AsLong:
- return Ctx.UnsignedLongFractTy;
- default:
- return ArgType::Invalid();
- }
+ }
+ if (LM.getKind() == LengthModifier::AsWide)
+ return ArgType(ArgType::WCStrTy, "wchar_t *");
+ return ArgType::CStrTy;
+ case ConversionSpecifier::SArg:
+ if (IsObjCLiteral)
+ return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
+ "const unichar *");
+ if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
+ LM.getKind() == LengthModifier::AsShort)
+ return ArgType::CStrTy;
+ return ArgType(ArgType::WCStrTy, "wchar_t *");
+ case ConversionSpecifier::CArg:
+ if (IsObjCLiteral)
+ return ArgType(Ctx.UnsignedShortTy, "unichar");
+ if (Ctx.getTargetInfo().getTriple().isOSMSVCRT() &&
+ LM.getKind() == LengthModifier::AsShort)
+ return Ctx.IntTy;
+ return ArgType(Ctx.WideCharTy, "wchar_t");
+ case ConversionSpecifier::pArg:
+ case ConversionSpecifier::PArg:
+ return ArgType::CPointerTy;
+ case ConversionSpecifier::ObjCObjArg:
+ return ArgType::ObjCPointerTy;
+ case ConversionSpecifier::kArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return Ctx.AccumTy;
+ case LengthModifier::AsShort:
+ return Ctx.ShortAccumTy;
+ case LengthModifier::AsLong:
+ return Ctx.LongAccumTy;
default:
- break;
+ return ArgType::Invalid();
+ }
+ case ConversionSpecifier::KArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return Ctx.UnsignedAccumTy;
+ case LengthModifier::AsShort:
+ return Ctx.UnsignedShortAccumTy;
+ case LengthModifier::AsLong:
+ return Ctx.UnsignedLongAccumTy;
+ default:
+ return ArgType::Invalid();
+ }
+ case ConversionSpecifier::rArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return Ctx.FractTy;
+ case LengthModifier::AsShort:
+ return Ctx.ShortFractTy;
+ case LengthModifier::AsLong:
+ return Ctx.LongFractTy;
+ default:
+ return ArgType::Invalid();
+ }
+ case ConversionSpecifier::RArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return Ctx.UnsignedFractTy;
+ case LengthModifier::AsShort:
+ return Ctx.UnsignedShortFractTy;
+ case LengthModifier::AsLong:
+ return Ctx.UnsignedLongFractTy;
+ default:
+ return ArgType::Invalid();
+ }
+ default:
+ break;
}
// FIXME: Handle other cases.
return ArgType();
}
-
-ArgType PrintfSpecifier::getArgType(ASTContext &Ctx,
- bool IsObjCLiteral) const {
+ArgType PrintfSpecifier::getArgType(ASTContext &Ctx, bool IsObjCLiteral) const {
const PrintfConversionSpecifier &CS = getConversionSpecifier();
if (!CS.consumesDataArgument())
@@ -852,44 +902,49 @@ bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
// Various types which are non-trivial to correct.
return false;
-#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
+#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
case BuiltinType::Id:
#include "clang/Basic/OpenCLImageTypes.def"
-#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
- case BuiltinType::Id:
+
+#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) case BuiltinType::Id:
#include "clang/Basic/OpenCLExtensionTypes.def"
-#define SVE_TYPE(Name, Id, SingletonId) \
- case BuiltinType::Id:
+
+#define SVE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/AArch64ACLETypes.def"
-#define PPC_VECTOR_TYPE(Name, Id, Size) \
- case BuiltinType::Id:
+
+#define PPC_VECTOR_TYPE(Name, Id, Size) case BuiltinType::Id:
#include "clang/Basic/PPCTypes.def"
+
#define RVV_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/RISCVVTypes.def"
+
#define WASM_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/WebAssemblyReferenceTypes.def"
+
#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) case BuiltinType::Id:
#include "clang/Basic/AMDGPUTypes.def"
+
#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) case BuiltinType::Id:
#include "clang/Basic/HLSLIntangibleTypes.def"
+
#define SIGNED_TYPE(Id, SingletonId)
#define UNSIGNED_TYPE(Id, SingletonId)
#define FLOATING_TYPE(Id, SingletonId)
-#define BUILTIN_TYPE(Id, SingletonId) \
- case BuiltinType::Id:
+#define BUILTIN_TYPE(Id, SingletonId) case BuiltinType::Id:
#include "clang/AST/BuiltinTypes.def"
+
// Misc other stuff which doesn't make sense here.
return false;
case BuiltinType::UInt:
case BuiltinType::Int:
case BuiltinType::Float:
- LM.setKind(VectorNumElts.isInvalid() ?
- LengthModifier::None : LengthModifier::AsShortLong);
+ LM.setKind(VectorNumElts.isInvalid() ? LengthModifier::None
+ : LengthModifier::AsShortLong);
break;
case BuiltinType::Double:
- LM.setKind(VectorNumElts.isInvalid() ?
- LengthModifier::None : LengthModifier::AsLong);
+ LM.setKind(VectorNumElts.isInvalid() ? LengthModifier::None
+ : LengthModifier::AsLong);
break;
case BuiltinType::Char_U:
case BuiltinType::UChar:
@@ -985,11 +1040,16 @@ void PrintfSpecifier::toString(raw_ostream &os) const {
}
// Conversion flags
- if (IsLeftJustified) os << "-";
- if (HasPlusPrefix) os << "+";
- if (HasSpacePrefix) os << " ";
- if (HasAlternativeForm) os << "#";
- if (HasLeadingZeroes) os << "0";
+ if (IsLeftJustified)
+ os << "-";
+ if (HasPlusPrefix)
+ os << "+";
+ if (HasSpacePrefix)
+ os << " ";
+ if (HasAlternativeForm)
+ os << "#";
+ if (HasLeadingZeroes)
+ os << "0";
// Minimum field width
FieldWidth.toString(os);
@@ -1152,18 +1212,18 @@ bool PrintfSpecifier::hasValidThousandsGroupingPrefix() const {
return true;
switch (CS.getKind()) {
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::DArg:
- case ConversionSpecifier::iArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::UArg:
- case ConversionSpecifier::fArg:
- case ConversionSpecifier::FArg:
- case ConversionSpecifier::gArg:
- case ConversionSpecifier::GArg:
- return true;
- default:
- return false;
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::DArg:
+ case ConversionSpecifier::iArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::UArg:
+ case ConversionSpecifier::fArg:
+ case ConversionSpecifier::FArg:
+ case ConversionSpecifier::gArg:
+ case ConversionSpecifier::GArg:
+ return true;
+ default:
+ return false;
}
}
@@ -1208,7 +1268,7 @@ bool PrintfSpecifier::hasValidPrecision() const {
}
bool PrintfSpecifier::hasValidFieldWidth() const {
if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
- return true;
+ return true;
// The field width is valid for all conversions except n
switch (CS.getKind()) {
diff --git a/clang/lib/AST/ScanfFormatString.cpp b/clang/lib/AST/ScanfFormatString.cpp
index 41cf71a3e042d..90cbbd60bbcf5 100644
--- a/clang/lib/AST/ScanfFormatString.cpp
+++ b/clang/lib/AST/ScanfFormatString.cpp
@@ -11,29 +11,28 @@
//
//===----------------------------------------------------------------------===//
-#include "clang/AST/FormatString.h"
#include "FormatStringParsing.h"
+#include "clang/AST/FormatString.h"
#include "clang/Basic/TargetInfo.h"
+using clang::UpdateOnReturn;
using clang::analyze_format_string::ArgType;
+using clang::analyze_format_string::ConversionSpecifier;
using clang::analyze_format_string::FormatStringHandler;
using clang::analyze_format_string::LengthModifier;
using clang::analyze_format_string::OptionalAmount;
-using clang::analyze_format_string::ConversionSpecifier;
using clang::analyze_scanf::ScanfConversionSpecifier;
using clang::analyze_scanf::ScanfSpecifier;
-using clang::UpdateOnReturn;
using namespace clang;
typedef clang::analyze_format_string::SpecifierResult<ScanfSpecifier>
- ScanfSpecifierResult;
+ ScanfSpecifierResult;
-static bool ParseScanList(FormatStringHandler &H,
- ScanfConversionSpecifier &CS,
+static bool ParseScanList(FormatStringHandler &H, ScanfConversionSpecifier &CS,
const char *&Beg, const char *E) {
const char *I = Beg;
const char *start = I - 1;
- UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+ UpdateOnReturn<const char *> UpdateBeg(Beg, I);
// No more characters?
if (I == E) {
@@ -73,8 +72,7 @@ static bool ParseScanList(FormatStringHandler &H,
// FIXME: Much of this is copy-paste from ParsePrintfSpecifier.
// We can possibly refactor.
static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
- const char *&Beg,
- const char *E,
+ const char *&Beg, const char *E,
unsigned &argIndex,
const LangOptions &LO,
const TargetInfo &Target) {
@@ -82,28 +80,28 @@ static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
using namespace clang::analyze_scanf;
const char *I = Beg;
const char *Start = nullptr;
- UpdateOnReturn <const char*> UpdateBeg(Beg, I);
+ UpdateOnReturn<const char *> UpdateBeg(Beg, I);
- // Look for a '%' character that indicates the start of a format specifier.
- for ( ; I != E ; ++I) {
+ // Look for a '%' character that indicates the start of a format specifier.
+ for (; I != E; ++I) {
char c = *I;
if (c == '\0') {
- // Detect spurious null characters, which are likely errors.
+ // Detect spurious null characters, which are likely errors.
H.HandleNullChar(I);
return true;
}
if (c == '%') {
- Start = I++; // Record the start of the format specifier.
+ Start = I++; // Record the start of the format specifier.
break;
}
}
- // No format specifier found?
+ // No format specifier found?
if (!Start)
return false;
if (I == E) {
- // No more characters left?
+ // No more characters left?
H.HandleIncompleteSpecifier(Start, E - Start);
return true;
}
@@ -113,7 +111,7 @@ static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
return true;
if (I == E) {
- // No more characters left?
+ // No more characters left?
H.HandleIncompleteSpecifier(Start, E - Start);
return true;
}
@@ -143,7 +141,7 @@ static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
// Look for the length modifier.
if (ParseLengthModifier(FS, I, E, LO, /*IsScanf=*/true) && I == E) {
- // No more characters left?
+ // No more characters left?
H.HandleIncompleteSpecifier(Start, E - Start);
return true;
}
@@ -158,45 +156,91 @@ static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
const char *conversionPosition = I++;
ScanfConversionSpecifier::Kind k = ScanfConversionSpecifier::InvalidSpecifier;
switch (*conversionPosition) {
- default:
- break;
- case '%': k = ConversionSpecifier::PercentArg; break;
- case 'b': k = ConversionSpecifier::bArg; break;
- case 'A': k = ConversionSpecifier::AArg; break;
- case 'E': k = ConversionSpecifier::EArg; break;
- case 'F': k = ConversionSpecifier::FArg; break;
- case 'G': k = ConversionSpecifier::GArg; break;
- case 'X': k = ConversionSpecifier::XArg; break;
- case 'a': k = ConversionSpecifier::aArg; break;
- case 'd': k = ConversionSpecifier::dArg; break;
- case 'e': k = ConversionSpecifier::eArg; break;
- case 'f': k = ConversionSpecifier::fArg; break;
- case 'g': k = ConversionSpecifier::gArg; break;
- case 'i': k = ConversionSpecifier::iArg; break;
- case 'n': k = ConversionSpecifier::nArg; break;
- case 'c': k = ConversionSpecifier::cArg; break;
- case 'C': k = ConversionSpecifier::CArg; break;
- case 'S': k = ConversionSpecifier::SArg; break;
- case '[': k = ConversionSpecifier::ScanListArg; break;
- case 'u': k = ConversionSpecifier::uArg; break;
- case 'x': k = ConversionSpecifier::xArg; break;
- case 'o': k = ConversionSpecifier::oArg; break;
- case 's': k = ConversionSpecifier::sArg; break;
- case 'p': k = ConversionSpecifier::pArg; break;
- // Apple extensions
- // Apple-specific
- case 'D':
- if (Target.getTriple().isOSDarwin())
- k = ConversionSpecifier::DArg;
- break;
- case 'O':
- if (Target.getTriple().isOSDarwin())
- k = ConversionSpecifier::OArg;
- break;
- case 'U':
- if (Target.getTriple().isOSDarwin())
- k = ConversionSpecifier::UArg;
- break;
+ default:
+ break;
+ case '%':
+ k = ConversionSpecifier::PercentArg;
+ break;
+ case 'b':
+ k = ConversionSpecifier::bArg;
+ break;
+ case 'A':
+ k = ConversionSpecifier::AArg;
+ break;
+ case 'E':
+ k = ConversionSpecifier::EArg;
+ break;
+ case 'F':
+ k = ConversionSpecifier::FArg;
+ break;
+ case 'G':
+ k = ConversionSpecifier::GArg;
+ break;
+ case 'X':
+ k = ConversionSpecifier::XArg;
+ break;
+ case 'a':
+ k = ConversionSpecifier::aArg;
+ break;
+ case 'd':
+ k = ConversionSpecifier::dArg;
+ break;
+ case 'e':
+ k = ConversionSpecifier::eArg;
+ break;
+ case 'f':
+ k = ConversionSpecifier::fArg;
+ break;
+ case 'g':
+ k = ConversionSpecifier::gArg;
+ break;
+ case 'i':
+ k = ConversionSpecifier::iArg;
+ break;
+ case 'n':
+ k = ConversionSpecifier::nArg;
+ break;
+ case 'c':
+ k = ConversionSpecifier::cArg;
+ break;
+ case 'C':
+ k = ConversionSpecifier::CArg;
+ break;
+ case 'S':
+ k = ConversionSpecifier::SArg;
+ break;
+ case '[':
+ k = ConversionSpecifier::ScanListArg;
+ break;
+ case 'u':
+ k = ConversionSpecifier::uArg;
+ break;
+ case 'x':
+ k = ConversionSpecifier::xArg;
+ break;
+ case 'o':
+ k = ConversionSpecifier::oArg;
+ break;
+ case 's':
+ k = ConversionSpecifier::sArg;
+ break;
+ case 'p':
+ k = ConversionSpecifier::pArg;
+ break;
+ // Apple extensions
+ // Apple-specific
+ case 'D':
+ if (Target.getTriple().isOSDarwin())
+ k = ConversionSpecifier::DArg;
+ break;
+ case 'O':
+ if (Target.getTriple().isOSDarwin())
+ k = ConversionSpecifier::OArg;
+ break;
+ case 'U':
+ if (Target.getTriple().isOSDarwin())
+ k = ConversionSpecifier::UArg;
+ break;
}
ScanfConversionSpecifier CS(conversionPosition, k);
if (k == ScanfConversionSpecifier::ScanListArg) {
@@ -204,8 +248,8 @@ static ScanfSpecifierResult ParseScanfSpecifier(FormatStringHandler &H,
return true;
}
FS.setConversionSpecifier(CS);
- if (CS.consumesDataArgument() && !FS.getSuppressAssignment()
- && !FS.usesPositionalArg())
+ if (CS.consumesDataArgument() && !FS.getSuppressAssignment() &&
+ !FS.usesPositionalArg())
FS.setArgIndex(argIndex++);
// FIXME: '%' and '*' doesn't make sense. Issue a warning.
@@ -229,196 +273,196 @@ ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const {
if (!CS.consumesDataArgument())
return ArgType::Invalid();
- switch(CS.getKind()) {
- // Signed int.
- case ConversionSpecifier::dArg:
- case ConversionSpecifier::DArg:
- case ConversionSpecifier::iArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return ArgType::PtrTo(Ctx.IntTy);
- case LengthModifier::AsChar:
- return ArgType::PtrTo(ArgType::AnyCharTy);
- case LengthModifier::AsShort:
- return ArgType::PtrTo(Ctx.ShortTy);
- case LengthModifier::AsLong:
- return ArgType::PtrTo(Ctx.LongTy);
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- return ArgType::PtrTo(Ctx.LongLongTy);
- case LengthModifier::AsInt64:
- return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
- case LengthModifier::AsIntMax:
- return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
- case LengthModifier::AsSizeT:
- return ArgType::PtrTo(ArgType::makeSizeT(
- ArgType(Ctx.getSignedSizeType(), "signed size_t")));
- case LengthModifier::AsPtrDiff:
- return ArgType::PtrTo(ArgType::makePtr
diff T(
- ArgType(Ctx.getPointerDiffType(), "ptr
diff _t")));
- case LengthModifier::AsLongDouble:
- // GNU extension.
- return ArgType::PtrTo(Ctx.LongLongTy);
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsInt32:
- case LengthModifier::AsInt3264:
- case LengthModifier::AsWide:
- case LengthModifier::AsShortLong:
- return ArgType::Invalid();
- }
- llvm_unreachable("Unsupported LengthModifier Type");
-
- // Unsigned int.
- case ConversionSpecifier::bArg:
- case ConversionSpecifier::oArg:
- case ConversionSpecifier::OArg:
- case ConversionSpecifier::uArg:
- case ConversionSpecifier::UArg:
- case ConversionSpecifier::xArg:
- case ConversionSpecifier::XArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return ArgType::PtrTo(Ctx.UnsignedIntTy);
- case LengthModifier::AsChar:
- return ArgType::PtrTo(Ctx.UnsignedCharTy);
- case LengthModifier::AsShort:
- return ArgType::PtrTo(Ctx.UnsignedShortTy);
- case LengthModifier::AsLong:
- return ArgType::PtrTo(Ctx.UnsignedLongTy);
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
- case LengthModifier::AsInt64:
- return ArgType::PtrTo(ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
- case LengthModifier::AsIntMax:
- return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
- case LengthModifier::AsSizeT:
- return ArgType::PtrTo(
- ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t")));
- case LengthModifier::AsPtrDiff:
- return ArgType::PtrTo(ArgType::makePtr
diff T(
- ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptr
diff _t")));
- case LengthModifier::AsLongDouble:
- // GNU extension.
- return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsInt32:
- case LengthModifier::AsInt3264:
- case LengthModifier::AsWide:
- case LengthModifier::AsShortLong:
- return ArgType::Invalid();
- }
- llvm_unreachable("Unsupported LengthModifier Type");
-
- // Float.
- case ConversionSpecifier::aArg:
- case ConversionSpecifier::AArg:
- case ConversionSpecifier::eArg:
- case ConversionSpecifier::EArg:
- case ConversionSpecifier::fArg:
- case ConversionSpecifier::FArg:
- case ConversionSpecifier::gArg:
- case ConversionSpecifier::GArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return ArgType::PtrTo(Ctx.FloatTy);
- case LengthModifier::AsLong:
- return ArgType::PtrTo(Ctx.DoubleTy);
- case LengthModifier::AsLongDouble:
- return ArgType::PtrTo(Ctx.LongDoubleTy);
- default:
- return ArgType::Invalid();
- }
-
- // Char, string and scanlist.
- case ConversionSpecifier::cArg:
- case ConversionSpecifier::sArg:
- case ConversionSpecifier::ScanListArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return ArgType::PtrTo(ArgType::AnyCharTy);
- case LengthModifier::AsLong:
- case LengthModifier::AsWide:
- return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- return ArgType::PtrTo(ArgType::CStrTy);
- case LengthModifier::AsShort:
- if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
- return ArgType::PtrTo(ArgType::AnyCharTy);
- [[fallthrough]];
- default:
- return ArgType::Invalid();
- }
- case ConversionSpecifier::CArg:
- case ConversionSpecifier::SArg:
- // FIXME: Mac OS X specific?
- switch (LM.getKind()) {
- case LengthModifier::None:
- case LengthModifier::AsWide:
- return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *"));
- case LengthModifier::AsShort:
- if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
- return ArgType::PtrTo(ArgType::AnyCharTy);
- [[fallthrough]];
- default:
- return ArgType::Invalid();
- }
-
- // Pointer.
- case ConversionSpecifier::pArg:
- return ArgType::PtrTo(ArgType::CPointerTy);
-
- // Write-back.
- case ConversionSpecifier::nArg:
- switch (LM.getKind()) {
- case LengthModifier::None:
- return ArgType::PtrTo(Ctx.IntTy);
- case LengthModifier::AsChar:
- return ArgType::PtrTo(Ctx.SignedCharTy);
- case LengthModifier::AsShort:
- return ArgType::PtrTo(Ctx.ShortTy);
- case LengthModifier::AsLong:
- return ArgType::PtrTo(Ctx.LongTy);
- case LengthModifier::AsLongLong:
- case LengthModifier::AsQuad:
- return ArgType::PtrTo(Ctx.LongLongTy);
- case LengthModifier::AsInt64:
- return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
- case LengthModifier::AsIntMax:
- return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
- case LengthModifier::AsSizeT:
- return ArgType::PtrTo(ArgType::makeSizeT(
- ArgType(Ctx.getSignedSizeType(), "signed size_t")));
- case LengthModifier::AsPtrDiff:
- return ArgType::PtrTo(ArgType::makePtr
diff T(
- ArgType(Ctx.getPointerDiffType(), "ptr
diff _t")));
- case LengthModifier::AsLongDouble:
- return ArgType(); // FIXME: Is this a known extension?
- case LengthModifier::AsAllocate:
- case LengthModifier::AsMAllocate:
- case LengthModifier::AsInt32:
- case LengthModifier::AsInt3264:
- case LengthModifier::AsWide:
- case LengthModifier::AsShortLong:
- return ArgType::Invalid();
- }
+ switch (CS.getKind()) {
+ // Signed int.
+ case ConversionSpecifier::dArg:
+ case ConversionSpecifier::DArg:
+ case ConversionSpecifier::iArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return ArgType::PtrTo(Ctx.IntTy);
+ case LengthModifier::AsChar:
+ return ArgType::PtrTo(ArgType::AnyCharTy);
+ case LengthModifier::AsShort:
+ return ArgType::PtrTo(Ctx.ShortTy);
+ case LengthModifier::AsLong:
+ return ArgType::PtrTo(Ctx.LongTy);
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ return ArgType::PtrTo(Ctx.LongLongTy);
+ case LengthModifier::AsInt64:
+ return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
+ case LengthModifier::AsIntMax:
+ return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
+ case LengthModifier::AsSizeT:
+ return ArgType::PtrTo(ArgType::makeSizeT(
+ ArgType(Ctx.getSignedSizeType(), "signed size_t")));
+ case LengthModifier::AsPtrDiff:
+ return ArgType::PtrTo(ArgType::makePtr
diff T(
+ ArgType(Ctx.getPointerDiffType(), "ptr
diff _t")));
+ case LengthModifier::AsLongDouble:
+ // GNU extension.
+ return ArgType::PtrTo(Ctx.LongLongTy);
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsInt32:
+ case LengthModifier::AsInt3264:
+ case LengthModifier::AsWide:
+ case LengthModifier::AsShortLong:
+ return ArgType::Invalid();
+ }
+ llvm_unreachable("Unsupported LengthModifier Type");
+
+ // Unsigned int.
+ case ConversionSpecifier::bArg:
+ case ConversionSpecifier::oArg:
+ case ConversionSpecifier::OArg:
+ case ConversionSpecifier::uArg:
+ case ConversionSpecifier::UArg:
+ case ConversionSpecifier::xArg:
+ case ConversionSpecifier::XArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return ArgType::PtrTo(Ctx.UnsignedIntTy);
+ case LengthModifier::AsChar:
+ return ArgType::PtrTo(Ctx.UnsignedCharTy);
+ case LengthModifier::AsShort:
+ return ArgType::PtrTo(Ctx.UnsignedShortTy);
+ case LengthModifier::AsLong:
+ return ArgType::PtrTo(Ctx.UnsignedLongTy);
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
+ case LengthModifier::AsInt64:
+ return ArgType::PtrTo(
+ ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
+ case LengthModifier::AsIntMax:
+ return ArgType::PtrTo(ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
+ case LengthModifier::AsSizeT:
+ return ArgType::PtrTo(
+ ArgType::makeSizeT(ArgType(Ctx.getSizeType(), "size_t")));
+ case LengthModifier::AsPtrDiff:
+ return ArgType::PtrTo(ArgType::makePtr
diff T(
+ ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptr
diff _t")));
+ case LengthModifier::AsLongDouble:
+ // GNU extension.
+ return ArgType::PtrTo(Ctx.UnsignedLongLongTy);
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsInt32:
+ case LengthModifier::AsInt3264:
+ case LengthModifier::AsWide:
+ case LengthModifier::AsShortLong:
+ return ArgType::Invalid();
+ }
+ llvm_unreachable("Unsupported LengthModifier Type");
+
+ // Float.
+ case ConversionSpecifier::aArg:
+ case ConversionSpecifier::AArg:
+ case ConversionSpecifier::eArg:
+ case ConversionSpecifier::EArg:
+ case ConversionSpecifier::fArg:
+ case ConversionSpecifier::FArg:
+ case ConversionSpecifier::gArg:
+ case ConversionSpecifier::GArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return ArgType::PtrTo(Ctx.FloatTy);
+ case LengthModifier::AsLong:
+ return ArgType::PtrTo(Ctx.DoubleTy);
+ case LengthModifier::AsLongDouble:
+ return ArgType::PtrTo(Ctx.LongDoubleTy);
+ default:
+ return ArgType::Invalid();
+ }
+ // Char, string and scanlist.
+ case ConversionSpecifier::cArg:
+ case ConversionSpecifier::sArg:
+ case ConversionSpecifier::ScanListArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return ArgType::PtrTo(ArgType::AnyCharTy);
+ case LengthModifier::AsLong:
+ case LengthModifier::AsWide:
+ return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ return ArgType::PtrTo(ArgType::CStrTy);
+ case LengthModifier::AsShort:
+ if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
+ return ArgType::PtrTo(ArgType::AnyCharTy);
+ [[fallthrough]];
default:
- break;
+ return ArgType::Invalid();
+ }
+ case ConversionSpecifier::CArg:
+ case ConversionSpecifier::SArg:
+ // FIXME: Mac OS X specific?
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ case LengthModifier::AsWide:
+ return ArgType::PtrTo(ArgType(Ctx.getWideCharType(), "wchar_t"));
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ return ArgType::PtrTo(ArgType(ArgType::WCStrTy, "wchar_t *"));
+ case LengthModifier::AsShort:
+ if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
+ return ArgType::PtrTo(ArgType::AnyCharTy);
+ [[fallthrough]];
+ default:
+ return ArgType::Invalid();
+ }
+
+ // Pointer.
+ case ConversionSpecifier::pArg:
+ return ArgType::PtrTo(ArgType::CPointerTy);
+
+ // Write-back.
+ case ConversionSpecifier::nArg:
+ switch (LM.getKind()) {
+ case LengthModifier::None:
+ return ArgType::PtrTo(Ctx.IntTy);
+ case LengthModifier::AsChar:
+ return ArgType::PtrTo(Ctx.SignedCharTy);
+ case LengthModifier::AsShort:
+ return ArgType::PtrTo(Ctx.ShortTy);
+ case LengthModifier::AsLong:
+ return ArgType::PtrTo(Ctx.LongTy);
+ case LengthModifier::AsLongLong:
+ case LengthModifier::AsQuad:
+ return ArgType::PtrTo(Ctx.LongLongTy);
+ case LengthModifier::AsInt64:
+ return ArgType::PtrTo(ArgType(Ctx.LongLongTy, "__int64"));
+ case LengthModifier::AsIntMax:
+ return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
+ case LengthModifier::AsSizeT:
+ return ArgType::PtrTo(ArgType::makeSizeT(
+ ArgType(Ctx.getSignedSizeType(), "signed size_t")));
+ case LengthModifier::AsPtrDiff:
+ return ArgType::PtrTo(ArgType::makePtr
diff T(
+ ArgType(Ctx.getPointerDiffType(), "ptr
diff _t")));
+ case LengthModifier::AsLongDouble:
+ return ArgType(); // FIXME: Is this a known extension?
+ case LengthModifier::AsAllocate:
+ case LengthModifier::AsMAllocate:
+ case LengthModifier::AsInt32:
+ case LengthModifier::AsInt3264:
+ case LengthModifier::AsWide:
+ case LengthModifier::AsShortLong:
+ return ArgType::Invalid();
+ }
+
+ default:
+ break;
}
return ArgType();
}
bool ScanfSpecifier::fixType(QualType QT, QualType RawQT,
- const LangOptions &LangOpt,
- ASTContext &Ctx) {
+ const LangOptions &LangOpt, ASTContext &Ctx) {
// %n is
diff erent from other conversion specifiers; don't try to fix it.
if (CS.getKind() == ConversionSpecifier::nArg)
@@ -460,48 +504,48 @@ bool ScanfSpecifier::fixType(QualType QT, QualType RawQT,
// Figure out the length modifier.
switch (BT->getKind()) {
- // no modifier
- case BuiltinType::UInt:
- case BuiltinType::Int:
- case BuiltinType::Float:
- LM.setKind(LengthModifier::None);
- break;
-
- // hh
- case BuiltinType::Char_U:
- case BuiltinType::UChar:
- case BuiltinType::Char_S:
- case BuiltinType::SChar:
- LM.setKind(LengthModifier::AsChar);
- break;
-
- // h
- case BuiltinType::Short:
- case BuiltinType::UShort:
- LM.setKind(LengthModifier::AsShort);
- break;
-
- // l
- case BuiltinType::Long:
- case BuiltinType::ULong:
- case BuiltinType::Double:
- LM.setKind(LengthModifier::AsLong);
- break;
-
- // ll
- case BuiltinType::LongLong:
- case BuiltinType::ULongLong:
- LM.setKind(LengthModifier::AsLongLong);
- break;
-
- // L
- case BuiltinType::LongDouble:
- LM.setKind(LengthModifier::AsLongDouble);
- break;
-
- // Don't know.
- default:
- return false;
+ // no modifier
+ case BuiltinType::UInt:
+ case BuiltinType::Int:
+ case BuiltinType::Float:
+ LM.setKind(LengthModifier::None);
+ break;
+
+ // hh
+ case BuiltinType::Char_U:
+ case BuiltinType::UChar:
+ case BuiltinType::Char_S:
+ case BuiltinType::SChar:
+ LM.setKind(LengthModifier::AsChar);
+ break;
+
+ // h
+ case BuiltinType::Short:
+ case BuiltinType::UShort:
+ LM.setKind(LengthModifier::AsShort);
+ break;
+
+ // l
+ case BuiltinType::Long:
+ case BuiltinType::ULong:
+ case BuiltinType::Double:
+ LM.setKind(LengthModifier::AsLong);
+ break;
+
+ // ll
+ case BuiltinType::LongLong:
+ case BuiltinType::ULongLong:
+ LM.setKind(LengthModifier::AsLongLong);
+ break;
+
+ // L
+ case BuiltinType::LongDouble:
+ LM.setKind(LengthModifier::AsLongDouble);
+ break;
+
+ // Don't know.
+ default:
+ return false;
}
// Handle size_t, ptr
diff _t, etc. that have dedicated length modifiers in C99.
@@ -551,17 +595,17 @@ bool clang::analyze_format_string::ParseScanfString(FormatStringHandler &H,
// Keep looking for a format specifier until we have exhausted the string.
while (I != E) {
- const ScanfSpecifierResult &FSR = ParseScanfSpecifier(H, I, E, argIndex,
- LO, Target);
+ const ScanfSpecifierResult &FSR =
+ ParseScanfSpecifier(H, I, E, argIndex, LO, Target);
// Did a fail-stop error of any kind occur when parsing the specifier?
// If so, don't do any more processing.
if (FSR.shouldStop())
return true;
- // Did we exhaust the string or encounter an error that
- // we can recover from?
+ // Did we exhaust the string or encounter an error that
+ // we can recover from?
if (!FSR.hasValue())
continue;
- // We have a format specifier. Pass it to the callback.
+ // We have a format specifier. Pass it to the callback.
if (!H.HandleScanfSpecifier(FSR.getValue(), FSR.getStart(),
I - FSR.getStart())) {
return true;
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 9f950f185f8f0..12f77d021eb0d 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -7843,23 +7843,21 @@ class CheckFormatHandler : public analyze_format_string::FormatStringHandler {
unsigned specifierLen) override;
void HandleInvalidLengthModifier(
- const analyze_format_string::FormatSpecifier &FS,
- const analyze_format_string::ConversionSpecifier &CS,
- const char *startSpecifier, unsigned specifierLen,
- unsigned DiagID);
+ const analyze_format_string::FormatSpecifier &FS,
+ const analyze_format_string::ConversionSpecifier &CS,
+ const char *startSpecifier, unsigned specifierLen, unsigned DiagID);
void HandleNonStandardLengthModifier(
- const analyze_format_string::FormatSpecifier &FS,
- const char *startSpecifier, unsigned specifierLen);
+ const analyze_format_string::FormatSpecifier &FS,
+ const char *startSpecifier, unsigned specifierLen);
void HandleNonStandardConversionSpecifier(
- const analyze_format_string::ConversionSpecifier &CS,
- const char *startSpecifier, unsigned specifierLen);
+ const analyze_format_string::ConversionSpecifier &CS,
+ const char *startSpecifier, unsigned specifierLen);
void HandlePosition(const char *startPos, unsigned posLen) override;
- void HandleInvalidPosition(const char *startSpecifier,
- unsigned specifierLen,
+ void HandleInvalidPosition(const char *startSpecifier, unsigned specifierLen,
analyze_format_string::PositionContext p) override;
void HandleZeroPosition(const char *startPos, unsigned posLen) override;
@@ -7907,10 +7905,11 @@ SourceRange CheckFormatHandler::getFormatStringRange() {
return OrigFormatExpr->getSourceRange();
}
-CharSourceRange CheckFormatHandler::
-getSpecifierRange(const char *startSpecifier, unsigned specifierLen) {
+CharSourceRange
+CheckFormatHandler::getSpecifierRange(const char *startSpecifier,
+ unsigned specifierLen) {
SourceLocation Start = getLocationOfByte(startSpecifier);
- SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
+ SourceLocation End = getLocationOfByte(startSpecifier + specifierLen - 1);
// Advance the end SourceLocation by one due to half-open ranges.
End = End.getLocWithOffset(1);
@@ -7924,10 +7923,10 @@ SourceLocation CheckFormatHandler::getLocationOfByte(const char *x) {
}
void CheckFormatHandler::HandleIncompleteSpecifier(const char *startSpecifier,
- unsigned specifierLen){
+ unsigned specifierLen) {
EmitFormatDiagnostic(S.PDiag(diag::warn_printf_incomplete_specifier),
getLocationOfByte(startSpecifier),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen));
}
@@ -7945,12 +7944,12 @@ void CheckFormatHandler::HandleInvalidLengthModifier(
if (FixedLM) {
EmitFormatDiagnostic(S.PDiag(DiagID) << LM.toString() << CS.toString(),
getLocationOfByte(LM.getStart()),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen));
S.Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
- << FixedLM->toString()
- << FixItHint::CreateReplacement(LMRange, FixedLM->toString());
+ << FixedLM->toString()
+ << FixItHint::CreateReplacement(LMRange, FixedLM->toString());
} else {
FixItHint Hint;
@@ -7959,9 +7958,8 @@ void CheckFormatHandler::HandleInvalidLengthModifier(
EmitFormatDiagnostic(S.PDiag(DiagID) << LM.toString() << CS.toString(),
getLocationOfByte(LM.getStart()),
- /*IsStringLocation*/true,
- getSpecifierRange(startSpecifier, specifierLen),
- Hint);
+ /*IsStringLocation*/ true,
+ getSpecifierRange(startSpecifier, specifierLen), Hint);
}
}
@@ -7977,20 +7975,20 @@ void CheckFormatHandler::HandleNonStandardLengthModifier(
std::optional<LengthModifier> FixedLM = FS.getCorrectedLengthModifier();
if (FixedLM) {
EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard)
- << LM.toString() << 0,
+ << LM.toString() << 0,
getLocationOfByte(LM.getStart()),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen));
S.Diag(getLocationOfByte(LM.getStart()), diag::note_format_fix_specifier)
- << FixedLM->toString()
- << FixItHint::CreateReplacement(LMRange, FixedLM->toString());
+ << FixedLM->toString()
+ << FixItHint::CreateReplacement(LMRange, FixedLM->toString());
} else {
EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard)
- << LM.toString() << 0,
+ << LM.toString() << 0,
getLocationOfByte(LM.getStart()),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen));
}
}
@@ -8004,26 +8002,25 @@ void CheckFormatHandler::HandleNonStandardConversionSpecifier(
std::optional<ConversionSpecifier> FixedCS = CS.getStandardSpecifier();
if (FixedCS) {
EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard)
- << CS.toString() << /*conversion specifier*/1,
+ << CS.toString() << /*conversion specifier*/ 1,
getLocationOfByte(CS.getStart()),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen));
CharSourceRange CSRange = getSpecifierRange(CS.getStart(), CS.getLength());
S.Diag(getLocationOfByte(CS.getStart()), diag::note_format_fix_specifier)
- << FixedCS->toString()
- << FixItHint::CreateReplacement(CSRange, FixedCS->toString());
+ << FixedCS->toString()
+ << FixItHint::CreateReplacement(CSRange, FixedCS->toString());
} else {
EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard)
- << CS.toString() << /*conversion specifier*/1,
+ << CS.toString() << /*conversion specifier*/ 1,
getLocationOfByte(CS.getStart()),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen));
}
}
-void CheckFormatHandler::HandlePosition(const char *startPos,
- unsigned posLen) {
+void CheckFormatHandler::HandlePosition(const char *startPos, unsigned posLen) {
if (!S.getDiagnostics().isIgnored(
diag::warn_format_non_standard_positional_arg, SourceLocation()))
EmitFormatDiagnostic(S.PDiag(diag::warn_format_non_standard_positional_arg),
@@ -8057,9 +8054,9 @@ void CheckFormatHandler::HandleNullChar(const char *nullCharacter) {
if (!isa<ObjCStringLiteral>(OrigFormatExpr)) {
// The presence of a null character is likely an error.
EmitFormatDiagnostic(
- S.PDiag(diag::warn_printf_format_string_contains_null_char),
- getLocationOfByte(nullCharacter), /*IsStringLocation*/true,
- getFormatStringRange());
+ S.PDiag(diag::warn_printf_format_string_contains_null_char),
+ getLocationOfByte(nullCharacter), /*IsStringLocation*/ true,
+ getFormatStringRange());
}
}
@@ -8087,8 +8084,7 @@ void CheckFormatHandler::DoneProcessing() {
void UncoveredArgHandler::Diagnose(Sema &S, bool IsFunctionCall,
const Expr *ArgExpr) {
- assert(hasUncoveredArg() && !DiagnosticExprs.empty() &&
- "Invalid state");
+ assert(hasUncoveredArg() && !DiagnosticExprs.empty() && "Invalid state");
if (!ArgExpr)
return;
@@ -8103,25 +8099,19 @@ void UncoveredArgHandler::Diagnose(Sema &S, bool IsFunctionCall,
PDiag << E->getSourceRange();
CheckFormatHandler::EmitFormatDiagnostic(
- S, IsFunctionCall, DiagnosticExprs[0],
- PDiag, Loc, /*IsStringLocation*/false,
- DiagnosticExprs[0]->getSourceRange());
-}
-
-bool
-CheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex,
- SourceLocation Loc,
- const char *startSpec,
- unsigned specifierLen,
- const char *csStart,
- unsigned csLen) {
+ S, IsFunctionCall, DiagnosticExprs[0], PDiag, Loc,
+ /*IsStringLocation*/ false, DiagnosticExprs[0]->getSourceRange());
+}
+
+bool CheckFormatHandler::HandleInvalidConversionSpecifier(
+ unsigned argIndex, SourceLocation Loc, const char *startSpec,
+ unsigned specifierLen, const char *csStart, unsigned csLen) {
bool keepGoing = true;
if (argIndex < NumDataArgs) {
// Consider the argument coverered, even though the specifier doesn't
// make sense.
CoveredArgs.set(argIndex);
- }
- else {
+ } else {
// If argIndex exceeds the number of data arguments we
// don't issue a warning because that is just a cascade of warnings (and
// they may have intended '%%' anyway). We don't want to continue processing
@@ -8139,8 +8129,7 @@ CheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex,
if (!llvm::sys::locale::isPrint(*csStart)) {
llvm::UTF32 CodePoint;
const llvm::UTF8 **B = reinterpret_cast<const llvm::UTF8 **>(&csStart);
- const llvm::UTF8 *E =
- reinterpret_cast<const llvm::UTF8 *>(csStart + csLen);
+ const llvm::UTF8 *E = reinterpret_cast<const llvm::UTF8 *>(csStart + csLen);
llvm::ConversionResult Result =
llvm::convertUTF8Sequence(B, E, &CodePoint, llvm::strictConversion);
@@ -8166,29 +8155,27 @@ CheckFormatHandler::HandleInvalidConversionSpecifier(unsigned argIndex,
return keepGoing;
}
-void
-CheckFormatHandler::HandlePositionalNonpositionalArgs(SourceLocation Loc,
- const char *startSpec,
- unsigned specifierLen) {
+void CheckFormatHandler::HandlePositionalNonpositionalArgs(
+ SourceLocation Loc, const char *startSpec, unsigned specifierLen) {
EmitFormatDiagnostic(
- S.PDiag(diag::warn_format_mix_positional_nonpositional_args),
- Loc, /*isStringLoc*/true, getSpecifierRange(startSpec, specifierLen));
+ S.PDiag(diag::warn_format_mix_positional_nonpositional_args), Loc,
+ /*isStringLoc*/ true, getSpecifierRange(startSpec, specifierLen));
}
-bool
-CheckFormatHandler::CheckNumArgs(
- const analyze_format_string::FormatSpecifier &FS,
- const analyze_format_string::ConversionSpecifier &CS,
- const char *startSpecifier, unsigned specifierLen, unsigned argIndex) {
+bool CheckFormatHandler::CheckNumArgs(
+ const analyze_format_string::FormatSpecifier &FS,
+ const analyze_format_string::ConversionSpecifier &CS,
+ const char *startSpecifier, unsigned specifierLen, unsigned argIndex) {
if (HasFormatArguments() && argIndex >= NumDataArgs) {
- PartialDiagnostic PDiag = FS.usesPositionalArg()
- ? (S.PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
- << (argIndex+1) << NumDataArgs)
- : S.PDiag(diag::warn_printf_insufficient_data_args);
- EmitFormatDiagnostic(
- PDiag, getLocationOfByte(CS.getStart()), /*IsStringLocation*/true,
- getSpecifierRange(startSpecifier, specifierLen));
+ PartialDiagnostic PDiag =
+ FS.usesPositionalArg()
+ ? (S.PDiag(diag::warn_printf_positional_arg_exceeds_data_args)
+ << (argIndex + 1) << NumDataArgs)
+ : S.PDiag(diag::warn_printf_insufficient_data_args);
+ EmitFormatDiagnostic(PDiag, getLocationOfByte(CS.getStart()),
+ /*IsStringLocation*/ true,
+ getSpecifierRange(startSpecifier, specifierLen));
// Since more arguments than conversion tokens are given, by extension
// all arguments are covered, so mark this as so.
@@ -8198,14 +8185,14 @@ CheckFormatHandler::CheckNumArgs(
return true;
}
-template<typename Range>
+template <typename Range>
void CheckFormatHandler::EmitFormatDiagnostic(PartialDiagnostic PDiag,
SourceLocation Loc,
bool IsStringLocation,
Range StringRange,
ArrayRef<FixItHint> FixIt) {
- EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag,
- Loc, IsStringLocation, StringRange, FixIt);
+ EmitFormatDiagnostic(S, inFunctionCall, Args[FormatIdx], PDiag, Loc,
+ IsStringLocation, StringRange, FixIt);
}
/// If the format string is not within the function call, emit a note
@@ -8246,11 +8233,11 @@ void CheckFormatHandler::EmitFormatDiagnostic(
D << FixIt;
} else {
S.Diag(IsStringLocation ? ArgumentExpr->getExprLoc() : Loc, PDiag)
- << ArgumentExpr->getSourceRange();
+ << ArgumentExpr->getSourceRange();
const Sema::SemaDiagnosticBuilder &Note =
- S.Diag(IsStringLocation ? Loc : StringRange.getBegin(),
- diag::note_format_string_defined);
+ S.Diag(IsStringLocation ? Loc : StringRange.getBegin(),
+ diag::note_format_string_defined);
Note << StringRange;
Note << FixIt;
@@ -8286,9 +8273,8 @@ class CheckPrintfHandler : public CheckFormatHandler {
}
bool HandleInvalidPrintfConversionSpecifier(
- const analyze_printf::PrintfSpecifier &FS,
- const char *startSpecifier,
- unsigned specifierLen) override;
+ const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier,
+ unsigned specifierLen) override;
void handleInvalidMaskType(StringRef MaskType) override;
@@ -8296,16 +8282,16 @@ class CheckPrintfHandler : public CheckFormatHandler {
const char *startSpecifier, unsigned specifierLen,
const TargetInfo &Target) override;
bool checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
- const char *StartSpecifier,
- unsigned SpecifierLen,
+ const char *StartSpecifier, unsigned SpecifierLen,
const Expr *E);
- bool HandleAmount(const analyze_format_string::OptionalAmount &Amt, unsigned k,
- const char *startSpecifier, unsigned specifierLen);
+ bool HandleAmount(const analyze_format_string::OptionalAmount &Amt,
+ unsigned k, const char *startSpecifier,
+ unsigned specifierLen);
void HandleInvalidAmount(const analyze_printf::PrintfSpecifier &FS,
const analyze_printf::OptionalAmount &Amt,
- unsigned type,
- const char *startSpecifier, unsigned specifierLen);
+ unsigned type, const char *startSpecifier,
+ unsigned specifierLen);
void HandleFlag(const analyze_printf::PrintfSpecifier &FS,
const analyze_printf::OptionalFlag &flag,
const char *startSpecifier, unsigned specifierLen);
@@ -8313,14 +8299,13 @@ class CheckPrintfHandler : public CheckFormatHandler {
const analyze_printf::OptionalFlag &ignoredFlag,
const analyze_printf::OptionalFlag &flag,
const char *startSpecifier, unsigned specifierLen);
- bool checkForCStrMembers(const analyze_printf::ArgType &AT,
- const Expr *E);
+ bool checkForCStrMembers(const analyze_printf::ArgType &AT, const Expr *E);
void HandleEmptyObjCModifierFlag(const char *startFlag,
unsigned flagLen) override;
void HandleInvalidObjCModifierFlag(const char *startFlag,
- unsigned flagLen) override;
+ unsigned flagLen) override;
void
HandleObjCFlagsWithNonObjCConversion(const char *flagsStart,
@@ -8431,12 +8416,11 @@ bool CheckPrintfHandler::HandleInvalidPrintfConversionSpecifier(
const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier,
unsigned specifierLen) {
const analyze_printf::PrintfConversionSpecifier &CS =
- FS.getConversionSpecifier();
+ FS.getConversionSpecifier();
- return HandleInvalidConversionSpecifier(FS.getArgIndex(),
- getLocationOfByte(CS.getStart()),
- startSpecifier, specifierLen,
- CS.getStart(), CS.getLength());
+ return HandleInvalidConversionSpecifier(
+ FS.getArgIndex(), getLocationOfByte(CS.getStart()), startSpecifier,
+ specifierLen, CS.getStart(), CS.getLength());
}
void CheckPrintfHandler::handleInvalidMaskType(StringRef MaskType) {
@@ -8502,26 +8486,23 @@ bool CheckPrintfHandler::HandleAmount(
}
void CheckPrintfHandler::HandleInvalidAmount(
- const analyze_printf::PrintfSpecifier &FS,
- const analyze_printf::OptionalAmount &Amt,
- unsigned type,
- const char *startSpecifier,
- unsigned specifierLen) {
+ const analyze_printf::PrintfSpecifier &FS,
+ const analyze_printf::OptionalAmount &Amt, unsigned type,
+ const char *startSpecifier, unsigned specifierLen) {
const analyze_printf::PrintfConversionSpecifier &CS =
- FS.getConversionSpecifier();
+ FS.getConversionSpecifier();
FixItHint fixit =
- Amt.getHowSpecified() == analyze_printf::OptionalAmount::Constant
- ? FixItHint::CreateRemoval(getSpecifierRange(Amt.getStart(),
- Amt.getConstantLength()))
- : FixItHint();
+ Amt.getHowSpecified() == analyze_printf::OptionalAmount::Constant
+ ? FixItHint::CreateRemoval(
+ getSpecifierRange(Amt.getStart(), Amt.getConstantLength()))
+ : FixItHint();
EmitFormatDiagnostic(S.PDiag(diag::warn_printf_nonsensical_optional_amount)
- << type << CS.toString(),
+ << type << CS.toString(),
getLocationOfByte(Amt.getStart()),
- /*IsStringLocation*/true,
- getSpecifierRange(startSpecifier, specifierLen),
- fixit);
+ /*IsStringLocation*/ true,
+ getSpecifierRange(startSpecifier, specifierLen), fixit);
}
void CheckPrintfHandler::HandleFlag(const analyze_printf::PrintfSpecifier &FS,
@@ -8530,39 +8511,37 @@ void CheckPrintfHandler::HandleFlag(const analyze_printf::PrintfSpecifier &FS,
unsigned specifierLen) {
// Warn about pointless flag with a fixit removal.
const analyze_printf::PrintfConversionSpecifier &CS =
- FS.getConversionSpecifier();
- EmitFormatDiagnostic(S.PDiag(diag::warn_printf_nonsensical_flag)
- << flag.toString() << CS.toString(),
- getLocationOfByte(flag.getPosition()),
- /*IsStringLocation*/true,
- getSpecifierRange(startSpecifier, specifierLen),
- FixItHint::CreateRemoval(
- getSpecifierRange(flag.getPosition(), 1)));
+ FS.getConversionSpecifier();
+ EmitFormatDiagnostic(
+ S.PDiag(diag::warn_printf_nonsensical_flag)
+ << flag.toString() << CS.toString(),
+ getLocationOfByte(flag.getPosition()),
+ /*IsStringLocation*/ true,
+ getSpecifierRange(startSpecifier, specifierLen),
+ FixItHint::CreateRemoval(getSpecifierRange(flag.getPosition(), 1)));
}
void CheckPrintfHandler::HandleIgnoredFlag(
- const analyze_printf::PrintfSpecifier &FS,
- const analyze_printf::OptionalFlag &ignoredFlag,
- const analyze_printf::OptionalFlag &flag,
- const char *startSpecifier,
- unsigned specifierLen) {
+ const analyze_printf::PrintfSpecifier &FS,
+ const analyze_printf::OptionalFlag &ignoredFlag,
+ const analyze_printf::OptionalFlag &flag, const char *startSpecifier,
+ unsigned specifierLen) {
// Warn about ignored flag with a fixit removal.
EmitFormatDiagnostic(S.PDiag(diag::warn_printf_ignored_flag)
- << ignoredFlag.toString() << flag.toString(),
+ << ignoredFlag.toString() << flag.toString(),
getLocationOfByte(ignoredFlag.getPosition()),
- /*IsStringLocation*/true,
+ /*IsStringLocation*/ true,
getSpecifierRange(startSpecifier, specifierLen),
FixItHint::CreateRemoval(
- getSpecifierRange(ignoredFlag.getPosition(), 1)));
+ getSpecifierRange(ignoredFlag.getPosition(), 1)));
}
void CheckPrintfHandler::HandleEmptyObjCModifierFlag(const char *startFlag,
unsigned flagLen) {
// Warn about an empty flag.
- EmitFormatDiagnostic(S.PDiag(diag::warn_printf_empty_objc_flag),
- getLocationOfByte(startFlag),
- /*IsStringLocation*/true,
- getSpecifierRange(startFlag, flagLen));
+ EmitFormatDiagnostic(
+ S.PDiag(diag::warn_printf_empty_objc_flag), getLocationOfByte(startFlag),
+ /*IsStringLocation*/ true, getSpecifierRange(startFlag, flagLen));
}
void CheckPrintfHandler::HandleInvalidObjCModifierFlag(const char *startFlag,
@@ -8571,20 +8550,21 @@ void CheckPrintfHandler::HandleInvalidObjCModifierFlag(const char *startFlag,
auto Range = getSpecifierRange(startFlag, flagLen);
StringRef flag(startFlag, flagLen);
EmitFormatDiagnostic(S.PDiag(diag::warn_printf_invalid_objc_flag) << flag,
- getLocationOfByte(startFlag),
- /*IsStringLocation*/true,
- Range, FixItHint::CreateRemoval(Range));
+ getLocationOfByte(startFlag),
+ /*IsStringLocation*/ true, Range,
+ FixItHint::CreateRemoval(Range));
}
void CheckPrintfHandler::HandleObjCFlagsWithNonObjCConversion(
- const char *flagsStart, const char *flagsEnd, const char *conversionPosition) {
- // Warn about using '[...]' without a '@' conversion.
- auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
- auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
- EmitFormatDiagnostic(S.PDiag(diag) << StringRef(conversionPosition, 1),
- getLocationOfByte(conversionPosition),
- /*IsStringLocation*/ true, Range,
- FixItHint::CreateRemoval(Range));
+ const char *flagsStart, const char *flagsEnd,
+ const char *conversionPosition) {
+ // Warn about using '[...]' without a '@' conversion.
+ auto Range = getSpecifierRange(flagsStart, flagsEnd - flagsStart + 1);
+ auto diag = diag::warn_printf_ObjCflags_without_ObjCConversion;
+ EmitFormatDiagnostic(S.PDiag(diag) << StringRef(conversionPosition, 1),
+ getLocationOfByte(conversionPosition),
+ /*IsStringLocation*/ true, Range,
+ FixItHint::CreateRemoval(Range));
}
void EquatableFormatArgument::EmitDiagnostic(Sema &S, PartialDiagnostic PDiag,
@@ -8870,10 +8850,9 @@ bool CheckPrintfHandler::HandlePrintfSpecifier(
if (FS.consumesDataArgument()) {
if (atFirstArg) {
- atFirstArg = false;
- usesPositionalArgs = FS.usesPositionalArg();
- }
- else if (usesPositionalArgs != FS.usesPositionalArg()) {
+ atFirstArg = false;
+ usesPositionalArgs = FS.usesPositionalArg();
+ } else if (usesPositionalArgs != FS.usesPositionalArg()) {
HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
startSpecifier, specifierLen);
return false;
@@ -8882,13 +8861,13 @@ bool CheckPrintfHandler::HandlePrintfSpecifier(
// First check if the field width, precision, and conversion specifier
// have matching data arguments.
- if (!HandleAmount(FS.getFieldWidth(), /* field width */ 0,
- startSpecifier, specifierLen)) {
+ if (!HandleAmount(FS.getFieldWidth(), /* field width */ 0, startSpecifier,
+ specifierLen)) {
return false;
}
- if (!HandleAmount(FS.getPrecision(), /* precision */ 1,
- startSpecifier, specifierLen)) {
+ if (!HandleAmount(FS.getPrecision(), /* precision */ 1, startSpecifier,
+ specifierLen)) {
return false;
}
@@ -9010,13 +8989,13 @@ bool CheckPrintfHandler::HandlePrintfSpecifier(
// Check for invalid use of field width
if (!FS.hasValidFieldWidth()) {
HandleInvalidAmount(FS, FS.getFieldWidth(), /* field width */ 0,
- startSpecifier, specifierLen);
+ startSpecifier, specifierLen);
}
// Check for invalid use of precision
if (!FS.hasValidPrecision()) {
HandleInvalidAmount(FS, FS.getPrecision(), /* precision */ 1,
- startSpecifier, specifierLen);
+ startSpecifier, specifierLen);
}
// Precision is mandatory for %P specifier.
@@ -9045,10 +9024,10 @@ bool CheckPrintfHandler::HandlePrintfSpecifier(
// Check that flags are not ignored by another flag
if (FS.hasSpacePrefix() && FS.hasPlusPrefix()) // ' ' ignored by '+'
HandleIgnoredFlag(FS, FS.hasSpacePrefix(), FS.hasPlusPrefix(),
- startSpecifier, specifierLen);
+ startSpecifier, specifierLen);
if (FS.hasLeadingZeros() && FS.isLeftJustified()) // '0' ignored by '-'
HandleIgnoredFlag(FS, FS.hasLeadingZeros(), FS.isLeftJustified(),
- startSpecifier, specifierLen);
+ startSpecifier, specifierLen);
// Check the length modifier is valid with the given conversion specifier.
if (!FS.hasValidLengthModifier(S.getASTContext().getTargetInfo(),
@@ -9115,20 +9094,19 @@ static bool requiresParensToAddCast(const Expr *E) {
}
static std::pair<QualType, StringRef>
-shouldNotPrintDirectly(const ASTContext &Context,
- QualType IntendedTy,
+shouldNotPrintDirectly(const ASTContext &Context, QualType IntendedTy,
const Expr *E) {
// Use a 'while' to peel off layers of typedefs.
QualType TyTy = IntendedTy;
while (const TypedefType *UserTy = TyTy->getAs<TypedefType>()) {
StringRef Name = UserTy->getDecl()->getName();
QualType CastTy = llvm::StringSwitch<QualType>(Name)
- .Case("CFIndex", Context.getNSIntegerType())
- .Case("NSInteger", Context.getNSIntegerType())
- .Case("NSUInteger", Context.getNSUIntegerType())
- .Case("SInt32", Context.IntTy)
- .Case("UInt32", Context.UnsignedIntTy)
- .Default(QualType());
+ .Case("CFIndex", Context.getNSIntegerType())
+ .Case("NSInteger", Context.getNSIntegerType())
+ .Case("NSUInteger", Context.getNSUIntegerType())
+ .Case("SInt32", Context.IntTy)
+ .Case("UInt32", Context.UnsignedIntTy)
+ .Default(QualType());
if (!CastTy.isNull())
return std::make_pair(CastTy, Name);
@@ -9138,8 +9116,7 @@ shouldNotPrintDirectly(const ASTContext &Context,
// Strip parens if necessary.
if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
- return shouldNotPrintDirectly(Context,
- PE->getSubExpr()->getType(),
+ return shouldNotPrintDirectly(Context, PE->getSubExpr()->getType(),
PE->getSubExpr());
// If this is a conditional expression, then its result type is constructed
@@ -9150,14 +9127,10 @@ shouldNotPrintDirectly(const ASTContext &Context,
QualType TrueTy, FalseTy;
StringRef TrueName, FalseName;
- std::tie(TrueTy, TrueName) =
- shouldNotPrintDirectly(Context,
- CO->getTrueExpr()->getType(),
- CO->getTrueExpr());
- std::tie(FalseTy, FalseName) =
- shouldNotPrintDirectly(Context,
- CO->getFalseExpr()->getType(),
- CO->getFalseExpr());
+ std::tie(TrueTy, TrueName) = shouldNotPrintDirectly(
+ Context, CO->getTrueExpr()->getType(), CO->getTrueExpr());
+ std::tie(FalseTy, FalseName) = shouldNotPrintDirectly(
+ Context, CO->getFalseExpr()->getType(), CO->getFalseExpr());
if (TrueTy == FalseTy)
return std::make_pair(TrueTy, TrueName);
@@ -9173,8 +9146,8 @@ shouldNotPrintDirectly(const ASTContext &Context,
/// Return true if \p ICE is an implicit argument promotion of an arithmetic
/// type. Bit-field 'promotions' from a higher ranked type to a lower ranked
/// type do not count.
-static bool
-isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE) {
+static bool isArithmeticArgumentPromotion(Sema &S,
+ const ImplicitCastExpr *ICE) {
QualType From = ICE->getSubExpr()->getType();
QualType To = ICE->getType();
// It's an integer promotion if the destination type is the promoted
@@ -9210,11 +9183,9 @@ handleFormatSignedness(analyze_format_string::ArgType::MatchKind Match,
return Match;
}
-bool
-CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
- const char *StartSpecifier,
- unsigned SpecifierLen,
- const Expr *E) {
+bool CheckPrintfHandler::checkFormatExpr(
+ const analyze_printf::PrintfSpecifier &FS, const char *StartSpecifier,
+ unsigned SpecifierLen, const Expr *E) {
using namespace analyze_format_string;
using namespace analyze_printf;
@@ -9388,10 +9359,12 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
// Special-case some of Darwin's platform-independence types by suggesting
// casts to primitive types that are known to be large enough.
- bool ShouldNotPrintDirectly = false; StringRef CastTyName;
+ bool ShouldNotPrintDirectly = false;
+ StringRef CastTyName;
if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {
QualType CastTy;
- std::tie(CastTy, CastTyName) = shouldNotPrintDirectly(S.Context, IntendedTy, E);
+ std::tie(CastTy, CastTyName) =
+ shouldNotPrintDirectly(S.Context, IntendedTy, E);
if (!CastTy.isNull()) {
// %zi/%zu and %td/%tu are OK to use for NSInteger/NSUInteger of type int
// (long in ASTContext). Only complain to pedants or when they're the
@@ -9462,7 +9435,7 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
IntendedTy.print(CastFix, S.Context.getPrintingPolicy());
CastFix << (S.LangOpts.CPlusPlus ? ">" : ")");
- SmallVector<FixItHint,4> Hints;
+ SmallVector<FixItHint, 4> Hints;
ArgType::MatchKind IntendedMatch = AT.matchesType(S.Context, IntendedTy);
IntendedMatch = handleFormatSignedness(IntendedMatch, S.getDiagnostics(),
E->getExprLoc());
@@ -9526,8 +9499,8 @@ CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
}
}
} else {
- const CharSourceRange &CSR = getSpecifierRange(StartSpecifier,
- SpecifierLen);
+ const CharSourceRange &CSR =
+ getSpecifierRange(StartSpecifier, SpecifierLen);
// Since the warning for passing non-POD types to variadic functions
// was deferred until now, we emit a warning for non-POD
// arguments here.
@@ -9641,10 +9614,10 @@ class CheckScanfHandler : public CheckFormatHandler {
const char *startSpecifier,
unsigned specifierLen) override;
- bool HandleInvalidScanfConversionSpecifier(
- const analyze_scanf::ScanfSpecifier &FS,
- const char *startSpecifier,
- unsigned specifierLen) override;
+ bool
+ HandleInvalidScanfConversionSpecifier(const analyze_scanf::ScanfSpecifier &FS,
+ const char *startSpecifier,
+ unsigned specifierLen) override;
void HandleIncompleteScanList(const char *start, const char *end) override;
};
@@ -9654,27 +9627,24 @@ class CheckScanfHandler : public CheckFormatHandler {
void CheckScanfHandler::HandleIncompleteScanList(const char *start,
const char *end) {
EmitFormatDiagnostic(S.PDiag(diag::warn_scanf_scanlist_incomplete),
- getLocationOfByte(end), /*IsStringLocation*/true,
+ getLocationOfByte(end), /*IsStringLocation*/ true,
getSpecifierRange(start, end - start));
}
bool CheckScanfHandler::HandleInvalidScanfConversionSpecifier(
- const analyze_scanf::ScanfSpecifier &FS,
- const char *startSpecifier,
- unsigned specifierLen) {
+ const analyze_scanf::ScanfSpecifier &FS, const char *startSpecifier,
+ unsigned specifierLen) {
const analyze_scanf::ScanfConversionSpecifier &CS =
- FS.getConversionSpecifier();
+ FS.getConversionSpecifier();
- return HandleInvalidConversionSpecifier(FS.getArgIndex(),
- getLocationOfByte(CS.getStart()),
- startSpecifier, specifierLen,
- CS.getStart(), CS.getLength());
+ return HandleInvalidConversionSpecifier(
+ FS.getArgIndex(), getLocationOfByte(CS.getStart()), startSpecifier,
+ specifierLen, CS.getStart(), CS.getLength());
}
bool CheckScanfHandler::HandleScanfSpecifier(
- const analyze_scanf::ScanfSpecifier &FS,
- const char *startSpecifier,
- unsigned specifierLen) {
+ const analyze_scanf::ScanfSpecifier &FS, const char *startSpecifier,
+ unsigned specifierLen) {
using namespace analyze_scanf;
using namespace analyze_format_string;
@@ -9686,8 +9656,7 @@ bool CheckScanfHandler::HandleScanfSpecifier(
if (atFirstArg) {
atFirstArg = false;
usesPositionalArgs = FS.usesPositionalArg();
- }
- else if (usesPositionalArgs != FS.usesPositionalArg()) {
+ } else if (usesPositionalArgs != FS.usesPositionalArg()) {
HandlePositionalNonpositionalArgs(getLocationOfByte(CS.getStart()),
startSpecifier, specifierLen);
return false;
@@ -9698,11 +9667,11 @@ bool CheckScanfHandler::HandleScanfSpecifier(
const OptionalAmount &Amt = FS.getFieldWidth();
if (Amt.getHowSpecified() == OptionalAmount::Constant) {
if (Amt.getConstantAmount() == 0) {
- const CharSourceRange &R = getSpecifierRange(Amt.getStart(),
- Amt.getConstantLength());
+ const CharSourceRange &R =
+ getSpecifierRange(Amt.getStart(), Amt.getConstantLength());
EmitFormatDiagnostic(S.PDiag(diag::warn_scanf_nonzero_width),
getLocationOfByte(Amt.getStart()),
- /*IsStringLocation*/true, R,
+ /*IsStringLocation*/ true, R,
FixItHint::CreateRemoval(R));
}
}
@@ -9716,9 +9685,9 @@ bool CheckScanfHandler::HandleScanfSpecifier(
// Consume the argument.
unsigned argIndex = FS.getArgIndex();
if (argIndex < NumDataArgs) {
- // The check to see if the argIndex is valid will come later.
- // We set the bit here because we may exit early from this
- // function if we encounter some other error.
+ // The check to see if the argIndex is valid will come later.
+ // We set the bit here because we may exit early from this
+ // function if we encounter some other error.
CoveredArgs.set(argIndex);
}
@@ -9878,7 +9847,7 @@ static void CheckFormatString(
const char *Str = StrRef.data();
// Account for cases where the string literal is truncated in a declaration.
const ConstantArrayType *T =
- S.Context.getAsConstantArrayType(FExpr->getType());
+ S.Context.getAsConstantArrayType(FExpr->getType());
assert(T && "String literal not of constant array type!");
size_t TypeSize = T->getZExtSize();
size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
@@ -10021,9 +9990,8 @@ bool Sema::FormatStringHasSArg(const StringLiteral *FExpr) {
assert(T && "String literal not of constant array type!");
size_t TypeSize = T->getZExtSize();
size_t StrLen = std::min(std::max(TypeSize, size_t(1)) - 1, StrRef.size());
- return analyze_format_string::ParseFormatStringHasSArg(Str, Str + StrLen,
- getLangOpts(),
- Context.getTargetInfo());
+ return analyze_format_string::ParseFormatStringHasSArg(
+ Str, Str + StrLen, getLangOpts(), Context.getTargetInfo());
}
//===--- CHECK: Warn on use of wrong absolute value function. -------------===//
More information about the cfe-commits
mailing list