ROSE  0.9.10.54
Public Types | Public Member Functions | Static Public Member Functions | Protected Member Functions | List of all members
Rose::BinaryAnalysis::Unparser::Base Class Referenceabstract

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 inovke 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 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).

Definition at line 69 of file BinaryUnparserBase.h.

#include <BinaryUnparserBase.h>

Inheritance diagram for Rose::BinaryAnalysis::Unparser::Base:
Inheritance graph
[legend]
Collaboration diagram for Rose::BinaryAnalysis::Unparser::Base:
Collaboration graph
[legend]

Public Types

typedef Sawyer::SharedPointer< BasePtr
 

Public Member Functions

virtual Ptr copy () const =0
 
virtual const Settingssettings () const =0
 
virtual Settingssettings ()=0
 
Ptr nextUnparser () const
 
void operator() (std::ostream &out, const Partitioner2::Partitioner &p) const
 Emit the entity to an output stream. More...
 
void operator() (std::ostream &out, const Partitioner2::Partitioner &p, SgAsmInstruction *insn) const
 Emit the entity to an output stream. More...
 
void operator() (std::ostream &out, const Partitioner2::Partitioner &p, const Partitioner2::BasicBlockPtr &bb) const
 Emit the entity to an output stream. More...
 
void operator() (std::ostream &out, const Partitioner2::Partitioner &p, const Partitioner2::DataBlockPtr &db) const
 Emit the entity to an output stream. More...
 
void operator() (std::ostream &out, const Partitioner2::Partitioner &p, const Partitioner2::FunctionPtr &f) const
 Emit the entity to an output stream. More...
 
std::string operator() (const Partitioner2::Partitioner &p) const
 Emit the entity to a string. More...
 
std::string operator() (const Partitioner2::Partitioner &p, SgAsmInstruction *insn) const
 Emit the entity to a string. More...
 
std::string operator() (const Partitioner2::Partitioner &p, const Partitioner2::BasicBlockPtr &bb) const
 Emit the entity to a string. More...
 
std::string operator() (const Partitioner2::Partitioner &p, const Partitioner2::DataBlockPtr &db) const
 Emit the entity to a string. More...
 
std::string operator() (const Partitioner2::Partitioner &p, const Partitioner2::FunctionPtr &f) const
 Emit the entity to a string. More...
 
void unparse (std::ostream &, const Partitioner2::Partitioner &) const
 High-level unparsing function. More...
 
void unparse (std::ostream &, const Partitioner2::Partitioner &, SgAsmInstruction *) const
 High-level unparsing function. More...
 
void unparse (std::ostream &, const Partitioner2::Partitioner &, const Partitioner2::BasicBlockPtr &) const
 High-level unparsing function. More...
 
void unparse (std::ostream &, const Partitioner2::Partitioner &, const Partitioner2::DataBlockPtr &) const
 High-level unparsing function. More...
 
void unparse (std::ostream &, const Partitioner2::Partitioner &, const Partitioner2::FunctionPtr &) const
 High-level unparsing function. More...
 
std::string unparse (const Partitioner2::Partitioner &) const
 High-level unparsing function. More...
 
std::string unparse (const Partitioner2::Partitioner &, SgAsmInstruction *) const
 High-level unparsing function. More...
 
std::string unparse (const Partitioner2::Partitioner &, const Partitioner2::BasicBlockPtr &) const
 High-level unparsing function. More...
 
std::string unparse (const Partitioner2::Partitioner &, const Partitioner2::DataBlockPtr &) const
 High-level unparsing function. More...
 
std::string unparse (const Partitioner2::Partitioner &, const Partitioner2::FunctionPtr &) const
 High-level unparsing function. More...
 
virtual void emitFunction (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionPrologue (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionBody (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionEpilogue (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionReasons (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionCallers (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionCallees (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionComment (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionStackDelta (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionCallingConvention (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionNoopAnalysis (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitFunctionMayReturn (std::ostream &, const Partitioner2::FunctionPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitDataBlock (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitDataBlockPrologue (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitDataBlockBody (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitDataBlockEpilogue (std::ostream &, const Partitioner2::DataBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlock (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockPrologue (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockBody (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockEpilogue (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockComment (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockSharing (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockPredecessors (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitBasicBlockSuccessors (std::ostream &, const Partitioner2::BasicBlockPtr &, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstruction (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionPrologue (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionBody (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionEpilogue (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionAddress (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionBytes (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionStackDelta (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionMnemonic (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionOperands (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitInstructionComment (std::ostream &, SgAsmInstruction *, State &) const
 Mid-level unparser function. More...
 
virtual void emitOperand (std::ostream &, SgAsmExpression *, State &) const
 Mid-level unparser function. More...
 
virtual void emitOperandPrologue (std::ostream &, SgAsmExpression *, State &) const
 Mid-level unparser function. More...
 
virtual void emitOperandBody (std::ostream &, SgAsmExpression *, State &) const
 Mid-level unparser function. More...
 
virtual void emitOperandEpilogue (std::ostream &, SgAsmExpression *, State &) const
 Mid-level unparser function. More...
 
virtual void emitRegister (std::ostream &, RegisterDescriptor, State &) const
 Mid-level unparser function. More...
 
virtual std::vector< std::string > emitUnsignedInteger (std::ostream &, const Sawyer::Container::BitVector &, State &) const
 Mid-level unparser function. More...
 
virtual std::vector< std::string > emitSignedInteger (std::ostream &, const Sawyer::Container::BitVector &, State &) const
 Mid-level unparser function. More...
 
virtual std::vector< std::string > emitInteger (std::ostream &, const Sawyer::Container::BitVector &, State &, bool isSigned) const
 Mid-level unparser function. More...
 
virtual bool emitAddress (std::ostream &, rose_addr_t, State &, bool always=true) const
 Mid-level unparser function. More...
 
virtual bool emitAddress (std::ostream &, const Sawyer::Container::BitVector &, State &, bool always=true) const
 Mid-level unparser function. More...
 
virtual void emitCommentBlock (std::ostream &, const std::string &, State &, const std::string &prefix=";;; ") const
 Mid-level unparser function. More...
 
virtual void emitTypeName (std::ostream &, SgAsmType *, State &) const
 Mid-level unparser function. More...
 
- Public Member Functions inherited from Sawyer::SharedObject
 SharedObject ()
 Default constructor. More...
 
 SharedObject (const SharedObject &)
 Copy constructor. More...
 
virtual ~SharedObject ()
 Virtual destructor. More...
 
SharedObjectoperator= (const SharedObject &)
 Assignment. More...
 

Static Public Member Functions

static std::string leftJustify (const std::string &, size_t nchars)
 
static std::string juxtaposeColumns (const std::vector< std::string > &content, const std::vector< size_t > &minWidths, const std::string &columnSeparator=" ")
 

Protected Member Functions

 Base (const Ptr &nextUnparser)
 

Member Function Documentation

void Rose::BinaryAnalysis::Unparser::Base::operator() ( std::ostream &  out,
const Partitioner2::Partitioner p 
) const
inline

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.

Definition at line 96 of file BinaryUnparserBase.h.

References unparse().

void Rose::BinaryAnalysis::Unparser::Base::operator() ( std::ostream &  out,
const Partitioner2::Partitioner p,
SgAsmInstruction insn 
) const
inline

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.

Definition at line 99 of file BinaryUnparserBase.h.

References unparse().

void Rose::BinaryAnalysis::Unparser::Base::operator() ( std::ostream &  out,
const Partitioner2::Partitioner p,
const Partitioner2::BasicBlockPtr bb 
) const
inline

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.

Definition at line 103 of file BinaryUnparserBase.h.

References unparse().

void Rose::BinaryAnalysis::Unparser::Base::operator() ( std::ostream &  out,
const Partitioner2::Partitioner p,
const Partitioner2::DataBlockPtr db 
) const
inline

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.

Definition at line 107 of file BinaryUnparserBase.h.

References unparse().

void Rose::BinaryAnalysis::Unparser::Base::operator() ( std::ostream &  out,
const Partitioner2::Partitioner p,
const Partitioner2::FunctionPtr f 
) const
inline

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.

Definition at line 111 of file BinaryUnparserBase.h.

References unparse().

std::string Rose::BinaryAnalysis::Unparser::Base::operator() ( const Partitioner2::Partitioner p) const
inline

Emit the entity to a string.

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

Definition at line 122 of file BinaryUnparserBase.h.

References unparse().

std::string Rose::BinaryAnalysis::Unparser::Base::operator() ( const Partitioner2::Partitioner p,
SgAsmInstruction insn 
) const
inline

Emit the entity to a string.

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

Definition at line 125 of file BinaryUnparserBase.h.

References unparse().

std::string Rose::BinaryAnalysis::Unparser::Base::operator() ( const Partitioner2::Partitioner p,
const Partitioner2::BasicBlockPtr bb 
) const
inline

Emit the entity to a string.

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

Definition at line 128 of file BinaryUnparserBase.h.

References unparse().

std::string Rose::BinaryAnalysis::Unparser::Base::operator() ( const Partitioner2::Partitioner p,
const Partitioner2::DataBlockPtr db 
) const
inline

Emit the entity to a string.

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

Definition at line 131 of file BinaryUnparserBase.h.

References unparse().

std::string Rose::BinaryAnalysis::Unparser::Base::operator() ( const Partitioner2::Partitioner p,
const Partitioner2::FunctionPtr f 
) const
inline

Emit the entity to a string.

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

Definition at line 134 of file BinaryUnparserBase.h.

References unparse().

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

High-level unparsing function.

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

Referenced by operator()().

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

High-level unparsing function.

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

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

High-level unparsing function.

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

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

High-level unparsing function.

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

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

High-level unparsing function.

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

std::string Rose::BinaryAnalysis::Unparser::Base::unparse ( const Partitioner2::Partitioner ) const

High-level unparsing function.

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

std::string Rose::BinaryAnalysis::Unparser::Base::unparse ( const Partitioner2::Partitioner ,
SgAsmInstruction  
) const

High-level unparsing function.

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

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

High-level unparsing function.

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

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

High-level unparsing function.

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

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

High-level unparsing function.

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

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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::M68k, Rose::BinaryAnalysis::Unparser::Mips, and Rose::BinaryAnalysis::Unparser::Powerpc.

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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::Arm, and Rose::BinaryAnalysis::Unparser::X86.

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 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".

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 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".

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 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".

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 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".

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 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::Arm, Rose::BinaryAnalysis::Unparser::M68k, Rose::BinaryAnalysis::Unparser::Mips, Rose::BinaryAnalysis::Unparser::Powerpc, and Rose::BinaryAnalysis::Unparser::X86.

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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".

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 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.


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