TPEF::TPEFWriter Class Reference

#include <TPEFWriter.hh>

Inheritance diagram for TPEF::TPEFWriter:

Collaboration diagram for TPEF::TPEFWriter:

Static Public Member Functions
static const BinaryWriter &	instance ()

Protected Member Functions
	TPEFWriter ()
	~TPEFWriter ()
virtual void	actualWriteBinary (BinaryStream &stream, const Binary *bin) const
Protected Member Functions inherited from TPEF::BinaryWriter
	BinaryWriter ()
void	setWriter (const BinaryWriter *writer)

Static Private Attributes
static BinaryWriter *	instance_ = NULL
	Instance which is used for writing binary file.

Additional Inherited Members
Public Member Functions inherited from TPEF::BinaryWriter
virtual	~BinaryWriter ()
void	writeBinary (BinaryStream &stream, const Binary *bin) const

Detailed Description

Class for writing TPEF binary files.

Definition at line 44 of file TPEFWriter.hh.

Constructor & Destructor Documentation

TPEFWriter()

TPEF::TPEFWriter::TPEFWriter ( )

protected

Constructor.

Definition at line 55 of file TPEFWriter.cc.

                       : BinaryWriter() {
    setWriter(this);
}

References TPEF::BinaryWriter::setWriter().

Referenced by instance().

Here is the call graph for this function:

~TPEFWriter()

TPEF::TPEFWriter::~TPEFWriter ( )

protected

Destructor.

Definition at line 62 of file TPEFWriter.cc.

                        {
}

Member Function Documentation

actualWriteBinary()

void TPEF::TPEFWriter::actualWriteBinary ( BinaryStream &  stream, const Binary *  bin  ) const

protectedvirtual

Writes binary object model in to a binary stream.

Parameters

stream	Stream where to write.
bin	Binary to write.

Implements TPEF::BinaryWriter.

Definition at line 84 of file TPEFWriter.cc.

                             {
 
    // check that there is only one resource section and null section
    if (bin->sectionCount(Section::ST_ADDRSP) > 1 ||
        bin->sectionCount(Section::ST_MR) > 1) {
        
        bool onlyOneAddressSpaceAndResourceSectionIsAllowed = false;
        assert(onlyOneAddressSpaceAndResourceSectionIsAllowed);
    }
    
    FileOffset startOffset = stream.writePosition();
 
    // file header must be written first
    stream.setWritePosition(startOffset + TPEFHeaders::FH_ID);
    for (Word i = 0; i < TPEFHeaders::FH_ID_SIZE; i++) {
        // sets stream tpef version same as binary version
        if (i == 8) {
            TPEFHeaders::TPEFVersion version = bin->TPEFVersion();
            stream.setTPEFVersion(version);
            stream.writeByte(version);
        } else {
            stream.writeByte(TPEFHeaders::FH_ID_BYTES[i]);
        }
    }
    
    stream.setWritePosition(startOffset + TPEFHeaders::FH_ARCH);
    stream.writeByte(bin->arch());
    
    stream.setWritePosition(startOffset + TPEFHeaders::FH_TYPE);
    stream.writeByte(bin->type());
 
    // offset to the first section header
    stream.setWritePosition(startOffset + TPEFHeaders::FH_SHOFF);
    stream.writeWord(TPEFHeaders::FH_HEADER_SIZE);
 
    // size of file header
    stream.setWritePosition(startOffset + TPEFHeaders::FH_SIZE);
    stream.writeHalfWord(TPEFHeaders::FH_HEADER_SIZE);
 
    stream.setWritePosition(startOffset + TPEFHeaders::FH_SHSIZE);
    stream.writeHalfWord(TPEFHeaders::SH_HEADER_SIZE);
 
    // number of sections
    stream.setWritePosition(startOffset + TPEFHeaders::FH_SHNUM);
    stream.writeHalfWord(bin->sectionCount());
 
    // file offset to the header of string table section
    stream.setWritePosition(startOffset + TPEFHeaders::FH_SHSTRTAB);
    if (bin->strings() != NULL) {
        FileOffsetReplacer replacer(bin->strings());
        replacer.resolve();
    } else {
        stream.writeWord(0);
    }
 
    // offset of first header
    FileOffset sectionHeaderOffset = TPEFHeaders::FH_HEADER_SIZE;
 
    Section* section = NULL;
 
    for (Word i = 0; i < bin->sectionCount(); i++) {
        section = bin->section(i);
        try {
            stream.setWritePosition(startOffset + sectionHeaderOffset);
            SectionWriter::writeHeader(stream, section, this);
            sectionHeaderOffset += TPEFHeaders::SH_HEADER_SIZE;
 
        } catch (const InstanceNotFound& i) {
            std::cerr << "Writer for a section header not found"
                      << std::endl;
            continue;
        }
    }
 
    // then the section bodies
    for (Word i = 0; i < bin->sectionCount(); i++) {
        section = bin->section(i);
        try {
            if (!section->noBits()) {
                SectionWriter::writeData(stream, section, this);
            } else {
                // TODO: If we are in this branch verify that there is
                //       only undef elements in section.
                //       i.e. verify that section is empty...
            }
        } catch(const InstanceNotFound& i) {
            abortWithError("Writer for a section body not found");
        }
    }
}

References abortWithError, TPEF::Binary::arch(), assert, TPEF::TPEFHeaders::FH_ARCH, TPEF::TPEFHeaders::FH_HEADER_SIZE, TPEF::TPEFHeaders::FH_ID, TPEF::TPEFHeaders::FH_ID_BYTES, TPEF::TPEFHeaders::FH_ID_SIZE, TPEF::TPEFHeaders::FH_SHNUM, TPEF::TPEFHeaders::FH_SHOFF, TPEF::TPEFHeaders::FH_SHSIZE, TPEF::TPEFHeaders::FH_SHSTRTAB, TPEF::TPEFHeaders::FH_SIZE, TPEF::TPEFHeaders::FH_TYPE, TPEF::Section::noBits(), TPEF::ValueReplacer::resolve(), TPEF::Binary::section(), TPEF::Binary::sectionCount(), TPEF::BinaryStream::setTPEFVersion(), TPEF::BinaryStream::setWritePosition(), TPEF::TPEFHeaders::SH_HEADER_SIZE, TPEF::Section::ST_ADDRSP, TPEF::Section::ST_MR, TPEF::Binary::strings(), TPEF::Binary::TPEFVersion(), TPEF::Binary::type(), TPEF::BinaryStream::writeByte(), TPEF::SectionWriter::writeData(), TPEF::BinaryStream::writeHalfWord(), TPEF::SectionWriter::writeHeader(), TPEF::BinaryStream::writePosition(), and TPEF::BinaryStream::writeWord().

Here is the call graph for this function:

instance()

const BinaryWriter & TPEF::TPEFWriter::instance ( )

static

Returns an instance of this class (singleton).

Returns

Instance of class.

Definition at line 70 of file TPEFWriter.cc.

                                         {
    if (instance_ == NULL) {
        instance_ = new TPEFWriter();
    }
    return *instance_;
}

References instance_, and TPEFWriter().

Referenced by main(), TPEF::TPEFSectionWriter::parent(), and TTAProgram::Program::writeToTPEF().

Here is the call graph for this function:

Member Data Documentation

instance_

BinaryWriter * TPEF::TPEFWriter::instance_ = NULL

staticprivate

Instance which is used for writing binary file.

Definition at line 58 of file TPEFWriter.hh.

Referenced by instance().

---

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

• TPEFWriter.hh
• TPEFWriter.cc