TPEF::TPEFSectionWriter Class Reference

#include <TPEFSectionWriter.hh>

Inheritance diagram for TPEF::TPEFSectionWriter:

Collaboration diagram for TPEF::TPEFSectionWriter:

Protected Member Functions
	TPEFSectionWriter ()
virtual	~TPEFSectionWriter ()
virtual const BinaryWriter &	parent () const
virtual void	actualWriteHeader (BinaryStream &stream, const Section *sect) const
virtual void	actualWriteData (BinaryStream &stream, const Section *sect) const
virtual Section::SectionType	type () const =0
	Returns SectionTypet hat actual reader or writer instance can handle. More...
virtual void	createKeys (const Section *sect) const
virtual void	writeSize (BinaryStream &stream, const Section *sect) const
virtual void	writeInfo (BinaryStream &stream, const Section *sect) const
virtual SectionId	getSectionId () const
virtual Word	elementSize (const Section *section) const
Protected Member Functions inherited from TPEF::SectionWriter
	SectionWriter ()
virtual	~SectionWriter ()
virtual void	finalize (BinaryStream &stream, Section *section) const

Private Member Functions
	TPEFSectionWriter (const TPEFSectionWriter &)
void	writeBodyStartOffset (BinaryStream &stream, const Section *sect) const

Additional Inherited Members
Static Public Member Functions inherited from TPEF::SectionWriter
static void	writeHeader (BinaryStream &stream, const Section *sect, const BinaryWriter *writer)
static void	writeData (BinaryStream &stream, const Section *sect, const BinaryWriter *writer)
static void	finalizeBinary (BinaryStream &stream, const Binary *binaryToFinalize, const BinaryWriter *writer)
Static Protected Member Functions inherited from TPEF::SectionWriter
static void	registerSectionWriter (const SectionWriter *sWriter)
static SectionId	getUniqueSectionId ()

Detailed Description

Base class for all TPEF filetype writer classes.

Definition at line 49 of file TPEFSectionWriter.hh.

Constructor & Destructor Documentation

TPEFSectionWriter() [1/2]

TPEF::TPEFSectionWriter::TPEFSectionWriter ( )

protected

Constructor.

Definition at line 63 of file TPEFSectionWriter.cc.

                                     : SectionWriter() {
}

~TPEFSectionWriter()

TPEF::TPEFSectionWriter::~TPEFSectionWriter ( )

protectedvirtual

Destructor.

Definition at line 69 of file TPEFSectionWriter.cc.

                                      {
}

TPEFSectionWriter() [2/2]

TPEF::TPEFSectionWriter::TPEFSectionWriter ( const TPEFSectionWriter &  )

private

Member Function Documentation

actualWriteData()

void TPEF::TPEFSectionWriter::actualWriteData ( BinaryStream &  stream, const Section *  sect  ) const

protectedvirtual

Empty default implementation of method.

This is used if Section does not contain any data part.

Parameters

stream	Where to write.
sect	Data to write.

Implements TPEF::SectionWriter.

Reimplemented in TPEF::TPEFSymbolSectionWriter, TPEF::TPEFDebugSectionWriter, TPEF::TPEFASpaceSectionWriter, TPEF::TPEFRelocSectionWriter, TPEF::TPEFResourceSectionWriter, TPEF::TPEFLineNumSectionWriter, TPEF::TPEFCodeSectionWriter, TPEF::TPEFDataSectionWriter, and TPEF::TPEFStringSectionWriter.

Definition at line 193 of file TPEFSectionWriter.cc.

                                                           {
}

actualWriteHeader()

void TPEF::TPEFSectionWriter::actualWriteHeader ( BinaryStream &  stream, const Section *  sect  ) const

protectedvirtual

Writes section's header into stream.

Parameters

stream	Stream where to write.
sect	Section to be written.

Implements TPEF::SectionWriter.

Definition at line 89 of file TPEFSectionWriter.cc.

                               {
 
    // inform reference manager about the section
    SectionOffset sectionOffset = stream.writePosition();
 
    // getSectionId must be overridden for special section identifiers
    // like NullSection's
    SectionId id = getSectionId();
 
    // create reference keys for section class
    SafePointer::addObjectReference(SectionKey(id), sect);
    SafePointer::addObjectReference(FileOffsetKey(sectionOffset), sect);
 
    // start writing header fields
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_NAME);
    Chunk* name = sect->name();
 
    if (name != NULL) {
        SectionOffsetReplacer nameReplacer(name);
        nameReplacer.resolve();
    } else {
        stream.writeWord(0);
    }
 
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_TYPE);
    stream.writeByte(sect->type());
 
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_FLAGS);
    stream.writeByte(sect->flags());
 
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_ADDR);
 
    if (sect->isProgramSection()) {
        stream.writeWord(sect->startingAddress());
    } else {
        stream.writeWord(0);
    }
 
    // offset of the section data
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_OFFSET);
    writeBodyStartOffset(stream, sect);
 
    // size of the section
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_SIZE);
    writeSize(stream, sect);
 
    // section identification code
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_ID);
    stream.writeHalfWord(id);
 
 
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_ASPACE);
    if (sect->aSpace() != NULL) {
        // section address space identifier
        SectionIndexReplacer indexReplacer(sect->aSpace(), sizeof(Byte));
        indexReplacer.resolve();
    } else {
        bool addressSpaceCantBeNull = false;
        assert(addressSpaceCantBeNull);
    }
 
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_PADDING);
    stream.writeByte(0);
 
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_LINK);
    Section* linkSect = sect->link();
 
    if (linkSect != NULL) {
        SectionIdReplacer linkReplacer(linkSect);
        linkReplacer.resolve();
    } else {
        stream.writeHalfWord(0);
    }
 
    // by deafult info field is not used.
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_INFO);
    writeInfo(stream, sect);
 
    // section elements size is asked from actual section writer
    stream.setWritePosition(sectionOffset + TPEFHeaders::SH_ENTSIZE);
 
    // check that if element size is zero then vLen flag is set or
    // section is null section
    assert((elementSize(sect) == 0) ==
           (sect->vLen() || (sect->type() == Section::ST_NULL)));
    stream.writeWord(elementSize(sect));
 
    // create keys for section elements if nobits flag is set.
    if (sect->noBits()) {
        createKeys(sect);
    }
}

References TPEF::ReferenceManager::SafePointer::addObjectReference(), TPEF::Section::aSpace(), assert, createKeys(), elementSize(), TPEF::Section::flags(), getSectionId(), TPEF::Section::isProgramSection(), TPEF::Section::link(), TPEF::Section::name(), TPEF::Section::noBits(), TPEF::ValueReplacer::resolve(), TPEF::BinaryStream::setWritePosition(), TPEF::TPEFHeaders::SH_ADDR, TPEF::TPEFHeaders::SH_ASPACE, TPEF::TPEFHeaders::SH_ENTSIZE, TPEF::TPEFHeaders::SH_FLAGS, TPEF::TPEFHeaders::SH_ID, TPEF::TPEFHeaders::SH_INFO, TPEF::TPEFHeaders::SH_LINK, TPEF::TPEFHeaders::SH_NAME, TPEF::TPEFHeaders::SH_OFFSET, TPEF::TPEFHeaders::SH_PADDING, TPEF::TPEFHeaders::SH_SIZE, TPEF::TPEFHeaders::SH_TYPE, TPEF::Section::ST_NULL, TPEF::Section::startingAddress(), TPEF::Section::type(), TPEF::Section::vLen(), writeBodyStartOffset(), TPEF::BinaryStream::writeByte(), TPEF::BinaryStream::writeHalfWord(), writeInfo(), TPEF::BinaryStream::writePosition(), writeSize(), and TPEF::BinaryStream::writeWord().

Here is the call graph for this function:

createKeys()

void TPEF::TPEFSectionWriter::createKeys ( const Section *  sect ) const

protectedvirtual

Fall through method for creating reference keys.

This method is used for those sections, whose elements can be referred, but there is no section body stored in TPEF binary (if section has no bits flag set, then this method is invoked instead writeData).

Empty implementation for sections that don't need keys created if section do not have body.

Parameters

sect	Section which for keys will be created.

Reimplemented in TPEF::TPEFUDataSectionWriter, TPEF::TPEFSymbolSectionWriter, and TPEF::TPEFDebugSectionWriter.

Definition at line 286 of file TPEFSectionWriter.cc.

                                                    {
}

Referenced by actualWriteHeader().

elementSize()

Word TPEF::TPEFSectionWriter::elementSize ( const Section *  section ) const

protectedvirtual

Returns fixed element size of section.

Parameters

sect	Data to write.

Returns

Element size of section.

Reimplemented in TPEF::TPEFSymbolSectionWriter, TPEF::TPEFDataSectionWriter, TPEF::TPEFDebugSectionWriter, TPEF::TPEFUDataSectionWriter, TPEF::TPEFASpaceSectionWriter, TPEF::TPEFRelocSectionWriter, TPEF::TPEFResourceSectionWriter, TPEF::TPEFLineNumSectionWriter, TPEF::TPEFStringSectionWriter, and TPEF::TPEFNullSectionWriter.

Definition at line 204 of file TPEFSectionWriter.cc.

                                                     {
    return 0;
}

Referenced by actualWriteHeader().

getSectionId()

SectionId TPEF::TPEFSectionWriter::getSectionId ( ) const

protectedvirtual

Get section identification code for the section.

Returns

Valid section identification code.

Reimplemented in TPEF::TPEFNullSectionWriter.

Definition at line 268 of file TPEFSectionWriter.cc.

                                      {
    return SectionWriter::getUniqueSectionId();
}

References TPEF::SectionWriter::getUniqueSectionId().

Referenced by actualWriteHeader().

Here is the call graph for this function:

parent()

const BinaryWriter & TPEF::TPEFSectionWriter::parent ( ) const

protectedvirtual

Returns binary writer which for section writers are created.

Returns

Binary writer which for section writers are created.

Implements TPEF::SectionWriter.

Definition at line 78 of file TPEFSectionWriter.cc.

                                {
    return TPEFWriter::instance();
}

References TPEF::TPEFWriter::instance().

Here is the call graph for this function:

type()

virtual Section::SectionType TPEF::TPEFSectionWriter::type ( ) const

protectedpure virtual

Returns SectionTypet hat actual reader or writer instance can handle.

Implements TPEF::SectionWriter.

Implemented in TPEF::TPEFUDataSectionWriter, TPEF::TPEFCodeSectionWriter, TPEF::TPEFDataSectionWriter, TPEF::TPEFASpaceSectionWriter, TPEF::TPEFRelocSectionWriter, TPEF::TPEFResourceSectionWriter, TPEF::TPEFStringSectionWriter, TPEF::TPEFSymbolSectionWriter, TPEF::TPEFDebugSectionWriter, TPEF::TPEFLineNumSectionWriter, TPEF::TPEFNullSectionWriter, and TPEF::TPEFLEDataSectionWriter.

writeBodyStartOffset()

void TPEF::TPEFSectionWriter::writeBodyStartOffset ( BinaryStream &  stream, const Section *  sect  ) const

private

Writes Section's data area offset into stream.

Parameters

stream	Stream where to write.
sect	Section which data's offset to write.

Definition at line 245 of file TPEFSectionWriter.cc.

                                                                   {
 
    if (sect->noBits()) {
        stream.writeWord(0);
 
    } else {
        if (sect->isChunkable()) {
            FileOffsetReplacer replacer(sect->chunk(0));
            replacer.resolve();
        } else {
            FileOffsetReplacer replacer(sect->element(0));
            replacer.resolve();
        }
    }
}

References TPEF::Section::chunk(), TPEF::Section::element(), TPEF::Section::isChunkable(), TPEF::Section::noBits(), TPEF::ValueReplacer::resolve(), and TPEF::BinaryStream::writeWord().

Referenced by actualWriteHeader().

Here is the call graph for this function:

writeInfo()

void TPEF::TPEFSectionWriter::writeInfo ( BinaryStream &  stream, const Section *  sect  ) const

protectedvirtual

Writes section info field into stream.

Default implementation writes, there zero word.

Parameters

stream	Stream where to write.
sect	Section which info field to write.

Reimplemented in TPEF::TPEFRelocSectionWriter, TPEF::TPEFCodeSectionWriter, and TPEF::TPEFLineNumSectionWriter.

Definition at line 233 of file TPEFSectionWriter.cc.

                                                     {
    stream.writeWord(0);
}

References TPEF::BinaryStream::writeWord().

Referenced by actualWriteHeader().

Here is the call graph for this function:

writeSize()

void TPEF::TPEFSectionWriter::writeSize ( BinaryStream &  stream, const Section *  sect  ) const

protectedvirtual

Writes section size field in to stream.

Default implementation, which uses replacer class to write size.

Parameters

stream	Stream, where to write.
sect	Section which size to write.

Reimplemented in TPEF::TPEFUDataSectionWriter, and TPEF::TPEFNullSectionWriter.

Definition at line 218 of file TPEFSectionWriter.cc.

                                                        {
    SectionSizeReplacer replacer(sect);
    replacer.resolve();
}

References TPEF::ValueReplacer::resolve().

Referenced by actualWriteHeader().

Here is the call graph for this function:

---

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

• TPEFSectionWriter.hh
• TPEFSectionWriter.cc