clang  8.0.0svn
FormatString.h
Go to the documentation of this file.
1 //= FormatString.h - Analysis of printf/fprintf format strings --*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines APIs for analyzing the format strings of printf, fscanf,
11 // and friends.
12 //
13 // The structure of format strings for fprintf are described in C99 7.19.6.1.
14 //
15 // The structure of format strings for fscanf are described in C99 7.19.6.2.
16 //
17 //===----------------------------------------------------------------------===//
18 
19 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_FORMATSTRING_H
20 #define LLVM_CLANG_ANALYSIS_ANALYSES_FORMATSTRING_H
21 
23 
24 namespace clang {
25 
26 class TargetInfo;
27 
28 //===----------------------------------------------------------------------===//
29 /// Common components of both fprintf and fscanf format strings.
30 namespace analyze_format_string {
31 
32 /// Class representing optional flags with location and representation
33 /// information.
34 class OptionalFlag {
35 public:
36  OptionalFlag(const char *Representation)
37  : representation(Representation), flag(false) {}
38  bool isSet() const { return flag; }
39  void set() { flag = true; }
40  void clear() { flag = false; }
41  void setPosition(const char *position) {
42  assert(position);
43  flag = true;
44  this->position = position;
45  }
46  const char *getPosition() const {
47  assert(position);
48  return position;
49  }
50  const char *toString() const { return representation; }
51 
52  // Overloaded operators for bool like qualities
53  explicit operator bool() const { return flag; }
54  OptionalFlag& operator=(const bool &rhs) {
55  flag = rhs;
56  return *this; // Return a reference to myself.
57  }
58 private:
59  const char *representation;
60  const char *position;
61  bool flag;
62 };
63 
64 /// Represents the length modifier in a format string in scanf/printf.
66 public:
67  enum Kind {
69  AsChar, // 'hh'
70  AsShort, // 'h'
71  AsLong, // 'l'
72  AsLongLong, // 'll'
73  AsQuad, // 'q' (BSD, deprecated, for 64-bit integer types)
74  AsIntMax, // 'j'
75  AsSizeT, // 'z'
76  AsPtrDiff, // 't'
77  AsInt32, // 'I32' (MSVCRT, like __int32)
78  AsInt3264, // 'I' (MSVCRT, like __int3264 from MIDL)
79  AsInt64, // 'I64' (MSVCRT, like __int64)
80  AsLongDouble, // 'L'
81  AsAllocate, // for '%as', GNU extension to C90 scanf
82  AsMAllocate, // for '%ms', GNU extension to scanf
83  AsWide, // 'w' (MSVCRT, like l but only for c, C, s, S, or Z
84  AsWideChar = AsLong // for '%ls', only makes sense for printf
85  };
86 
88  : Position(nullptr), kind(None) {}
89  LengthModifier(const char *pos, Kind k)
90  : Position(pos), kind(k) {}
91 
92  const char *getStart() const {
93  return Position;
94  }
95 
96  unsigned getLength() const {
97  switch (kind) {
98  default:
99  return 1;
100  case AsLongLong:
101  case AsChar:
102  return 2;
103  case AsInt32:
104  case AsInt64:
105  return 3;
106  case None:
107  return 0;
108  }
109  }
110 
111  Kind getKind() const { return kind; }
112  void setKind(Kind k) { kind = k; }
113 
114  const char *toString() const;
115 
116 private:
117  const char *Position;
118  Kind kind;
119 };
120 
122 public:
123  enum Kind {
124  InvalidSpecifier = 0,
125  // C99 conversion specifiers.
128  DArg, // Apple extension
130  IntArgBeg = dArg,
131  IntArgEnd = iArg,
132 
134  OArg, // Apple extension
136  UArg, // Apple extension
139  UIntArgBeg = oArg,
140  UIntArgEnd = XArg,
141 
150  DoubleArgBeg = fArg,
151  DoubleArgEnd = AArg,
152 
159 
160  // Apple extension: P specifies to os_log that the data being pointed to is
161  // to be copied by os_log. The precision indicates the number of bytes to
162  // copy.
164 
165  // ** Printf-specific **
166 
167  ZArg, // MS extension
168 
169  // Objective-C specific specifiers.
170  ObjCObjArg, // '@'
171  ObjCBeg = ObjCObjArg,
172  ObjCEnd = ObjCObjArg,
173 
174  // FreeBSD kernel specific specifiers.
179 
180  // GlibC specific specifiers.
181  PrintErrno, // 'm'
182 
183  PrintfConvBeg = ObjCObjArg,
184  PrintfConvEnd = PrintErrno,
185 
186  // ** Scanf-specific **
187  ScanListArg, // '['
188  ScanfConvBeg = ScanListArg,
189  ScanfConvEnd = ScanListArg
190  };
191 
192  ConversionSpecifier(bool isPrintf = true)
193  : IsPrintf(isPrintf), Position(nullptr), EndScanList(nullptr),
194  kind(InvalidSpecifier) {}
195 
196  ConversionSpecifier(bool isPrintf, const char *pos, Kind k)
197  : IsPrintf(isPrintf), Position(pos), EndScanList(nullptr), kind(k) {}
198 
199  const char *getStart() const {
200  return Position;
201  }
202 
203  StringRef getCharacters() const {
204  return StringRef(getStart(), getLength());
205  }
206 
207  bool consumesDataArgument() const {
208  switch (kind) {
209  case PrintErrno:
210  assert(IsPrintf);
211  return false;
212  case PercentArg:
213  return false;
214  case InvalidSpecifier:
215  return false;
216  default:
217  return true;
218  }
219  }
220 
221  Kind getKind() const { return kind; }
222  void setKind(Kind k) { kind = k; }
223  unsigned getLength() const {
224  return EndScanList ? EndScanList - Position : 1;
225  }
226  void setEndScanList(const char *pos) { EndScanList = pos; }
227 
228  bool isIntArg() const { return (kind >= IntArgBeg && kind <= IntArgEnd) ||
229  kind == FreeBSDrArg || kind == FreeBSDyArg; }
230  bool isUIntArg() const { return kind >= UIntArgBeg && kind <= UIntArgEnd; }
231  bool isAnyIntArg() const { return kind >= IntArgBeg && kind <= UIntArgEnd; }
232  bool isDoubleArg() const {
233  return kind >= DoubleArgBeg && kind <= DoubleArgEnd;
234  }
235 
236  const char *toString() const;
237 
238  bool isPrintfKind() const { return IsPrintf; }
239 
240  Optional<ConversionSpecifier> getStandardSpecifier() const;
241 
242 protected:
243  bool IsPrintf;
244  const char *Position;
245  const char *EndScanList;
247 };
248 
249 class ArgType {
250 public:
251  enum Kind { UnknownTy, InvalidTy, SpecificTy, ObjCPointerTy, CPointerTy,
252  AnyCharTy, CStrTy, WCStrTy, WIntTy };
253 
254  enum MatchKind { NoMatch = 0, Match = 1, NoMatchPedantic };
255 
256 private:
257  const Kind K;
258  QualType T;
259  const char *Name = nullptr;
260  bool Ptr = false;
261 
262  /// The TypeKind identifies certain well-known types like size_t and
263  /// ptrdiff_t.
264  enum class TypeKind { DontCare, SizeT, PtrdiffT };
265  TypeKind TK = TypeKind::DontCare;
266 
267 public:
268  ArgType(Kind K = UnknownTy, const char *N = nullptr) : K(K), Name(N) {}
269  ArgType(QualType T, const char *N = nullptr) : K(SpecificTy), T(T), Name(N) {}
270  ArgType(CanQualType T) : K(SpecificTy), T(T) {}
271 
272  static ArgType Invalid() { return ArgType(InvalidTy); }
273  bool isValid() const { return K != InvalidTy; }
274 
275  bool isSizeT() const { return TK == TypeKind::SizeT; }
276 
277  bool isPtrdiffT() const { return TK == TypeKind::PtrdiffT; }
278 
279  /// Create an ArgType which corresponds to the type pointer to A.
280  static ArgType PtrTo(const ArgType& A) {
281  assert(A.K >= InvalidTy && "ArgType cannot be pointer to invalid/unknown");
282  ArgType Res = A;
283  Res.Ptr = true;
284  return Res;
285  }
286 
287  /// Create an ArgType which corresponds to the size_t/ssize_t type.
288  static ArgType makeSizeT(const ArgType &A) {
289  ArgType Res = A;
290  Res.TK = TypeKind::SizeT;
291  return Res;
292  }
293 
294  /// Create an ArgType which corresponds to the ptrdiff_t/unsigned ptrdiff_t
295  /// type.
296  static ArgType makePtrdiffT(const ArgType &A) {
297  ArgType Res = A;
298  Res.TK = TypeKind::PtrdiffT;
299  return Res;
300  }
301 
302  MatchKind matchesType(ASTContext &C, QualType argTy) const;
303 
304  QualType getRepresentativeType(ASTContext &C) const;
305 
306  ArgType makeVectorType(ASTContext &C, unsigned NumElts) const;
307 
308  std::string getRepresentativeTypeName(ASTContext &C) const;
309 };
310 
312 public:
313  enum HowSpecified { NotSpecified, Constant, Arg, Invalid };
314 
316  unsigned amount,
317  const char *amountStart,
318  unsigned amountLength,
319  bool usesPositionalArg)
320  : start(amountStart), length(amountLength), hs(howSpecified), amt(amount),
321  UsesPositionalArg(usesPositionalArg), UsesDotPrefix(0) {}
322 
323  OptionalAmount(bool valid = true)
324  : start(nullptr),length(0), hs(valid ? NotSpecified : Invalid), amt(0),
325  UsesPositionalArg(0), UsesDotPrefix(0) {}
326 
327  explicit OptionalAmount(unsigned Amount)
328  : start(nullptr), length(0), hs(Constant), amt(Amount),
329  UsesPositionalArg(false), UsesDotPrefix(false) {}
330 
331  bool isInvalid() const {
332  return hs == Invalid;
333  }
334 
335  HowSpecified getHowSpecified() const { return hs; }
336  void setHowSpecified(HowSpecified h) { hs = h; }
337 
338  bool hasDataArgument() const { return hs == Arg; }
339 
340  unsigned getArgIndex() const {
341  assert(hasDataArgument());
342  return amt;
343  }
344 
345  unsigned getConstantAmount() const {
346  assert(hs == Constant);
347  return amt;
348  }
349 
350  const char *getStart() const {
351  // We include the . character if it is given.
352  return start - UsesDotPrefix;
353  }
354 
355  unsigned getConstantLength() const {
356  assert(hs == Constant);
357  return length + UsesDotPrefix;
358  }
359 
360  ArgType getArgType(ASTContext &Ctx) const;
361 
362  void toString(raw_ostream &os) const;
363 
364  bool usesPositionalArg() const { return (bool) UsesPositionalArg; }
365  unsigned getPositionalArgIndex() const {
366  assert(hasDataArgument());
367  return amt + 1;
368  }
369 
370  bool usesDotPrefix() const { return UsesDotPrefix; }
371  void setUsesDotPrefix() { UsesDotPrefix = true; }
372 
373 private:
374  const char *start;
375  unsigned length;
376  HowSpecified hs;
377  unsigned amt;
378  bool UsesPositionalArg : 1;
379  bool UsesDotPrefix;
380 };
381 
382 
384 protected:
389 
390  /// Positional arguments, an IEEE extension:
391  /// IEEE Std 1003.1, 2004 Edition
392  /// http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
394  unsigned argIndex;
395 public:
396  FormatSpecifier(bool isPrintf)
397  : CS(isPrintf), VectorNumElts(false),
398  UsesPositionalArg(false), argIndex(0) {}
399 
401  LM = lm;
402  }
403 
404  void setUsesPositionalArg() { UsesPositionalArg = true; }
405 
406  void setArgIndex(unsigned i) {
407  argIndex = i;
408  }
409 
410  unsigned getArgIndex() const {
411  return argIndex;
412  }
413 
414  unsigned getPositionalArgIndex() const {
415  return argIndex + 1;
416  }
417 
419  return LM;
420  }
421 
422  const OptionalAmount &getFieldWidth() const {
423  return FieldWidth;
424  }
425 
426  void setVectorNumElts(const OptionalAmount &Amt) {
427  VectorNumElts = Amt;
428  }
429 
431  return VectorNumElts;
432  }
433 
434  void setFieldWidth(const OptionalAmount &Amt) {
435  FieldWidth = Amt;
436  }
437 
438  bool usesPositionalArg() const { return UsesPositionalArg; }
439 
440  bool hasValidLengthModifier(const TargetInfo &Target) const;
441 
442  bool hasStandardLengthModifier() const;
443 
444  Optional<LengthModifier> getCorrectedLengthModifier() const;
445 
446  bool hasStandardConversionSpecifier(const LangOptions &LangOpt) const;
447 
448  bool hasStandardLengthConversionCombination() const;
449 
450  /// For a TypedefType QT, if it is a named integer type such as size_t,
451  /// assign the appropriate value to LM and return true.
452  static bool namedTypeToLengthModifier(QualType QT, LengthModifier &LM);
453 };
454 
455 } // end analyze_format_string namespace
456 
457 //===----------------------------------------------------------------------===//
458 /// Pieces specific to fprintf format strings.
459 
460 namespace analyze_printf {
461 
464 public:
466  : ConversionSpecifier(true, nullptr, InvalidSpecifier) {}
467 
468  PrintfConversionSpecifier(const char *pos, Kind k)
469  : ConversionSpecifier(true, pos, k) {}
470 
471  bool isObjCArg() const { return kind >= ObjCBeg && kind <= ObjCEnd; }
472  bool isDoubleArg() const { return kind >= DoubleArgBeg &&
473  kind <= DoubleArgEnd; }
474 
476  return CS->isPrintfKind();
477  }
478 };
479 
484 
486  OptionalFlag HasThousandsGrouping; // ''', POSIX extension.
487  OptionalFlag IsLeftJustified; // '-'
488  OptionalFlag HasPlusPrefix; // '+'
489  OptionalFlag HasSpacePrefix; // ' '
490  OptionalFlag HasAlternativeForm; // '#'
491  OptionalFlag HasLeadingZeroes; // '0'
492  OptionalFlag HasObjCTechnicalTerm; // '[tt]'
493  OptionalFlag IsPrivate; // '{private}'
494  OptionalFlag IsPublic; // '{public}'
495  OptionalFlag IsSensitive; // '{sensitive}'
496  OptionalAmount Precision;
497  StringRef MaskType;
498 
499  ArgType getScalarArgType(ASTContext &Ctx, bool IsObjCLiteral) const;
500 
501 public:
503  : FormatSpecifier(/* isPrintf = */ true), HasThousandsGrouping("'"),
504  IsLeftJustified("-"), HasPlusPrefix("+"), HasSpacePrefix(" "),
505  HasAlternativeForm("#"), HasLeadingZeroes("0"),
506  HasObjCTechnicalTerm("tt"), IsPrivate("private"), IsPublic("public"),
507  IsSensitive("sensitive") {}
508 
509  static PrintfSpecifier Parse(const char *beg, const char *end);
510 
511  // Methods for incrementally constructing the PrintfSpecifier.
513  CS = cs;
514  }
515  void setHasThousandsGrouping(const char *position) {
516  HasThousandsGrouping.setPosition(position);
517  }
518  void setIsLeftJustified(const char *position) {
519  IsLeftJustified.setPosition(position);
520  }
521  void setHasPlusPrefix(const char *position) {
522  HasPlusPrefix.setPosition(position);
523  }
524  void setHasSpacePrefix(const char *position) {
525  HasSpacePrefix.setPosition(position);
526  }
527  void setHasAlternativeForm(const char *position) {
528  HasAlternativeForm.setPosition(position);
529  }
530  void setHasLeadingZeros(const char *position) {
531  HasLeadingZeroes.setPosition(position);
532  }
533  void setHasObjCTechnicalTerm(const char *position) {
534  HasObjCTechnicalTerm.setPosition(position);
535  }
536  void setIsPrivate(const char *position) { IsPrivate.setPosition(position); }
537  void setIsPublic(const char *position) { IsPublic.setPosition(position); }
538  void setIsSensitive(const char *position) {
539  IsSensitive.setPosition(position);
540  }
541  void setUsesPositionalArg() { UsesPositionalArg = true; }
542 
543  // Methods for querying the format specifier.
544 
546  return cast<PrintfConversionSpecifier>(CS);
547  }
548 
549  void setPrecision(const OptionalAmount &Amt) {
550  Precision = Amt;
551  Precision.setUsesDotPrefix();
552  }
553 
554  const OptionalAmount &getPrecision() const {
555  return Precision;
556  }
557 
558  bool consumesDataArgument() const {
559  return getConversionSpecifier().consumesDataArgument();
560  }
561 
562  /// Returns the builtin type that a data argument
563  /// paired with this format specifier should have. This method
564  /// will return null if the format specifier does not have
565  /// a matching data argument or the matching argument matches
566  /// more than one type.
567  ArgType getArgType(ASTContext &Ctx, bool IsObjCLiteral) const;
568 
570  return HasThousandsGrouping;
571  }
572  const OptionalFlag &isLeftJustified() const { return IsLeftJustified; }
573  const OptionalFlag &hasPlusPrefix() const { return HasPlusPrefix; }
574  const OptionalFlag &hasAlternativeForm() const { return HasAlternativeForm; }
575  const OptionalFlag &hasLeadingZeros() const { return HasLeadingZeroes; }
576  const OptionalFlag &hasSpacePrefix() const { return HasSpacePrefix; }
577  const OptionalFlag &hasObjCTechnicalTerm() const { return HasObjCTechnicalTerm; }
578  const OptionalFlag &isPrivate() const { return IsPrivate; }
579  const OptionalFlag &isPublic() const { return IsPublic; }
580  const OptionalFlag &isSensitive() const { return IsSensitive; }
581  bool usesPositionalArg() const { return UsesPositionalArg; }
582 
583  StringRef getMaskType() const { return MaskType; }
584  void setMaskType(StringRef S) { MaskType = S; }
585 
586  /// Changes the specifier and length according to a QualType, retaining any
587  /// flags or options. Returns true on success, or false when a conversion
588  /// was not successful.
589  bool fixType(QualType QT, const LangOptions &LangOpt, ASTContext &Ctx,
590  bool IsObjCLiteral);
591 
592  void toString(raw_ostream &os) const;
593 
594  // Validation methods - to check if any element results in undefined behavior
595  bool hasValidPlusPrefix() const;
596  bool hasValidAlternativeForm() const;
597  bool hasValidLeadingZeros() const;
598  bool hasValidSpacePrefix() const;
599  bool hasValidLeftJustified() const;
600  bool hasValidThousandsGroupingPrefix() const;
601 
602  bool hasValidPrecision() const;
603  bool hasValidFieldWidth() const;
604 };
605 } // end analyze_printf namespace
606 
607 //===----------------------------------------------------------------------===//
608 /// Pieces specific to fscanf format strings.
609 
610 namespace analyze_scanf {
611 
614 public:
616  : ConversionSpecifier(false, nullptr, InvalidSpecifier) {}
617 
618  ScanfConversionSpecifier(const char *pos, Kind k)
619  : ConversionSpecifier(false, pos, k) {}
620 
622  return !CS->isPrintfKind();
623  }
624 };
625 
630 
632  OptionalFlag SuppressAssignment; // '*'
633 public:
635  FormatSpecifier(/* isPrintf = */ false),
636  SuppressAssignment("*") {}
637 
638  void setSuppressAssignment(const char *position) {
639  SuppressAssignment.setPosition(position);
640  }
641 
643  return SuppressAssignment;
644  }
645 
647  CS = cs;
648  }
649 
651  return cast<ScanfConversionSpecifier>(CS);
652  }
653 
654  bool consumesDataArgument() const {
655  return CS.consumesDataArgument() && !SuppressAssignment;
656  }
657 
658  ArgType getArgType(ASTContext &Ctx) const;
659 
660  bool fixType(QualType QT, QualType RawQT, const LangOptions &LangOpt,
661  ASTContext &Ctx);
662 
663  void toString(raw_ostream &os) const;
664 
665  static ScanfSpecifier Parse(const char *beg, const char *end);
666 };
667 
668 } // end analyze_scanf namespace
669 
670 //===----------------------------------------------------------------------===//
671 // Parsing and processing of format strings (both fprintf and fscanf).
672 
673 namespace analyze_format_string {
674 
676 
678 public:
680  virtual ~FormatStringHandler();
681 
682  virtual void HandleNullChar(const char *nullCharacter) {}
683 
684  virtual void HandlePosition(const char *startPos, unsigned posLen) {}
685 
686  virtual void HandleInvalidPosition(const char *startPos, unsigned posLen,
687  PositionContext p) {}
688 
689  virtual void HandleZeroPosition(const char *startPos, unsigned posLen) {}
690 
691  virtual void HandleIncompleteSpecifier(const char *startSpecifier,
692  unsigned specifierLen) {}
693 
694  virtual void HandleEmptyObjCModifierFlag(const char *startFlags,
695  unsigned flagsLen) {}
696 
697  virtual void HandleInvalidObjCModifierFlag(const char *startFlag,
698  unsigned flagLen) {}
699 
700  virtual void HandleObjCFlagsWithNonObjCConversion(const char *flagsStart,
701  const char *flagsEnd,
702  const char *conversionPosition) {}
703  // Printf-specific handlers.
704 
707  const char *startSpecifier,
708  unsigned specifierLen) {
709  return true;
710  }
711 
713  const char *startSpecifier,
714  unsigned specifierLen) {
715  return true;
716  }
717 
718  /// Handle mask types whose sizes are not between one and eight bytes.
719  virtual void handleInvalidMaskType(StringRef MaskType) {}
720 
721  // Scanf-specific handlers.
722 
725  const char *startSpecifier,
726  unsigned specifierLen) {
727  return true;
728  }
729 
731  const char *startSpecifier,
732  unsigned specifierLen) {
733  return true;
734  }
735 
736  virtual void HandleIncompleteScanList(const char *start, const char *end) {}
737 };
738 
740  const char *beg, const char *end, const LangOptions &LO,
741  const TargetInfo &Target, bool isFreeBSDKPrintf);
742 
743 bool ParseFormatStringHasSArg(const char *beg, const char *end,
744  const LangOptions &LO, const TargetInfo &Target);
745 
747  const char *beg, const char *end, const LangOptions &LO,
748  const TargetInfo &Target);
749 
750 } // end analyze_format_string namespace
751 } // end clang namespace
752 #endif
const OptionalFlag & hasAlternativeForm() const
Definition: FormatString.h:574
virtual void HandlePosition(const char *startPos, unsigned posLen)
Definition: FormatString.h:684
static ArgType makePtrdiffT(const ArgType &A)
Create an ArgType which corresponds to the ptrdiff_t/unsigned ptrdiff_t type.
Definition: FormatString.h:296
virtual bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS, const char *startSpecifier, unsigned specifierLen)
Definition: FormatString.h:730
A (possibly-)qualified type.
Definition: Type.h:642
const ScanfConversionSpecifier & getConversionSpecifier() const
Definition: FormatString.h:650
void setIsPublic(const char *position)
Definition: FormatString.h:537
const OptionalFlag & getSuppressAssignment() const
Definition: FormatString.h:642
virtual void HandleInvalidObjCModifierFlag(const char *startFlag, unsigned flagLen)
Definition: FormatString.h:697
virtual void HandleZeroPosition(const char *startPos, unsigned posLen)
Definition: FormatString.h:689
OptionalFlag(const char *Representation)
Definition: FormatString.h:36
void setPosition(const char *position)
Definition: FormatString.h:41
ArgType(QualType T, const char *N=nullptr)
Definition: FormatString.h:269
void setHasLeadingZeros(const char *position)
Definition: FormatString.h:530
const OptionalFlag & hasThousandsGrouping() const
Definition: FormatString.h:569
PrintfConversionSpecifier(const char *pos, Kind k)
Definition: FormatString.h:468
static bool classof(const analyze_format_string::ConversionSpecifier *CS)
Definition: FormatString.h:621
virtual void HandleEmptyObjCModifierFlag(const char *startFlags, unsigned flagsLen)
Definition: FormatString.h:694
void setPrecision(const OptionalAmount &Amt)
Definition: FormatString.h:549
static ArgType makeSizeT(const ArgType &A)
Create an ArgType which corresponds to the size_t/ssize_t type.
Definition: FormatString.h:288
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
bool ParseScanfString(FormatStringHandler &H, const char *beg, const char *end, const LangOptions &LO, const TargetInfo &Target)
void setHasSpacePrefix(const char *position)
Definition: FormatString.h:524
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
void setConversionSpecifier(const PrintfConversionSpecifier &cs)
Definition: FormatString.h:512
void setFieldWidth(const OptionalAmount &Amt)
Definition: FormatString.h:434
virtual bool HandleInvalidPrintfConversionSpecifier(const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier, unsigned specifierLen)
Definition: FormatString.h:705
Represents the length modifier in a format string in scanf/printf.
Definition: FormatString.h:65
void setIsLeftJustified(const char *position)
Definition: FormatString.h:518
virtual void handleInvalidMaskType(StringRef MaskType)
Handle mask types whose sizes are not between one and eight bytes.
Definition: FormatString.h:719
static ArgType PtrTo(const ArgType &A)
Create an ArgType which corresponds to the type pointer to A.
Definition: FormatString.h:280
ScanfConversionSpecifier(const char *pos, Kind k)
Definition: FormatString.h:618
const OptionalFlag & hasLeadingZeros() const
Definition: FormatString.h:575
const OptionalFlag & hasPlusPrefix() const
Definition: FormatString.h:573
ArgType(Kind K=UnknownTy, const char *N=nullptr)
Definition: FormatString.h:268
Exposes information about the current target.
Definition: TargetInfo.h:54
const OptionalFlag & isLeftJustified() const
Definition: FormatString.h:572
#define bool
Definition: stdbool.h:31
const OptionalAmount & getFieldWidth() const
Definition: FormatString.h:422
virtual void HandleNullChar(const char *nullCharacter)
Definition: FormatString.h:682
const OptionalFlag & isSensitive() const
Definition: FormatString.h:580
void setVectorNumElts(const OptionalAmount &Amt)
Definition: FormatString.h:426
float __ovld __cnfn length(float p)
Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)
const LengthModifier & getLengthModifier() const
Definition: FormatString.h:418
bool ParseFormatStringHasSArg(const char *beg, const char *end, const LangOptions &LO, const TargetInfo &Target)
virtual void HandleObjCFlagsWithNonObjCConversion(const char *flagsStart, const char *flagsEnd, const char *conversionPosition)
Definition: FormatString.h:700
#define false
Definition: stdbool.h:33
virtual void HandleInvalidPosition(const char *startPos, unsigned posLen, PositionContext p)
Definition: FormatString.h:686
void setIsPrivate(const char *position)
Definition: FormatString.h:536
Class representing optional flags with location and representation information.
Definition: FormatString.h:34
void setHasThousandsGrouping(const char *position)
Definition: FormatString.h:515
void setConversionSpecifier(const ScanfConversionSpecifier &cs)
Definition: FormatString.h:646
const PrintfConversionSpecifier & getConversionSpecifier() const
Definition: FormatString.h:545
virtual bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS, const char *startSpecifier, unsigned specifierLen)
Definition: FormatString.h:712
const OptionalFlag & hasObjCTechnicalTerm() const
Definition: FormatString.h:577
Dataflow Directional Tag Classes.
void setSuppressAssignment(const char *position)
Definition: FormatString.h:638
const OptionalAmount & getVectorNumElts() const
Definition: FormatString.h:430
OptionalFlag & operator=(const bool &rhs)
Definition: FormatString.h:54
const OptionalFlag & isPrivate() const
Definition: FormatString.h:578
OptionalAmount(HowSpecified howSpecified, unsigned amount, const char *amountStart, unsigned amountLength, bool usesPositionalArg)
Definition: FormatString.h:315
void setHasObjCTechnicalTerm(const char *position)
Definition: FormatString.h:533
const OptionalAmount & getPrecision() const
Definition: FormatString.h:554
void setHasPlusPrefix(const char *position)
Definition: FormatString.h:521
const OptionalFlag & isPublic() const
Definition: FormatString.h:579
const OptionalFlag & hasSpacePrefix() const
Definition: FormatString.h:576
virtual void HandleIncompleteSpecifier(const char *startSpecifier, unsigned specifierLen)
Definition: FormatString.h:691
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
bool UsesPositionalArg
Positional arguments, an IEEE extension: IEEE Std 1003.1, 2004 Edition http://www.opengroup.org/onlinepubs/009695399/functions/printf.html.
Definition: FormatString.h:393
static bool classof(const analyze_format_string::ConversionSpecifier *CS)
Definition: FormatString.h:475
ConversionSpecifier(bool isPrintf, const char *pos, Kind k)
Definition: FormatString.h:196
bool ParsePrintfString(FormatStringHandler &H, const char *beg, const char *end, const LangOptions &LO, const TargetInfo &Target, bool isFreeBSDKPrintf)
void setHasAlternativeForm(const char *position)
Definition: FormatString.h:527
#define true
Definition: stdbool.h:32
void setIsSensitive(const char *position)
Definition: FormatString.h:538
virtual void HandleIncompleteScanList(const char *start, const char *end)
Definition: FormatString.h:736
virtual bool HandleInvalidScanfConversionSpecifier(const analyze_scanf::ScanfSpecifier &FS, const char *startSpecifier, unsigned specifierLen)
Definition: FormatString.h:723