return StringRef(Data.data() + StartOfFile, getSize());
}
- error_code getMemoryBuffer(OwningPtr<MemoryBuffer> &Result,
- bool FullPath = false) const;
error_code getMemoryBuffer(std::unique_ptr<MemoryBuffer> &Result,
bool FullPath = false) const;
- error_code getAsBinary(OwningPtr<Binary> &Result,
- LLVMContext *Context = nullptr) const;
error_code getAsBinary(std::unique_ptr<Binary> &Result,
LLVMContext *Context = nullptr) const;
};
#ifndef LLVM_SUPPORT_FILEOUTPUTBUFFER_H
#define LLVM_SUPPORT_FILEOUTPUTBUFFER_H
-#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DataTypes.h"
/// Factory method to create an OutputBuffer object which manages a read/write
/// buffer of the specified size. When committed, the buffer will be written
/// to the file at the specified path.
- static error_code create(StringRef FilePath, size_t Size,
- OwningPtr<FileOutputBuffer> &Result,
- unsigned Flags = 0);
static error_code create(StringRef FilePath, size_t Size,
std::unique_ptr<FileOutputBuffer> &Result,
unsigned Flags = 0);
namespace llvm {
class error_code;
-template<class T> class OwningPtr;
/// MemoryBuffer - This interface provides simple read-only access to a block
/// of memory, and provides simple methods for reading files and standard input
/// \param IsVolatileSize Set to true to indicate that the file size may be
/// changing, e.g. when libclang tries to parse while the user is
/// editing/updating the file.
- static error_code getFile(Twine Filename, OwningPtr<MemoryBuffer> &Result,
- int64_t FileSize = -1,
- bool RequiresNullTerminator = true,
- bool IsVolatileSize = false);
static error_code getFile(Twine Filename,
std::unique_ptr<MemoryBuffer> &Result,
int64_t FileSize = -1,
/// \param IsVolatileSize Set to true to indicate that the file size may be
/// changing, e.g. when libclang tries to parse while the user is
/// editing/updating the file.
- static error_code getOpenFileSlice(int FD, const char *Filename,
- OwningPtr<MemoryBuffer> &Result,
- uint64_t MapSize, int64_t Offset,
- bool IsVolatileSize = false);
static error_code getOpenFileSlice(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t MapSize, int64_t Offset,
/// \param IsVolatileSize Set to true to indicate that the file size may be
/// changing, e.g. when libclang tries to parse while the user is
/// editing/updating the file.
- static error_code getOpenFile(int FD, const char *Filename,
- OwningPtr<MemoryBuffer> &Result,
- uint64_t FileSize,
- bool RequiresNullTerminator = true,
- bool IsVolatileSize = false);
static error_code getOpenFile(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t FileSize,
/// getSTDIN - Read all of stdin into a file buffer, and return it.
/// If an error occurs, this returns null and sets ec.
- static error_code getSTDIN(OwningPtr<MemoryBuffer> &Result);
static error_code getSTDIN(std::unique_ptr<MemoryBuffer> &Result);
/// getFileOrSTDIN - Open the specified file as a MemoryBuffer, or open stdin
/// if the Filename is "-". If an error occurs, this returns null and sets
/// ec.
- static error_code getFileOrSTDIN(StringRef Filename,
- OwningPtr<MemoryBuffer> &Result,
- int64_t FileSize = -1);
static error_code getFileOrSTDIN(StringRef Filename,
std::unique_ptr<MemoryBuffer> &Result,
int64_t FileSize = -1);
#include "llvm/Object/Archive.h"
#include "llvm/ADT/APInt.h"
-#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Support/Endian.h"
return error_code::success();
}
-error_code Archive::Child::getMemoryBuffer(OwningPtr<MemoryBuffer> &Result,
- bool FullPath) const {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getMemoryBuffer(MB, FullPath);
- Result = std::move(MB);
- return ec;
-}
-
error_code Archive::Child::getAsBinary(std::unique_ptr<Binary> &Result,
LLVMContext *Context) const {
std::unique_ptr<Binary> ret;
return object_error::success;
}
-error_code Archive::Child::getAsBinary(OwningPtr<Binary> &Result,
- LLVMContext *Context) const {
- std::unique_ptr<Binary> B;
- error_code ec = getAsBinary(B, Context);
- Result = std::move(B);
- return ec;
-}
-
ErrorOr<Archive*> Archive::create(MemoryBuffer *Source) {
error_code EC;
std::unique_ptr<Archive> Ret(new Archive(Source, EC));
//===----------------------------------------------------------------------===//
#include "llvm/Support/FileOutputBuffer.h"
-#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/system_error.h"
return error_code::success();
}
-error_code FileOutputBuffer::create(StringRef FilePath,
- size_t Size,
- OwningPtr<FileOutputBuffer> &Result,
- unsigned Flags) {
- std::unique_ptr<FileOutputBuffer> FOB;
- error_code ec = create(FilePath, Size, FOB, Flags);
- Result = std::move(FOB);
- return ec;
-}
-
error_code FileOutputBuffer::commit(int64_t NewSmallerSize) {
// Unmap buffer, letting OS flush dirty pages to file on disk.
Region.reset(nullptr);
//===----------------------------------------------------------------------===//
#include "llvm/Support/MemoryBuffer.h"
-#include "llvm/ADT/OwningPtr.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Config/config.h"
#include "llvm/Support/Errno.h"
return getFile(Filename, Result, FileSize);
}
-error_code MemoryBuffer::getFileOrSTDIN(StringRef Filename,
- OwningPtr<MemoryBuffer> &Result,
- int64_t FileSize) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getFileOrSTDIN(Filename, MB, FileSize);
- Result = std::move(MB);
- return ec;
-}
-
//===----------------------------------------------------------------------===//
// MemoryBuffer::getFile implementation.
RequiresNullTerminator, IsVolatileSize);
}
-error_code MemoryBuffer::getFile(Twine Filename,
- OwningPtr<MemoryBuffer> &Result,
- int64_t FileSize,
- bool RequiresNullTerminator,
- bool IsVolatileSize) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getFile(Filename, MB, FileSize, RequiresNullTerminator,
- IsVolatileSize);
- Result = std::move(MB);
- return ec;
-}
-
static error_code getOpenFileImpl(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t FileSize, uint64_t MapSize,
RequiresNullTerminator, IsVolatileSize);
}
-error_code MemoryBuffer::getOpenFile(int FD, const char *Filename,
- OwningPtr<MemoryBuffer> &Result,
- uint64_t FileSize,
- bool RequiresNullTerminator,
- bool IsVolatileSize) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getOpenFileImpl(FD, Filename, MB, FileSize, FileSize, 0,
- RequiresNullTerminator, IsVolatileSize);
- Result = std::move(MB);
- return ec;
-}
-
error_code MemoryBuffer::getOpenFileSlice(int FD, const char *Filename,
std::unique_ptr<MemoryBuffer> &Result,
uint64_t MapSize, int64_t Offset,
IsVolatileSize);
}
-error_code MemoryBuffer::getOpenFileSlice(int FD, const char *Filename,
- OwningPtr<MemoryBuffer> &Result,
- uint64_t MapSize, int64_t Offset,
- bool IsVolatileSize) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getOpenFileImpl(FD, Filename, MB, -1, MapSize, Offset, false,
- IsVolatileSize);
- Result = std::move(MB);
- return ec;
-}
-
//===----------------------------------------------------------------------===//
// MemoryBuffer::getSTDIN implementation.
//===----------------------------------------------------------------------===//
return getMemoryBufferForStream(0, "<stdin>", Result);
}
-
-error_code MemoryBuffer::getSTDIN(OwningPtr<MemoryBuffer> &Result) {
- std::unique_ptr<MemoryBuffer> MB;
- error_code ec = getSTDIN(MB);
- Result = std::move(MB);
- return ec;
-}
projects / oota-llvm.git / commitdiff