blob: 547bd4e0c84ea55bc38b3b4ee76ad54d8f3cb4a4 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- LiteralSupport.cpp - Code to parse and process literals ----------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the NumericLiteralParser, CharLiteralParser, and
11// StringLiteralParser interfaces.
12//
13//===----------------------------------------------------------------------===//
14
15#include "clang/Lex/LiteralSupport.h"
16#include "clang/Lex/Preprocessor.h"
Chris Lattner500d3292009-01-29 05:15:15 +000017#include "clang/Lex/LexDiagnostic.h"
Chris Lattner136f93a2007-07-16 06:55:01 +000018#include "clang/Basic/TargetInfo.h"
Eli Friedmanf74a4582011-11-01 02:14:50 +000019#include "clang/Basic/ConvertUTF.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000020#include "llvm/ADT/StringExtras.h"
David Blaikie9fe8c742011-09-23 05:35:21 +000021#include "llvm/Support/ErrorHandling.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022using namespace clang;
23
24/// HexDigitValue - Return the value of the specified hex digit, or -1 if it's
25/// not valid.
26static int HexDigitValue(char C) {
27 if (C >= '0' && C <= '9') return C-'0';
28 if (C >= 'a' && C <= 'f') return C-'a'+10;
29 if (C >= 'A' && C <= 'F') return C-'A'+10;
30 return -1;
31}
32
Douglas Gregor5cee1192011-07-27 05:40:30 +000033static unsigned getCharWidth(tok::TokenKind kind, const TargetInfo &Target) {
34 switch (kind) {
David Blaikieb219cfc2011-09-23 05:06:16 +000035 default: llvm_unreachable("Unknown token type!");
Douglas Gregor5cee1192011-07-27 05:40:30 +000036 case tok::char_constant:
37 case tok::string_literal:
38 case tok::utf8_string_literal:
39 return Target.getCharWidth();
40 case tok::wide_char_constant:
41 case tok::wide_string_literal:
42 return Target.getWCharWidth();
43 case tok::utf16_char_constant:
44 case tok::utf16_string_literal:
45 return Target.getChar16Width();
46 case tok::utf32_char_constant:
47 case tok::utf32_string_literal:
48 return Target.getChar32Width();
49 }
50}
51
Reid Spencer5f016e22007-07-11 17:01:13 +000052/// ProcessCharEscape - Parse a standard C escape sequence, which can occur in
53/// either a character or a string literal.
54static unsigned ProcessCharEscape(const char *&ThisTokBuf,
55 const char *ThisTokEnd, bool &HadError,
Douglas Gregor5cee1192011-07-27 05:40:30 +000056 FullSourceLoc Loc, unsigned CharWidth,
David Blaikied6471f72011-09-25 23:23:43 +000057 DiagnosticsEngine *Diags) {
Reid Spencer5f016e22007-07-11 17:01:13 +000058 // Skip the '\' char.
59 ++ThisTokBuf;
60
61 // We know that this character can't be off the end of the buffer, because
62 // that would have been \", which would not have been the end of string.
63 unsigned ResultChar = *ThisTokBuf++;
64 switch (ResultChar) {
65 // These map to themselves.
66 case '\\': case '\'': case '"': case '?': break;
Mike Stump1eb44332009-09-09 15:08:12 +000067
Reid Spencer5f016e22007-07-11 17:01:13 +000068 // These have fixed mappings.
69 case 'a':
70 // TODO: K&R: the meaning of '\\a' is different in traditional C
71 ResultChar = 7;
72 break;
73 case 'b':
74 ResultChar = 8;
75 break;
76 case 'e':
Chris Lattner91f54ce2010-11-17 06:26:08 +000077 if (Diags)
78 Diags->Report(Loc, diag::ext_nonstandard_escape) << "e";
Reid Spencer5f016e22007-07-11 17:01:13 +000079 ResultChar = 27;
80 break;
Eli Friedman3c548012009-06-10 01:32:39 +000081 case 'E':
Chris Lattner91f54ce2010-11-17 06:26:08 +000082 if (Diags)
83 Diags->Report(Loc, diag::ext_nonstandard_escape) << "E";
Eli Friedman3c548012009-06-10 01:32:39 +000084 ResultChar = 27;
85 break;
Reid Spencer5f016e22007-07-11 17:01:13 +000086 case 'f':
87 ResultChar = 12;
88 break;
89 case 'n':
90 ResultChar = 10;
91 break;
92 case 'r':
93 ResultChar = 13;
94 break;
95 case 't':
96 ResultChar = 9;
97 break;
98 case 'v':
99 ResultChar = 11;
100 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000101 case 'x': { // Hex escape.
102 ResultChar = 0;
103 if (ThisTokBuf == ThisTokEnd || !isxdigit(*ThisTokBuf)) {
Chris Lattner91f54ce2010-11-17 06:26:08 +0000104 if (Diags)
105 Diags->Report(Loc, diag::err_hex_escape_no_digits);
Reid Spencer5f016e22007-07-11 17:01:13 +0000106 HadError = 1;
107 break;
108 }
Mike Stump1eb44332009-09-09 15:08:12 +0000109
Reid Spencer5f016e22007-07-11 17:01:13 +0000110 // Hex escapes are a maximal series of hex digits.
111 bool Overflow = false;
112 for (; ThisTokBuf != ThisTokEnd; ++ThisTokBuf) {
113 int CharVal = HexDigitValue(ThisTokBuf[0]);
114 if (CharVal == -1) break;
Chris Lattnerc29bbde2008-09-30 20:45:40 +0000115 // About to shift out a digit?
116 Overflow |= (ResultChar & 0xF0000000) ? true : false;
Reid Spencer5f016e22007-07-11 17:01:13 +0000117 ResultChar <<= 4;
118 ResultChar |= CharVal;
119 }
120
121 // See if any bits will be truncated when evaluated as a character.
Reid Spencer5f016e22007-07-11 17:01:13 +0000122 if (CharWidth != 32 && (ResultChar >> CharWidth) != 0) {
123 Overflow = true;
124 ResultChar &= ~0U >> (32-CharWidth);
125 }
Mike Stump1eb44332009-09-09 15:08:12 +0000126
Reid Spencer5f016e22007-07-11 17:01:13 +0000127 // Check for overflow.
Chris Lattner91f54ce2010-11-17 06:26:08 +0000128 if (Overflow && Diags) // Too many digits to fit in
129 Diags->Report(Loc, diag::warn_hex_escape_too_large);
Reid Spencer5f016e22007-07-11 17:01:13 +0000130 break;
131 }
132 case '0': case '1': case '2': case '3':
133 case '4': case '5': case '6': case '7': {
134 // Octal escapes.
135 --ThisTokBuf;
136 ResultChar = 0;
137
138 // Octal escapes are a series of octal digits with maximum length 3.
139 // "\0123" is a two digit sequence equal to "\012" "3".
140 unsigned NumDigits = 0;
141 do {
142 ResultChar <<= 3;
143 ResultChar |= *ThisTokBuf++ - '0';
144 ++NumDigits;
145 } while (ThisTokBuf != ThisTokEnd && NumDigits < 3 &&
146 ThisTokBuf[0] >= '0' && ThisTokBuf[0] <= '7');
Mike Stump1eb44332009-09-09 15:08:12 +0000147
Reid Spencer5f016e22007-07-11 17:01:13 +0000148 // Check for overflow. Reject '\777', but not L'\777'.
Reid Spencer5f016e22007-07-11 17:01:13 +0000149 if (CharWidth != 32 && (ResultChar >> CharWidth) != 0) {
Chris Lattner91f54ce2010-11-17 06:26:08 +0000150 if (Diags)
151 Diags->Report(Loc, diag::warn_octal_escape_too_large);
Reid Spencer5f016e22007-07-11 17:01:13 +0000152 ResultChar &= ~0U >> (32-CharWidth);
153 }
154 break;
155 }
Mike Stump1eb44332009-09-09 15:08:12 +0000156
Reid Spencer5f016e22007-07-11 17:01:13 +0000157 // Otherwise, these are not valid escapes.
158 case '(': case '{': case '[': case '%':
159 // GCC accepts these as extensions. We warn about them as such though.
Chris Lattner91f54ce2010-11-17 06:26:08 +0000160 if (Diags)
161 Diags->Report(Loc, diag::ext_nonstandard_escape)
Douglas Gregorb90f4b32010-05-26 05:35:51 +0000162 << std::string()+(char)ResultChar;
Eli Friedmanf01fdff2009-04-28 00:51:18 +0000163 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000164 default:
Chris Lattner91f54ce2010-11-17 06:26:08 +0000165 if (Diags == 0)
Douglas Gregorb90f4b32010-05-26 05:35:51 +0000166 break;
167
Ted Kremenek23ef69d2010-12-03 00:09:56 +0000168 if (isgraph(ResultChar))
Chris Lattner91f54ce2010-11-17 06:26:08 +0000169 Diags->Report(Loc, diag::ext_unknown_escape)
170 << std::string()+(char)ResultChar;
Chris Lattnerac92d822008-11-22 07:23:31 +0000171 else
Chris Lattner91f54ce2010-11-17 06:26:08 +0000172 Diags->Report(Loc, diag::ext_unknown_escape)
173 << "x"+llvm::utohexstr(ResultChar);
Reid Spencer5f016e22007-07-11 17:01:13 +0000174 break;
175 }
Mike Stump1eb44332009-09-09 15:08:12 +0000176
Reid Spencer5f016e22007-07-11 17:01:13 +0000177 return ResultChar;
178}
179
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000180/// ProcessUCNEscape - Read the Universal Character Name, check constraints and
Nico Weber59705ae2010-10-09 00:27:47 +0000181/// return the UTF32.
182static bool ProcessUCNEscape(const char *&ThisTokBuf, const char *ThisTokEnd,
183 uint32_t &UcnVal, unsigned short &UcnLen,
David Blaikied6471f72011-09-25 23:23:43 +0000184 FullSourceLoc Loc, DiagnosticsEngine *Diags,
Seth Cantrellbe773522012-01-18 12:27:04 +0000185 const LangOptions &Features,
186 bool in_char_string_literal = false) {
Chris Lattner6c66f072010-11-17 06:46:14 +0000187 if (!Features.CPlusPlus && !Features.C99 && Diags)
Chris Lattner872a45e2010-11-17 06:55:10 +0000188 Diags->Report(Loc, diag::warn_ucn_not_valid_in_c89);
Mike Stump1eb44332009-09-09 15:08:12 +0000189
Steve Naroff4e93b342009-04-01 11:09:15 +0000190 // Save the beginning of the string (for error diagnostics).
191 const char *ThisTokBegin = ThisTokBuf;
Mike Stump1eb44332009-09-09 15:08:12 +0000192
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000193 // Skip the '\u' char's.
194 ThisTokBuf += 2;
Reid Spencer5f016e22007-07-11 17:01:13 +0000195
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000196 if (ThisTokBuf == ThisTokEnd || !isxdigit(*ThisTokBuf)) {
Chris Lattner6c66f072010-11-17 06:46:14 +0000197 if (Diags)
Chris Lattner872a45e2010-11-17 06:55:10 +0000198 Diags->Report(Loc, diag::err_ucn_escape_no_digits);
Nico Weber59705ae2010-10-09 00:27:47 +0000199 return false;
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000200 }
Nico Weber59705ae2010-10-09 00:27:47 +0000201 UcnLen = (ThisTokBuf[-1] == 'u' ? 4 : 8);
Fariborz Jahanian56bedef2010-08-31 23:34:27 +0000202 unsigned short UcnLenSave = UcnLen;
Nico Weber59705ae2010-10-09 00:27:47 +0000203 for (; ThisTokBuf != ThisTokEnd && UcnLenSave; ++ThisTokBuf, UcnLenSave--) {
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000204 int CharVal = HexDigitValue(ThisTokBuf[0]);
205 if (CharVal == -1) break;
206 UcnVal <<= 4;
207 UcnVal |= CharVal;
208 }
209 // If we didn't consume the proper number of digits, there is a problem.
Nico Weber59705ae2010-10-09 00:27:47 +0000210 if (UcnLenSave) {
Chris Lattner872a45e2010-11-17 06:55:10 +0000211 if (Diags) {
Chris Lattner7ef5c272010-11-17 07:05:50 +0000212 SourceLocation L =
213 Lexer::AdvanceToTokenCharacter(Loc, ThisTokBuf-ThisTokBegin,
214 Loc.getManager(), Features);
215 Diags->Report(FullSourceLoc(L, Loc.getManager()),
216 diag::err_ucn_escape_incomplete);
Chris Lattner872a45e2010-11-17 06:55:10 +0000217 }
Nico Weber59705ae2010-10-09 00:27:47 +0000218 return false;
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000219 }
Seth Cantrellbe773522012-01-18 12:27:04 +0000220 // Check UCN constraints (C99 6.4.3p2) [C++11 lex.charset p2]
221 bool invalid_ucn = (0xD800<=UcnVal && UcnVal<=0xDFFF) // surrogate codepoints
222 || 0x10FFFF < UcnVal; // maximum legal UTF32 value
223
224 // C++11 allows UCNs that refer to control characters and basic source
225 // characters inside character and string literals
226 if (!Features.CPlusPlus0x || !in_char_string_literal) {
227 if ((UcnVal < 0xa0 &&
228 (UcnVal != 0x24 && UcnVal != 0x40 && UcnVal != 0x60 ))) { // $, @, `
229 invalid_ucn = true;
230 }
231 }
232
233 if (invalid_ucn) {
Chris Lattner6c66f072010-11-17 06:46:14 +0000234 if (Diags)
Chris Lattner872a45e2010-11-17 06:55:10 +0000235 Diags->Report(Loc, diag::err_ucn_escape_invalid);
Nico Weber59705ae2010-10-09 00:27:47 +0000236 return false;
237 }
238 return true;
239}
240
241/// EncodeUCNEscape - Read the Universal Character Name, check constraints and
242/// convert the UTF32 to UTF8 or UTF16. This is a subroutine of
243/// StringLiteralParser. When we decide to implement UCN's for identifiers,
244/// we will likely rework our support for UCN's.
245static void EncodeUCNEscape(const char *&ThisTokBuf, const char *ThisTokEnd,
Chris Lattnera95880d2010-11-17 07:12:42 +0000246 char *&ResultBuf, bool &HadError,
Douglas Gregor5cee1192011-07-27 05:40:30 +0000247 FullSourceLoc Loc, unsigned CharByteWidth,
David Blaikied6471f72011-09-25 23:23:43 +0000248 DiagnosticsEngine *Diags,
249 const LangOptions &Features) {
Nico Weber59705ae2010-10-09 00:27:47 +0000250 typedef uint32_t UTF32;
251 UTF32 UcnVal = 0;
252 unsigned short UcnLen = 0;
Chris Lattnera95880d2010-11-17 07:12:42 +0000253 if (!ProcessUCNEscape(ThisTokBuf, ThisTokEnd, UcnVal, UcnLen, Loc, Diags,
254 Features)) {
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000255 HadError = 1;
256 return;
257 }
Nico Weber59705ae2010-10-09 00:27:47 +0000258
Douglas Gregor5cee1192011-07-27 05:40:30 +0000259 assert((CharByteWidth == 1 || CharByteWidth == 2 || CharByteWidth) &&
260 "only character widths of 1, 2, or 4 bytes supported");
Nico Webera0f15b02010-10-06 04:57:26 +0000261
Douglas Gregor5cee1192011-07-27 05:40:30 +0000262 (void)UcnLen;
263 assert((UcnLen== 4 || UcnLen== 8) && "only ucn length of 4 or 8 supported");
Nico Webera0f15b02010-10-06 04:57:26 +0000264
Douglas Gregor5cee1192011-07-27 05:40:30 +0000265 if (CharByteWidth == 4) {
Eli Friedmancaf1f262011-11-02 23:06:23 +0000266 // FIXME: Make the type of the result buffer correct instead of
267 // using reinterpret_cast.
268 UTF32 *ResultPtr = reinterpret_cast<UTF32*>(ResultBuf);
269 *ResultPtr = UcnVal;
270 ResultBuf += 4;
Douglas Gregor5cee1192011-07-27 05:40:30 +0000271 return;
272 }
273
274 if (CharByteWidth == 2) {
Eli Friedmancaf1f262011-11-02 23:06:23 +0000275 // FIXME: Make the type of the result buffer correct instead of
276 // using reinterpret_cast.
277 UTF16 *ResultPtr = reinterpret_cast<UTF16*>(ResultBuf);
278
Nico Webera0f15b02010-10-06 04:57:26 +0000279 if (UcnVal < (UTF32)0xFFFF) {
Eli Friedmancaf1f262011-11-02 23:06:23 +0000280 *ResultPtr = UcnVal;
281 ResultBuf += 2;
Nico Webera0f15b02010-10-06 04:57:26 +0000282 return;
283 }
Nico Webera0f15b02010-10-06 04:57:26 +0000284
Eli Friedmancaf1f262011-11-02 23:06:23 +0000285 // Convert to UTF16.
Nico Webera0f15b02010-10-06 04:57:26 +0000286 UcnVal -= 0x10000;
Eli Friedmancaf1f262011-11-02 23:06:23 +0000287 *ResultPtr = 0xD800 + (UcnVal >> 10);
288 *(ResultPtr+1) = 0xDC00 + (UcnVal & 0x3FF);
289 ResultBuf += 4;
Fariborz Jahanian56bedef2010-08-31 23:34:27 +0000290 return;
291 }
Douglas Gregor5cee1192011-07-27 05:40:30 +0000292
293 assert(CharByteWidth == 1 && "UTF-8 encoding is only for 1 byte characters");
294
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000295 // Now that we've parsed/checked the UCN, we convert from UTF32->UTF8.
296 // The conversion below was inspired by:
297 // http://www.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
Mike Stump1eb44332009-09-09 15:08:12 +0000298 // First, we determine how many bytes the result will require.
Steve Naroff4e93b342009-04-01 11:09:15 +0000299 typedef uint8_t UTF8;
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000300
301 unsigned short bytesToWrite = 0;
302 if (UcnVal < (UTF32)0x80)
303 bytesToWrite = 1;
304 else if (UcnVal < (UTF32)0x800)
305 bytesToWrite = 2;
306 else if (UcnVal < (UTF32)0x10000)
307 bytesToWrite = 3;
308 else
309 bytesToWrite = 4;
Mike Stump1eb44332009-09-09 15:08:12 +0000310
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000311 const unsigned byteMask = 0xBF;
312 const unsigned byteMark = 0x80;
Mike Stump1eb44332009-09-09 15:08:12 +0000313
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000314 // Once the bits are split out into bytes of UTF8, this is a mask OR-ed
Steve Naroff8a5c0cd2009-03-31 10:29:45 +0000315 // into the first byte, depending on how many bytes follow.
Mike Stump1eb44332009-09-09 15:08:12 +0000316 static const UTF8 firstByteMark[5] = {
Steve Naroff8a5c0cd2009-03-31 10:29:45 +0000317 0x00, 0x00, 0xC0, 0xE0, 0xF0
Steve Naroff0e3e3eb2009-03-30 23:46:03 +0000318 };
319 // Finally, we write the bytes into ResultBuf.
320 ResultBuf += bytesToWrite;
321 switch (bytesToWrite) { // note: everything falls through.
322 case 4: *--ResultBuf = (UTF8)((UcnVal | byteMark) & byteMask); UcnVal >>= 6;
323 case 3: *--ResultBuf = (UTF8)((UcnVal | byteMark) & byteMask); UcnVal >>= 6;
324 case 2: *--ResultBuf = (UTF8)((UcnVal | byteMark) & byteMask); UcnVal >>= 6;
325 case 1: *--ResultBuf = (UTF8) (UcnVal | firstByteMark[bytesToWrite]);
326 }
327 // Update the buffer.
328 ResultBuf += bytesToWrite;
329}
Reid Spencer5f016e22007-07-11 17:01:13 +0000330
331
332/// integer-constant: [C99 6.4.4.1]
333/// decimal-constant integer-suffix
334/// octal-constant integer-suffix
335/// hexadecimal-constant integer-suffix
Mike Stump1eb44332009-09-09 15:08:12 +0000336/// decimal-constant:
Reid Spencer5f016e22007-07-11 17:01:13 +0000337/// nonzero-digit
338/// decimal-constant digit
Mike Stump1eb44332009-09-09 15:08:12 +0000339/// octal-constant:
Reid Spencer5f016e22007-07-11 17:01:13 +0000340/// 0
341/// octal-constant octal-digit
Mike Stump1eb44332009-09-09 15:08:12 +0000342/// hexadecimal-constant:
Reid Spencer5f016e22007-07-11 17:01:13 +0000343/// hexadecimal-prefix hexadecimal-digit
344/// hexadecimal-constant hexadecimal-digit
345/// hexadecimal-prefix: one of
346/// 0x 0X
347/// integer-suffix:
348/// unsigned-suffix [long-suffix]
349/// unsigned-suffix [long-long-suffix]
350/// long-suffix [unsigned-suffix]
351/// long-long-suffix [unsigned-sufix]
352/// nonzero-digit:
353/// 1 2 3 4 5 6 7 8 9
354/// octal-digit:
355/// 0 1 2 3 4 5 6 7
356/// hexadecimal-digit:
357/// 0 1 2 3 4 5 6 7 8 9
358/// a b c d e f
359/// A B C D E F
360/// unsigned-suffix: one of
361/// u U
362/// long-suffix: one of
363/// l L
Mike Stump1eb44332009-09-09 15:08:12 +0000364/// long-long-suffix: one of
Reid Spencer5f016e22007-07-11 17:01:13 +0000365/// ll LL
366///
367/// floating-constant: [C99 6.4.4.2]
368/// TODO: add rules...
369///
Reid Spencer5f016e22007-07-11 17:01:13 +0000370NumericLiteralParser::
371NumericLiteralParser(const char *begin, const char *end,
372 SourceLocation TokLoc, Preprocessor &pp)
373 : PP(pp), ThisTokBegin(begin), ThisTokEnd(end) {
Mike Stump1eb44332009-09-09 15:08:12 +0000374
Chris Lattnerc29bbde2008-09-30 20:45:40 +0000375 // This routine assumes that the range begin/end matches the regex for integer
376 // and FP constants (specifically, the 'pp-number' regex), and assumes that
377 // the byte at "*end" is both valid and not part of the regex. Because of
378 // this, it doesn't have to check for 'overscan' in various places.
379 assert(!isalnum(*end) && *end != '.' && *end != '_' &&
380 "Lexer didn't maximally munch?");
Mike Stump1eb44332009-09-09 15:08:12 +0000381
Reid Spencer5f016e22007-07-11 17:01:13 +0000382 s = DigitsBegin = begin;
383 saw_exponent = false;
384 saw_period = false;
Reid Spencer5f016e22007-07-11 17:01:13 +0000385 isLong = false;
386 isUnsigned = false;
387 isLongLong = false;
Chris Lattner6e400c22007-08-26 03:29:23 +0000388 isFloat = false;
Chris Lattner506b8de2007-08-26 01:58:14 +0000389 isImaginary = false;
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000390 isMicrosoftInteger = false;
Reid Spencer5f016e22007-07-11 17:01:13 +0000391 hadError = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000392
Reid Spencer5f016e22007-07-11 17:01:13 +0000393 if (*s == '0') { // parse radix
Chris Lattner368328c2008-06-30 06:39:54 +0000394 ParseNumberStartingWithZero(TokLoc);
395 if (hadError)
396 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000397 } else { // the first digit is non-zero
398 radix = 10;
399 s = SkipDigits(s);
400 if (s == ThisTokEnd) {
401 // Done.
Christopher Lamb016765e2007-11-29 06:06:27 +0000402 } else if (isxdigit(*s) && !(*s == 'e' || *s == 'E')) {
Chris Lattnerac92d822008-11-22 07:23:31 +0000403 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-begin),
Chris Lattner5f9e2722011-07-23 10:55:15 +0000404 diag::err_invalid_decimal_digit) << StringRef(s, 1);
Chris Lattnerac92d822008-11-22 07:23:31 +0000405 hadError = true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000406 return;
407 } else if (*s == '.') {
408 s++;
409 saw_period = true;
410 s = SkipDigits(s);
Mike Stump1eb44332009-09-09 15:08:12 +0000411 }
Chris Lattner4411f462008-09-29 23:12:31 +0000412 if ((*s == 'e' || *s == 'E')) { // exponent
Chris Lattner70f66ab2008-04-20 18:47:55 +0000413 const char *Exponent = s;
Reid Spencer5f016e22007-07-11 17:01:13 +0000414 s++;
415 saw_exponent = true;
416 if (*s == '+' || *s == '-') s++; // sign
417 const char *first_non_digit = SkipDigits(s);
Chris Lattner0b7f69d2008-04-20 18:41:46 +0000418 if (first_non_digit != s) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000419 s = first_non_digit;
Chris Lattner0b7f69d2008-04-20 18:41:46 +0000420 } else {
Chris Lattnerac92d822008-11-22 07:23:31 +0000421 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, Exponent-begin),
422 diag::err_exponent_has_no_digits);
423 hadError = true;
Chris Lattner0b7f69d2008-04-20 18:41:46 +0000424 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000425 }
426 }
427 }
428
429 SuffixBegin = s;
Mike Stump1eb44332009-09-09 15:08:12 +0000430
Chris Lattner506b8de2007-08-26 01:58:14 +0000431 // Parse the suffix. At this point we can classify whether we have an FP or
432 // integer constant.
433 bool isFPConstant = isFloatingLiteral();
Mike Stump1eb44332009-09-09 15:08:12 +0000434
Chris Lattner506b8de2007-08-26 01:58:14 +0000435 // Loop over all of the characters of the suffix. If we see something bad,
436 // we break out of the loop.
437 for (; s != ThisTokEnd; ++s) {
438 switch (*s) {
439 case 'f': // FP Suffix for "float"
440 case 'F':
441 if (!isFPConstant) break; // Error for integer constant.
Chris Lattner6e400c22007-08-26 03:29:23 +0000442 if (isFloat || isLong) break; // FF, LF invalid.
443 isFloat = true;
Chris Lattner506b8de2007-08-26 01:58:14 +0000444 continue; // Success.
445 case 'u':
446 case 'U':
447 if (isFPConstant) break; // Error for floating constant.
448 if (isUnsigned) break; // Cannot be repeated.
449 isUnsigned = true;
450 continue; // Success.
451 case 'l':
452 case 'L':
453 if (isLong || isLongLong) break; // Cannot be repeated.
Chris Lattner6e400c22007-08-26 03:29:23 +0000454 if (isFloat) break; // LF invalid.
Mike Stump1eb44332009-09-09 15:08:12 +0000455
Chris Lattner506b8de2007-08-26 01:58:14 +0000456 // Check for long long. The L's need to be adjacent and the same case.
457 if (s+1 != ThisTokEnd && s[1] == s[0]) {
458 if (isFPConstant) break; // long long invalid for floats.
459 isLongLong = true;
460 ++s; // Eat both of them.
461 } else {
Reid Spencer5f016e22007-07-11 17:01:13 +0000462 isLong = true;
Reid Spencer5f016e22007-07-11 17:01:13 +0000463 }
Chris Lattner506b8de2007-08-26 01:58:14 +0000464 continue; // Success.
465 case 'i':
Chris Lattnerc6374152010-10-14 00:24:10 +0000466 case 'I':
Francois Pichet62ec1f22011-09-17 17:15:52 +0000467 if (PP.getLangOptions().MicrosoftExt) {
Fariborz Jahaniana8be02b2010-01-22 21:36:53 +0000468 if (isFPConstant || isLong || isLongLong) break;
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000469
Steve Naroff0c29b222008-04-04 21:02:54 +0000470 // Allow i8, i16, i32, i64, and i128.
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000471 if (s + 1 != ThisTokEnd) {
472 switch (s[1]) {
473 case '8':
474 s += 2; // i8 suffix
475 isMicrosoftInteger = true;
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000476 break;
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000477 case '1':
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000478 if (s + 2 == ThisTokEnd) break;
Francois Pichetd062b602011-01-11 11:57:53 +0000479 if (s[2] == '6') {
480 s += 3; // i16 suffix
481 isMicrosoftInteger = true;
482 }
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000483 else if (s[2] == '2') {
484 if (s + 3 == ThisTokEnd) break;
Francois Pichetd062b602011-01-11 11:57:53 +0000485 if (s[3] == '8') {
486 s += 4; // i128 suffix
487 isMicrosoftInteger = true;
488 }
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000489 }
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000490 break;
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000491 case '3':
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000492 if (s + 2 == ThisTokEnd) break;
Francois Pichetd062b602011-01-11 11:57:53 +0000493 if (s[2] == '2') {
494 s += 3; // i32 suffix
495 isLong = true;
496 isMicrosoftInteger = true;
497 }
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000498 break;
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000499 case '6':
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000500 if (s + 2 == ThisTokEnd) break;
Francois Pichetd062b602011-01-11 11:57:53 +0000501 if (s[2] == '4') {
502 s += 3; // i64 suffix
503 isLongLong = true;
504 isMicrosoftInteger = true;
505 }
Nuno Lopes6e8c7ac2009-11-28 13:37:52 +0000506 break;
Mike Stumpb79fe2d2009-10-08 22:55:36 +0000507 default:
508 break;
509 }
510 break;
Steve Naroff0c29b222008-04-04 21:02:54 +0000511 }
Steve Naroff0c29b222008-04-04 21:02:54 +0000512 }
513 // fall through.
Chris Lattner506b8de2007-08-26 01:58:14 +0000514 case 'j':
515 case 'J':
516 if (isImaginary) break; // Cannot be repeated.
517 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-begin),
518 diag::ext_imaginary_constant);
519 isImaginary = true;
520 continue; // Success.
Reid Spencer5f016e22007-07-11 17:01:13 +0000521 }
Chris Lattner506b8de2007-08-26 01:58:14 +0000522 // If we reached here, there was an error.
523 break;
524 }
Mike Stump1eb44332009-09-09 15:08:12 +0000525
Chris Lattner506b8de2007-08-26 01:58:14 +0000526 // Report an error if there are any.
527 if (s != ThisTokEnd) {
Chris Lattnerac92d822008-11-22 07:23:31 +0000528 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-begin),
529 isFPConstant ? diag::err_invalid_suffix_float_constant :
530 diag::err_invalid_suffix_integer_constant)
Chris Lattner5f9e2722011-07-23 10:55:15 +0000531 << StringRef(SuffixBegin, ThisTokEnd-SuffixBegin);
Chris Lattnerac92d822008-11-22 07:23:31 +0000532 hadError = true;
Chris Lattner506b8de2007-08-26 01:58:14 +0000533 return;
Reid Spencer5f016e22007-07-11 17:01:13 +0000534 }
535}
536
Chris Lattner368328c2008-06-30 06:39:54 +0000537/// ParseNumberStartingWithZero - This method is called when the first character
538/// of the number is found to be a zero. This means it is either an octal
539/// number (like '04') or a hex number ('0x123a') a binary number ('0b1010') or
Mike Stump1eb44332009-09-09 15:08:12 +0000540/// a floating point number (01239.123e4). Eat the prefix, determining the
Chris Lattner368328c2008-06-30 06:39:54 +0000541/// radix etc.
542void NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {
543 assert(s[0] == '0' && "Invalid method call");
544 s++;
Mike Stump1eb44332009-09-09 15:08:12 +0000545
Chris Lattner368328c2008-06-30 06:39:54 +0000546 // Handle a hex number like 0x1234.
547 if ((*s == 'x' || *s == 'X') && (isxdigit(s[1]) || s[1] == '.')) {
548 s++;
549 radix = 16;
550 DigitsBegin = s;
551 s = SkipHexDigits(s);
Aaron Ballman66b0eba2012-02-08 13:36:33 +0000552 bool noSignificand = (s == DigitsBegin);
Chris Lattner368328c2008-06-30 06:39:54 +0000553 if (s == ThisTokEnd) {
554 // Done.
555 } else if (*s == '.') {
556 s++;
557 saw_period = true;
Aaron Ballman66b0eba2012-02-08 13:36:33 +0000558 const char *floatDigitsBegin = s;
Chris Lattner368328c2008-06-30 06:39:54 +0000559 s = SkipHexDigits(s);
Aaron Ballman66b0eba2012-02-08 13:36:33 +0000560 noSignificand &= (floatDigitsBegin == s);
Chris Lattner368328c2008-06-30 06:39:54 +0000561 }
Aaron Ballman66b0eba2012-02-08 13:36:33 +0000562
563 if (noSignificand) {
564 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-ThisTokBegin), \
565 diag::err_hexconstant_requires_digits);
566 hadError = true;
567 return;
568 }
569
Chris Lattner368328c2008-06-30 06:39:54 +0000570 // A binary exponent can appear with or with a '.'. If dotted, the
Mike Stump1eb44332009-09-09 15:08:12 +0000571 // binary exponent is required.
Douglas Gregor1155c422011-08-30 22:40:35 +0000572 if (*s == 'p' || *s == 'P') {
Chris Lattner368328c2008-06-30 06:39:54 +0000573 const char *Exponent = s;
574 s++;
575 saw_exponent = true;
576 if (*s == '+' || *s == '-') s++; // sign
577 const char *first_non_digit = SkipDigits(s);
Chris Lattner6ea62382008-07-25 18:18:34 +0000578 if (first_non_digit == s) {
Chris Lattnerac92d822008-11-22 07:23:31 +0000579 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, Exponent-ThisTokBegin),
580 diag::err_exponent_has_no_digits);
581 hadError = true;
Chris Lattner6ea62382008-07-25 18:18:34 +0000582 return;
Chris Lattner368328c2008-06-30 06:39:54 +0000583 }
Chris Lattner6ea62382008-07-25 18:18:34 +0000584 s = first_non_digit;
Mike Stump1eb44332009-09-09 15:08:12 +0000585
Douglas Gregor1155c422011-08-30 22:40:35 +0000586 if (!PP.getLangOptions().HexFloats)
Chris Lattnerac92d822008-11-22 07:23:31 +0000587 PP.Diag(TokLoc, diag::ext_hexconstant_invalid);
Chris Lattner368328c2008-06-30 06:39:54 +0000588 } else if (saw_period) {
Chris Lattnerac92d822008-11-22 07:23:31 +0000589 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-ThisTokBegin),
590 diag::err_hexconstant_requires_exponent);
591 hadError = true;
Chris Lattner368328c2008-06-30 06:39:54 +0000592 }
593 return;
594 }
Mike Stump1eb44332009-09-09 15:08:12 +0000595
Chris Lattner368328c2008-06-30 06:39:54 +0000596 // Handle simple binary numbers 0b01010
597 if (*s == 'b' || *s == 'B') {
598 // 0b101010 is a GCC extension.
Chris Lattner413d3552008-06-30 06:44:49 +0000599 PP.Diag(TokLoc, diag::ext_binary_literal);
Chris Lattner368328c2008-06-30 06:39:54 +0000600 ++s;
601 radix = 2;
602 DigitsBegin = s;
603 s = SkipBinaryDigits(s);
604 if (s == ThisTokEnd) {
605 // Done.
606 } else if (isxdigit(*s)) {
Chris Lattnerac92d822008-11-22 07:23:31 +0000607 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-ThisTokBegin),
Chris Lattner5f9e2722011-07-23 10:55:15 +0000608 diag::err_invalid_binary_digit) << StringRef(s, 1);
Chris Lattnerac92d822008-11-22 07:23:31 +0000609 hadError = true;
Chris Lattner368328c2008-06-30 06:39:54 +0000610 }
Chris Lattner413d3552008-06-30 06:44:49 +0000611 // Other suffixes will be diagnosed by the caller.
Chris Lattner368328c2008-06-30 06:39:54 +0000612 return;
613 }
Mike Stump1eb44332009-09-09 15:08:12 +0000614
Chris Lattner368328c2008-06-30 06:39:54 +0000615 // For now, the radix is set to 8. If we discover that we have a
616 // floating point constant, the radix will change to 10. Octal floating
Mike Stump1eb44332009-09-09 15:08:12 +0000617 // point constants are not permitted (only decimal and hexadecimal).
Chris Lattner368328c2008-06-30 06:39:54 +0000618 radix = 8;
619 DigitsBegin = s;
620 s = SkipOctalDigits(s);
621 if (s == ThisTokEnd)
622 return; // Done, simple octal number like 01234
Mike Stump1eb44332009-09-09 15:08:12 +0000623
Chris Lattner413d3552008-06-30 06:44:49 +0000624 // If we have some other non-octal digit that *is* a decimal digit, see if
625 // this is part of a floating point number like 094.123 or 09e1.
626 if (isdigit(*s)) {
627 const char *EndDecimal = SkipDigits(s);
628 if (EndDecimal[0] == '.' || EndDecimal[0] == 'e' || EndDecimal[0] == 'E') {
629 s = EndDecimal;
630 radix = 10;
631 }
632 }
Mike Stump1eb44332009-09-09 15:08:12 +0000633
Chris Lattner413d3552008-06-30 06:44:49 +0000634 // If we have a hex digit other than 'e' (which denotes a FP exponent) then
635 // the code is using an incorrect base.
Chris Lattner368328c2008-06-30 06:39:54 +0000636 if (isxdigit(*s) && *s != 'e' && *s != 'E') {
Chris Lattnerac92d822008-11-22 07:23:31 +0000637 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, s-ThisTokBegin),
Chris Lattner5f9e2722011-07-23 10:55:15 +0000638 diag::err_invalid_octal_digit) << StringRef(s, 1);
Chris Lattnerac92d822008-11-22 07:23:31 +0000639 hadError = true;
Chris Lattner368328c2008-06-30 06:39:54 +0000640 return;
641 }
Mike Stump1eb44332009-09-09 15:08:12 +0000642
Chris Lattner368328c2008-06-30 06:39:54 +0000643 if (*s == '.') {
644 s++;
645 radix = 10;
646 saw_period = true;
Chris Lattner413d3552008-06-30 06:44:49 +0000647 s = SkipDigits(s); // Skip suffix.
Chris Lattner368328c2008-06-30 06:39:54 +0000648 }
649 if (*s == 'e' || *s == 'E') { // exponent
650 const char *Exponent = s;
651 s++;
652 radix = 10;
653 saw_exponent = true;
654 if (*s == '+' || *s == '-') s++; // sign
655 const char *first_non_digit = SkipDigits(s);
656 if (first_non_digit != s) {
657 s = first_non_digit;
658 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000659 PP.Diag(PP.AdvanceToTokenCharacter(TokLoc, Exponent-ThisTokBegin),
Chris Lattnerac92d822008-11-22 07:23:31 +0000660 diag::err_exponent_has_no_digits);
661 hadError = true;
Chris Lattner368328c2008-06-30 06:39:54 +0000662 return;
663 }
664 }
665}
666
667
Reid Spencer5f016e22007-07-11 17:01:13 +0000668/// GetIntegerValue - Convert this numeric literal value to an APInt that
669/// matches Val's input width. If there is an overflow, set Val to the low bits
670/// of the result and return true. Otherwise, return false.
671bool NumericLiteralParser::GetIntegerValue(llvm::APInt &Val) {
Daniel Dunbara179be32008-10-16 07:32:01 +0000672 // Fast path: Compute a conservative bound on the maximum number of
673 // bits per digit in this radix. If we can't possibly overflow a
674 // uint64 based on that bound then do the simple conversion to
675 // integer. This avoids the expensive overflow checking below, and
676 // handles the common cases that matter (small decimal integers and
677 // hex/octal values which don't overflow).
678 unsigned MaxBitsPerDigit = 1;
Mike Stump1eb44332009-09-09 15:08:12 +0000679 while ((1U << MaxBitsPerDigit) < radix)
Daniel Dunbara179be32008-10-16 07:32:01 +0000680 MaxBitsPerDigit += 1;
681 if ((SuffixBegin - DigitsBegin) * MaxBitsPerDigit <= 64) {
682 uint64_t N = 0;
683 for (s = DigitsBegin; s != SuffixBegin; ++s)
684 N = N*radix + HexDigitValue(*s);
685
686 // This will truncate the value to Val's input width. Simply check
687 // for overflow by comparing.
688 Val = N;
689 return Val.getZExtValue() != N;
690 }
691
Reid Spencer5f016e22007-07-11 17:01:13 +0000692 Val = 0;
693 s = DigitsBegin;
694
695 llvm::APInt RadixVal(Val.getBitWidth(), radix);
696 llvm::APInt CharVal(Val.getBitWidth(), 0);
697 llvm::APInt OldVal = Val;
Mike Stump1eb44332009-09-09 15:08:12 +0000698
Reid Spencer5f016e22007-07-11 17:01:13 +0000699 bool OverflowOccurred = false;
700 while (s < SuffixBegin) {
701 unsigned C = HexDigitValue(*s++);
Mike Stump1eb44332009-09-09 15:08:12 +0000702
Reid Spencer5f016e22007-07-11 17:01:13 +0000703 // If this letter is out of bound for this radix, reject it.
704 assert(C < radix && "NumericLiteralParser ctor should have rejected this");
Mike Stump1eb44332009-09-09 15:08:12 +0000705
Reid Spencer5f016e22007-07-11 17:01:13 +0000706 CharVal = C;
Mike Stump1eb44332009-09-09 15:08:12 +0000707
Reid Spencer5f016e22007-07-11 17:01:13 +0000708 // Add the digit to the value in the appropriate radix. If adding in digits
709 // made the value smaller, then this overflowed.
710 OldVal = Val;
711
712 // Multiply by radix, did overflow occur on the multiply?
713 Val *= RadixVal;
714 OverflowOccurred |= Val.udiv(RadixVal) != OldVal;
715
Reid Spencer5f016e22007-07-11 17:01:13 +0000716 // Add value, did overflow occur on the value?
Daniel Dunbard70cb642008-10-16 06:39:30 +0000717 // (a + b) ult b <=> overflow
Reid Spencer5f016e22007-07-11 17:01:13 +0000718 Val += CharVal;
Reid Spencer5f016e22007-07-11 17:01:13 +0000719 OverflowOccurred |= Val.ult(CharVal);
720 }
721 return OverflowOccurred;
722}
723
John McCall94c939d2009-12-24 09:08:04 +0000724llvm::APFloat::opStatus
725NumericLiteralParser::GetFloatValue(llvm::APFloat &Result) {
Ted Kremenek427d5af2007-11-26 23:12:30 +0000726 using llvm::APFloat;
Mike Stump1eb44332009-09-09 15:08:12 +0000727
Erick Tryzelaare9f195f2009-08-16 23:36:28 +0000728 unsigned n = std::min(SuffixBegin - ThisTokBegin, ThisTokEnd - ThisTokBegin);
John McCall94c939d2009-12-24 09:08:04 +0000729 return Result.convertFromString(StringRef(ThisTokBegin, n),
730 APFloat::rmNearestTiesToEven);
Reid Spencer5f016e22007-07-11 17:01:13 +0000731}
732
Reid Spencer5f016e22007-07-11 17:01:13 +0000733
Craig Topper2fa4e862011-08-11 04:06:15 +0000734/// character-literal: [C++0x lex.ccon]
735/// ' c-char-sequence '
736/// u' c-char-sequence '
737/// U' c-char-sequence '
738/// L' c-char-sequence '
739/// c-char-sequence:
740/// c-char
741/// c-char-sequence c-char
742/// c-char:
743/// any member of the source character set except the single-quote ',
744/// backslash \, or new-line character
745/// escape-sequence
746/// universal-character-name
747/// escape-sequence: [C++0x lex.ccon]
748/// simple-escape-sequence
749/// octal-escape-sequence
750/// hexadecimal-escape-sequence
751/// simple-escape-sequence:
NAKAMURA Takumiddddd482011-08-12 05:49:51 +0000752/// one of \' \" \? \\ \a \b \f \n \r \t \v
Craig Topper2fa4e862011-08-11 04:06:15 +0000753/// octal-escape-sequence:
754/// \ octal-digit
755/// \ octal-digit octal-digit
756/// \ octal-digit octal-digit octal-digit
757/// hexadecimal-escape-sequence:
758/// \x hexadecimal-digit
759/// hexadecimal-escape-sequence hexadecimal-digit
760/// universal-character-name:
761/// \u hex-quad
762/// \U hex-quad hex-quad
763/// hex-quad:
764/// hex-digit hex-digit hex-digit hex-digit
765///
Reid Spencer5f016e22007-07-11 17:01:13 +0000766CharLiteralParser::CharLiteralParser(const char *begin, const char *end,
Douglas Gregor5cee1192011-07-27 05:40:30 +0000767 SourceLocation Loc, Preprocessor &PP,
768 tok::TokenKind kind) {
Seth Cantrellbe773522012-01-18 12:27:04 +0000769 // At this point we know that the character matches the regex "(L|u|U)?'.*'".
Reid Spencer5f016e22007-07-11 17:01:13 +0000770 HadError = false;
Mike Stump1eb44332009-09-09 15:08:12 +0000771
Douglas Gregor5cee1192011-07-27 05:40:30 +0000772 Kind = kind;
773
Seth Cantrellbe773522012-01-18 12:27:04 +0000774 // Skip over wide character determinant.
775 if (Kind != tok::char_constant) {
Douglas Gregor5cee1192011-07-27 05:40:30 +0000776 ++begin;
777 }
Mike Stump1eb44332009-09-09 15:08:12 +0000778
Reid Spencer5f016e22007-07-11 17:01:13 +0000779 // Skip over the entry quote.
780 assert(begin[0] == '\'' && "Invalid token lexed");
781 ++begin;
782
Seth Cantrellbe773522012-01-18 12:27:04 +0000783 // Trim the ending quote.
784 assert(end[-1] == '\'' && "Invalid token lexed");
785 --end;
786
Mike Stump1eb44332009-09-09 15:08:12 +0000787 // FIXME: The "Value" is an uint64_t so we can handle char literals of
Chris Lattnerfc8f0e12011-04-15 05:22:18 +0000788 // up to 64-bits.
Reid Spencer5f016e22007-07-11 17:01:13 +0000789 // FIXME: This extensively assumes that 'char' is 8-bits.
Chris Lattner98be4942008-03-05 18:54:05 +0000790 assert(PP.getTargetInfo().getCharWidth() == 8 &&
Reid Spencer5f016e22007-07-11 17:01:13 +0000791 "Assumes char is 8 bits");
Chris Lattnere3ad8812009-04-28 21:51:46 +0000792 assert(PP.getTargetInfo().getIntWidth() <= 64 &&
793 (PP.getTargetInfo().getIntWidth() & 7) == 0 &&
794 "Assumes sizeof(int) on target is <= 64 and a multiple of char");
795 assert(PP.getTargetInfo().getWCharWidth() <= 64 &&
796 "Assumes sizeof(wchar) on target is <= 64");
Sanjiv Gupta4bc11af2009-04-21 02:21:29 +0000797
Seth Cantrellbe773522012-01-18 12:27:04 +0000798 SmallVector<uint32_t,4> codepoint_buffer;
799 codepoint_buffer.resize(end-begin);
800 uint32_t *buffer_begin = &codepoint_buffer.front();
801 uint32_t *buffer_end = buffer_begin + codepoint_buffer.size();
Mike Stump1eb44332009-09-09 15:08:12 +0000802
Seth Cantrellbe773522012-01-18 12:27:04 +0000803 // Unicode escapes representing characters that cannot be correctly
804 // represented in a single code unit are disallowed in character literals
805 // by this implementation.
806 uint32_t largest_character_for_kind;
807 if (tok::wide_char_constant == Kind) {
808 largest_character_for_kind = 0xFFFFFFFFu >> (32-PP.getTargetInfo().getWCharWidth());
809 } else if (tok::utf16_char_constant == Kind) {
810 largest_character_for_kind = 0xFFFF;
811 } else if (tok::utf32_char_constant == Kind) {
812 largest_character_for_kind = 0x10FFFF;
813 } else {
814 largest_character_for_kind = 0x7Fu;
Chris Lattnere3ad8812009-04-28 21:51:46 +0000815 }
816
Seth Cantrellbe773522012-01-18 12:27:04 +0000817 while (begin!=end) {
818 // Is this a span of non-escape characters?
819 if (begin[0] != '\\') {
820 char const *start = begin;
821 do {
822 ++begin;
823 } while (begin != end && *begin != '\\');
824
Eli Friedman91359302012-02-11 05:08:10 +0000825 char const *tmp_in_start = start;
826 uint32_t *tmp_out_start = buffer_begin;
Seth Cantrellbe773522012-01-18 12:27:04 +0000827 ConversionResult res =
828 ConvertUTF8toUTF32(reinterpret_cast<UTF8 const **>(&start),
829 reinterpret_cast<UTF8 const *>(begin),
830 &buffer_begin,buffer_end,strictConversion);
831 if (res!=conversionOK) {
Eli Friedman91359302012-02-11 05:08:10 +0000832 // If we see bad encoding for unprefixed character literals, warn and
833 // simply copy the byte values, for compatibility with gcc and
834 // older versions of clang.
835 bool NoErrorOnBadEncoding = isAscii();
836 unsigned Msg = diag::err_bad_character_encoding;
837 if (NoErrorOnBadEncoding)
838 Msg = diag::warn_bad_character_encoding;
839 PP.Diag(Loc, Msg);
840 if (NoErrorOnBadEncoding) {
841 start = tmp_in_start;
842 buffer_begin = tmp_out_start;
843 for ( ; start != begin; ++start, ++buffer_begin)
844 *buffer_begin = static_cast<uint8_t>(*start);
845 } else {
846 HadError = true;
847 }
Seth Cantrellbe773522012-01-18 12:27:04 +0000848 } else {
Eli Friedman91359302012-02-11 05:08:10 +0000849 for (; tmp_out_start <buffer_begin; ++tmp_out_start) {
850 if (*tmp_out_start > largest_character_for_kind) {
Seth Cantrellbe773522012-01-18 12:27:04 +0000851 HadError = true;
852 PP.Diag(Loc, diag::err_character_too_large);
853 }
854 }
855 }
856
857 continue;
858 }
859 // Is this a Universal Character Name excape?
860 if (begin[1] == 'u' || begin[1] == 'U') {
861 unsigned short UcnLen = 0;
862 if (!ProcessUCNEscape(begin, end, *buffer_begin, UcnLen,
863 FullSourceLoc(Loc, PP.getSourceManager()),
864 &PP.getDiagnostics(), PP.getLangOptions(),
865 true))
866 {
867 HadError = true;
868 } else if (*buffer_begin > largest_character_for_kind) {
869 HadError = true;
870 PP.Diag(Loc,diag::err_character_too_large);
871 }
872
873 ++buffer_begin;
874 continue;
875 }
876 unsigned CharWidth = getCharWidth(Kind, PP.getTargetInfo());
877 uint64_t result =
878 ProcessCharEscape(begin, end, HadError,
879 FullSourceLoc(Loc,PP.getSourceManager()),
880 CharWidth, &PP.getDiagnostics());
881 *buffer_begin++ = result;
882 }
883
884 unsigned NumCharsSoFar = buffer_begin-&codepoint_buffer.front();
885
Chris Lattnere3ad8812009-04-28 21:51:46 +0000886 if (NumCharsSoFar > 1) {
Seth Cantrellbe773522012-01-18 12:27:04 +0000887 if (isWide())
Douglas Gregor5cee1192011-07-27 05:40:30 +0000888 PP.Diag(Loc, diag::warn_extraneous_char_constant);
Seth Cantrellbe773522012-01-18 12:27:04 +0000889 else if (isAscii() && NumCharsSoFar == 4)
890 PP.Diag(Loc, diag::ext_four_char_character_literal);
891 else if (isAscii())
Chris Lattnere3ad8812009-04-28 21:51:46 +0000892 PP.Diag(Loc, diag::ext_multichar_character_literal);
893 else
Seth Cantrellbe773522012-01-18 12:27:04 +0000894 PP.Diag(Loc, diag::err_multichar_utf_character_literal);
Eli Friedman2a1c3632009-06-01 05:25:02 +0000895 IsMultiChar = true;
Daniel Dunbar930b71a2009-07-29 01:46:05 +0000896 } else
897 IsMultiChar = false;
Sanjiv Gupta4bc11af2009-04-21 02:21:29 +0000898
Seth Cantrellbe773522012-01-18 12:27:04 +0000899 llvm::APInt LitVal(PP.getTargetInfo().getIntWidth(), 0);
900
901 // Narrow character literals act as though their value is concatenated
902 // in this implementation, but warn on overflow.
903 bool multi_char_too_long = false;
904 if (isAscii() && isMultiChar()) {
905 LitVal = 0;
906 for (size_t i=0;i<NumCharsSoFar;++i) {
907 // check for enough leading zeros to shift into
908 multi_char_too_long |= (LitVal.countLeadingZeros() < 8);
909 LitVal <<= 8;
910 LitVal = LitVal + (codepoint_buffer[i] & 0xFF);
911 }
912 } else if (NumCharsSoFar > 0) {
913 // otherwise just take the last character
914 LitVal = buffer_begin[-1];
915 }
916
917 if (!HadError && multi_char_too_long) {
918 PP.Diag(Loc,diag::warn_char_constant_too_large);
919 }
920
Sanjiv Gupta4bc11af2009-04-21 02:21:29 +0000921 // Transfer the value from APInt to uint64_t
922 Value = LitVal.getZExtValue();
Mike Stump1eb44332009-09-09 15:08:12 +0000923
Reid Spencer5f016e22007-07-11 17:01:13 +0000924 // If this is a single narrow character, sign extend it (e.g. '\xFF' is "-1")
925 // if 'char' is signed for this target (C99 6.4.4.4p10). Note that multiple
926 // character constants are not sign extended in the this implementation:
927 // '\xFF\xFF' = 65536 and '\x0\xFF' = 255, which matches GCC.
Douglas Gregor5cee1192011-07-27 05:40:30 +0000928 if (isAscii() && NumCharsSoFar == 1 && (Value & 128) &&
Eli Friedman15b91762009-06-05 07:05:05 +0000929 PP.getLangOptions().CharIsSigned)
Reid Spencer5f016e22007-07-11 17:01:13 +0000930 Value = (signed char)Value;
931}
932
933
Craig Topper2fa4e862011-08-11 04:06:15 +0000934/// string-literal: [C++0x lex.string]
935/// encoding-prefix " [s-char-sequence] "
936/// encoding-prefix R raw-string
937/// encoding-prefix:
938/// u8
939/// u
940/// U
941/// L
Reid Spencer5f016e22007-07-11 17:01:13 +0000942/// s-char-sequence:
943/// s-char
944/// s-char-sequence s-char
945/// s-char:
Craig Topper2fa4e862011-08-11 04:06:15 +0000946/// any member of the source character set except the double-quote ",
947/// backslash \, or new-line character
948/// escape-sequence
Reid Spencer5f016e22007-07-11 17:01:13 +0000949/// universal-character-name
Craig Topper2fa4e862011-08-11 04:06:15 +0000950/// raw-string:
951/// " d-char-sequence ( r-char-sequence ) d-char-sequence "
952/// r-char-sequence:
953/// r-char
954/// r-char-sequence r-char
955/// r-char:
956/// any member of the source character set, except a right parenthesis )
957/// followed by the initial d-char-sequence (which may be empty)
958/// followed by a double quote ".
959/// d-char-sequence:
960/// d-char
961/// d-char-sequence d-char
962/// d-char:
963/// any member of the basic source character set except:
964/// space, the left parenthesis (, the right parenthesis ),
965/// the backslash \, and the control characters representing horizontal
966/// tab, vertical tab, form feed, and newline.
967/// escape-sequence: [C++0x lex.ccon]
968/// simple-escape-sequence
969/// octal-escape-sequence
970/// hexadecimal-escape-sequence
971/// simple-escape-sequence:
NAKAMURA Takumiddddd482011-08-12 05:49:51 +0000972/// one of \' \" \? \\ \a \b \f \n \r \t \v
Craig Topper2fa4e862011-08-11 04:06:15 +0000973/// octal-escape-sequence:
974/// \ octal-digit
975/// \ octal-digit octal-digit
976/// \ octal-digit octal-digit octal-digit
977/// hexadecimal-escape-sequence:
978/// \x hexadecimal-digit
979/// hexadecimal-escape-sequence hexadecimal-digit
Reid Spencer5f016e22007-07-11 17:01:13 +0000980/// universal-character-name:
981/// \u hex-quad
982/// \U hex-quad hex-quad
983/// hex-quad:
984/// hex-digit hex-digit hex-digit hex-digit
985///
986StringLiteralParser::
Chris Lattnerd2177732007-07-20 16:59:19 +0000987StringLiteralParser(const Token *StringToks, unsigned NumStringToks,
Chris Lattner0833dd02010-11-17 07:21:13 +0000988 Preprocessor &PP, bool Complain)
989 : SM(PP.getSourceManager()), Features(PP.getLangOptions()),
Argyrios Kyrtzidis403de3f2011-05-17 22:09:56 +0000990 Target(PP.getTargetInfo()), Diags(Complain ? &PP.getDiagnostics() : 0),
Douglas Gregor5cee1192011-07-27 05:40:30 +0000991 MaxTokenLength(0), SizeBound(0), CharByteWidth(0), Kind(tok::unknown),
992 ResultPtr(ResultBuf.data()), hadError(false), Pascal(false) {
Chris Lattner0833dd02010-11-17 07:21:13 +0000993 init(StringToks, NumStringToks);
994}
995
996void StringLiteralParser::init(const Token *StringToks, unsigned NumStringToks){
Argyrios Kyrtzidis403de3f2011-05-17 22:09:56 +0000997 // The literal token may have come from an invalid source location (e.g. due
998 // to a PCH error), in which case the token length will be 0.
999 if (NumStringToks == 0 || StringToks[0].getLength() < 2) {
1000 hadError = true;
1001 return;
1002 }
1003
Reid Spencer5f016e22007-07-11 17:01:13 +00001004 // Scan all of the string portions, remember the max individual token length,
1005 // computing a bound on the concatenated string length, and see whether any
1006 // piece is a wide-string. If any of the string portions is a wide-string
1007 // literal, the result is a wide-string literal [C99 6.4.5p4].
Argyrios Kyrtzidis403de3f2011-05-17 22:09:56 +00001008 assert(NumStringToks && "expected at least one token");
Sean Hunt6cf75022010-08-30 17:47:05 +00001009 MaxTokenLength = StringToks[0].getLength();
Argyrios Kyrtzidis403de3f2011-05-17 22:09:56 +00001010 assert(StringToks[0].getLength() >= 2 && "literal token is invalid!");
Sean Hunt6cf75022010-08-30 17:47:05 +00001011 SizeBound = StringToks[0].getLength()-2; // -2 for "".
Douglas Gregor5cee1192011-07-27 05:40:30 +00001012 Kind = StringToks[0].getKind();
Sean Hunt6cf75022010-08-30 17:47:05 +00001013
1014 hadError = false;
Reid Spencer5f016e22007-07-11 17:01:13 +00001015
1016 // Implement Translation Phase #6: concatenation of string literals
1017 /// (C99 5.1.1.2p1). The common case is only one string fragment.
1018 for (unsigned i = 1; i != NumStringToks; ++i) {
Argyrios Kyrtzidis403de3f2011-05-17 22:09:56 +00001019 if (StringToks[i].getLength() < 2) {
1020 hadError = true;
1021 return;
1022 }
1023
Reid Spencer5f016e22007-07-11 17:01:13 +00001024 // The string could be shorter than this if it needs cleaning, but this is a
1025 // reasonable bound, which is all we need.
Argyrios Kyrtzidis403de3f2011-05-17 22:09:56 +00001026 assert(StringToks[i].getLength() >= 2 && "literal token is invalid!");
Sean Hunt6cf75022010-08-30 17:47:05 +00001027 SizeBound += StringToks[i].getLength()-2; // -2 for "".
Mike Stump1eb44332009-09-09 15:08:12 +00001028
Reid Spencer5f016e22007-07-11 17:01:13 +00001029 // Remember maximum string piece length.
Sean Hunt6cf75022010-08-30 17:47:05 +00001030 if (StringToks[i].getLength() > MaxTokenLength)
1031 MaxTokenLength = StringToks[i].getLength();
Mike Stump1eb44332009-09-09 15:08:12 +00001032
Douglas Gregor5cee1192011-07-27 05:40:30 +00001033 // Remember if we see any wide or utf-8/16/32 strings.
1034 // Also check for illegal concatenations.
1035 if (StringToks[i].isNot(Kind) && StringToks[i].isNot(tok::string_literal)) {
1036 if (isAscii()) {
1037 Kind = StringToks[i].getKind();
1038 } else {
1039 if (Diags)
1040 Diags->Report(FullSourceLoc(StringToks[i].getLocation(), SM),
1041 diag::err_unsupported_string_concat);
1042 hadError = true;
1043 }
1044 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001045 }
Chris Lattnerdbb1ecc2009-02-26 23:01:51 +00001046
Reid Spencer5f016e22007-07-11 17:01:13 +00001047 // Include space for the null terminator.
1048 ++SizeBound;
Mike Stump1eb44332009-09-09 15:08:12 +00001049
Reid Spencer5f016e22007-07-11 17:01:13 +00001050 // TODO: K&R warning: "traditional C rejects string constant concatenation"
Mike Stump1eb44332009-09-09 15:08:12 +00001051
Douglas Gregor5cee1192011-07-27 05:40:30 +00001052 // Get the width in bytes of char/wchar_t/char16_t/char32_t
1053 CharByteWidth = getCharWidth(Kind, Target);
1054 assert((CharByteWidth & 7) == 0 && "Assumes character size is byte multiple");
1055 CharByteWidth /= 8;
Mike Stump1eb44332009-09-09 15:08:12 +00001056
Reid Spencer5f016e22007-07-11 17:01:13 +00001057 // The output buffer size needs to be large enough to hold wide characters.
1058 // This is a worst-case assumption which basically corresponds to L"" "long".
Douglas Gregor5cee1192011-07-27 05:40:30 +00001059 SizeBound *= CharByteWidth;
Mike Stump1eb44332009-09-09 15:08:12 +00001060
Reid Spencer5f016e22007-07-11 17:01:13 +00001061 // Size the temporary buffer to hold the result string data.
1062 ResultBuf.resize(SizeBound);
Mike Stump1eb44332009-09-09 15:08:12 +00001063
Reid Spencer5f016e22007-07-11 17:01:13 +00001064 // Likewise, but for each string piece.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00001065 SmallString<512> TokenBuf;
Reid Spencer5f016e22007-07-11 17:01:13 +00001066 TokenBuf.resize(MaxTokenLength);
Mike Stump1eb44332009-09-09 15:08:12 +00001067
Reid Spencer5f016e22007-07-11 17:01:13 +00001068 // Loop over all the strings, getting their spelling, and expanding them to
1069 // wide strings as appropriate.
1070 ResultPtr = &ResultBuf[0]; // Next byte to fill in.
Mike Stump1eb44332009-09-09 15:08:12 +00001071
Anders Carlssonee98ac52007-10-15 02:50:23 +00001072 Pascal = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001073
Reid Spencer5f016e22007-07-11 17:01:13 +00001074 for (unsigned i = 0, e = NumStringToks; i != e; ++i) {
1075 const char *ThisTokBuf = &TokenBuf[0];
1076 // Get the spelling of the token, which eliminates trigraphs, etc. We know
1077 // that ThisTokBuf points to a buffer that is big enough for the whole token
1078 // and 'spelled' tokens can only shrink.
Douglas Gregor50f6af72010-03-16 05:20:39 +00001079 bool StringInvalid = false;
Chris Lattner0833dd02010-11-17 07:21:13 +00001080 unsigned ThisTokLen =
Chris Lattnerb0607272010-11-17 07:26:20 +00001081 Lexer::getSpelling(StringToks[i], ThisTokBuf, SM, Features,
1082 &StringInvalid);
Douglas Gregor50f6af72010-03-16 05:20:39 +00001083 if (StringInvalid) {
Douglas Gregor5cee1192011-07-27 05:40:30 +00001084 hadError = true;
Douglas Gregor50f6af72010-03-16 05:20:39 +00001085 continue;
1086 }
1087
Reid Spencer5f016e22007-07-11 17:01:13 +00001088 const char *ThisTokEnd = ThisTokBuf+ThisTokLen-1; // Skip end quote.
Reid Spencer5f016e22007-07-11 17:01:13 +00001089 // TODO: Input character set mapping support.
Mike Stump1eb44332009-09-09 15:08:12 +00001090
Craig Topper1661d712011-08-08 06:10:39 +00001091 // Skip marker for wide or unicode strings.
Douglas Gregor5cee1192011-07-27 05:40:30 +00001092 if (ThisTokBuf[0] == 'L' || ThisTokBuf[0] == 'u' || ThisTokBuf[0] == 'U') {
Reid Spencer5f016e22007-07-11 17:01:13 +00001093 ++ThisTokBuf;
Douglas Gregor5cee1192011-07-27 05:40:30 +00001094 // Skip 8 of u8 marker for utf8 strings.
1095 if (ThisTokBuf[0] == '8')
1096 ++ThisTokBuf;
Fariborz Jahanian56bedef2010-08-31 23:34:27 +00001097 }
Mike Stump1eb44332009-09-09 15:08:12 +00001098
Craig Topper2fa4e862011-08-11 04:06:15 +00001099 // Check for raw string
1100 if (ThisTokBuf[0] == 'R') {
1101 ThisTokBuf += 2; // skip R"
Mike Stump1eb44332009-09-09 15:08:12 +00001102
Craig Topper2fa4e862011-08-11 04:06:15 +00001103 const char *Prefix = ThisTokBuf;
1104 while (ThisTokBuf[0] != '(')
Anders Carlssonee98ac52007-10-15 02:50:23 +00001105 ++ThisTokBuf;
Craig Topper2fa4e862011-08-11 04:06:15 +00001106 ++ThisTokBuf; // skip '('
Mike Stump1eb44332009-09-09 15:08:12 +00001107
Craig Topper2fa4e862011-08-11 04:06:15 +00001108 // remove same number of characters from the end
1109 if (ThisTokEnd >= ThisTokBuf + (ThisTokBuf - Prefix))
1110 ThisTokEnd -= (ThisTokBuf - Prefix);
1111
1112 // Copy the string over
Eli Friedmanf74a4582011-11-01 02:14:50 +00001113 if (CopyStringFragment(StringRef(ThisTokBuf,ThisTokEnd-ThisTokBuf)))
1114 {
Eli Friedman91359302012-02-11 05:08:10 +00001115 if (DiagnoseBadString(StringToks[i]))
1116 hadError = true;
Eli Friedmanf74a4582011-11-01 02:14:50 +00001117 }
1118
Craig Topper2fa4e862011-08-11 04:06:15 +00001119 } else {
1120 assert(ThisTokBuf[0] == '"' && "Expected quote, lexer broken?");
1121 ++ThisTokBuf; // skip "
1122
1123 // Check if this is a pascal string
1124 if (Features.PascalStrings && ThisTokBuf + 1 != ThisTokEnd &&
1125 ThisTokBuf[0] == '\\' && ThisTokBuf[1] == 'p') {
1126
1127 // If the \p sequence is found in the first token, we have a pascal string
1128 // Otherwise, if we already have a pascal string, ignore the first \p
1129 if (i == 0) {
Reid Spencer5f016e22007-07-11 17:01:13 +00001130 ++ThisTokBuf;
Craig Topper2fa4e862011-08-11 04:06:15 +00001131 Pascal = true;
1132 } else if (Pascal)
1133 ThisTokBuf += 2;
1134 }
Mike Stump1eb44332009-09-09 15:08:12 +00001135
Craig Topper2fa4e862011-08-11 04:06:15 +00001136 while (ThisTokBuf != ThisTokEnd) {
1137 // Is this a span of non-escape characters?
1138 if (ThisTokBuf[0] != '\\') {
1139 const char *InStart = ThisTokBuf;
1140 do {
1141 ++ThisTokBuf;
1142 } while (ThisTokBuf != ThisTokEnd && ThisTokBuf[0] != '\\');
1143
1144 // Copy the character span over.
Eli Friedmanf74a4582011-11-01 02:14:50 +00001145 if (CopyStringFragment(StringRef(InStart,ThisTokBuf-InStart)))
1146 {
Eli Friedman91359302012-02-11 05:08:10 +00001147 if (DiagnoseBadString(StringToks[i]))
1148 hadError = true;
Eli Friedmanf74a4582011-11-01 02:14:50 +00001149 }
Craig Topper2fa4e862011-08-11 04:06:15 +00001150 continue;
Reid Spencer5f016e22007-07-11 17:01:13 +00001151 }
Craig Topper2fa4e862011-08-11 04:06:15 +00001152 // Is this a Universal Character Name escape?
1153 if (ThisTokBuf[1] == 'u' || ThisTokBuf[1] == 'U') {
1154 EncodeUCNEscape(ThisTokBuf, ThisTokEnd, ResultPtr,
1155 hadError, FullSourceLoc(StringToks[i].getLocation(),SM),
1156 CharByteWidth, Diags, Features);
1157 continue;
1158 }
1159 // Otherwise, this is a non-UCN escape character. Process it.
1160 unsigned ResultChar =
1161 ProcessCharEscape(ThisTokBuf, ThisTokEnd, hadError,
1162 FullSourceLoc(StringToks[i].getLocation(), SM),
1163 CharByteWidth*8, Diags);
Mike Stump1eb44332009-09-09 15:08:12 +00001164
Eli Friedmancaf1f262011-11-02 23:06:23 +00001165 if (CharByteWidth == 4) {
1166 // FIXME: Make the type of the result buffer correct instead of
1167 // using reinterpret_cast.
1168 UTF32 *ResultWidePtr = reinterpret_cast<UTF32*>(ResultPtr);
Nico Weber9b483df2011-11-14 05:17:37 +00001169 *ResultWidePtr = ResultChar;
Eli Friedmancaf1f262011-11-02 23:06:23 +00001170 ResultPtr += 4;
1171 } else if (CharByteWidth == 2) {
1172 // FIXME: Make the type of the result buffer correct instead of
1173 // using reinterpret_cast.
1174 UTF16 *ResultWidePtr = reinterpret_cast<UTF16*>(ResultPtr);
Nico Weber9b483df2011-11-14 05:17:37 +00001175 *ResultWidePtr = ResultChar & 0xFFFF;
Eli Friedmancaf1f262011-11-02 23:06:23 +00001176 ResultPtr += 2;
1177 } else {
1178 assert(CharByteWidth == 1 && "Unexpected char width");
1179 *ResultPtr++ = ResultChar & 0xFF;
1180 }
Craig Topper2fa4e862011-08-11 04:06:15 +00001181 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001182 }
1183 }
Mike Stump1eb44332009-09-09 15:08:12 +00001184
Chris Lattnerbbee00b2009-01-16 18:51:42 +00001185 if (Pascal) {
Eli Friedman22508f42011-11-05 00:41:04 +00001186 if (CharByteWidth == 4) {
1187 // FIXME: Make the type of the result buffer correct instead of
1188 // using reinterpret_cast.
1189 UTF32 *ResultWidePtr = reinterpret_cast<UTF32*>(ResultBuf.data());
1190 ResultWidePtr[0] = GetNumStringChars() - 1;
1191 } else if (CharByteWidth == 2) {
1192 // FIXME: Make the type of the result buffer correct instead of
1193 // using reinterpret_cast.
1194 UTF16 *ResultWidePtr = reinterpret_cast<UTF16*>(ResultBuf.data());
1195 ResultWidePtr[0] = GetNumStringChars() - 1;
1196 } else {
1197 assert(CharByteWidth == 1 && "Unexpected char width");
1198 ResultBuf[0] = GetNumStringChars() - 1;
1199 }
Chris Lattnerbbee00b2009-01-16 18:51:42 +00001200
1201 // Verify that pascal strings aren't too large.
Chris Lattner0833dd02010-11-17 07:21:13 +00001202 if (GetStringLength() > 256) {
1203 if (Diags)
1204 Diags->Report(FullSourceLoc(StringToks[0].getLocation(), SM),
1205 diag::err_pascal_string_too_long)
1206 << SourceRange(StringToks[0].getLocation(),
1207 StringToks[NumStringToks-1].getLocation());
Douglas Gregor5cee1192011-07-27 05:40:30 +00001208 hadError = true;
Eli Friedman57d7dde2009-04-01 03:17:08 +00001209 return;
1210 }
Chris Lattner0833dd02010-11-17 07:21:13 +00001211 } else if (Diags) {
Douglas Gregor427c4922010-07-20 14:33:20 +00001212 // Complain if this string literal has too many characters.
Chris Lattnera95880d2010-11-17 07:12:42 +00001213 unsigned MaxChars = Features.CPlusPlus? 65536 : Features.C99 ? 4095 : 509;
Douglas Gregor427c4922010-07-20 14:33:20 +00001214
1215 if (GetNumStringChars() > MaxChars)
Chris Lattner0833dd02010-11-17 07:21:13 +00001216 Diags->Report(FullSourceLoc(StringToks[0].getLocation(), SM),
1217 diag::ext_string_too_long)
Douglas Gregor427c4922010-07-20 14:33:20 +00001218 << GetNumStringChars() << MaxChars
Chris Lattnera95880d2010-11-17 07:12:42 +00001219 << (Features.CPlusPlus ? 2 : Features.C99 ? 1 : 0)
Douglas Gregor427c4922010-07-20 14:33:20 +00001220 << SourceRange(StringToks[0].getLocation(),
1221 StringToks[NumStringToks-1].getLocation());
Chris Lattnerbbee00b2009-01-16 18:51:42 +00001222 }
Reid Spencer5f016e22007-07-11 17:01:13 +00001223}
Chris Lattner719e6152009-02-18 19:21:10 +00001224
1225
Craig Topper2fa4e862011-08-11 04:06:15 +00001226/// copyStringFragment - This function copies from Start to End into ResultPtr.
1227/// Performs widening for multi-byte characters.
Eli Friedmanf74a4582011-11-01 02:14:50 +00001228bool StringLiteralParser::CopyStringFragment(StringRef Fragment) {
1229 assert(CharByteWidth==1 || CharByteWidth==2 || CharByteWidth==4);
1230 ConversionResult result = conversionOK;
Craig Topper2fa4e862011-08-11 04:06:15 +00001231 // Copy the character span over.
1232 if (CharByteWidth == 1) {
Eli Friedman91359302012-02-11 05:08:10 +00001233 if (!isLegalUTF8Sequence(reinterpret_cast<const UTF8*>(Fragment.begin()),
1234 reinterpret_cast<const UTF8*>(Fragment.end())))
1235 result = sourceIllegal;
Craig Topper2fa4e862011-08-11 04:06:15 +00001236 memcpy(ResultPtr, Fragment.data(), Fragment.size());
1237 ResultPtr += Fragment.size();
Eli Friedmanf74a4582011-11-01 02:14:50 +00001238 } else if (CharByteWidth == 2) {
1239 UTF8 const *sourceStart = (UTF8 const *)Fragment.data();
1240 // FIXME: Make the type of the result buffer correct instead of
1241 // using reinterpret_cast.
1242 UTF16 *targetStart = reinterpret_cast<UTF16*>(ResultPtr);
Eli Friedman91359302012-02-11 05:08:10 +00001243 ConversionFlags flags = strictConversion;
Eli Friedmanf74a4582011-11-01 02:14:50 +00001244 result = ConvertUTF8toUTF16(
1245 &sourceStart,sourceStart + Fragment.size(),
1246 &targetStart,targetStart + 2*Fragment.size(),flags);
1247 if (result==conversionOK)
1248 ResultPtr = reinterpret_cast<char*>(targetStart);
1249 } else if (CharByteWidth == 4) {
1250 UTF8 const *sourceStart = (UTF8 const *)Fragment.data();
1251 // FIXME: Make the type of the result buffer correct instead of
1252 // using reinterpret_cast.
1253 UTF32 *targetStart = reinterpret_cast<UTF32*>(ResultPtr);
Eli Friedman91359302012-02-11 05:08:10 +00001254 ConversionFlags flags = strictConversion;
Eli Friedmanf74a4582011-11-01 02:14:50 +00001255 result = ConvertUTF8toUTF32(
1256 &sourceStart,sourceStart + Fragment.size(),
1257 &targetStart,targetStart + 4*Fragment.size(),flags);
1258 if (result==conversionOK)
1259 ResultPtr = reinterpret_cast<char*>(targetStart);
Craig Topper2fa4e862011-08-11 04:06:15 +00001260 }
Eli Friedmanf74a4582011-11-01 02:14:50 +00001261 assert((result != targetExhausted)
1262 && "ConvertUTF8toUTFXX exhausted target buffer");
1263 return result != conversionOK;
Craig Topper2fa4e862011-08-11 04:06:15 +00001264}
1265
Eli Friedman91359302012-02-11 05:08:10 +00001266bool StringLiteralParser::DiagnoseBadString(const Token &Tok) {
1267 // If we see bad encoding for unprefixed string literals, warn and
1268 // simply copy the byte values, for compatibility with gcc and older
1269 // versions of clang.
1270 bool NoErrorOnBadEncoding = isAscii();
1271 unsigned Msg = NoErrorOnBadEncoding ? diag::warn_bad_string_encoding :
1272 diag::err_bad_string_encoding;
1273 if (Diags)
1274 Diags->Report(FullSourceLoc(Tok.getLocation(), SM), Msg);
1275 return !NoErrorOnBadEncoding;
1276}
Craig Topper2fa4e862011-08-11 04:06:15 +00001277
Chris Lattner719e6152009-02-18 19:21:10 +00001278/// getOffsetOfStringByte - This function returns the offset of the
1279/// specified byte of the string data represented by Token. This handles
1280/// advancing over escape sequences in the string.
1281unsigned StringLiteralParser::getOffsetOfStringByte(const Token &Tok,
Chris Lattner6c66f072010-11-17 06:46:14 +00001282 unsigned ByteNo) const {
Chris Lattner719e6152009-02-18 19:21:10 +00001283 // Get the spelling of the token.
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +00001284 SmallString<32> SpellingBuffer;
Sean Hunt6cf75022010-08-30 17:47:05 +00001285 SpellingBuffer.resize(Tok.getLength());
Mike Stump1eb44332009-09-09 15:08:12 +00001286
Douglas Gregor50f6af72010-03-16 05:20:39 +00001287 bool StringInvalid = false;
Chris Lattner719e6152009-02-18 19:21:10 +00001288 const char *SpellingPtr = &SpellingBuffer[0];
Chris Lattnerb0607272010-11-17 07:26:20 +00001289 unsigned TokLen = Lexer::getSpelling(Tok, SpellingPtr, SM, Features,
1290 &StringInvalid);
Chris Lattner91f54ce2010-11-17 06:26:08 +00001291 if (StringInvalid)
Douglas Gregor50f6af72010-03-16 05:20:39 +00001292 return 0;
Chris Lattner719e6152009-02-18 19:21:10 +00001293
Douglas Gregor5cee1192011-07-27 05:40:30 +00001294 assert(SpellingPtr[0] != 'L' && SpellingPtr[0] != 'u' &&
1295 SpellingPtr[0] != 'U' && "Doesn't handle wide or utf strings yet");
Chris Lattner719e6152009-02-18 19:21:10 +00001296
Mike Stump1eb44332009-09-09 15:08:12 +00001297
Chris Lattner719e6152009-02-18 19:21:10 +00001298 const char *SpellingStart = SpellingPtr;
1299 const char *SpellingEnd = SpellingPtr+TokLen;
1300
1301 // Skip over the leading quote.
1302 assert(SpellingPtr[0] == '"' && "Should be a string literal!");
1303 ++SpellingPtr;
Mike Stump1eb44332009-09-09 15:08:12 +00001304
Chris Lattner719e6152009-02-18 19:21:10 +00001305 // Skip over bytes until we find the offset we're looking for.
1306 while (ByteNo) {
1307 assert(SpellingPtr < SpellingEnd && "Didn't find byte offset!");
Mike Stump1eb44332009-09-09 15:08:12 +00001308
Chris Lattner719e6152009-02-18 19:21:10 +00001309 // Step over non-escapes simply.
1310 if (*SpellingPtr != '\\') {
1311 ++SpellingPtr;
1312 --ByteNo;
1313 continue;
1314 }
Mike Stump1eb44332009-09-09 15:08:12 +00001315
Chris Lattner719e6152009-02-18 19:21:10 +00001316 // Otherwise, this is an escape character. Advance over it.
1317 bool HadError = false;
1318 ProcessCharEscape(SpellingPtr, SpellingEnd, HadError,
Chris Lattnerca1475e2010-11-17 06:35:43 +00001319 FullSourceLoc(Tok.getLocation(), SM),
Douglas Gregor5cee1192011-07-27 05:40:30 +00001320 CharByteWidth*8, Diags);
Chris Lattner719e6152009-02-18 19:21:10 +00001321 assert(!HadError && "This method isn't valid on erroneous strings");
1322 --ByteNo;
1323 }
Mike Stump1eb44332009-09-09 15:08:12 +00001324
Chris Lattner719e6152009-02-18 19:21:10 +00001325 return SpellingPtr-SpellingStart;
1326}