Rose::BinaryAnalysis::Unparser::Base Class Reference

Description

Abstract base class for unparsers.

This defines the interface only. All data that's used during unparsing is provided to each function so that this interface is thread-safe. Only the configuration settings are stored in the unparser itself.

End users generally invoke the high-level output methods, which are provided by non-virtual function operators that are overloaded on the type of object being unparsed.

The high-level function operators each call a corresponding overloaded virtual unparse function that kicks things off by creating an unparse Unparser::State object, setting the front parser to the one whose unparse method was called, and invoking an appropriate mid-level "emit" function in that front parser.

Mid-level "emit" functions use a combination of C++ virtual functions and unparser object chaining as described in the documentation for those functions. This permits two ways to override or augment behavior: behavior modification based on architecture (virtual functions) and behavior modification based on a filtering concept to support things like tables and HTML (chaining).

The following code is a starting point for creating your own unparser:

class MyUnparser: public BinaryAnalysis::Unparser::Base {
protected:
    explicit MyUnparser(const BinaryAnalysis::Unparser::Base::Ptr &next)
        : BinaryAnalysis::Unparser::Base(next) {
        ASSERT_not_null(next);
    }
 
public:
    typedef Sawyer::SharedPointer<MyUnparser> Ptr;
 
    static Ptr instance(const BinaryAnalysis::Unparser::Base::Ptr &next) { return Ptr(new MyUnparser(next)); }
    virtual BinaryAnalysis::Unparser::Base::Ptr copy() const override { return Ptr(new MyUnparser(nextUnparser()->copy())); }
    virtual const BinaryAnalysis::Unparser::Settings& settings() const override { return nextUnparser()->settings(); }
    virtual BinaryAnalysis::Unparser::Settings& settings() override { return nextUnparser()->settings(); }
 
    // specialized output functions here...
};

To instantiate this parser from a Partitioner2::Partitioner object named partitioner, do this:

BinaryAnalysis::Unparser::Base::Ptr unparser = partitioner->unparser();
unparser->settings() = settings.unparser; // See Rose::BinaryAnalysis::Unparser::Settings for starters
unparser = MyUnparser::instance(unparser);

Definition at line 422 of file Unparser/Base.h.

#include <Rose/BinaryAnalysis/Unparser/Base.h>

Inheritance diagram for Rose::BinaryAnalysis::Unparser::Base:

Collaboration diagram for Rose::BinaryAnalysis::Unparser::Base:

Public Types
typedef Sawyer::SharedPointer< Base >	Ptr

Public Member Functions
virtual Ptr	copy () const =0
Architecture::BaseConstPtr	architecture () const
	Property: Architecture.
virtual void	initializeState (State &) const
	Finish initializing the unparser state.
virtual void	updateIntraFunctionArrows (State &) const
	Calculate intra-function arrows.
virtual const Settings &	settings () const =0
	Property: Settings associated with this unparser.
virtual Settings &	settings ()=0
	Property: Settings associated with this unparser.
void	settings (const Settings &s)
	Property: Settings associated with this unparser.
Ptr	nextUnparser () const
	Property: Next parser in chain.
void	nextUnparser (Ptr next)
	Property: Next parser in chain.
void	operator() (std::ostream &, const Partitioner2::PartitionerConstPtr &) const
	Emit the entity to an output stream.
void	operator() (std::ostream &, const Partitioner2::PartitionerConstPtr &, SgAsmInstruction *) const
	Emit the entity to an output stream.
void	operator() (std::ostream &, const Partitioner2::PartitionerConstPtr &, SgAsmExpression *) const
	Emit the entity to an output stream.
void	operator() (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Partitioner2::BasicBlockPtr &) const
	Emit the entity to an output stream.
void	operator() (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Partitioner2::DataBlockPtr &) const
	Emit the entity to an output stream.
void	operator() (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &) const
	Emit the entity to an output stream.
void	operator() (std::ostream &, SgAsmInstruction *) const
	Emit the entity to an output stream.
std::string	operator() (const Partitioner2::PartitionerConstPtr &, const Progress::Ptr &=Progress::Ptr()) const
	Emit the entity to a string.
std::string	operator() (const Partitioner2::PartitionerConstPtr &, SgAsmInstruction *) const
	Emit the entity to a string.
std::string	operator() (const Partitioner2::PartitionerConstPtr &, SgAsmExpression *) const
	Emit the entity to a string.
std::string	operator() (const Partitioner2::PartitionerConstPtr &, const Partitioner2::BasicBlockPtr &) const
	Emit the entity to a string.
std::string	operator() (const Partitioner2::PartitionerConstPtr &, const Partitioner2::DataBlockPtr &) const
	Emit the entity to a string.
std::string	operator() (const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &) const
	Emit the entity to a string.
std::string	operator() (SgAsmInstruction *) const
	Emit the entity to a string.
void	unparse (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Progress::Ptr &=Progress::Ptr()) const
	High-level unparsing function.
void	unparse (std::ostream &, const Partitioner2::PartitionerConstPtr &, SgAsmInstruction *) const
	High-level unparsing function.
void	unparse (std::ostream &, const Partitioner2::PartitionerConstPtr &, SgAsmExpression *) const
	High-level unparsing function.
void	unparse (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Partitioner2::BasicBlockPtr &) const
	High-level unparsing function.
void	unparse (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Partitioner2::DataBlockPtr &) const
	High-level unparsing function.
void	unparse (std::ostream &, const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &) const
	High-level unparsing function.
void	unparse (std::ostream &, SgAsmInstruction *) const
	High-level unparsing function.
void	unparse (std::ostream &, SgAsmExpression *) const
	High-level unparsing function.
std::string	unparse (const Partitioner2::PartitionerConstPtr &, const Progress::Ptr &=Progress::Ptr()) const
	High-level unparsing function.
std::string	unparse (const Partitioner2::PartitionerConstPtr &, SgAsmInstruction *) const
	High-level unparsing function.
std::string	unparse (const Partitioner2::PartitionerConstPtr &, SgAsmExpression *) const
	High-level unparsing function.
std::string	unparse (const Partitioner2::PartitionerConstPtr &, const Partitioner2::BasicBlockPtr &) const
	High-level unparsing function.
std::string	unparse (const Partitioner2::PartitionerConstPtr &, const Partitioner2::DataBlockPtr &) const
	High-level unparsing function.
std::string	unparse (const Partitioner2::PartitionerConstPtr &, const Partitioner2::FunctionPtr &) const
	High-level unparsing function.
std::string	unparse (SgAsmInstruction *) const
	High-level unparsing function.
std::string	unparse (SgAsmExpression *) const
	High-level unparsing function.
virtual void	emitFunction (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionPrologue (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionBody (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionEpilogue (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionSourceLocation (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionReasons (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionCallers (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionCallees (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionComment (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionStackDelta (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionCallingConvention (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionNoopAnalysis (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitFunctionMayReturn (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
	Mid-level unparser function.
virtual void	emitDataBlockSourceLocation (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitDataBlock (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitDataBlockPrologue (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitDataBlockBody (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitDataBlockEpilogue (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlock (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockPrologue (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockBody (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockEpilogue (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockSourceLocation (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockComment (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockSharing (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockPredecessors (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockSuccessors (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitBasicBlockReachability (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
	Mid-level unparser function.
virtual void	emitInstruction (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionPrologue (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionBody (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionEpilogue (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionAddress (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionBytes (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionStackDelta (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionFrameDelta (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionMnemonic (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionOperands (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionComment (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitInstructionSemantics (std::ostream &, SgAsmInstruction *, State &) const
	Mid-level unparser function.
virtual void	emitOperand (std::ostream &, SgAsmExpression *, State &) const
	Mid-level unparser function.
virtual void	emitOperandPrologue (std::ostream &, SgAsmExpression *, State &) const
	Mid-level unparser function.
virtual void	emitOperandBody (std::ostream &, SgAsmExpression *, State &) const
	Mid-level unparser function.
virtual void	emitOperandEpilogue (std::ostream &, SgAsmExpression *, State &) const
	Mid-level unparser function.
virtual void	emitExpression (std::ostream &, SgAsmExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryAdd (std::ostream &, SgAsmBinaryAdd *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryAsr (std::ostream &, SgAsmBinaryAsr *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryConcat (std::ostream &, SgAsmBinaryConcat *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryDivide (std::ostream &, SgAsmBinaryDivide *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryLsl (std::ostream &, SgAsmBinaryLsl *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryLsr (std::ostream &, SgAsmBinaryLsr *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryMsl (std::ostream &, SgAsmBinaryMsl *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryMultiply (std::ostream &, SgAsmBinaryMultiply *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryMod (std::ostream &, SgAsmBinaryMod *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryPreupdate (std::ostream &, SgAsmBinaryPreupdate *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryPostupdate (std::ostream &, SgAsmBinaryPostupdate *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinaryRor (std::ostream &, SgAsmBinaryRor *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitBinarySubtract (std::ostream &, SgAsmBinarySubtract *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitByteOrder (std::ostream &, SgAsmByteOrder *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitDirectRegisterExpression (std::ostream &, SgAsmDirectRegisterExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitExprListExp (std::ostream &, SgAsmExprListExp *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitFloatValueExpression (std::ostream &, SgAsmFloatValueExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitIndirectRegisterExpression (std::ostream &, SgAsmIndirectRegisterExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitIntegerValueExpression (std::ostream &, SgAsmIntegerValueExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitMemoryReferenceExpression (std::ostream &, SgAsmMemoryReferenceExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitRegisterNames (std::ostream &, SgAsmRegisterNames *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitRiscOperation (std::ostream &, SgAsmRiscOperation *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitStackExpression (std::ostream &, SgAsmStackExpression *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitUnaryMinus (std::ostream &, SgAsmUnaryMinus *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitUnaryPlus (std::ostream &, SgAsmUnaryPlus *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitUnarySignedExtend (std::ostream &, SgAsmUnarySignedExtend *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitUnaryTruncate (std::ostream &, SgAsmUnaryTruncate *, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitUnaryUnsignedExtend (std::ostream &, SgAsmUnaryUnsignedExtend *, State &) const
	Mid-level unparser function.
virtual void	emitRegister (std::ostream &, RegisterDescriptor, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitUnsignedInteger (std::ostream &, const Sawyer::Container::BitVector &, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitSignedInteger (std::ostream &, const Sawyer::Container::BitVector &, State &) const
	Mid-level unparser function.
virtual std::vector< std::string >	emitInteger (std::ostream &, const Sawyer::Container::BitVector &, State &, bool isSigned) const
	Mid-level unparser function.
virtual bool	emitAddress (std::ostream &, rose_addr_t, State &, bool always=true) const
	Mid-level unparser function.
virtual bool	emitAddress (std::ostream &, const Sawyer::Container::BitVector &, State &, bool always=true) const
	Mid-level unparser function.
virtual void	emitCommentBlock (std::ostream &, const std::string &, State &, const std::string &prefix=";;; ") const
	Mid-level unparser function.
virtual void	emitTypeName (std::ostream &, SgAsmType *, State &) const
	Mid-level unparser function.
virtual void	emitLinePrefix (std::ostream &, State &) const
	Mid-level unparser function.
Public Member Functions inherited from Sawyer::SharedObject
	SharedObject ()
	Default constructor.
	SharedObject (const SharedObject &)
	Copy constructor.
virtual	~SharedObject ()
	Virtual destructor.
SharedObject &	operator= (const SharedObject &)
	Assignment.

Static Public Member Functions
static std::string	leftJustify (const std::string &, size_t nchars)
	Render a string left justified.
static std::string	juxtaposeColumns (const std::vector< std::string > &content, const std::vector< size_t > &minWidths, const std::vector< std::pair< std::string, std::string > > &colorEscapes, const std::string &columnSeparator=" ")
	Render a table row.
static bool	ascendingSourceAddress (Partitioner2::ControlFlowGraph::ConstEdgeIterator a, Partitioner2::ControlFlowGraph::ConstEdgeIterator b)
	Return true if edges are in order by source address.
static bool	ascendingTargetAddress (Partitioner2::ControlFlowGraph::ConstEdgeIterator a, Partitioner2::ControlFlowGraph::ConstEdgeIterator b)
	Return true if edges are in order by target address.
static std::vector< Partitioner2::ControlFlowGraph::ConstEdgeIterator >	orderedBlockPredecessors (const Partitioner2::PartitionerConstPtr &, const Partitioner2::BasicBlockPtr &)
	Ordered incoming CFG edges.
static std::vector< Partitioner2::ControlFlowGraph::ConstEdgeIterator >	orderedBlockSuccessors (const Partitioner2::PartitionerConstPtr &, const Partitioner2::BasicBlockPtr &)
	Ordered outgoing CFG edges.

Protected Member Functions
	Base (const Architecture::BaseConstPtr &)
	Base (const Ptr &nextUnparser)

Member Typedef Documentation

Ptr

typedef Sawyer::SharedPointer<Base> Rose::BinaryAnalysis::Unparser::Base::Ptr

Definition at line 424 of file Unparser/Base.h.

Member Function Documentation

settings() [1/3]

virtual const Settings & Rose::BinaryAnalysis::Unparser::Base::settings ( ) const

pure virtual

Property: Settings associated with this unparser.

Most of these settings can also be configured from the command-line. They control features of the unparser directly without the programmer having to invervene by creating a subclss or chaining a new parser. Most of the switches simply turn things on and off.

Copying an unparser also copies its settings.

Implemented in Rose::BinaryAnalysis::Unparser::Cil, Rose::BinaryAnalysis::Unparser::Jvm, Rose::BinaryAnalysis::Unparser::M68k, Rose::BinaryAnalysis::Unparser::Mips, Rose::BinaryAnalysis::Unparser::Null, Rose::BinaryAnalysis::Unparser::Powerpc, and Rose::BinaryAnalysis::Unparser::X86.

Referenced by settings().

settings() [2/3]

virtual Settings & Rose::BinaryAnalysis::Unparser::Base::settings ( )

pure virtual

Property: Settings associated with this unparser.

Most of these settings can also be configured from the command-line. They control features of the unparser directly without the programmer having to invervene by creating a subclss or chaining a new parser. Most of the switches simply turn things on and off.

Copying an unparser also copies its settings.

Implemented in Rose::BinaryAnalysis::Unparser::Cil, Rose::BinaryAnalysis::Unparser::Jvm, Rose::BinaryAnalysis::Unparser::M68k, Rose::BinaryAnalysis::Unparser::Mips, Rose::BinaryAnalysis::Unparser::Null, Rose::BinaryAnalysis::Unparser::Powerpc, and Rose::BinaryAnalysis::Unparser::X86.

settings() [3/3]

void Rose::BinaryAnalysis::Unparser::Base::settings ( const Settings &  s )

inline

Property: Settings associated with this unparser.

Most of these settings can also be configured from the command-line. They control features of the unparser directly without the programmer having to invervene by creating a subclss or chaining a new parser. Most of the switches simply turn things on and off.

Copying an unparser also copies its settings.

Definition at line 449 of file Unparser/Base.h.

References settings().

nextUnparser() [1/2]

Ptr Rose::BinaryAnalysis::Unparser::Base::nextUnparser ( ) const

inline

Property: Next parser in chain.

Parsers can be subclass and/or chained. Nearly all functions check for chaining and delegate to the next parser in the chain. When one function calls some other function, it uses the first parser of the chain. The chain can be created by supplying an argument to the constructor, or it can be constructed later by setting this property.

Definition at line 461 of file Unparser/Base.h.

nextUnparser() [2/2]

void Rose::BinaryAnalysis::Unparser::Base::nextUnparser ( Ptr  next )

inline

Property: Next parser in chain.

Parsers can be subclass and/or chained. Nearly all functions check for chaining and delegate to the next parser in the chain. When one function calls some other function, it uses the first parser of the chain. The chain can be created by supplying an argument to the constructor, or it can be constructed later by setting this property.

Definition at line 462 of file Unparser/Base.h.

architecture()

Architecture::BaseConstPtr Rose::BinaryAnalysis::Unparser::Base::architecture

(

)

const

Property: Architecture.

A non-null pointer to the architecture that this unparser unparses.

operator()() [1/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [2/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		SgAsmInstruction *
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [3/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		SgAsmExpression *
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [4/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::BasicBlockPtr &
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [5/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::DataBlockPtr &
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [6/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::FunctionPtr &
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [7/14]

void Rose::BinaryAnalysis::Unparser::Base::operator()	(	std::ostream &	,
		SgAsmInstruction *
	)		const

Emit the entity to an output stream.

Renders the third argument as text and sends it to the stream indicated by the first argument. The partitioner argument provides additional details about the thing being printed. The version of this function that takes only two arguments causes all functions to be emitted.

operator()() [8/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()	(	const Partitioner2::PartitionerConstPtr &	,
		const Progress::Ptr &	= Progress::Ptr()
	)		const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

operator()() [9/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()	(	const Partitioner2::PartitionerConstPtr &	,
		SgAsmInstruction *
	)		const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

operator()() [10/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()	(	const Partitioner2::PartitionerConstPtr &	,
		SgAsmExpression *
	)		const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

operator()() [11/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::BasicBlockPtr &
	)		const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

operator()() [12/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::DataBlockPtr &
	)		const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

operator()() [13/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::FunctionPtr &
	)		const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

operator()() [14/14]

std::string Rose::BinaryAnalysis::Unparser::Base::operator()

(

SgAsmInstruction *

)

const

Emit the entity to a string.

This is just a convenience wrapper around the three-argument form.

unparse() [1/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Progress::Ptr &	= Progress::Ptr()
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [2/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		SgAsmInstruction *
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [3/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		SgAsmExpression *
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [4/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::BasicBlockPtr &
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [5/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::DataBlockPtr &
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [6/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::FunctionPtr &
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [7/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		SgAsmInstruction *
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [8/16]

void Rose::BinaryAnalysis::Unparser::Base::unparse	(	std::ostream &	,
		SgAsmExpression *
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [9/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse	(	const Partitioner2::PartitionerConstPtr &	,
		const Progress::Ptr &	= Progress::Ptr()
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [10/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse	(	const Partitioner2::PartitionerConstPtr &	,
		SgAsmInstruction *
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [11/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse	(	const Partitioner2::PartitionerConstPtr &	,
		SgAsmExpression *
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [12/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::BasicBlockPtr &
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [13/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::DataBlockPtr &
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [14/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse	(	const Partitioner2::PartitionerConstPtr &	,
		const Partitioner2::FunctionPtr &
	)		const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [15/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse

(

SgAsmInstruction *

)

const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

unparse() [16/16]

std::string Rose::BinaryAnalysis::Unparser::Base::unparse

(

SgAsmExpression *

)

const

High-level unparsing function.

This function does the same thing as the function operator that has the same arguments.

emitFunction()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunction ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionPrologue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionPrologue ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionBody()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionBody ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionEpilogue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionEpilogue ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionSourceLocation()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionSourceLocation ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionReasons()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionReasons ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionCallers()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionCallers ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionCallees()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionCallees ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionComment()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionComment ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionStackDelta()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionStackDelta ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionCallingConvention()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionCallingConvention ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionNoopAnalysis()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionNoopAnalysis ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFunctionMayReturn()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitFunctionMayReturn ( std::ostream &  , const Partitioner2::FunctionPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitDataBlockSourceLocation()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitDataBlockSourceLocation ( std::ostream &  , const Partitioner2::DataBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitDataBlock()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitDataBlock ( std::ostream &  , const Partitioner2::DataBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitDataBlockPrologue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitDataBlockPrologue ( std::ostream &  , const Partitioner2::DataBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitDataBlockBody()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitDataBlockBody ( std::ostream &  , const Partitioner2::DataBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitDataBlockEpilogue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitDataBlockEpilogue ( std::ostream &  , const Partitioner2::DataBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlock()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlock ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockPrologue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockPrologue ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockBody()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockBody ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockEpilogue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockEpilogue ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockSourceLocation()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockSourceLocation ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockComment()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockComment ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockSharing()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockSharing ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockPredecessors()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockPredecessors ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockSuccessors()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockSuccessors ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBasicBlockReachability()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitBasicBlockReachability ( std::ostream &  , const Partitioner2::BasicBlockPtr &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstruction()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstruction ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionPrologue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionPrologue ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionBody()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionBody ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionEpilogue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionEpilogue ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionAddress()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionAddress ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionBytes()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionBytes ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionStackDelta()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionStackDelta ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionFrameDelta()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionFrameDelta ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionMnemonic()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionMnemonic ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

Reimplemented in Rose::BinaryAnalysis::Unparser::X86.

emitInstructionOperands()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionOperands ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionComment()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionComment ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInstructionSemantics()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitInstructionSemantics ( std::ostream &  , SgAsmInstruction *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitOperand()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitOperand ( std::ostream &  , SgAsmExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitOperandPrologue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitOperandPrologue ( std::ostream &  , SgAsmExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitOperandBody()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitOperandBody ( std::ostream &  , SgAsmExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitOperandEpilogue()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitOperandEpilogue ( std::ostream &  , SgAsmExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitExpression()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitExpression ( std::ostream &  , SgAsmExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryAdd()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryAdd ( std::ostream &  , SgAsmBinaryAdd *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryAsr()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryAsr ( std::ostream &  , SgAsmBinaryAsr *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryConcat()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryConcat ( std::ostream &  , SgAsmBinaryConcat *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryDivide()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryDivide ( std::ostream &  , SgAsmBinaryDivide *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryLsl()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryLsl ( std::ostream &  , SgAsmBinaryLsl *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryLsr()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryLsr ( std::ostream &  , SgAsmBinaryLsr *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryMsl()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryMsl ( std::ostream &  , SgAsmBinaryMsl *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryMultiply()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryMultiply ( std::ostream &  , SgAsmBinaryMultiply *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryMod()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryMod ( std::ostream &  , SgAsmBinaryMod *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryPreupdate()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryPreupdate ( std::ostream &  , SgAsmBinaryPreupdate *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryPostupdate()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryPostupdate ( std::ostream &  , SgAsmBinaryPostupdate *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinaryRor()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinaryRor ( std::ostream &  , SgAsmBinaryRor *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitBinarySubtract()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitBinarySubtract ( std::ostream &  , SgAsmBinarySubtract *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitByteOrder()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitByteOrder ( std::ostream &  , SgAsmByteOrder *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitDirectRegisterExpression()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitDirectRegisterExpression ( std::ostream &  , SgAsmDirectRegisterExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitExprListExp()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitExprListExp ( std::ostream &  , SgAsmExprListExp *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitFloatValueExpression()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitFloatValueExpression ( std::ostream &  , SgAsmFloatValueExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitIndirectRegisterExpression()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitIndirectRegisterExpression ( std::ostream &  , SgAsmIndirectRegisterExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

Reimplemented in Rose::BinaryAnalysis::Unparser::X86.

emitIntegerValueExpression()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitIntegerValueExpression ( std::ostream &  , SgAsmIntegerValueExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitMemoryReferenceExpression()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitMemoryReferenceExpression ( std::ostream &  , SgAsmMemoryReferenceExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

Reimplemented in Rose::BinaryAnalysis::Unparser::X86.

emitRegisterNames()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitRegisterNames ( std::ostream &  , SgAsmRegisterNames *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitRiscOperation()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitRiscOperation ( std::ostream &  , SgAsmRiscOperation *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitStackExpression()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitStackExpression ( std::ostream &  , SgAsmStackExpression *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitUnaryMinus()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitUnaryMinus ( std::ostream &  , SgAsmUnaryMinus *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitUnaryPlus()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitUnaryPlus ( std::ostream &  , SgAsmUnaryPlus *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitUnarySignedExtend()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitUnarySignedExtend ( std::ostream &  , SgAsmUnarySignedExtend *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitUnaryTruncate()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitUnaryTruncate ( std::ostream &  , SgAsmUnaryTruncate *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitUnaryUnsignedExtend()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitUnaryUnsignedExtend ( std::ostream &  , SgAsmUnaryUnsignedExtend *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitRegister()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitRegister ( std::ostream &  , RegisterDescriptor  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitUnsignedInteger()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitUnsignedInteger ( std::ostream &  , const Sawyer::Container::BitVector &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitSignedInteger()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitSignedInteger ( std::ostream &  , const Sawyer::Container::BitVector &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitInteger()

virtual std::vector< std::string > Rose::BinaryAnalysis::Unparser::Base::emitInteger ( std::ostream &  , const Sawyer::Container::BitVector &  , State &  , bool  isSigned  ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitAddress() [1/2]

virtual bool Rose::BinaryAnalysis::Unparser::Base::emitAddress ( std::ostream &  , rose_addr_t  , State &  , bool  always = true  ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitAddress() [2/2]

virtual bool Rose::BinaryAnalysis::Unparser::Base::emitAddress ( std::ostream &  , const Sawyer::Container::BitVector &  , State &  , bool  always = true  ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitCommentBlock()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitCommentBlock ( std::ostream &  , const std::string &  , State &  , const std::string &  prefix = ";;; "  ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

emitTypeName()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitTypeName ( std::ostream &  , SgAsmType *  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

Reimplemented in Rose::BinaryAnalysis::Unparser::X86.

emitLinePrefix()

virtual void Rose::BinaryAnalysis::Unparser::Base::emitLinePrefix ( std::ostream &  , State &    ) const

virtual

Mid-level unparser function.

This function emits some entity to the specified output stream. All call-specific state is supplied in the State reference so that this function can be called with a const parser references and is thread safe per state object. The high-level functions create the state – states are not intended for end users – before calling this mid-level function.

This mid-level function uses a combination of C++ virtual function calls and object chaining. The virtual functions allow subclasses to override or augment behavior from the base class, so that, e.g., an x86 operand expression can be output in a different format than an m68k expression. The object chaining allows one unparser to override or augment the behavior of another function and is used, for example, to provide HTML wrapping around various entities.

The object chaining is implemented in two parts: every unparser object has a nextUnparser pointer and the final unparser in the list has a null pointer for this property; the Unparser::State object has a frontUnparser method that returns the first unparser in this list. This mid-level function is expected to always invoke functions on the front unparser in order to give every parser in the chain a chance to influence behavior. The base implementation of this mid-level function defers to the next parser in the chain if there is one, otherwise it performs some default output that's hopefully appropriate for most unparsers.

All such chained and virtual emitters begin with the letters "emit".

initializeState()

virtual void Rose::BinaryAnalysis::Unparser::Base::initializeState ( State &  ) const

virtual

Finish initializing the unparser state.

This gets called by the unparse methods just after the state object is created. It can be used to adjust the state before any unparsing actually starts. One common use is to initialize the global margin arrows. The base implementation does nothing except chain to the next unparser.

updateIntraFunctionArrows()

virtual void Rose::BinaryAnalysis::Unparser::Base::updateIntraFunctionArrows ( State &  ) const

virtual

Calculate intra-function arrows.

This is the oppurtunity for the subclass to calculate the intra-function arrows that should appear in the left margin of the output. This function is invoked by the base parser after emitting the function prologue and after possibly calculating CFG intra-function arrows but before emitting any basic blocks or data blocks for the function.

juxtaposeColumns()

static std::string Rose::BinaryAnalysis::Unparser::Base::juxtaposeColumns ( const std::vector< std::string > &  content, const std::vector< size_t > &  minWidths, const std::vector< std::pair< std::string, std::string > > &  colorEscapes, const std::string &  columnSeparator = " "  )

static

Render a table row.

Given a row of table data as a vector of cell contents, each of which could be multiple lines, return a string, also possibly multiple lines, that renders the row into columns. The colorEscapes are the pair of strings that should be emitted before and after each column and do not contribute to the width of the column.

ascendingSourceAddress()

static bool Rose::BinaryAnalysis::Unparser::Base::ascendingSourceAddress ( Partitioner2::ControlFlowGraph::ConstEdgeIterator  a, Partitioner2::ControlFlowGraph::ConstEdgeIterator  b  )

static

Return true if edges are in order by source address.

If edge a has a source address that's less than the address of b, or if @ a has a source address and b has no source address, then return true; otherwise return false. Both edges must be valid edges, not end iterators. This defines the order that block prefixes are emitted. Source addresses are the last address of the source vertex.

ascendingTargetAddress()

static bool Rose::BinaryAnalysis::Unparser::Base::ascendingTargetAddress ( Partitioner2::ControlFlowGraph::ConstEdgeIterator  a, Partitioner2::ControlFlowGraph::ConstEdgeIterator  b  )

static

Return true if edges are in order by target address.

If edge a has a target address that's less than the address of b, or if @ a has a target address and b has no target address, then return true; otherwise return false. Both edges must be valid edges, not end iterators. This defines the order that block suffixes are emitted. Target addresses are the first address of the target vertex.

orderedBlockPredecessors()

static std::vector< Partitioner2::ControlFlowGraph::ConstEdgeIterator > Rose::BinaryAnalysis::Unparser::Base::orderedBlockPredecessors ( const Partitioner2::PartitionerConstPtr &  , const Partitioner2::BasicBlockPtr &    )

static

Ordered incoming CFG edges.

Returns the incoming CFG edges for the specified basic block in the order that they should be displayed in the listing. The order is defined by ascendingSourceAddress.

orderedBlockSuccessors()

static std::vector< Partitioner2::ControlFlowGraph::ConstEdgeIterator > Rose::BinaryAnalysis::Unparser::Base::orderedBlockSuccessors ( const Partitioner2::PartitionerConstPtr &  , const Partitioner2::BasicBlockPtr &    )

static

Ordered outgoing CFG edges.

Returns the outgoing CFG edges for the specified basic block in the order that they should be displayed in the listing. The order is defined by ascendingTargetAddress.

---

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

• Unparser/Base.h