Lines Matching refs:CurPtr
579 const char *CurPtr = Buffer->getBufferStart();
581 while (CurPtr != Buffer->getBufferEnd()) {
582 char ch = *CurPtr++;
589 if (CurPtr != Buffer->getBufferEnd())
590 MaxLineOffset = CurPtr - Buffer->getBufferStart();
1450 bool Lexer::LexIdentifier(Token &Result, const char *CurPtr) {
1453 unsigned char C = *CurPtr++;
1455 C = *CurPtr++;
1457 --CurPtr; // Back up over the skipped character.
1468 FormTokenWithChars(Result, CurPtr, tok::raw_identifier);
1490 C = getCharAndSize(CurPtr, Size);
1498 Diag(CurPtr, diag::ext_dollar_in_identifier);
1499 CurPtr = ConsumeChar(CurPtr, Size, Result);
1500 C = getCharAndSize(CurPtr, Size);
1504 const char *UCNPtr = CurPtr + Size;
1505 uint32_t CodePoint = tryReadUCN(UCNPtr, CurPtr, /*Token=*/0);
1511 makeCharRange(*this, CurPtr, UCNPtr),
1516 if ((UCNPtr - CurPtr == 6 && CurPtr[1] == 'u') ||
1517 (UCNPtr - CurPtr == 10 && CurPtr[1] == 'U'))
1518 CurPtr = UCNPtr;
1520 while (CurPtr != UCNPtr)
1521 (void)getAndAdvanceChar(CurPtr, Result);
1523 C = getCharAndSize(CurPtr, Size);
1526 const char *UnicodePtr = CurPtr;
1539 makeCharRange(*this, CurPtr, UnicodePtr),
1543 CurPtr = UnicodePtr;
1544 C = getCharAndSize(CurPtr, Size);
1551 CurPtr = ConsumeChar(CurPtr, Size, Result);
1553 C = getCharAndSize(CurPtr, Size);
1555 CurPtr = ConsumeChar(CurPtr, Size, Result);
1556 C = getCharAndSize(CurPtr, Size);
1575 bool Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {
1577 char C = getCharAndSize(CurPtr, Size);
1580 CurPtr = ConsumeChar(CurPtr, Size, Result);
1582 C = getCharAndSize(CurPtr, Size);
1590 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1602 else if (std::find(BufferPtr, CurPtr, '_') != CurPtr)
1606 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1612 char Next = getCharAndSizeNoWarn(CurPtr + Size, NextSize, getLangOpts());
1615 Diag(CurPtr, diag::warn_cxx11_compat_digit_separator);
1616 CurPtr = ConsumeChar(CurPtr, Size, Result);
1617 return LexNumericConstant(Result, CurPtr);
1623 FormTokenWithChars(Result, CurPtr, tok::numeric_constant);
1630 const char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr,
1636 char C = getCharAndSize(CurPtr, Size);
1640 Diag(CurPtr,
1643 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
1644 return CurPtr;
1664 char Next = getCharAndSizeNoWarn(CurPtr + Consumed, NextSize,
1685 Diag(CurPtr, getLangOpts().MicrosoftMode ?
1688 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
1689 return CurPtr;
1694 CurPtr = ConsumeChar(CurPtr, Size, Result);
1695 C = getCharAndSize(CurPtr, Size);
1698 return CurPtr;
1703 bool Lexer::LexStringLiteral(Token &Result, const char *CurPtr,
1715 char C = getAndAdvanceChar(CurPtr, Result);
1720 C = getAndAdvanceChar(CurPtr, Result);
1723 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1726 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1731 if (isCodeCompletionPoint(CurPtr-1)) {
1733 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1738 NulCharacter = CurPtr-1;
1740 C = getAndAdvanceChar(CurPtr, Result);
1745 CurPtr = LexUDSuffix(Result, CurPtr, true);
1753 FormTokenWithChars(Result, CurPtr, Kind);
1760 bool Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr,
1772 while (PrefixLen != 16 && isRawStringDelimBody(CurPtr[PrefixLen]))
1776 if (CurPtr[PrefixLen] != '(') {
1778 const char *PrefixEnd = &CurPtr[PrefixLen];
1791 char C = *CurPtr++;
1795 if (C == 0 && CurPtr-1 == BufferEnd) {
1796 --CurPtr;
1801 FormTokenWithChars(Result, CurPtr, tok::unknown);
1805 // Save prefix and move CurPtr past it
1806 const char *Prefix = CurPtr;
1807 CurPtr += PrefixLen + 1; // skip over prefix and '('
1810 char C = *CurPtr++;
1814 if (strncmp(CurPtr, Prefix, PrefixLen) == 0 && CurPtr[PrefixLen] == '"') {
1815 CurPtr += PrefixLen + 1; // skip over prefix and '"'
1818 } else if (C == 0 && CurPtr-1 == BufferEnd) { // End of file.
1822 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1829 CurPtr = LexUDSuffix(Result, CurPtr, true);
1833 FormTokenWithChars(Result, CurPtr, Kind);
1840 bool Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {
1842 const char *AfterLessPos = CurPtr;
1843 char C = getAndAdvanceChar(CurPtr, Result);
1848 getAndAdvanceChar(CurPtr, Result);
1850 (C == 0 && (CurPtr-1 == BufferEnd || // End of file.
1851 isCodeCompletionPoint(CurPtr-1)))) {
1857 NulCharacter = CurPtr-1;
1859 C = getAndAdvanceChar(CurPtr, Result);
1868 FormTokenWithChars(Result, CurPtr, tok::angle_string_literal);
1876 bool Lexer::LexCharConstant(Token &Result, const char *CurPtr,
1886 char C = getAndAdvanceChar(CurPtr, Result);
1890 FormTokenWithChars(Result, CurPtr, tok::unknown);
1897 C = getAndAdvanceChar(CurPtr, Result);
1900 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1903 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1908 if (isCodeCompletionPoint(CurPtr-1)) {
1910 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1915 NulCharacter = CurPtr-1;
1917 C = getAndAdvanceChar(CurPtr, Result);
1922 CurPtr = LexUDSuffix(Result, CurPtr, false);
1930 FormTokenWithChars(Result, CurPtr, Kind);
1940 bool Lexer::SkipWhitespace(Token &Result, const char *CurPtr,
1943 bool SawNewline = isVerticalWhitespace(CurPtr[-1]);
1945 unsigned char Char = *CurPtr;
1951 Char = *++CurPtr;
1959 BufferPtr = CurPtr;
1965 Char = *++CurPtr;
1970 FormTokenWithChars(Result, CurPtr, tok::unknown);
1980 char PrevChar = CurPtr[-1];
1989 BufferPtr = CurPtr;
1999 bool Lexer::SkipLineComment(Token &Result, const char *CurPtr,
2016 C = *CurPtr;
2020 C = *++CurPtr;
2022 const char *NextLine = CurPtr;
2025 const char *EscapePtr = CurPtr-1;
2030 CurPtr = EscapePtr;
2033 CurPtr = EscapePtr-2;
2042 const char *OldPtr = CurPtr;
2045 C = getAndAdvanceChar(CurPtr, Result);
2050 if (C != 0 && CurPtr == OldPtr+1) {
2051 CurPtr = NextLine;
2058 if (CurPtr != OldPtr+1 && C != '/' && CurPtr[0] != '/') {
2059 for (; OldPtr != CurPtr; ++OldPtr)
2064 const char *ForwardPtr = CurPtr;
2077 if (CurPtr == BufferEnd+1) {
2078 --CurPtr;
2082 if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2094 getSourceLocation(CurPtr)))) {
2095 BufferPtr = CurPtr;
2101 return SaveLineComment(Result, CurPtr);
2105 if (ParsingPreprocessorDirective || CurPtr == BufferEnd) {
2106 BufferPtr = CurPtr;
2115 ++CurPtr;
2122 BufferPtr = CurPtr;
2128 bool Lexer::SaveLineComment(Token &Result, const char *CurPtr) {
2131 FormTokenWithChars(Result, CurPtr, tok::comment);
2156 static bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr,
2158 assert(CurPtr[0] == '\n' || CurPtr[0] == '\r');
2161 --CurPtr;
2164 if (CurPtr[0] == '\n' || CurPtr[0] == '\r') {
2166 if (CurPtr[0] == CurPtr[1])
2169 --CurPtr;
2175 while (isHorizontalWhitespace(*CurPtr) || *CurPtr == 0) {
2176 --CurPtr;
2181 if (*CurPtr == '\\') {
2182 if (CurPtr[-1] != '*') return false;
2185 if (CurPtr[0] != '/' || CurPtr[-1] != '?' || CurPtr[-2] != '?' ||
2186 CurPtr[-3] != '*')
2190 CurPtr -= 2;
2196 L->Diag(CurPtr, diag::trigraph_ignored_block_comment);
2200 L->Diag(CurPtr, diag::trigraph_ends_block_comment);
2205 L->Diag(CurPtr, diag::escaped_newline_block_comment_end);
2209 L->Diag(CurPtr, diag::backslash_newline_space);
2230 bool Lexer::SkipBlockComment(Token &Result, const char *CurPtr,
2241 unsigned char C = getCharAndSize(CurPtr, CharSize);
2242 CurPtr += CharSize;
2243 if (C == 0 && CurPtr == BufferEnd+1) {
2246 --CurPtr;
2251 FormTokenWithChars(Result, CurPtr, tok::unknown);
2255 BufferPtr = CurPtr;
2262 C = *CurPtr++;
2267 if (CurPtr + 24 < BufferEnd &&
2272 while (C != '/' && ((intptr_t)CurPtr & 0x0F) != 0)
2273 C = *CurPtr++;
2279 while (CurPtr+16 <= BufferEnd) {
2280 int cmp = _mm_movemask_epi8(_mm_cmpeq_epi8(*(const __m128i*)CurPtr,
2286 CurPtr += llvm::countTrailingZeros<unsigned>(cmp) + 1;
2289 CurPtr += 16;
2296 while (CurPtr+16 <= BufferEnd &&
2297 !vec_any_eq(*(vector unsigned char*)CurPtr, Slashes))
2298 CurPtr += 16;
2301 while (CurPtr[0] != '/' &&
2302 CurPtr[1] != '/' &&
2303 CurPtr[2] != '/' &&
2304 CurPtr[3] != '/' &&
2305 CurPtr+4 < BufferEnd) {
2306 CurPtr += 4;
2311 C = *CurPtr++;
2316 C = *CurPtr++;
2320 if (CurPtr[-2] == '*') // We found the final */. We're done!
2323 if ((CurPtr[-2] == '\n' || CurPtr[-2] == '\r')) {
2324 if (isEndOfBlockCommentWithEscapedNewLine(CurPtr-2, this)) {
2330 if (CurPtr[0] == '*' && CurPtr[1] != '/') {
2335 Diag(CurPtr-1, diag::warn_nested_block_comment);
2337 } else if (C == 0 && CurPtr == BufferEnd+1) {
2343 --CurPtr;
2348 FormTokenWithChars(Result, CurPtr, tok::unknown);
2352 BufferPtr = CurPtr;
2354 } else if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2360 C = *CurPtr++;
2366 getSourceLocation(CurPtr)))) {
2367 BufferPtr = CurPtr;
2373 FormTokenWithChars(Result, CurPtr, tok::comment);
2381 if (isHorizontalWhitespace(*CurPtr)) {
2382 SkipWhitespace(Result, CurPtr+1, TokAtPhysicalStartOfLine);
2387 BufferPtr = CurPtr;
2403 // CurPtr - Cache BufferPtr in an automatic variable.
2404 const char *CurPtr = BufferPtr;
2406 char Char = getAndAdvanceChar(CurPtr, Tmp);
2414 if (CurPtr-1 != BufferEnd) {
2415 if (isCodeCompletionPoint(CurPtr-1)) {
2430 assert(CurPtr[-1] == Char && "Trigraphs for newline?");
2431 BufferPtr = CurPtr-1;
2448 /// LexEndOfFile - CurPtr points to the end of this file. Handle this
2452 bool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {
2460 FormTokenWithChars(Result, CurPtr, tok::eod);
2488 if (CurPtr != BufferStart && (CurPtr[-1] != '\n' && CurPtr[-1] != '\r')) {
2511 BufferPtr = CurPtr;
2555 static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
2559 StringRef RestOfBuffer(CurPtr+TermLen, BufferEnd-CurPtr-TermLen);
2578 bool Lexer::IsStartOfConflictMarker(const char *CurPtr) {
2580 if (CurPtr != BufferStart &&
2581 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2585 if ((BufferEnd-CurPtr < 8 || StringRef(CurPtr, 7) != "<<<<<<<") &&
2586 (BufferEnd-CurPtr < 6 || StringRef(CurPtr, 5) != ">>>> "))
2594 ConflictMarkerKind Kind = *CurPtr == '<' ? CMK_Normal : CMK_Perforce;
2598 if (FindConflictEnd(CurPtr, BufferEnd, Kind)) {
2601 Diag(CurPtr, diag::err_conflict_marker);
2606 while (*CurPtr != '\r' && *CurPtr != '\n') {
2607 assert(CurPtr != BufferEnd && "Didn't find end of line");
2608 ++CurPtr;
2610 BufferPtr = CurPtr;
2623 bool Lexer::HandleEndOfConflictMarker(const char *CurPtr) {
2625 if (CurPtr != BufferStart &&
2626 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2636 if (CurPtr[i] != CurPtr[0])
2640 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
2642 if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
2644 CurPtr = End;
2647 while (CurPtr != BufferEnd && *CurPtr != '\r' && *CurPtr != '\n')
2648 ++CurPtr;
2650 BufferPtr = CurPtr;
2660 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
2662 SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
2688 const char *CurPtr = StartPtr + CharSize;
2689 const char *KindLoc = &CurPtr[-1];
2693 char C = getCharAndSize(CurPtr, CharSize);
2719 CurPtr += CharSize;
2724 if (CurPtr - StartPtr == (ptrdiff_t)NumHexDigits + 2)
2725 StartPtr = CurPtr;
2727 while (StartPtr != CurPtr)
2730 StartPtr = CurPtr;
2782 const char *CurPtr) {
2788 << makeCharRange(*this, BufferPtr, CurPtr);
2796 bool Lexer::LexUnicode(Token &Result, uint32_t C, const char *CurPtr) {
2801 makeCharRange(*this, BufferPtr, CurPtr),
2806 return LexIdentifier(Result, CurPtr);
2822 << FixItHint::CreateRemoval(makeCharRange(*this, BufferPtr, CurPtr));
2824 BufferPtr = CurPtr;
2831 FormTokenWithChars(Result, CurPtr, tok::unknown);
2883 // CurPtr - Cache BufferPtr in an automatic variable.
2884 const char *CurPtr = BufferPtr;
2887 if ((*CurPtr == ' ') || (*CurPtr == '\t')) {
2888 ++CurPtr;
2889 while ((*CurPtr == ' ') || (*CurPtr == '\t'))
2890 ++CurPtr;
2896 FormTokenWithChars(Result, CurPtr, tok::unknown);
2901 BufferPtr = CurPtr;
2908 char Char = getAndAdvanceChar(CurPtr, Result);
2914 if (CurPtr-1 == BufferEnd)
2915 return LexEndOfFile(Result, CurPtr-1);
2918 if (isCodeCompletionPoint(CurPtr-1)) {
2921 FormTokenWithChars(Result, CurPtr, tok::code_completion);
2926 Diag(CurPtr-1, diag::null_in_file);
2928 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
2938 return LexEndOfFile(Result, CurPtr-1);
2967 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
2979 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
2983 CurPtr = BufferPtr;
2987 if (CurPtr[0] == '/' && CurPtr[1] == '/' && !inKeepCommentMode() &&
2990 if (SkipLineComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
2993 } else if (CurPtr[0] == '/' && CurPtr[1] == '*' && !inKeepCommentMode()) {
2994 if (SkipBlockComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
2997 } else if (isHorizontalWhitespace(*CurPtr)) {
3010 return LexNumericConstant(Result, CurPtr);
3017 Char = getCharAndSize(CurPtr, SizeTmp);
3021 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3026 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3031 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3033 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3038 char Char2 = getCharAndSize(CurPtr + SizeTmp, SizeTmp2);
3043 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3049 char Char3 = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3053 ConsumeChar(ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3063 return LexIdentifier(Result, CurPtr);
3070 Char = getCharAndSize(CurPtr, SizeTmp);
3074 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3079 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3084 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3086 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3092 return LexIdentifier(Result, CurPtr);
3099 Char = getCharAndSize(CurPtr, SizeTmp);
3103 ConsumeChar(CurPtr, SizeTmp, Result),
3108 return LexIdentifier(Result, CurPtr);
3113 Char = getCharAndSize(CurPtr, SizeTmp);
3117 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3122 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3124 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3130 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3146 return LexIdentifier(Result, CurPtr);
3151 Diag(CurPtr-1, diag::ext_dollar_in_identifier);
3154 return LexIdentifier(Result, CurPtr);
3164 return LexCharConstant(Result, CurPtr, tok::char_constant);
3170 return LexStringLiteral(Result, CurPtr, tok::string_literal);
3195 Char = getCharAndSize(CurPtr, SizeTmp);
3200 return LexNumericConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result));
3203 CurPtr += SizeTmp;
3205 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '.') {
3207 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3214 Char = getCharAndSize(CurPtr, SizeTmp);
3217 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3220 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3226 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
3228 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3234 Char = getCharAndSize(CurPtr, SizeTmp);
3236 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3239 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3246 Char = getCharAndSize(CurPtr, SizeTmp);
3248 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3251 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '*') { // C++ ->*
3252 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3256 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3259 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3269 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
3271 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3278 Char = getCharAndSize(CurPtr, SizeTmp);
3292 TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';
3295 if (SkipLineComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3307 if (SkipBlockComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3317 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3324 Char = getCharAndSize(CurPtr, SizeTmp);
3327 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3330 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3332 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3333 Char = getCharAndSize(CurPtr, SizeTmp);
3334 if (Char == '%' && getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == ':') {
3336 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3339 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3358 Char = getCharAndSize(CurPtr, SizeTmp);
3360 return LexAngledStringLiteral(Result, CurPtr);
3362 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
3365 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3367 } else if (After == '<' && IsStartOfConflictMarker(CurPtr-1)) {
3371 } else if (After == '<' && HandleEndOfConflictMarker(CurPtr-1)) {
3377 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3380 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3384 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3388 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == ':') {
3395 char After = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3404 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3407 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3414 Char = getCharAndSize(CurPtr, SizeTmp);
3416 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3419 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
3421 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3424 } else if (After == '>' && IsStartOfConflictMarker(CurPtr-1)) {
3428 } else if (After == '>' && HandleEndOfConflictMarker(CurPtr-1)) {
3433 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3436 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3445 Char = getCharAndSize(CurPtr, SizeTmp);
3447 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3454 Char = getCharAndSize(CurPtr, SizeTmp);
3457 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3460 if (CurPtr[1] == '|' && HandleEndOfConflictMarker(CurPtr-1))
3463 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3469 Char = getCharAndSize(CurPtr, SizeTmp);
3472 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3475 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3484 Char = getCharAndSize(CurPtr, SizeTmp);
3487 if (CurPtr[1] == '=' && HandleEndOfConflictMarker(CurPtr-1))
3491 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3500 Char = getCharAndSize(CurPtr, SizeTmp);
3503 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3508 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3523 if (CurPtr[-1] == '@' && LangOpts.ObjC1)
3531 if (uint32_t CodePoint = tryReadUCN(CurPtr, BufferPtr, &Result)) {
3532 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
3533 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3541 return LexUnicode(Result, CodePoint, CurPtr);
3555 // We can't just reset CurPtr to BufferPtr because BufferPtr may point to
3557 --CurPtr;
3559 llvm::convertUTF8Sequence((const UTF8 **)&CurPtr,
3564 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
3565 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3572 return LexUnicode(Result, CodePoint, CurPtr);
3577 ++CurPtr;
3585 Diag(CurPtr, diag::err_invalid_utf8);
3587 BufferPtr = CurPtr+1;
3599 FormTokenWithChars(Result, CurPtr, Kind);
3605 FormTokenWithChars(Result, CurPtr, tok::hash);