#include <BinaryStream.hh>

Collaboration diagram for TPEF::BinaryStream:

Public Member Functions
	BinaryStream (std::ostream &stream, bool littleEndian=false)

	BinaryStream (std::string name, bool littleEndian=false)

virtual	~BinaryStream ()

Byte	readByte ()

HalfWord	readHalfWord ()

Word	readWord ()

void	readByteBlock (Byte *buffer, unsigned int howmany)

void	readHalfWordBlock (HalfWord *buffer, unsigned int howmany)

void	readWordBlock (Word *buffer, unsigned int howmany)

void	writeByte (Byte byte)

void	writeHalfWord (HalfWord halfword)

void	writeWord (Word word)

void	writeByteBlock (Byte *bytes, unsigned int howmany)

void	writeHalfWordBlock (HalfWord *hwords, unsigned int howmany)

void	writeWordBlock (Word *words, unsigned int howmany)

unsigned int	readPosition ()

unsigned int	writePosition ()

void	setReadPosition (unsigned int position)

void	setWritePosition (unsigned int position)

bool	endOfFile ()

unsigned int	sizeOfFile ()

void	setTPEFVersion (TPEFHeaders::TPEFVersion version)

TPEFHeaders::TPEFVersion	TPEFVersion () const

Private Member Functions
BinaryStream &	operator= (BinaryStream &old)
	Assignment not allowed. More...

	BinaryStream (BinaryStream &old)
	Copying not allowed. More...

void	openInput (std::string name)

void	openOutput (std::string name)

void	close ()

Byte	getByte ()

void	putByte (Byte byte)

bool	needsSwap () const

Private Attributes
std::ifstream	iStream_
	The input stream. More...

std::ofstream	oStream_
	The output stream. More...

std::string	fileName_
	The name of the stream. More...

std::ostream *	extOStream_
	Externally given output stream. More...

bool	littleEndianStorage_
	In case we want to store the words in little endian order, big endian otherwise. More...

TPEFHeaders::TPEFVersion	tpefVersion_
	Indicates TPEF format version used. More...

Detailed Description

Abstracts the input/output binary stream used to read and write TTA programs.

It takes care of opening and closing the streams automatically, and hides possible byte order mismatch.

The bits read from the stream are converted to the byte order of the host machine. Conversely, the bits written into the stream will be converted to the standard byte order of TTA Program Exchange Format files which adheres to the byte order of the ADF the TPEF is associated with (by default big endian).

Definition at line 59 of file BinaryStream.hh.

Constructor & Destructor Documentation

◆ BinaryStream() [1/3]

TPEF::BinaryStream::BinaryStream	(	std::ostream &	stream,
		bool	littleEndian = `false`
	)

Definition at line 50 of file BinaryStream.cc.

                                                                : 
     fileName_(""), extOStream_(&stream), littleEndianStorage_(littleEndian),
     tpefVersion_(TPEFHeaders::TPEF_V2) {
 }

◆ BinaryStream() [2/3]

TPEF::BinaryStream::BinaryStream	(	std::string	name,
		bool	littleEndian = `false`
	)

Prepares the binary stream so that it can be read from / written to.

The input string is used as the name of the file to open (if existing) or to create (if not existing).

Parameters

name	is the name of the input file.

Note: The initial read and write positions of the stream are 0.

Definition at line 64 of file BinaryStream.cc.

                                                            : 
     fileName_(name), extOStream_(NULL), littleEndianStorage_(littleEndian),
     tpefVersion_(TPEFHeaders::TPEF_V1) {
 }

◆ ~BinaryStream()

TPEF::BinaryStream::~BinaryStream ( )

virtual

Closes the stream.

No other cleanup or deallocation activity is required.

Note: Only way of closing and flushing the actual output stream can be done be calling the destructor (through deletion of the object).

Definition at line 107 of file BinaryStream.cc.

                             {
     close();
 }

References close().

Here is the call graph for this function:

◆ BinaryStream() [3/3]

TPEF::BinaryStream::BinaryStream ( BinaryStream & old )

private

Copying not allowed.

Member Function Documentation

◆ close()

void TPEF::BinaryStream::close ( )

private

Closes the stream.

Definition at line 544 of file BinaryStream.cc.

                     {
     if (iStream_.is_open()) {
         iStream_.close();
     }
     if (oStream_.is_open()) {
         oStream_.close();
     }
 }

References iStream_, and oStream_.

Referenced by ~BinaryStream().

◆ endOfFile()

bool TPEF::BinaryStream::endOfFile ( )

Returns true if read position is at the end of file.

Exceptions

UnreachableStream If stream is bad or otherwise unreachable.

Definition at line 722 of file BinaryStream.cc.

                         {
     if (extOStream_ != NULL) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, "External stream is write-only.");
     }
  
     if (!iStream_.is_open()) {
         try {
             openInput(fileName_);
  
         } catch (const UnreachableStream& error) {
             UnreachableStream newException =
                 UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
             newException.setCause(error);
             throw newException;
         }
     }
  
     if (iStream_.bad()) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, fileName_);
     }
  
     return iStream_.eof();
 }

References __func__, extOStream_, fileName_, iStream_, openInput(), and Exception::setCause().

Here is the call graph for this function:

◆ getByte()

Byte TPEF::BinaryStream::getByte ( )

private

Referenced by readByte(), and readByteBlock().

◆ needsSwap()

bool TPEF::BinaryStream::needsSwap ( ) const

private

Returns true in case words should be swapped due to mismatch between the host and current target (TTA) endianness.

Definition at line 74 of file BinaryStream.cc.

                               {
     return (littleEndianStorage_ && (HOST_BIGENDIAN == 1)) ||
         (!littleEndianStorage_ && (HOST_BIGENDIAN == 0));
 }

References HOST_BIGENDIAN, and littleEndianStorage_.

Referenced by readHalfWord(), readWord(), writeHalfWord(), and writeWord().

◆ openInput()

void TPEF::BinaryStream::openInput ( std::string name )

private

Opens the binary file for input.

Parameters

name	Name of the input file.

Exceptions

UnreachableStream If file is not found or is unreadable.

Note: The initial read position is 0.

Definition at line 484 of file BinaryStream.cc.

                                       {
     if (extOStream_ != NULL) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, "External stream is write-only.");
     }
  
     iStream_.open(name.c_str());
  
     if (!iStream_.is_open()) {
         const std::string error = (boost::format(
             "File '%s' could not be opened for input.") % name).str();
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, error);
     }
     if (oStream_.is_open()) {
         oStream_.flush();
     }
     iStream_.tie(&oStream_);
 }

References __func__, extOStream_, iStream_, and oStream_.

Referenced by endOfFile(), readPosition(), setReadPosition(), and sizeOfFile().

◆ openOutput()

void TPEF::BinaryStream::openOutput ( std::string name )

private

Opens the binary file for output.

If a file doesn't exist, a new empty file will be created.

Parameters

name	Name of the output file.

Exceptions

UnreachableStream If file cannot be opened.

Note: The initial write position is 0.

Definition at line 514 of file BinaryStream.cc.

                                        {
     if (extOStream_ != NULL) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, 
             "External stream should be always open.");
     }
  
     oStream_.open(name.c_str(), fstream::out);
  
     // With some versions of STL a non-existing file is not
     // automatically created when using only 'out'-flag. In that case,
     // we have to open the stream in truncate mode to force the creating
     // of the empty file.
     if (!oStream_.is_open()) {
         oStream_.clear();
         oStream_.open(name.c_str(), fstream::out | fstream::trunc);
     }
  
     if (!oStream_.is_open()) {
         const std::string error = (boost::format(
              "File '%s' could not be opened for output.") % fileName_).str();        
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, error);
     }
 }

References __func__, extOStream_, fileName_, and oStream_.

Referenced by setWritePosition(), and writePosition().

◆ operator=()

BinaryStream& TPEF::BinaryStream::operator= ( BinaryStream & old )

private

Assignment not allowed.

◆ putByte()

void TPEF::BinaryStream::putByte ( Byte byte )

private

Referenced by writeByte(), and writeByteBlock().

◆ readByte()

Byte TPEF::BinaryStream::readByte ( )

Reads one Byte from the binary stream.

Returns: The next 8-bit byte from the stream.

Exceptions

UnreachableStream	If reading from the stream fails.
EndOfFile	If end of file were reached.

Definition at line 120 of file BinaryStream.cc.

                        {
     Byte value;
  
     try {
         value = getByte();
  
     } catch (const EndOfFile& error) {
         EndOfFile newException =
             EndOfFile(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
  
     return value;
 }

References __func__, fileName_, getByte(), and Exception::setCause().

Here is the call graph for this function:

◆ readByteBlock()

void TPEF::BinaryStream::readByteBlock	(	Byte *	buffer,
		unsigned int	howmany
	)

Reads a block of Bytes from the binary stream.

Parameters

buffer	is where the bytes are returned.
howmany	is how many bytes are supposed to be read.

Exceptions

UnreachableStream	If reading from the stream fails.
EndOfFile	If end of file were reached.

Definition at line 225 of file BinaryStream.cc.

                                                               {
     try {
         for (unsigned int i = 0; i < howmany; i++) {
             buffer[i] = getByte();
         }
  
     } catch (const EndOfFile& error) {
         EndOfFile newException =
             EndOfFile(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, getByte(), and Exception::setCause().

Referenced by readHalfWord(), and readWord().

Here is the call graph for this function:

◆ readHalfWord()

HalfWord TPEF::BinaryStream::readHalfWord ( )

Reads one HalfWord from the binary stream.

Returns: The next 16-bit word (half-word) from the stream.

Exceptions

UnreachableStream	If reading from the stream fails.
EndOfFile	If end of file were reached.

Definition at line 150 of file BinaryStream.cc.

                            {
     union {
         Byte buffer[sizeof(HalfWord)];
         HalfWord result;
     } U;
  
     try {
         readByteBlock(U.buffer, sizeof(HalfWord));
  
     } catch (const EndOfFile& error) {
         EndOfFile newException =
             EndOfFile(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
  
     // convert half-word to host endianess
     if (needsSwap())
         Swapper::swap(U.buffer, (Byte*)&U.result, sizeof(U.result));
  
     return U.result;
 }

References __func__, fileName_, needsSwap(), readByteBlock(), Exception::setCause(), and TPEF::Swapper::swap().

Referenced by TPEF::AOutTextSectionReader::initializeImmediateMove(), TPEF::AOutTextSectionReader::initializeMove(), TPEF::AOutSymbolSectionReader::initializeSymbol(), TPEF::AOutReader::isMyStreamType(), TPEF::TPEFDebugSectionReader::readData(), TPEF::TPEFSymbolSectionReader::readData(), TPEF::TPEFLineNumSectionReader::readData(), TPEF::TPEFResourceSectionReader::readData(), TPEF::TPEFCodeSectionReader::readData(), TPEF::TPEFSectionReader::readData(), TPEF::TPEFReader::readData(), readHalfWordBlock(), TPEF::AOutReader::readHeader(), TPEF::TPEFCodeSectionReader::readId(), TPEF::TPEFCodeSectionReader::readInfo(), TPEF::TPEFLineNumSectionReader::readInfo(), and TPEF::TPEFRelocSectionReader::readInfo().

Here is the call graph for this function:

◆ readHalfWordBlock()

void TPEF::BinaryStream::readHalfWordBlock	(	HalfWord *	buffer,
		unsigned int	howmany
	)

Reads a block of HalfWords from the binary stream.

Parameters

buffer	is where the halfwords are returned.
howmany	is how many halfwords are supposed to be read.

Exceptions

UnreachableStream	If reading from the stream fails.
EndOfFile	If end of file were reached.

Definition at line 254 of file BinaryStream.cc.

                                                                       {
     try {
         for (unsigned int i = 0; i < howmany; i++) {
             buffer[i] = readHalfWord();
         }
  
     } catch (const EndOfFile& error) {
         EndOfFile newException =
             EndOfFile(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, readHalfWord(), and Exception::setCause().

Here is the call graph for this function:

◆ readPosition()

unsigned int TPEF::BinaryStream::readPosition ( )

Returns the current position of the read cursor.

Exceptions

UnreachableStream If stream is bad or otherwise unreachable.

Definition at line 561 of file BinaryStream.cc.

                            {
     if (extOStream_ != NULL) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, "External stream is write-only.");
     }
  
     if (!iStream_.is_open()) {
         try {
             openInput(fileName_);
         } catch (const UnreachableStream& error) {
             UnreachableStream newException =
                 UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
             newException.setCause(error);
             throw newException;
         }
     }
  
     if (iStream_.bad()) {
         throw UnreachableStream(__FILE__, __LINE__,
                                 "BinaryStream::readPosition", fileName_);
     }
     return iStream_.tellg();
 }

References __func__, extOStream_, fileName_, iStream_, openInput(), and Exception::setCause().

Here is the call graph for this function:

◆ readWord()

Word TPEF::BinaryStream::readWord ( )

Reads one Word from the binary stream.

Returns: The next 32-bit word from the stream.

Exceptions

UnreachableStream	If reading from the stream fails.
EndOfFile	If end of file were reached.

Definition at line 187 of file BinaryStream.cc.

                        {
     union {
         Byte buffer[sizeof(Word)];
         Word result;
     } U;
  
     try {
         readByteBlock(U.buffer, sizeof(Word));
  
     } catch (const EndOfFile& error) {
         EndOfFile newException =
             EndOfFile(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
  
     // convert word to host endianess
     if (needsSwap())
         Swapper::swap(U.buffer, (Byte*)&U.result, sizeof(U.result));
     
     return U.result;
 }

References __func__, fileName_, needsSwap(), readByteBlock(), Exception::setCause(), and TPEF::Swapper::swap().

Referenced by TPEF::AOutTextSectionReader::initializeImmediateMove(), TPEF::AOutTextSectionReader::initializeMove(), TPEF::AOutRelocationSectionReader::initializeRelocElement(), TPEF::AOutSymbolSectionReader::initializeSymbol(), TPEF::TPEFDebugSectionReader::readData(), TPEF::TPEFASpaceSectionReader::readData(), TPEF::TPEFLineNumSectionReader::readData(), TPEF::TPEFSymbolSectionReader::readData(), TPEF::TPEFResourceSectionReader::readData(), TPEF::TPEFRelocSectionReader::readData(), TPEF::TPEFSectionReader::readData(), TPEF::TPEFReader::readData(), TPEF::AOutReader::readHeader(), TPEF::TPEFSectionReader::readInfo(), and readWordBlock().

Here is the call graph for this function:

◆ readWordBlock()

void TPEF::BinaryStream::readWordBlock	(	Word *	buffer,
		unsigned int	howmany
	)

Reads a block of Words from the binary stream.

Parameters

buffer	is where the words are returned.
howmany	is how many words are supposed to be read.

Exceptions

UnreachableStream	If reading from the stream fails.
EndOfFile	If end of file were reached.

Definition at line 283 of file BinaryStream.cc.

                                                               {
     try {
         for (unsigned int i = 0; i < howmany; i++) {
             buffer[i] = readWord();
         }
     } catch (const EndOfFile& error) {
         EndOfFile newException =
             EndOfFile(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, readWord(), and Exception::setCause().

Here is the call graph for this function:

◆ setReadPosition()

void TPEF::BinaryStream::setReadPosition ( unsigned int position )

Sets the read cursor position in the stream.

If the stream has reached end-of-file, and read position is then set before eof, eof-status is automatically cleared and reading is again possible. Setting position beyond eof doesn't immediately set eof-status, instead, it is only set after trying to read past eof.

Parameters

position New read cursor position.

Exceptions

UnreachableStream If stream is bad or otherwise unreachable.

Definition at line 629 of file BinaryStream.cc.

                                                    {
     if (extOStream_ != NULL) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, "External stream is write-only.");
     }
  
     if (!iStream_.is_open()) {
         try {
             openInput(fileName_);
  
         } catch (const UnreachableStream& error) {
             UnreachableStream newException =
                 UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
             newException.setCause(error);
             throw newException;
         }
     }
     if (iStream_.bad()) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, fileName_);
     }
  
     // if eof is already reached, the stream must be cleared to make it
     // accessible again
     bool eof = false;
     if (iStream_.eof()) {
         eof = true;
         iStream_.clear();
     }
  
     // possible eof-status is cleared if the position is set before eof
     iStream_.seekg(0, ios::end);
     unsigned int fileSize = iStream_.tellg();
     if (position <= fileSize) {
         iStream_.clear();
         eof = false;
     }
  
     iStream_.seekg(position);
  
     // return the eof status if it has been cleared earlier to access the
     // stream and read position is not set before eof
     if (eof) {
         iStream_.setstate(ios::eofbit);
     }
 }

References __func__, extOStream_, fileName_, iStream_, openInput(), and Exception::setCause().

Referenced by TPEF::TPEFReader::isMyStreamType(), TPEF::AOutReader::isMyStreamType(), Assembler::readAssemblerCode(), TPEF::TPEFASpaceSectionReader::readData(), TPEF::TPEFDebugSectionReader::readData(), TPEF::TPEFResourceSectionReader::readData(), TPEF::TPEFLineNumSectionReader::readData(), TPEF::TPEFSymbolSectionReader::readData(), TPEF::TPEFRelocSectionReader::readData(), TPEF::TPEFSectionReader::readData(), TPEF::TPEFReader::readData(), and sizeOfFile().

Here is the call graph for this function:

◆ setTPEFVersion()

void TPEF::BinaryStream::setTPEFVersion ( TPEFHeaders::TPEFVersion version )

Sets TPEF version to be used.

Parameters

version TPEF format version.

Definition at line 86 of file BinaryStream.cc.

                                                            {
     tpefVersion_ = version;
 }

References tpefVersion_.

Referenced by TPEF::TPEFWriter::actualWriteBinary(), and TPEF::TPEFReader::readData().

◆ setWritePosition()

void TPEF::BinaryStream::setWritePosition ( unsigned int position )

Sets the write cursor position in the stream.

If write position is located past the end of the file and writing to the stream is attempted, WritePastEOF exception will be thrown.

See also: putByte

Parameters

position New write cursor position.

Exceptions

UnreachableStream If stream is bad or otherwise unreachable.

Definition at line 689 of file BinaryStream.cc.

                                                     {
     if (extOStream_ != NULL) {
         extOStream_->seekp(position);    
         return;
     }
  
     if (!oStream_.is_open()) {
         try {
             openOutput(fileName_);
  
         } catch (const UnreachableStream& error) {
             UnreachableStream newException =
                 UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
             newException.setCause(error);
             throw newException;
         }
     }
  
     if (oStream_.bad()) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, fileName_);
     }
  
     oStream_.seekp(position);
 }

References __func__, extOStream_, fileName_, openOutput(), oStream_, and Exception::setCause().

Referenced by TPEF::TPEFWriter::actualWriteBinary(), TPEF::TPEFSectionWriter::actualWriteHeader(), sizeOfFile(), TPEF::SectionOffsetReplacer::tryToReplace(), TPEF::SectionIdReplacer::tryToReplace(), TPEF::SectionIndexReplacer::tryToReplace(), TPEF::FileOffsetReplacer::tryToReplace(), and TPEF::SectionSizeReplacer::tryToReplace().

Here is the call graph for this function:

◆ sizeOfFile()

unsigned int TPEF::BinaryStream::sizeOfFile ( )

Checks the size of the file being handled.

First tries to check the size from output stream, if it's not opened, tries to check from input stream.

Exceptions

UnreachableStream If stream is bad or file does not exist.

Note: UnreachableStream is also generated if file is existing with only write rights and it is not yet opened for writing. This is because of restricted file handling abilities of C++ standard library.

Returns: The size of the file.

Definition at line 764 of file BinaryStream.cc.

                          {
     if (extOStream_ != NULL) {
         unsigned int currentPos =  extOStream_->tellp();
         extOStream_->seekp(0, ios::end);
         unsigned int fileSize = extOStream_->tellp();
         extOStream_->seekp(currentPos, ios::end);
         return fileSize;
     }
  
     if (oStream_.is_open()) {
         unsigned int currentPos = writePosition();
         oStream_.seekp(0, ios::end);
         unsigned int fileSize = oStream_.tellp();
         setWritePosition(currentPos);
         return fileSize;
  
     } else if (!iStream_.is_open()) {
         try {
             openInput(fileName_);
  
         } catch (const UnreachableStream& error) {
             UnreachableStream newException =
                 UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
             newException.setCause(error);
             throw newException;
         }
     }
  
     if (iStream_.bad()) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, fileName_);
     }
  
     unsigned int currentPos = readPosition();
     iStream_.seekg(0, ios::end);
     unsigned int fileSize = iStream_.tellg();
     setReadPosition(currentPos);
     return fileSize;
 }

References __func__, extOStream_, fileName_, iStream_, openInput(), oStream_, readPosition(), Exception::setCause(), setReadPosition(), setWritePosition(), and writePosition().

Referenced by TPEF::AOutReader::isMyStreamType(), Assembler::readAssemblerCode(), and TPEF::AOutReader::readHeader().

Here is the call graph for this function:

◆ TPEFVersion()

TPEFHeaders::TPEFVersion TPEF::BinaryStream::TPEFVersion ( ) const

Returns TPEF version being used.

Definition at line 95 of file BinaryStream.cc.

                                 {
     return tpefVersion_;
 }

References tpefVersion_.

Referenced by TPEF::TPEFCodeSectionReader::readId(), and TPEF::TPEFCodeSectionWriter::writeId().

◆ writeByte()

void TPEF::BinaryStream::writeByte ( Byte byte )

Writes one Byte to the binary stream.

Parameters

byte	The Byte to write to the stream.

Exceptions

UnreachableStream	If writing to stream fails.
WritePastEOF	If tried to write past end of file.

Definition at line 310 of file BinaryStream.cc.

                                  {
     try {
         putByte(byte);
  
     } catch (const WritePastEOF& error) {
         WritePastEOF newException =
             WritePastEOF(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, putByte(), and Exception::setCause().

Referenced by TPEF::TPEFWriter::actualWriteBinary(), TPEF::TPEFStringSectionWriter::actualWriteData(), TPEF::TPEFResourceSectionWriter::actualWriteData(), TPEF::TPEFRelocSectionWriter::actualWriteData(), TPEF::TPEFDataSectionWriter::actualWriteData(), TPEF::TPEFDebugSectionWriter::actualWriteData(), TPEF::TPEFSymbolSectionWriter::actualWriteData(), TPEF::TPEFSectionWriter::actualWriteHeader(), TPEF::TPEFCodeSectionWriter::writeAnnotations(), TPEF::TPEFCodeSectionWriter::writeAttributeField(), TPEF::TPEFCodeSectionWriter::writeDataField(), TPEF::TPEFASpaceSectionWriter::writeElement(), TPEF::TPEFCodeSectionWriter::writeId(), TPEF::TPEFCodeSectionWriter::writeInfo(), and TPEF::SectionIndexReplacer::writeReplacement().

Here is the call graph for this function:

◆ writeByteBlock()

void TPEF::BinaryStream::writeByteBlock	(	Byte *	bytes,
		unsigned int	howmany
	)

Writes a block of Bytes to the binary stream.

Parameters

bytes	The block of Bytes to be written.
howmany	How many Bytes to write.

Exceptions

UnreachableStream	If writing to stream fails.
WritePastEOF	If tried to write past end of file.

Definition at line 401 of file BinaryStream.cc.

                                                               {
     try {
         for (unsigned int i = 0; i < howmany; i++) {
             putByte(bytes[i]);
         }
     } catch (const WritePastEOF& error) {
         WritePastEOF newException =
             WritePastEOF(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, putByte(), and Exception::setCause().

Referenced by writeHalfWord(), and writeWord().

Here is the call graph for this function:

◆ writeHalfWord()

void TPEF::BinaryStream::writeHalfWord ( HalfWord halfword )

Writes one HalfWord to the binary stream.

Parameters

halfword The HalfWord to write to the stream.

Exceptions

UnreachableStream	If writing to stream fails.
WritePastEOF	If tried to write past end of file.

Definition at line 336 of file BinaryStream.cc.

                                              {
     Byte buffer[sizeof(HalfWord)];
  
     // convert HalfWord to the target byte order.
     if (needsSwap())
         Swapper::swap((Byte*)&halfword, buffer, sizeof(HalfWord));
  
     try {
         writeByteBlock(buffer, sizeof(HalfWord));
  
     } catch (const WritePastEOF& error) {
         WritePastEOF newException =
             WritePastEOF(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, needsSwap(), Exception::setCause(), TPEF::Swapper::swap(), and writeByteBlock().

Referenced by TPEF::TPEFWriter::actualWriteBinary(), TPEF::TPEFLineNumSectionWriter::actualWriteData(), TPEF::TPEFResourceSectionWriter::actualWriteData(), TPEF::TPEFDebugSectionWriter::actualWriteData(), TPEF::TPEFSymbolSectionWriter::actualWriteData(), TPEF::TPEFSectionWriter::actualWriteHeader(), TPEF::SectionIdReplacer::tryToReplace(), TPEF::TPEFCodeSectionWriter::writeDataField(), writeHalfWordBlock(), TPEF::TPEFCodeSectionWriter::writeId(), TPEF::TPEFCodeSectionWriter::writeInfo(), TPEF::TPEFLineNumSectionWriter::writeInfo(), TPEF::TPEFRelocSectionWriter::writeInfo(), and TPEF::SectionIndexReplacer::writeReplacement().

Here is the call graph for this function:

◆ writeHalfWordBlock()

void TPEF::BinaryStream::writeHalfWordBlock	(	HalfWord *	halfwords,
		unsigned int	howmany
	)

Writes a block of HalfWords to the binary stream.

Parameters

halfwords	The block of HalfWords to be written.
howmany	How many HalfWords to write.

Exceptions

UnreachableStream	If writing to stream fails.
WritePastEOF	If tried to write past end of file.

Definition at line 429 of file BinaryStream.cc.

                                                                           {
     try {
         for (unsigned int i = 0; i < howmany; i++) {
             writeHalfWord(halfwords[i]);
         }
     } catch (const WritePastEOF& error) {
         WritePastEOF newException =
             WritePastEOF(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, Exception::setCause(), and writeHalfWord().

Here is the call graph for this function:

◆ writePosition()

unsigned int TPEF::BinaryStream::writePosition ( )

Returns the current position of the write cursor.

Exceptions

UnreachableStream If stream is bad or otherwise unreachable.

Definition at line 592 of file BinaryStream.cc.

                             {
     if (extOStream_ != NULL) {
         return extOStream_->tellp();
     }
  
     if (!oStream_.is_open()) {
         try {
             openOutput(fileName_);
  
         } catch (const UnreachableStream& error) {
             UnreachableStream newException =
                 UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
             newException.setCause(error);
             throw newException;
         }
     }
  
     if (oStream_.bad()) {
         throw UnreachableStream(
             __FILE__, __LINE__, __func__, fileName_);
     }
     return oStream_.tellp();
 }

References __func__, extOStream_, fileName_, openOutput(), oStream_, and Exception::setCause().

Here is the call graph for this function:

◆ writeWord()

void TPEF::BinaryStream::writeWord ( Word word )

Writes one Word to the binary stream.

Parameters

word	The Word to write to the stream.

Exceptions

UnreachableStream	If writing to stream fails.
WritePastEOF	If tried to write past end of file.

Definition at line 368 of file BinaryStream.cc.

                                  {
     Byte buffer[sizeof(Word)];
  
     // convert Word to the target byte order.
     if (needsSwap())
         Swapper::swap((Byte*)&word, buffer, sizeof(Word));
  
     try {
         writeByteBlock(buffer, sizeof(Word));
  
     } catch (const WritePastEOF& error) {
         WritePastEOF newException =
             WritePastEOF(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, needsSwap(), Exception::setCause(), TPEF::Swapper::swap(), and writeByteBlock().

Referenced by TPEF::TPEFWriter::actualWriteBinary(), TPEF::TPEFResourceSectionWriter::actualWriteData(), TPEF::TPEFDebugSectionWriter::actualWriteData(), TPEF::TPEFSectionWriter::actualWriteHeader(), TPEF::SectionOffsetReplacer::tryToReplace(), TPEF::FileOffsetReplacer::tryToReplace(), TPEF::SectionSizeReplacer::tryToReplace(), TPEF::TPEFSectionWriter::writeBodyStartOffset(), TPEF::TPEFSectionWriter::writeInfo(), TPEF::SectionIndexReplacer::writeReplacement(), TPEF::TPEFNullSectionWriter::writeSize(), TPEF::TPEFUDataSectionWriter::writeSize(), TPEF::TPEFSymbolSectionWriter::writeValueAndSize(), and writeWordBlock().

Here is the call graph for this function:

◆ writeWordBlock()

void TPEF::BinaryStream::writeWordBlock	(	Word *	words,
		unsigned int	howmany
	)

Writes a block of Words to the binary stream.

Parameters

words	The block of Words to be written.
howmany	How many Words to write.

Exceptions

UnreachableStream	If writing to stream fails.
WritePastEOF	If tried to write past end of file.

Definition at line 457 of file BinaryStream.cc.

                                                               {
     try {
         for (unsigned int i = 0; i < howmany; i++) {
             writeWord(words[i]);
         }
     } catch (const WritePastEOF& error) {
         WritePastEOF newException =
             WritePastEOF(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
  
     } catch (const UnreachableStream& error) {
         UnreachableStream newException =
             UnreachableStream(__FILE__, __LINE__, __func__, fileName_);
         newException.setCause(error);
         throw newException;
     }
 }

References __func__, fileName_, Exception::setCause(), and writeWord().

Here is the call graph for this function:

Member Data Documentation

◆ extOStream_

std::ostream* TPEF::BinaryStream::extOStream_

private

Externally given output stream.

Definition at line 100 of file BinaryStream.hh.

Referenced by endOfFile(), openInput(), openOutput(), readPosition(), setReadPosition(), setWritePosition(), sizeOfFile(), and writePosition().

◆ fileName_

std::string TPEF::BinaryStream::fileName_

private

The name of the stream.

Definition at line 97 of file BinaryStream.hh.

Referenced by endOfFile(), openOutput(), readByte(), readByteBlock(), readHalfWord(), readHalfWordBlock(), readPosition(), readWord(), readWordBlock(), setReadPosition(), setWritePosition(), sizeOfFile(), writeByte(), writeByteBlock(), writeHalfWord(), writeHalfWordBlock(), writePosition(), writeWord(), and writeWordBlock().

◆ iStream_

std::ifstream TPEF::BinaryStream::iStream_

private

The input stream.

Definition at line 93 of file BinaryStream.hh.

Referenced by close(), endOfFile(), openInput(), readPosition(), setReadPosition(), and sizeOfFile().

◆ littleEndianStorage_

bool TPEF::BinaryStream::littleEndianStorage_

private

In case we want to store the words in little endian order, big endian otherwise.

Definition at line 104 of file BinaryStream.hh.

Referenced by needsSwap().

◆ oStream_

std::ofstream TPEF::BinaryStream::oStream_

private

The output stream.

Definition at line 95 of file BinaryStream.hh.

Referenced by close(), openInput(), openOutput(), setWritePosition(), sizeOfFile(), and writePosition().

◆ tpefVersion_

TPEFHeaders::TPEFVersion TPEF::BinaryStream::tpefVersion_

private

Indicates TPEF format version used.

Definition at line 107 of file BinaryStream.hh.

Referenced by setTPEFVersion(), and TPEFVersion().

The documentation for this class was generated from the following files:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BinaryStream() [1/3]

◆ BinaryStream() [2/3]

◆ ~BinaryStream()

◆ BinaryStream() [3/3]

Member Function Documentation

◆ close()

◆ endOfFile()

◆ getByte()

◆ needsSwap()

◆ openInput()

◆ openOutput()

◆ operator=()

◆ putByte()

◆ readByte()

◆ readByteBlock()

◆ readHalfWord()

◆ readHalfWordBlock()

◆ readPosition()

◆ readWord()

◆ readWordBlock()

◆ setReadPosition()

◆ setTPEFVersion()

◆ setWritePosition()

◆ sizeOfFile()

◆ TPEFVersion()

◆ writeByte()

◆ writeByteBlock()

◆ writeHalfWord()

◆ writeHalfWordBlock()

◆ writePosition()

◆ writeWord()

◆ writeWordBlock()

Member Data Documentation

◆ extOStream_

◆ fileName_

◆ iStream_

◆ littleEndianStorage_

◆ oStream_

◆ tpefVersion_