Lines Matching defs:CurPtr
655 const char *CurPtr = Buffer.begin();
657 while (CurPtr != Buffer.end()) {
658 char ch = *CurPtr++;
665 if (CurPtr != Buffer.end())
666 MaxLineOffset = CurPtr - Buffer.begin();
1766 bool Lexer::tryConsumeIdentifierUCN(const char *&CurPtr, unsigned Size,
1768 const char *UCNPtr = CurPtr + Size;
1769 uint32_t CodePoint = tryReadUCN(UCNPtr, CurPtr, /*Token=*/nullptr);
1781 makeCharRange(*this, CurPtr, UCNPtr),
1790 makeCharRange(*this, CurPtr, UCNPtr));
1793 makeCharRange(*this, CurPtr, UCNPtr),
1798 if ((UCNPtr - CurPtr == 6 && CurPtr[1] == 'u') ||
1799 (UCNPtr - CurPtr == 10 && CurPtr[1] == 'U'))
1800 CurPtr = UCNPtr;
1802 while (CurPtr != UCNPtr)
1803 (void)getAndAdvanceChar(CurPtr, Result);
1807 bool Lexer::tryConsumeIdentifierUTF8Char(const char *&CurPtr, Token &Result) {
1811 // CurPtr may point to the splicing \ on the preceding line,
1814 getCharAndSize(CurPtr, FirstCodeUnitSize);
1815 const char *CharStart = CurPtr + FirstCodeUnitSize - 1;
1853 ConsumeChar(CurPtr, FirstCodeUnitSize, Result);
1854 CurPtr = UnicodePtr;
1859 const char *CurPtr) {
1866 makeCharRange(*this, BufferPtr, CurPtr));
1868 makeCharRange(*this, BufferPtr, CurPtr),
1871 makeCharRange(*this, BufferPtr, CurPtr));
1875 return LexIdentifierContinue(Result, CurPtr);
1892 makeCharRange(*this, BufferPtr, CurPtr), /*IsStart*/ true);
1893 BufferPtr = CurPtr;
1900 FormTokenWithChars(Result, CurPtr, tok::unknown);
1905 fastParseASCIIIdentifier(const char *CurPtr,
1916 while (LLVM_LIKELY(BufferEnd - CurPtr >= BytesPerRegister)) {
1917 __m128i Cv = _mm_loadu_si128((const __m128i *)(CurPtr));
1922 CurPtr += Consumed;
1925 return CurPtr;
1929 unsigned char C = *CurPtr;
1931 C = *++CurPtr;
1932 return CurPtr;
1935 bool Lexer::LexIdentifierContinue(Token &Result, const char *CurPtr) {
1940 CurPtr = fastParseASCIIIdentifier(CurPtr, BufferEnd);
1944 unsigned char C = getCharAndSize(CurPtr, Size);
1946 CurPtr = ConsumeChar(CurPtr, Size, Result);
1955 Diag(CurPtr, diag::ext_dollar_in_identifier);
1956 CurPtr = ConsumeChar(CurPtr, Size, Result);
1959 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
1961 if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result))
1968 FormTokenWithChars(Result, CurPtr, tok::raw_identifier);
1985 if (isCodeCompletionPoint(CurPtr)) {
1993 assert(*CurPtr == 0 && "Completion character must be 0");
1994 ++CurPtr;
1998 if (CurPtr < BufferEnd) {
1999 while (isAsciiIdentifierContinue(*CurPtr))
2000 ++CurPtr;
2002 BufferPtr = CurPtr;
2031 bool Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {
2033 char C = getCharAndSize(CurPtr, Size);
2036 CurPtr = ConsumeChar(CurPtr, Size, Result);
2038 if (LangOpts.HLSL && C == '.' && (*CurPtr == 'x' || *CurPtr == 'r')) {
2039 CurPtr -= Size;
2042 C = getCharAndSize(CurPtr, Size);
2050 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
2063 std::find(BufferPtr, CurPtr, '_') != CurPtr)
2067 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
2072 auto [Next, NextSize] = getCharAndSizeNoWarn(CurPtr + Size, LangOpts);
2075 Diag(CurPtr, LangOpts.CPlusPlus
2078 CurPtr = ConsumeChar(CurPtr, Size, Result);
2079 CurPtr = ConsumeChar(CurPtr, NextSize, Result);
2080 return LexNumericConstant(Result, CurPtr);
2085 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
2086 return LexNumericConstant(Result, CurPtr);
2087 if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result))
2088 return LexNumericConstant(Result, CurPtr);
2092 FormTokenWithChars(Result, CurPtr, tok::numeric_constant);
2099 const char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr,
2105 char C = getCharAndSize(CurPtr, Size);
2109 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
2111 else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result))
2114 return CurPtr;
2119 Diag(CurPtr,
2122 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
2123 return CurPtr;
2145 getCharAndSizeNoWarn(CurPtr + Consumed, LangOpts);
2165 Diag(CurPtr, LangOpts.MSVCCompat
2168 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
2169 return CurPtr;
2172 CurPtr = ConsumeChar(CurPtr, Size, Result);
2177 C = getCharAndSize(CurPtr, Size);
2179 CurPtr = ConsumeChar(CurPtr, Size, Result);
2180 } else if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result)) {
2181 } else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result)) {
2186 return CurPtr;
2191 bool Lexer::LexStringLiteral(Token &Result, const char *CurPtr,
2193 const char *AfterQuote = CurPtr;
2204 char C = getAndAdvanceChar(CurPtr, Result);
2209 C = getAndAdvanceChar(CurPtr, Result);
2212 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
2215 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2220 if (isCodeCompletionPoint(CurPtr-1)) {
2222 codeCompleteIncludedFile(AfterQuote, CurPtr - 1, /*IsAngled=*/false);
2225 FormTokenWithChars(Result, CurPtr - 1, tok::unknown);
2230 NulCharacter = CurPtr-1;
2232 C = getAndAdvanceChar(CurPtr, Result);
2237 CurPtr = LexUDSuffix(Result, CurPtr, true);
2245 FormTokenWithChars(Result, CurPtr, Kind);
2252 bool Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr,
2264 while (PrefixLen != 16 && isRawStringDelimBody(CurPtr[PrefixLen])) {
2266 llvm::is_contained({'$', '@', '`'}, CurPtr[PrefixLen])) {
2267 const char *Pos = &CurPtr[PrefixLen];
2277 if (CurPtr[PrefixLen] != '(') {
2279 const char *PrefixEnd = &CurPtr[PrefixLen];
2294 char C = *CurPtr++;
2298 if (C == 0 && CurPtr-1 == BufferEnd) {
2299 --CurPtr;
2304 FormTokenWithChars(Result, CurPtr, tok::unknown);
2308 // Save prefix and move CurPtr past it
2309 const char *Prefix = CurPtr;
2310 CurPtr += PrefixLen + 1; // skip over prefix and '('
2313 char C = *CurPtr++;
2317 if (strncmp(CurPtr, Prefix, PrefixLen) == 0 && CurPtr[PrefixLen] == '"') {
2318 CurPtr += PrefixLen + 1; // skip over prefix and '"'
2321 } else if (C == 0 && CurPtr-1 == BufferEnd) { // End of file.
2325 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2332 CurPtr = LexUDSuffix(Result, CurPtr, true);
2336 FormTokenWithChars(Result, CurPtr, Kind);
2343 bool Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {
2346 const char *AfterLessPos = CurPtr;
2347 char C = getAndAdvanceChar(CurPtr, Result);
2352 C = getAndAdvanceChar(CurPtr, Result);
2355 (C == 0 && (CurPtr - 1 == BufferEnd))) { // End of file.
2363 if (isCodeCompletionPoint(CurPtr - 1)) {
2364 codeCompleteIncludedFile(AfterLessPos, CurPtr - 1, /*IsAngled=*/true);
2366 FormTokenWithChars(Result, CurPtr - 1, tok::unknown);
2369 NulCharacter = CurPtr-1;
2371 C = getAndAdvanceChar(CurPtr, Result);
2380 FormTokenWithChars(Result, CurPtr, tok::header_name);
2420 bool Lexer::LexCharConstant(Token &Result, const char *CurPtr,
2434 char C = getAndAdvanceChar(CurPtr, Result);
2438 FormTokenWithChars(Result, CurPtr, tok::unknown);
2445 C = getAndAdvanceChar(CurPtr, Result);
2448 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
2451 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2456 if (isCodeCompletionPoint(CurPtr-1)) {
2458 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2463 NulCharacter = CurPtr-1;
2465 C = getAndAdvanceChar(CurPtr, Result);
2470 CurPtr = LexUDSuffix(Result, CurPtr, false);
2478 FormTokenWithChars(Result, CurPtr, Kind);
2487 bool Lexer::SkipWhitespace(Token &Result, const char *CurPtr,
2490 bool SawNewline = isVerticalWhitespace(CurPtr[-1]);
2492 unsigned char Char = *CurPtr;
2501 setLastNewLine(CurPtr - 1);
2507 Char = *++CurPtr;
2515 BufferPtr = CurPtr;
2520 if (*CurPtr == '\n')
2521 setLastNewLine(CurPtr);
2523 Char = *++CurPtr;
2528 FormTokenWithChars(Result, CurPtr, tok::unknown);
2538 char PrevChar = CurPtr[-1];
2553 BufferPtr = CurPtr;
2563 bool Lexer::SkipLineComment(Token &Result, const char *CurPtr,
2580 // This loop terminates with CurPtr pointing at the newline (or end of buffer)
2591 C = *CurPtr;
2595 C = *++CurPtr;
2601 (const llvm::UTF8 *)CurPtr, (const llvm::UTF8 *)BufferEnd);
2604 Diag(CurPtr, diag::warn_invalid_utf8_in_comment);
2606 ++CurPtr;
2609 CurPtr += Length;
2614 const char *NextLine = CurPtr;
2617 const char *EscapePtr = CurPtr-1;
2626 CurPtr = EscapePtr;
2630 CurPtr = EscapePtr-2;
2643 const char *OldPtr = CurPtr;
2646 C = getAndAdvanceChar(CurPtr, Result);
2651 if (C != 0 && CurPtr == OldPtr+1) {
2652 CurPtr = NextLine;
2659 if (CurPtr != OldPtr + 1 && C != '/' &&
2660 (CurPtr == BufferEnd + 1 || CurPtr[0] != '/')) {
2661 for (; OldPtr != CurPtr; ++OldPtr)
2666 const char *ForwardPtr = CurPtr;
2679 if (C == '\r' || C == '\n' || CurPtr == BufferEnd + 1) {
2680 --CurPtr;
2684 if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2695 getSourceLocation(CurPtr)))) {
2696 BufferPtr = CurPtr;
2702 return SaveLineComment(Result, CurPtr);
2706 if (ParsingPreprocessorDirective || CurPtr == BufferEnd) {
2707 BufferPtr = CurPtr;
2716 NewLinePtr = CurPtr++;
2723 BufferPtr = CurPtr;
2729 bool Lexer::SaveLineComment(Token &Result, const char *CurPtr) {
2732 FormTokenWithChars(Result, CurPtr, tok::comment);
2757 static bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr, Lexer *L,
2759 assert(CurPtr[0] == '\n' || CurPtr[0] == '\r');
2768 --CurPtr;
2771 if (CurPtr[0] == '\n' || CurPtr[0] == '\r') {
2773 if (CurPtr[0] == CurPtr[1])
2776 --CurPtr;
2781 while (isHorizontalWhitespace(*CurPtr) || *CurPtr == 0) {
2782 SpacePos = CurPtr;
2783 --CurPtr;
2787 if (*CurPtr == '\\') {
2788 --CurPtr;
2789 } else if (CurPtr[0] == '/' && CurPtr[-1] == '?' && CurPtr[-2] == '?') {
2791 TrigraphPos = CurPtr - 2;
2792 CurPtr -= 3;
2799 if (*CurPtr == '*')
2802 if (*CurPtr != '\n' && *CurPtr != '\r')
2820 L->Diag(CurPtr + 1, diag::escaped_newline_block_comment_end);
2845 bool Lexer::SkipBlockComment(Token &Result, const char *CurPtr,
2856 unsigned char C = getCharAndSize(CurPtr, CharSize);
2857 CurPtr += CharSize;
2858 if (C == 0 && CurPtr == BufferEnd+1) {
2861 --CurPtr;
2866 FormTokenWithChars(Result, CurPtr, tok::unknown);
2870 BufferPtr = CurPtr;
2877 C = *CurPtr++;
2888 if (CurPtr + 24 < BufferEnd &&
2893 while (C != '/' && (intptr_t)CurPtr % 16 != 0) {
2896 C = *CurPtr++;
2902 while (CurPtr + 16 < BufferEnd) {
2903 int Mask = _mm_movemask_epi8(*(const __m128i *)CurPtr);
2908 int cmp = _mm_movemask_epi8(_mm_cmpeq_epi8(*(const __m128i*)CurPtr,
2914 CurPtr += llvm::countr_zero<unsigned>(cmp) + 1;
2917 CurPtr += 16;
2927 while (CurPtr + 16 < BufferEnd) {
2929 vec_any_ge(*(const __vector unsigned char *)CurPtr, LongUTF)))
2931 if (vec_any_eq(*(const __vector unsigned char *)CurPtr, Slashes)) {
2934 CurPtr += 16;
2938 while (CurPtr + 16 < BufferEnd) {
2941 HasNonASCII |= !isASCII(CurPtr[I]);
2948 HasSlash |= CurPtr[I] == '/';
2951 CurPtr += 16;
2956 C = *CurPtr++;
2965 C = *CurPtr++;
2969 // CurPtr is 1 code unit past C, so to decode
2972 (const llvm::UTF8 *)CurPtr - 1, (const llvm::UTF8 *)BufferEnd);
2975 Diag(CurPtr - 1, diag::warn_invalid_utf8_in_comment);
2979 CurPtr += Length - 1;
2981 C = *CurPtr++;
2986 if (CurPtr[-2] == '*') // We found the final */. We're done!
2989 if ((CurPtr[-2] == '\n' || CurPtr[-2] == '\r')) {
2990 if (isEndOfBlockCommentWithEscapedNewLine(CurPtr - 2, this,
2997 if (CurPtr[0] == '*' && CurPtr[1] != '/') {
3002 Diag(CurPtr-1, diag::warn_nested_block_comment);
3004 } else if (C == 0 && CurPtr == BufferEnd+1) {
3010 --CurPtr;
3015 FormTokenWithChars(Result, CurPtr, tok::unknown);
3019 BufferPtr = CurPtr;
3021 } else if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
3027 C = *CurPtr++;
3033 getSourceLocation(CurPtr)))) {
3034 BufferPtr = CurPtr;
3040 FormTokenWithChars(Result, CurPtr, tok::comment);
3048 if (isHorizontalWhitespace(*CurPtr)) {
3049 SkipWhitespace(Result, CurPtr+1, TokAtPhysicalStartOfLine);
3054 BufferPtr = CurPtr;
3071 // CurPtr - Cache BufferPtr in an automatic variable.
3072 const char *CurPtr = BufferPtr;
3074 char Char = getAndAdvanceChar(CurPtr, Tmp);
3082 if (CurPtr-1 != BufferEnd) {
3083 if (isCodeCompletionPoint(CurPtr-1)) {
3099 assert(CurPtr[-1] == Char && "Trigraphs for newline?");
3100 BufferPtr = CurPtr-1;
3117 /// LexEndOfFile - CurPtr points to the end of this file. Handle this
3121 bool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {
3129 FormTokenWithChars(Result, CurPtr, tok::eod);
3168 if (CurPtr != BufferStart && (CurPtr[-1] != '\n' && CurPtr[-1] != '\r')) {
3190 BufferPtr = CurPtr;
3241 static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
3245 auto RestOfBuffer = StringRef(CurPtr, BufferEnd - CurPtr).substr(TermLen);
3264 bool Lexer::IsStartOfConflictMarker(const char *CurPtr) {
3266 if (CurPtr != BufferStart &&
3267 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
3271 if (!StringRef(CurPtr, BufferEnd - CurPtr).starts_with("<<<<<<<") &&
3272 !StringRef(CurPtr, BufferEnd - CurPtr).starts_with(">>>> "))
3280 ConflictMarkerKind Kind = *CurPtr == '<' ? CMK_Normal : CMK_Perforce;
3284 if (FindConflictEnd(CurPtr, BufferEnd, Kind)) {
3287 Diag(CurPtr, diag::err_conflict_marker);
3292 while (*CurPtr != '\r' && *CurPtr != '\n') {
3293 assert(CurPtr != BufferEnd && "Didn't find end of line");
3294 ++CurPtr;
3296 BufferPtr = CurPtr;
3308 bool Lexer::HandleEndOfConflictMarker(const char *CurPtr) {
3310 if (CurPtr != BufferStart &&
3311 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
3321 if (CurPtr[i] != CurPtr[0])
3325 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
3327 if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
3329 CurPtr = End;
3332 while (CurPtr != BufferEnd && *CurPtr != '\r' && *CurPtr != '\n')
3333 ++CurPtr;
3335 BufferPtr = CurPtr;
3345 static const char *findPlaceholderEnd(const char *CurPtr,
3347 if (CurPtr == BufferEnd)
3350 for (; CurPtr != BufferEnd; ++CurPtr) {
3351 if (CurPtr[0] == '#' && CurPtr[1] == '>')
3352 return CurPtr + 2;
3357 bool Lexer::lexEditorPlaceholder(Token &Result, const char *CurPtr) {
3358 assert(CurPtr[-1] == '<' && CurPtr[0] == '#' && "Not a placeholder!");
3361 const char *End = findPlaceholderEnd(CurPtr + 1, BufferEnd);
3364 const char *Start = CurPtr - 1;
3376 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
3378 SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
3409 const char *CurPtr = StartPtr + CharSize;
3410 const char *KindLoc = &CurPtr[-1];
3414 char C = getCharAndSize(CurPtr, CharSize);
3417 CurPtr += CharSize;
3422 CurPtr += CharSize;
3445 CurPtr += CharSize;
3488 if (CurPtr - StartPtr == (ptrdiff_t)(Count + 1 + (Delimited ? 2 : 0)))
3489 StartPtr = CurPtr;
3491 while (StartPtr != CurPtr)
3494 StartPtr = CurPtr;
3508 const char *CurPtr = StartPtr + CharSize;
3509 const char *KindLoc = &CurPtr[-1];
3511 C = getCharAndSize(CurPtr, CharSize);
3517 CurPtr += CharSize;
3518 const char *StartName = CurPtr;
3522 C = getCharAndSize(CurPtr, CharSize);
3523 CurPtr += CharSize;
3551 << makeCharRange(*this, StartName, CurPtr - CharSize);
3555 makeCharRange(*this, StartName, CurPtr - CharSize),
3582 if (CurPtr - StartPtr == (ptrdiff_t)(Buffer.size() + 3))
3583 StartPtr = CurPtr;
3585 while (StartPtr != CurPtr)
3588 StartPtr = CurPtr;
3659 const char *CurPtr) {
3663 << makeCharRange(*this, BufferPtr, CurPtr);
3720 // CurPtr - Cache BufferPtr in an automatic variable.
3721 const char *CurPtr = BufferPtr;
3724 if (isHorizontalWhitespace(*CurPtr)) {
3726 ++CurPtr;
3727 } while (isHorizontalWhitespace(*CurPtr));
3733 FormTokenWithChars(Result, CurPtr, tok::unknown);
3738 BufferPtr = CurPtr;
3745 char Char = getAndAdvanceChar(CurPtr, Result);
3754 if (CurPtr-1 == BufferEnd)
3755 return LexEndOfFile(Result, CurPtr-1);
3758 if (isCodeCompletionPoint(CurPtr-1)) {
3761 FormTokenWithChars(Result, CurPtr, tok::code_completion);
3766 Diag(CurPtr-1, diag::null_in_file);
3768 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3779 Diag(CurPtr-1, diag::ext_ctrl_z_eof_microsoft);
3780 return LexEndOfFile(Result, CurPtr-1);
3788 if (CurPtr[0] == '\n')
3789 (void)getAndAdvanceChar(CurPtr, Result);
3805 NewLinePtr = CurPtr - 1;
3814 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3826 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3830 CurPtr = BufferPtr;
3834 if (CurPtr[0] == '/' && CurPtr[1] == '/' && !inKeepCommentMode() &&
3836 if (SkipLineComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
3839 } else if (CurPtr[0] == '/' && CurPtr[1] == '*' && !inKeepCommentMode()) {
3840 if (SkipBlockComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
3843 } else if (isHorizontalWhitespace(*CurPtr)) {
3856 return LexNumericConstant(Result, CurPtr);
3866 Char = getCharAndSize(CurPtr, SizeTmp);
3870 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3875 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3880 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3882 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3887 char Char2 = getCharAndSize(CurPtr + SizeTmp, SizeTmp2);
3892 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3897 Result, ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3903 char Char3 = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3907 ConsumeChar(ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3917 return LexIdentifierContinue(Result, CurPtr);
3924 Char = getCharAndSize(CurPtr, SizeTmp);
3928 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3933 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3938 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3940 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3946 return LexIdentifierContinue(Result, CurPtr);
3953 Char = getCharAndSize(CurPtr, SizeTmp);
3957 ConsumeChar(CurPtr, SizeTmp, Result),
3962 return LexIdentifierContinue(Result, CurPtr);
3967 Char = getCharAndSize(CurPtr, SizeTmp);
3971 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3976 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3978 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3984 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4001 return LexIdentifierContinue(Result, CurPtr);
4006 Diag(CurPtr-1, diag::ext_dollar_in_identifier);
4009 return LexIdentifierContinue(Result, CurPtr);
4019 return LexCharConstant(Result, CurPtr, tok::char_constant);
4025 return LexStringLiteral(Result, CurPtr,
4052 Char = getCharAndSize(CurPtr, SizeTmp);
4057 return LexNumericConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result));
4060 CurPtr += SizeTmp;
4062 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '.') {
4064 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4071 Char = getCharAndSize(CurPtr, SizeTmp);
4074 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4077 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4083 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
4085 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4091 Char = getCharAndSize(CurPtr, SizeTmp);
4093 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4096 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4103 Char = getCharAndSize(CurPtr, SizeTmp);
4105 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4108 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '*') { // C++ ->*
4109 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4113 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4116 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4126 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
4128 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4135 Char = getCharAndSize(CurPtr, SizeTmp);
4149 TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';
4152 if (SkipLineComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4164 if (SkipBlockComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4174 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4181 Char = getCharAndSize(CurPtr, SizeTmp);
4184 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4187 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4189 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4190 Char = getCharAndSize(CurPtr, SizeTmp);
4191 if (Char == '%' && getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == ':') {
4193 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4196 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4215 Char = getCharAndSize(CurPtr, SizeTmp);
4217 return LexAngledStringLiteral(Result, CurPtr);
4219 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
4222 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4224 } else if (After == '<' && IsStartOfConflictMarker(CurPtr-1)) {
4228 } else if (After == '<' && HandleEndOfConflictMarker(CurPtr-1)) {
4234 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4237 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4241 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
4246 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4256 getSourceLocation(CurPtr + SizeTmp, SizeTmp2), " ");
4259 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4263 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == ':') {
4270 char After = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
4279 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4282 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4285 lexEditorPlaceholder(Result, CurPtr)) {
4292 Char = getCharAndSize(CurPtr, SizeTmp);
4294 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4297 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
4299 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4302 } else if (After == '>' && IsStartOfConflictMarker(CurPtr-1)) {
4306 } else if (After == '>' && HandleEndOfConflictMarker(CurPtr-1)) {
4311 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4314 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4322 Char = getCharAndSize(CurPtr, SizeTmp);
4324 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4327 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4334 Char = getCharAndSize(CurPtr, SizeTmp);
4337 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4340 if (CurPtr[1] == '|' && HandleEndOfConflictMarker(CurPtr-1))
4343 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4349 Char = getCharAndSize(CurPtr, SizeTmp);
4352 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4355 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4364 Char = getCharAndSize(CurPtr, SizeTmp);
4367 if (CurPtr[1] == '=' && HandleEndOfConflictMarker(CurPtr-1))
4371 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4380 Char = getCharAndSize(CurPtr, SizeTmp);
4383 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4388 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4403 if (CurPtr[-1] == '@' && LangOpts.ObjC)
4412 if (uint32_t CodePoint = tryReadUCN(CurPtr, BufferPtr, &Result)) {
4413 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
4414 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
4422 return LexUnicodeIdentifierStart(Result, CodePoint, CurPtr);
4437 // We can't just reset CurPtr to BufferPtr because BufferPtr may point to
4439 --CurPtr;
4441 llvm::convertUTF8Sequence((const llvm::UTF8 **)&CurPtr,
4446 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
4447 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
4454 return LexUnicodeIdentifierStart(Result, CodePoint, CurPtr);
4459 ++CurPtr;
4467 Diag(CurPtr, diag::err_invalid_utf8);
4469 BufferPtr = CurPtr+1;
4481 FormTokenWithChars(Result, CurPtr, Kind);
4487 FormTokenWithChars(Result, CurPtr, tok::hash);