# Interface: com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric

Base interface for IR expressions \(IRE\) used by JEB's native decompilation engine, `gendec`. They can be statements or non\-statements. 

 Refer to sub\-interfaces. Refer to [IEStatement](IEStatement) for statements.

## Method: accessesMemory
- return type: `boolean`

Description: Determine whether this IRE accesses memory.
return: true if the expression reads or writes to memory

## Method: addFlags
- parameter: `addedFlags`, type: `int`
- return type: `boolean`

Description: Add flags to this IRE's flags list.
parameter: addedFlags: flags to add
return: true if the flags were effectively changed \(new additions were made\); false otherwise

## Method: asCompose
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECompose`

Description: 
return: this IRE as an [IECompose](IECompose)

## Method: asCond
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: 
return: this IRE as an [IECond](IECond)

## Method: asGroup
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroup`

Description: 
return: this IRE as an [IEGroup](IEGroup)

## Method: asGroupElt
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGroupElt`

Description: 
return: this IRE as an [IEGroupElt](IEGroupElt)

## Method: asImm
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: 
return: this IRE as an [IEImm](IEImm)

## Method: asMem
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEMem`

Description: 
return: this IRE as an [IEMem](IEMem)

## Method: asOperation
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEOperation`

Description: 
return: this IRE as an [IEOperation](IEOperation)

## Method: asRange
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IERange`

Description: 
return: this IRE as an [IERange](IERange)

## Method: asSlice
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IESlice`

Description: 
return: this IRE as an [IESlice](IESlice)

## Method: asStatement
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEStatement`

Description: 
return: this IRE as an [IEStatement](IEStatement)

## Method: asVar
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`

Description: 
return: this IRE as an [IEVar](IEVar)

## Method: bit
- parameter: `pos`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve a one bit value at the pos position
parameter: pos: bit position to be retrieved
return: [IEGeneric](IEGeneric) of size 1 with bit at position \`pos\`

## Method: collectSubExpressions
- parameter: `sink`, type: `java.util.Collection<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`

Description: Perform a shallow collection of the sub\-expressions of this expression. All collected expressions are directly rooted in this IRE \(i.e. their parent is this IR expression\). 

 This method appends to the provided sink \(existing elements are not cleared\). The current element \(this\) is not appended; only the sub\-expressions are considered.
parameter: sink: output collection

## Method: copyProperties
- parameter: `srcExp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Copy the base properties from the provided IR source expression to this expression.
parameter: srcExp: source expression

## Method: countSuccessiveBits
- parameter: `ones`, type: `boolean`
- parameter: `fromMsb`, type: `boolean`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IECond`

Description: Count successive bits in an integer, starting from MSB or LSB.
parameter: ones: true if '1's should be counted, false for '0's
parameter: fromMsb: true if count should start from MSB, false from LSB
parameter: bitsize: 

## Method: duplicate
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Clone \(deep copy\) the expression.
return: the duplicate expression

## Method: equalsEx
- parameter: `obj`, type: `java.lang.Object`
- parameter: `includeType`, type: `boolean`
- return type: `boolean`

Description: Same as [Object#equals(Object)](Object#equals(Object)) with the possibility to exclude the type from the comparison.
parameter: obj: object to compare
parameter: includeType: true to include the type in the equality test
return: true if equal

## Method: evaluate
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEImm`

Description: Evaluate the IRE.
parameter: state: IR state \(input and output\)
return: the evaluation if the IRE; null if the state is configured to soft\-fail on errors
throws: thrown if the state is configured to hard\-fail on errors             \(default\)

## Method: evaluateAddress
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `long`

Description: Evaluate the IRE as a 64\-bit address.
parameter: state: IR state
return: the evaluated address
throws: thrown if the state is configured to hard\-fail on errors             \(default\)

## Method: evaluateUnsignedLong
- parameter: `state`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EState`
- return type: `long`

Description: Evaluate the IRE as an unsigned long value. This convenience method will throw if the underlying immediate bit size exceeds 63 bits \(unsigned value\).
parameter: state: IR state
return: the evaluation if the IRE, as an **unsigned** value, if meaningful; the state is         also updated
throws: thrown if the state is configured to hard\-fail on errors             \(default\)

## Method: examine
- parameter: `tester`, type: `java.util.function.Predicate<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`
- return type: `boolean`

Description: Visit the constituents of this expression, and check if one of them is passing the provided test.
parameter: tester: a predicate object examining the [IEGeneric](IEGeneric) elements of this expression
return: true if a constituent passed the test; false if none passed the test

## Method: extend
- parameter: `newBitsize`, type: `int`
- parameter: `signedExtension`, type: `boolean`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: 
parameter: newBitsize: 
parameter: signedExtension: 
return: 

## Method: find
- parameter: `elt`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `start`, type: `int`
- parameter: `comparisonMethod`, type: `int`
- parameter: `thisParent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.util.base.Couple<com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric,com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric>`

Description: Find the parent of the the provided child element.
parameter: elt: an IR element; if the element is `this`, the method will return null
parameter: start: count of instances of `elt` that should be skipped before returning the            parent element; this is useful is the element provided may not be unique within            the tree \(e.g. IEVar\)
parameter: comparisonMethod: 0= identity, 1= equality, 2= type\-less equality
parameter: thisParent: optional parent of *this* IR element
return: if found, the pair \(parent, element\) parent; else, null

## Method: findByType
- parameter: `clazz`, type: `java.lang.Class<T>`
- return type: `T`

Description: Find the first child element by type.
parameter: T: 
parameter: clazz: type of the element to be found; careful, if the type is the one of            `this`, then this object will be returned
return: the element or null

## Method: findByType
- parameter: `clazz`, type: `java.lang.Class<T>`
- parameter: `start`, type: `int`
- return type: `T`

Description: Find a child element by type.
parameter: T: 
parameter: clazz: type of the element to be found; careful, if the type is the one of            `this`, then this object will be returned
parameter: start: count of matched elements that should be skipped before returning the element
return: the element or null

## Method: findParent
- parameter: `elt`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Find the parent of the first instance of the provided child element. The comparison is done by identity.
parameter: elt: an IR element; if the element is `this`, the method will return null
return: the parent or null

## Method: findParent
- parameter: `elt`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `start`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Find the parent of the the provided child element. The comparison is done by identity.
parameter: elt: an IR element; if the element is `this`, the method will return null
parameter: start: count of instances of `elt` that should be skipped before returning the            parent element; this is useful is the element provided may not be unique within            the tree \(e.g. IEVar\)
return: the parent or null

## Method: generateC
- parameter: `ectx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.IERoutineContext`
- parameter: `cctx`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ast.ICMethod`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ast.ICElement`

Description: Generate the C abstract syntax tree portion for this expression.
parameter: ectx: IR routine context
parameter: cctx: C routine local context
return: the C AST element \(may contain sub\-elements\)

## Method: getBitsize
- return type: `int`

Description: Get the size, in bits, of the IR expression. It is illegal to query The bitsize of some expressions.
return: the size in bits

## Method: getDefinedOrUsedAsDestination
- parameter: `defuse`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EDefUseInfo`

Description: For [non\-statements](IEStatement) only. Assuming 'this' is a destination value, extract the variable or variable bits that are used and defined by it.
parameter: defuse: sink \- both the \`def\` and \`use\` field may be modified

## Method: getExplicitlyUsed
- parameter: `defuse`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EDefUseInfo`

Description: Get a list of variable or variable bits 'explicitly used' \(read\) by the instruction. This method is inherently deep.
parameter: defuse: sink \- only the \`use\` field is modified

## Method: getExplicitlyUsed
- return type: `com.pnfsoftware.jeb.core.units.code.IdRanges`

Description: Convenience method around [#getExplicitlyUsed(EDefUseInfo)](#getExplicitlyUsed(EDefUseInfo)).
return: an used id ranges object

## Method: getFlags
- return type: `int`

Description: Get the expression flags. 

 The flags are defined in the sub\-interfaces. They do not overlap.
return: expression flags

## Method: getPriority
- return type: `int`

Description: Get the base priority level of the expression. Higher number correlates to lower priority; 0 means "no priority". \(Therefore, the highest priority level is 1.\)
return: expression priority

## Method: getSafeType
- parameter: `etypeman`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: Generate a safe wildcard type for the expression, if it doesn't already have one. If generated, the type is NOT assigned to the IR expression.
parameter: etypeman: 
return: the wildcard type, never null

## Method: getType
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: Get the currently set intermediate\-type.
return: 

## Method: getUsed
- parameter: `defuse`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EDefUseInfo`

Description: Retrieve the variables or variable bits 'used' \(read\) by the instruction. This method is inherently deep. 

 Note that some IRE may implicitly use variables, such as some [ECall](IECall), [PC\-assigns](IEAssign), [UntranslatedInstruction](IEUntranslatedInstruction). This method returns those implicit uses.
parameter: defuse: sink \- only the \`use\` field is modified

## Method: getUsed
- return type: `com.pnfsoftware.jeb.core.units.code.IdRanges`

Description: Convenience method to invoke [#getUsed(EDefUseInfo)](#getUsed(EDefUseInfo)).
return: an used id ranges object

## Method: half
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve the lower half\-part of this IRE. If the IRE does not have an even count of bits N, then the lowest CEIL\(N/2\) bits are returned.
return: 

## Method: hasFlags
- parameter: `checkedFlags`, type: `int`
- return type: `boolean`

Description: Check if this IRE contains the provided flags.
parameter: checkedFlags: flags to check
return: true if all the checked flags are present

## Method: isCompose
- return type: `boolean`

Description: 
return: true if this IRE is an [IECompose](IECompose)

## Method: isCond
- return type: `boolean`

Description: 
return: true if this IRE is an [IECond](IECond)

## Method: isGroup
- return type: `boolean`

Description: 
return: true if this IRE is an [IEGroup](IEGroup)

## Method: isGroupElt
- return type: `boolean`

Description: 
return: true if this IRE is an [IEGroupElt](IEGroupElt)

## Method: isImm
- return type: `boolean`

Description: 
return: true if this IRE is an [IEImm](IEImm)

## Method: isMem
- return type: `boolean`

Description: 
return: true if this IRE is an [IEMem](IEMem)

## Method: isOperation
- return type: `boolean`

Description: 
return: true if this IRE is an [IEOperation](IEOperation)

## Method: isOperation
- parameter: `expectedOp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType`
- return type: `boolean`

Description: 
parameter: expectedOp: an operator
return: true if this IRE is an [IEOperation](IEOperation) using the provided operator

## Method: isOperation
- parameter: `candidateOps`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.OperationType[]`
- return type: `boolean`

Description: 
parameter: candidateOps: a list of operators
return: true if this IRE is an [IEOperation](IEOperation) using one of the candidate operators

## Method: isOperation
- parameter: `name`, type: `java.lang.String`
- return type: `boolean`

Description: 
parameter: name: operation name
return: true if this IRE is an [IEOperation](IEOperation) of the provided name

## Method: isRange
- return type: `boolean`

Description: 
return: true if this IRE is an [IERange](IERange)

## Method: isSlice
- return type: `boolean`

Description: 
return: true if this IRE is a [IESlice](IESlice)

## Method: isSlice
- parameter: `wantedStart`, type: `int`
- parameter: `wantedEnd`, type: `int`
- return type: `boolean`

Description: 
parameter: wantedStart: 
parameter: wantedEnd: 
return: true if this IRE is a [IESlice](IESlice) of the provided range

## Method: isStatement
- return type: `boolean`

Description: 
return: true if this IRE is an [IEStatement](IEStatement)

## Method: isVar
- return type: `boolean`

Description: 
return: true if this IRE is an [IEVar](IEVar)

## Method: isVar
- parameter: `wantedVarId`, type: `int`
- return type: `boolean`

Description: 
parameter: wantedVarId: variable id
return: true if this IRE is an [IEVar](IEVar) having the provided id

## Method: leftShift
- parameter: `shift`, type: `int`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: left shift of an expression, with an optional [#slice(int, int)](#slice(int, int))
parameter: shift: left shift value
parameter: bitsize: bitsize of the final [IEGeneric](IEGeneric). Note that            `bitSize - shift < currentBitSize` must be respected.
return: [IEGeneric](IEGeneric) left shifted by the shift value

## Method: leftShift
- parameter: `shift`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: left shift of an expression
parameter: shift: left shift value
return: [IEGeneric](IEGeneric) left shifted by the shift value

## Method: lsb
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Return the least significant bit \(lsb\) of an expression. No duplicate is done, it is up to caller to duplicate current [IEGeneric](IEGeneric) if needed.
return: the least significant bit

## Method: msb
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Return the most significant bit \(msb\) of an expression. No duplicate is done, it is up to caller to duplicate current [IEGeneric](IEGeneric) if needed.
return: the most significant bit

## Method: part
- parameter: `cnt`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Equivalent to `slice(0, cnt)`
parameter: cnt: wanted bit count
return: 

## Method: removeFlags
- parameter: `removedFlags`, type: `int`

Description: Remove flags from this IRE's flags list.
parameter: removedFlags: flags to remove

## Method: replaceSubExpression
- parameter: `oldExp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `newExp`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Shallow replacement, by reference. Only the first occurrence is replaced. 

 Be careful when replacing immediates or variables. Unexpected behaviors may happen if the expression contains multiple instances of the same imm or var.
parameter: oldExp: the expression to be replaced
parameter: newExp: the new expression, whose type must be consistent with the expression replaced
return: success indicator
throws: 

## Method: replaceVar
- parameter: `var`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVar`
- parameter: `repl`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `int`

Description: Deep replace. All matching [variables](IEVar) are replaced. The implementation is responsible for duplicating the IR expressions, to ensure that the resulting statement or group of statement does not contain duplicate references to mutable objects.
parameter: var: variable to replace
parameter: repl: replacement expression
return: the number of instances replaced
throws: if replacement produces an invalid expression

## Method: rightShift
- parameter: `shift`, type: `int`
- parameter: `bitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: right shift of an expression, with an optional [#slice(int, int)](#slice(int, int))
parameter: shift: right shift value
parameter: bitsize: bitsize of the final [IEGeneric](IEGeneric). Note that            `bitSize < currentBitSize` must be respected.
return: [IEGeneric](IEGeneric) right shifted by the shift value

## Method: rightShift
- parameter: `shift`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: right shift of an expression
parameter: shift: right shift value
return: [IEGeneric](IEGeneric) right shifted by the shift value

## Method: safelyType
- parameter: `etypeman`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardTypeManager`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`

Description: Generate and assign a safe wildcard type to the expression if it doesn't already have one.
parameter: etypeman: 
return: the wildcard type, never null

## Method: setFlags
- parameter: `newFlags`, type: `int`

Description: Set the expression's flags.
parameter: newFlags: new expression flags

## Method: setType
- parameter: `type`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- return type: `boolean`

Description: Set a pre\-propagation intermediate\-type. Does not propagate/update type in the super\- or sub\-expression.
parameter: type: the new type; may be null
return: true if a type was set correctly, or unchanged; false if the type was not set, eg         because of a conflict with the current type

## Method: setType
- parameter: `newType`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `ti`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ETypeInfo`
- return type: `boolean`

Description: Set a pre\-propagation intermediate\-type. Does not propagate/update type in the super\- or sub\-expression. Not forced.
parameter: newType: the new type; may be null
parameter: ti: optional type\-setting information structure, contains information about how many            types were set, the list of type conflicts, etc.
return: true if a type was set correctly, or unchanged; false if the type was not set, eg         because of a conflict with the current type

## Method: setType
- parameter: `newType`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IWildcardType`
- parameter: `ti`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ETypeInfo`
- parameter: `forceUpdate`, type: `boolean`
- return type: `boolean`

Description: Set a pre\-propagation intermediate\-type. Does not propagate/update type in the super\- or sub\-expression.
parameter: newType: the new type; may be null
parameter: ti: optional type\-setting information structure, contains information about how many            types were set, the list of type conflicts, etc.
parameter: forceUpdate: true to force a type update even if the new type is less speciialized \(has            a lesser score\) than the currently existing type
return: true if a type was set correctly, or unchanged; false if the type was not set, eg         because of a conflict with the current type

## Method: signExtend
- parameter: `newBitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Sign extend the current [IEGeneric](IEGeneric). This method will create a valid [IEGeneric](IEGeneric) \(meaning [IEGeneric](IEGeneric) will not have duplicates id \- in particular, in the form C\(x, x.msb\(\)?ones\(\):zeros\(\)\) where x will be present in base value and msb predicate\)
parameter: newBitsize: must be superior to [#getBitsize()](#getBitsize())

## Method: slice
- parameter: `begin`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Equivalent to `slice(begin, [bitsize](#getBitsize()))`.
parameter: begin: start position
return: the sliced [IEGeneric](IEGeneric)

## Method: slice
- parameter: `begin`, type: `int`
- parameter: `end`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Slice of an [IEGeneric](IEGeneric).
parameter: begin: start \(inclusive\) position
parameter: end: end \(exclusive\) position. Note that `end <= bitsize && begin < end` must be            respected
return: the sliced [IEGeneric](IEGeneric)

## Method: slice
- parameter: `r`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IERange`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Slice of an [IEGeneric](IEGeneric).
parameter: r: 
return: 

## Method: topHalf
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Retrieve the top half\-part of this IRE. If the IRE does not have an even count of bits N, then the highest FLOOR\(N/2\) bits are returned.
return: 

## Method: updateTypes
- parameter: `ti`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.ETypeInfo`

Description: Deep update the types of the constituents of this IRE, update the IRE type as well the direct constituents if needed. Not forced. When this method is called, it is the responsibility to verify that the constituent IREs are typeable, and if not, to make them typeable \(eg, EImm updates, EVar copies, etc.\).
parameter: ti: optional type information object; provides access to a [wildcard type manager](IWildcardTypeManager), and used to record typing conflicts

## Method: verify

Description: Verify the legality of this IR expression.
throws: if the IRE is deemed invalid or illegal

## Method: visitDepthPost
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- return type: `boolean`

Description: Depth\-first search, post\-order visit of an expression tree or sub\-tree. The node being visited may be replaced without notifying the visitor. 

 Pre\-order visits offer more options than post order visits: the visitor may decide to skip children; to skip the destination of assignments. However, replacement of nodes requires additional code to register the new node. Conversely, post\-order visits do not offer any specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
return: 

## Method: visitDepthPost
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Depth\-first search, post\-order visit of an expression tree or sub\-tree. The node being visited may be replaced without notifying the visitor. 

 Pre\-order visits offer more options than post order visits: the visitor may decide to skip children; to skip the destination of assignments. However, replacement of nodes requires additional code to register the new node. Conversely, post\-order visits do not offer any specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
parameter: parent: 
return: 

## Method: visitDepthPost
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `results`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EVisitResults`
- return type: `boolean`

Description: Depth\-first search, post\-order visit of an expression tree or sub\-tree. The node being visited may be replaced without notifying the visitor. 

 Pre\-order visits offer more options than post order visits: the visitor may decide to skip children; to skip the destination of assignments. However, replacement of nodes requires additional code to register the new node. Conversely, post\-order visits do not offer any specific option, but provide the simplest way to replace nodes.
parameter: visitor: the visitor object
parameter: parent: 
parameter: results: 
return: true if the visit was successful

## Method: visitDepthPre
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- return type: `boolean`

Description: Depth\-first search, pre\-order visit of an expression tree or sub\-tree. The node being visited may be replaced, but the client code is responsible for `setReplacedNode` notifying the visitor. 

 Pre\-order visits offer more options than post order visits: the visitor may decide to skip children; to skip the destination of assignments. However, replacement of nodes requires additional code to register the new node. Conversely, post\-order visits do not offer any specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
return: 

## Method: visitDepthPre
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- return type: `boolean`

Description: Depth\-first search, pre\-order visit of an expression tree or sub\-tree. The node being visited may be replaced, but the client code is responsible for `setReplacedNode` notifying the visitor. 

 Pre\-order visits offer more options than post order visits: the visitor may decide to skip children; to skip the destination of assignments. However, replacement of nodes requires additional code to register the new node. Conversely, post\-order visits do not offer any specific option, but provide the simplest way to replace nodes.
parameter: visitor: 
parameter: parent: 
return: 

## Method: visitDepthPre
- parameter: `visitor`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEVisitor`
- parameter: `parent`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`
- parameter: `results`, type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.EVisitResults`
- return type: `boolean`

Description: Depth\-first search, pre\-order visit of an expression tree or sub\-tree. The node being visited may be replaced, but the client code is responsible for `setReplacedNode` notifying the visitor. 

 Pre\-order visits offer more options than post order visits: the visitor may decide to skip children; to skip the destination of assignments. However, replacement of nodes requires additional code to register the new node. Conversely, post\-order visits do not offer any specific option, but provide the simplest way to replace nodes.
parameter: visitor: the visitor object
parameter: parent: 
parameter: results: 
return: true if the visit was successful

## Method: zeroExtend
- parameter: `newBitsize`, type: `int`
- return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.ir.IEGeneric`

Description: Zero extend the current [IEGeneric](IEGeneric)
parameter: newBitsize: must be superior to [#getBitsize()](#getBitsize())