Lines Matching defs:CurPtr
654 const char *CurPtr = Buffer.begin();
656 while (CurPtr != Buffer.end()) {
657 char ch = *CurPtr++;
664 if (CurPtr != Buffer.end())
665 MaxLineOffset = CurPtr - Buffer.begin();
1788 bool Lexer::tryConsumeIdentifierUCN(const char *&CurPtr, unsigned Size,
1790 const char *UCNPtr = CurPtr + Size;
1791 uint32_t CodePoint = tryReadUCN(UCNPtr, CurPtr, /*Token=*/nullptr);
1803 makeCharRange(*this, CurPtr, UCNPtr),
1812 makeCharRange(*this, CurPtr, UCNPtr));
1815 makeCharRange(*this, CurPtr, UCNPtr),
1820 if ((UCNPtr - CurPtr == 6 && CurPtr[1] == 'u') ||
1821 (UCNPtr - CurPtr == 10 && CurPtr[1] == 'U'))
1822 CurPtr = UCNPtr;
1824 while (CurPtr != UCNPtr)
1825 (void)getAndAdvanceChar(CurPtr, Result);
1829 bool Lexer::tryConsumeIdentifierUTF8Char(const char *&CurPtr, Token &Result) {
1833 // CurPtr may point to the splicing \ on the preceding line,
1836 getCharAndSize(CurPtr, FirstCodeUnitSize);
1837 const char *CharStart = CurPtr + FirstCodeUnitSize - 1;
1875 ConsumeChar(CurPtr, FirstCodeUnitSize, Result);
1876 CurPtr = UnicodePtr;
1881 const char *CurPtr) {
1888 makeCharRange(*this, BufferPtr, CurPtr));
1890 makeCharRange(*this, BufferPtr, CurPtr),
1893 makeCharRange(*this, BufferPtr, CurPtr));
1897 return LexIdentifierContinue(Result, CurPtr);
1914 makeCharRange(*this, BufferPtr, CurPtr), /*IsStart*/ true);
1915 BufferPtr = CurPtr;
1922 FormTokenWithChars(Result, CurPtr, tok::unknown);
1927 fastParseASCIIIdentifier(const char *CurPtr,
1938 while (LLVM_LIKELY(BufferEnd - CurPtr >= BytesPerRegister)) {
1939 __m128i Cv = _mm_loadu_si128((const __m128i *)(CurPtr));
1944 CurPtr += Consumed;
1947 return CurPtr;
1951 unsigned char C = *CurPtr;
1953 C = *++CurPtr;
1954 return CurPtr;
1957 bool Lexer::LexIdentifierContinue(Token &Result, const char *CurPtr) {
1962 CurPtr = fastParseASCIIIdentifier(CurPtr, BufferEnd);
1966 unsigned char C = getCharAndSize(CurPtr, Size);
1968 CurPtr = ConsumeChar(CurPtr, Size, Result);
1977 Diag(CurPtr, diag::ext_dollar_in_identifier);
1978 CurPtr = ConsumeChar(CurPtr, Size, Result);
1981 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
1983 if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result))
1990 FormTokenWithChars(Result, CurPtr, tok::raw_identifier);
2007 if (isCodeCompletionPoint(CurPtr)) {
2015 assert(*CurPtr == 0 && "Completion character must be 0");
2016 ++CurPtr;
2020 if (CurPtr < BufferEnd) {
2021 while (isAsciiIdentifierContinue(*CurPtr))
2022 ++CurPtr;
2024 BufferPtr = CurPtr;
2053 bool Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {
2055 char C = getCharAndSize(CurPtr, Size);
2058 CurPtr = ConsumeChar(CurPtr, Size, Result);
2060 if (LangOpts.HLSL && C == '.' && (*CurPtr == 'x' || *CurPtr == 'r')) {
2061 CurPtr -= Size;
2064 C = getCharAndSize(CurPtr, Size);
2072 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
2085 std::find(BufferPtr, CurPtr, '_') != CurPtr)
2089 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
2094 auto [Next, NextSize] = getCharAndSizeNoWarn(CurPtr + Size, LangOpts);
2097 Diag(CurPtr, LangOpts.CPlusPlus
2100 CurPtr = ConsumeChar(CurPtr, Size, Result);
2101 CurPtr = ConsumeChar(CurPtr, NextSize, Result);
2102 return LexNumericConstant(Result, CurPtr);
2107 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
2108 return LexNumericConstant(Result, CurPtr);
2109 if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result))
2110 return LexNumericConstant(Result, CurPtr);
2114 FormTokenWithChars(Result, CurPtr, tok::numeric_constant);
2121 const char *Lexer::LexUDSuffix(Token &Result, const char *CurPtr,
2127 char C = getCharAndSize(CurPtr, Size);
2131 if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result))
2133 else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result))
2136 return CurPtr;
2141 Diag(CurPtr,
2144 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
2145 return CurPtr;
2167 getCharAndSizeNoWarn(CurPtr + Consumed, LangOpts);
2187 Diag(CurPtr, LangOpts.MSVCCompat
2190 << FixItHint::CreateInsertion(getSourceLocation(CurPtr), " ");
2191 return CurPtr;
2194 CurPtr = ConsumeChar(CurPtr, Size, Result);
2199 C = getCharAndSize(CurPtr, Size);
2201 CurPtr = ConsumeChar(CurPtr, Size, Result);
2202 } else if (C == '\\' && tryConsumeIdentifierUCN(CurPtr, Size, Result)) {
2203 } else if (!isASCII(C) && tryConsumeIdentifierUTF8Char(CurPtr, Result)) {
2208 return CurPtr;
2213 bool Lexer::LexStringLiteral(Token &Result, const char *CurPtr,
2215 const char *AfterQuote = CurPtr;
2226 char C = getAndAdvanceChar(CurPtr, Result);
2231 C = getAndAdvanceChar(CurPtr, Result);
2234 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
2237 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2242 if (isCodeCompletionPoint(CurPtr-1)) {
2244 codeCompleteIncludedFile(AfterQuote, CurPtr - 1, /*IsAngled=*/false);
2247 FormTokenWithChars(Result, CurPtr - 1, tok::unknown);
2252 NulCharacter = CurPtr-1;
2254 C = getAndAdvanceChar(CurPtr, Result);
2259 CurPtr = LexUDSuffix(Result, CurPtr, true);
2267 FormTokenWithChars(Result, CurPtr, Kind);
2274 bool Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr,
2286 while (PrefixLen != 16 && isRawStringDelimBody(CurPtr[PrefixLen])) {
2288 llvm::is_contained({'$', '@', '`'}, CurPtr[PrefixLen])) {
2289 const char *Pos = &CurPtr[PrefixLen];
2299 if (CurPtr[PrefixLen] != '(') {
2301 const char *PrefixEnd = &CurPtr[PrefixLen];
2316 char C = *CurPtr++;
2320 if (C == 0 && CurPtr-1 == BufferEnd) {
2321 --CurPtr;
2326 FormTokenWithChars(Result, CurPtr, tok::unknown);
2330 // Save prefix and move CurPtr past it
2331 const char *Prefix = CurPtr;
2332 CurPtr += PrefixLen + 1; // skip over prefix and '('
2335 char C = *CurPtr++;
2339 if (strncmp(CurPtr, Prefix, PrefixLen) == 0 && CurPtr[PrefixLen] == '"') {
2340 CurPtr += PrefixLen + 1; // skip over prefix and '"'
2343 } else if (C == 0 && CurPtr-1 == BufferEnd) { // End of file.
2347 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2354 CurPtr = LexUDSuffix(Result, CurPtr, true);
2358 FormTokenWithChars(Result, CurPtr, Kind);
2365 bool Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {
2368 const char *AfterLessPos = CurPtr;
2369 char C = getAndAdvanceChar(CurPtr, Result);
2374 C = getAndAdvanceChar(CurPtr, Result);
2377 (C == 0 && (CurPtr - 1 == BufferEnd))) { // End of file.
2385 if (isCodeCompletionPoint(CurPtr - 1)) {
2386 codeCompleteIncludedFile(AfterLessPos, CurPtr - 1, /*IsAngled=*/true);
2388 FormTokenWithChars(Result, CurPtr - 1, tok::unknown);
2391 NulCharacter = CurPtr-1;
2393 C = getAndAdvanceChar(CurPtr, Result);
2402 FormTokenWithChars(Result, CurPtr, tok::header_name);
2442 bool Lexer::LexCharConstant(Token &Result, const char *CurPtr,
2458 char C = getAndAdvanceChar(CurPtr, Result);
2462 FormTokenWithChars(Result, CurPtr, tok::unknown);
2469 C = getAndAdvanceChar(CurPtr, Result);
2472 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
2475 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2480 if (isCodeCompletionPoint(CurPtr-1)) {
2482 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
2487 NulCharacter = CurPtr-1;
2489 C = getAndAdvanceChar(CurPtr, Result);
2494 CurPtr = LexUDSuffix(Result, CurPtr, false);
2502 FormTokenWithChars(Result, CurPtr, Kind);
2511 bool Lexer::SkipWhitespace(Token &Result, const char *CurPtr,
2514 bool SawNewline = isVerticalWhitespace(CurPtr[-1]);
2516 unsigned char Char = *CurPtr;
2525 setLastNewLine(CurPtr - 1);
2531 Char = *++CurPtr;
2539 BufferPtr = CurPtr;
2544 if (*CurPtr == '\n')
2545 setLastNewLine(CurPtr);
2547 Char = *++CurPtr;
2552 FormTokenWithChars(Result, CurPtr, tok::unknown);
2562 char PrevChar = CurPtr[-1];
2577 BufferPtr = CurPtr;
2587 bool Lexer::SkipLineComment(Token &Result, const char *CurPtr,
2604 // This loop terminates with CurPtr pointing at the newline (or end of buffer)
2615 C = *CurPtr;
2619 C = *++CurPtr;
2625 (const llvm::UTF8 *)CurPtr, (const llvm::UTF8 *)BufferEnd);
2628 Diag(CurPtr, diag::warn_invalid_utf8_in_comment);
2630 ++CurPtr;
2633 CurPtr += Length;
2638 const char *NextLine = CurPtr;
2641 const char *EscapePtr = CurPtr-1;
2650 CurPtr = EscapePtr;
2654 CurPtr = EscapePtr-2;
2667 const char *OldPtr = CurPtr;
2670 C = getAndAdvanceChar(CurPtr, Result);
2675 if (C != 0 && CurPtr == OldPtr+1) {
2676 CurPtr = NextLine;
2683 if (CurPtr != OldPtr + 1 && C != '/' &&
2684 (CurPtr == BufferEnd + 1 || CurPtr[0] != '/')) {
2685 for (; OldPtr != CurPtr; ++OldPtr)
2690 const char *ForwardPtr = CurPtr;
2703 if (C == '\r' || C == '\n' || CurPtr == BufferEnd + 1) {
2704 --CurPtr;
2708 if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
2719 getSourceLocation(CurPtr)))) {
2720 BufferPtr = CurPtr;
2726 return SaveLineComment(Result, CurPtr);
2730 if (ParsingPreprocessorDirective || CurPtr == BufferEnd) {
2731 BufferPtr = CurPtr;
2740 NewLinePtr = CurPtr++;
2747 BufferPtr = CurPtr;
2753 bool Lexer::SaveLineComment(Token &Result, const char *CurPtr) {
2756 FormTokenWithChars(Result, CurPtr, tok::comment);
2781 static bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr, Lexer *L,
2783 assert(CurPtr[0] == '\n' || CurPtr[0] == '\r');
2792 --CurPtr;
2795 if (CurPtr[0] == '\n' || CurPtr[0] == '\r') {
2797 if (CurPtr[0] == CurPtr[1])
2800 --CurPtr;
2805 while (isHorizontalWhitespace(*CurPtr) || *CurPtr == 0) {
2806 SpacePos = CurPtr;
2807 --CurPtr;
2811 if (*CurPtr == '\\') {
2812 --CurPtr;
2813 } else if (CurPtr[0] == '/' && CurPtr[-1] == '?' && CurPtr[-2] == '?') {
2815 TrigraphPos = CurPtr - 2;
2816 CurPtr -= 3;
2823 if (*CurPtr == '*')
2826 if (*CurPtr != '\n' && *CurPtr != '\r')
2844 L->Diag(CurPtr + 1, diag::escaped_newline_block_comment_end);
2869 bool Lexer::SkipBlockComment(Token &Result, const char *CurPtr,
2880 unsigned char C = getCharAndSize(CurPtr, CharSize);
2881 CurPtr += CharSize;
2882 if (C == 0 && CurPtr == BufferEnd+1) {
2885 --CurPtr;
2890 FormTokenWithChars(Result, CurPtr, tok::unknown);
2894 BufferPtr = CurPtr;
2901 C = *CurPtr++;
2912 if (CurPtr + 24 < BufferEnd &&
2917 while (C != '/' && (intptr_t)CurPtr % 16 != 0) {
2920 C = *CurPtr++;
2926 while (CurPtr + 16 < BufferEnd) {
2927 int Mask = _mm_movemask_epi8(*(const __m128i *)CurPtr);
2932 int cmp = _mm_movemask_epi8(_mm_cmpeq_epi8(*(const __m128i*)CurPtr,
2938 CurPtr += llvm::countr_zero<unsigned>(cmp) + 1;
2941 CurPtr += 16;
2951 while (CurPtr + 16 < BufferEnd) {
2953 vec_any_ge(*(const __vector unsigned char *)CurPtr, LongUTF)))
2955 if (vec_any_eq(*(const __vector unsigned char *)CurPtr, Slashes)) {
2958 CurPtr += 16;
2962 while (CurPtr + 16 < BufferEnd) {
2965 HasNonASCII |= !isASCII(CurPtr[I]);
2972 HasSlash |= CurPtr[I] == '/';
2975 CurPtr += 16;
2980 C = *CurPtr++;
2989 C = *CurPtr++;
2993 // CurPtr is 1 code unit past C, so to decode
2996 (const llvm::UTF8 *)CurPtr - 1, (const llvm::UTF8 *)BufferEnd);
2999 Diag(CurPtr - 1, diag::warn_invalid_utf8_in_comment);
3003 CurPtr += Length - 1;
3005 C = *CurPtr++;
3010 if (CurPtr[-2] == '*') // We found the final */. We're done!
3013 if ((CurPtr[-2] == '\n' || CurPtr[-2] == '\r')) {
3014 if (isEndOfBlockCommentWithEscapedNewLine(CurPtr - 2, this,
3021 if (CurPtr[0] == '*' && CurPtr[1] != '/') {
3026 Diag(CurPtr-1, diag::warn_nested_block_comment);
3028 } else if (C == 0 && CurPtr == BufferEnd+1) {
3034 --CurPtr;
3039 FormTokenWithChars(Result, CurPtr, tok::unknown);
3043 BufferPtr = CurPtr;
3045 } else if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
3051 C = *CurPtr++;
3057 getSourceLocation(CurPtr)))) {
3058 BufferPtr = CurPtr;
3064 FormTokenWithChars(Result, CurPtr, tok::comment);
3072 if (isHorizontalWhitespace(*CurPtr)) {
3073 SkipWhitespace(Result, CurPtr+1, TokAtPhysicalStartOfLine);
3078 BufferPtr = CurPtr;
3095 // CurPtr - Cache BufferPtr in an automatic variable.
3096 const char *CurPtr = BufferPtr;
3098 char Char = getAndAdvanceChar(CurPtr, Tmp);
3106 if (CurPtr-1 != BufferEnd) {
3107 if (isCodeCompletionPoint(CurPtr-1)) {
3123 assert(CurPtr[-1] == Char && "Trigraphs for newline?");
3124 BufferPtr = CurPtr-1;
3141 /// LexEndOfFile - CurPtr points to the end of this file. Handle this
3145 bool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {
3153 FormTokenWithChars(Result, CurPtr, tok::eod);
3192 if (CurPtr != BufferStart && (CurPtr[-1] != '\n' && CurPtr[-1] != '\r')) {
3214 BufferPtr = CurPtr;
3265 static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
3269 auto RestOfBuffer = StringRef(CurPtr, BufferEnd - CurPtr).substr(TermLen);
3288 bool Lexer::IsStartOfConflictMarker(const char *CurPtr) {
3290 if (CurPtr != BufferStart &&
3291 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
3295 if (!StringRef(CurPtr, BufferEnd - CurPtr).starts_with("<<<<<<<") &&
3296 !StringRef(CurPtr, BufferEnd - CurPtr).starts_with(">>>> "))
3304 ConflictMarkerKind Kind = *CurPtr == '<' ? CMK_Normal : CMK_Perforce;
3308 if (FindConflictEnd(CurPtr, BufferEnd, Kind)) {
3311 Diag(CurPtr, diag::err_conflict_marker);
3316 while (*CurPtr != '\r' && *CurPtr != '\n') {
3317 assert(CurPtr != BufferEnd && "Didn't find end of line");
3318 ++CurPtr;
3320 BufferPtr = CurPtr;
3332 bool Lexer::HandleEndOfConflictMarker(const char *CurPtr) {
3334 if (CurPtr != BufferStart &&
3335 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
3345 if (CurPtr[i] != CurPtr[0])
3349 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
3351 if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
3353 CurPtr = End;
3356 while (CurPtr != BufferEnd && *CurPtr != '\r' && *CurPtr != '\n')
3357 ++CurPtr;
3359 BufferPtr = CurPtr;
3369 static const char *findPlaceholderEnd(const char *CurPtr,
3371 if (CurPtr == BufferEnd)
3374 for (; CurPtr != BufferEnd; ++CurPtr) {
3375 if (CurPtr[0] == '#' && CurPtr[1] == '>')
3376 return CurPtr + 2;
3381 bool Lexer::lexEditorPlaceholder(Token &Result, const char *CurPtr) {
3382 assert(CurPtr[-1] == '<' && CurPtr[0] == '#' && "Not a placeholder!");
3385 const char *End = findPlaceholderEnd(CurPtr + 1, BufferEnd);
3388 const char *Start = CurPtr - 1;
3400 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
3402 SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
3433 const char *CurPtr = StartPtr + CharSize;
3434 const char *KindLoc = &CurPtr[-1];
3438 char C = getCharAndSize(CurPtr, CharSize);
3441 CurPtr += CharSize;
3446 CurPtr += CharSize;
3469 CurPtr += CharSize;
3512 if (CurPtr - StartPtr == (ptrdiff_t)(Count + 1 + (Delimited ? 2 : 0)))
3513 StartPtr = CurPtr;
3515 while (StartPtr != CurPtr)
3518 StartPtr = CurPtr;
3532 const char *CurPtr = StartPtr + CharSize;
3533 const char *KindLoc = &CurPtr[-1];
3535 C = getCharAndSize(CurPtr, CharSize);
3541 CurPtr += CharSize;
3542 const char *StartName = CurPtr;
3546 C = getCharAndSize(CurPtr, CharSize);
3547 CurPtr += CharSize;
3575 << makeCharRange(*this, StartName, CurPtr - CharSize);
3579 makeCharRange(*this, StartName, CurPtr - CharSize),
3606 if (CurPtr - StartPtr == (ptrdiff_t)(Buffer.size() + 3))
3607 StartPtr = CurPtr;
3609 while (StartPtr != CurPtr)
3612 StartPtr = CurPtr;
3683 const char *CurPtr) {
3687 << makeCharRange(*this, BufferPtr, CurPtr);
3744 // CurPtr - Cache BufferPtr in an automatic variable.
3745 const char *CurPtr = BufferPtr;
3748 if (isHorizontalWhitespace(*CurPtr)) {
3750 ++CurPtr;
3751 } while (isHorizontalWhitespace(*CurPtr));
3757 FormTokenWithChars(Result, CurPtr, tok::unknown);
3762 BufferPtr = CurPtr;
3769 char Char = getAndAdvanceChar(CurPtr, Result);
3778 if (CurPtr-1 == BufferEnd)
3779 return LexEndOfFile(Result, CurPtr-1);
3782 if (isCodeCompletionPoint(CurPtr-1)) {
3785 FormTokenWithChars(Result, CurPtr, tok::code_completion);
3790 Diag(CurPtr-1, diag::null_in_file);
3792 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3803 Diag(CurPtr-1, diag::ext_ctrl_z_eof_microsoft);
3804 return LexEndOfFile(Result, CurPtr-1);
3812 if (CurPtr[0] == '\n')
3813 (void)getAndAdvanceChar(CurPtr, Result);
3829 NewLinePtr = CurPtr - 1;
3838 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3850 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
3854 CurPtr = BufferPtr;
3858 if (CurPtr[0] == '/' && CurPtr[1] == '/' && !inKeepCommentMode() &&
3860 if (SkipLineComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
3863 } else if (CurPtr[0] == '/' && CurPtr[1] == '*' && !inKeepCommentMode()) {
3864 if (SkipBlockComment(Result, CurPtr+2, TokAtPhysicalStartOfLine))
3867 } else if (isHorizontalWhitespace(*CurPtr)) {
3880 return LexNumericConstant(Result, CurPtr);
3890 Char = getCharAndSize(CurPtr, SizeTmp);
3894 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3899 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3904 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3906 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3911 char Char2 = getCharAndSize(CurPtr + SizeTmp, SizeTmp2);
3916 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3921 Result, ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3927 char Char3 = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
3931 ConsumeChar(ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3941 return LexIdentifierContinue(Result, CurPtr);
3948 Char = getCharAndSize(CurPtr, SizeTmp);
3952 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3957 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
3962 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
3964 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
3970 return LexIdentifierContinue(Result, CurPtr);
3977 Char = getCharAndSize(CurPtr, SizeTmp);
3981 ConsumeChar(CurPtr, SizeTmp, Result),
3986 return LexIdentifierContinue(Result, CurPtr);
3991 Char = getCharAndSize(CurPtr, SizeTmp);
3995 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4000 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
4002 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4008 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4025 return LexIdentifierContinue(Result, CurPtr);
4030 Diag(CurPtr-1, diag::ext_dollar_in_identifier);
4033 return LexIdentifierContinue(Result, CurPtr);
4043 return LexCharConstant(Result, CurPtr, tok::char_constant);
4049 return LexStringLiteral(Result, CurPtr,
4076 Char = getCharAndSize(CurPtr, SizeTmp);
4081 return LexNumericConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result));
4084 CurPtr += SizeTmp;
4086 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '.') {
4088 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4095 Char = getCharAndSize(CurPtr, SizeTmp);
4098 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4101 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4107 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
4109 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4115 Char = getCharAndSize(CurPtr, SizeTmp);
4117 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4120 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4127 Char = getCharAndSize(CurPtr, SizeTmp);
4129 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4132 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '*') { // C++ ->*
4133 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4137 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4140 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4150 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
4152 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4159 Char = getCharAndSize(CurPtr, SizeTmp);
4173 TreatAsComment = getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*';
4176 if (SkipLineComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4188 if (SkipBlockComment(Result, ConsumeChar(CurPtr, SizeTmp, Result),
4198 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4205 Char = getCharAndSize(CurPtr, SizeTmp);
4208 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4211 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4213 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4214 Char = getCharAndSize(CurPtr, SizeTmp);
4215 if (Char == '%' && getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == ':') {
4217 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4220 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4239 Char = getCharAndSize(CurPtr, SizeTmp);
4241 return LexAngledStringLiteral(Result, CurPtr);
4243 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
4246 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4248 } else if (After == '<' && IsStartOfConflictMarker(CurPtr-1)) {
4252 } else if (After == '<' && HandleEndOfConflictMarker(CurPtr-1)) {
4258 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4261 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4265 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
4270 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4280 getSourceLocation(CurPtr + SizeTmp, SizeTmp2), " ");
4283 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4287 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == ':') {
4294 char After = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
4303 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4306 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4309 lexEditorPlaceholder(Result, CurPtr)) {
4316 Char = getCharAndSize(CurPtr, SizeTmp);
4318 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4321 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
4323 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4326 } else if (After == '>' && IsStartOfConflictMarker(CurPtr-1)) {
4330 } else if (After == '>' && HandleEndOfConflictMarker(CurPtr-1)) {
4335 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
4338 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4346 Char = getCharAndSize(CurPtr, SizeTmp);
4348 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4352 Diag(CurPtr, diag::err_opencl_logical_exclusive_or);
4357 Char = getCharAndSize(CurPtr, SizeTmp);
4360 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4363 if (CurPtr[1] == '|' && HandleEndOfConflictMarker(CurPtr-1))
4366 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4372 Char = getCharAndSize(CurPtr, SizeTmp);
4375 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4378 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4387 Char = getCharAndSize(CurPtr, SizeTmp);
4390 if (CurPtr[1] == '=' && HandleEndOfConflictMarker(CurPtr-1))
4394 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4403 Char = getCharAndSize(CurPtr, SizeTmp);
4406 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4411 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
4426 if (CurPtr[-1] == '@' && LangOpts.ObjC)
4435 if (uint32_t CodePoint = tryReadUCN(CurPtr, BufferPtr, &Result)) {
4436 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
4437 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
4445 return LexUnicodeIdentifierStart(Result, CodePoint, CurPtr);
4460 // We can't just reset CurPtr to BufferPtr because BufferPtr may point to
4462 --CurPtr;
4464 llvm::convertUTF8Sequence((const llvm::UTF8 **)&CurPtr,
4469 if (CheckUnicodeWhitespace(Result, CodePoint, CurPtr)) {
4470 if (SkipWhitespace(Result, CurPtr, TokAtPhysicalStartOfLine))
4477 return LexUnicodeIdentifierStart(Result, CodePoint, CurPtr);
4482 ++CurPtr;
4490 Diag(CurPtr, diag::err_invalid_utf8);
4492 BufferPtr = CurPtr+1;
4504 FormTokenWithChars(Result, CurPtr, Kind);
4510 FormTokenWithChars(Result, CurPtr, tok::hash);