The c-language token emitter. More...

#include <printc.hh>

Inheritance diagram for PrintC:

Collaboration diagram for PrintC:

[legend]

Public Member Functions
	PrintC (Architecture *g, const string &nm="c-language")
	Constructor. More...

virtual void	resetDefaults (void)
	Set printing options to their default value.

virtual void	adjustTypeOperators (void)
	Set basic data-type information for p-code operators.

virtual void	setCommentStyle (const string &nm)
	Set the way comments are displayed in decompiler output. More...

virtual void	docTypeDefinitions (const TypeFactory *typegrp)
	Emit definitions of data-types. More...

virtual void	docAllGlobals (void)
	Emit declarations of global variables.

virtual void	docSingleGlobal (const Symbol *sym)
	Emit the declaration for a single (global) Symbol. More...

virtual void	docFunction (const Funcdata *fd)
	Emit the declaration (and body) of a function. More...

virtual void	emitBlockBasic (const BlockBasic *bb)
	Emit statements in a basic block.

virtual void	emitBlockGraph (const BlockGraph *bl)
	Emit (an unspecified) list of blocks.

virtual void	emitBlockCopy (const BlockCopy *bl)
	Emit a basic block (with any labels)

virtual void	emitBlockGoto (const BlockGoto *bl)
	Emit a block ending with a goto statement.

virtual void	emitBlockLs (const BlockList *bl)
	Emit a sequence of blocks.

virtual void	emitBlockCondition (const BlockCondition *bl)
	Emit a conditional statement.

virtual void	emitBlockIf (const BlockIf *bl)
	Emit an if/else style construct.

virtual void	emitBlockWhileDo (const BlockWhileDo *bl)
	Emit a loop structure, check at top.

virtual void	emitBlockDoWhile (const BlockDoWhile *bl)
	Emit a loop structure, check at bottom.

virtual void	emitBlockInfLoop (const BlockInfLoop *bl)
	Emit an infinite loop structure.

virtual void	emitBlockSwitch (const BlockSwitch *bl)
	Emit a switch structure.

virtual void	opCopy (const PcodeOp *op)
	Emit a COPY operator.

virtual void	opLoad (const PcodeOp *op)
	Emit a LOAD operator.

virtual void	opStore (const PcodeOp *op)
	Emit a STORE operator.

virtual void	opBranch (const PcodeOp *op)
	Emit a BRANCH operator.

virtual void	opCbranch (const PcodeOp *op)

virtual void	opBranchind (const PcodeOp *op)
	Emit a BRANCHIND operator.

virtual void	opCall (const PcodeOp *op)
	Emit a CALL operator.

virtual void	opCallind (const PcodeOp *op)
	Emit a CALLIND operator.

virtual void	opCallother (const PcodeOp *op)
	Emit a CALLOTHER operator.

virtual void	opConstructor (const PcodeOp *op, bool withNew)
	Emit an operator constructing an object.

virtual void	opReturn (const PcodeOp *op)
	Emit a RETURN operator.

virtual void	opIntEqual (const PcodeOp *op)
	Emit a INT_EQUAL operator.

virtual void	opIntNotEqual (const PcodeOp *op)
	Emit a INT_NOTEQUAL operator.

virtual void	opIntSless (const PcodeOp *op)
	Emit a INT_SLESS operator.

virtual void	opIntSlessEqual (const PcodeOp *op)
	Emit a INT_SLESSEQUAL operator.

virtual void	opIntLess (const PcodeOp *op)
	Emit a INT_LESS operator.

virtual void	opIntLessEqual (const PcodeOp *op)
	Emit a INT_LESSEQUAL operator.

virtual void	opIntZext (const PcodeOp op, const PcodeOp readOp)
	Emit a INT_ZEXT operator.

virtual void	opIntSext (const PcodeOp op, const PcodeOp readOp)
	Emit a INT_SEXT operator.

virtual void	opIntAdd (const PcodeOp *op)
	Emit a INT_ADD operator.

virtual void	opIntSub (const PcodeOp *op)
	Emit a INT_SUB operator.

virtual void	opIntCarry (const PcodeOp *op)
	Emit a INT_CARRY operator.

virtual void	opIntScarry (const PcodeOp *op)
	Emit a INT_SCARRY operator.

virtual void	opIntSborrow (const PcodeOp *op)
	Emit a INT_SBORROW operator.

virtual void	opInt2Comp (const PcodeOp *op)
	Emit a INT_2COMP operator.

virtual void	opIntNegate (const PcodeOp *op)
	Emit a INT_NEGATE operator.

virtual void	opIntXor (const PcodeOp *op)
	Emit a INT_XOR operator.

virtual void	opIntAnd (const PcodeOp *op)
	Emit a INT_AND operator.

virtual void	opIntOr (const PcodeOp *op)
	Emit a INT_OR operator.

virtual void	opIntLeft (const PcodeOp *op)
	Emit a INT_LEFT operator.

virtual void	opIntRight (const PcodeOp *op)
	Emit a INT_RIGHT operator.

virtual void	opIntSright (const PcodeOp *op)
	Emit a INT_SRIGHT operator.

virtual void	opIntMult (const PcodeOp *op)
	Emit a INT_MULT operator.

virtual void	opIntDiv (const PcodeOp *op)
	Emit a INT_DIV operator.

virtual void	opIntSdiv (const PcodeOp *op)
	Emit a INT_SDIV operator.

virtual void	opIntRem (const PcodeOp *op)
	Emit a INT_REM operator.

virtual void	opIntSrem (const PcodeOp *op)
	Emit a INT_SREM operator.

virtual void	opBoolNegate (const PcodeOp *op)

virtual void	opBoolXor (const PcodeOp *op)
	Emit a BOOL_XOR operator.

virtual void	opBoolAnd (const PcodeOp *op)
	Emit a BOOL_AND operator.

virtual void	opBoolOr (const PcodeOp *op)
	Emit a BOOL_OR operator.

virtual void	opFloatEqual (const PcodeOp *op)
	Emit a FLOAT_EQUAL operator.

virtual void	opFloatNotEqual (const PcodeOp *op)
	Emit a FLOAT_NOTEQUAL operator.

virtual void	opFloatLess (const PcodeOp *op)
	Emit a FLOAT_LESS operator.

virtual void	opFloatLessEqual (const PcodeOp *op)
	Emit a FLOAT_LESSEQUAL operator.

virtual void	opFloatNan (const PcodeOp *op)
	Emit a FLOAT_NAN operator.

virtual void	opFloatAdd (const PcodeOp *op)
	Emit a FLOAT_ADD operator.

virtual void	opFloatDiv (const PcodeOp *op)
	Emit a FLOAT_DIV operator.

virtual void	opFloatMult (const PcodeOp *op)
	Emit a FLOAT_MULT operator.

virtual void	opFloatSub (const PcodeOp *op)
	Emit a FLOAT_SUB operator.

virtual void	opFloatNeg (const PcodeOp *op)
	Emit a FLOAT_NEG operator.

virtual void	opFloatAbs (const PcodeOp *op)
	Emit a FLOAT_ABS operator.

virtual void	opFloatSqrt (const PcodeOp *op)
	Emit a FLOAT_SQRT operator.

virtual void	opFloatInt2Float (const PcodeOp *op)
	Emit a FLOAT_INT2FLOAT operator.

virtual void	opFloatFloat2Float (const PcodeOp *op)
	Emit a FLOAT_FLOAT2FLOAT operator.

virtual void	opFloatTrunc (const PcodeOp *op)
	Emit a FLOAT_TRUNC operator.

virtual void	opFloatCeil (const PcodeOp *op)
	Emit a FLOAT_CEIL operator.

virtual void	opFloatFloor (const PcodeOp *op)
	Emit a FLOAT_FLOOR operator.

virtual void	opFloatRound (const PcodeOp *op)
	Emit a FLOAT_ROUND operator.

virtual void	opMultiequal (const PcodeOp *op)
	Emit a MULTIEQUAL operator.

virtual void	opIndirect (const PcodeOp *op)
	Emit a INDIRECT operator.

virtual void	opPiece (const PcodeOp *op)
	Emit a PIECE operator.

virtual void	opSubpiece (const PcodeOp *op)
	Emit a SUBPIECE operator.

virtual void	opCast (const PcodeOp *op)
	Emit a CAST operator.

virtual void	opPtradd (const PcodeOp *op)
	Emit a PTRADD operator.

virtual void	opPtrsub (const PcodeOp *op)

virtual void	opSegmentOp (const PcodeOp *op)

virtual void	opCpoolRefOp (const PcodeOp *op)
	Emit a CPOOLREF operator.

virtual void	opNewOp (const PcodeOp *op)
	Emit a NEW operator.

virtual void	opInsertOp (const PcodeOp *op)
	Emit an INSERT operator.

virtual void	opExtractOp (const PcodeOp *op)
	Emit an EXTRACT operator.

virtual void	opPopcountOp (const PcodeOp *op)
	Emit a POPCOUNT operator.

Public Member Functions inherited from PrintLanguage
	PrintLanguage (Architecture *g, const string &nm)
	Constructor. More...

virtual	~PrintLanguage (void)
	Destructor.

void	setLineCommentIndent (int4 val)
	Set the number of characters to indent comment lines. More...

void	setCommentDelimeter (const string &start, const string &stop, bool usecommentfill)
	Establish comment delimiters for the language. More...

void	setXML (bool val)
	Set whether the low-level emitter, emits XML markup. More...

void	setFlat (bool val)
	Set whether nesting code structure should be emitted. More...

virtual void	clear (void)
	Clear the RPN stack and the low-level emitter.

virtual void	setIntegerFormat (const string &nm)
	Set the default integer format. More...

Protected Member Functions
void	buildTypeStack (const Datatype ct, vector< const Datatype > &typestack)
	Prepare to push components of a data-type declaration. More...

void	pushPrototypeInputs (const FuncProto *proto)
	Push input parameters. More...

void	pushSymbolScope (const Symbol *symbol)
	Push tokens resolving a symbol's scope. More...

void	emitSymbolScope (const Symbol *symbol)
	Emit tokens resolving a symbol's scope. More...

virtual void	pushTypeStart (const Datatype *ct, bool noident)
	Push part of a data-type declaration onto the RPN stack, up to the identifier. More...

virtual void	pushTypeEnd (const Datatype *ct)
	Push the tail ends of a data-type declaration onto the RPN stack. More...

void	pushBoolConstant (uintb val, const TypeBase ct, const Varnode vn, const PcodeOp *op)
	Push a true or false token to the RPN stack. More...

void	pushCharConstant (uintb val, const TypeChar ct, const Varnode vn, const PcodeOp *op)
	Push a single character constant to the RPN stack. More...

void	pushEnumConstant (uintb val, const TypeEnum ct, const Varnode vn, const PcodeOp *op)
	Push an enumerated value to the RPN stack. More...

virtual bool	pushPtrCharConstant (uintb val, const TypePointer ct, const Varnode vn, const PcodeOp *op)
	Attempt to push a quoted string representing a given constant pointer onto the RPN stack. More...

bool	pushPtrCodeConstant (uintb val, const TypePointer ct, const Varnode vn, const PcodeOp *op)
	Attempt to push a function name representing a constant pointer onto the RPN stack. More...

virtual bool	doEmitWideCharPrefix (void) const
	Return true if this language requires a prefix when expressing wide characters. More...

bool	checkArrayDeref (const Varnode *vn) const
	Determine whether a LOAD/STORE expression requires pointer '*' syntax. More...

void	emitStructDefinition (const TypeStruct *ct)
	Emit the definition of a structure data-type. More...

void	emitEnumDefinition (const TypeEnum *ct)
	Emit the definition of an enumeration data-type. More...

void	emitPrototypeOutput (const FuncProto proto, const Funcdata fd)
	Emit the output data-type of a function prototype. More...

void	emitPrototypeInputs (const FuncProto *proto)
	Emit the input data-types of a function prototype. More...

void	emitGlobalVarDeclsRecursive (Scope *scope)
	Emit variable declarations for all global symbols under given scope. More...

void	emitLocalVarDecls (const Funcdata *fd)
	Emit variable declarations for a function. More...

void	emitStatement (const PcodeOp *inst)
	Emit a statement in the body of a function. More...

bool	emitInplaceOp (const PcodeOp *op)
	Attempt to emit an expression rooted at an in-place operator. More...

void	emitGotoStatement (const FlowBlock bl, const FlowBlock exp_bl, uint4 type)
	Emit a statement representing an unstructured branch. More...

void	emitSwitchCase (int4 casenum, const BlockSwitch *switchbl)
	Emit labels for a case block. More...

void	emitLabel (const FlowBlock *bl)
	Emit a formal label for a given control-flow block. More...

void	emitLabelStatement (const FlowBlock *bl)
	Emit any required label statement for a given basic block. More...

void	emitAnyLabelStatement (const FlowBlock *bl)
	Emit any required label statement for a given control-flow block. More...

void	emitCommentGroup (const PcodeOp *inst)
	Emit comments associated with a given statement. More...

void	emitCommentBlockTree (const FlowBlock *bl)
	Emit any comments under the given control-flow subtree. More...

void	emitCommentFuncHeader (const Funcdata *fd)
	Emit comments in the given function's header. More...

void	emitForLoop (const BlockWhileDo *bl)
	Emit block as a for loop. More...

void	opFunc (const PcodeOp *op)
	Push a functional expression based on the given p-code op to the RPN stack. More...

void	opTypeCast (const PcodeOp *op)
	Push the given p-code op using type-cast syntax to the RPN stack. More...

void	opHiddenFunc (const PcodeOp *op)
	Push the given p-code op as a hidden token. More...

bool	printCharacterConstant (ostream &s, const Address &addr, Datatype *charType) const
	Print a quoted (unicode) string at the given address. More...

int4	getHiddenThisSlot (const PcodeOp op, FuncProto fc)
	Get position of "this" pointer needing to be hidden. More...

void	resetDefaultsPrintC (void)
	Set default values for options specific to PrintC.

virtual void	pushConstant (uintb val, const Datatype ct, const Varnode vn, const PcodeOp *op)
	Push a constant onto the RPN stack. More...

virtual bool	pushEquate (uintb val, int4 sz, const EquateSymbol sym, const Varnode vn, const PcodeOp *op)
	Push a constant marked up by and EquateSymbol onto the RPN stack. More...

virtual void	pushAnnotation (const Varnode vn, const PcodeOp op)
	Push an address which is not in the normal data-flow. More...

virtual void	pushSymbol (const Symbol sym, const Varnode vn, const PcodeOp *op)
	Push a specific Symbol onto the RPN stack. More...

virtual void	pushUnnamedLocation (const Address &addr, const Varnode vn, const PcodeOp op)
	Push an address as a substitute for a Symbol onto the RPN stack. More...

virtual void	pushPartialSymbol (const Symbol sym, int4 off, int4 sz, const Varnode vn, const PcodeOp op, Datatype outtype)
	Push a variable that represents only part of a symbol onto the RPN stack. More...

virtual void	pushMismatchSymbol (const Symbol sym, int4 off, int4 sz, const Varnode vn, const PcodeOp *op)
	Push an identifier for a variable that mismatches with its Symbol. More...

virtual void	push_integer (uintb val, int4 sz, bool sign, const Varnode vn, const PcodeOp op)
	Push a constant with an integer data-type to the RPN stack. More...

virtual void	push_float (uintb val, int4 sz, const Varnode vn, const PcodeOp op)
	Push a constant with a floating-point data-type to the RPN stack. More...

virtual void	printUnicode (ostream &s, int4 onechar) const
	Print a single unicode character as a character constant for the high-level language. More...

virtual void	pushType (const Datatype *ct)
	Push a data-type name onto the RPN expression stack. More...

virtual string	genericFunctionName (const Address &addr)
	Create a generic function name base on the entry point address. More...

virtual string	genericTypeName (const Datatype *ct)
	Generate a generic name for an unnamed data-type. More...

virtual void	emitExpression (const PcodeOp *op)
	Emit a full expression. More...

virtual void	emitVarDecl (const Symbol *sym)
	Emit a variable declaration. More...

virtual void	emitVarDeclStatement (const Symbol *sym)
	Emit a variable declaration statement. More...

virtual bool	emitScopeVarDecls (const Scope *scope, int4 cat)
	Emit all the variable declarations for a given scope. More...

virtual void	emitFunctionDeclaration (const Funcdata *fd)
	Emit a function declaration. More...

virtual void	emitTypeDefinition (const Datatype *ct)
	Emit the definition of the given data-type. More...

virtual bool	checkPrintNegation (const Varnode *vn)
	Check whether a given boolean Varnode can be printed in negated form. More...

Protected Member Functions inherited from PrintLanguage
void	popScope (void)
	Pop to the previous symbol scope.

void	pushOp (const OpToken tok, const PcodeOp op)
	Push an operator token onto the RPN stack. More...

void	pushAtom (const Atom &atom)
	Push a variable token onto the RPN stack. More...

void	pushVnImplied (const Varnode vn, const PcodeOp op, uint4 m)
	Push an implied variable onto the RPN stack. More...

void	pushVnExplicit (const Varnode vn, const PcodeOp op)
	Push an explicit variable onto the RPN stack. More...

void	pushVnLHS (const Varnode vn, const PcodeOp op)
	Push a variable as the left-hand side of an expression. More...

bool	parentheses (const OpToken *op2)
	Determine if the given token should be emitted in its own parenthetic expression. More...

void	emitOp (const ReversePolish &entry)
	Send an operator token from the RPN to the emitter. More...

void	emitAtom (const Atom &atom)
	Send an variable token from the RPN to the emitter. More...

bool	escapeCharacterData (ostream &s, const uint1 *buf, int4 count, int4 charsize, bool bigend) const
	Emit a byte buffer to the stream as unicode characters. More...

void	recurse (void)
	Emit from the RPN stack as much as possible. More...

void	opBinary (const OpToken tok, const PcodeOp op)
	Push a binary operator onto the RPN stack. More...

void	opUnary (const OpToken tok, const PcodeOp op)
	Push a unary operator onto the RPN stack. More...

void	resetDefaultsInternal (void)
	Reset options to default for PrintLanguage.

virtual void	emitLineComment (int4 indent, const Comment *comm)
	Emit a comment line. More...

Protected Attributes
bool	option_NULL
	Set to true if we should emit NULL keyword.

bool	option_inplace_ops
	Set to true if we should use '+=' '&=' etc.

bool	option_convention
	Set to true if we should print calling convention.

bool	option_nocasts
	Don't print a cast if true.

bool	option_unplaced
	Set to true if we should display unplaced comments.

bool	option_hide_exts
	Set to true if we should hide implied extension operations.

string	nullToken
	Token to use for 'null'.

CommentSorter	commsorter
	Container/organizer for comments in the current function.

Protected Attributes inherited from PrintLanguage
Architecture *	glb
	The Architecture owning the language emitter.

const Scope *	curscope
	The current symbol scope.

CastStrategy *	castStrategy
	The strategy for emitting explicit case operations.

EmitXml *	emit
	The low-level token emitter.

uint4	mods
	Currently active printing modifications.

uint4	instr_comment_type
	Type of instruction comments to display.

uint4	head_comment_type
	Type of header comments to display.

namespace_strategy	namespc_strategy
	How should namespace tokens be displayed.

Static Protected Attributes
static OpToken	hidden = { "", 1, 70, false, OpToken::hiddenfunction, 0, 0, (OpToken *)0 }
	Hidden functional (that may force parentheses)

static OpToken	scope = { "::", 2, 70, true, OpToken::binary, 0, 0, (OpToken *)0 }
	The sub-scope/namespace operator.

static OpToken	object_member = { ".", 2, 66, true, OpToken::binary, 0, 0, (OpToken *)0 }
	The member operator.

static OpToken	pointer_member = { "->", 2, 66, true, OpToken::binary, 0, 0, (OpToken *)0 }
	The points to member operator.

static OpToken	subscript = { "[]", 2, 66, false, OpToken::postsurround, 0, 0, (OpToken *)0 }
	The array subscript operator.

static OpToken	function_call = { "()", 2, 66, false, OpToken::postsurround, 0, 10, (OpToken *)0 }
	The function call operator.

static OpToken	bitwise_not = { "~", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken *)0 }
	The bitwise negate operator.

static OpToken	boolean_not = { "!", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken *)0 }
	The boolean not operator.

static OpToken	unary_minus = { "-", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken *)0 }
	The unary minus operator.

static OpToken	unary_plus = { "+", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken *)0 }
	The unary plus operator.

static OpToken	addressof = { "&", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken *)0 }
	The address of operator.

static OpToken	dereference = { "", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken )0 }
	The pointer dereference operator.

static OpToken	typecast = { "()", 2, 62, false, OpToken::presurround, 0, 0, (OpToken *)0 }
	The type cast operator.

static OpToken	multiply = { "", 2, 54, true, OpToken::binary, 1, 0, (OpToken )0 }
	The multiplication operator.

static OpToken	divide = { "/", 2, 54, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The division operator.

static OpToken	modulo = { "%", 2, 54, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The modulo operator.

static OpToken	binary_plus = { "+", 2, 50, true, OpToken::binary, 1, 0, (OpToken *)0 }
	The binary addition operator.

static OpToken	binary_minus = { "-", 2, 50, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The binary subtraction operator.

static OpToken	shift_left = { "<<", 2, 46, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The left shift operator.

static OpToken	shift_right = { ">>", 2, 46, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The right shift operator.

static OpToken	shift_sright = { ">>", 2, 46, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The signed right shift operator.

static OpToken	less_than = { "<", 2, 42, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The less than operator.

static OpToken	less_equal = { "<=", 2, 42, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The less than or equal operator.

static OpToken	greater_than = { ">", 2, 42, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The greater than operator.

static OpToken	greater_equal = { ">=", 2, 42, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The greater than or equal operator.

static OpToken	equal = { "==", 2, 38, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The equal operator.

static OpToken	not_equal = { "!=", 2, 38, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The not equal operator.

static OpToken	bitwise_and = { "&", 2, 34, true, OpToken::binary, 1, 0, (OpToken *)0 }
	The logical and operator.

static OpToken	bitwise_xor = { "^", 2, 30, true, OpToken::binary, 1, 0, (OpToken *)0 }
	The logical xor operator.

static OpToken	bitwise_or = { "\|", 2, 26, true, OpToken::binary, 1, 0, (OpToken *)0 }
	The logical or operator.

static OpToken	boolean_and = { "&&", 2, 22, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The boolean and operator.

static OpToken	boolean_or = { "\|\|", 2, 18, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The boolean or operator.

static OpToken	boolean_xor = { "^^", 2, 20, false, OpToken::binary, 1, 0, (OpToken *)0 }
	The boolean xor operator.

static OpToken	assignment = { "=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The assignment operator.

static OpToken	comma = { ",", 2, 2, true, OpToken::binary, 0, 0, (OpToken *)0 }
	The comma operator (for parameter lists)

static OpToken	new_op = { "", 2, 62, false, OpToken::space, 1, 0, (OpToken *)0 }
	The new operator.

static OpToken	multequal = { "=", 2, 14, false, OpToken::binary, 1, 5, (OpToken )0 }
	The in-place multiplication operator.

static OpToken	divequal = { "/=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place division operator.

static OpToken	remequal = { "%=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place modulo operator.

static OpToken	plusequal = { "+=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place addition operator.

static OpToken	minusequal = { "-=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place subtraction operator.

static OpToken	leftequal = { "<<=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place left shift operator.

static OpToken	rightequal = { ">>=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place right shift operator.

static OpToken	andequal = { "&=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place logical and operator.

static OpToken	orequal = { "\|=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place logical or operator.

static OpToken	xorequal = { "^=", 2, 14, false, OpToken::binary, 1, 5, (OpToken *)0 }
	The in-place logical xor operator.

static OpToken	type_expr_space = { "", 2, 10, false, OpToken::space, 1, 0, (OpToken *)0 }
	Type declaration involving a space (identifier or adornment)

static OpToken	type_expr_nospace = { "", 2, 10, false, OpToken::space, 0, 0, (OpToken *)0 }
	Type declaration with no space.

static OpToken	ptr_expr = { "", 1, 62, false, OpToken::unary_prefix, 0, 0, (OpToken )0 }
	Pointer adornment for a type declaration.

static OpToken	array_expr = { "[]", 2, 66, false, OpToken::postsurround, 1, 0, (OpToken *)0 }
	Array adornment for a type declaration.

static OpToken	enum_cat = { "\|", 2, 26, true, OpToken::binary, 0, 0, (OpToken *)0 }
	The concatenation operator for enumerated values.

Additional Inherited Members
Public Types inherited from PrintLanguage
enum	modifiers { force_hex = 1, force_dec = 2, bestfit = 4, force_scinote = 8, force_pointer = 0x10, print_load_value = 0x20, print_store_value = 0x40, no_branch = 0x80, only_branch = 0x100, comma_separate = 0x200, flat = 0x400, falsebranch = 0x800, nofallthru = 0x1000, negatetoken = 0x2000, hide_thisparam = 0x4000 }
	Possible context sensitive modifiers to how tokens get emitted. More...

enum	tagtype { syntax, vartoken, functoken, optoken, typetoken, fieldtoken, blanktoken }
	Possible types of Atom. More...

enum	namespace_strategy { MINIMAL_NAMESPACES = 0, NO_NAMESPACES = 1, ALL_NAMESPACES = 2 }
	Strategies for displaying namespace tokens. More...

Static Public Member Functions inherited from PrintLanguage
static int4	mostNaturalBase (uintb val)
	Determine the most natural base for an integer. More...

static void	formatBinary (ostream &s, uintb val)
	Print a number in binary form. More...

Static Protected Member Functions inherited from PrintLanguage
static bool	unicodeNeedsEscape (int4 codepoint)
	Determine if the given codepoint needs to be escaped. More...

Detailed Description

The c-language token emitter.

The c-language specific rules for emitting:

expressions
statements
function prototypes
variable declarations
if/else structures
loop structures
etc.

Constructor & Destructor Documentation

◆ PrintC()

PrintC::PrintC	(	Architecture *	g,
		const string &	nm = `"c-language"`
	)

Constructor.

Parameters

g	is the Architecture owning this c-language emitter
nm	is the name assigned to this emitter

Member Function Documentation

◆ buildTypeStack()

void PrintC::buildTypeStack	(	const Datatype *	ct,
		vector< const Datatype * > &	typestack
	)

protected

Prepare to push components of a data-type declaration.

Push nested components of a data-type declaration onto a stack, so we can access it bottom up

Parameters

ct	is the data-type being emitted
typestack	will hold the sub-types involved in the displaying the declaration

◆ checkArrayDeref()

bool PrintC::checkArrayDeref ( const Varnode * vn ) const

protected

Determine whether a LOAD/STORE expression requires pointer '*' syntax.

An expression involving a LOAD or STORE can sometimes be emitted using array syntax (or field member syntax). This method determines if this kind of syntax is appropriate or if a '*' operator is required.

Parameters

vn	is the root of the pointer expression (feeding into LOAD or STORE)

Returns: false if '*' syntax is required, true if some other syntax is used

◆ checkPrintNegation()

bool PrintC::checkPrintNegation ( const Varnode * vn )

protectedvirtual

Check whether a given boolean Varnode can be printed in negated form.

In many situations a boolean value can be inverted by flipping the operator token producing it to a complementary token.

Parameters

vn	is the given boolean Varnode

Returns: true if the value can be easily inverted

Implements PrintLanguage.

◆ docFunction()

void PrintC::docFunction ( const Funcdata * fd )

virtual

Emit the declaration (and body) of a function.

Parameters

fd	is the function to emit

Implements PrintLanguage.

Reimplemented in PrintJava.

◆ docSingleGlobal()

void PrintC::docSingleGlobal ( const Symbol * sym )

virtual

Emit the declaration for a single (global) Symbol.

Parameters

sym	is the Symbol to declare

Implements PrintLanguage.

◆ docTypeDefinitions()

void PrintC::docTypeDefinitions ( const TypeFactory * typegrp )

virtual

Emit definitions of data-types.

Parameters

typegrp is the container for the data-types that should be defined

Implements PrintLanguage.

◆ doEmitWideCharPrefix()

bool PrintC::doEmitWideCharPrefix ( void ) const

protectedvirtual

Return true if this language requires a prefix when expressing wide characters.

The c-language standard requires that strings (and character constants) made up of wide character elements have an 'L' prefix added before the quote characters. Other related languages may not do this. Having this as a virtual method lets derived languages to tailor their strings while still using the basic PrintC functionality

Returns: true if a prefix should be printed

Reimplemented in PrintJava.

◆ emitAnyLabelStatement()

void PrintC::emitAnyLabelStatement ( const FlowBlock * bl )

protected

Emit any required label statement for a given control-flow block.

The block does not have to be a basic block. This routine finds the entry basic block and prints any necessary labels for that.

Parameters

bl	is the given control-flow block

◆ emitCommentBlockTree()

void PrintC::emitCommentBlockTree ( const FlowBlock * bl )

protected

Emit any comments under the given control-flow subtree.

With the control-flow hierarchy, print any comments associated with basic blocks in the specified subtree. Used where statements from multiple basic blocks are printed on one line and a normal comment would get printed in the middle of this line.

Parameters

bl	is the root of the control-flow subtree

◆ emitCommentFuncHeader()

void PrintC::emitCommentFuncHeader ( const Funcdata * fd )

protected

Emit comments in the given function's header.

Collect all comment lines marked as header for the function and emit them with the appropriate delimiters.

Parameters

fd	is the given function

◆ emitCommentGroup()

void PrintC::emitCommentGroup ( const PcodeOp * inst )

protected

Emit comments associated with a given statement.

Collect any comment lines the sorter has associated with a statement rooted at a given PcodeOp and emit them using appropriate delimiters

Parameters

inst	is the given PcodeOp

◆ emitEnumDefinition()

void PrintC::emitEnumDefinition ( const TypeEnum * ct )

protected

Emit the definition of an enumeration data-type.

Print all the named values making up the data-type, using the enum keyword

Parameters

ct	is the enumerated data-type

◆ emitExpression()

void PrintC::emitExpression ( const PcodeOp * op )

protectedvirtual

Emit a full expression.

This can be an assignment statement, if the given PcodeOp has an output Varnode, or it can be a statement with no left-hand side.

Parameters

op	is the given PcodeOp performing the final operation of the expression

Implements PrintLanguage.

◆ emitForLoop()

void PrintC::emitForLoop ( const BlockWhileDo * bl )

protected

Emit block as a for loop.

Print the loop using the keyword for, followed by a semicolon separated

Initializer statement
Condition statment
Iterate statement

Then print the body of the loop

◆ emitFunctionDeclaration()

void PrintC::emitFunctionDeclaration ( const Funcdata * fd )

protectedvirtual

Emit a function declaration.

This prints the formal defining prototype for a function.

Parameters

fd	is the Funcdata object representing the function to be emitted

Implements PrintLanguage.

◆ emitGlobalVarDeclsRecursive()

void PrintC::emitGlobalVarDeclsRecursive ( Scope * scope )

protected

Emit variable declarations for all global symbols under given scope.

For the given scope and all of its children that are not function scopes, emit a variable declaration for each symbol.

Parameters

scope is the given scope

◆ emitGotoStatement()

void PrintC::emitGotoStatement	(	const FlowBlock *	bl,
		const FlowBlock *	exp_bl,
		uint4	type
	)

protected

Emit a statement representing an unstructured branch.

Given the type of unstructured branch, with source and destination blocks, construct a statement with the appropriate c-language keyword (goto, break, continue) representing a control-flow branch between the blocks.

Parameters

bl	is the source block
exp_bl	is the destination block (which may provide a label)
type	is the given type of the branch

◆ emitInplaceOp()

bool PrintC::emitInplaceOp ( const PcodeOp * op )

protected

Attempt to emit an expression rooted at an in-place operator.

Check that the given p-code op has an in-place token form and if the first input and the output are references to the same variable. If so, emit the expression using the in-place token.

Parameters

op	is the given PcodeOp

Returns: true if the expression was emitted (as in-place), or false if not emitted at all

◆ emitLabel()

void PrintC::emitLabel ( const FlowBlock * bl )

protected

Emit a formal label for a given control-flow block.

Check for an explicit label that has been registered with the basic block. Otherwise, construct a generic label based on the entry address of the block. Emit the label as a single token.

Parameters

bl	is the given block

◆ emitLabelStatement()

void PrintC::emitLabelStatement ( const FlowBlock * bl )

protected

Emit any required label statement for a given basic block.

If the basic block is the destination of a goto statement, emit a label for the block followed by the ':' terminator.

Parameters

bl	is the given control-flow block

◆ emitLocalVarDecls()

void PrintC::emitLocalVarDecls ( const Funcdata * fd )

protected

Emit variable declarations for a function.

A formal variable declaration is emitted for every symbol in the given function scope. I.e. all local variables are declared.

Parameters

fd	is the function being emitted

◆ emitPrototypeInputs()

void PrintC::emitPrototypeInputs ( const FuncProto * proto )

protected

Emit the input data-types of a function prototype.

This emits the individual type declarations of the input parameters to the function as a comma separated list.

Parameters

proto is the given prototype of the function

◆ emitPrototypeOutput()

void PrintC::emitPrototypeOutput	(	const FuncProto *	proto,
		const Funcdata *	fd
	)

protected

Emit the output data-type of a function prototype.

In C, when printing a function prototype, the function's output data-type is displayed first as a type declaration, where the function name acts as the declaration's identifier. This method emits the declaration in preparation for this.

Parameters

proto	is the function prototype object
fd	is the (optional) Funcdata object providing additional meta-data about the function

◆ emitScopeVarDecls()

bool PrintC::emitScopeVarDecls	(	const Scope *	scope,
		int4	cat
	)

protectedvirtual

Emit all the variable declarations for a given scope.

A subset of all variables can be declared by specifying a category, 0 for parameters, -1 for everything.

Parameters

scope	is the given Scope
cat	is the category of variable to declare

Implements PrintLanguage.

◆ emitStatement()

void PrintC::emitStatement ( const PcodeOp * inst )

protected

Emit a statement in the body of a function.

This emits an entire statement rooted at a given operation. All associated expressions on the right-hand and left-hand sides are recursively emitted. Depending on the current printing properties, the statement is usually terminated with ';' character.

Parameters

inst	is the given root PcodeOp of the statement

◆ emitStructDefinition()

void PrintC::emitStructDefinition ( const TypeStruct * ct )

protected

Emit the definition of a structure data-type.

Print all the components making up the data-type, using the struct keyword

Parameters

ct	is the structure data-type

◆ emitSwitchCase()

void PrintC::emitSwitchCase	(	int4	casenum,
		const BlockSwitch *	switchbl
	)

protected

Emit labels for a case block.

Given a switch block and an index indicating a particular case block, look up all the labels associated with that case and emit them using formal labels with the case keyword and a ':' terminator.

Parameters

casenum	is the given index of the case block
switchbl	is the root block of the switch

◆ emitSymbolScope()

void PrintC::emitSymbolScope ( const Symbol * symbol )

protected

Emit tokens resolving a symbol's scope.

Emit the elements of the given symbol's namespace path that distinguish it within the current scope.

Parameters

symbol is the given Symbol

◆ emitTypeDefinition()

void PrintC::emitTypeDefinition ( const Datatype * ct )

protectedvirtual

Emit the definition of the given data-type.

This is currently limited to a 'struct' or 'enum' definitions. The definition is emitted so that name associated with data-type object will be associated with the definition (in anything that parses it)

Parameters

ct	is the given data-type

◆ emitVarDecl()

void PrintC::emitVarDecl ( const Symbol * sym )

protectedvirtual

Emit a variable declaration.

This can be part of a full a statement, or just the declaration of a function parameter

Parameters

sym	is the Symbol to be declared

Implements PrintLanguage.

◆ emitVarDeclStatement()

void PrintC::emitVarDeclStatement ( const Symbol * sym )

protectedvirtual

Emit a variable declaration statement.

Parameters

sym	is the Symbol to be declared

Implements PrintLanguage.

◆ genericFunctionName()

string PrintC::genericFunctionName ( const Address & addr )

protectedvirtual

Create a generic function name base on the entry point address.

Parameters

addr	is the entry point address of the function

Returns: the generated name

◆ genericTypeName()

string PrintC::genericTypeName ( const Datatype * ct )

protectedvirtual

Generate a generic name for an unnamed data-type.

Parameters

ct	is the given data-type

Returns: the generated name

◆ getHiddenThisSlot()

int4 PrintC::getHiddenThisSlot	(	const PcodeOp *	op,
		FuncProto *	fc
	)

protected

Get position of "this" pointer needing to be hidden.

For the given CALL op, if a "this" pointer exists and needs to be hidden because of the print configuration, return the Varnode slot corresponding to the "this". Otherwise return -1.

Parameters

op	is the given CALL PcodeOp
fc	is the function prototype corresponding to the CALL

Returns: the "this" Varnode slot or -1

◆ opBoolNegate()

void PrintC::opBoolNegate ( const PcodeOp * op )

virtual

Print the BOOL_NEGATE but check for opportunities to flip the next operator instead

Parameters

op	is the BOOL_NEGATE PcodeOp

Implements PrintLanguage.

◆ opCbranch()

void PrintC::opCbranch ( const PcodeOp * op )

virtual

Print the branching condition:

If it is the first condition, print if
If there is no block structure, print goto

Parameters

op	is the CBRANCH PcodeOp

Implements PrintLanguage.

◆ opFunc()

void PrintC::opFunc ( const PcodeOp * op )

protected

Push a functional expression based on the given p-code op to the RPN stack.

This is used for expression that require functional syntax, where the name of the function is the name of the operator. The inputs to the p-code op form the roots of the comma separated list of parameters within the syntax.

Parameters

op	is the given PcodeOp

◆ opHiddenFunc()

void PrintC::opHiddenFunc ( const PcodeOp * op )

protected

Push the given p-code op as a hidden token.

The syntax represents the given op using a function with one input, where the function name is not printed. The input expression is simply printed without adornment inside the larger expression, with one minor difference. The hidden operator protects against confusing evaluation order between the operators inside and outside the hidden function. If both the inside and outside operators are the same associative token, the hidden token makes sure the inner expression is surrounded with parentheses.

Parameters

op	is the given PcodeOp

◆ opPtrsub()

void PrintC::opPtrsub ( const PcodeOp * op )

virtual

We need to distinguish between the following cases:

ptr-> struct spacebase or array
valueoption on/off (from below)
valueflex yes/no (can we turn valueoption above?)

Then the printing breaks up into the following table:

        val flex   |   val flex   |   val flex   |   val flex
        off  yes       off   no        on  yes        on   no
 
struct  &( ).name      &( )->name     ( ).name       ( )->name
spcbase n/a            &name          n/a            name
array   ( )            *( )           ( )[0]         *( )[0]

The '&' is dropped if the output type is an array

Parameters

op	is the PTRSUB PcodeOp

Implements PrintLanguage.

◆ opSegmentOp()

void PrintC::opSegmentOp ( const PcodeOp * op )

virtual

slot 0 is the spaceid constant
slot 1 is the segment, we could conceivably try to annotate the segment here
slot 2 is the pointer we are really interested in printing

Parameters

op	is the SEGMENTOP PcodeOp

Implements PrintLanguage.

◆ opTypeCast()

void PrintC::opTypeCast ( const PcodeOp * op )

protected

Push the given p-code op using type-cast syntax to the RPN stack.

The syntax represents the given op using a standard c-language cast. The data-type being cast to is obtained from the output variable of the op. The input expression is also recursively pushed.

Parameters

op	is the given PcodeOp

◆ printCharacterConstant()

bool PrintC::printCharacterConstant	(	ostream &	s,
		const Address &	addr,
		Datatype *	charType
	)		const

protected

Print a quoted (unicode) string at the given address.

Data for the string is obtained directly from the LoadImage. The bytes are checked for appropriate unicode encoding and the presence of a terminator. If all these checks pass, the string is emitted.

Parameters

s	is the output stream to print to
addr	is the address of the string data within the LoadImage
charType	is the underlying character data-type

Returns: true if a proper string was found and printed to the stream

◆ printUnicode()

void PrintC::printUnicode	(	ostream &	s,
		int4	onechar
	)		const

protectedvirtual

Print a single unicode character as a character constant for the high-level language.

For most languages, this prints the character surrounded by single quotes.

Parameters

s	is the output stream
onechar	is the unicode code point of the character to print

Implements PrintLanguage.

◆ push_float()

void PrintC::push_float	(	uintb	val,
		int4	sz,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push a constant with a floating-point data-type to the RPN stack.

The encoding is drawn from the underlying Translate object, and the print properties are checked for formatting overrides. In any case, a format is decided upon, and the constant is pushed as a single token.

Parameters

val	is the given encoded floating-point value
sz	is the size (in bytes) of the encoded value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

◆ push_integer()

void PrintC::push_integer	(	uintb	val,
		int4	sz,
		bool	sign,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push a constant with an integer data-type to the RPN stack.

Various checks are made to see if the integer should be printed as an equate symbol or if there is other overriding information about what format it should be printed in. In any case, a final determination of the format is made and the integer is pushed as a single token.

Parameters

val	is the given integer value
sz	is the size (in bytes) to associate with the integer
sign	is set to true if the integer should be treated as a signed value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

◆ pushAnnotation()

void PrintC::pushAnnotation	(	const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push an address which is not in the normal data-flow.

The given Varnode is treated as an address, which may or may not have a symbol name.

Parameters

vn	is the annotation Varnode
op	is the PcodeOp which takes the annotation as input

Implements PrintLanguage.

◆ pushBoolConstant()

void PrintC::pushBoolConstant	(	uintb	val,
		const TypeBase *	ct,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protected

Push a true or false token to the RPN stack.

A single Atom representing the boolean value is emitted

Parameters

val	is the boolean value (non-zero for true)
ct	is the data-type associated with the value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

◆ pushCharConstant()

void PrintC::pushCharConstant	(	uintb	val,
		const TypeChar *	ct,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protected

Push a single character constant to the RPN stack.

For C, a character constant is usually emitted as the character in single quotes. Handle unicode, wide characters, etc. Characters come in with the compiler's raw encoding.

Parameters

val	is the constant value
ct	is data-type attached to the value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

◆ pushConstant()

void PrintC::pushConstant	(	uintb	val,
		const Datatype *	ct,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push a constant onto the RPN stack.

The value is ultimately emitted based on its data-type and other associated mark-up

Parameters

val	is the value of the constant
ct	is the data-type of the constant
vn	is the Varnode holding the constant (optional)
op	is the PcodeOp using the constant (optional)

Implements PrintLanguage.

◆ pushEnumConstant()

void PrintC::pushEnumConstant	(	uintb	val,
		const TypeEnum *	ct,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protected

Push an enumerated value to the RPN stack.

Handle cases where the value is built out of multiple named elements of the enumeration or where the value cannot be expressed using named elements

Parameters

val	is the enumerated value being pushed
ct	is the enumerated data-type attached to the value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

◆ pushEquate()

bool PrintC::pushEquate	(	uintb	val,
		int4	sz,
		const EquateSymbol *	sym,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push a constant marked up by and EquateSymbol onto the RPN stack.

The equate may substitute a name or force a conversion for the constant

Parameters

val	is the value of the constant
sz	is the number of bytes to use for the encoding
sym	is the EquateSymbol that marks up the constant
vn	is the Varnode holding the constant (optional)
op	is the PcodeOp using the constant (optional)

Implements PrintLanguage.

◆ pushMismatchSymbol()

void PrintC::pushMismatchSymbol	(	const Symbol *	sym,
		int4	off,
		int4	sz,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push an identifier for a variable that mismatches with its Symbol.

This happens when a Varnode overlaps, but is not contained by a Symbol. This most commonly happens when the size of a Symbol is unknown

Parameters

sym	is the overlapped symbol
off	is the byte offset of the variable relative to the symbol
sz	is the size of the variable in bytes
vn	is the Varnode representing the variable
op	is a PcodeOp associated with the Varnode

Implements PrintLanguage.

◆ pushPartialSymbol()

void PrintC::pushPartialSymbol	(	const Symbol *	sym,
		int4	off,
		int4	sz,
		const Varnode *	vn,
		const PcodeOp *	op,
		Datatype *	outtype
	)

protectedvirtual

Push a variable that represents only part of a symbol onto the RPN stack.

Generally member syntax specifying a field within a structure gets emitted.

Parameters

sym	is the root Symbol
off	is the byte offset, within the Symbol, of the partial variable
sz	is the number of bytes in the partial variable
vn	is the Varnode holding the partial value
op	is a PcodeOp associate with the Varnode
outtype	is the data-type expected by expression using the partial variable

Implements PrintLanguage.

◆ pushPrototypeInputs()

void PrintC::pushPrototypeInputs ( const FuncProto * proto )

protected

Push input parameters.

Push the comma separated list of data-type declarations onto the RPN stack as part of emitting a given function prototype

Parameters

proto is the given function prototype

◆ pushPtrCharConstant()

bool PrintC::pushPtrCharConstant	(	uintb	val,
		const TypePointer *	ct,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Attempt to push a quoted string representing a given constant pointer onto the RPN stack.

Check if the constant pointer refers to character data that can be emitted as a quoted string. If so push the string, if not return false to indicate a token was not pushed

Parameters

val	is the value of the given constant pointer
ct	is the pointer data-type attached to the value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

Returns: true if a quoted string was pushed to the RPN stack

◆ pushPtrCodeConstant()

bool PrintC::pushPtrCodeConstant	(	uintb	val,
		const TypePointer *	ct,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protected

Attempt to push a function name representing a constant pointer onto the RPN stack.

Given the pointer value, try to look up the function at that address and push the function's name as a single Atom.

Parameters

val	is the given constant pointer value
ct	is the pointer data-type attached to the value
vn	is the Varnode holding the value
op	is the PcodeOp using the value

Returns: true if a name was pushed to the RPN stack, return false otherwise

◆ pushSymbol()

void PrintC::pushSymbol	(	const Symbol *	sym,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push a specific Symbol onto the RPN stack.

Parameters

sym	is the given Symbol
vn	is the Varnode holding the Symbol value
op	is a PcodeOp associated with the Varnode

Implements PrintLanguage.

◆ pushSymbolScope()

void PrintC::pushSymbolScope ( const Symbol * symbol )

protected

Push tokens resolving a symbol's scope.

Calculate what elements of a given symbol's namespace path are necessary to distinguish it within the current scope. Then print these elements.

Parameters

symbol is the given symbol

◆ pushType()

void PrintC::pushType ( const Datatype * ct )

protectedvirtual

Push a data-type name onto the RPN expression stack.

The data-type is generally emitted as if for a cast.

Parameters

ct	is the data-type to push

Implements PrintLanguage.

◆ pushTypeEnd()

void PrintC::pushTypeEnd ( const Datatype * ct )

protectedvirtual

Push the tail ends of a data-type declaration onto the RPN stack.

Because the front-ends were pushed on base-type -> final-modifier, the tail-ends are pushed on final-modifier -> base-type. The tail-ends amount to

array subscripts . [ # ] and
function parameters . ( paramlist )

Parameters

ct	is the data-type being pushed

Reimplemented in PrintJava.

◆ pushTypeStart()

void PrintC::pushTypeStart	(	const Datatype *	ct,
		bool	noident
	)

protectedvirtual

Push part of a data-type declaration onto the RPN stack, up to the identifier.

Store off array sizes for printing after the identifier

Parameters

ct	is the data-type to push
noident	is true if an identifier will not be pushed as part of the declaration

Reimplemented in PrintJava.

◆ pushUnnamedLocation()

void PrintC::pushUnnamedLocation	(	const Address &	addr,
		const Varnode *	vn,
		const PcodeOp *	op
	)

protectedvirtual

Push an address as a substitute for a Symbol onto the RPN stack.

If there is no Symbol or other name source for an explicit variable, this method is used to print something to represent the variable based on its storage address.

Parameters

addr	is the storage address
vn	is the Varnode representing the variable (if present)
op	is a PcodeOp associated with the variable

Implements PrintLanguage.

◆ setCommentStyle()

void PrintC::setCommentStyle ( const string & nm )

virtual

Set the way comments are displayed in decompiler output.

This method can either be provided a formal name or a sample of the initial delimiter, then it will choose from among the schemes it knows

Parameters

nm	is the configuration description

Implements PrintLanguage.

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

printc.hh
printc.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ PrintC()

Member Function Documentation

◆ buildTypeStack()

◆ checkArrayDeref()

◆ checkPrintNegation()

◆ docFunction()

◆ docSingleGlobal()

◆ docTypeDefinitions()

◆ doEmitWideCharPrefix()

◆ emitAnyLabelStatement()

◆ emitCommentBlockTree()

◆ emitCommentFuncHeader()

◆ emitCommentGroup()

◆ emitEnumDefinition()

◆ emitExpression()

◆ emitForLoop()

◆ emitFunctionDeclaration()

◆ emitGlobalVarDeclsRecursive()

◆ emitGotoStatement()

◆ emitInplaceOp()

◆ emitLabel()

◆ emitLabelStatement()

◆ emitLocalVarDecls()

◆ emitPrototypeInputs()

◆ emitPrototypeOutput()

◆ emitScopeVarDecls()

◆ emitStatement()

◆ emitStructDefinition()

◆ emitSwitchCase()

◆ emitSymbolScope()

◆ emitTypeDefinition()

◆ emitVarDecl()

◆ emitVarDeclStatement()

◆ genericFunctionName()

◆ genericTypeName()

◆ getHiddenThisSlot()

◆ opBoolNegate()

◆ opCbranch()

◆ opFunc()

◆ opHiddenFunc()

◆ opPtrsub()

◆ opSegmentOp()

◆ opTypeCast()

◆ printCharacterConstant()

◆ printUnicode()

◆ push_float()

◆ push_integer()

◆ pushAnnotation()

◆ pushBoolConstant()

◆ pushCharConstant()

◆ pushConstant()

◆ pushEnumConstant()

◆ pushEquate()

◆ pushMismatchSymbol()

◆ pushPartialSymbol()

◆ pushPrototypeInputs()

◆ pushPtrCharConstant()

◆ pushPtrCodeConstant()

◆ pushSymbol()

◆ pushSymbolScope()

◆ pushType()

◆ pushTypeEnd()

◆ pushTypeStart()

◆ pushUnnamedLocation()

◆ setCommentStyle()