# Interface: com.pnfsoftware.jeb.core.units.INativeCodeUnit Specialized code unit that manages a native code processor and uses a virtual memory. Code units own and work closely with the following objects: - [INativeCodeAnalyzer](INativeCodeAnalyzer) \- code analyzer - - [IMemoryModel](IMemoryModel) \- code model for [INativeItem](INativeItem) and derived objects - - [ITypeManager](ITypeManager) \- type and package manager - Note: if a debugger is attached, a temporary physical image base can be set. ## Static Field: externalSymbolsPrefix Type: `java.lang.String` Constant value: `extern` Description: [SymbolType#EXTERN_FUNCTION](SymbolType#EXTERN_FUNCTION) routine prefix ## Static Field: importPtrPrefix Type: `java.lang.String` Constant value: `ptr_` Description: [SymbolType#PTRFUNCTION](SymbolType#PTRFUNCTION) routine prefix ## Static Field: targetPrefix Type: `java.lang.String` Constant value: `*` Description: Target routine prefix with named trampoline: '\*' ## Static Field: trampolinePrefix Type: `java.lang.String` Constant value: `→` Description: Trampoline routines prefix: unicode RIGHTWARDS ARROW '→' ## Method: getAddressFromCodeCoordinates - parameter: `cc`, type: `com.pnfsoftware.jeb.core.output.code.coordinates.ICodeCoordinates` - parameter: `precision`, type: `com.pnfsoftware.jeb.core.output.AddressConversionPrecision` - return type: `java.lang.String` Description: Convert code coordinates to an address string. parameter: cc: code coordinates parameter: precision: conversion precision return: an address string, or null if none ## Method: getAnalyzerExtension - return type: `com.pnfsoftware.jeb.core.units.code.asm.analyzer.INativeCodeAnalyzerExtension` Description: Get the principal code analyzer extension attached to this unit. return: the analyzer extension ## Method: getCanonicalMemoryAddress - parameter: `address`, type: `java.lang.String` - return type: `long` Description: Convert a flexible native code unit address to a canonical memory address. Unit addresses can be code labels, pseudo labels, string representations of physical addresses, etc. parameter: address: an address return: the memory address, or \-1 \(0xFFFFFFFF\_FFFFFFFFL\) on failure ## Method: getCanonicalMemoryAddress - parameter: `address`, type: `java.lang.String` - parameter: `precision`, type: `com.pnfsoftware.jeb.core.output.AddressConversionPrecision` - return type: `long` Description: Convert a flexible native code unit address to a canonical memory address. Unit addresses can be code labels, pseudo labels, string representations of physical addresses, etc. parameter: address: an address parameter: precision: use COARSE to bypass early name resolution, and attempt a simple number conversion first \(e.g., with coarse address "aabb" will be resolved to 0xAABB before looking if an item is named "aabb"\); with FINE \(or DEFAULT\), item name resolution is attempted first; therefore, for quick and unreliable conversions, use COARSE; else, use the DEFAULT setting return: the memory address, or \-1 \(0xFFFFFFFF\_FFFFFFFFL\) on failure ## Method: getClass - parameter: `fqname`, type: `java.lang.String` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeClassItem` ## Method: getClassByIndex - parameter: `index`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeClassItem` Description: Get a class by its internal index. Class indices are monotonously increasing, and gaps may exist as classes get destroyed and created. The caller should not assume that `getClassByIndex(i)==getClasses().get(i)`. parameter: index: an opaque class index, eg one present in [ICodeCoordinates](ICodeCoordinates) return: a class object or null ## Method: getClassManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.type.IClassManager` Description: Get the class manager used by this unit. return: the class manager ## Method: getClasses - return type: `java.util.List` ## Method: getCodeAnalyzer - return type: `com.pnfsoftware.jeb.core.units.code.asm.analyzer.INativeCodeAnalyzer` Description: Get the code analyzer. Life\-cycle information: this method will return null until the unit is [processed](#process()). return: the code analyzer, or null if unavailable ## Method: getCodeAnalyzerExtensionsManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.analyzer.INativeCodeAnalyzerExtensionsManager` Description: Retrieve the currently\-set analyzer extensions manager. Life\-cycle information: this method will return null until the unit is [processed](#process()). Note: third\-party code should not use this for now. return: the analyzer extensions manager, or null if unavailable ## Method: getCodeFormatter - return type: `com.pnfsoftware.jeb.core.units.code.asm.render.GenericCodeFormatter` Description: Get the helper object used to format instructions into a sink. Do not confuse the code formatter with the unit's [formatter](#getFormatter()). return: the code formatter ## Method: getCodeModel - return type: `com.pnfsoftware.jeb.core.units.code.asm.analyzer.INativeCodeModel` Description: Get the code model. return: the code model ## Method: getCodeObjectContainer - return type: `com.pnfsoftware.jeb.core.units.codeobject.ICodeObjectUnit` Description: Provide the parent code object container, if there is one. Typically, that would be an ELF, PE\-COFF, or Mach\-O unit accessible through the generic interface [ICodeObjectUnit](ICodeObjectUnit) or any of the derived specialized interfaces. return: a unit or null ## Method: getCommentManager - return type: `com.pnfsoftware.jeb.core.units.code.NativeCommentManager` ## Method: getDataTypeAt - parameter: `address`, type: `long` - return type: `com.pnfsoftware.jeb.core.units.code.asm.type.INativeType` Description: Get the native type of the data item located at the provided address. parameter: address: item address return: the native type, or null if none ## Method: getDecompiler - return type: `com.pnfsoftware.jeb.core.units.code.asm.decompiler.INativeDecompilerUnit` Description: Retrieve or create a decompiler for this unit. If a corresponding `gendec` plugin is not available with your JEB license, null is returned. return: the native decompiler unit, or null if unavailable ## Method: getDisassemblyDocument - return type: `com.pnfsoftware.jeb.core.units.code.asm.render.INativeDisassemblyDocument` ## Method: getEndianness - return type: `com.pnfsoftware.jeb.util.io.Endianness` Description: Retrieve the endianness. This method is for convenience only; byte ordering can always be retrieved through the [IProcessor](IProcessor). return: byte ordering for the target ## Method: getEntryPointAddress - return type: `long` Description: Get the address of the entry\-point of this unit, if any. return: entry\-point address, or \-1L if none ## Method: getField - parameter: `fqname`, type: `java.lang.String` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeFieldItem` ## Method: getFieldByIndex - parameter: `index`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeFieldItem` Description: Get a field by its internal index. Field indices are monotonously increasing, and gaps may exist as fields get destroyed and created. The caller should not assume that `getFieldByIndex(i)==getFields().get(i)`. parameter: index: an opaque field index, eg one present in [ICodeCoordinates](ICodeCoordinates) return: a field object or null ## Method: getFieldManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.IFieldManager` Description: Get the field manager used by this unit. return: the field manager ## Method: getFields - return type: `java.util.List` ## Method: getHighLevelEntryPointAddress - return type: `long` Description: Get the address of the high\-level entry\-point of this unit, if any. The high\-level entry\-point corresponds to a `main()` \(or similar\) routine. It is the routine executed after the compiler\-generated initialization code is executed. Note that it might be set as a result of the initial analysis. return: real entry point address, \-1L if none ## Method: getInlineComment - parameter: `address`, type: `long` - return type: `java.lang.String` Description: Convenience method used to retrieve the inline comment at the provided virtual address. parameter: address: VA return: a comment or null ## Method: getInternalMethod - parameter: `memoryAddress`, type: `long` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` Description: Retrieve an internal method by its entry\-point address. An internal method has an associated [data](INativeMethodDataItem) item associated to it. If multiple methods share the provided entry\-point address, the first one is returned. parameter: memoryAddress: entry\-point address return: a routine item or null ## Method: getInternalMethod - parameter: `memoryAddress`, type: `long` - parameter: `addressIsEntryPoint`, type: `boolean` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` Description: Retrieve an internal method by address \(any address within the method\). An internal method has an associated [data](INativeMethodDataItem) item associated to it. If multiple methods share the provided address, the one with the lowest entry\-point address is returned. parameter: memoryAddress: memory address parameter: addressIsEntryPoint: true if the provided address is the method entry\-point; false if the address is just part of the routine. In the latter case, if the address belongs to several routines, any one is returned return: a routine item or null ## Method: getInternalMethods - return type: `java.util.List` Description: Retrieve all internal methods. An internal method has an associated [data](INativeMethodDataItem) item associated to it. return: a list of internal methods ## Method: getInternalMethods - parameter: `memoryAddress`, type: `long` - return type: `java.util.List` Description: Retrieve the internal methods spanning over the provided address parameter: memoryAddress: memory address return: a list of internal methods spanning over the address ## Method: getInternalMethodsLeafFirst - return type: `java.util.List` Description: Retrieve all internal methods, ordered from the leaves to the roots. An internal method has an associated [data](INativeMethodDataItem) item associated to it. return: a list of internal methods ## Method: getInternalMethodsSizeFirst - return type: `java.util.List` Description: Retrieve all internal methods, ordered from their ascending byte size. An internal method has an associated [data](INativeMethodDataItem) item associated to it. return: a list of internal methods ## Method: getItemObject - parameter: `id`, type: `long` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeItem` ## Method: getLock - return type: `com.pnfsoftware.jeb.core.units.IUnitLock` Description: Retrieve the model lock, used to request a full\-access model lock or a partial, read\-only, transactional lock. All plugin code accessing the native units and units relying on native units should use those locks to perform operations safely in a concurrent environment. return: the native model lock ## Method: getMemory - return type: `com.pnfsoftware.jeb.core.units.code.asm.memory.IVirtualMemory` Description: Retrieve the virtual memory managed used by this unit. return: the virtual memory ## Method: getMethod - parameter: `fqname`, type: `java.lang.String` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` ## Method: getMethodByIndex - parameter: `index`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` Description: Get a method by its internal index. Method indices are monotonously increasing, and gaps may exist as methods get destroyed and created. The caller should not assume that `getMethodByIndex(i)==getMethods().get(i)`. parameter: index: an opaque method index, eg one present in [ICodeCoordinates](ICodeCoordinates) return: a method object or null ## Method: getMethodManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.IMethodManager` Description: Get the method manager used by this unit. return: the method manager ## Method: getMethods - return type: `java.util.List` ## Method: getNativeItemAt - parameter: `address`, type: `long` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeContinuousItem` Description: Get the item located at the exact address. parameter: address: item start address return: the item, or null if none ## Method: getNativeItemOver - parameter: `address`, type: `long` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeContinuousItem` Description: Get the item spanning over the provided address. parameter: address: an address return: the item, or null if none ## Method: getNativeItemsOver - parameter: `address`, type: `long` - parameter: `size`, type: `int` - return type: `java.util.SortedMap` Description: Retrieve a read\-only map of the native items located within the provided memory range. parameter: address: start address parameter: size: range size in bytes return: a map of item addresses to native items ## Method: getPackageManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.type.IPackageManager` Description: Get the package/namespace manager used by this unit. return: the package manager ## Method: getPackages - return type: `java.util.List` ## Method: getPhysicalImageDelta - return type: `long` Description: Retrieve the difference between Physical Image base as set by [#setPhysicalImageBase(long)](#setPhysicalImageBase(long)) and Virtual Image Base as retrieved by [#getVirtualImageBase()](#getVirtualImageBase()). **This value should only be used for rendering.** return: the physical image delta ## Method: getProcessor - return type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor` Description: Retrieve the machine code parser \(pseudo\-processor\) managed by this unit. return: the processor ## Method: getProcessorName - return type: `java.lang.String` Description: Convenience method used to retrieve the processor's name. The processor value specifies, among other things, the underlying instruction set used by the instructions of this code unit. return: a lower\-case string, never null \(if the processor is unknown or not set, 'unknown' is retrieved\) ## Method: getSignatureManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.sig.NativeSignatureDBManager` Description: Get the global signature manager used by this unit. return: the signature manager ## Method: getStringByIndex - parameter: `index`, type: `int` - return type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeStringItem` Description: Retrieve a string by index. Careful, this is not the same as [getStrings\(\).get\(index\)](#getStrings()). parameter: index: internal string index return: the string item, or null if none ## Method: getStrings - return type: `java.util.List` ## Method: getSymbolicStringAddress - parameter: `address`, type: `long` - return type: `java.lang.String` Description: Retrieve the simplest symbol address that corresponds to the given physical address. Same as [getSymbolicStringAddress\(address, 0\)](#getSymbolicStringAddress(long, int)). parameter: address: memory address return: a symbolic address string ## Method: getSymbolicStringAddress - parameter: `address`, type: `long` - parameter: `sspref`, type: `int` - return type: `java.lang.String` Description: Retrieve a symbol address that corresponds to the given physical address. Example: if address if at offset 10h inside method foo\(\) \(at address 401000h\), querying this method with sspref=2 will return a label "foo\+10h"; however, querying with sspref=0 would simply return "401010h". parameter: address: a memory address parameter: sspref: resolution type: \(in the examples a below, a routine exists at address 0x401000\) 0= will resolve to a standard hex\-formatted address, e.g. `0x402000` to `402000h` 1= will first resolve to any existing label, routine address, e.g. `0x401000` to `sub_401000` etc. 2= will first resolve to a routine\-based address, e.g. `sub_401010` to `sub_401000+10h` return: a symbolic address string ## Method: getTypeLibraryService - return type: `com.pnfsoftware.jeb.core.units.code.asm.type.TypeLibraryService` Description: Get the global type library service. return: the type library service ## Method: getTypeManager - return type: `com.pnfsoftware.jeb.core.units.code.asm.type.ITypeManager` Description: Get the global type manager used by this unit. return: the type manager ## Method: getTypes - return type: `java.util.List` ## Method: isAnalysisCompleted - return type: `boolean` Description: Determine whether a code analysis pass is ongoing. return: false if a code analysis is currently taking place, true otherwise ## Method: isInitialAnalysisDone - return type: `boolean` Description: Determine whether or not an initial analysis pass has been done. return: true if initial analysis has completed ## Method: performAnalysis - parameter: `async`, type: `boolean` - parameter: `includeAdvancedAnalysis`, type: `java.lang.Boolean` - parameter: `onCompletion`, type: `java.lang.Runnable` - return type: `boolean` Description: Start an analysis. parameter: async: if true, this method is executed asynchronously and returns immediately; use [INativeCodeAnalyzer#isAnalyzing()](INativeCodeAnalyzer#isAnalyzing()) to determine whether the analysis has completed. parameter: includeAdvancedAnalysis: if null, use the unit's settings; if non\-null, bypass the unit's configuration and force\-enable or force\-disable the advanced analysis parameter: onCompletion: optional runnable to be executed on completion \(always\) return: true if the analysis was started ## Method: performInitialAnalysis - return type: `boolean` Description: Perform the initial analysis pass. This method should be called once, after [successful unit processing](#isProcessed()). The initial analysis pass parameters, such as synchronicity, the inclusion of global or advanced analysis, etc. are determined automatically. return: true if the analysis pass was started or completed ## Method: performInitialAnalysis - parameter: `blocking`, type: `java.lang.Boolean` - return type: `boolean` Description: Perform the initial analysis pass. parameter: blocking: optional blocking mode return: true if the analysis pass was started or completed ## Method: process - return type: `boolean` Description: Quickly process the unit. Be careful that the [IUnit](IUnit) is not analyzed while [#performInitialAnalysis()](#performInitialAnalysis()) was not called. return: true if [IUnit](IUnit) was processed \(may then check [#isInitialAnalysisDone()](#isInitialAnalysisDone()) to check that unit is fully usable\) ## Method: setAnalyzerExtension - parameter: `ext`, type: `com.pnfsoftware.jeb.core.units.code.asm.analyzer.INativeCodeAnalyzerExtension` Description: Set the principal code analyzer extension for this unit. parameter: ext: analyzer extension ## Method: setCallingConvention - parameter: `cc`, type: `com.pnfsoftware.jeb.core.units.code.asm.type.ICallingConvention` Description: Set the default calling convention. parameter: cc: calling convention ## Method: setCodeAt - parameter: `address`, type: `long` - parameter: `procmode`, type: `int` - parameter: `undefineOverlappingItems`, type: `boolean` - return type: `boolean` Description: Parse and create an instruction at the provided address. parameter: address: instruction address parameter: procmode: processor mode \(refer to `MODE_xxx` constants in [IProcessor](IProcessor)\) parameter: undefineOverlappingItems: if false, the method will fail if existing items overlap with the memory range needed to accommodate a newly\-created item return: success indicator ## Method: setCodeFormatter - parameter: `codeFormatter`, type: `com.pnfsoftware.jeb.core.units.code.asm.render.GenericCodeFormatter` Description: Set the helper object used to format instructions into a sink. parameter: codeFormatter: code formatter ## Method: setCompilerType - parameter: `compilerType`, type: `com.pnfsoftware.jeb.core.units.codeobject.CompilerType` Description: Set a hint. This method may be called optionally, before process\(\). The hint may be disregarded. parameter: compilerType: compiler type hint ## Method: setDataAt - parameter: `address`, type: `long` - parameter: `type`, type: `com.pnfsoftware.jeb.core.units.code.asm.type.INativeType` - parameter: `name`, type: `java.lang.String` - return type: `boolean` Description: Create or update a data item at the provided address. Overlapping items may be deleted. Note: to create String items, see [#setStringAt(long, long, StringEncoding, int, int)](#setStringAt(long, long, StringEncoding, int, int)). parameter: address: item address parameter: type: item type parameter: name: optional name return: success indicator ## Method: setDataAt - parameter: `address`, type: `long` - parameter: `type`, type: `com.pnfsoftware.jeb.core.units.code.asm.type.INativeType` - parameter: `name`, type: `java.lang.String` - parameter: `undefineOverlappingItems`, type: `boolean` - return type: `boolean` Description: Create or update a data item at the provided address. Note: to create String items, see [#setStringAt(long, long, StringEncoding, int, int)](#setStringAt(long, long, StringEncoding, int, int)). parameter: address: item address parameter: type: item type parameter: name: optional name parameter: undefineOverlappingItems: if false, the method will fail if existing items overlap with the memory range needed to accommodate a newly\-created item return: success indicator ## Method: setDataTypeAt - parameter: `address`, type: `long` - parameter: `type`, type: `com.pnfsoftware.jeb.core.units.code.asm.type.INativeType` - return type: `boolean` Description: Convenience method to set the native type of a data item located at the provided address. If no item exists at the provided address, one will be created. Overlapping items may be deleted. Note: to create String items, see [#setStringAt(long, long, StringEncoding, int, int)](#setStringAt(long, long, StringEncoding, int, int)). parameter: address: item address parameter: type: native type return: success indicator ## Method: setInlineComment - parameter: `address`, type: `long` - parameter: `comment`, type: `java.lang.String` - return type: `boolean` Description: Convenience method used to set the inline comment at the provided virtual address. parameter: address: VA parameter: comment: a comment return: success indicator ## Method: setMemory - parameter: `mem`, type: `com.pnfsoftware.jeb.core.units.code.asm.memory.IVirtualMemory` Description: Optionally set the current optional virtual memory \(VM\) used by this unit. This method should be called at most once \(typically done in the unit's identifier\), before [processing](#process()) the unit. It is optional; the VM object set may be overridden during unit processing if it is deemed inappropriate to handle the code object. Therefore, after processing, client code should always retrieve the actual VM object via [#getMemory()](#getMemory()). parameter: mem: optional VM ## Method: setPhysicalImageBase - parameter: `physicalImageBase`, type: `long` Description: Set the real \(physical\) image base for this piece of code. That address is the real address of the first loaded byte on a target device. The existence of this method implies that at most one physical address can be used at any time. \(Typically, debuggers use this method to let code units know of where they are currently mapped, which in turn is used to better render assembly output.\) Generally, the physical image address changes across different launches. parameter: physicalImageBase: the physical image base of this code unit; the value 0 means that the physical address is unknown ## Method: setProcessor - parameter: `proc`, type: `com.pnfsoftware.jeb.core.units.code.asm.processor.IProcessor` Description: Set the code parser \(processor\) used by this unit. This method should be called at most once \(typically done in the unit's identifier\), before [processing](#process()) the unit. parameter: proc: mandatory processor ## Method: setRoutineAt - parameter: `address`, type: `long` - return type: `boolean` Description: Parse and attempt to create a routine at the provided address. The processor mode used will be the default one, and the analysis will be done forcefully. parameter: address: routine start address return: success indicator: if true, a routine was created \(or existed\) at the provided address ## Method: setRoutineAt - parameter: `address`, type: `long` - parameter: `procmode`, type: `int` - return type: `boolean` Description: Parse and attempt to create a routine at the provided address. The analysis is done forcefully. parameter: address: routine start address parameter: procmode: processor mode return: success indicator: if true, a routine was created \(or existed\) at the provided address ## Method: setRoutineAt - parameter: `address`, type: `long` - parameter: `procmode`, type: `int` - parameter: `permission`, type: `int` - return type: `boolean` Description: Parse and attempt to create a routine at the provided address. parameter: address: routine start address parameter: procmode: processor mode parameter: permission: one of the `PERMISSION_xxx` constants of [INativeCodeAnalyzer](INativeCodeAnalyzer) \(refer to [enqueuePointerForAnalysis](INativeCodeAnalyzer#enqueuePointerForAnalysis(com.pnfsoftware.jeb.core.units.code.Pointer, int)) for details\) return: success indicator: if true, a routine was created \(or existed\) at the provided address ## Method: setRoutinePrototype - parameter: `routine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` - parameter: `prototypeString`, type: `java.lang.String` - return type: `boolean` Description: Set a routine prototype. This method uses non\-standard prototype declarations and should be avoided. Use [#setRoutineSignature(INativeMethodItem, String, boolean)](#setRoutineSignature(INativeMethodItem, String, boolean)) instead. parameter: routine: target routine parameter: prototypeString: a prototype string having the following style: ``` returnType(paramType1 _) returnType(paramType1, paramType2) returnType(paramType1, paramType2, ...) ``` return: success indicator ## Method: setRoutineReferenceAt - parameter: `address`, type: `long` - parameter: `routine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` - return type: `boolean` Description: Create a special data item representing a reference to a method. Those items are similar to function pointer items \(pointer to prototypes\), except that they refer specifically to routine objects managed by this unit. parameter: address: item address parameter: routine: target routine return: success indicator ## Method: setRoutineSignature - parameter: `routine`, type: `com.pnfsoftware.jeb.core.units.code.asm.items.INativeMethodItem` - parameter: `signatureString`, type: `java.lang.String` - parameter: `prototypeOnly`, type: `boolean` - return type: `boolean` Description: Set a routine signature or protytpe. parameter: routine: target routine parameter: signatureString: a C\-like signature; some C\+\+ features such as namespaces \(`::`\) or templates \(`<...>`\) are allowed but disregarded parameter: prototypeOnly: if true, only the prototype will be applied; method and parameter names, if provided, will not be applied return: success indicator ## Method: setStringAt - parameter: `address`, type: `long` - parameter: `addressMax`, type: `long` - parameter: `stringType`, type: `com.pnfsoftware.jeb.core.units.code.asm.type.StringEncoding` - parameter: `minChars`, type: `int` - parameter: `maxChars`, type: `int` - return type: `boolean` Description: Create a string data item. Overlapping items may be deleted. parameter: address: mandatory start address parameter: addressMax: optional maximum \(final\) address for the string; use \-1 for no limit parameter: stringType: the string type hint; null to let this method determine the best string type heuristically parameter: minChars: minimum number of characters to be found in the string for it to be considered valid; set to \-1 for default \(currently: 3\) parameter: maxChars: maximum number of characters \(not bytes\) to be parsed; set to \-1 for default \(currently: 100\_000\) return: success indicator ## Method: setStringAt - parameter: `address`, type: `long` - parameter: `addressMax`, type: `long` - parameter: `stringType`, type: `com.pnfsoftware.jeb.core.units.code.asm.type.StringEncoding` - parameter: `minChars`, type: `int` - parameter: `maxChars`, type: `int` - parameter: `undefineOverlappingItems`, type: `boolean` - return type: `boolean` Description: Create a string data item. parameter: address: mandatory start address parameter: addressMax: optional maximum \(final\) address for the string; use \-1 for no limit parameter: stringType: the string type hint; null to let this method determine the best string type heuristically parameter: minChars: minimum number of characters to be found in the string for it to be considered valid; set to \-1 for default \(currently: 3\) parameter: maxChars: maximum number of characters \(not bytes\) to be parsed; set to \-1 for default \(currently: 100\_000\) parameter: undefineOverlappingItems: if false, the method will fail if existing items overlap with the memory range needed to accommodate a newly\-created item return: success indicator ## Method: setSubsystemType - parameter: `subsystemType`, type: `com.pnfsoftware.jeb.core.units.codeobject.SubsystemType` Description: Set a hint. This method may be called optionally, before process\(\). The hint may be disregarded. parameter: subsystemType: subsystem type hint ## Method: setVirtualImageBase - parameter: `virtualImageBase`, type: `long` Description: Set preferred image base parameter: virtualImageBase: preferred virtual image base ## Method: undefineItem - parameter: `address`, type: `long` - return type: `boolean` Description: Undefine the memory item starting at the provided address. Careful, this method may have unintended side effects. Example: deleting an instruction item that's part of a routine body will also discard that routine, which in turn may discard other items or references, within this unit or other units. parameter: address: item address return: success indicator