1 //== PrintfFormatString.cpp - Analysis of printf format strings --*- C++ -*-==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // Handling of format string in printf and friends. The structure of format
11 // strings for fprintf() are described in C99 7.19.6.1.
13 //===----------------------------------------------------------------------===//
15 #include "clang/Analysis/Analyses/FormatString.h"
16 #include "FormatStringParsing.h"
17 #include "clang/Basic/TargetInfo.h"
19 using clang::analyze_format_string::ArgType;
20 using clang::analyze_format_string::FormatStringHandler;
21 using clang::analyze_format_string::LengthModifier;
22 using clang::analyze_format_string::OptionalAmount;
23 using clang::analyze_format_string::ConversionSpecifier;
24 using clang::analyze_printf::PrintfSpecifier;
26 using namespace clang;
28 typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
29 PrintfSpecifierResult;
31 //===----------------------------------------------------------------------===//
32 // Methods for parsing format strings.
33 //===----------------------------------------------------------------------===//
35 using analyze_format_string::ParseNonPositionAmount;
37 static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
38 const char *Start, const char *&Beg, const char *E,
41 FS.setPrecision(ParseNonPositionAmount(Beg, E, *argIndex));
43 const OptionalAmount Amt = ParsePositionAmount(H, Start, Beg, E,
44 analyze_format_string::PrecisionPos);
52 static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
56 const LangOptions &LO,
57 const TargetInfo &Target) {
59 using namespace clang::analyze_format_string;
60 using namespace clang::analyze_printf;
63 const char *Start = 0;
64 UpdateOnReturn <const char*> UpdateBeg(Beg, I);
66 // Look for a '%' character that indicates the start of a format specifier.
67 for ( ; I != E ; ++I) {
70 // Detect spurious null characters, which are likely errors.
75 Start = I++; // Record the start of the format specifier.
80 // No format specifier found?
85 // No more characters left?
86 H.HandleIncompleteSpecifier(Start, E - Start);
91 if (ParseArgPosition(H, FS, Start, I, E))
95 // No more characters left?
96 H.HandleIncompleteSpecifier(Start, E - Start);
100 // Look for flags (if any).
102 for ( ; I != E; ++I) {
104 default: hasMore = false; break;
106 // FIXME: POSIX specific. Always accept?
107 FS.setHasThousandsGrouping(I);
109 case '-': FS.setIsLeftJustified(I); break;
110 case '+': FS.setHasPlusPrefix(I); break;
111 case ' ': FS.setHasSpacePrefix(I); break;
112 case '#': FS.setHasAlternativeForm(I); break;
113 case '0': FS.setHasLeadingZeros(I); break;
120 // No more characters left?
121 H.HandleIncompleteSpecifier(Start, E - Start);
125 // Look for the field width (if any).
126 if (ParseFieldWidth(H, FS, Start, I, E,
127 FS.usesPositionalArg() ? 0 : &argIndex))
131 // No more characters left?
132 H.HandleIncompleteSpecifier(Start, E - Start);
136 // Look for the precision (if any).
140 H.HandleIncompleteSpecifier(Start, E - Start);
144 if (ParsePrecision(H, FS, Start, I, E,
145 FS.usesPositionalArg() ? 0 : &argIndex))
149 // No more characters left?
150 H.HandleIncompleteSpecifier(Start, E - Start);
155 // Look for the length modifier.
156 if (ParseLengthModifier(FS, I, E, LO) && I == E) {
157 // No more characters left?
158 H.HandleIncompleteSpecifier(Start, E - Start);
163 // Detect spurious null characters, which are likely errors.
168 // Finally, look for the conversion specifier.
169 const char *conversionPosition = I++;
170 ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
171 switch (*conversionPosition) {
174 // C99: 7.19.6.1 (section 8).
175 case '%': k = ConversionSpecifier::PercentArg; break;
176 case 'A': k = ConversionSpecifier::AArg; break;
177 case 'E': k = ConversionSpecifier::EArg; break;
178 case 'F': k = ConversionSpecifier::FArg; break;
179 case 'G': k = ConversionSpecifier::GArg; break;
180 case 'X': k = ConversionSpecifier::XArg; break;
181 case 'a': k = ConversionSpecifier::aArg; break;
182 case 'c': k = ConversionSpecifier::cArg; break;
183 case 'd': k = ConversionSpecifier::dArg; break;
184 case 'e': k = ConversionSpecifier::eArg; break;
185 case 'f': k = ConversionSpecifier::fArg; break;
186 case 'g': k = ConversionSpecifier::gArg; break;
187 case 'i': k = ConversionSpecifier::iArg; break;
188 case 'n': k = ConversionSpecifier::nArg; break;
189 case 'o': k = ConversionSpecifier::oArg; break;
190 case 'p': k = ConversionSpecifier::pArg; break;
191 case 's': k = ConversionSpecifier::sArg; break;
192 case 'u': k = ConversionSpecifier::uArg; break;
193 case 'x': k = ConversionSpecifier::xArg; break;
195 case 'C': k = ConversionSpecifier::CArg; break;
196 case 'S': k = ConversionSpecifier::SArg; break;
198 case '@': k = ConversionSpecifier::ObjCObjArg; break;
200 case 'm': k = ConversionSpecifier::PrintErrno; break;
201 // FreeBSD format extensions
203 if (LO.FormatExtensions)
204 k = ConversionSpecifier::FreeBSDbArg; // int followed by char *
207 if (LO.FormatExtensions)
208 k = ConversionSpecifier::FreeBSDrArg;
211 if (LO.FormatExtensions)
212 k = ConversionSpecifier::iArg;
216 if (Target.getTriple().isOSDarwin())
217 k = ConversionSpecifier::DArg;
218 else if (LO.FormatExtensions)
219 k = ConversionSpecifier::FreeBSDDArg; // u_char * followed by char *
222 if (Target.getTriple().isOSDarwin())
223 k = ConversionSpecifier::OArg;
226 if (Target.getTriple().isOSDarwin())
227 k = ConversionSpecifier::UArg;
230 PrintfConversionSpecifier CS(conversionPosition, k);
231 FS.setConversionSpecifier(CS);
232 if (CS.consumesDataArgument() && !FS.usesPositionalArg())
233 FS.setArgIndex(argIndex++);
235 if (k == ConversionSpecifier::FreeBSDbArg ||
236 k == ConversionSpecifier::FreeBSDDArg)
239 if (k == ConversionSpecifier::InvalidSpecifier) {
240 // Assume the conversion takes one argument.
241 return !H.HandleInvalidPrintfConversionSpecifier(FS, Start, I - Start);
243 return PrintfSpecifierResult(Start, FS);
246 bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
249 const LangOptions &LO,
250 const TargetInfo &Target) {
252 unsigned argIndex = 0;
254 // Keep looking for a format specifier until we have exhausted the string.
256 const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex,
258 // Did a fail-stop error of any kind occur when parsing the specifier?
259 // If so, don't do any more processing.
260 if (FSR.shouldStop())
262 // Did we exhaust the string or encounter an error that
263 // we can recover from?
266 // We have a format specifier. Pass it to the callback.
267 if (!H.HandlePrintfSpecifier(FSR.getValue(), FSR.getStart(),
271 assert(I == E && "Format string not exhausted");
275 //===----------------------------------------------------------------------===//
276 // Methods on PrintfSpecifier.
277 //===----------------------------------------------------------------------===//
279 ArgType PrintfSpecifier::getArgType(ASTContext &Ctx,
280 bool IsObjCLiteral) const {
281 const PrintfConversionSpecifier &CS = getConversionSpecifier();
283 if (!CS.consumesDataArgument())
284 return ArgType::Invalid();
286 if (CS.getKind() == ConversionSpecifier::cArg)
287 switch (LM.getKind()) {
288 case LengthModifier::None: return Ctx.IntTy;
289 case LengthModifier::AsLong:
290 return ArgType(ArgType::WIntTy, "wint_t");
292 return ArgType::Invalid();
296 switch (LM.getKind()) {
297 case LengthModifier::AsLongDouble:
299 return Ctx.LongLongTy;
300 case LengthModifier::None:
302 case LengthModifier::AsInt32:
303 return ArgType(Ctx.IntTy, "__int32");
304 case LengthModifier::AsChar: return ArgType::AnyCharTy;
305 case LengthModifier::AsShort: return Ctx.ShortTy;
306 case LengthModifier::AsLong: return Ctx.LongTy;
307 case LengthModifier::AsLongLong:
308 case LengthModifier::AsQuad:
309 return Ctx.LongLongTy;
310 case LengthModifier::AsInt64:
311 return ArgType(Ctx.LongLongTy, "__int64");
312 case LengthModifier::AsIntMax:
313 return ArgType(Ctx.getIntMaxType(), "intmax_t");
314 case LengthModifier::AsSizeT:
315 // FIXME: How to get the corresponding signed version of size_t?
317 case LengthModifier::AsInt3264:
318 return Ctx.getTargetInfo().getTriple().isArch64Bit()
319 ? ArgType(Ctx.LongLongTy, "__int64")
320 : ArgType(Ctx.IntTy, "__int32");
321 case LengthModifier::AsPtrDiff:
322 return ArgType(Ctx.getPointerDiffType(), "ptrdiff_t");
323 case LengthModifier::AsAllocate:
324 case LengthModifier::AsMAllocate:
325 return ArgType::Invalid();
329 switch (LM.getKind()) {
330 case LengthModifier::AsLongDouble:
332 return Ctx.UnsignedLongLongTy;
333 case LengthModifier::None:
334 return Ctx.UnsignedIntTy;
335 case LengthModifier::AsInt32:
336 return ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
337 case LengthModifier::AsChar: return Ctx.UnsignedCharTy;
338 case LengthModifier::AsShort: return Ctx.UnsignedShortTy;
339 case LengthModifier::AsLong: return Ctx.UnsignedLongTy;
340 case LengthModifier::AsLongLong:
341 case LengthModifier::AsQuad:
342 return Ctx.UnsignedLongLongTy;
343 case LengthModifier::AsInt64:
344 return ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64");
345 case LengthModifier::AsIntMax:
346 return ArgType(Ctx.getUIntMaxType(), "uintmax_t");
347 case LengthModifier::AsSizeT:
348 return ArgType(Ctx.getSizeType(), "size_t");
349 case LengthModifier::AsInt3264:
350 return Ctx.getTargetInfo().getTriple().isArch64Bit()
351 ? ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64")
352 : ArgType(Ctx.UnsignedIntTy, "unsigned __int32");
353 case LengthModifier::AsPtrDiff:
354 // FIXME: How to get the corresponding unsigned
355 // version of ptrdiff_t?
357 case LengthModifier::AsAllocate:
358 case LengthModifier::AsMAllocate:
359 return ArgType::Invalid();
362 if (CS.isDoubleArg()) {
363 if (LM.getKind() == LengthModifier::AsLongDouble)
364 return Ctx.LongDoubleTy;
368 if (CS.getKind() == ConversionSpecifier::nArg) {
369 switch (LM.getKind()) {
370 case LengthModifier::None:
371 return ArgType::PtrTo(Ctx.IntTy);
372 case LengthModifier::AsChar:
373 return ArgType::PtrTo(Ctx.SignedCharTy);
374 case LengthModifier::AsShort:
375 return ArgType::PtrTo(Ctx.ShortTy);
376 case LengthModifier::AsLong:
377 return ArgType::PtrTo(Ctx.LongTy);
378 case LengthModifier::AsLongLong:
379 case LengthModifier::AsQuad:
380 return ArgType::PtrTo(Ctx.LongLongTy);
381 case LengthModifier::AsIntMax:
382 return ArgType::PtrTo(ArgType(Ctx.getIntMaxType(), "intmax_t"));
383 case LengthModifier::AsSizeT:
384 return ArgType(); // FIXME: ssize_t
385 case LengthModifier::AsPtrDiff:
386 return ArgType::PtrTo(ArgType(Ctx.getPointerDiffType(), "ptrdiff_t"));
387 case LengthModifier::AsLongDouble:
388 return ArgType(); // FIXME: Is this a known extension?
389 case LengthModifier::AsAllocate:
390 case LengthModifier::AsMAllocate:
391 case LengthModifier::AsInt32:
392 case LengthModifier::AsInt3264:
393 case LengthModifier::AsInt64:
394 return ArgType::Invalid();
398 switch (CS.getKind()) {
399 case ConversionSpecifier::sArg:
400 if (LM.getKind() == LengthModifier::AsWideChar) {
402 return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
404 return ArgType(ArgType::WCStrTy, "wchar_t *");
406 return ArgType::CStrTy;
407 case ConversionSpecifier::SArg:
409 return ArgType(Ctx.getPointerType(Ctx.UnsignedShortTy.withConst()),
411 return ArgType(ArgType::WCStrTy, "wchar_t *");
412 case ConversionSpecifier::CArg:
414 return ArgType(Ctx.UnsignedShortTy, "unichar");
415 return ArgType(Ctx.WideCharTy, "wchar_t");
416 case ConversionSpecifier::pArg:
417 return ArgType::CPointerTy;
418 case ConversionSpecifier::ObjCObjArg:
419 return ArgType::ObjCPointerTy;
424 // FIXME: Handle other cases.
428 bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
429 ASTContext &Ctx, bool IsObjCLiteral) {
430 // %n is different from other conversion specifiers; don't try to fix it.
431 if (CS.getKind() == ConversionSpecifier::nArg)
434 // Handle Objective-C objects first. Note that while the '%@' specifier will
435 // not warn for structure pointer or void pointer arguments (because that's
436 // how CoreFoundation objects are implemented), we only show a fixit for '%@'
437 // if we know it's an object (block, id, class, or __attribute__((NSObject))).
438 if (QT->isObjCRetainableType()) {
442 CS.setKind(ConversionSpecifier::ObjCObjArg);
444 // Disable irrelevant flags
445 HasThousandsGrouping = false;
446 HasPlusPrefix = false;
447 HasSpacePrefix = false;
448 HasAlternativeForm = false;
449 HasLeadingZeroes = false;
450 Precision.setHowSpecified(OptionalAmount::NotSpecified);
451 LM.setKind(LengthModifier::None);
456 // Handle strings next (char *, wchar_t *)
457 if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
458 CS.setKind(ConversionSpecifier::sArg);
460 // Disable irrelevant flags
461 HasAlternativeForm = 0;
462 HasLeadingZeroes = 0;
464 // Set the long length modifier for wide characters
465 if (QT->getPointeeType()->isWideCharType())
466 LM.setKind(LengthModifier::AsWideChar);
468 LM.setKind(LengthModifier::None);
473 // If it's an enum, get its underlying type.
474 if (const EnumType *ETy = QT->getAs<EnumType>())
475 QT = ETy->getDecl()->getIntegerType();
477 // We can only work with builtin types.
478 const BuiltinType *BT = QT->getAs<BuiltinType>();
482 // Set length modifier
483 switch (BT->getKind()) {
484 case BuiltinType::Bool:
485 case BuiltinType::WChar_U:
486 case BuiltinType::WChar_S:
487 case BuiltinType::Char16:
488 case BuiltinType::Char32:
489 case BuiltinType::UInt128:
490 case BuiltinType::Int128:
491 case BuiltinType::Half:
492 // Various types which are non-trivial to correct.
495 #define SIGNED_TYPE(Id, SingletonId)
496 #define UNSIGNED_TYPE(Id, SingletonId)
497 #define FLOATING_TYPE(Id, SingletonId)
498 #define BUILTIN_TYPE(Id, SingletonId) \
499 case BuiltinType::Id:
500 #include "clang/AST/BuiltinTypes.def"
501 // Misc other stuff which doesn't make sense here.
504 case BuiltinType::UInt:
505 case BuiltinType::Int:
506 case BuiltinType::Float:
507 case BuiltinType::Double:
508 LM.setKind(LengthModifier::None);
511 case BuiltinType::Char_U:
512 case BuiltinType::UChar:
513 case BuiltinType::Char_S:
514 case BuiltinType::SChar:
515 LM.setKind(LengthModifier::AsChar);
518 case BuiltinType::Short:
519 case BuiltinType::UShort:
520 LM.setKind(LengthModifier::AsShort);
523 case BuiltinType::Long:
524 case BuiltinType::ULong:
525 LM.setKind(LengthModifier::AsLong);
528 case BuiltinType::LongLong:
529 case BuiltinType::ULongLong:
530 LM.setKind(LengthModifier::AsLongLong);
533 case BuiltinType::LongDouble:
534 LM.setKind(LengthModifier::AsLongDouble);
538 // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
539 if (isa<TypedefType>(QT) && (LangOpt.C99 || LangOpt.CPlusPlus11))
540 namedTypeToLengthModifier(QT, LM);
542 // If fixing the length modifier was enough, we might be done.
543 if (hasValidLengthModifier(Ctx.getTargetInfo())) {
544 // If we're going to offer a fix anyway, make sure the sign matches.
545 switch (CS.getKind()) {
546 case ConversionSpecifier::uArg:
547 case ConversionSpecifier::UArg:
548 if (QT->isSignedIntegerType())
549 CS.setKind(clang::analyze_format_string::ConversionSpecifier::dArg);
551 case ConversionSpecifier::dArg:
552 case ConversionSpecifier::DArg:
553 case ConversionSpecifier::iArg:
554 if (QT->isUnsignedIntegerType() && !HasPlusPrefix)
555 CS.setKind(clang::analyze_format_string::ConversionSpecifier::uArg);
558 // Other specifiers do not have signed/unsigned variants.
562 const analyze_printf::ArgType &ATR = getArgType(Ctx, IsObjCLiteral);
563 if (ATR.isValid() && ATR.matchesType(Ctx, QT))
567 // Set conversion specifier and disable any flags which do not apply to it.
568 // Let typedefs to char fall through to int, as %c is silly for uint8_t.
569 if (!isa<TypedefType>(QT) && QT->isCharType()) {
570 CS.setKind(ConversionSpecifier::cArg);
571 LM.setKind(LengthModifier::None);
572 Precision.setHowSpecified(OptionalAmount::NotSpecified);
573 HasAlternativeForm = 0;
574 HasLeadingZeroes = 0;
577 // Test for Floating type first as LongDouble can pass isUnsignedIntegerType
578 else if (QT->isRealFloatingType()) {
579 CS.setKind(ConversionSpecifier::fArg);
581 else if (QT->isSignedIntegerType()) {
582 CS.setKind(ConversionSpecifier::dArg);
583 HasAlternativeForm = 0;
585 else if (QT->isUnsignedIntegerType()) {
586 CS.setKind(ConversionSpecifier::uArg);
587 HasAlternativeForm = 0;
590 llvm_unreachable("Unexpected type");
596 void PrintfSpecifier::toString(raw_ostream &os) const {
597 // Whilst some features have no defined order, we are using the order
598 // appearing in the C99 standard (ISO/IEC 9899:1999 (E) 7.19.6.1)
602 if (usesPositionalArg()) {
603 os << getPositionalArgIndex() << "$";
607 if (IsLeftJustified) os << "-";
608 if (HasPlusPrefix) os << "+";
609 if (HasSpacePrefix) os << " ";
610 if (HasAlternativeForm) os << "#";
611 if (HasLeadingZeroes) os << "0";
613 // Minimum field width
614 FieldWidth.toString(os);
616 Precision.toString(os);
619 // Conversion specifier
623 bool PrintfSpecifier::hasValidPlusPrefix() const {
627 // The plus prefix only makes sense for signed conversions
628 switch (CS.getKind()) {
629 case ConversionSpecifier::dArg:
630 case ConversionSpecifier::DArg:
631 case ConversionSpecifier::iArg:
632 case ConversionSpecifier::fArg:
633 case ConversionSpecifier::FArg:
634 case ConversionSpecifier::eArg:
635 case ConversionSpecifier::EArg:
636 case ConversionSpecifier::gArg:
637 case ConversionSpecifier::GArg:
638 case ConversionSpecifier::aArg:
639 case ConversionSpecifier::AArg:
640 case ConversionSpecifier::FreeBSDrArg:
648 bool PrintfSpecifier::hasValidAlternativeForm() const {
649 if (!HasAlternativeForm)
652 // Alternate form flag only valid with the oxXaAeEfFgG conversions
653 switch (CS.getKind()) {
654 case ConversionSpecifier::oArg:
655 case ConversionSpecifier::OArg:
656 case ConversionSpecifier::xArg:
657 case ConversionSpecifier::XArg:
658 case ConversionSpecifier::aArg:
659 case ConversionSpecifier::AArg:
660 case ConversionSpecifier::eArg:
661 case ConversionSpecifier::EArg:
662 case ConversionSpecifier::fArg:
663 case ConversionSpecifier::FArg:
664 case ConversionSpecifier::gArg:
665 case ConversionSpecifier::GArg:
666 case ConversionSpecifier::FreeBSDrArg:
674 bool PrintfSpecifier::hasValidLeadingZeros() const {
675 if (!HasLeadingZeroes)
678 // Leading zeroes flag only valid with the diouxXaAeEfFgG conversions
679 switch (CS.getKind()) {
680 case ConversionSpecifier::dArg:
681 case ConversionSpecifier::DArg:
682 case ConversionSpecifier::iArg:
683 case ConversionSpecifier::oArg:
684 case ConversionSpecifier::OArg:
685 case ConversionSpecifier::uArg:
686 case ConversionSpecifier::UArg:
687 case ConversionSpecifier::xArg:
688 case ConversionSpecifier::XArg:
689 case ConversionSpecifier::aArg:
690 case ConversionSpecifier::AArg:
691 case ConversionSpecifier::eArg:
692 case ConversionSpecifier::EArg:
693 case ConversionSpecifier::fArg:
694 case ConversionSpecifier::FArg:
695 case ConversionSpecifier::gArg:
696 case ConversionSpecifier::GArg:
704 bool PrintfSpecifier::hasValidSpacePrefix() const {
708 // The space prefix only makes sense for signed conversions
709 switch (CS.getKind()) {
710 case ConversionSpecifier::dArg:
711 case ConversionSpecifier::DArg:
712 case ConversionSpecifier::iArg:
713 case ConversionSpecifier::fArg:
714 case ConversionSpecifier::FArg:
715 case ConversionSpecifier::eArg:
716 case ConversionSpecifier::EArg:
717 case ConversionSpecifier::gArg:
718 case ConversionSpecifier::GArg:
719 case ConversionSpecifier::aArg:
720 case ConversionSpecifier::AArg:
728 bool PrintfSpecifier::hasValidLeftJustified() const {
729 if (!IsLeftJustified)
732 // The left justified flag is valid for all conversions except n
733 switch (CS.getKind()) {
734 case ConversionSpecifier::nArg:
742 bool PrintfSpecifier::hasValidThousandsGroupingPrefix() const {
743 if (!HasThousandsGrouping)
746 switch (CS.getKind()) {
747 case ConversionSpecifier::dArg:
748 case ConversionSpecifier::DArg:
749 case ConversionSpecifier::iArg:
750 case ConversionSpecifier::uArg:
751 case ConversionSpecifier::UArg:
752 case ConversionSpecifier::fArg:
753 case ConversionSpecifier::FArg:
754 case ConversionSpecifier::gArg:
755 case ConversionSpecifier::GArg:
762 bool PrintfSpecifier::hasValidPrecision() const {
763 if (Precision.getHowSpecified() == OptionalAmount::NotSpecified)
766 // Precision is only valid with the diouxXaAeEfFgGs conversions
767 switch (CS.getKind()) {
768 case ConversionSpecifier::dArg:
769 case ConversionSpecifier::DArg:
770 case ConversionSpecifier::iArg:
771 case ConversionSpecifier::oArg:
772 case ConversionSpecifier::OArg:
773 case ConversionSpecifier::uArg:
774 case ConversionSpecifier::UArg:
775 case ConversionSpecifier::xArg:
776 case ConversionSpecifier::XArg:
777 case ConversionSpecifier::aArg:
778 case ConversionSpecifier::AArg:
779 case ConversionSpecifier::eArg:
780 case ConversionSpecifier::EArg:
781 case ConversionSpecifier::fArg:
782 case ConversionSpecifier::FArg:
783 case ConversionSpecifier::gArg:
784 case ConversionSpecifier::GArg:
785 case ConversionSpecifier::sArg:
792 bool PrintfSpecifier::hasValidFieldWidth() const {
793 if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
796 // The field width is valid for all conversions except n
797 switch (CS.getKind()) {
798 case ConversionSpecifier::nArg: