TPEF::TPEFASpaceSectionWriter Class Reference

#include <TPEFASpaceSectionWriter.hh>

Inheritance diagram for TPEF::TPEFASpaceSectionWriter:

Collaboration diagram for TPEF::TPEFASpaceSectionWriter:

Protected Member Functions
	TPEFASpaceSectionWriter ()
virtual	~TPEFASpaceSectionWriter ()
virtual Section::SectionType	type () const
virtual void	actualWriteData (BinaryStream &stream, const Section *section) const
virtual Word	elementSize (const Section *section) const
Protected Member Functions inherited from TPEF::TPEFSectionWriter
	TPEFSectionWriter ()
virtual	~TPEFSectionWriter ()
virtual const BinaryWriter &	parent () const
virtual void	actualWriteHeader (BinaryStream &stream, const Section *sect) const
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
Protected Member Functions inherited from TPEF::SectionWriter
	SectionWriter ()
virtual	~SectionWriter ()
virtual void	finalize (BinaryStream &stream, Section *section) const

Private Member Functions
	TPEFASpaceSectionWriter (const TPEFASpaceSectionWriter &)
	Copying not allowed.
TPEFASpaceSectionWriter	operator= (const TPEFASpaceSectionWriter &)
	Assignment not allowed.
void	writeElement (BinaryStream &stream, const ASpaceElement *elem, SectionId id, Word index) const

Static Private Attributes
static const TPEFASpaceSectionWriter	instance_
	An unique instance of class.
static const Word	elementSize_ = 8
	The fixed size address space element.

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

Writes TPEF address space section to stream.

Definition at line 47 of file TPEFASpaceSectionWriter.hh.

Constructor & Destructor Documentation

TPEFASpaceSectionWriter() [1/2]

TPEF::TPEFASpaceSectionWriter::TPEFASpaceSectionWriter ( )

protected

Constructor.

Registers itself to SectionWriter.

Definition at line 63 of file TPEFASpaceSectionWriter.cc.

                                                 : TPEFSectionWriter() {
    registerSectionWriter(this);
}

References TPEF::SectionWriter::registerSectionWriter().

Here is the call graph for this function:

~TPEFASpaceSectionWriter()

TPEF::TPEFASpaceSectionWriter::~TPEFASpaceSectionWriter ( )

protectedvirtual

Destructor.

Definition at line 70 of file TPEFASpaceSectionWriter.cc.

                                                  {
}

TPEFASpaceSectionWriter() [2/2]

TPEF::TPEFASpaceSectionWriter::TPEFASpaceSectionWriter ( const TPEFASpaceSectionWriter &  )

private

Copying not allowed.

Member Function Documentation

actualWriteData()

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

protectedvirtual

Writes the data of the section in to stream.

Parameters

stream	The stream to be written to.
sect	The section to be written.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 90 of file TPEFASpaceSectionWriter.cc.

                               {
 
    FileOffset startOffset = stream.writePosition();
 
    // file offset to data of section
    SafePointer::addObjectReference(
        FileOffsetKey(startOffset), sect->element(0));
 
    // resolve identification code of currently written section
    SectionKey sectionKey = SafePointer::sectionKeyFor(sect);
 
    SectionId sectionId = sectionKey.sectionId();
 
    // index zero is reserved for undefined element.
    Byte index = 1;
    bool undefASpaceWritten = false;
 
    for (unsigned int i = 0; i < sect->elementCount(); i++) {
 
        ASpaceElement* elem = dynamic_cast<ASpaceElement*>(sect->element(i));
        assert(elem != NULL);
 
        // references to undefined address space will be written out as
        // identification code zero
        if (dynamic_cast<const ASpaceSection*>(sect)->isUndefined(elem)) {
            assert(elem->MAU() == 0);
            assert(elem->wordSize() == 0);
            assert(elem->align() == 0);
            undefASpaceWritten = true;
            writeElement(stream, elem, sectionId, 0);
        } else {
            writeElement(stream, elem, sectionId, index);
        }
 
        index++;
    }
 
    assert(undefASpaceWritten);
 
    SectionSizeReplacer::setSize(sect, stream.writePosition() - startOffset);
}

References TPEF::ReferenceManager::SafePointer::addObjectReference(), TPEF::ASpaceElement::align(), assert, TPEF::Section::element(), TPEF::Section::elementCount(), TPEF::ASpaceElement::MAU(), TPEF::ReferenceManager::SectionKey::sectionId(), TPEF::ReferenceManager::SafePointer::sectionKeyFor(), TPEF::SectionSizeReplacer::setSize(), TPEF::ASpaceElement::wordSize(), writeElement(), and TPEF::BinaryStream::writePosition().

Here is the call graph for this function:

elementSize()

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

protectedvirtual

Returns the fixed size length of section elements.

Returns

The fixed size length of section elements.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 168 of file TPEFASpaceSectionWriter.cc.

                                                           {
    return elementSize_;
}

References elementSize_.

operator=()

TPEFASpaceSectionWriter TPEF::TPEFASpaceSectionWriter::operator= ( const TPEFASpaceSectionWriter &  )

private

Assignment not allowed.

type()

Section::SectionType TPEF::TPEFASpaceSectionWriter::type ( ) const

protectedvirtual

Returns the section type this writer can write.

Returns

The section type writer can write.

Implements TPEF::TPEFSectionWriter.

Definition at line 79 of file TPEFASpaceSectionWriter.cc.

                                    {
    return Section::ST_ADDRSP;
}

References TPEF::Section::ST_ADDRSP.

writeElement()

void TPEF::TPEFASpaceSectionWriter::writeElement ( BinaryStream &  stream, const ASpaceElement *  elem, SectionId  id, Word  index  ) const

private

Writes address space element to stream.

Parameters

stream	Stream where to write.
elem	Element to write.
id	Section identification code of address space section.
index	Identification code of address space element.

Definition at line 143 of file TPEFASpaceSectionWriter.cc.

                      {
 
    // add index of element for index replacer
    SafePointer::addObjectReference(
        SectionIndexKey(id, index), elem);
 
    stream.writeByte(index);
    stream.writeByte(elem->MAU());
    stream.writeByte(elem->align());
    stream.writeByte(elem->wordSize());
 
    SectionOffsetReplacer replacer(elem->name());
    replacer.resolve();
}

References TPEF::ReferenceManager::SafePointer::addObjectReference(), TPEF::ASpaceElement::align(), TPEF::ASpaceElement::MAU(), TPEF::ASpaceElement::name(), TPEF::ValueReplacer::resolve(), TPEF::ASpaceElement::wordSize(), and TPEF::BinaryStream::writeByte().

Referenced by actualWriteData().

Here is the call graph for this function:

Member Data Documentation

elementSize_

const Word TPEF::TPEFASpaceSectionWriter::elementSize_ = 8

staticprivate

The fixed size address space element.

Definition at line 75 of file TPEFASpaceSectionWriter.hh.

Referenced by elementSize().

instance_

const TPEFASpaceSectionWriter TPEF::TPEFASpaceSectionWriter::instance_

staticprivate

An unique instance of class.

Definition at line 73 of file TPEFASpaceSectionWriter.hh.

---

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

• TPEFASpaceSectionWriter.hh
• TPEFASpaceSectionWriter.cc