1 //===- BinaryStreamReader.cpp - Reads objects from a binary stream --------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/Support/BinaryStreamReader.h"
12 #include "llvm/Support/BinaryStreamError.h"
13 #include "llvm/Support/BinaryStreamRef.h"
16 using endianness = llvm::support::endianness;
18 BinaryStreamReader::BinaryStreamReader(BinaryStreamRef Ref) : Stream(Ref) {}
20 BinaryStreamReader::BinaryStreamReader(BinaryStream &Stream) : Stream(Stream) {}
22 BinaryStreamReader::BinaryStreamReader(ArrayRef<uint8_t> Data,
24 : Stream(Data, Endian) {}
26 BinaryStreamReader::BinaryStreamReader(StringRef Data, endianness Endian)
27 : Stream(Data, Endian) {}
29 Error BinaryStreamReader::readLongestContiguousChunk(
30 ArrayRef<uint8_t> &Buffer) {
31 if (auto EC = Stream.readLongestContiguousChunk(Offset, Buffer))
33 Offset += Buffer.size();
34 return Error::success();
37 Error BinaryStreamReader::readBytes(ArrayRef<uint8_t> &Buffer, uint32_t Size) {
38 if (auto EC = Stream.readBytes(Offset, Size, Buffer))
41 return Error::success();
44 Error BinaryStreamReader::readCString(StringRef &Dest) {
45 uint32_t OriginalOffset = getOffset();
46 uint32_t FoundOffset = 0;
48 uint32_t ThisOffset = getOffset();
49 ArrayRef<uint8_t> Buffer;
50 if (auto EC = readLongestContiguousChunk(Buffer))
52 StringRef S(reinterpret_cast<const char *>(Buffer.begin()), Buffer.size());
53 size_t Pos = S.find_first_of('\0');
54 if (LLVM_LIKELY(Pos != StringRef::npos)) {
55 FoundOffset = Pos + ThisOffset;
59 assert(FoundOffset >= OriginalOffset);
61 setOffset(OriginalOffset);
62 size_t Length = FoundOffset - OriginalOffset;
64 if (auto EC = readFixedString(Dest, Length))
67 // Now set the offset back to after the null terminator.
68 setOffset(FoundOffset + 1);
69 return Error::success();
72 Error BinaryStreamReader::readFixedString(StringRef &Dest, uint32_t Length) {
73 ArrayRef<uint8_t> Bytes;
74 if (auto EC = readBytes(Bytes, Length))
76 Dest = StringRef(reinterpret_cast<const char *>(Bytes.begin()), Bytes.size());
77 return Error::success();
80 Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref) {
81 return readStreamRef(Ref, bytesRemaining());
84 Error BinaryStreamReader::readStreamRef(BinaryStreamRef &Ref, uint32_t Length) {
85 if (bytesRemaining() < Length)
86 return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
87 Ref = Stream.slice(Offset, Length);
89 return Error::success();
92 Error BinaryStreamReader::skip(uint32_t Amount) {
93 if (Amount > bytesRemaining())
94 return make_error<BinaryStreamError>(stream_error_code::stream_too_short);
96 return Error::success();
99 Error BinaryStreamReader::padToAlignment(uint32_t Align) {
100 uint32_t NewOffset = alignTo(Offset, Align);
101 return skip(NewOffset - Offset);
104 uint8_t BinaryStreamReader::peek() const {
105 ArrayRef<uint8_t> Buffer;
106 auto EC = Stream.readBytes(Offset, 1, Buffer);
107 assert(!EC && "Cannot peek an empty buffer!");
108 llvm::consumeError(std::move(EC));
112 std::pair<BinaryStreamReader, BinaryStreamReader>
113 BinaryStreamReader::split(uint32_t Off) const {
114 assert(getLength() >= Off);
116 BinaryStreamRef First = Stream.drop_front(Offset);
118 BinaryStreamRef Second = First.drop_front(Off);
119 First = First.keep_front(Off);
120 BinaryStreamReader W1{First};
121 BinaryStreamReader W2{Second};
122 return std::make_pair(W1, W2);