FormatString.h source code [clang_source_code/include/clang/AST/FormatString.h]

1	//= FormatString.h - Analysis of printf/fprintf 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	// This file defines APIs for analyzing the format strings of printf, fscanf,
10	// and friends.
11	//
12	// The structure of format strings for fprintf are described in C99 7.19.6.1.
13	//
14	// The structure of format strings for fscanf are described in C99 7.19.6.2.
15	//
16	//===----------------------------------------------------------------------===//
17
18	#ifndef LLVM_CLANG_ANALYSIS_ANALYSES_FORMATSTRING_H
19	#define LLVM_CLANG_ANALYSIS_ANALYSES_FORMATSTRING_H
20
21	#include "clang/AST/CanonicalType.h"
22
23	namespace clang {
24
25	class TargetInfo;
26
27	//===----------------------------------------------------------------------===//
28	/// Common components of both fprintf and fscanf format strings.
29	namespace analyze_format_string {
30
31	/// Class representing optional flags with location and representation
32	/// information.
33	class OptionalFlag {
34	public:
35	OptionalFlag(const char *Representation)
36	: representation(Representation), flag(false) {}
37	bool isSet() const { return flag; }
38	void set() { flag = true; }
39	void clear() { flag = false; }
40	void setPosition(const char *position) {
41	assert(position);
42	flag = true;
43	this->position = position;
44	}
45	const char *getPosition() const {
46	assert(position);
47	return position;
48	}
49	const char *toString() const { return representation; }
50
51	// Overloaded operators for bool like qualities
52	explicit operator bool() const { return flag; }
53	OptionalFlag& operator=(const bool &rhs) {
54	flag = rhs;
55	return *this; // Return a reference to myself.
56	}
57	private:
58	const char *representation;
59	const char *position;
60	bool flag;
61	};
62
63	/// Represents the length modifier in a format string in scanf/printf.
64	class LengthModifier {
65	public:
66	enum Kind {
67	None,
68	AsChar, // 'hh'
69	AsShort, // 'h'
70	AsShortLong, // 'hl' (OpenCL float/int vector element)
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
87	LengthModifier()
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
121	class ConversionSpecifier {
122	public:
123	enum Kind {
124	InvalidSpecifier = 0,
125	// C99 conversion specifiers.
126	cArg,
127	dArg,
128	DArg, // Apple extension
129	iArg,
130	IntArgBeg = dArg,
131	IntArgEnd = iArg,
132
133	oArg,
134	OArg, // Apple extension
135	uArg,
136	UArg, // Apple extension
137	xArg,
138	XArg,
139	UIntArgBeg = oArg,
140	UIntArgEnd = XArg,
141
142	fArg,
143	FArg,
144	eArg,
145	EArg,
146	gArg,
147	GArg,
148	aArg,
149	AArg,
150	DoubleArgBeg = fArg,
151	DoubleArgEnd = AArg,
152
153	sArg,
154	pArg,
155	nArg,
156	PercentArg,
157	CArg,
158	SArg,
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.
163	PArg,
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.
175	FreeBSDbArg,
176	FreeBSDDArg,
177	FreeBSDrArg,
178	FreeBSDyArg,
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;
246	Kind kind;
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	(0) . __assert_fail ("A.K >= InvalidTy && \"ArgType cannot be pointer to invalid/unknown\"", "/home/seafit/code_projects/clang_source/clang/include/clang/AST/FormatString.h", 281, __PRETTY_FUNCTION__))" file_link="../../../../include/assert.h.html#88" macro="true">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
311	class OptionalAmount {
312	public:
313	enum HowSpecified { NotSpecified, Constant, Arg, Invalid };
314
315	OptionalAmount(HowSpecified howSpecified,
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
383	class FormatSpecifier {
384	protected:
385	LengthModifier LM;
386	OptionalAmount FieldWidth;
387	ConversionSpecifier CS;
388	OptionalAmount VectorNumElts;
389
390	/// Positional arguments, an IEEE extension:
391	/// IEEE Std 1003.1, 2004 Edition
392	/// http://www.opengroup.org/onlinepubs/009695399/functions/printf.html
393	bool UsesPositionalArg;
394	unsigned argIndex;
395	public:
396	FormatSpecifier(bool isPrintf)
397	: CS(isPrintf), VectorNumElts(false),
398	UsesPositionalArg(false), argIndex(0) {}
399
400	void setLengthModifier(LengthModifier lm) {
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
418	const LengthModifier &getLengthModifier() const {
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
430	const OptionalAmount &getVectorNumElts() const {
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,
441	const LangOptions &LO) const;
442
443	bool hasStandardLengthModifier() const;
444
445	Optional<LengthModifier> getCorrectedLengthModifier() const;
446
447	bool hasStandardConversionSpecifier(const LangOptions &LangOpt) const;
448
449	bool hasStandardLengthConversionCombination() const;
450
451	/// For a TypedefType QT, if it is a named integer type such as size_t,
452	/// assign the appropriate value to LM and return true.
453	static bool namedTypeToLengthModifier(QualType QT, LengthModifier &LM);
454	};
455
456	} // end analyze_format_string namespace
457
458	//===----------------------------------------------------------------------===//
459	/// Pieces specific to fprintf format strings.
460
461	namespace analyze_printf {
462
463	class PrintfConversionSpecifier :
464	public analyze_format_string::ConversionSpecifier {
465	public:
466	PrintfConversionSpecifier()
467	: ConversionSpecifier(true, nullptr, InvalidSpecifier) {}
468
469	PrintfConversionSpecifier(const char *pos, Kind k)
470	: ConversionSpecifier(true, pos, k) {}
471
472	bool isObjCArg() const { return kind >= ObjCBeg && kind <= ObjCEnd; }
473	bool isDoubleArg() const { return kind >= DoubleArgBeg &&
474	kind <= DoubleArgEnd; }
475
476	static bool classof(const analyze_format_string::ConversionSpecifier *CS) {
477	return CS->isPrintfKind();
478	}
479	};
480
481	using analyze_format_string::ArgType;
482	using analyze_format_string::LengthModifier;
483	using analyze_format_string::OptionalAmount;
484	using analyze_format_string::OptionalFlag;
485
486	class PrintfSpecifier : public analyze_format_string::FormatSpecifier {
487	OptionalFlag HasThousandsGrouping; // ''', POSIX extension.
488	OptionalFlag IsLeftJustified; // '-'
489	OptionalFlag HasPlusPrefix; // '+'
490	OptionalFlag HasSpacePrefix; // ' '
491	OptionalFlag HasAlternativeForm; // '#'
492	OptionalFlag HasLeadingZeroes; // '0'
493	OptionalFlag HasObjCTechnicalTerm; // '[tt]'
494	OptionalFlag IsPrivate; // '{private}'
495	OptionalFlag IsPublic; // '{public}'
496	OptionalFlag IsSensitive; // '{sensitive}'
497	OptionalAmount Precision;
498	StringRef MaskType;
499
500	ArgType getScalarArgType(ASTContext &Ctx, bool IsObjCLiteral) const;
501
502	public:
503	PrintfSpecifier()
504	: FormatSpecifier(/* isPrintf = */ true), HasThousandsGrouping("'"),
505	IsLeftJustified("-"), HasPlusPrefix("+"), HasSpacePrefix(" "),
506	HasAlternativeForm("#"), HasLeadingZeroes("0"),
507	HasObjCTechnicalTerm("tt"), IsPrivate("private"), IsPublic("public"),
508	IsSensitive("sensitive") {}
509
510	static PrintfSpecifier Parse(const char beg, const char end);
511
512	// Methods for incrementally constructing the PrintfSpecifier.
513	void setConversionSpecifier(const PrintfConversionSpecifier &cs) {
514	CS = cs;
515	}
516	void setHasThousandsGrouping(const char *position) {
517	HasThousandsGrouping.setPosition(position);
518	}
519	void setIsLeftJustified(const char *position) {
520	IsLeftJustified.setPosition(position);
521	}
522	void setHasPlusPrefix(const char *position) {
523	HasPlusPrefix.setPosition(position);
524	}
525	void setHasSpacePrefix(const char *position) {
526	HasSpacePrefix.setPosition(position);
527	}
528	void setHasAlternativeForm(const char *position) {
529	HasAlternativeForm.setPosition(position);
530	}
531	void setHasLeadingZeros(const char *position) {
532	HasLeadingZeroes.setPosition(position);
533	}
534	void setHasObjCTechnicalTerm(const char *position) {
535	HasObjCTechnicalTerm.setPosition(position);
536	}
537	void setIsPrivate(const char *position) { IsPrivate.setPosition(position); }
538	void setIsPublic(const char *position) { IsPublic.setPosition(position); }
539	void setIsSensitive(const char *position) {
540	IsSensitive.setPosition(position);
541	}
542	void setUsesPositionalArg() { UsesPositionalArg = true; }
543
544	// Methods for querying the format specifier.
545
546	const PrintfConversionSpecifier &getConversionSpecifier() const {
547	return cast<PrintfConversionSpecifier>(CS);
548	}
549
550	void setPrecision(const OptionalAmount &Amt) {
551	Precision = Amt;
552	Precision.setUsesDotPrefix();
553	}
554
555	const OptionalAmount &getPrecision() const {
556	return Precision;
557	}
558
559	bool consumesDataArgument() const {
560	return getConversionSpecifier().consumesDataArgument();
561	}
562
563	/// Returns the builtin type that a data argument
564	/// paired with this format specifier should have. This method
565	/// will return null if the format specifier does not have
566	/// a matching data argument or the matching argument matches
567	/// more than one type.
568	ArgType getArgType(ASTContext &Ctx, bool IsObjCLiteral) const;
569
570	const OptionalFlag &hasThousandsGrouping() const {
571	return HasThousandsGrouping;
572	}
573	const OptionalFlag &isLeftJustified() const { return IsLeftJustified; }
574	const OptionalFlag &hasPlusPrefix() const { return HasPlusPrefix; }
575	const OptionalFlag &hasAlternativeForm() const { return HasAlternativeForm; }
576	const OptionalFlag &hasLeadingZeros() const { return HasLeadingZeroes; }
577	const OptionalFlag &hasSpacePrefix() const { return HasSpacePrefix; }
578	const OptionalFlag &hasObjCTechnicalTerm() const { return HasObjCTechnicalTerm; }
579	const OptionalFlag &isPrivate() const { return IsPrivate; }
580	const OptionalFlag &isPublic() const { return IsPublic; }
581	const OptionalFlag &isSensitive() const { return IsSensitive; }
582	bool usesPositionalArg() const { return UsesPositionalArg; }
583
584	StringRef getMaskType() const { return MaskType; }
585	void setMaskType(StringRef S) { MaskType = S; }
586
587	/// Changes the specifier and length according to a QualType, retaining any
588	/// flags or options. Returns true on success, or false when a conversion
589	/// was not successful.
590	bool fixType(QualType QT, const LangOptions &LangOpt, ASTContext &Ctx,
591	bool IsObjCLiteral);
592
593	void toString(raw_ostream &os) const;
594
595	// Validation methods - to check if any element results in undefined behavior
596	bool hasValidPlusPrefix() const;
597	bool hasValidAlternativeForm() const;
598	bool hasValidLeadingZeros() const;
599	bool hasValidSpacePrefix() const;
600	bool hasValidLeftJustified() const;
601	bool hasValidThousandsGroupingPrefix() const;
602
603	bool hasValidPrecision() const;
604	bool hasValidFieldWidth() const;
605	};
606	} // end analyze_printf namespace
607
608	//===----------------------------------------------------------------------===//
609	/// Pieces specific to fscanf format strings.
610
611	namespace analyze_scanf {
612
613	class ScanfConversionSpecifier :
614	public analyze_format_string::ConversionSpecifier {
615	public:
616	ScanfConversionSpecifier()
617	: ConversionSpecifier(false, nullptr, InvalidSpecifier) {}
618
619	ScanfConversionSpecifier(const char *pos, Kind k)
620	: ConversionSpecifier(false, pos, k) {}
621
622	static bool classof(const analyze_format_string::ConversionSpecifier *CS) {
623	return !CS->isPrintfKind();
624	}
625	};
626
627	using analyze_format_string::ArgType;
628	using analyze_format_string::LengthModifier;
629	using analyze_format_string::OptionalAmount;
630	using analyze_format_string::OptionalFlag;
631
632	class ScanfSpecifier : public analyze_format_string::FormatSpecifier {
633	OptionalFlag SuppressAssignment; // '*'
634	public:
635	ScanfSpecifier() :
636	FormatSpecifier(/* isPrintf = */ false),
637	SuppressAssignment("*") {}
638
639	void setSuppressAssignment(const char *position) {
640	SuppressAssignment.setPosition(position);
641	}
642
643	const OptionalFlag &getSuppressAssignment() const {
644	return SuppressAssignment;
645	}
646
647	void setConversionSpecifier(const ScanfConversionSpecifier &cs) {
648	CS = cs;
649	}
650
651	const ScanfConversionSpecifier &getConversionSpecifier() const {
652	return cast<ScanfConversionSpecifier>(CS);
653	}
654
655	bool consumesDataArgument() const {
656	return CS.consumesDataArgument() && !SuppressAssignment;
657	}
658
659	ArgType getArgType(ASTContext &Ctx) const;
660
661	bool fixType(QualType QT, QualType RawQT, const LangOptions &LangOpt,
662	ASTContext &Ctx);
663
664	void toString(raw_ostream &os) const;
665
666	static ScanfSpecifier Parse(const char beg, const char end);
667	};
668
669	} // end analyze_scanf namespace
670
671	//===----------------------------------------------------------------------===//
672	// Parsing and processing of format strings (both fprintf and fscanf).
673
674	namespace analyze_format_string {
675
676	enum PositionContext { FieldWidthPos = 0, PrecisionPos = 1 };
677
678	class FormatStringHandler {
679	public:
680	FormatStringHandler() {}
681	virtual ~FormatStringHandler();
682
683	virtual void HandleNullChar(const char *nullCharacter) {}
684
685	virtual void HandlePosition(const char *startPos, unsigned posLen) {}
686
687	virtual void HandleInvalidPosition(const char *startPos, unsigned posLen,
688	PositionContext p) {}
689
690	virtual void HandleZeroPosition(const char *startPos, unsigned posLen) {}
691
692	virtual void HandleIncompleteSpecifier(const char *startSpecifier,
693	unsigned specifierLen) {}
694
695	virtual void HandleEmptyObjCModifierFlag(const char *startFlags,
696	unsigned flagsLen) {}
697
698	virtual void HandleInvalidObjCModifierFlag(const char *startFlag,
699	unsigned flagLen) {}
700
701	virtual void HandleObjCFlagsWithNonObjCConversion(const char *flagsStart,
702	const char *flagsEnd,
703	const char *conversionPosition) {}
704	// Printf-specific handlers.
705
706	virtual bool HandleInvalidPrintfConversionSpecifier(
707	const analyze_printf::PrintfSpecifier &FS,
708	const char *startSpecifier,
709	unsigned specifierLen) {
710	return true;
711	}
712
713	virtual bool HandlePrintfSpecifier(const analyze_printf::PrintfSpecifier &FS,
714	const char *startSpecifier,
715	unsigned specifierLen) {
716	return true;
717	}
718
719	/// Handle mask types whose sizes are not between one and eight bytes.
720	virtual void handleInvalidMaskType(StringRef MaskType) {}
721
722	// Scanf-specific handlers.
723
724	virtual bool HandleInvalidScanfConversionSpecifier(
725	const analyze_scanf::ScanfSpecifier &FS,
726	const char *startSpecifier,
727	unsigned specifierLen) {
728	return true;
729	}
730
731	virtual bool HandleScanfSpecifier(const analyze_scanf::ScanfSpecifier &FS,
732	const char *startSpecifier,
733	unsigned specifierLen) {
734	return true;
735	}
736
737	virtual void HandleIncompleteScanList(const char start, const char end) {}
738	};
739
740	bool ParsePrintfString(FormatStringHandler &H,
741	const char beg, const char end, const LangOptions &LO,
742	const TargetInfo &Target, bool isFreeBSDKPrintf);
743
744	bool ParseFormatStringHasSArg(const char beg, const char end,
745	const LangOptions &LO, const TargetInfo &Target);
746
747	bool ParseScanfString(FormatStringHandler &H,
748	const char beg, const char end, const LangOptions &LO,
749	const TargetInfo &Target);
750
751	} // end analyze_format_string namespace
752	} // end clang namespace
753	#endif
754