Lines Matching defs:CurPtr
573 const char *CurPtr = Buffer->getBufferStart();
575 while (CurPtr != Buffer->getBufferEnd()) {
576 char ch = *CurPtr++;
583 if (CurPtr != Buffer->getBufferEnd())
584 MaxLineOffset = CurPtr - Buffer->getBufferStart();
1422 void Lexer::LexIdentifier(Token &Result, const char *CurPtr) {
1425 unsigned char C = *CurPtr++;
1427 C = *CurPtr++;
1429 --CurPtr; // Back up over the skipped character.
1440 FormTokenWithChars(Result, CurPtr, tok::raw_identifier);
1462 C = getCharAndSize(CurPtr, Size);
1470 Diag(CurPtr, diag::ext_dollar_in_identifier);
1471 CurPtr = ConsumeChar(CurPtr, Size, Result);
1472 C = getCharAndSize(CurPtr, Size);
1476 const char *UCNPtr = CurPtr + Size;
1477 uint32_t CodePoint = tryReadUCN(UCNPtr, CurPtr, /*Token=*/0);
1483 makeCharRange(*this, CurPtr, UCNPtr),
1488 if ((UCNPtr - CurPtr == 6 && CurPtr[1] == 'u') ||
1489 (UCNPtr - CurPtr == 10 && CurPtr[1] == 'U'))
1490 CurPtr = UCNPtr;
1492 while (CurPtr != UCNPtr)
1493 (void)getAndAdvanceChar(CurPtr, Result);
1495 C = getCharAndSize(CurPtr, Size);
1498 const char *UnicodePtr = CurPtr;
1511 makeCharRange(*this, CurPtr, UnicodePtr),
1515 CurPtr = UnicodePtr;
1516 C = getCharAndSize(CurPtr, Size);
1523 CurPtr = ConsumeChar(CurPtr, Size, Result);
1525 C = getCharAndSize(CurPtr, Size);
1527 CurPtr = ConsumeChar(CurPtr, Size, Result);
1528 C = getCharAndSize(CurPtr, Size);
1547 void Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {
1549 char C = getCharAndSize(CurPtr, Size);
1552 CurPtr = ConsumeChar(CurPtr, Size, Result);
1554 C = getCharAndSize(CurPtr, Size);
1562 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1574 else if (std::find(BufferPtr, CurPtr, '_') != CurPtr)
1578 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1583 FormTokenWithChars(Result, CurPtr, tok::numeric_constant);
1589 const char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr,
1595 char C = getCharAndSize(CurPtr, Size);
1599 Diag(CurPtr,
1602 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
1603 return CurPtr;
1616 if (!isIdentifierBody(getCharAndSizeNoWarn(CurPtr + Size, NextSize,
1623 Diag(CurPtr, getLangOpts().MicrosoftMode ?
1626 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
1627 return CurPtr;
1632 CurPtr = ConsumeChar(CurPtr, Size, Result);
1633 C = getCharAndSize(CurPtr, Size);
1636 return CurPtr;
1641 void Lexer::LexStringLiteral(Token &Result, const char *CurPtr,
1653 char C = getAndAdvanceChar(CurPtr, Result);
1658 C = getAndAdvanceChar(CurPtr, Result);
1661 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1664 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1669 if (isCodeCompletionPoint(CurPtr-1)) {
1671 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1675 NulCharacter = CurPtr-1;
1677 C = getAndAdvanceChar(CurPtr, Result);
1682 CurPtr = LexUDSuffix(Result, CurPtr, true);
1690 FormTokenWithChars(Result, CurPtr, Kind);
1696 void Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr,
1708 while (PrefixLen != 16 && isRawStringDelimBody(CurPtr[PrefixLen]))
1712 if (CurPtr[PrefixLen] != '(') {
1714 const char *PrefixEnd = &CurPtr[PrefixLen];
1727 char C = *CurPtr++;
1731 if (C == 0 && CurPtr-1 == BufferEnd) {
1732 --CurPtr;
1737 FormTokenWithChars(Result, CurPtr, tok::unknown);
1741 // Save prefix and move CurPtr past it
1742 const char *Prefix = CurPtr;
1743 CurPtr += PrefixLen + 1; // skip over prefix and '('
1746 char C = *CurPtr++;
1750 if (strncmp(CurPtr, Prefix, PrefixLen) == 0 && CurPtr[PrefixLen] == '"') {
1751 CurPtr += PrefixLen + 1; // skip over prefix and '"'
1754 } else if (C == 0 && CurPtr-1 == BufferEnd) { // End of file.
1758 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1765 CurPtr = LexUDSuffix(Result, CurPtr, true);
1769 FormTokenWithChars(Result, CurPtr, Kind);
1775 void Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {
1777 const char *AfterLessPos = CurPtr;
1778 char C = getAndAdvanceChar(CurPtr, Result);
1783 getAndAdvanceChar(CurPtr, Result);
1785 (C == 0 && (CurPtr-1 == BufferEnd || // End of file.
1786 isCodeCompletionPoint(CurPtr-1)))) {
1792 NulCharacter = CurPtr-1;
1794 C = getAndAdvanceChar(CurPtr, Result);
1803 FormTokenWithChars(Result, CurPtr, tok::angle_string_literal);
1810 void Lexer::LexCharConstant(Token &Result, const char *CurPtr,
1820 char C = getAndAdvanceChar(CurPtr, Result);
1824 FormTokenWithChars(Result, CurPtr, tok::unknown);
1831 C = getAndAdvanceChar(CurPtr, Result);
1834 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1837 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1842 if (isCodeCompletionPoint(CurPtr-1)) {
1844 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1848 NulCharacter = CurPtr-1;
1850 C = getAndAdvanceChar(CurPtr, Result);
1855 CurPtr = LexUDSuffix(Result, CurPtr, false);
1863 FormTokenWithChars(Result, CurPtr, Kind);
1872 bool Lexer::SkipWhitespace(Token &Result, const char *CurPtr) {
1874 bool SawNewline = isVerticalWhitespace(CurPtr[-1]);
1876 unsigned char Char = *CurPtr;
1882 Char = *++CurPtr;
1890 BufferPtr = CurPtr;
1896 Char = *++CurPtr;
1901 FormTokenWithChars(Result, CurPtr, tok::unknown);
1909 char PrevChar = CurPtr[-1];
1916 BufferPtr = CurPtr;
1926 bool Lexer::SkipLineComment(Token &Result, const char *CurPtr) {
1942 C = *CurPtr;
1946 C = *++CurPtr;
1948 const char *NextLine = CurPtr;
1951 const char *EscapePtr = CurPtr-1;
1956 CurPtr = EscapePtr;
1959 CurPtr = EscapePtr-2;
1968 const char *OldPtr = CurPtr;
1971 C = getAndAdvanceChar(CurPtr, Result);
1976 if (C != 0 && CurPtr == OldPtr+1) {
1977 CurPtr = NextLine;
1984 if (CurPtr != OldPtr+1 && C != '/' && CurPtr[0] != '/') {
1985 for (; OldPtr != CurPtr; ++OldPtr)
1990 const char *ForwardPtr = CurPtr;
2003 if (CurPtr == BufferEnd+1) {
2004 --CurPtr;
2008 if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2020 getSourceLocation(CurPtr)))) {
2021 BufferPtr = CurPtr;
2027 return SaveLineComment(Result, CurPtr);
2031 if (ParsingPreprocessorDirective || CurPtr == BufferEnd) {
2032 BufferPtr = CurPtr;
2041 ++CurPtr;
2047 BufferPtr = CurPtr;
2053 bool Lexer::SaveLineComment(Token &Result, const char *CurPtr) {
2056 FormTokenWithChars(Result, CurPtr, tok::comment);
2081 static bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr,
2083 assert(CurPtr[0] == '\n' || CurPtr[0] == '\r');
2086 --CurPtr;
2089 if (CurPtr[0] == '\n' || CurPtr[0] == '\r') {
2091 if (CurPtr[0] == CurPtr[1])
2094 --CurPtr;
2100 while (isHorizontalWhitespace(*CurPtr) || *CurPtr == 0) {
2101 --CurPtr;
2106 if (*CurPtr == '\\') {
2107 if (CurPtr[-1] != '*') return false;
2110 if (CurPtr[0] != '/' || CurPtr[-1] != '?' || CurPtr[-2] != '?' ||
2111 CurPtr[-3] != '*')
2115 CurPtr -= 2;
2121 L->Diag(CurPtr, diag::trigraph_ignored_block_comment);
2125 L->Diag(CurPtr, diag::trigraph_ends_block_comment);
2130 L->Diag(CurPtr, diag::escaped_newline_block_comment_end);
2134 L->Diag(CurPtr, diag::backslash_newline_space);
2155 bool Lexer::SkipBlockComment(Token &Result, const char *CurPtr) {
2165 unsigned char C = getCharAndSize(CurPtr, CharSize);
2166 CurPtr += CharSize;
2167 if (C == 0 && CurPtr == BufferEnd+1) {
2170 --CurPtr;
2175 FormTokenWithChars(Result, CurPtr, tok::unknown);
2179 BufferPtr = CurPtr;
2186 C = *CurPtr++;
2191 if (CurPtr + 24 < BufferEnd &&
2196 while (C != '/' && ((intptr_t)CurPtr & 0x0F) != 0)
2197 C = *CurPtr++;
2203 while (CurPtr+16 <= BufferEnd) {
2204 int cmp = _mm_movemask_epi8(_mm_cmpeq_epi8(*(const __m128i*)CurPtr,
2210 CurPtr += llvm::countTrailingZeros<unsigned>(cmp) + 1;
2213 CurPtr += 16;
2220 while (CurPtr+16 <= BufferEnd &&
2221 !vec_any_eq(*(vector unsigned char*)CurPtr, Slashes))
2222 CurPtr += 16;
2225 while (CurPtr[0] != '/' &&
2226 CurPtr[1] != '/' &&
2227 CurPtr[2] != '/' &&
2228 CurPtr[3] != '/' &&
2229 CurPtr+4 < BufferEnd) {
2230 CurPtr += 4;
2235 C = *CurPtr++;
2240 C = *CurPtr++;
2244 if (CurPtr[-2] == '*') // We found the final */. We're done!
2247 if ((CurPtr[-2] == '\n' || CurPtr[-2] == '\r')) {
2248 if (isEndOfBlockCommentWithEscapedNewLine(CurPtr-2, this)) {
2254 if (CurPtr[0] == '*' && CurPtr[1] != '/') {
2259 Diag(CurPtr-1, diag::warn_nested_block_comment);
2261 } else if (C == 0 && CurPtr == BufferEnd+1) {
2267 --CurPtr;
2272 FormTokenWithChars(Result, CurPtr, tok::unknown);
2276 BufferPtr = CurPtr;
2278 } else if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2284 C = *CurPtr++;
2290 getSourceLocation(CurPtr)))) {
2291 BufferPtr = CurPtr;
2297 FormTokenWithChars(Result, CurPtr, tok::comment);
2305 if (isHorizontalWhitespace(*CurPtr)) {
2306 SkipWhitespace(Result, CurPtr+1);
2311 BufferPtr = CurPtr;
2327 // CurPtr - Cache BufferPtr in an automatic variable.
2328 const char *CurPtr = BufferPtr;
2330 char Char = getAndAdvanceChar(CurPtr, Tmp);
2338 if (CurPtr-1 != BufferEnd) {
2339 if (isCodeCompletionPoint(CurPtr-1)) {
2354 assert(CurPtr[-1] == Char && "Trigraphs for newline?");
2355 BufferPtr = CurPtr-1;
2372 /// LexEndOfFile - CurPtr points to the end of this file. Handle this
2376 bool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {
2384 FormTokenWithChars(Result, CurPtr, tok::eod);
2412 if (CurPtr != BufferStart && (CurPtr[-1] != '\n' && CurPtr[-1] != '\r'))
2417 BufferPtr = CurPtr;
2456 static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
2460 StringRef RestOfBuffer(CurPtr+TermLen, BufferEnd-CurPtr-TermLen);
2479 bool Lexer::IsStartOfConflictMarker(const char *CurPtr) {
2481 if (CurPtr != BufferStart &&
2482 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2486 if ((BufferEnd-CurPtr < 8 || StringRef(CurPtr, 7) != "<<<<<<<") &&
2487 (BufferEnd-CurPtr < 6 || StringRef(CurPtr, 5) != ">>>> "))
2495 ConflictMarkerKind Kind = *CurPtr == '<' ? CMK_Normal : CMK_Perforce;
2499 if (FindConflictEnd(CurPtr, BufferEnd, Kind)) {
2502 Diag(CurPtr, diag::err_conflict_marker);
2507 while (*CurPtr != '\r' && *CurPtr != '\n') {
2508 assert(CurPtr != BufferEnd && "Didn't find end of line");
2509 ++CurPtr;
2511 BufferPtr = CurPtr;
2524 bool Lexer::HandleEndOfConflictMarker(const char *CurPtr) {
2526 if (CurPtr != BufferStart &&
2527 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2537 if (CurPtr[i] != CurPtr[0])
2541 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
2543 if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
2545 CurPtr = End;
2548 while (CurPtr != BufferEnd && *CurPtr != '\r' && *CurPtr != '\n')
2549 ++CurPtr;
2551 BufferPtr = CurPtr;
2561 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
2563 SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
2589 const char *CurPtr = StartPtr + CharSize;
2590 const char *KindLoc = &CurPtr[-1];
2594 char C = getCharAndSize(CurPtr, CharSize);
2620 CurPtr += CharSize;
2625 if (CurPtr - StartPtr == (ptrdiff_t)NumHexDigits + 2)
2626 StartPtr = CurPtr;
2628 while (StartPtr != CurPtr)
2631 StartPtr = CurPtr;
2678 void Lexer::LexUnicode(Token &Result, uint32_t C, const char *CurPtr) {
2682 << makeCharRange(*this, BufferPtr, CurPtr);
2685 if (SkipWhitespace(Result, CurPtr))
2695 makeCharRange(*this, BufferPtr, CurPtr),
2700 return LexIdentifier(Result, CurPtr);
2716 << FixItHint::CreateRemoval(makeCharRange(*this, BufferPtr, CurPtr));
2718 BufferPtr = CurPtr;
2725 FormTokenWithChars(Result, CurPtr, tok::unknown);
2740 // CurPtr - Cache BufferPtr in an automatic variable.
2741 const char *CurPtr = BufferPtr;
2744 if ((*CurPtr == ' ') || (*CurPtr == '\t')) {
2745 ++CurPtr;
2746 while ((*CurPtr == ' ') || (*CurPtr == '\t'))
2747 ++CurPtr;
2753 FormTokenWithChars(Result, CurPtr, tok::unknown);
2758 BufferPtr = CurPtr;
2765 char Char = getAndAdvanceChar(CurPtr, Result);
2771 if (CurPtr-1 == BufferEnd) {
2775 if (LexEndOfFile(Result, CurPtr-1)) // Retreat back into the file.
2782 if (isCodeCompletionPoint(CurPtr-1)) {
2785 FormTokenWithChars(Result, CurPtr, tok::code_completion);
2790 Diag(CurPtr-1, diag::null_in_file);
2792 if (SkipWhitespace(Result, CurPtr))
2803 if (LexEndOfFile(Result, CurPtr-1)) // Retreat back into the file.
2834 if (SkipWhitespace(Result, CurPtr))
2843 if (SkipWhitespace(Result, CurPtr))
2847 CurPtr = BufferPtr;
2851 if (CurPtr[0] == '/' && CurPtr[1] == '/' && !inKeepCommentMode() &&
2853 if (SkipLineComment(Result, CurPtr+2))
2856 } else if (CurPtr[0] == '/' && CurPtr[1] == '*' && !inKeepCommentMode()) {
2857 if (SkipBlockComment(Result, CurPtr+2))
2860 } else if (isHorizontalWhitespace(*CurPtr)) {
2871 return LexNumericConstant(Result, CurPtr);
2878 Char = getCharAndSize(CurPtr, SizeTmp);
2882 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2887 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2892 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
2894 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2899 char Char2 = getCharAndSize(CurPtr + SizeTmp, SizeTmp2);
2904 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2910 char Char3 = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
2914 ConsumeChar(ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2924 return LexIdentifier(Result, CurPtr);
2931 Char = getCharAndSize(CurPtr, SizeTmp);
2935 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2940 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2945 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
2947 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2953 return LexIdentifier(Result, CurPtr);
2960 Char = getCharAndSize(CurPtr, SizeTmp);
2964 ConsumeChar(CurPtr, SizeTmp, Result),
2969 return LexIdentifier(Result, CurPtr);
2974 Char = getCharAndSize(CurPtr, SizeTmp);
2978 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2983 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
2985 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2991 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3007 return LexIdentifier(Result, CurPtr);
3012 Diag(CurPtr-1, diag::ext_dollar_in_identifier);
3015 return LexIdentifier(Result, CurPtr);
3025 return LexCharConstant(Result, CurPtr, tok::char_constant);
3031 return LexStringLiteral(Result, CurPtr, tok::string_literal);
3056 Char = getCharAndSize(CurPtr, SizeTmp);
3061 return LexNumericConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result));
3064 CurPtr += SizeTmp;
3066 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '.') {
3068 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3075 Char = getCharAndSize(CurPtr, SizeTmp);
3078 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3081 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3087 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
3089 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3095 Char = getCharAndSize(CurPtr, SizeTmp);
3097 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3100 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3107 Char = getCharAndSize(CurPtr, SizeTmp);
3109 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3112 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '*') { // C++ ->*
3113 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3117 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3120 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3130 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
3132 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3139 Char = getCharAndSize(CurPtr, SizeTmp);
3152 TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';
3155 if (SkipLineComment(Result, ConsumeChar(CurPtr, SizeTmp, Result)))
3166 CurPtr, SizeTmp, Result)))
3172 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3179 Char = getCharAndSize(CurPtr, SizeTmp);
3182 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3185 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3187 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3188 Char = getCharAndSize(CurPtr, SizeTmp);
3189 if (Char == '%' && getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == ':') {
3191 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3194 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3213 Char = getCharAndSize(CurPtr, SizeTmp);
3215 return LexAngledStringLiteral(Result, CurPtr);
3217 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
3220 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3222 } else if (After == '<' && IsStartOfConflictMarker(CurPtr-1)) {
3226 } else if (After == '<' && HandleEndOfConflictMarker(CurPtr-1)) {
3232 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3235 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3239 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3243 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == ':') {
3250 char After = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3259 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3262 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3269 Char = getCharAndSize(CurPtr, SizeTmp);
3271 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3274 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
3276 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3279 } else if (After == '>' && IsStartOfConflictMarker(CurPtr-1)) {
3283 } else if (After == '>' && HandleEndOfConflictMarker(CurPtr-1)) {
3288 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3291 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3300 Char = getCharAndSize(CurPtr, SizeTmp);
3302 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3309 Char = getCharAndSize(CurPtr, SizeTmp);
3312 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3315 if (CurPtr[1] == '|' && HandleEndOfConflictMarker(CurPtr-1))
3318 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3324 Char = getCharAndSize(CurPtr, SizeTmp);
3327 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3330 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3339 Char = getCharAndSize(CurPtr, SizeTmp);
3342 if (CurPtr[1] == '=' && HandleEndOfConflictMarker(CurPtr-1))
3346 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3355 Char = getCharAndSize(CurPtr, SizeTmp);
3358 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3363 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3378 if (CurPtr[-1] == '@' && LangOpts.ObjC1)
3386 if (uint32_t CodePoint = tryReadUCN(CurPtr, BufferPtr, &Result))
3387 return LexUnicode(Result, CodePoint, CurPtr);
3400 // We can't just reset CurPtr to BufferPtr because BufferPtr may point to
3402 --CurPtr;
3404 llvm::convertUTF8Sequence((const UTF8 **)&CurPtr,
3409 return LexUnicode(Result, CodePoint, CurPtr);
3413 ++CurPtr;
3421 Diag(CurPtr, diag::err_invalid_utf8);
3423 BufferPtr = CurPtr+1;
3432 FormTokenWithChars(Result, CurPtr, Kind);
3438 FormTokenWithChars(Result, CurPtr, tok::hash);
