blob: 7347dca3c21e3024ba56a764a945e07d86fb1e7e [file] [log] [blame]
Ted Kremenek826a3452010-07-16 02:11:22 +00001//== PrintfFormatString.cpp - Analysis of printf format strings --*- C++ -*-==//
Ted Kremenek8f0a1c72010-01-27 23:43:25 +00002//
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// Handling of format string in printf and friends. The structure of format
11// strings for fprintf() are described in C99 7.19.6.1.
12//
13//===----------------------------------------------------------------------===//
14
Ted Kremenek826a3452010-07-16 02:11:22 +000015#include "clang/Analysis/Analyses/FormatString.h"
16#include "FormatStringParsing.h"
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000017
Ted Kremenek826a3452010-07-16 02:11:22 +000018using clang::analyze_format_string::ArgTypeResult;
19using clang::analyze_format_string::FormatStringHandler;
20using clang::analyze_format_string::LengthModifier;
21using clang::analyze_format_string::OptionalAmount;
Ted Kremenek6ecb9502010-07-20 20:04:27 +000022using clang::analyze_format_string::ConversionSpecifier;
Ted Kremenek826a3452010-07-16 02:11:22 +000023using clang::analyze_printf::PrintfSpecifier;
Ted Kremenekefaff192010-02-27 01:41:03 +000024
Ted Kremenek808015a2010-01-29 03:16:21 +000025using namespace clang;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000026
Ted Kremenek826a3452010-07-16 02:11:22 +000027typedef clang::analyze_format_string::SpecifierResult<PrintfSpecifier>
28 PrintfSpecifierResult;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000029
30//===----------------------------------------------------------------------===//
31// Methods for parsing format strings.
32//===----------------------------------------------------------------------===//
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000033
Ted Kremenek826a3452010-07-16 02:11:22 +000034using analyze_format_string::ParseNonPositionAmount;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000035
Ted Kremenek826a3452010-07-16 02:11:22 +000036static bool ParsePrecision(FormatStringHandler &H, PrintfSpecifier &FS,
Ted Kremenekefaff192010-02-27 01:41:03 +000037 const char *Start, const char *&Beg, const char *E,
38 unsigned *argIndex) {
39 if (argIndex) {
40 FS.setPrecision(ParseNonPositionAmount(Beg, E, *argIndex));
Chad Rosier30601782011-08-17 23:08:45 +000041 } else {
Ted Kremenekefaff192010-02-27 01:41:03 +000042 const OptionalAmount Amt = ParsePositionAmount(H, Start, Beg, E,
Ted Kremenek826a3452010-07-16 02:11:22 +000043 analyze_format_string::PrecisionPos);
Ted Kremenekefaff192010-02-27 01:41:03 +000044 if (Amt.isInvalid())
45 return true;
46 FS.setPrecision(Amt);
47 }
48 return false;
49}
50
Ted Kremenek826a3452010-07-16 02:11:22 +000051static PrintfSpecifierResult ParsePrintfSpecifier(FormatStringHandler &H,
Ted Kremenek74d56a12010-02-04 20:46:58 +000052 const char *&Beg,
Ted Kremenek7f70dc82010-02-26 19:18:41 +000053 const char *E,
54 unsigned &argIndex) {
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000055
Ted Kremenek6ecb9502010-07-20 20:04:27 +000056 using namespace clang::analyze_format_string;
Ted Kremenek4b220fa2010-01-29 02:13:53 +000057 using namespace clang::analyze_printf;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000058
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000059 const char *I = Beg;
Ted Kremenekc7ae51a2010-01-28 00:02:05 +000060 const char *Start = 0;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000061 UpdateOnReturn <const char*> UpdateBeg(Beg, I);
62
63 // Look for a '%' character that indicates the start of a format specifier.
Ted Kremeneke729acb2010-01-28 23:56:52 +000064 for ( ; I != E ; ++I) {
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000065 char c = *I;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000066 if (c == '\0') {
67 // Detect spurious null characters, which are likely errors.
68 H.HandleNullChar(I);
69 return true;
70 }
71 if (c == '%') {
Ted Kremeneke729acb2010-01-28 23:56:52 +000072 Start = I++; // Record the start of the format specifier.
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000073 break;
74 }
75 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000076
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000077 // No format specifier found?
78 if (!Start)
79 return false;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000080
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000081 if (I == E) {
82 // No more characters left?
Ted Kremenek826a3452010-07-16 02:11:22 +000083 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000084 return true;
85 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000086
Ted Kremenek826a3452010-07-16 02:11:22 +000087 PrintfSpecifier FS;
Ted Kremenekefaff192010-02-27 01:41:03 +000088 if (ParseArgPosition(H, FS, Start, I, E))
89 return true;
90
91 if (I == E) {
92 // No more characters left?
Ted Kremenek826a3452010-07-16 02:11:22 +000093 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenekefaff192010-02-27 01:41:03 +000094 return true;
95 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +000096
Ted Kremenek8f0a1c72010-01-27 23:43:25 +000097 // Look for flags (if any).
98 bool hasMore = true;
99 for ( ; I != E; ++I) {
100 switch (*I) {
101 default: hasMore = false; break;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000102 case '\'':
Ted Kremenekbd18d452011-01-08 05:28:38 +0000103 // FIXME: POSIX specific. Always accept?
104 FS.setHasThousandsGrouping(I);
105 break;
Tom Caree4ee9662010-06-17 19:00:27 +0000106 case '-': FS.setIsLeftJustified(I); break;
107 case '+': FS.setHasPlusPrefix(I); break;
108 case ' ': FS.setHasSpacePrefix(I); break;
109 case '#': FS.setHasAlternativeForm(I); break;
110 case '0': FS.setHasLeadingZeros(I); break;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000111 }
112 if (!hasMore)
113 break;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000114 }
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000115
116 if (I == E) {
117 // No more characters left?
Ted Kremenek826a3452010-07-16 02:11:22 +0000118 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000119 return true;
120 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000121
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000122 // Look for the field width (if any).
Ted Kremenekefaff192010-02-27 01:41:03 +0000123 if (ParseFieldWidth(H, FS, Start, I, E,
124 FS.usesPositionalArg() ? 0 : &argIndex))
125 return true;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000126
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000127 if (I == E) {
128 // No more characters left?
Ted Kremenek826a3452010-07-16 02:11:22 +0000129 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000130 return true;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000131 }
132
133 // Look for the precision (if any).
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000134 if (*I == '.') {
Ted Kremenek808015a2010-01-29 03:16:21 +0000135 ++I;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000136 if (I == E) {
Ted Kremenek826a3452010-07-16 02:11:22 +0000137 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000138 return true;
139 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000140
Ted Kremenekefaff192010-02-27 01:41:03 +0000141 if (ParsePrecision(H, FS, Start, I, E,
142 FS.usesPositionalArg() ? 0 : &argIndex))
143 return true;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000144
145 if (I == E) {
146 // No more characters left?
Ted Kremenek826a3452010-07-16 02:11:22 +0000147 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000148 return true;
149 }
150 }
151
152 // Look for the length modifier.
Ted Kremenek826a3452010-07-16 02:11:22 +0000153 if (ParseLengthModifier(FS, I, E) && I == E) {
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000154 // No more characters left?
Ted Kremenek826a3452010-07-16 02:11:22 +0000155 H.HandleIncompleteSpecifier(Start, E - Start);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000156 return true;
157 }
Ted Kremenekdf17f9d2010-02-09 00:04:09 +0000158
Ted Kremenek4dcb18f2010-01-29 20:29:53 +0000159 if (*I == '\0') {
Ted Kremenekdf17f9d2010-02-09 00:04:09 +0000160 // Detect spurious null characters, which are likely errors.
161 H.HandleNullChar(I);
162 return true;
Ted Kremenek4dcb18f2010-01-29 20:29:53 +0000163 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000164
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000165 // Finally, look for the conversion specifier.
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000166 const char *conversionPosition = I++;
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000167 ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000168 switch (*conversionPosition) {
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000169 default:
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000170 break;
Ted Kremenekc7cbb9b2010-01-28 00:55:28 +0000171 // C99: 7.19.6.1 (section 8).
Ted Kremenek87260c72010-02-24 00:05:54 +0000172 case '%': k = ConversionSpecifier::PercentArg; break;
173 case 'A': k = ConversionSpecifier::AArg; break;
174 case 'E': k = ConversionSpecifier::EArg; break;
175 case 'F': k = ConversionSpecifier::FArg; break;
176 case 'G': k = ConversionSpecifier::GArg; break;
177 case 'X': k = ConversionSpecifier::XArg; break;
178 case 'a': k = ConversionSpecifier::aArg; break;
Ted Kremenek92a6feb2010-07-20 20:03:49 +0000179 case 'c': k = ConversionSpecifier::cArg; break;
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000180 case 'd': k = ConversionSpecifier::dArg; break;
Ted Kremenek87260c72010-02-24 00:05:54 +0000181 case 'e': k = ConversionSpecifier::eArg; break;
182 case 'f': k = ConversionSpecifier::fArg; break;
183 case 'g': k = ConversionSpecifier::gArg; break;
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000184 case 'i': k = ConversionSpecifier::iArg; break;
Ted Kremenek35d353b2010-07-20 20:04:10 +0000185 case 'n': k = ConversionSpecifier::nArg; break;
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000186 case 'o': k = ConversionSpecifier::oArg; break;
Ted Kremenek66932052010-07-20 20:04:04 +0000187 case 'p': k = ConversionSpecifier::pArg; break;
Ted Kremenek99196b12010-07-20 20:03:58 +0000188 case 's': k = ConversionSpecifier::sArg; break;
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000189 case 'u': k = ConversionSpecifier::uArg; break;
190 case 'x': k = ConversionSpecifier::xArg; break;
Ted Kremenekbd18d452011-01-08 05:28:38 +0000191 // POSIX specific.
Ted Kremenek87260c72010-02-24 00:05:54 +0000192 case 'C': k = ConversionSpecifier::CArg; break;
Ted Kremenekde183a42010-07-20 20:04:15 +0000193 case 'S': k = ConversionSpecifier::SArg; break;
Ted Kremenekc7cbb9b2010-01-28 00:55:28 +0000194 // Objective-C.
Ted Kremenek4dcb18f2010-01-29 20:29:53 +0000195 case '@': k = ConversionSpecifier::ObjCObjArg; break;
Ted Kremenekdf17f9d2010-02-09 00:04:09 +0000196 // Glibc specific.
Ted Kremenek4dcb18f2010-01-29 20:29:53 +0000197 case 'm': k = ConversionSpecifier::PrintErrno; break;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000198 }
Ted Kremenek6ecb9502010-07-20 20:04:27 +0000199 PrintfConversionSpecifier CS(conversionPosition, k);
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000200 FS.setConversionSpecifier(CS);
Ted Kremenekefaff192010-02-27 01:41:03 +0000201 if (CS.consumesDataArgument() && !FS.usesPositionalArg())
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000202 FS.setArgIndex(argIndex++);
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000203
204 if (k == ConversionSpecifier::InvalidSpecifier) {
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000205 // Assume the conversion takes one argument.
Ted Kremenek79662972010-12-02 20:57:51 +0000206 return !H.HandleInvalidPrintfConversionSpecifier(FS, Start, I - Start);
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000207 }
Ted Kremenek826a3452010-07-16 02:11:22 +0000208 return PrintfSpecifierResult(Start, FS);
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000209}
210
Ted Kremenek826a3452010-07-16 02:11:22 +0000211bool clang::analyze_format_string::ParsePrintfString(FormatStringHandler &H,
212 const char *I,
213 const char *E) {
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000214
215 unsigned argIndex = 0;
216
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000217 // Keep looking for a format specifier until we have exhausted the string.
218 while (I != E) {
Ted Kremenek826a3452010-07-16 02:11:22 +0000219 const PrintfSpecifierResult &FSR = ParsePrintfSpecifier(H, I, E, argIndex);
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000220 // Did a fail-stop error of any kind occur when parsing the specifier?
221 // If so, don't do any more processing.
222 if (FSR.shouldStop())
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000223 return true;;
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000224 // Did we exhaust the string or encounter an error that
225 // we can recover from?
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000226 if (!FSR.hasValue())
Ted Kremenek26ac2e02010-01-29 02:40:24 +0000227 continue;
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000228 // We have a format specifier. Pass it to the callback.
Ted Kremenek826a3452010-07-16 02:11:22 +0000229 if (!H.HandlePrintfSpecifier(FSR.getValue(), FSR.getStart(),
Ted Kremeneka8d8fec2010-01-28 02:46:17 +0000230 I - FSR.getStart()))
Ted Kremenek4dcb18f2010-01-29 20:29:53 +0000231 return true;
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000232 }
233 assert(I == E && "Format string not exhausted");
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000234 return false;
235}
Ted Kremenek8f0a1c72010-01-27 23:43:25 +0000236
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000237//===----------------------------------------------------------------------===//
Tom Care3bfc5f42010-06-09 04:11:11 +0000238// Methods on ConversionSpecifier.
239//===----------------------------------------------------------------------===//
240const char *ConversionSpecifier::toString() const {
241 switch (kind) {
242 case dArg: return "d";
243 case iArg: return "i";
244 case oArg: return "o";
245 case uArg: return "u";
246 case xArg: return "x";
247 case XArg: return "X";
248 case fArg: return "f";
249 case FArg: return "F";
250 case eArg: return "e";
251 case EArg: return "E";
252 case gArg: return "g";
253 case GArg: return "G";
254 case aArg: return "a";
255 case AArg: return "A";
Ted Kremenek7fdba132010-07-20 20:04:36 +0000256 case cArg: return "c";
257 case sArg: return "s";
258 case pArg: return "p";
259 case nArg: return "n";
260 case PercentArg: return "%";
261 case ScanListArg: return "[";
Tom Care3bfc5f42010-06-09 04:11:11 +0000262 case InvalidSpecifier: return NULL;
263
264 // MacOS X unicode extensions.
Ted Kremenek7fdba132010-07-20 20:04:36 +0000265 case CArg: return "C";
Ted Kremenekde183a42010-07-20 20:04:15 +0000266 case SArg: return "S";
Tom Care3bfc5f42010-06-09 04:11:11 +0000267
268 // Objective-C specific specifiers.
269 case ObjCObjArg: return "@";
270
271 // GlibC specific specifiers.
272 case PrintErrno: return "m";
273 }
274 return NULL;
275}
276
277//===----------------------------------------------------------------------===//
Ted Kremenek826a3452010-07-16 02:11:22 +0000278// Methods on PrintfSpecifier.
Tom Care3bfc5f42010-06-09 04:11:11 +0000279//===----------------------------------------------------------------------===//
280
Ted Kremenek826a3452010-07-16 02:11:22 +0000281ArgTypeResult PrintfSpecifier::getArgType(ASTContext &Ctx) const {
Ted Kremenek6ecb9502010-07-20 20:04:27 +0000282 const PrintfConversionSpecifier &CS = getConversionSpecifier();
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000283
Ted Kremenek33567d22010-01-29 22:59:32 +0000284 if (!CS.consumesDataArgument())
285 return ArgTypeResult::Invalid();
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000286
Ted Kremenek9325eaf2010-08-24 22:24:51 +0000287 if (CS.getKind() == ConversionSpecifier::cArg)
288 switch (LM.getKind()) {
289 case LengthModifier::None: return Ctx.IntTy;
290 case LengthModifier::AsLong: return ArgTypeResult::WIntTy;
291 default:
292 return ArgTypeResult::Invalid();
293 }
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000294
Ted Kremenek33567d22010-01-29 22:59:32 +0000295 if (CS.isIntArg())
Tom Care3bfc5f42010-06-09 04:11:11 +0000296 switch (LM.getKind()) {
297 case LengthModifier::AsLongDouble:
Ted Kremenek33567d22010-01-29 22:59:32 +0000298 return ArgTypeResult::Invalid();
Tom Care3bfc5f42010-06-09 04:11:11 +0000299 case LengthModifier::None: return Ctx.IntTy;
Ted Kremenek6ca4a9a2011-10-25 04:20:41 +0000300 case LengthModifier::AsChar: return ArgTypeResult::AnyCharTy;
Tom Care3bfc5f42010-06-09 04:11:11 +0000301 case LengthModifier::AsShort: return Ctx.ShortTy;
302 case LengthModifier::AsLong: return Ctx.LongTy;
303 case LengthModifier::AsLongLong: return Ctx.LongLongTy;
304 case LengthModifier::AsIntMax:
Ted Kremenek33567d22010-01-29 22:59:32 +0000305 // FIXME: Return unknown for now.
306 return ArgTypeResult();
Tom Care3bfc5f42010-06-09 04:11:11 +0000307 case LengthModifier::AsSizeT: return Ctx.getSizeType();
308 case LengthModifier::AsPtrDiff: return Ctx.getPointerDiffType();
Ted Kremenek33567d22010-01-29 22:59:32 +0000309 }
310
311 if (CS.isUIntArg())
Tom Care3bfc5f42010-06-09 04:11:11 +0000312 switch (LM.getKind()) {
313 case LengthModifier::AsLongDouble:
Ted Kremenek33567d22010-01-29 22:59:32 +0000314 return ArgTypeResult::Invalid();
Tom Care3bfc5f42010-06-09 04:11:11 +0000315 case LengthModifier::None: return Ctx.UnsignedIntTy;
316 case LengthModifier::AsChar: return Ctx.UnsignedCharTy;
317 case LengthModifier::AsShort: return Ctx.UnsignedShortTy;
318 case LengthModifier::AsLong: return Ctx.UnsignedLongTy;
319 case LengthModifier::AsLongLong: return Ctx.UnsignedLongLongTy;
320 case LengthModifier::AsIntMax:
Ted Kremenek33567d22010-01-29 22:59:32 +0000321 // FIXME: Return unknown for now.
322 return ArgTypeResult();
Tom Care3bfc5f42010-06-09 04:11:11 +0000323 case LengthModifier::AsSizeT:
Ted Kremenek33567d22010-01-29 22:59:32 +0000324 // FIXME: How to get the corresponding unsigned
325 // version of size_t?
326 return ArgTypeResult();
Tom Care3bfc5f42010-06-09 04:11:11 +0000327 case LengthModifier::AsPtrDiff:
Ted Kremenek33567d22010-01-29 22:59:32 +0000328 // FIXME: How to get the corresponding unsigned
329 // version of ptrdiff_t?
330 return ArgTypeResult();
331 }
Ted Kremenek4e4b30e2010-02-16 01:46:59 +0000332
Ted Kremenekf911eba2010-02-01 23:23:50 +0000333 if (CS.isDoubleArg()) {
Tom Care3bfc5f42010-06-09 04:11:11 +0000334 if (LM.getKind() == LengthModifier::AsLongDouble)
Ted Kremenekf911eba2010-02-01 23:23:50 +0000335 return Ctx.LongDoubleTy;
Ted Kremenekc9a89fe2010-01-30 01:02:18 +0000336 return Ctx.DoubleTy;
Ted Kremenekf911eba2010-02-01 23:23:50 +0000337 }
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000338
Ted Kremenek87260c72010-02-24 00:05:54 +0000339 switch (CS.getKind()) {
Ted Kremenek99196b12010-07-20 20:03:58 +0000340 case ConversionSpecifier::sArg:
Tom Care3bfc5f42010-06-09 04:11:11 +0000341 return ArgTypeResult(LM.getKind() == LengthModifier::AsWideChar ?
342 ArgTypeResult::WCStrTy : ArgTypeResult::CStrTy);
Ted Kremenekde183a42010-07-20 20:04:15 +0000343 case ConversionSpecifier::SArg:
Ted Kremenek87260c72010-02-24 00:05:54 +0000344 // FIXME: This appears to be Mac OS X specific.
345 return ArgTypeResult::WCStrTy;
346 case ConversionSpecifier::CArg:
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000347 return Ctx.WCharTy;
Ted Kremenek66932052010-07-20 20:04:04 +0000348 case ConversionSpecifier::pArg:
Ted Kremenek13927a42010-06-16 21:23:04 +0000349 return ArgTypeResult::CPointerTy;
Ted Kremenek87260c72010-02-24 00:05:54 +0000350 default:
351 break;
352 }
Ted Kremenek7f70dc82010-02-26 19:18:41 +0000353
Ted Kremenek33567d22010-01-29 22:59:32 +0000354 // FIXME: Handle other cases.
Ted Kremenek40888ad2010-01-29 23:00:35 +0000355 return ArgTypeResult();
Ted Kremenek33567d22010-01-29 22:59:32 +0000356}
357
Hans Wennborga7da2152011-10-18 08:10:06 +0000358bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt) {
Tom Care3bfc5f42010-06-09 04:11:11 +0000359 // Handle strings first (char *, wchar_t *)
360 if (QT->isPointerType() && (QT->getPointeeType()->isAnyCharacterType())) {
Ted Kremenek99196b12010-07-20 20:03:58 +0000361 CS.setKind(ConversionSpecifier::sArg);
Tom Care3bfc5f42010-06-09 04:11:11 +0000362
Tom Care876e9942010-06-11 04:22:02 +0000363 // Disable irrelevant flags
364 HasAlternativeForm = 0;
365 HasLeadingZeroes = 0;
366
Tom Care3bfc5f42010-06-09 04:11:11 +0000367 // Set the long length modifier for wide characters
368 if (QT->getPointeeType()->isWideCharType())
369 LM.setKind(LengthModifier::AsWideChar);
370
371 return true;
372 }
373
374 // We can only work with builtin types.
Tom Care3bfc5f42010-06-09 04:11:11 +0000375 const BuiltinType *BT = QT->getAs<BuiltinType>();
John McCall2dde35b2011-10-18 22:28:37 +0000376 if (!BT)
377 return false;
Tom Care876e9942010-06-11 04:22:02 +0000378
Tom Care3bfc5f42010-06-09 04:11:11 +0000379 // Set length modifier
380 switch (BT->getKind()) {
Eli Friedman06d88ec2011-04-27 22:06:20 +0000381 case BuiltinType::Bool:
382 case BuiltinType::WChar_U:
383 case BuiltinType::WChar_S:
384 case BuiltinType::Char16:
385 case BuiltinType::Char32:
386 case BuiltinType::UInt128:
387 case BuiltinType::Int128:
Anton Korobeynikovaa4a99b2011-10-14 23:23:15 +0000388 case BuiltinType::Half:
John McCall2dde35b2011-10-18 22:28:37 +0000389 // Various types which are non-trivial to correct.
Eli Friedman06d88ec2011-04-27 22:06:20 +0000390 return false;
391
John McCall2dde35b2011-10-18 22:28:37 +0000392#define SIGNED_TYPE(Id, SingletonId)
393#define UNSIGNED_TYPE(Id, SingletonId)
394#define FLOATING_TYPE(Id, SingletonId)
395#define BUILTIN_TYPE(Id, SingletonId) \
396 case BuiltinType::Id:
397#include "clang/AST/BuiltinTypes.def"
Eli Friedman06d88ec2011-04-27 22:06:20 +0000398 // Misc other stuff which doesn't make sense here.
399 return false;
400
401 case BuiltinType::UInt:
402 case BuiltinType::Int:
403 case BuiltinType::Float:
404 case BuiltinType::Double:
Tom Care876e9942010-06-11 04:22:02 +0000405 LM.setKind(LengthModifier::None);
Tom Care3bfc5f42010-06-09 04:11:11 +0000406 break;
Tom Care876e9942010-06-11 04:22:02 +0000407
Ted Kremenek4d8ae4d2010-10-21 04:00:58 +0000408 case BuiltinType::Char_U:
409 case BuiltinType::UChar:
410 case BuiltinType::Char_S:
411 case BuiltinType::SChar:
412 LM.setKind(LengthModifier::AsChar);
413 break;
414
415 case BuiltinType::Short:
416 case BuiltinType::UShort:
417 LM.setKind(LengthModifier::AsShort);
418 break;
419
Tom Care3bfc5f42010-06-09 04:11:11 +0000420 case BuiltinType::Long:
421 case BuiltinType::ULong:
422 LM.setKind(LengthModifier::AsLong);
423 break;
424
425 case BuiltinType::LongLong:
426 case BuiltinType::ULongLong:
427 LM.setKind(LengthModifier::AsLongLong);
428 break;
429
430 case BuiltinType::LongDouble:
431 LM.setKind(LengthModifier::AsLongDouble);
432 break;
433 }
434
Hans Wennborga7da2152011-10-18 08:10:06 +0000435 // Handle size_t, ptrdiff_t, etc. that have dedicated length modifiers in C99.
436 if (isa<TypedefType>(QT) && (LangOpt.C99 || LangOpt.CPlusPlus0x)) {
437 const IdentifierInfo *Identifier = QT.getBaseTypeIdentifier();
438 if (Identifier->getName() == "size_t") {
439 LM.setKind(LengthModifier::AsSizeT);
440 } else if (Identifier->getName() == "ssize_t") {
441 // Not C99, but common in Unix.
442 LM.setKind(LengthModifier::AsSizeT);
443 } else if (Identifier->getName() == "intmax_t") {
444 LM.setKind(LengthModifier::AsIntMax);
445 } else if (Identifier->getName() == "uintmax_t") {
446 LM.setKind(LengthModifier::AsIntMax);
447 } else if (Identifier->getName() == "ptrdiff_t") {
448 LM.setKind(LengthModifier::AsPtrDiff);
449 }
450 }
451
Tom Care3bfc5f42010-06-09 04:11:11 +0000452 // Set conversion specifier and disable any flags which do not apply to it.
Ted Kremenek4d8ae4d2010-10-21 04:00:58 +0000453 // Let typedefs to char fall through to int, as %c is silly for uint8_t.
454 if (isa<TypedefType>(QT) && QT->isAnyCharacterType()) {
Ted Kremenek92a6feb2010-07-20 20:03:49 +0000455 CS.setKind(ConversionSpecifier::cArg);
Ted Kremenek4d8ae4d2010-10-21 04:00:58 +0000456 LM.setKind(LengthModifier::None);
Tom Care3bfc5f42010-06-09 04:11:11 +0000457 Precision.setHowSpecified(OptionalAmount::NotSpecified);
458 HasAlternativeForm = 0;
459 HasLeadingZeroes = 0;
Tom Caree4ee9662010-06-17 19:00:27 +0000460 HasPlusPrefix = 0;
Tom Care3bfc5f42010-06-09 04:11:11 +0000461 }
462 // Test for Floating type first as LongDouble can pass isUnsignedIntegerType
Douglas Gregor0c293ea2010-06-22 23:07:26 +0000463 else if (QT->isRealFloatingType()) {
Tom Care3bfc5f42010-06-09 04:11:11 +0000464 CS.setKind(ConversionSpecifier::fArg);
465 }
Tom Care3bfc5f42010-06-09 04:11:11 +0000466 else if (QT->isSignedIntegerType()) {
467 CS.setKind(ConversionSpecifier::dArg);
468 HasAlternativeForm = 0;
469 }
Douglas Gregorc8c4b402010-06-09 05:25:34 +0000470 else if (QT->isUnsignedIntegerType()) {
Ted Kremenek1e713f52011-04-25 22:32:59 +0000471 // Preserve the original formatting, e.g. 'X', 'o'.
472 if (!cast<PrintfConversionSpecifier>(CS).isUIntArg())
473 CS.setKind(ConversionSpecifier::uArg);
Tom Care3bfc5f42010-06-09 04:11:11 +0000474 HasAlternativeForm = 0;
Tom Caree4ee9662010-06-17 19:00:27 +0000475 HasPlusPrefix = 0;
Chad Rosier30601782011-08-17 23:08:45 +0000476 } else {
David Blaikieb219cfc2011-09-23 05:06:16 +0000477 llvm_unreachable("Unexpected type");
Tom Care3bfc5f42010-06-09 04:11:11 +0000478 }
479
480 return true;
481}
482
Chris Lattner5f9e2722011-07-23 10:55:15 +0000483void PrintfSpecifier::toString(raw_ostream &os) const {
Tom Care3bfc5f42010-06-09 04:11:11 +0000484 // Whilst some features have no defined order, we are using the order
NAKAMURA Takumi00995302011-01-27 07:09:49 +0000485 // appearing in the C99 standard (ISO/IEC 9899:1999 (E) 7.19.6.1)
Tom Care3bfc5f42010-06-09 04:11:11 +0000486 os << "%";
487
488 // Positional args
489 if (usesPositionalArg()) {
490 os << getPositionalArgIndex() << "$";
491 }
492
493 // Conversion flags
494 if (IsLeftJustified) os << "-";
495 if (HasPlusPrefix) os << "+";
496 if (HasSpacePrefix) os << " ";
497 if (HasAlternativeForm) os << "#";
498 if (HasLeadingZeroes) os << "0";
499
500 // Minimum field width
501 FieldWidth.toString(os);
502 // Precision
503 Precision.toString(os);
504 // Length modifier
505 os << LM.toString();
506 // Conversion specifier
507 os << CS.toString();
508}
Tom Caree4ee9662010-06-17 19:00:27 +0000509
Ted Kremenek826a3452010-07-16 02:11:22 +0000510bool PrintfSpecifier::hasValidPlusPrefix() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000511 if (!HasPlusPrefix)
512 return true;
513
514 // The plus prefix only makes sense for signed conversions
515 switch (CS.getKind()) {
516 case ConversionSpecifier::dArg:
517 case ConversionSpecifier::iArg:
518 case ConversionSpecifier::fArg:
519 case ConversionSpecifier::FArg:
520 case ConversionSpecifier::eArg:
521 case ConversionSpecifier::EArg:
522 case ConversionSpecifier::gArg:
523 case ConversionSpecifier::GArg:
524 case ConversionSpecifier::aArg:
525 case ConversionSpecifier::AArg:
526 return true;
527
528 default:
529 return false;
530 }
531}
532
Ted Kremenek826a3452010-07-16 02:11:22 +0000533bool PrintfSpecifier::hasValidAlternativeForm() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000534 if (!HasAlternativeForm)
535 return true;
536
Anders Carlsson2e6c19a2010-11-21 18:34:21 +0000537 // Alternate form flag only valid with the oxXaAeEfFgG conversions
Tom Caree4ee9662010-06-17 19:00:27 +0000538 switch (CS.getKind()) {
539 case ConversionSpecifier::oArg:
540 case ConversionSpecifier::xArg:
Anders Carlsson2e6c19a2010-11-21 18:34:21 +0000541 case ConversionSpecifier::XArg:
Tom Caree4ee9662010-06-17 19:00:27 +0000542 case ConversionSpecifier::aArg:
543 case ConversionSpecifier::AArg:
544 case ConversionSpecifier::eArg:
545 case ConversionSpecifier::EArg:
546 case ConversionSpecifier::fArg:
547 case ConversionSpecifier::FArg:
548 case ConversionSpecifier::gArg:
549 case ConversionSpecifier::GArg:
550 return true;
551
552 default:
553 return false;
554 }
555}
556
Ted Kremenek826a3452010-07-16 02:11:22 +0000557bool PrintfSpecifier::hasValidLeadingZeros() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000558 if (!HasLeadingZeroes)
559 return true;
560
561 // Leading zeroes flag only valid with the diouxXaAeEfFgG conversions
562 switch (CS.getKind()) {
563 case ConversionSpecifier::dArg:
564 case ConversionSpecifier::iArg:
565 case ConversionSpecifier::oArg:
566 case ConversionSpecifier::uArg:
567 case ConversionSpecifier::xArg:
568 case ConversionSpecifier::XArg:
569 case ConversionSpecifier::aArg:
570 case ConversionSpecifier::AArg:
571 case ConversionSpecifier::eArg:
572 case ConversionSpecifier::EArg:
573 case ConversionSpecifier::fArg:
574 case ConversionSpecifier::FArg:
575 case ConversionSpecifier::gArg:
576 case ConversionSpecifier::GArg:
577 return true;
578
579 default:
580 return false;
581 }
582}
583
Ted Kremenek826a3452010-07-16 02:11:22 +0000584bool PrintfSpecifier::hasValidSpacePrefix() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000585 if (!HasSpacePrefix)
586 return true;
587
588 // The space prefix only makes sense for signed conversions
589 switch (CS.getKind()) {
590 case ConversionSpecifier::dArg:
591 case ConversionSpecifier::iArg:
592 case ConversionSpecifier::fArg:
593 case ConversionSpecifier::FArg:
594 case ConversionSpecifier::eArg:
595 case ConversionSpecifier::EArg:
596 case ConversionSpecifier::gArg:
597 case ConversionSpecifier::GArg:
598 case ConversionSpecifier::aArg:
599 case ConversionSpecifier::AArg:
600 return true;
601
602 default:
603 return false;
604 }
605}
606
Ted Kremenek826a3452010-07-16 02:11:22 +0000607bool PrintfSpecifier::hasValidLeftJustified() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000608 if (!IsLeftJustified)
609 return true;
610
611 // The left justified flag is valid for all conversions except n
612 switch (CS.getKind()) {
Ted Kremenek35d353b2010-07-20 20:04:10 +0000613 case ConversionSpecifier::nArg:
Tom Caree4ee9662010-06-17 19:00:27 +0000614 return false;
615
616 default:
617 return true;
618 }
619}
620
Ted Kremenek65197b42011-01-08 05:28:46 +0000621bool PrintfSpecifier::hasValidThousandsGroupingPrefix() const {
622 if (!HasThousandsGrouping)
623 return true;
NAKAMURA Takumidfbb02a2011-01-27 07:10:08 +0000624
Ted Kremenek65197b42011-01-08 05:28:46 +0000625 switch (CS.getKind()) {
626 case ConversionSpecifier::dArg:
627 case ConversionSpecifier::iArg:
628 case ConversionSpecifier::uArg:
629 case ConversionSpecifier::fArg:
630 case ConversionSpecifier::FArg:
631 case ConversionSpecifier::gArg:
632 case ConversionSpecifier::GArg:
633 return true;
634 default:
635 return false;
636 }
637}
638
Ted Kremenek826a3452010-07-16 02:11:22 +0000639bool PrintfSpecifier::hasValidPrecision() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000640 if (Precision.getHowSpecified() == OptionalAmount::NotSpecified)
641 return true;
642
643 // Precision is only valid with the diouxXaAeEfFgGs conversions
644 switch (CS.getKind()) {
645 case ConversionSpecifier::dArg:
646 case ConversionSpecifier::iArg:
647 case ConversionSpecifier::oArg:
648 case ConversionSpecifier::uArg:
649 case ConversionSpecifier::xArg:
650 case ConversionSpecifier::XArg:
651 case ConversionSpecifier::aArg:
652 case ConversionSpecifier::AArg:
653 case ConversionSpecifier::eArg:
654 case ConversionSpecifier::EArg:
655 case ConversionSpecifier::fArg:
656 case ConversionSpecifier::FArg:
657 case ConversionSpecifier::gArg:
658 case ConversionSpecifier::GArg:
Ted Kremenek99196b12010-07-20 20:03:58 +0000659 case ConversionSpecifier::sArg:
Tom Caree4ee9662010-06-17 19:00:27 +0000660 return true;
661
662 default:
663 return false;
664 }
665}
Ted Kremenek826a3452010-07-16 02:11:22 +0000666bool PrintfSpecifier::hasValidFieldWidth() const {
Tom Caree4ee9662010-06-17 19:00:27 +0000667 if (FieldWidth.getHowSpecified() == OptionalAmount::NotSpecified)
668 return true;
669
670 // The field width is valid for all conversions except n
671 switch (CS.getKind()) {
Ted Kremenek35d353b2010-07-20 20:04:10 +0000672 case ConversionSpecifier::nArg:
Tom Caree4ee9662010-06-17 19:00:27 +0000673 return false;
674
675 default:
676 return true;
677 }
678}