| //===--- ScratchBuffer.cpp - Scratch space for forming tokens -------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // This file implements the ScratchBuffer interface. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "clang/Lex/ScratchBuffer.h" |
| #include "clang/Basic/SourceManager.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include <cstring> |
| using namespace clang; |
| |
| // ScratchBufSize - The size of each chunk of scratch memory. Slightly less |
| //than a page, almost certainly enough for anything. :) |
| static const unsigned ScratchBufSize = 4060; |
| |
| ScratchBuffer::ScratchBuffer(SourceManager &SM) |
| : SourceMgr(SM), CurBuffer(nullptr) { |
| // Set BytesUsed so that the first call to getToken will require an alloc. |
| BytesUsed = ScratchBufSize; |
| } |
| |
| /// getToken - Splat the specified text into a temporary MemoryBuffer and |
| /// return a SourceLocation that refers to the token. This is just like the |
| /// method below, but returns a location that indicates the physloc of the |
| /// token. |
| SourceLocation ScratchBuffer::getToken(const char *Buf, unsigned Len, |
| const char *&DestPtr) { |
| if (BytesUsed+Len+2 > ScratchBufSize) |
| AllocScratchBuffer(Len+2); |
| else { |
| // Clear out the source line cache if it's already been computed. |
| // FIXME: Allow this to be incrementally extended. |
| SourceMgr.getSLocEntry(SourceMgr.getFileID(BufferStartLoc)) |
| .getFile() |
| .getContentCache() |
| .SourceLineCache = SrcMgr::LineOffsetMapping(); |
| } |
| |
| // Prefix the token with a \n, so that it looks like it is the first thing on |
| // its own virtual line in caret diagnostics. |
| CurBuffer[BytesUsed++] = '\n'; |
| |
| // Return a pointer to the character data. |
| DestPtr = CurBuffer+BytesUsed; |
| |
| // Copy the token data into the buffer. |
| memcpy(CurBuffer+BytesUsed, Buf, Len); |
| |
| // Remember that we used these bytes. |
| BytesUsed += Len+1; |
| |
| // Add a NUL terminator to the token. This keeps the tokens separated, in |
| // case they get relexed, and puts them on their own virtual lines in case a |
| // diagnostic points to one. |
| CurBuffer[BytesUsed-1] = '\0'; |
| |
| return BufferStartLoc.getLocWithOffset(BytesUsed-Len-1); |
| } |
| |
| void ScratchBuffer::AllocScratchBuffer(unsigned RequestLen) { |
| // Only pay attention to the requested length if it is larger than our default |
| // page size. If it is, we allocate an entire chunk for it. This is to |
| // support gigantic tokens, which almost certainly won't happen. :) |
| if (RequestLen < ScratchBufSize) |
| RequestLen = ScratchBufSize; |
| |
| // Get scratch buffer. Zero-initialize it so it can be dumped into a PCH file |
| // deterministically. |
| std::unique_ptr<llvm::WritableMemoryBuffer> OwnBuf = |
| llvm::WritableMemoryBuffer::getNewMemBuffer(RequestLen, |
| "<scratch space>"); |
| CurBuffer = OwnBuf->getBufferStart(); |
| FileID FID = SourceMgr.createFileID(std::move(OwnBuf)); |
| BufferStartLoc = SourceMgr.getLocForStartOfFile(FID); |
| BytesUsed = 0; |
| } |