Lines Matching defs:CurPtr
560 const char *CurPtr = Buffer.begin();
562 while (CurPtr != Buffer.end()) {
563 char ch = *CurPtr++;
570 if (CurPtr != Buffer.end())
571 MaxLineOffset = CurPtr - Buffer.begin();
1428 bool Lexer::tryConsumeIdentifierUCN(const char *&CurPtr, unsigned Size,
1430 const char *UCNPtr = CurPtr + Size;
1431 uint32_t CodePoint = tryReadUCN(UCNPtr, CurPtr, /*Token=*/nullptr);
1437 makeCharRange(*this, CurPtr, UCNPtr),
1441 if ((UCNPtr - CurPtr == 6 && CurPtr[1] == 'u') ||
1442 (UCNPtr - CurPtr == 10 && CurPtr[1] == 'U'))
1443 CurPtr = UCNPtr;
1445 while (CurPtr != UCNPtr)
1446 (void)getAndAdvanceChar(CurPtr, Result);
1450 bool Lexer::tryConsumeIdentifierUTF8Char(const char *&CurPtr) {
1451 const char *UnicodePtr = CurPtr;
1464 makeCharRange(*this, CurPtr, UnicodePtr),
1467 CurPtr = UnicodePtr;
1471 bool Lexer::LexIdentifier(Token &Result, const char *CurPtr) {
1474 unsigned char C = *CurPtr++;
1476 C = *CurPtr++;
1478 --CurPtr; // Back up over the skipped character.
1489 FormTokenWithChars(Result, CurPtr, tok::raw_identifier);
1511 C = getCharAndSize(CurPtr, Size);
1519 Diag(CurPtr, diag::ext_dollar_in_identifier);
1520 CurPtr = ConsumeChar(CurPtr, Size, Result);
1521 C = getCharAndSize(CurPtr, Size);
1524 } else if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result)) {
1525 C = getCharAndSize(CurPtr, Size);
1527 } else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr)) {
1528 C = getCharAndSize(CurPtr, Size);
1535 CurPtr = ConsumeChar(CurPtr, Size, Result);
1537 C = getCharAndSize(CurPtr, Size);
1539 CurPtr = ConsumeChar(CurPtr, Size, Result);
1540 C = getCharAndSize(CurPtr, Size);
1559 bool Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {
1561 char C = getCharAndSize(CurPtr, Size);
1564 CurPtr = ConsumeChar(CurPtr, Size, Result);
1566 C = getCharAndSize(CurPtr, Size);
1574 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1586 else if (std::find(BufferPtr, CurPtr, '_') != CurPtr)
1590 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1596 char Next = getCharAndSizeNoWarn(CurPtr + Size, NextSize, getLangOpts());
1599 Diag(CurPtr, diag::warn_cxx11_compat_digit_separator);
1600 CurPtr = ConsumeChar(CurPtr, Size, Result);
1601 CurPtr = ConsumeChar(CurPtr, NextSize, Result);
1602 return LexNumericConstant(Result, CurPtr);
1607 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
1608 return LexNumericConstant(Result, CurPtr);
1609 if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr))
1610 return LexNumericConstant(Result, CurPtr);
1614 FormTokenWithChars(Result, CurPtr, tok::numeric_constant);
1621 const char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr,
1627 char C = getCharAndSize(CurPtr, Size);
1631 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
1633 else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr))
1636 return CurPtr;
1641 Diag(CurPtr,
1644 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
1645 return CurPtr;
1667 char Next = getCharAndSizeNoWarn(CurPtr + Consumed, NextSize,
1688 Diag(CurPtr, getLangOpts().MSVCCompat
1691 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
1692 return CurPtr;
1695 CurPtr = ConsumeChar(CurPtr, Size, Result);
1700 C = getCharAndSize(CurPtr, Size);
1701 if (isIdentifierBody(C)) { CurPtr = ConsumeChar(CurPtr, Size, Result); }
1702 else if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result)) {}
1703 else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr)) {}
1707 return CurPtr;
1712 bool Lexer::LexStringLiteral(Token &Result, const char *CurPtr,
1725 char C = getAndAdvanceChar(CurPtr, Result);
1730 C = getAndAdvanceChar(CurPtr, Result);
1733 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1736 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1741 if (isCodeCompletionPoint(CurPtr-1)) {
1743 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1748 NulCharacter = CurPtr-1;
1750 C = getAndAdvanceChar(CurPtr, Result);
1755 CurPtr = LexUDSuffix(Result, CurPtr, true);
1763 FormTokenWithChars(Result, CurPtr, Kind);
1770 bool Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr,
1782 while (PrefixLen != 16 && isRawStringDelimBody(CurPtr[PrefixLen]))
1786 if (CurPtr[PrefixLen] != '(') {
1788 const char *PrefixEnd = &CurPtr[PrefixLen];
1801 char C = *CurPtr++;
1805 if (C == 0 && CurPtr-1 == BufferEnd) {
1806 --CurPtr;
1811 FormTokenWithChars(Result, CurPtr, tok::unknown);
1815 // Save prefix and move CurPtr past it
1816 const char *Prefix = CurPtr;
1817 CurPtr += PrefixLen + 1; // skip over prefix and '('
1820 char C = *CurPtr++;
1824 if (strncmp(CurPtr, Prefix, PrefixLen) == 0 && CurPtr[PrefixLen] == '"') {
1825 CurPtr += PrefixLen + 1; // skip over prefix and '"'
1828 } else if (C == 0 && CurPtr-1 == BufferEnd) { // End of file.
1832 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1839 CurPtr = LexUDSuffix(Result, CurPtr, true);
1843 FormTokenWithChars(Result, CurPtr, Kind);
1850 bool Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {
1853 const char *AfterLessPos = CurPtr;
1854 char C = getAndAdvanceChar(CurPtr, Result);
1859 getAndAdvanceChar(CurPtr, Result);
1861 (C == 0 && (CurPtr-1 == BufferEnd || // End of file.
1862 isCodeCompletionPoint(CurPtr-1)))) {
1868 NulCharacter = CurPtr-1;
1870 C = getAndAdvanceChar(CurPtr, Result);
1879 FormTokenWithChars(Result, CurPtr, tok::angle_string_literal);
1887 bool Lexer::LexCharConstant(Token &Result, const char *CurPtr,
1901 char C = getAndAdvanceChar(CurPtr, Result);
1905 FormTokenWithChars(Result, CurPtr, tok::unknown);
1912 C = getAndAdvanceChar(CurPtr, Result);
1915 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1918 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1923 if (isCodeCompletionPoint(CurPtr-1)) {
1925 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1930 NulCharacter = CurPtr-1;
1932 C = getAndAdvanceChar(CurPtr, Result);
1937 CurPtr = LexUDSuffix(Result, CurPtr, false);
1945 FormTokenWithChars(Result, CurPtr, Kind);
1955 bool Lexer::SkipWhitespace(Token &Result, const char *CurPtr,
1958 bool SawNewline = isVerticalWhitespace(CurPtr[-1]);
1960 unsigned char Char = *CurPtr;
1966 Char = *++CurPtr;
1974 BufferPtr = CurPtr;
1980 Char = *++CurPtr;
1985 FormTokenWithChars(Result, CurPtr, tok::unknown);
1995 char PrevChar = CurPtr[-1];
2004 BufferPtr = CurPtr;
2014 bool Lexer::SkipLineComment(Token &Result, const char *CurPtr,
2031 C = *CurPtr;
2035 C = *++CurPtr;
2037 const char *NextLine = CurPtr;
2040 const char *EscapePtr = CurPtr-1;
2048 CurPtr = EscapePtr;
2051 CurPtr = EscapePtr-2;
2064 const char *OldPtr = CurPtr;
2067 C = getAndAdvanceChar(CurPtr, Result);
2072 if (C != 0 && CurPtr == OldPtr+1) {
2073 CurPtr = NextLine;
2080 if (CurPtr != OldPtr+1 && C != '/' && CurPtr[0] != '/') {
2081 for (; OldPtr != CurPtr; ++OldPtr)
2086 const char *ForwardPtr = CurPtr;
2099 if (CurPtr == BufferEnd+1) {
2100 --CurPtr;
2104 if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2116 getSourceLocation(CurPtr)))) {
2117 BufferPtr = CurPtr;
2123 return SaveLineComment(Result, CurPtr);
2127 if (ParsingPreprocessorDirective || CurPtr == BufferEnd) {
2128 BufferPtr = CurPtr;
2137 ++CurPtr;
2144 BufferPtr = CurPtr;
2150 bool Lexer::SaveLineComment(Token &Result, const char *CurPtr) {
2153 FormTokenWithChars(Result, CurPtr, tok::comment);
2178 static bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr,
2180 assert(CurPtr[0] == '\n' || CurPtr[0] == '\r');
2183 --CurPtr;
2186 if (CurPtr[0] == '\n' || CurPtr[0] == '\r') {
2188 if (CurPtr[0] == CurPtr[1])
2191 --CurPtr;
2197 while (isHorizontalWhitespace(*CurPtr) || *CurPtr == 0) {
2198 --CurPtr;
2203 if (*CurPtr == '\\') {
2204 if (CurPtr[-1] != '*') return false;
2207 if (CurPtr[0] != '/' || CurPtr[-1] != '?' || CurPtr[-2] != '?' ||
2208 CurPtr[-3] != '*')
2212 CurPtr -= 2;
2218 L->Diag(CurPtr, diag::trigraph_ignored_block_comment);
2222 L->Diag(CurPtr, diag::trigraph_ends_block_comment);
2227 L->Diag(CurPtr, diag::escaped_newline_block_comment_end);
2231 L->Diag(CurPtr, diag::backslash_newline_space);
2252 bool Lexer::SkipBlockComment(Token &Result, const char *CurPtr,
2263 unsigned char C = getCharAndSize(CurPtr, CharSize);
2264 CurPtr += CharSize;
2265 if (C == 0 && CurPtr == BufferEnd+1) {
2268 --CurPtr;
2273 FormTokenWithChars(Result, CurPtr, tok::unknown);
2277 BufferPtr = CurPtr;
2284 C = *CurPtr++;
2289 if (CurPtr + 24 < BufferEnd &&
2294 while (C != '/' && ((intptr_t)CurPtr & 0x0F) != 0)
2295 C = *CurPtr++;
2301 while (CurPtr+16 <= BufferEnd) {
2302 int cmp = _mm_movemask_epi8(_mm_cmpeq_epi8(*(const __m128i*)CurPtr,
2308 CurPtr += llvm::countTrailingZeros<unsigned>(cmp) + 1;
2311 CurPtr += 16;
2318 while (CurPtr+16 <= BufferEnd &&
2319 !vec_any_eq(*(const vector unsigned char*)CurPtr, Slashes))
2320 CurPtr += 16;
2323 while (CurPtr[0] != '/' &&
2324 CurPtr[1] != '/' &&
2325 CurPtr[2] != '/' &&
2326 CurPtr[3] != '/' &&
2327 CurPtr+4 < BufferEnd) {
2328 CurPtr += 4;
2333 C = *CurPtr++;
2338 C = *CurPtr++;
2342 if (CurPtr[-2] == '*') // We found the final */. We're done!
2345 if ((CurPtr[-2] == '\n' || CurPtr[-2] == '\r')) {
2346 if (isEndOfBlockCommentWithEscapedNewLine(CurPtr-2, this)) {
2352 if (CurPtr[0] == '*' && CurPtr[1] != '/') {
2357 Diag(CurPtr-1, diag::warn_nested_block_comment);
2359 } else if (C == 0 && CurPtr == BufferEnd+1) {
2365 --CurPtr;
2370 FormTokenWithChars(Result, CurPtr, tok::unknown);
2374 BufferPtr = CurPtr;
2376 } else if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2382 C = *CurPtr++;
2388 getSourceLocation(CurPtr)))) {
2389 BufferPtr = CurPtr;
2395 FormTokenWithChars(Result, CurPtr, tok::comment);
2403 if (isHorizontalWhitespace(*CurPtr)) {
2404 SkipWhitespace(Result, CurPtr+1, TokAtPhysicalStartOfLine);
2409 BufferPtr = CurPtr;
2425 // CurPtr - Cache BufferPtr in an automatic variable.
2426 const char *CurPtr = BufferPtr;
2428 char Char = getAndAdvanceChar(CurPtr, Tmp);
2436 if (CurPtr-1 != BufferEnd) {
2437 if (isCodeCompletionPoint(CurPtr-1)) {
2452 assert(CurPtr[-1] == Char && "Trigraphs for newline?");
2453 BufferPtr = CurPtr-1;
2470 /// LexEndOfFile - CurPtr points to the end of this file. Handle this
2474 bool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {
2482 FormTokenWithChars(Result, CurPtr, tok::eod);
2511 if (CurPtr != BufferStart && (CurPtr[-1] != '\n' && CurPtr[-1] != '\r')) {
2533 BufferPtr = CurPtr;
2577 static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
2581 StringRef RestOfBuffer(CurPtr+TermLen, BufferEnd-CurPtr-TermLen);
2600 bool Lexer::IsStartOfConflictMarker(const char *CurPtr) {
2602 if (CurPtr != BufferStart &&
2603 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2607 if ((BufferEnd-CurPtr < 8 || StringRef(CurPtr, 7) != "<<<<<<<") &&
2608 (BufferEnd-CurPtr < 6 || StringRef(CurPtr, 5) != ">>>> "))
2616 ConflictMarkerKind Kind = *CurPtr == '<' ? CMK_Normal : CMK_Perforce;
2620 if (FindConflictEnd(CurPtr, BufferEnd, Kind)) {
2623 Diag(CurPtr, diag::err_conflict_marker);
2628 while (*CurPtr != '\r' && *CurPtr != '\n') {
2629 assert(CurPtr != BufferEnd && "Didn't find end of line");
2630 ++CurPtr;
2632 BufferPtr = CurPtr;
2645 bool Lexer::HandleEndOfConflictMarker(const char *CurPtr) {
2647 if (CurPtr != BufferStart &&
2648 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2658 if (CurPtr[i] != CurPtr[0])
2662 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
2664 if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
2666 CurPtr = End;
2669 while (CurPtr != BufferEnd && *CurPtr != '\r' && *CurPtr != '\n')
2670 ++CurPtr;
2672 BufferPtr = CurPtr;
2682 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
2684 SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
2710 const char *CurPtr = StartPtr + CharSize;
2711 const char *KindLoc = &CurPtr[-1];
2715 char C = getCharAndSize(CurPtr, CharSize);
2741 CurPtr += CharSize;
2746 if (CurPtr - StartPtr == (ptrdiff_t)NumHexDigits + 2)
2747 StartPtr = CurPtr;
2749 while (StartPtr != CurPtr)
2752 StartPtr = CurPtr;
2804 const char *CurPtr) {
2810 << makeCharRange(*this, BufferPtr, CurPtr);
2818 bool Lexer::LexUnicode(Token &Result, uint32_t C, const char *CurPtr) {
2823 makeCharRange(*this, BufferPtr, CurPtr),
2828 return LexIdentifier(Result, CurPtr);
2844 << FixItHint::CreateRemoval(makeCharRange(*this, BufferPtr, CurPtr));
2846 BufferPtr = CurPtr;
2853 FormTokenWithChars(Result, CurPtr, tok::unknown);
2905 // CurPtr - Cache BufferPtr in an automatic variable.
2906 const char *CurPtr = BufferPtr;
2909 if ((*CurPtr == ' ') || (*CurPtr == '\t')) {
2910 ++CurPtr;
2911 while ((*CurPtr == ' ') || (*CurPtr == '\t'))
2912 ++CurPtr;
2918 FormTokenWithChars(Result, CurPtr, tok::unknown);
2923 BufferPtr = CurPtr;
2930 char Char = getAndAdvanceChar(CurPtr, Result);
2936 if (CurPtr-1 == BufferEnd)
2937 return LexEndOfFile(Result, CurPtr-1);
2940 if (isCodeCompletionPoint(CurPtr-1)) {
2943 FormTokenWithChars(Result, CurPtr, tok::code_completion);
2948 Diag(CurPtr-1, diag::null_in_file);
2950 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
2960 return LexEndOfFile(Result, CurPtr-1);
2989 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3001 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3005 CurPtr = BufferPtr;
3009 if (CurPtr[0] == '/' && CurPtr[1] == '/' && !inKeepCommentMode() &&
3012 if (SkipLineComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
3015 } else if (CurPtr[0] == '/' && CurPtr[1] == '*' && !inKeepCommentMode()) {
3016 if (SkipBlockComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
3019 } else if (isHorizontalWhitespace(*CurPtr)) {
3032 return LexNumericConstant(Result, CurPtr);
3039 Char = getCharAndSize(CurPtr, SizeTmp);
3043 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3048 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3053 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3055 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3060 char Char2 = getCharAndSize(CurPtr + SizeTmp, SizeTmp2);
3065 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3070 Result, ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3076 char Char3 = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3080 ConsumeChar(ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3090 return LexIdentifier(Result, CurPtr);
3097 Char = getCharAndSize(CurPtr, SizeTmp);
3101 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3106 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3111 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3113 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3119 return LexIdentifier(Result, CurPtr);
3126 Char = getCharAndSize(CurPtr, SizeTmp);
3130 ConsumeChar(CurPtr, SizeTmp, Result),
3135 return LexIdentifier(Result, CurPtr);
3140 Char = getCharAndSize(CurPtr, SizeTmp);
3144 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3149 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3151 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3157 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3173 return LexIdentifier(Result, CurPtr);
3178 Diag(CurPtr-1, diag::ext_dollar_in_identifier);
3181 return LexIdentifier(Result, CurPtr);
3191 return LexCharConstant(Result, CurPtr, tok::char_constant);
3197 return LexStringLiteral(Result, CurPtr, tok::string_literal);
3222 Char = getCharAndSize(CurPtr, SizeTmp);
3227 return LexNumericConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result));
3230 CurPtr += SizeTmp;
3232 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '.') {
3234 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3241 Char = getCharAndSize(CurPtr, SizeTmp);
3244 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3247 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3253 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
3255 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3261 Char = getCharAndSize(CurPtr, SizeTmp);
3263 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3266 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3273 Char = getCharAndSize(CurPtr, SizeTmp);
3275 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3278 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '*') { // C++ ->*
3279 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3283 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3286 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3296 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
3298 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3305 Char = getCharAndSize(CurPtr, SizeTmp);
3319 TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';
3322 if (SkipLineComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3334 if (SkipBlockComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3344 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3351 Char = getCharAndSize(CurPtr, SizeTmp);
3354 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3357 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3359 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3360 Char = getCharAndSize(CurPtr, SizeTmp);
3361 if (Char == '%' && getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == ':') {
3363 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3366 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3385 Char = getCharAndSize(CurPtr, SizeTmp);
3387 return LexAngledStringLiteral(Result, CurPtr);
3389 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
3392 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3394 } else if (After == '<' && IsStartOfConflictMarker(CurPtr-1)) {
3398 } else if (After == '<' && HandleEndOfConflictMarker(CurPtr-1)) {
3404 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3407 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3411 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3415 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == ':') {
3422 char After = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3431 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3434 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3441 Char = getCharAndSize(CurPtr, SizeTmp);
3443 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3446 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
3448 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3451 } else if (After == '>' && IsStartOfConflictMarker(CurPtr-1)) {
3455 } else if (After == '>' && HandleEndOfConflictMarker(CurPtr-1)) {
3460 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3463 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3472 Char = getCharAndSize(CurPtr, SizeTmp);
3474 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3481 Char = getCharAndSize(CurPtr, SizeTmp);
3484 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3487 if (CurPtr[1] == '|' && HandleEndOfConflictMarker(CurPtr-1))
3490 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3496 Char = getCharAndSize(CurPtr, SizeTmp);
3499 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3502 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3511 Char = getCharAndSize(CurPtr, SizeTmp);
3514 if (CurPtr[1] == '=' && HandleEndOfConflictMarker(CurPtr-1))
3518 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3527 Char = getCharAndSize(CurPtr, SizeTmp);
3530 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3535 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
3550 if (CurPtr[-1] == '@' && LangOpts.ObjC1)
3558 if (uint32_t CodePoint = tryReadUCN(CurPtr, BufferPtr, &Result)) {
3559 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
3560 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3568 return LexUnicode(Result, CodePoint, CurPtr);
3582 // We can't just reset CurPtr to BufferPtr because BufferPtr may point to
3584 --CurPtr;
3586 llvm::convertUTF8Sequence((const UTF8 **)&CurPtr,
3591 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
3592 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3599 return LexUnicode(Result, CodePoint, CurPtr);
3604 ++CurPtr;
3612 Diag(CurPtr, diag::err_invalid_utf8);
3614 BufferPtr = CurPtr+1;
3626 FormTokenWithChars(Result, CurPtr, Kind);
3632 FormTokenWithChars(Result, CurPtr, tok::hash);
