1//= ScanfFormatString.cpp - Analysis of printf format strings --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Handling of format string in scanf and friends. The structure of format
10// strings for fscanf() are described in C99 7.19.6.2.
11//
12//===----------------------------------------------------------------------===//
13
14#include "FormatStringParsing.h"
15#include "clang/AST/FormatString.h"
16#include "clang/Basic/TargetInfo.h"
17
18using clang::UpdateOnReturn;
19using clang::analyze_format_string::ArgType;
20using clang::analyze_format_string::ConversionSpecifier;
21using clang::analyze_format_string::FormatStringHandler;
22using clang::analyze_format_string::LengthModifier;
23using clang::analyze_format_string::OptionalAmount;
24using clang::analyze_scanf::ScanfConversionSpecifier;
25using clang::analyze_scanf::ScanfSpecifier;
26using namespace clang;
27
28typedef clang::analyze_format_string::SpecifierResult<ScanfSpecifier>
29 ScanfSpecifierResult;
30
31namespace {
32
33class ScanfFormatStringParser : analyze_format_string::FormatStringParser {
34public:
35 ScanfFormatStringParser(FormatStringHandler &H, const LangOptions &LO,
36 const TargetInfo &Target)
37 : FormatStringParser(H, LO, Target, /*IsScanf=*/true) {}
38
39 ScanfSpecifierResult parseSpecifier(const char *&Beg, const char *E,
40 unsigned &argIndex) const;
41
42private:
43 bool parseScanList(ScanfConversionSpecifier &CS, const char *&Beg,
44 const char *E) const;
45};
46
47} // namespace
48
49bool ScanfFormatStringParser::parseScanList(ScanfConversionSpecifier &CS,
50 const char *&Beg,
51 const char *E) const {
52 const char *I = Beg;
53 const char *start = I - 1;
54 UpdateOnReturn<const char *> UpdateBeg(Beg, I);
55
56 // No more characters?
57 if (I == E) {
58 H.HandleIncompleteScanList(start, end: I);
59 return true;
60 }
61
62 // Special case: ']' is the first character.
63 if (*I == ']') {
64 if (++I == E) {
65 H.HandleIncompleteScanList(start, end: I - 1);
66 return true;
67 }
68 }
69
70 // Special case: "^]" are the first characters.
71 if (I + 1 != E && I[0] == '^' && I[1] == ']') {
72 I += 2;
73 if (I == E) {
74 H.HandleIncompleteScanList(start, end: I - 1);
75 return true;
76 }
77 }
78
79 // Look for a ']' character which denotes the end of the scan list.
80 while (*I != ']') {
81 if (++I == E) {
82 H.HandleIncompleteScanList(start, end: I - 1);
83 return true;
84 }
85 }
86
87 CS.setEndScanList(I);
88 return false;
89}
90
91// FIXME: Much of this is copy-paste from PrintfFormatStringParser.
92// We can possibly refactor.
93ScanfSpecifierResult
94ScanfFormatStringParser::parseSpecifier(const char *&Beg, const char *E,
95 unsigned &argIndex) const {
96 using namespace clang::analyze_format_string;
97 using namespace clang::analyze_scanf;
98 const char *I = Beg;
99 const char *Start = nullptr;
100 UpdateOnReturn<const char *> UpdateBeg(Beg, I);
101
102 // Look for a '%' character that indicates the start of a format specifier.
103 for (; I != E; ++I) {
104 char c = *I;
105 if (c == '\0') {
106 // Detect spurious null characters, which are likely errors.
107 H.HandleNullChar(nullCharacter: I);
108 return true;
109 }
110 if (c == '%') {
111 Start = I++; // Record the start of the format specifier.
112 break;
113 }
114 }
115
116 // No format specifier found?
117 if (!Start)
118 return false;
119
120 if (I == E) {
121 // No more characters left?
122 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
123 return true;
124 }
125
126 ScanfSpecifier FS;
127 if (parseArgPosition(CS&: FS, Start, Beg&: I, E))
128 return true;
129
130 if (I == E) {
131 // No more characters left?
132 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
133 return true;
134 }
135
136 // Look for '*' flag if it is present.
137 if (*I == '*') {
138 FS.setSuppressAssignment(I);
139 if (++I == E) {
140 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
141 return true;
142 }
143 }
144
145 // Look for the field width (if any). Unlike printf, this is either
146 // a fixed integer or isn't present.
147 const OptionalAmount &Amt = parseAmount(Beg&: I, E);
148 if (Amt.getHowSpecified() != OptionalAmount::NotSpecified) {
149 assert(Amt.getHowSpecified() == OptionalAmount::Constant);
150 FS.setFieldWidth(Amt);
151
152 if (I == E) {
153 // No more characters left?
154 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
155 return true;
156 }
157 }
158
159 // Look for the length modifier.
160 if (parseLengthModifier(FS, Beg&: I, E) && I == E) {
161 // No more characters left?
162 H.HandleIncompleteSpecifier(startSpecifier: Start, specifierLen: E - Start);
163 return true;
164 }
165
166 // Detect spurious null characters, which are likely errors.
167 if (*I == '\0') {
168 H.HandleNullChar(nullCharacter: I);
169 return true;
170 }
171
172 // Finally, look for the conversion specifier.
173 const char *conversionPosition = I++;
174 ScanfConversionSpecifier::Kind k = ScanfConversionSpecifier::InvalidSpecifier;
175 switch (*conversionPosition) {
176 default:
177 break;
178 case '%':
179 k = ConversionSpecifier::PercentArg;
180 break;
181 case 'b':
182 k = ConversionSpecifier::bArg;
183 break;
184 case 'A':
185 k = ConversionSpecifier::AArg;
186 break;
187 case 'E':
188 k = ConversionSpecifier::EArg;
189 break;
190 case 'F':
191 k = ConversionSpecifier::FArg;
192 break;
193 case 'G':
194 k = ConversionSpecifier::GArg;
195 break;
196 case 'X':
197 k = ConversionSpecifier::XArg;
198 break;
199 case 'a':
200 k = ConversionSpecifier::aArg;
201 break;
202 case 'd':
203 k = ConversionSpecifier::dArg;
204 break;
205 case 'e':
206 k = ConversionSpecifier::eArg;
207 break;
208 case 'f':
209 k = ConversionSpecifier::fArg;
210 break;
211 case 'g':
212 k = ConversionSpecifier::gArg;
213 break;
214 case 'i':
215 k = ConversionSpecifier::iArg;
216 break;
217 case 'n':
218 k = ConversionSpecifier::nArg;
219 break;
220 case 'c':
221 k = ConversionSpecifier::cArg;
222 break;
223 case 'C':
224 k = ConversionSpecifier::CArg;
225 break;
226 case 'S':
227 k = ConversionSpecifier::SArg;
228 break;
229 case '[':
230 k = ConversionSpecifier::ScanListArg;
231 break;
232 case 'u':
233 k = ConversionSpecifier::uArg;
234 break;
235 case 'x':
236 k = ConversionSpecifier::xArg;
237 break;
238 case 'o':
239 k = ConversionSpecifier::oArg;
240 break;
241 case 's':
242 k = ConversionSpecifier::sArg;
243 break;
244 case 'p':
245 k = ConversionSpecifier::pArg;
246 break;
247 // Apple extensions
248 // Apple-specific
249 case 'D':
250 if (Target.getTriple().isOSDarwin())
251 k = ConversionSpecifier::DArg;
252 break;
253 case 'O':
254 if (Target.getTriple().isOSDarwin())
255 k = ConversionSpecifier::OArg;
256 break;
257 case 'U':
258 if (Target.getTriple().isOSDarwin())
259 k = ConversionSpecifier::UArg;
260 break;
261 }
262 ScanfConversionSpecifier CS(conversionPosition, k);
263 if (k == ScanfConversionSpecifier::ScanListArg) {
264 if (parseScanList(CS, Beg&: I, E))
265 return true;
266 }
267 FS.setConversionSpecifier(CS);
268 if (CS.consumesDataArgument() && !FS.getSuppressAssignment() &&
269 !FS.usesPositionalArg())
270 FS.setArgIndex(argIndex++);
271
272 // FIXME: '%' and '*' doesn't make sense. Issue a warning.
273 // FIXME: 'ConsumedSoFar' and '*' doesn't make sense.
274
275 if (k == ScanfConversionSpecifier::InvalidSpecifier) {
276 unsigned Len = I - Beg;
277 if (parseUTF8InvalidSpecifier(SpecifierBegin: Beg, FmtStrEnd: E, Len)) {
278 CS.setEndScanList(Beg + Len);
279 FS.setConversionSpecifier(CS);
280 }
281 // Assume the conversion takes one argument.
282 return !H.HandleInvalidScanfConversionSpecifier(FS, startSpecifier: Beg, specifierLen: Len);
283 }
284 return ScanfSpecifierResult(Start, FS);
285}
286
287ArgType ScanfSpecifier::getArgType(ASTContext &Ctx) const {
288 const ScanfConversionSpecifier &CS = getConversionSpecifier();
289
290 if (!CS.consumesDataArgument())
291 return ArgType::Invalid();
292
293 switch (CS.getKind()) {
294 // Signed int.
295 case ConversionSpecifier::dArg:
296 case ConversionSpecifier::DArg:
297 case ConversionSpecifier::iArg:
298 switch (LM.getKind()) {
299 case LengthModifier::None:
300 return ArgType::PtrTo(A: Ctx.IntTy);
301 case LengthModifier::AsChar:
302 return ArgType::PtrTo(A: ArgType::AnyCharTy);
303 case LengthModifier::AsShort:
304 return ArgType::PtrTo(A: Ctx.ShortTy);
305 case LengthModifier::AsLong:
306 return ArgType::PtrTo(A: Ctx.LongTy);
307 case LengthModifier::AsLongLong:
308 case LengthModifier::AsQuad:
309 return ArgType::PtrTo(A: Ctx.LongLongTy);
310 case LengthModifier::AsInt64:
311 return ArgType::PtrTo(A: ArgType(Ctx.LongLongTy, "__int64"));
312 case LengthModifier::AsIntMax:
313 return ArgType::PtrTo(A: ArgType(Ctx.getIntMaxType(), "intmax_t"));
314 case LengthModifier::AsSizeT:
315 return ArgType::PtrTo(A: ArgType::makeSizeT(
316 A: ArgType(Ctx.getSignedSizeType(), "signed size_t")));
317 case LengthModifier::AsPtrDiff:
318 return ArgType::PtrTo(A: ArgType::makePtrdiffT(
319 A: ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")));
320 case LengthModifier::AsIntN:
321 case LengthModifier::AsFastIntN:
322 return ArgType::PtrTo(A: ArgType::makeIntNType(Ctx, LengthMod: LM, /*Signed=*/true));
323 case LengthModifier::AsLongDouble:
324 // GNU extension.
325 return ArgType::PtrTo(A: Ctx.LongLongTy);
326 case LengthModifier::AsAllocate:
327 case LengthModifier::AsMAllocate:
328 case LengthModifier::AsInt32:
329 case LengthModifier::AsInt3264:
330 case LengthModifier::AsWide:
331 case LengthModifier::AsShortLong:
332 case LengthModifier::AsDecimal32:
333 case LengthModifier::AsDecimal64:
334 case LengthModifier::AsDecimal128:
335 return ArgType::Invalid();
336 }
337 llvm_unreachable("Unsupported LengthModifier Type");
338
339 // Unsigned int.
340 case ConversionSpecifier::bArg:
341 case ConversionSpecifier::oArg:
342 case ConversionSpecifier::OArg:
343 case ConversionSpecifier::uArg:
344 case ConversionSpecifier::UArg:
345 case ConversionSpecifier::xArg:
346 case ConversionSpecifier::XArg:
347 switch (LM.getKind()) {
348 case LengthModifier::None:
349 return ArgType::PtrTo(A: Ctx.UnsignedIntTy);
350 case LengthModifier::AsChar:
351 return ArgType::PtrTo(A: Ctx.UnsignedCharTy);
352 case LengthModifier::AsShort:
353 return ArgType::PtrTo(A: Ctx.UnsignedShortTy);
354 case LengthModifier::AsLong:
355 return ArgType::PtrTo(A: Ctx.UnsignedLongTy);
356 case LengthModifier::AsLongLong:
357 case LengthModifier::AsQuad:
358 return ArgType::PtrTo(A: Ctx.UnsignedLongLongTy);
359 case LengthModifier::AsInt64:
360 return ArgType::PtrTo(
361 A: ArgType(Ctx.UnsignedLongLongTy, "unsigned __int64"));
362 case LengthModifier::AsIntMax:
363 return ArgType::PtrTo(A: ArgType(Ctx.getUIntMaxType(), "uintmax_t"));
364 case LengthModifier::AsSizeT:
365 return ArgType::PtrTo(
366 A: ArgType::makeSizeT(A: ArgType(Ctx.getSizeType(), "size_t")));
367 case LengthModifier::AsPtrDiff:
368 return ArgType::PtrTo(A: ArgType::makePtrdiffT(
369 A: ArgType(Ctx.getUnsignedPointerDiffType(), "unsigned ptrdiff_t")));
370 case LengthModifier::AsIntN:
371 case LengthModifier::AsFastIntN:
372 return ArgType::PtrTo(A: ArgType::makeIntNType(Ctx, LengthMod: LM, /*Signed=*/false));
373 case LengthModifier::AsLongDouble:
374 // GNU extension.
375 return ArgType::PtrTo(A: Ctx.UnsignedLongLongTy);
376 case LengthModifier::AsAllocate:
377 case LengthModifier::AsMAllocate:
378 case LengthModifier::AsInt32:
379 case LengthModifier::AsInt3264:
380 case LengthModifier::AsWide:
381 case LengthModifier::AsShortLong:
382 case LengthModifier::AsDecimal32:
383 case LengthModifier::AsDecimal64:
384 case LengthModifier::AsDecimal128:
385 return ArgType::Invalid();
386 }
387 llvm_unreachable("Unsupported LengthModifier Type");
388
389 // Float.
390 case ConversionSpecifier::aArg:
391 case ConversionSpecifier::AArg:
392 case ConversionSpecifier::eArg:
393 case ConversionSpecifier::EArg:
394 case ConversionSpecifier::fArg:
395 case ConversionSpecifier::FArg:
396 case ConversionSpecifier::gArg:
397 case ConversionSpecifier::GArg:
398 switch (LM.getKind()) {
399 case LengthModifier::None:
400 return ArgType::PtrTo(A: Ctx.FloatTy);
401 case LengthModifier::AsLong:
402 return ArgType::PtrTo(A: Ctx.DoubleTy);
403 case LengthModifier::AsLongDouble:
404 return ArgType::PtrTo(A: Ctx.LongDoubleTy);
405 case LengthModifier::AsDecimal32:
406 return ArgType::PtrTo(A: ArgType::Unsupported(N: "_Decimal32"));
407 case LengthModifier::AsDecimal64:
408 return ArgType::PtrTo(A: ArgType::Unsupported(N: "_Decimal64"));
409 case LengthModifier::AsDecimal128:
410 return ArgType::PtrTo(A: ArgType::Unsupported(N: "_Decimal128"));
411 default:
412 return ArgType::Invalid();
413 }
414
415 // Char, string and scanlist.
416 case ConversionSpecifier::cArg:
417 case ConversionSpecifier::sArg:
418 case ConversionSpecifier::ScanListArg:
419 switch (LM.getKind()) {
420 case LengthModifier::None:
421 return ArgType::PtrTo(A: ArgType::AnyCharTy);
422 case LengthModifier::AsLong:
423 case LengthModifier::AsWide:
424 return ArgType::PtrTo(A: ArgType(Ctx.getWideCharType(), "wchar_t"));
425 case LengthModifier::AsAllocate:
426 case LengthModifier::AsMAllocate:
427 return ArgType::PtrTo(A: ArgType::CStrTy);
428 case LengthModifier::AsShort:
429 if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
430 return ArgType::PtrTo(A: ArgType::AnyCharTy);
431 [[fallthrough]];
432 default:
433 return ArgType::Invalid();
434 }
435 case ConversionSpecifier::CArg:
436 case ConversionSpecifier::SArg:
437 // FIXME: Mac OS X specific?
438 switch (LM.getKind()) {
439 case LengthModifier::None:
440 case LengthModifier::AsWide:
441 return ArgType::PtrTo(A: ArgType(Ctx.getWideCharType(), "wchar_t"));
442 case LengthModifier::AsAllocate:
443 case LengthModifier::AsMAllocate:
444 return ArgType::PtrTo(A: ArgType(ArgType::WCStrTy, "wchar_t *"));
445 case LengthModifier::AsShort:
446 if (Ctx.getTargetInfo().getTriple().isOSMSVCRT())
447 return ArgType::PtrTo(A: ArgType::AnyCharTy);
448 [[fallthrough]];
449 default:
450 return ArgType::Invalid();
451 }
452
453 // Pointer.
454 case ConversionSpecifier::pArg:
455 return ArgType::PtrTo(A: ArgType::CPointerTy);
456
457 // Write-back.
458 case ConversionSpecifier::nArg:
459 switch (LM.getKind()) {
460 case LengthModifier::None:
461 return ArgType::PtrTo(A: Ctx.IntTy);
462 case LengthModifier::AsChar:
463 return ArgType::PtrTo(A: Ctx.SignedCharTy);
464 case LengthModifier::AsShort:
465 return ArgType::PtrTo(A: Ctx.ShortTy);
466 case LengthModifier::AsLong:
467 return ArgType::PtrTo(A: Ctx.LongTy);
468 case LengthModifier::AsLongLong:
469 case LengthModifier::AsQuad:
470 return ArgType::PtrTo(A: Ctx.LongLongTy);
471 case LengthModifier::AsInt64:
472 return ArgType::PtrTo(A: ArgType(Ctx.LongLongTy, "__int64"));
473 case LengthModifier::AsIntMax:
474 return ArgType::PtrTo(A: ArgType(Ctx.getIntMaxType(), "intmax_t"));
475 case LengthModifier::AsSizeT:
476 return ArgType::PtrTo(A: ArgType::makeSizeT(
477 A: ArgType(Ctx.getSignedSizeType(), "signed size_t")));
478 case LengthModifier::AsPtrDiff:
479 return ArgType::PtrTo(A: ArgType::makePtrdiffT(
480 A: ArgType(Ctx.getPointerDiffType(), "ptrdiff_t")));
481 case LengthModifier::AsIntN:
482 case LengthModifier::AsFastIntN:
483 return ArgType::PtrTo(A: ArgType::makeIntNType(Ctx, LengthMod: LM, /*Signed=*/true));
484 case LengthModifier::AsLongDouble:
485 return ArgType(); // FIXME: Is this a known extension?
486 case LengthModifier::AsAllocate:
487 case LengthModifier::AsMAllocate:
488 case LengthModifier::AsInt32:
489 case LengthModifier::AsInt3264:
490 case LengthModifier::AsWide:
491 case LengthModifier::AsShortLong:
492 case LengthModifier::AsDecimal32:
493 case LengthModifier::AsDecimal64:
494 case LengthModifier::AsDecimal128:
495 return ArgType::Invalid();
496 }
497
498 default:
499 break;
500 }
501
502 return ArgType();
503}
504
505bool ScanfSpecifier::fixType(QualType QT, QualType RawQT,
506 const LangOptions &LangOpt, ASTContext &Ctx) {
507
508 // %n is different from other conversion specifiers; don't try to fix it.
509 if (CS.getKind() == ConversionSpecifier::nArg)
510 return false;
511
512 if (!QT->isPointerType())
513 return false;
514
515 QualType PT = QT->getPointeeType();
516
517 // If it's an enum, get its underlying type.
518 if (const auto *ED = PT->getAsEnumDecl()) {
519 // Don't try to fix incomplete enums.
520 if (!ED->isComplete())
521 return false;
522 PT = ED->getIntegerType();
523 }
524
525 const BuiltinType *BT = PT->getAs<BuiltinType>();
526 if (!BT)
527 return false;
528
529 // Pointer to a character.
530 if (PT->isAnyCharacterType()) {
531 CS.setKind(ConversionSpecifier::sArg);
532 if (PT->isWideCharType())
533 LM.setKind(LengthModifier::AsWideChar);
534 else
535 LM.setKind(LengthModifier::None);
536
537 // If we know the target array length, we can use it as a field width.
538 if (const ConstantArrayType *CAT = Ctx.getAsConstantArrayType(T: RawQT)) {
539 if (CAT->getSizeModifier() == ArraySizeModifier::Normal)
540 FieldWidth = OptionalAmount(OptionalAmount::Constant,
541 CAT->getZExtSize() - 1, "", 0, false);
542 }
543 return true;
544 }
545
546 // Figure out the length modifier.
547 switch (BT->getKind()) {
548 // no modifier
549 case BuiltinType::UInt:
550 case BuiltinType::Int:
551 case BuiltinType::Float:
552 LM.setKind(LengthModifier::None);
553 break;
554
555 // hh
556 case BuiltinType::Char_U:
557 case BuiltinType::UChar:
558 case BuiltinType::Char_S:
559 case BuiltinType::SChar:
560 LM.setKind(LengthModifier::AsChar);
561 break;
562
563 // h
564 case BuiltinType::Short:
565 case BuiltinType::UShort:
566 LM.setKind(LengthModifier::AsShort);
567 break;
568
569 // l
570 case BuiltinType::Long:
571 case BuiltinType::ULong:
572 case BuiltinType::Double:
573 LM.setKind(LengthModifier::AsLong);
574 break;
575
576 // ll
577 case BuiltinType::LongLong:
578 case BuiltinType::ULongLong:
579 LM.setKind(LengthModifier::AsLongLong);
580 break;
581
582 // L
583 case BuiltinType::LongDouble:
584 LM.setKind(LengthModifier::AsLongDouble);
585 break;
586
587 // Don't know.
588 default:
589 return false;
590 }
591
592 // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
593 if (LangOpt.C99 || LangOpt.CPlusPlus11)
594 namedTypeToLengthModifier(Ctx, QT: PT, LM);
595
596 // If fixing the length modifier was enough, we are done.
597 if (hasValidLengthModifier(Target: Ctx.getTargetInfo(), LO: LangOpt)) {
598 const analyze_scanf::ArgType &AT = getArgType(Ctx);
599 if (AT.isValid() && AT.matchesType(C&: Ctx, argTy: QT))
600 return true;
601 }
602
603 // Figure out the conversion specifier.
604 if (PT->isRealFloatingType())
605 CS.setKind(ConversionSpecifier::fArg);
606 else if (PT->isSignedIntegerType())
607 CS.setKind(ConversionSpecifier::dArg);
608 else if (PT->isUnsignedIntegerType())
609 CS.setKind(ConversionSpecifier::uArg);
610 else
611 llvm_unreachable("Unexpected type");
612
613 return true;
614}
615
616void ScanfSpecifier::toString(raw_ostream &os) const {
617 os << "%";
618
619 if (usesPositionalArg())
620 os << getPositionalArgIndex() << "$";
621 if (SuppressAssignment)
622 os << "*";
623
624 FieldWidth.toString(os);
625 os << LM.toString();
626 os << CS.toString();
627}
628
629bool clang::analyze_format_string::ParseScanfString(FormatStringHandler &H,
630 const char *I,
631 const char *E,
632 const LangOptions &LO,
633 const TargetInfo &Target) {
634
635 unsigned argIndex = 0;
636
637 // Keep looking for a format specifier until we have exhausted the string.
638 ScanfFormatStringParser P(H, LO, Target);
639 while (I != E) {
640 const ScanfSpecifierResult &FSR = P.parseSpecifier(Beg&: I, E, argIndex);
641 // Did a fail-stop error of any kind occur when parsing the specifier?
642 // If so, don't do any more processing.
643 if (FSR.shouldStop())
644 return true;
645 // Did we exhaust the string or encounter an error that
646 // we can recover from?
647 if (!FSR.hasValue())
648 continue;
649 // We have a format specifier. Pass it to the callback.
650 if (!H.HandleScanfSpecifier(FS: FSR.getValue(), startSpecifier: FSR.getStart(),
651 specifierLen: I - FSR.getStart())) {
652 return true;
653 }
654 }
655 assert(I == E && "Format string not exhausted");
656 return false;
657}
658