PrintfFormatString.cpp revision 808015a18bd97781ce437831a95a92fdfc8d5136 
1//= PrintfFormatStrings.cpp - Analysis of printf 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// 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
15#include "clang/Analysis/Analyses/PrintfFormatString.h"
16
17using clang::analyze_printf::FormatSpecifier;
18using clang::analyze_printf::OptionalAmount;
19using namespace clang;
20
21namespace {
22class FormatSpecifierResult {
23  FormatSpecifier FS;
24  const char *Start;
25  bool Stop;
26public:
27  FormatSpecifierResult(bool stop = false)
28    : Start(0), Stop(stop) {}
29  FormatSpecifierResult(const char *start,
30                        const FormatSpecifier &fs)
31    : FS(fs), Start(start), Stop(false) {}
32
33
34  const char *getStart() const { return Start; }
35  bool shouldStop() const { return Stop; }
36  bool hasValue() const { return Start != 0; }
37  const FormatSpecifier &getValue() const {
38    assert(hasValue());
39    return FS;
40  }
41  const FormatSpecifier &getValue() { return FS; }
42};
43} // end anonymous namespace
44
45template <typename T>
46class UpdateOnReturn {
47  T &ValueToUpdate;
48  const T &ValueToCopy;
49public:
50  UpdateOnReturn(T &valueToUpdate, const T &valueToCopy)
51    : ValueToUpdate(valueToUpdate), ValueToCopy(valueToCopy) {}
52
53  ~UpdateOnReturn() {
54    ValueToUpdate = ValueToCopy;
55  }
56};
57
58static OptionalAmount ParseAmount(const char *&Beg, const char *E) {
59  const char *I = Beg;
60  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
61
62  bool foundDigits = false;
63  unsigned accumulator = 0;
64
65  for ( ; I != E; ++I) {
66    char c = *I;
67    if (c >= '0' && c <= '9') {
68      foundDigits = true;
69      accumulator += (accumulator * 10) + (c - '0');
70      continue;
71    }
72
73    if (foundDigits)
74      return OptionalAmount(accumulator, Beg);
75
76    if (c == '*') {
77      ++I;
78      return OptionalAmount(OptionalAmount::Arg, Beg);
79    }
80
81    break;
82  }
83
84  return OptionalAmount();
85}
86
87static FormatSpecifierResult ParseFormatSpecifier(FormatStringHandler &H,
88                                                  const char *&Beg, const char *E) {
89
90  using namespace clang::analyze_printf;
91
92  const char *I = Beg;
93  const char *Start = 0;
94  UpdateOnReturn <const char*> UpdateBeg(Beg, I);
95
96  // Look for a '%' character that indicates the start of a format specifier.
97  for ( ; I != E ; ++I) {
98    char c = *I;
99    if (c == '\0') {
100      // Detect spurious null characters, which are likely errors.
101      H.HandleNullChar(I);
102      return true;
103    }
104    if (c == '%') {
105      Start = I++;  // Record the start of the format specifier.
106      break;
107    }
108  }
109
110  // No format specifier found?
111  if (!Start)
112    return false;
113
114  if (I == E) {
115    // No more characters left?
116    H.HandleIncompleteFormatSpecifier(Start, E - Start);
117    return true;
118  }
119
120  FormatSpecifier FS;
121
122  // Look for flags (if any).
123  bool hasMore = true;
124  for ( ; I != E; ++I) {
125    switch (*I) {
126      default: hasMore = false; break;
127      case '-': FS.setIsLeftJustified(); break;
128      case '+': FS.setHasPlusPrefix(); break;
129      case ' ': FS.setHasSpacePrefix(); break;
130      case '#': FS.setHasAlternativeForm(); break;
131      case '0': FS.setHasLeadingZeros(); break;
132    }
133    if (!hasMore)
134      break;
135  }
136
137  if (I == E) {
138    // No more characters left?
139    H.HandleIncompleteFormatSpecifier(Start, E - Start);
140    return true;
141  }
142
143  // Look for the field width (if any).
144  FS.setFieldWidth(ParseAmount(I, E));
145
146  if (I == E) {
147    // No more characters left?
148    H.HandleIncompleteFormatSpecifier(Start, E - Start);
149    return true;
150  }
151
152  // Look for the precision (if any).
153  if (*I == '.') {
154    ++I;
155    if (I == E) {
156      H.HandleIncompleteFormatSpecifier(Start, E - Start);
157      return true;
158    }
159
160    FS.setPrecision(ParseAmount(I, E));
161
162    if (I == E) {
163      // No more characters left?
164      H.HandleIncompleteFormatSpecifier(Start, E - Start);
165      return true;
166    }
167  }
168
169  // Look for the length modifier.
170  LengthModifier lm = None;
171  switch (*I) {
172    default:
173      break;
174    case 'h':
175      ++I;
176      lm = (I != E && *I == 'h') ? ++I, AsChar : AsShort;
177      break;
178    case 'l':
179      ++I;
180      lm = (I != E && *I == 'l') ? ++I, AsLongLong : AsLong;
181      break;
182    case 'j': lm = AsIntMax;     ++I; break;
183    case 'z': lm = AsSizeT;      ++I; break;
184    case 't': lm = AsPtrDiff;    ++I; break;
185    case 'L': lm = AsLongDouble; ++I; break;
186  }
187  FS.setLengthModifier(lm);
188
189  if (I == E) {
190    // No more characters left?
191    H.HandleIncompleteFormatSpecifier(Start, E - Start);
192    return true;
193  }
194
195  // Finally, look for the conversion specifier.
196  const char *conversionPosition = I++;
197  ConversionSpecifier::Kind k = ConversionSpecifier::InvalidSpecifier;
198  switch (*conversionPosition) {
199    default:
200      break;
201    // C99: 7.19.6.1 (section 8).
202    case 'd': k = ConversionSpecifier::dArg; break;
203    case 'i': k = ConversionSpecifier::iArg; break;
204    case 'o': k = ConversionSpecifier::oArg; break;
205    case 'u': k = ConversionSpecifier::uArg; break;
206    case 'x': k = ConversionSpecifier::xArg; break;
207    case 'X': k = ConversionSpecifier::XArg; break;
208    case 'f': k = ConversionSpecifier::fArg; break;
209    case 'F': k = ConversionSpecifier::FArg; break;
210    case 'e': k = ConversionSpecifier::eArg; break;
211    case 'E': k = ConversionSpecifier::EArg; break;
212    case 'g': k = ConversionSpecifier::gArg; break;
213    case 'G': k = ConversionSpecifier::GArg; break;
214    case 'a': k = ConversionSpecifier::aArg; break;
215    case 'A': k = ConversionSpecifier::AArg; break;
216    case 'c': k = ConversionSpecifier::IntAsCharArg; break;
217    case 's': k = ConversionSpecifier::CStrArg;      break;
218    case 'p': k = ConversionSpecifier::VoidPtrArg;   break;
219    case 'n': k = ConversionSpecifier::OutIntPtrArg; break;
220    case '%': k = ConversionSpecifier::PercentArg;   break;
221    // Objective-C.
222    case '@': k = ConversionSpecifier::ObjCObjArg; break;
223  }
224  FS.setConversionSpecifier(ConversionSpecifier(conversionPosition, k));
225
226  if (k == ConversionSpecifier::InvalidSpecifier) {
227    H.HandleInvalidConversionSpecifier(FS, Beg, I - Beg);
228    return false; // Keep processing format specifiers.
229  }
230  return FormatSpecifierResult(Start, FS);
231}
232
233bool clang::ParseFormatString(FormatStringHandler &H,
234                       const char *I, const char *E) {
235  // Keep looking for a format specifier until we have exhausted the string.
236  while (I != E) {
237    const FormatSpecifierResult &FSR = ParseFormatSpecifier(H, I, E);
238    // Did a fail-stop error of any kind occur when parsing the specifier?
239    // If so, don't do any more processing.
240    if (FSR.shouldStop())
241      return true;;
242    // Did we exhaust the string or encounter an error that
243    // we can recover from?
244    if (!FSR.hasValue())
245      continue;
246    // We have a format specifier.  Pass it to the callback.
247    if (!H.HandleFormatSpecifier(FSR.getValue(), FSR.getStart(),
248                                 I - FSR.getStart()))
249      return false;
250  }
251  assert(I == E && "Format string not exhausted");
252  return false;
253}
254
255FormatStringHandler::~FormatStringHandler() {}
256