Lines Matching full:curptr
524 const char *CurPtr = Buffer->getBufferStart();
526 while (CurPtr != Buffer->getBufferEnd()) {
527 char ch = *CurPtr++;
534 if (CurPtr != Buffer->getBufferEnd())
535 MaxLineOffset = CurPtr - Buffer->getBufferStart();
1260 void Lexer::LexIdentifier(Token &Result, const char *CurPtr) {
1263 unsigned char C = *CurPtr++;
1265 C = *CurPtr++;
1267 --CurPtr; // Back up over the skipped character.
1278 FormTokenWithChars(Result, CurPtr, tok::raw_identifier);
1300 C = getCharAndSize(CurPtr, Size);
1308 Diag(CurPtr, diag::ext_dollar_in_identifier);
1309 CurPtr = ConsumeChar(CurPtr, Size, Result);
1310 C = getCharAndSize(CurPtr, Size);
1318 CurPtr = ConsumeChar(CurPtr, Size, Result);
1320 C = getCharAndSize(CurPtr, Size);
1322 CurPtr = ConsumeChar(CurPtr, Size, Result);
1323 C = getCharAndSize(CurPtr, Size);
1342 void Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {
1344 char C = getCharAndSize(CurPtr, Size);
1347 CurPtr = ConsumeChar(CurPtr, Size, Result);
1349 C = getCharAndSize(CurPtr, Size);
1357 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1362 return LexNumericConstant(Result, ConsumeChar(CurPtr, Size, Result));
1366 FormTokenWithChars(Result, CurPtr, tok::numeric_constant);
1372 void Lexer::LexStringLiteral(Token &Result, const char *CurPtr,
1382 char C = getAndAdvanceChar(CurPtr, Result);
1387 C = getAndAdvanceChar(CurPtr, Result);
1390 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1393 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1398 if (isCodeCompletionPoint(CurPtr-1)) {
1400 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1404 NulCharacter = CurPtr-1;
1406 C = getAndAdvanceChar(CurPtr, Result);
1415 FormTokenWithChars(Result, CurPtr, Kind);
1421 void Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr,
1433 while (PrefixLen != 16 && isRawStringDelimBody(CurPtr[PrefixLen]))
1437 if (CurPtr[PrefixLen] != '(') {
1439 const char *PrefixEnd = &CurPtr[PrefixLen];
1452 char C = *CurPtr++;
1456 if (C == 0 && CurPtr-1 == BufferEnd) {
1457 --CurPtr;
1462 FormTokenWithChars(Result, CurPtr, tok::unknown);
1466 // Save prefix and move CurPtr past it
1467 const char *Prefix = CurPtr;
1468 CurPtr += PrefixLen + 1; // skip over prefix and '('
1471 char C = *CurPtr++;
1475 if (strncmp(CurPtr, Prefix, PrefixLen) == 0 && CurPtr[PrefixLen] == '"') {
1476 CurPtr += PrefixLen + 1; // skip over prefix and '"'
1479 } else if (C == 0 && CurPtr-1 == BufferEnd) { // End of file.
1483 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1490 FormTokenWithChars(Result, CurPtr, Kind);
1496 void Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {
1498 const char *AfterLessPos = CurPtr;
1499 char C = getAndAdvanceChar(CurPtr, Result);
1504 C = getAndAdvanceChar(CurPtr, Result);
1506 (C == 0 && (CurPtr-1 == BufferEnd || // End of file.
1507 isCodeCompletionPoint(CurPtr-1)))) {
1513 NulCharacter = CurPtr-1;
1515 C = getAndAdvanceChar(CurPtr, Result);
1524 FormTokenWithChars(Result, CurPtr, tok::angle_string_literal);
1531 void Lexer::LexCharConstant(Token &Result, const char *CurPtr,
1539 char C = getAndAdvanceChar(CurPtr, Result);
1543 FormTokenWithChars(Result, CurPtr, tok::unknown);
1552 C = getAndAdvanceChar(CurPtr, Result);
1554 (C == 0 && CurPtr-1 == BufferEnd)) { // End of file.
1557 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1560 if (isCodeCompletionPoint(CurPtr-1)) {
1562 FormTokenWithChars(Result, CurPtr-1, tok::unknown);
1566 NulCharacter = CurPtr-1;
1568 C = getAndAdvanceChar(CurPtr, Result);
1577 FormTokenWithChars(Result, CurPtr, Kind);
1586 bool Lexer::SkipWhitespace(Token &Result, const char *CurPtr) {
1588 unsigned char Char = *CurPtr; // Skip consequtive spaces efficiently.
1592 Char = *++CurPtr;
1600 BufferPtr = CurPtr;
1609 Char = *++CurPtr;
1613 char PrevChar = CurPtr[-1];
1619 FormTokenWithChars(Result, CurPtr, tok::unknown);
1623 BufferPtr = CurPtr;
1633 bool Lexer::SkipBCPLComment(Token &Result, const char *CurPtr) {
1649 C = *CurPtr;
1653 C = *++CurPtr;
1655 const char *NextLine = CurPtr;
1658 const char *EscapePtr = CurPtr-1;
1663 CurPtr = EscapePtr;
1666 CurPtr = EscapePtr-2;
1670 C = *CurPtr;
1677 const char *OldPtr = CurPtr;
1680 C = getAndAdvanceChar(CurPtr, Result);
1685 if (C != 0 && CurPtr == OldPtr+1) {
1686 CurPtr = NextLine;
1692 // newline, we want CurPtr, to end up pointing to it down below.
1694 --CurPtr;
1701 if (CurPtr != OldPtr+1 && C != '/' && CurPtr[0] != '/') {
1702 for (; OldPtr != CurPtr; ++OldPtr)
1707 const char *ForwardPtr = CurPtr;
1720 if (CurPtr == BufferEnd+1) {
1721 --CurPtr;
1725 if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
1737 getSourceLocation(CurPtr)))) {
1738 BufferPtr = CurPtr;
1744 return SaveBCPLComment(Result, CurPtr);
1748 if (ParsingPreprocessorDirective || CurPtr == BufferEnd) {
1749 BufferPtr = CurPtr;
1758 ++CurPtr;
1764 BufferPtr = CurPtr;
1770 bool Lexer::SaveBCPLComment(Token &Result, const char *CurPtr) {
1773 FormTokenWithChars(Result, CurPtr, tok::comment);
1798 static bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr,
1800 assert(CurPtr[0] == '\n' || CurPtr[0] == '\r');
1803 --CurPtr;
1806 if (CurPtr[0] == '\n' || CurPtr[0] == '\r') {
1808 if (CurPtr[0] == CurPtr[1])
1811 --CurPtr;
1817 while (isHorizontalWhitespace(*CurPtr) || *CurPtr == 0) {
1818 --CurPtr;
1823 if (*CurPtr == '\\') {
1824 if (CurPtr[-1] != '*') return false;
1827 if (CurPtr[0] != '/' || CurPtr[-1] != '?' || CurPtr[-2] != '?' ||
1828 CurPtr[-3] != '*')
1832 CurPtr -= 2;
1838 L->Diag(CurPtr, diag::trigraph_ignored_block_comment);
1842 L->Diag(CurPtr, diag::trigraph_ends_block_comment);
1847 L->Diag(CurPtr, diag::escaped_newline_block_comment_end);
1851 L->Diag(CurPtr, diag::backslash_newline_space);
1872 bool Lexer::SkipBlockComment(Token &Result, const char *CurPtr) {
1882 unsigned char C = getCharAndSize(CurPtr, CharSize);
1883 CurPtr += CharSize;
1884 if (C == 0 && CurPtr == BufferEnd+1) {
1887 --CurPtr;
1892 FormTokenWithChars(Result, CurPtr, tok::unknown);
1896 BufferPtr = CurPtr;
1903 C = *CurPtr++;
1908 if (CurPtr + 24 < BufferEnd &&
1913 while (C != '/' && ((intptr_t)CurPtr & 0x0F) != 0)
1914 C = *CurPtr++;
1921 while (CurPtr+16 <= BufferEnd &&
1922 _mm_movemask_epi8(_mm_cmpeq_epi8(*(__m128i*)CurPtr, Slashes)) == 0)
1923 CurPtr += 16;
1929 while (CurPtr+16 <= BufferEnd &&
1930 !vec_any_eq(*(vector unsigned char*)CurPtr, Slashes))
1931 CurPtr += 16;
1934 while (CurPtr[0] != '/' &&
1935 CurPtr[1] != '/' &&
1936 CurPtr[2] != '/' &&
1937 CurPtr[3] != '/' &&
1938 CurPtr+4 < BufferEnd) {
1939 CurPtr += 4;
1944 C = *CurPtr++;
1949 C = *CurPtr++;
1953 if (CurPtr[-2] == '*') // We found the final */. We're done!
1956 if ((CurPtr[-2] == '\n' || CurPtr[-2] == '\r')) {
1957 if (isEndOfBlockCommentWithEscapedNewLine(CurPtr-2, this)) {
1963 if (CurPtr[0] == '*' && CurPtr[1] != '/') {
1968 Diag(CurPtr-1, diag::warn_nested_block_comment);
1970 } else if (C == 0 && CurPtr == BufferEnd+1) {
1976 --CurPtr;
1981 FormTokenWithChars(Result, CurPtr, tok::unknown);
1985 BufferPtr = CurPtr;
1987 } else if (C == '\0' && isCodeCompletionPoint(CurPtr-1)) {
1993 C = *CurPtr++;
1999 getSourceLocation(CurPtr)))) {
2000 BufferPtr = CurPtr;
2006 FormTokenWithChars(Result, CurPtr, tok::comment);
2014 if (isHorizontalWhitespace(*CurPtr)) {
2016 SkipWhitespace(Result, CurPtr+1);
2021 BufferPtr = CurPtr;
2038 // CurPtr - Cache BufferPtr in an automatic variable.
2039 const char *CurPtr = BufferPtr;
2041 char Char = getAndAdvanceChar(CurPtr, Tmp);
2048 if (CurPtr-1 != BufferEnd) {
2049 if (isCodeCompletionPoint(CurPtr-1)) {
2063 assert(CurPtr[-1] == Char && "Trigraphs for newline?");
2064 BufferPtr = CurPtr-1;
2081 /// LexEndOfFile - CurPtr points to the end of this file. Handle this
2085 bool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {
2093 FormTokenWithChars(Result, CurPtr, tok::eod);
2121 if (CurPtr != BufferStart && (CurPtr[-1] != '\n' && CurPtr[-1] != '\r'))
2125 BufferPtr = CurPtr;
2164 static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
2168 StringRef RestOfBuffer(CurPtr+TermLen, BufferEnd-CurPtr-TermLen);
2187 bool Lexer::IsStartOfConflictMarker(const char *CurPtr) {
2189 if (CurPtr != BufferStart &&
2190 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2194 if ((BufferEnd-CurPtr < 8 || StringRef(CurPtr, 7) != "<<<<<<<") &&
2195 (BufferEnd-CurPtr < 6 || StringRef(CurPtr, 5) != ">>>> "))
2203 ConflictMarkerKind Kind = *CurPtr == '<' ? CMK_Normal : CMK_Perforce;
2207 if (FindConflictEnd(CurPtr, BufferEnd, Kind)) {
2210 Diag(CurPtr, diag::err_conflict_marker);
2215 while (*CurPtr != '\r' && *CurPtr != '\n') {
2216 assert(CurPtr != BufferEnd && "Didn't find end of line");
2217 ++CurPtr;
2219 BufferPtr = CurPtr;
2232 bool Lexer::HandleEndOfConflictMarker(const char *CurPtr) {
2234 if (CurPtr != BufferStart &&
2235 CurPtr[-1] != '\n' && CurPtr[-1] != '\r')
2245 if (CurPtr[i] != CurPtr[0])
2249 // fail if it got skipped with a '#if 0' or something. Note that CurPtr might
2251 if (const char *End = FindConflictEnd(CurPtr, BufferEnd,
2253 CurPtr = End;
2256 while (CurPtr != BufferEnd && *CurPtr != '\r' && *CurPtr != '\n')
2257 ++CurPtr;
2259 BufferPtr = CurPtr;
2269 bool Lexer::isCodeCompletionPoint(const char *CurPtr) const {
2271 SourceLocation Loc = FileLoc.getLocWithOffset(CurPtr-BufferStart);
2290 // CurPtr - Cache BufferPtr in an automatic variable.
2291 const char *CurPtr = BufferPtr;
2294 if ((*CurPtr == ' ') || (*CurPtr == '\t')) {
2295 ++CurPtr;
2296 while ((*CurPtr == ' ') || (*CurPtr == '\t'))
2297 ++CurPtr;
2303 FormTokenWithChars(Result, CurPtr, tok::unknown);
2307 BufferPtr = CurPtr;
2314 char Char = getAndAdvanceChar(CurPtr, Result);
2320 if (CurPtr-1 == BufferEnd) {
2324 if (LexEndOfFile(Result, CurPtr-1)) // Retreat back into the file.
2331 if (isCodeCompletionPoint(CurPtr-1)) {
2334 FormTokenWithChars(Result, CurPtr, tok::code_completion);
2339 Diag(CurPtr-1, diag::null_in_file);
2341 if (SkipWhitespace(Result, CurPtr))
2352 if (LexEndOfFile(Result, CurPtr-1)) // Retreat back into the file.
2383 if (SkipWhitespace(Result, CurPtr))
2392 if (SkipWhitespace(Result, CurPtr))
2396 CurPtr = BufferPtr;
2400 if (CurPtr[0] == '/' && CurPtr[1] == '/' && !inKeepCommentMode() &&
2402 if (SkipBCPLComment(Result, CurPtr+2))
2405 } else if (CurPtr[0] == '/' && CurPtr[1] == '*' && !inKeepCommentMode()) {
2406 if (SkipBlockComment(Result, CurPtr+2))
2409 } else if (isHorizontalWhitespace(*CurPtr)) {
2420 return LexNumericConstant(Result, CurPtr);
2427 Char = getCharAndSize(CurPtr, SizeTmp);
2431 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2436 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2440 if (Char == 'R' && getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
2442 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2447 char Char2 = getCharAndSize(CurPtr + SizeTmp, SizeTmp2);
2452 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2458 char Char3 = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
2462 ConsumeChar(ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2472 return LexIdentifier(Result, CurPtr);
2479 Char = getCharAndSize(CurPtr, SizeTmp);
2483 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2488 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2492 if (Char == 'R' && getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
2494 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2500 return LexIdentifier(Result, CurPtr);
2507 Char = getCharAndSize(CurPtr, SizeTmp);
2511 ConsumeChar(CurPtr, SizeTmp, Result),
2516 return LexIdentifier(Result, CurPtr);
2521 Char = getCharAndSize(CurPtr, SizeTmp);
2525 return LexStringLiteral(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2530 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == '"')
2532 ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2538 return LexCharConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result),
2554 return LexIdentifier(Result, CurPtr);
2559 Diag(CurPtr-1, diag::ext_dollar_in_identifier);
2562 return LexIdentifier(Result, CurPtr);
2572 return LexCharConstant(Result, CurPtr, tok::char_constant);
2578 return LexStringLiteral(Result, CurPtr, tok::string_literal);
2603 Char = getCharAndSize(CurPtr, SizeTmp);
2608 return LexNumericConstant(Result, ConsumeChar(CurPtr, SizeTmp, Result));
2611 CurPtr += SizeTmp;
2613 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '.') {
2615 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2622 Char = getCharAndSize(CurPtr, SizeTmp);
2625 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2628 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2634 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
2636 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2642 Char = getCharAndSize(CurPtr, SizeTmp);
2644 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2647 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2654 Char = getCharAndSize(CurPtr, SizeTmp);
2656 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2659 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == '*') { // C++ ->*
2660 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2664 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2667 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2677 if (getCharAndSize(CurPtr, SizeTmp) == '=') {
2679 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2686 Char = getCharAndSize(CurPtr, SizeTmp);
2697 getCharAndSize(CurPtr+SizeTmp, SizeTmp2) != '*') &&
2699 if (SkipBCPLComment(Result, ConsumeChar(CurPtr, SizeTmp, Result)))
2710 if (SkipBlockComment(Result, ConsumeChar(CurPtr, SizeTmp, Result)))
2716 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2723 Char = getCharAndSize(CurPtr, SizeTmp);
2726 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2729 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2731 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2732 Char = getCharAndSize(CurPtr, SizeTmp);
2733 if (Char == '%' && getCharAndSize(CurPtr+SizeTmp, SizeTmp2) == ':') {
2735 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2738 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2748 FormTokenWithChars(Result, CurPtr, tok::hash);
2775 Char = getCharAndSize(CurPtr, SizeTmp);
2777 return LexAngledStringLiteral(Result, CurPtr);
2779 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
2782 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2784 } else if (After == '<' && IsStartOfConflictMarker(CurPtr-1)) {
2788 } else if (After == '<' && HandleEndOfConflictMarker(CurPtr-1)) {
2794 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2797 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2801 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2805 getCharAndSize(CurPtr + SizeTmp, SizeTmp2) == ':') {
2812 char After = getCharAndSize(CurPtr + SizeTmp + SizeTmp2, SizeTmp3);
2821 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2824 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2831 Char = getCharAndSize(CurPtr, SizeTmp);
2833 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2836 char After = getCharAndSize(CurPtr+SizeTmp, SizeTmp2);
2838 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2841 } else if (After == '>' && IsStartOfConflictMarker(CurPtr-1)) {
2845 } else if (After == '>' && HandleEndOfConflictMarker(CurPtr-1)) {
2850 CurPtr = ConsumeChar(ConsumeChar(CurPtr, SizeTmp, Result),
2853 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2862 Char = getCharAndSize(CurPtr, SizeTmp);
2864 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2871 Char = getCharAndSize(CurPtr, SizeTmp);
2874 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2877 if (CurPtr[1] == '|' && HandleEndOfConflictMarker(CurPtr-1))
2880 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2886 Char = getCharAndSize(CurPtr, SizeTmp);
2889 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2892 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2901 Char = getCharAndSize(CurPtr, SizeTmp);
2904 if (CurPtr[1] == '=' && HandleEndOfConflictMarker(CurPtr-1))
2908 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2917 Char = getCharAndSize(CurPtr, SizeTmp);
2920 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2925 CurPtr = ConsumeChar(CurPtr, SizeTmp, Result);
2932 FormTokenWithChars(Result, CurPtr, tok::hash);
2957 if (CurPtr[-1] == '@' && Features.ObjC1)
2975 FormTokenWithChars(Result, CurPtr, Kind);
