diff --git a/.gitignore b/.gitignore index 9cf055c..7bae72f 100644 --- a/.gitignore +++ b/.gitignore @@ -346,3 +346,6 @@ KSPDevPath.xml # Binaries GameData/KSPCommunityFixes/Plugins/* + +# keep harmony PBD +!0Harmony.pdb diff --git a/KSPCommunityFixes/BasePatch.cs b/KSPCommunityFixes/BasePatch.cs index 8b361c2..5e31dab 100644 --- a/KSPCommunityFixes/BasePatch.cs +++ b/KSPCommunityFixes/BasePatch.cs @@ -375,9 +375,6 @@ private static IEnumerable OverrideTranspiler(IEnumerable overrideIl = PatchProcessor.GetOriginalInstructions(patch.patchMethod, out ILGenerator overrideGen); PatchProcessor.GetOriginalInstructions(__originalMethod, out ILGenerator originalGen); diff --git a/KSPCommunityFixes/BugFixes/ExtendedDeployableParts.cs b/KSPCommunityFixes/BugFixes/ExtendedDeployableParts.cs index bd924df..5d1f5cd 100644 --- a/KSPCommunityFixes/BugFixes/ExtendedDeployableParts.cs +++ b/KSPCommunityFixes/BugFixes/ExtendedDeployableParts.cs @@ -99,6 +99,10 @@ static IEnumerable ModuleDeployableSolarPanel_OnStart_Transpile { code[i].opcode = OpCodes.Br_S; code[i].operand = code[i + 2].operand; // grab the target instruction from the original jump + code[i + 1].opcode = OpCodes.Nop; // don't generate invalid IL + code[i + 1].operand = null; + code[i + 2].opcode = OpCodes.Nop; // don't generate invalid IL + code[i + 2].operand = null; break; } } diff --git a/KSPCommunityFixes/KSPCommunityFixes.csproj b/KSPCommunityFixes/KSPCommunityFixes.csproj index 5b2be6c..8485bd9 100644 --- a/KSPCommunityFixes/KSPCommunityFixes.csproj +++ b/KSPCommunityFixes/KSPCommunityFixes.csproj @@ -91,36 +91,43 @@ + + + + + - + + + + - - - - - - + + + + + + - diff --git a/KSPCommunityFixes/lib/0Harmony.dll b/KSPCommunityFixes/lib/0Harmony.dll index 54faa2d..c7586d7 100644 Binary files a/KSPCommunityFixes/lib/0Harmony.dll and b/KSPCommunityFixes/lib/0Harmony.dll differ diff --git a/KSPCommunityFixes/lib/0Harmony.pdb b/KSPCommunityFixes/lib/0Harmony.pdb new file mode 100644 index 0000000..45f3c7b Binary files /dev/null and b/KSPCommunityFixes/lib/0Harmony.pdb differ diff --git a/KSPCommunityFixes/lib/0Harmony.xml b/KSPCommunityFixes/lib/0Harmony.xml new file mode 100644 index 0000000..632bc61 --- /dev/null +++ b/KSPCommunityFixes/lib/0Harmony.xml @@ -0,0 +1,4126 @@ + + + + 0Harmony + + + + A factory to create delegate types + + + Default constructor + + + Creates a delegate type for a method + The method + The new delegate type + + + A getter delegate type + Type that getter gets field/property value from + Type of the value that getter gets + The instance get getter uses + An delegate + + + A setter delegate type + Type that setter sets field/property value for + Type of the value that setter sets + The instance the setter uses + The value the setter uses + An delegate + + + A constructor delegate type + Type that constructor creates + An delegate + + + A helper class for fast access to getters and setters + + + Creates an instantiation delegate + Type that constructor creates + The new instantiation delegate + + + Creates an getter delegate for a property + Type that getter reads property from + Type of the property that gets accessed + The property + The new getter delegate + + + Creates an getter delegate for a field + Type that getter reads field from + Type of the field that gets accessed + The field + The new getter delegate + + + Creates an getter delegate for a field (with a list of possible field names) + Type that getter reads field/property from + Type of the field/property that gets accessed + A list of possible field names + The new getter delegate + + + Creates an setter delegate + Type that setter assigns property value to + Type of the property that gets assigned + The property + The new setter delegate + + + Creates an setter delegate for a field + Type that setter assigns field value to + Type of the field that gets assigned + The field + The new getter delegate + + + A delegate to invoke a method + The instance + The method parameters + The method result + + + A helper class to invoke method with delegates + + + Creates a fast invocation handler from a method + The method to invoke + Controls if boxed value object is accessed/updated directly + The + + + The directBoxValueAccess option controls how value types passed by reference (e.g. ref int, out my_struct) are handled in the arguments array + passed to the fast invocation handler. + Since the arguments array is an object array, any value types contained within it are actually references to a boxed value object. + Like any other object, there can be other references to such boxed value objects, other than the reference within the arguments array. + For example, + + var val = 5; + var box = (object)val; + var arr = new object[] { box }; + handler(arr); // for a method with parameter signature: ref/out/in int + + + If directBoxValueAccess is true, the boxed value object is accessed (and potentially updated) directly when the handler is called, + such that all references to the boxed object reflect the potentially updated value. + In the above example, if the method associated with the handler updates the passed (boxed) value to 10, both box and arr[0] + now reflect the value 10. Note that the original val is not updated, since boxing always copies the value into the new boxed value object. + + + If directBoxValueAccess is false (default), the boxed value object in the arguments array is replaced with a "reboxed" value object, + such that potential updates to the value are reflected only in the arguments array. + In the above example, if the method associated with the handler updates the passed (boxed) value to 10, only arr[0] now reflects the value 10. + + + + + Delegate type for "ref return" injections + Return type of the original method, without ref modifier + + + + A mutable representation of an inline signature, similar to Mono.Cecil's CallSite. + Used by the calli instruction, can be used by transpilers + + + + See + + + See + + + See + + + The list of all parameter types or function pointer signatures received by the call site + + + The return type or function pointer signature returned by the call site + + + Returns a string representation of the inline signature + A string representation of the inline signature + + + + A mutable representation of a parameter type with an attached type modifier, + similar to Mono.Cecil's OptionalModifierType / RequiredModifierType and C#'s modopt / modreq + + + + Whether this is a modopt (optional modifier type) or a modreq (required modifier type) + + + The modifier type attached to the parameter type + + + The modified parameter type + + + Returns a string representation of the modifier type + A string representation of the modifier type + + + Specifies the type of method + + + This is a normal method + + + This is a getter + + + This is a setter + + + This is a constructor + + + This is a static constructor + + + This targets the MoveNext method of the enumerator result, that actually contains the method's implementation + + + This targets the MoveNext method of the async state machine, that actually contains the method's implementation + + + Finalize + + + This is a add event method + + + This is a remove event method + + + This is a op_Implicit + + + This is a op_Explicit + + + This is a op_UnaryPlus + + + This is a op_UnaryNegation + + + This is a op_LogicalNot + + + This is a op_OnesComplement + + + This is a op_Increment + + + This is a op_Decrement + + + This is a op_True + + + This is a op_False + + + This is a op_Addition + + + This is a op_Subtraction + + + This is a op_Multiply + + + This is a op_Division + + + This is a op_Modulus + + + This is a op_BitwiseAnd + + + This is a op_BitwiseOr + + + This is a op_ExclusiveOr + + + This is a op_LeftShift + + + This is a op_RightShift + + + This is a op_Equality + + + This is a op_Inequality + + + This is a op_GreaterThan + + + This is a op_LessThan + + + This is a op_GreaterThanOrEqual + + + This is a op_LessThanOrEqual + + + This is a op_Comma + + + Specifies the type of argument + + + This is a normal argument + + + This is a reference argument (ref) + + + This is an out argument (out) + + + This is a pointer argument (&) + + + Specifies the type of patch + + + Any patch + + + A prefix patch + + + A postfix patch + + + A transpiler + + + A finalizer + + + A reverse patch + + + An inner prefix patch + + + An inner postfix patch + + + Specifies the type of reverse patch + + + Use the unmodified original method (directly from IL) + + + Use the original as it is right now including previous patches but excluding future ones + + + Specifies the type of method call dispatching mechanics + + + Call the method using dynamic dispatching if method is virtual (including overriden) + + + This is the built-in form of late binding (a.k.a. dynamic binding) and is the default dispatching mechanic in C#. + This directly corresponds with the instruction. + + + For virtual (including overriden) methods, the instance type's most-derived/overriden implementation of the method is called. + For non-virtual (including static) methods, same behavior as : the exact specified method implementation is called. + + + Note: This is not a fully dynamic dispatch, since non-virtual (including static) methods are still called non-virtually. + A fully dynamic dispatch in C# involves using + the dynamic type + (actually a fully dynamic binding, since even the name and overload resolution happens at runtime), which does not support. + + + + + Call the method using static dispatching, regardless of whether method is virtual (including overriden) or non-virtual (including static) + + + a.k.a. non-virtual dispatching, early binding, or static binding. + This directly corresponds with the instruction. + + + For both virtual (including overriden) and non-virtual (including static) methods, the exact specified method implementation is called, without virtual/override mechanics. + + + + + The base class for all Harmony annotations (not meant to be used directly) + + + The common information for all attributes + + + Annotation to define a category for use with PatchCategory + + + Annotation specifying the category + Name of patch category + + + Annotation to define your Harmony patch methods + + + An empty annotation can be used together with TargetMethod(s) + + + An annotation that specifies a class to patch + The declaring class/type + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The argument types of the method or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + The full name of the declaring class/type + The name of the method, property or constructor to patch + The + + + Annotation to define the original method for delegate injection + + + An annotation that specifies a class to patch + The declaring class/type + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The argument types of the method or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The + An array of argument types to target overloads + Array of + + + An annotation that specifies a method, property or constructor to patch + The declaring class/type + The name of the method, property or constructor to patch + The + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + The name of the method, property or constructor to patch + The + + + An annotation that specifies call dispatching mechanics for the delegate + The + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + The + An array of argument types to target overloads + An array of + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + + + An annotation that specifies a method, property or constructor to patch + An array of argument types to target overloads + An array of + + + Annotation to define your standin methods for reverse patching + + + An annotation that specifies the type of reverse patching + The of the reverse patch + + + A Harmony annotation to define that all methods in a class are to be patched + + + A Harmony annotation + + + A Harmony annotation to define patch priority + The priority + + + A Harmony annotation + + + A Harmony annotation to define that a patch comes before another patch + The array of harmony IDs of the other patches + + + A Harmony annotation + + + A Harmony annotation to define that a patch comes after another patch + The array of harmony IDs of the other patches + + + A Harmony annotation + + + A Harmony annotation to debug a patch (output uses to log to your Desktop) + + + Specifies the Prepare function in a patch class + + + Specifies the Cleanup function in a patch class + + + Specifies the TargetMethod function in a patch class + + + Specifies the TargetMethods function in a patch class + + + Specifies the Prefix function in a patch class + + + Specifies the Postfix function in a patch class + + + Specifies the Transpiler function in a patch class + + + Specifies the Finalizer function in a patch class + + + A Harmony annotation + + + The name of the original argument + + + The index of the original argument + + + The new name of the original argument + + + An annotation to declare injected arguments by name + + + An annotation to declare injected arguments by index + Zero-based index + + + An annotation to declare injected arguments by renaming them + Name of the original argument + New name + + + An annotation to declare injected arguments by index and renaming them + Zero-based index + New name + + + An abstract wrapper around OpCode and their operands. Used by transpilers + + + The opcode + + + The operand + + + All labels defined on this instruction + + + All exception block boundaries defined on this instruction + + + Creates a new CodeInstruction with a given opcode and optional operand + The opcode + The operand + + + Create a full copy (including labels and exception blocks) of a CodeInstruction + The to copy + + + Clones a CodeInstruction and resets its labels and exception blocks + A lightweight copy of this code instruction + + + Clones a CodeInstruction, resets labels and exception blocks and sets its opcode + The opcode + A copy of this CodeInstruction with a new opcode + + + Clones a CodeInstruction, resets labels and exception blocks and sets its operand + The operand + A copy of this CodeInstruction with a new operand + + + Creates a CodeInstruction calling a method (CALL) + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A code instruction that calls the method matching the arguments + + + Creates a CodeInstruction calling a method (CALL) + The target method in the form TypeFullName:MethodName, where the type name matches a form recognized by Type.GetType like Some.Namespace.Type. + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A code instruction that calls the method matching the arguments + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + A new Codeinstruction + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + A new Codeinstruction + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + A new Codeinstruction + + + Creates a CodeInstruction calling a method (CALL) + The lambda expression using the method + A new Codeinstruction + + + Returns an instruction to call the specified closure + The delegate type to emit + The closure that defines the method to call + A that calls the closure as a method + + + Creates a CodeInstruction loading a field (LD[S]FLD[A]) + The class/type where the field is defined + The name of the field (case sensitive) + Use address of field + A new Codeinstruction + + + Creates a CodeInstruction storing to a field (ST[S]FLD) + The class/type where the field is defined + The name of the field (case sensitive) + A new Codeinstruction + + + Creates a CodeInstruction loading a local with the given index, using the shorter forms when possible + The index where the local is stored + Use address of local + A new Codeinstruction + + + + Creates a CodeInstruction storing to a local with the given index, using the shorter forms when possible + The index where the local is stored + A new Codeinstruction + + + + Creates a CodeInstruction loading an argument with the given index, using the shorter forms when possible + The index of the argument + Use address of argument + A new Codeinstruction + + + + Creates a CodeInstruction storing to an argument with the given index, using the shorter forms when possible + The index of the argument + A new Codeinstruction + + + + Checks if a CodeInstruction contains a given exception block type + Type of the exception block to check for + True if the instruction contains the exception block type, false otherwise + + + Returns a string representation of the code instruction + A string representation of the code instruction + + + Exception block types + + + The beginning of an exception block + + + The beginning of a catch block + + + The beginning of an except filter block (currently not supported to use in a patch) + + + The beginning of a fault block + + + The beginning of a finally block + + + The end of an exception block + + + An exception block + + + Block type + + + Catch type + + + Creates a new ExceptionBlock + The + The catch type + + + The Harmony instance is the main entry to Harmony. After creating one with an unique identifier, it is used to patch and query the current application domain + + + The unique identifier + + + Set to true before instantiating Harmony to debug Harmony or use an environment variable to set HARMONY_DEBUG to '1' like this: cmd /C "set HARMONY_DEBUG=1 && game.exe" + This is for full debugging. To debug only specific patches, use the attribute + + + Creates a new Harmony instance + A unique identifier (you choose your own) + A Harmony instance + + + Searches the current assembly for Harmony annotations and uses them to create patches + This method can fail to use the correct assembly when being inlined. It calls StackTrace.GetFrame(1) which can point to the wrong method/assembly. If you are unsure or run into problems, use PatchAll(Assembly.GetExecutingAssembly()) instead. + + + Creates a empty patch processor for an original method + The original method/constructor + A new instance + + + Creates a patch class processor from a class + The class/type + A new instance + + + Creates a reverse patcher for one of your stub methods + The original method/constructor + The stand-in stub method as + A new instance + + + Searches an assembly for HarmonyPatch-annotated classes/structs and uses them to create patches + The assembly + + + Searches an assembly for HarmonyPatch-annotated classes/structs without category annotations and uses them to create patches + + + Searches an assembly for HarmonyPatch-annotated classes/structs without category annotations and uses them to create patches + The assembly + + + Searches the current assembly for Harmony annotations with a specific category and uses them to create patches + Name of patch category + + + Searches an assembly for HarmonyPatch-annotated classes/structs with a specific category and uses them to create patches + The assembly + Name of patch category + + + Creates patches by manually specifying the methods + The original method/constructor + An optional prefix method wrapped in a object + An optional postfix method wrapped in a object + An optional transpiler method wrapped in a object + An optional finalizer method wrapped in a object + The replacement method that was created to patch the original method + + + Patches a foreign method onto a stub method of yours and optionally applies transpilers during the process + The original method/constructor you want to duplicate + Your stub method as that will become the original. Needs to have the correct signature (either original or whatever your transpilers generates) + An optional transpiler as method that will be applied during the process + The replacement method that was created to patch the stub method + + + Unpatches methods by patching them with zero patches. Fully unpatching is not supported. Be careful, unpatching is global + The optional Harmony ID to restrict unpatching to a specific Harmony instance + This method could be static if it wasn't for the fact that unpatching creates a new replacement method that contains your harmony ID + + + Unpatches a method by patching it with zero patches. Fully unpatching is not supported. Be careful, unpatching is global + The original method/constructor + The + The optional Harmony ID to restrict unpatching to a specific Harmony instance + + + Unpatches a method by patching it with zero patches. Fully unpatching is not supported. Be careful, unpatching is global + The original method/constructor + The patch method as method to remove + + + Searches the current assembly for types with a specific category annotation and uses them to unpatch existing patches. Fully unpatching is not supported. Be careful, unpatching is global + Name of patch category + + + Searches an assembly for HarmonyPatch-annotated classes/structs with a specific category annotation and uses them to unpatch existing patches. Fully unpatching is not supported. Be careful, unpatching is global + The assembly + Name of patch category + + + Test for patches from a specific Harmony ID + The Harmony ID + True if patches for this ID exist + + + Gets patch information for a given original method + The original method/constructor + The patch information as + + + Gets the methods this instance has patched + An enumeration of original methods/constructors + + + Gets all patched original methods in the appdomain + An enumeration of patched original methods/constructors + + + Gets the original method from a given replacement method + A replacement method (patched original method) + The original method/constructor or null if not found + + + Tries to get the method from a stackframe including dynamic replacement methods + The + For normal frames, frame.GetMethod() is returned. For frames containing patched methods, the replacement method is returned or null if no method can be found + + + Gets the original method from the stackframe and uses original if method is a dynamic replacement + The + The original method from that stackframe + + + Gets Harmony version for all active Harmony instances + [out] The current Harmony version + A dictionary containing assembly versions keyed by Harmony IDs + + + Under Mono, HarmonyException wraps IL compile errors with detailed information about the failure + + + Get a list of IL instructions in pairs of offset+code + A list of key/value pairs which represent an offset and the code at that offset + + + Get a list of IL instructions without offsets + A list of + + + Get the error offset of the errornous IL instruction + The offset + + + Get the index of the errornous IL instruction + The index into the list of instructions or -1 if not found + + + A wrapper around a method to use it as a patch (for example a Prefix) + + + The original method + + + Patch Category + + + Class/type declaring this patch + + + Patch method name + + + Optional patch + + + Array of argument types of the patch method + + + + of the patch + + + Install this patch before patches with these Harmony IDs + + + Install this patch after patches with these Harmony IDs + + + Reverse patch type, see + + + Create debug output for this patch + + + Whether to use (true) or (false) mechanics + for -attributed delegate + + + Default constructor + + + Creates a patch from a given method + The original method + + + Creates a patch from a given method + The original method + + + Creates a patch from a given method + The original method + The patch + A list of harmony IDs that should come after this patch + A list of harmony IDs that should come before this patch + Set to true to generate debug output + + + Creates a patch from a given method + The original method + The patch + A list of harmony IDs that should come after this patch + A list of harmony IDs that should come before this patch + Set to true to generate debug output + + + Creates a patch from a given method + The patch class/type + The patch method name + The optional argument types of the patch method (for overloaded methods) + + + Gets the names of all internal patch info fields + A list of field names + + + Merges annotations + The list of to merge + The merged + + + Returns a string that represents the annotation + A string representation + + + Creates a patch from a given method + The original method + + + Creates a patch from a given method + The original method + + + Annotation extensions + + + Copies annotation information + The source + The destination + + + Clones an annotation + The to clone + A copied + + + Merges annotations + The master + The detail + A new, merged + + + Gets all annotations on a class/type + The class/type + A list of all + + + Gets merged annotations on a class/type + The class/type + The merged + + + Gets all annotations on a method + The method/constructor + A list of + + + Gets merged annotations on a method + The method/constructor + The merged + + + Occcurances of a method that is called inside some outer method + + + Which occcurances (1-based) of the method, negative numbers are counting from the end, empty array means all occurances + + + Creates an InnerMethod + The inner method + Which occcurances (1-based) of the method, negative numbers are counting from the end, empty array means all occurances + + + The inner method + + + A serializable patch + + + Zero-based index + + + The owner (Harmony ID) + + + The priority, see + + + Keep this patch before the patches indicated in the list of Harmony IDs + + + Keep this patch after the patches indicated in the list of Harmony IDs + + + A flag that will log the replacement method via every time this patch is used to build the replacement, even in the future + + + For an infix patch, this defines the inner method that we will apply the patch to + + + The method of the static patch method + + + Creates a patch + The method of the patch + Zero-based index + An owner (Harmony ID) + The priority, see + A list of Harmony IDs for patches that should run after this patch + A list of Harmony IDs for patches that should run before this patch + A flag that will log the replacement method via every time this patch is used to build the replacement, even in the future + + + Creates a patch + The method of the patch + Zero-based index + An owner (Harmony ID) + + + Get the patch method or a DynamicMethod if original patch method is a patch factory + The original method/constructor + The method of the patch + + + Determines whether patches are equal + The other patch + true if equal + + + Determines how patches sort + The other patch + integer to define sort order (-1, 0, 1) + + + Hash function + A hash code + + + A PatchClassProcessor used to turn on a class/type into patches + + + Name of the patch class's category + + + Creates a patch class processor by pointing out a class; similar to PatchAll() but without searching through all classes + The Harmony instance + The class to process + Use this if you want to patch a class that is not annotated with HarmonyPatch + + + Applies the patches + A list of all created replacement methods or null if patch class is not annotated + + + REmoves the patches + + + A group of patches + + + A collection of prefix + + + A collection of postfix + + + A collection of transpiler + + + A collection of finalizer + + + A collection of inner prefix + + + A collection of inner postfix + + + Gets all owners (Harmony IDs) or all known patches + The patch owners + + + Creates a group of patches + An array of prefixes as + An array of postfixes as + An array of transpileres as + An array of finalizeres as + An array of inner prefixes as + An array of inner postfixes as + + + Serializable patch information + + + Prefixes as an array of + + + Postfixes as an array of + + + Transpilers as an array of + + + Finalizers as an array of + + + InnerPrefixes as an array of + + + InnerPostfixes as an array of + + + Returns if any of the patches wants debugging turned on + + + Number of replacements created + + + Adds prefixes + An owner (Harmony ID) + The patch methods + + + Adds a prefix + + + Removes prefixes + The owner of the prefixes, or * for all + + + Adds postfixes + An owner (Harmony ID) + The patch methods + + + Adds a postfix + + + Removes postfixes + The owner of the postfixes, or * for all + + + Adds transpilers + An owner (Harmony ID) + The patch methods + + + Adds a transpiler + + + Removes transpilers + Removes transpilers + The owner of the transpilers, or * for all + + + Adds finalizers + An owner (Harmony ID) + The patch methods + + + Adds a finalizer + + + Removes finalizers + The owner of the finalizers, or * for all + + + Adds inner prefixes + An owner (Harmony ID) + The patch methods + + + Removes inner prefixes + The owner of the inner prefixes, or * for all + + + Adds inner postfixes + An owner (Harmony ID) + The patch methods + + + Removes inner postfixes + The owner of the inner postfixes, or * for all + + + Removes a patch using its method + The method of the patch to remove + + + A PatchProcessor handles patches on a method/constructor + + + Creates a new PatchProcessor + The Harmony instance + The original method/constructor + + + Adds a prefix + The prefix as a + A for chaining calls + + + Adds a prefix + The prefix method + A for chaining calls + + + Adds a postfix + The postfix as a + A for chaining calls + + + Adds a postfix + The postfix method + A for chaining calls + + + Adds a transpiler + The transpiler as a + A for chaining calls + + + Adds a transpiler + The transpiler method + A for chaining calls + + + Adds a finalizer + The finalizer as a + A for chaining calls + + + Adds a finalizer + The finalizer method + A for chaining calls + + + Adds an inner prefix + The inner prefix as a + A for chaining calls + + + Adds an inner prefix + The inner prefix method + A for chaining calls + + + Adds an inner postfix + The inner postfix as a + A for chaining calls + + + Adds an inner postfix + The inner postfix method + A for chaining calls + + + Gets all patched original methods in the appdomain + An enumeration of patched method/constructor + + + Applies all registered patches + The generated replacement method + + + Unpatches patches of a given type and/or Harmony ID + The patch type + Harmony ID or * for any + A for chaining calls + + + Unpatches a specific patch + The method of the patch + A for chaining calls + + + Gets patch information on an original + The original method/constructor + The patch information as + + + Sort patch methods by their priority rules + The original method + Patches to sort + The sorted patch methods + + + Gets Harmony version for all active Harmony instances + [out] The current Harmony version + A dictionary containing assembly version keyed by Harmony ID + + + Creates a new empty generator to use when reading method bodies + A new + + + Creates a new generator matching the method/constructor to use when reading method bodies + The original method/constructor to copy method information from + A new + + + Returns the methods unmodified list of code instructions + The original method/constructor + Optionally an existing generator that will be used to create all local variables and labels contained in the result (if not specified, an internal generator is used) + A list containing all the original + + + Returns the methods unmodified list of code instructions + The original method/constructor + A new generator that now contains all local variables and labels contained in the result + A list containing all the original + + + Returns the methods current list of code instructions after all existing transpilers have been applied + The original method/constructor + Apply only the first count of transpilers + Optionally an existing generator that will be used to create all local variables and labels contained in the result (if not specified, an internal generator is used) + A list of + + + Returns the methods current list of code instructions after all existing transpilers have been applied + The original method/constructor + A new generator that now contains all local variables and labels contained in the result + Apply only the first count of transpilers + A list of + + + A low level way to read the body of a method. Used for quick searching in methods + The original method + All instructions as opcode/operand pairs + + + A low level way to read the body of a method. Used for quick searching in methods + The original method + An existing generator that will be used to create all local variables and labels contained in the result + All instructions as opcode/operand pairs + + + A patch priority + + + Patch last + + + Patch with very low priority + + + Patch with low priority + + + Patch with lower than normal priority + + + Patch with normal priority + + + Patch with higher than normal priority + + + Patch with high priority + + + Patch with very high priority + + + Patch first + + + A reverse patcher + + + Creates a reverse patcher + The Harmony instance + The original method/constructor + Your stand-in stub method as + + + Applies the patch + The type of patch, see + The generated replacement method + + + A collection of commonly used transpilers + + + A transpiler that replaces all occurrences of a given method with another one using the same signature + The enumeration of to act on + Method or constructor to search for + Method or constructor to replace with + Modified enumeration of + + + A transpiler that alters instructions that match a predicate by calling an action + The enumeration of to act on + A predicate selecting the instructions to change + An action to apply to matching instructions + Modified enumeration of + + + A transpiler that logs a text at the beginning of the method + The instructions to act on + The log text + Modified enumeration of + + + Patch serialization + + + Control the binding of a serialized object to a type + Specifies the assembly name of the serialized object + Specifies the type name of the serialized object + The type of the object the formatter creates a new instance of + + + Serializes a patch info + The + The serialized data + + + Deserialize a patch info + The serialized data + A + + + Compare function to sort patch priorities + The patch + Zero-based index + The priority + A standard sort integer (-1, 0, 1) + + + A helper class for reflection related functions + + + Shortcut for to simplify the use of reflections and make it work for any access level + + + Shortcut for to simplify the use of reflections and make it work for any access level but only within the current type + + + Enumerates all assemblies in the current app domain, excluding visual studio assemblies + An enumeration of + + + Gets a type by name. Prefers a full name with namespace but falls back to the first type matching the name otherwise + The name + A type or null if not found + + + Searches a type by regular expression; for exact searching, use + The regular expression that matches against Type.FullName or Type.Name + Refetches the cached types if set to true + The first type where FullName or Name matches the search + + + Clears the type cache that uses + + + Gets all successfully loaded types from a given assembly + The assembly + An array of types + + This calls and returns , while catching any thrown . + If such an exception is thrown, returns the successfully loaded types (, + filtered for non-null values). + + + + Enumerates all successfully loaded types in the current app domain, excluding visual studio assemblies + An enumeration of all in all assemblies, excluding visual studio assemblies + + + Enumerates all inner types (non-recursive) of a given type + The class/type to start with + An enumeration of all inner + + + Applies a function going up the type hierarchy and stops at the first non-null result + Result type of func() + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + The type hierarchy of a class or value type (including struct) does NOT include implemented interfaces, + and the type hierarchy of an interface is only itself (regardless of whether that interface implements other interfaces). + The top-most type in the type hierarchy of all non-interface types (including value types) is . + + + + Applies a function going into inner types and stops at the first non-null result + Generic type parameter + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + + Creates an identifiable version of a method + The method + + + + Gets the reflection information for a directly declared field + The class/type where the field is defined + The name of the field + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a directly declared field + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A field or null when the field cannot be found + + + Gets the reflection information for a field by searching the type and all its super types + The class/type where the field is defined + The name of the field (case sensitive) + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a field by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A field or null when the field cannot be found + + + Gets the reflection information for a field + The class/type where the field is declared + The zero-based index of the field inside the class definition + A field or null when type is null or when the field cannot be found + + + Gets the reflection information for a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for a directly declared property + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A property or null when the property cannot be found + + + Gets the reflection information for a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of a directly declared property + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the property cannot be found + + + Gets the reflection information for the getter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for the setter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the Setter method of a directly declared property + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the property cannot be found + + + Gets the reflection information for the setter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for a property by searching the type and all its super types + The class/type + The name + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for a property by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A property or null when the property cannot be found + + + Gets the reflection information for an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of a property by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for the setter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of a property by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for a directly declared event + The class/type where the event is declared + The name of the event (case sensitive) + An event or null when type/name is null or when the event cannot be found + + + Gets the reflection information for a directly declared event + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + An event or null when the event cannot be found + + + Gets the reflection information for an event by searching the type and all its super types + The class/type where the event is declared + The name of the event (case sensitive) + An event or null when type/name is null or when the event cannot be found + + + Gets the reflection information for an event by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + An event or null when the event cannot be found + + + Gets the reflection information for the add method of a directly declared event + The class/type where the event is declared + The name of the event (case sensitive) + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the add method of a directly declared event + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the event cannot be found + + + Gets the reflection information for the add method of an event by searching the type and all its super types + The class/type where the event is declared + The name of the event (case sensitive) + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the add method of an event by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the event cannot be found + + + Gets the reflection information for the remove method of a directly declared event + The class/type where the event is declared + The name of the event (case sensitive) + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the remove method of a directly declared event + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the event cannot be found + + + Gets the reflection information for the remove method of an event by searching the type and all its super types + The class/type where the event is declared + The name of the event (case sensitive) + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the remove method of an event by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A method or null when the event cannot be found + + + Gets the reflection information for a directly declared method + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the reflection information for a directly declared method + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when the method cannot be found + + + Gets the reflection information for a method by searching the type and all its super types + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the reflection information for a method by searching the type and all its super types + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when the method cannot be found + + + Gets the method of an enumerator method + Enumerator method that creates the enumerator + The internal method of the enumerator or null if no valid enumerator is detected + + + Gets the method of an async method's state machine + Async method that creates the state machine internally + The internal method of the async state machine or null if no valid async method is detected + + + Gets the reflection information for a finalizer + The class/type that defines the finalizer + A method or null when type is null or when the finalizer cannot be found + + + Gets the reflection information for a directly declared finalizer + The class/type that defines the finalizer + A method or null when type is null or when the finalizer cannot be found + + + Gets the names of all method that are declared in a type + The declaring class/type + A list of method names + + + Gets the names of all method that are declared in the type of the instance + An instance of the type to search in + A list of method names + + + Gets the names of all fields that are declared in a type + The declaring class/type + A list of field names + + + Gets the names of all fields that are declared in the type of the instance + An instance of the type to search in + A list of field names + + + Gets the names of all properties that are declared in a type + The declaring class/type + A list of property names + + + Gets the names of all properties that are declared in the type of the instance + An instance of the type to search in + A list of property names + + + Gets the type of any class member of + A member + The class/type of this member + + + Returns a by searching for module-id and token + The module of the method + The token of the method + + + + Test if a class member is actually an concrete implementation + A member + True if the member is a declared + + + Gets the real implementation of a class member + A member + The member itself if its declared. Otherwise the member that is actually implemented in some base type + + + Gets the reflection information for a directly declared constructor + The class/type where the constructor is declared + Optional parameters to target a specific overload of the constructor + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the constructor cannot be found + + + Gets the reflection information for a constructor by searching the type and all its super types + The class/type where the constructor is declared + Optional parameters to target a specific overload of the method + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the method cannot be found + + + Gets reflection information for all declared constructors + The class/type where the constructors are declared + Optional parameters to only consider static constructors + A list of constructor infos + + + Gets reflection information for all declared methods + The class/type where the methods are declared + A list of methods + + + Gets reflection information for all declared properties + The class/type where the properties are declared + A list of properties + + + Gets reflection information for all declared fields + The class/type where the fields are declared + A list of fields + + + Gets the return type of a method or constructor + The method/constructor + The return type + + + Given a type, returns the first inner type matching a recursive search by name + The class/type to start searching at + The name of the inner type (case sensitive) + The inner type or null if type/name is null or if a type with that name cannot be found + + + Given a type, returns the first inner type matching a recursive search with a predicate + The class/type to start searching at + The predicate to search with + The inner type or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first method matching a predicate + The class/type to start searching at + The predicate to search with + The method or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first constructor matching a predicate + The class/type to start searching at + The predicate to search with + The constructor info or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first property matching a predicate + The class/type to start searching at + The predicate to search with + The property or null if type/predicate is null or if a type with that name cannot be found + + + Returns an array containing the type of each object in the given array + An array of objects + An array of types or an empty array if parameters is null (if an object is null, the type for it will be object) + + + Creates an array of input parameters for a given method and a given set of potential inputs + The method/constructor you are planing to call + The possible input parameters in any order + An object array matching the method signature + + + A readable/assignable reference delegate to an instance field of a class or static field (NOT an instance field of a struct) + + An arbitrary type if the field is static; otherwise the class that defines the field, or a parent class (including ), + implemented interface, or derived class of this type + + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The runtime instance to access the field (ignored and can be omitted for static fields) + A readable/assignable reference to the field + Null instance passed to a non-static field ref delegate + + Instance of invalid type passed to a non-static field ref delegate + (this can happen if is a parent class or interface of the field's declaring type) + + + + This delegate cannot be used for instance fields of structs, since a struct instance passed to the delegate would be passed by + value and thus would be a copy that only exists within the delegate's invocation. This is fine for a readonly reference, + but makes assignment futile. Use instead. + + + Note that is not required to be the field's declaring type. It can be a parent class (including ), + implemented interface, or a derived class of the field's declaring type ("instanceOfT is FieldDeclaringType" must be possible). + Specifically, must be assignable from OR to the field's declaring type. + Technically, this allows Nullable, although Nullable is only relevant for structs, and since only static fields of structs + are allowed for this delegate, and the instance passed to such a delegate is ignored, this hardly matters. + + + Similarly, is not required to be the field's field type, unless that type is a non-enum value type. + It can be a parent class (including object) or implemented interface of the field's field type. It cannot be a derived class. + This variance is not allowed for value types, since that would require boxing/unboxing, which is not allowed for ref values. + Special case for enum types: can also be the underlying integral type of the enum type. + Specifically, for reference types, must be assignable from + the field's field type; for non-enum value types, must be exactly the field's field type; for enum types, + must be either the field's field type or the underyling integral type of that field type. + + + This delegate supports static fields, even those defined in structs, for legacy reasons. + For such static fields, is effectively ignored. + Consider using (and StaticFieldRefAccess methods that return it) instead for static fields. + + + + + Creates a field reference delegate for an instance field of a class + The class that defines the instance field, or derived class of this type + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The name of the field + A readable/assignable delegate + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + Creates an instance field reference for a specific instance of a class + The class that defines the instance field, or derived class of this type + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The name of the field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance. + If you need to access a field's value for potentially multiple instances, use instead. + FieldRefAccess<T, F>(instance, fieldName) is functionally equivalent to FieldRefAccess<T, F>(fieldName)(instance). + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + + The type that defines the field, or derived class of this type; must not be a struct type unless the field is static + + The name of the field + + A readable/assignable delegate with T=object + (for static fields, the instance delegate parameter is ignored) + + + + This method is meant for cases where the given type is only known at runtime and thus can't be used as a type parameter T + in e.g. . + + + This method supports static fields, even those defined in structs, for legacy reasons. + Consider using (and other overloads) instead for static fields. + + + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + type of the field + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A readable/assignable delegate with T=object + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + + An arbitrary type if the field is static; otherwise the class that defines the field, or a parent class (including ), + implemented interface, or derived class of this type ("instanceOfT is FieldDeclaringType" must be possible) + + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable delegate + + + This method is meant for cases where the field has already been obtained, avoiding the field searching cost in + e.g. . + + + This method supports static fields, even those defined in structs, for legacy reasons. + For such static fields, is effectively ignored. + Consider using (and other overloads) instead for static fields. + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + Creates a field reference for an instance field of a class + + The type that defines the field; or a parent class (including ), implemented interface, or derived class of this type + ("instanceOfT is FieldDeclaringType" must be possible) + + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance and where the field has already been obtained. + If you need to access a field's value for potentially multiple instances, use instead. + FieldRefAccess<T, F>(instance, fieldInfo) is functionally equivalent to FieldRefAccess<T, F>(fieldInfo)(instance). + + + For backwards compatibility, there is no class constraint on . + Instead, the non-value-type check is done at runtime within the method. + + + + + A readable/assignable reference delegate to an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + A reference to the runtime instance to access the field + A readable/assignable reference to the field + + + Creates a field reference delegate for an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The name of the field + A readable/assignable delegate + + + Creates an instance field reference for a specific instance of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The name of the field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance. + If you need to access a field's value for potentially multiple instances, use instead. + StructFieldRefAccess<T, F>(ref instance, fieldName) is functionally equivalent to StructFieldRefAccess<T, F>(fieldName)(ref instance). + + + + + Creates a field reference delegate for an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable delegate + + + This method is meant for cases where the field has already been obtained, avoiding the field searching cost in + e.g. . + + + + + Creates a field reference for an instance field of a struct + The struct that defines the instance field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The instance + The field + A readable/assignable reference to the field + + + This method is meant for one-off access to a field's value for a single instance and where the field has already been obtained. + If you need to access a field's value for potentially multiple instances, use instead. + StructFieldRefAccess<T, F>(ref instance, fieldInfo) is functionally equivalent to StructFieldRefAccess<T, F>(fieldInfo)(ref instance). + + + + + A readable/assignable reference delegate to a static field + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + A readable/assignable reference to the field + + + Creates a static field reference + The type (can be class or struct) the field is defined in + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The name of the field + A readable/assignable reference to the field + + + Creates a static field reference + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The type (can be class or struct) the field is defined in + The name of the field + A readable/assignable reference to the field + + + Creates a static field reference + The type of the field + The member in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + A readable/assignable reference to the field + + + Creates a static field reference + An arbitrary type (by convention, the type the field is defined in) + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable reference to the field + + The type parameter is only used in exception messaging and to distinguish between this method overload + and the overload (which returns a rather than a reference). + + + + Creates a static field reference delegate + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The field + A readable/assignable delegate + + + Creates a delegate to a given method + The delegate Type + The method to create a delegate from. + + Only applies for instance methods. If null (default), returned delegate is an open (a.k.a. unbound) instance delegate + where an instance is supplied as the first argument to the delegate invocation; else, delegate is a closed (a.k.a. bound) + instance delegate where the delegate invocation always applies to the given . + + + Only applies for instance methods. If true (default) and is virtual, invocation of the delegate + calls the instance method virtually (the instance type's most-derived/overriden implementation of the method is called); + else, invocation of the delegate calls the exact specified (this is useful for calling base class methods) + Note: if false and is an interface method, an ArgumentException is thrown. + + + Only applies for instance methods, and if argument is null. + This argument only matters if the target signature contains a value type (such as struct or primitive types), + and your argument is replaced by a non-value type + (usually object) instead of using said value type. + Use this if the generic arguments of doesn't represent the delegate's + arguments, and calling this function fails + A delegate of given to given + + + Delegate invocation is more performant and more convenient to use than + at a one-time setup cost. + + + Works for both type of static and instance methods, both open and closed (a.k.a. unbound and bound) instance methods, + and both class and struct methods. + + + + + Creates a delegate to a given method + The delegate Type + The method in the form TypeFullName:MemberName, where TypeFullName matches the form recognized by Type.GetType like Some.Namespace.Type. + + Only applies for instance methods. If null (default), returned delegate is an open (a.k.a. unbound) instance delegate + where an instance is supplied as the first argument to the delegate invocation; else, delegate is a closed (a.k.a. bound) + instance delegate where the delegate invocation always applies to the given . + + + Only applies for instance methods. If true (default) and is virtual, invocation of the delegate + calls the instance method virtually (the instance type's most-derived/overriden implementation of the method is called); + else, invocation of the delegate calls the exact specified (this is useful for calling base class methods) + Note: if false and is an interface method, an ArgumentException is thrown. + + + Only applies for instance methods, and if argument is null. + This argument only matters if the target signature contains a value type (such as struct or primitive types), + and your argument is replaced by a non-value type + (usually object) instead of using said value type. + Use this if the generic arguments of doesn't represent the delegate's + arguments, and calling this function fails + A delegate of given to given + + + Delegate invocation is more performant and more convenient to use than + at a one-time setup cost. + + + Works for both type of static and instance methods, both open and closed (a.k.a. unbound and bound) instance methods, + and both class and struct methods. + + + + + Creates a delegate for a given delegate definition, attributed with [] + The delegate Type, attributed with [] + + Only applies for instance methods. If null (default), returned delegate is an open (a.k.a. unbound) instance delegate + where an instance is supplied as the first argument to the delegate invocation; else, delegate is a closed (a.k.a. bound) + instance delegate where the delegate invocation always applies to the given . + + A delegate of given to the method specified via [] + attributes on + + This calls with the method and virtualCall arguments + determined from the [] attributes on , + and the given (for closed instance delegates). + + + + Returns who called the current method + The calling method/constructor (excluding the caller) + + + Rethrows an exception while preserving its stack trace (throw statement typically clobbers existing stack traces) + The exception to rethrow + + + True if the current runtime is based on Mono, false otherwise (.NET) + + + True if the current runtime is .NET Framework, false otherwise (.NET Core or Mono, although latter isn't guaranteed) + + + True if the current runtime is .NET Core, false otherwise (Mono or .NET Framework) + + + Throws a missing member runtime exception + The type that is involved + A list of names + + + Gets default value for a specific type + The class/type + The default value + + + Creates an (possibly uninitialized) instance of a given type + The class/type + The new instance + + + Creates an (possibly uninitialized) instance of a given type + The class/type + The new instance + + + + A cache for the or similar Add methods for different types. + + + + Makes a deep copy of any object + The type of the instance that should be created; for legacy reasons, this must be a class or interface + The original object + A copy of the original object but of type T + + + Makes a deep copy of any object + The type of the instance that should be created + The original object + [out] The copy of the original object + Optional value transformation function (taking a field name and src/dst instances) + The optional path root to start with + + + Makes a deep copy of any object + The original object + The type of the instance that should be created + Optional value transformation function (taking a field name and src/dst instances) + The optional path root to start with + The copy of the original object + + + Tests if a type is a struct + The type + True if the type is a struct + + + Tests if a type is a class + The type + True if the type is a class + + + Tests if a type is a value type + The type + True if the type is a value type + + + Tests if a type is an integer type + The type + True if the type represents some integer + + + Tests if a type is a floating point type + The type + True if the type represents some floating point + + + Tests if a type is a numerical type + The type + True if the type represents some number + + + Tests if a type is void + The type + True if the type is void + + + Test whether an instance is of a nullable type + Type of instance + An instance to test + True if instance is of nullable type, false if not + + + Tests whether a type or member is static, as defined in C# + The type or member + True if the type or member is static + + + Tests whether a type is static, as defined in C# + The type + True if the type is static + + + Tests whether a property is static, as defined in C# + The property + True if the property is static + + + Tests whether an event is static, as defined in C# + The event + True if the event is static + + + Calculates a combined hash code for an enumeration of objects + The objects + The hash code + + + Adds extensions to Type for a lot of AccessTools methods + + + Enumerates all inner types (non-recursive) + The class/type to start with + An enumeration of all inner + + + Applies a function going up the type hierarchy and stops at the first non-null result + Result type of func() + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + The type hierarchy of a class or value type (including struct) does NOT include implemented interfaces, + and the type hierarchy of an interface is only itself (regardless of whether that interface implements other interfaces). + The top-most type in the type hierarchy of all non-interface types (including value types) is . + + + + Applies a function going into inner types and stops at the first non-null result + Generic type parameter + The class/type to start with + The evaluation function returning T + The first non-null result, or null if no match + + + Gets the reflection information for a directly declared field + The class/type where the field is defined + The name of the field + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a field by searching the type and all its super types + The class/type where the field is defined + The name of the field (case sensitive) + A field or null when type/name is null or when the field cannot be found + + + Gets the reflection information for a field + The class/type where the field is declared + The zero-based index of the field inside the class definition + A field or null when type is null or when the field cannot be found + + + Gets the reflection information for a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for the setter method of a directly declared property + The class/type where the property is declared + The name of the property (case sensitive) + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of a directly declared indexer property + The class/type where the indexer property is declared + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when indexer property cannot be found + + + Gets the reflection information for a property by searching the type and all its super types + The class/type + The name + A property or null when type/name is null or when the property cannot be found + + + Gets the reflection information for an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + An indexer property or null when type is null or when it cannot be found + + + Gets the reflection information for the getter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the getter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for the setter method of a property by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the property cannot be found + + + Gets the reflection information for the setter method of an indexer property by searching the type and all its super types + The class/type + Optional parameters to target a specific overload of multiple indexers + A method or null when type is null or when the indexer property cannot be found + + + Gets the reflection information for a directly declared event + The class/type where the event is declared + The name of the event (case sensitive) + An event or null when type/name is null or when the event cannot be found + + + Gets the reflection information for an event by searching the type and all its super types + The class/type + The name + An event or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the add method of a directly declared event + The class/type where the event is declared + The name of the event (case sensitive) + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the add method of an event by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the remove method of a directly declared event + The class/type where the event is declared + The name of the event (case sensitive) + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for the remove method of an event by searching the type and all its super types + The class/type + The name + A method or null when type/name is null or when the event cannot be found + + + Gets the reflection information for a finalizer + The class/type that defines the finalizer + A method or null when type is null or when the finalizer cannot be found + + + Gets the reflection information for a directly declared finalizer + The class/type that defines the finalizer + A method or null when type is null or when the finalizer cannot be found + + + Gets the reflection information for a directly declared method + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the reflection information for a method by searching the type and all its super types + The class/type where the method is declared + The name of the method (case sensitive) + Optional parameters to target a specific overload of the method + Optional list of types that define the generic version of the method + A method or null when type/name is null or when the method cannot be found + + + Gets the names of all method that are declared in a type + The declaring class/type + A list of method names + + + Gets the names of all fields that are declared in a type + The declaring class/type + A list of field names + + + Gets the names of all properties that are declared in a type + The declaring class/type + A list of property names + + + Gets the reflection information for a directly declared constructor + The class/type where the constructor is declared + Optional parameters to target a specific overload of the constructor + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the constructor cannot be found + + + Gets the reflection information for a constructor by searching the type and all its super types + The class/type where the constructor is declared + Optional parameters to target a specific overload of the method + Optional parameters to only consider static constructors + A constructor info or null when type is null or when the method cannot be found + + + Gets reflection information for all declared constructors + The class/type where the constructors are declared + Optional parameters to only consider static constructors + A list of constructor infos + + + Gets reflection information for all declared methods + The class/type where the methods are declared + A list of methods + + + Gets reflection information for all declared properties + The class/type where the properties are declared + A list of properties + + + Gets reflection information for all declared fields + The class/type where the fields are declared + A list of fields + + + Given a type, returns the first inner type matching a recursive search by name + The class/type to start searching at + The name of the inner type (case sensitive) + The inner type or null if type/name is null or if a type with that name cannot be found + + + Given a type, returns the first inner type matching a recursive search with a predicate + The class/type to start searching at + The predicate to search with + The inner type or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first method matching a predicate + The class/type to start searching at + The predicate to search with + The method or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first constructor matching a predicate + The class/type to start searching at + The predicate to search with + The constructor info or null if type/predicate is null or if a type with that name cannot be found + + + Given a type, returns the first property matching a predicate + The class/type to start searching at + The predicate to search with + The property or null if type/predicate is null or if a type with that name cannot be found + + + Creates a field reference delegate for an instance field of a class or static field (NOT an instance field of a struct) + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + + The type that defines the field, or derived class of this type; must not be a struct type unless the field is static + + The name of the field + + A readable/assignable delegate with T=object + (for static fields, the instance delegate parameter is ignored) + + + + This method is meant for cases where the given type is only known at runtime and thus can't be used as a type parameter T + in e.g. . + + + This method supports static fields, even those defined in structs, for legacy reasons. + Consider using (and other overloads) instead for static fields. + + + + + Creates a static field reference + + The type of the field; or if the field's type is a reference type (a class or interface, NOT a struct or other value type), + a type that is assignable from that type; or if the field's type is an enum type, + either that type or the underlying integral type of that enum type + + The type (can be class or struct) the field is defined in + The name of the field + A readable/assignable reference to the field + + + Throws a missing member runtime exception + The type that is involved + A list of names + + + Gets default value for a specific type + The class/type + The default value + + + Creates an (possibly uninitialized) instance of a given type + The class/type + The new instance + + + Tests if a type is a struct + The type + True if the type is a struct + + + Tests if a type is a class + The type + True if the type is a class + + + Tests if a type is a value type + The type + True if the type is a value type + + + Tests if a type is an integer type + The type + True if the type represents some integer + + + Tests if a type is a floating point type + The type + True if the type represents some floating point + + + Tests if a type is a numerical type + The type + True if the type represents some number + + + Tests if a type is void + The type + True if the type is void + + + Tests whether a type is static, as defined in C# + The type + True if the type is static + + + + By adding the following using statement to your source code: using static HarmonyLib.Code; + you can for example start using Ldarg_1 in you code instead of new CodeMatch(OpCodes.Ldarg_1) + and then you can use array notation to add an operand and/or a name: Call[myMethodInfo] instead of new CodeMatch(OpCodes.Call, myMethodInfo) + + + A CodeInstruction match + + + The name of the match + + + The matched opcodes + + + The matched opcodes + + + The matched operands + + + The jumps from the match + + + The jumps to the match + + + The match predicate + + + Creates a code match + The optional opcode + The optional operand + The optional name + + + Creates a code match + The opcodes + The optional operand + The optional name + + + Creates a code match that calls a method + The lambda expression using the method + The optional name + + + Creates a code match that calls a method + The lambda expression using the method + The optional name + + + Creates a code match + The CodeInstruction + An optional name + + + Creates a code match + The predicate + An optional name + + + Tests for any form of Ldarg* + The (optional) index + A new code match + + + Tests for Ldarga/Ldarga_S + The (optional) index + A new code match + + + Tests for Starg/Starg_S + The (optional) index + A new code match + + + Tests for any form of Ldloc* + The optional local variable + A new code match + + + Tests for any form of Stloc* + The optional local variable + A new code match + + + Tests if the code instruction calls the method/constructor + The method + A new code match + + + Tests if the code instruction loads a constant + A new code match + + + Tests if the code instruction loads an integer constant + The integer constant + A new code match + + + Tests if the code instruction loads a floating point constant + The floating point constant + A new code match + + + Tests if the code instruction loads an enum constant + The enum + A new code match + + + Tests if the code instruction loads a string constant + The string + A new code match + + + Tests if the code instruction loads a field + The field + Set to true if the address of the field is loaded + A new code match + + + Tests if the code instruction stores a field + The field + A new code match + + + Creates a code match that calls a method + The lambda expression using the method + A new code match + + + Creates a code match that calls a method + The lambda expression using the method + A new code match + + + Creates a code match for local loads + Whether to match for address loads + An optional name + A new code match + + + Creates a code match for local stores + An optional name + A new code match + + + Creates a code match for argument loads + Whether to match for address loads + An optional name + A new code match + + + Creates a code match for argument stores + An optional name + A new code match + + + Creates a code match for branching + An optional name + A new code match + + + Returns a string that represents the match + A string representation + + + A CodeInstruction matcher + + + Delegate for error handling + The current code matcher + The error message + True if the error should be suppressed and the matcher should continue (if possible) + + + The current position + The index or -1 if out of bounds + + + Gets the number of code instructions in this matcher + The count + + + Checks whether the position of this CodeMatcher is within bounds + True if this CodeMatcher is valid + + + Checks whether the position of this CodeMatcher is outside its bounds + True if this CodeMatcher is invalid + + + Gets the remaining code instructions + The remaining count + + + Gets the opcode at the current position + The opcode + + + Gets the operand at the current position + The operand + + + Gets the labels at the current position + The labels + + + Gets the exception blocks at the current position + The blocks + + + Creates an empty code matcher + + + Creates a code matcher from an enumeration of instructions + The instructions (transpiler argument) + An optional IL generator + + + Makes a clone of this instruction matcher + A copy of this matcher + + + Resets the current position to -1 and clears last matches and errors + If true, sets position to 0, otherwise sets it to -1 + The same code matcher + + + Gets instructions at the current position + The instruction + + + Gets instructions at the current position with offset + The offset + The instruction + + + Gets all instructions + A list of instructions + + + Gets all instructions as an enumeration + A list of instructions + + + Gets some instructions counting from current position + Number of instructions + A list of instructions + + + Gets all instructions within a range + The start index + The end index + A list of instructions + + + Gets all instructions within a range (relative to current position) + The start offset + The end offset + A list of instructions + + + Gets a list of all distinct labels + The instructions (transpiler argument) + A list of Labels + + + Reports a failure + The method involved + The logger + True if current position is invalid and error was logged + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed) + Explanation of where/why the exception was thrown that will be added to the exception message + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the matches do not match at current position + Explanation of where/why the exception was thrown that will be added to the exception message + Some code matches + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the matches do not match at any point between current position and the end + Explanation of where/why the exception was thrown that will be added to the exception message + Some code matches + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the matches do not match at any point between current position and the start + Explanation of where/why the exception was thrown that will be added to the exception message + Some code matches + The same code matcher + + + Throw an InvalidOperationException if current state is invalid (position out of bounds / last match failed), + or if the check function returns false + Explanation of where/why the exception was thrown that will be added to the exception message + Function that checks validity of current state. If it returns false, an exception is thrown + The same code matcher + + + Runs some code when chaining at the current position + The to run + The same code matcher + + + Registers an error handler that is invoked instead of throwing an exception + The to register or null to remove the current handler + The same code matcher + + + Sets an instruction at current position + The instruction to set + The same code matcher + + + Sets instruction at current position and advances + The instruction + The same code matcher + + + Sets opcode and operand at current position + The opcode + The operand + The same code matcher + + + Sets opcode and operand at current position and advances + The opcode + The operand + The same code matcher + + + Sets opcode at current position and advances + The opcode + The same code matcher + + + Sets operand at current position and advances + The operand + The same code matcher + + + Declares a local variable but does not add it + The variable type + [out] The new local variable + The same code matcher + + + Declares a new label but does not add it + [out] The new label + The same code matcher + + + Creates a label at current position + [out] The label + The same code matcher + + + Creates a label at a position + The position + [out] The new label + The same code matcher + + + Creates a label at the given offset from the current position + The offset + [out] The new label + The same code matcher + + + Adds an enumeration of labels to current position + The labels + The same code matcher + + + Adds an enumeration of labels at a position + The position + The labels + The same code matcher + + + Sets jump to + Branch instruction + Destination for the jump + [out] The created label + The same code matcher + + + Inserts some instructions at the current position + The instructions + The same code matcher + + + Inserts an enumeration of instructions at the current position + The instructions + The same code matcher + + + Inserts a branch at the current position + The branch opcode + Branch destination + The same code matcher + + + Inserts some instructions at the current position and advances it + The instructions + The same code matcher + + + Inserts an enumeration of instructions at the current position and advances it + The instructions + The same code matcher + + + Inserts a branch at the current position and advances it + The branch opcode + Branch destination + The same code matcher + + + Inserts instructions immediately after the current position + The instructions + The same code matcher + + + Inserts an enumeration of instructions immediately after the current position + The instructions + The same code matcher + + + Inserts a branch instruction immediately after the current position + The branch opcode + Branch destination index + The same code matcher + + + Inserts instructions immediately after the current position and advances to the last inserted instruction + The instructions + The same code matcher + + + Inserts an enumeration of instructions immediately after the current position and advances to the last inserted instruction + The instructions + The same code matcher + + + Inserts a branch instruction immediately after the current position and advances the position + The branch opcode + Branch destination index + The same code matcher + + + Removes current instruction + The same code matcher + + + Removes some instruction from current position by count + Number of instructions + The same code matcher + + + Removes the instructions in a range + The start + The end + The same code matcher + + + Removes the instructions in an offset range + The start offset + The end offset + The same code matcher + + + Advances the current position + The offset + The same code matcher + + + Moves the current position to the start + The same code matcher + + + Moves the current position to the end + The same code matcher + + + Searches forward with a predicate and advances position + A function to test each instruction for a match + The same code matcher + + + Searches backwards with a predicate and moves the position + A function to test each instruction for a match + The same code matcher + + + Matches forward and advances position to beginning of matching sequence + Some code matches + The same code matcher + + + Prepares matching forward and advancing position to beginning of matching sequence + Some code matches + The same code matcher + + + Matches forward and advances position to ending of matching sequence + Some code matches + The same code matcher + + + Prepares matching forward and advancing position to ending of matching sequence + Some code matches + The same code matcher + + + Matches backwards and moves the position to beginning of matching sequence + Some code matches + The same code matcher + + + Prepares matching backwards and reversing position to beginning of matching sequence + Some code matches + The same code matcher + + + Matches backwards and moves the position to ending of matching sequence + Some code matches + The same code matcher + + + Prepares matching backwards and reversing position to ending of matching sequence + Some code matches + The same code matcher + + + Removes instructions from the current position forward until a predicate is matched. The matched instruction is not removed + A function to test each instruction for a match + The same code matcher + + + Removes instructions from the current position backward until a predicate is matched. The matched instruction is not removed + A function to test each instruction for a match + The same code matcher + + + Removes instructions from the current position up to the next match (exclusive) + Some code matches + The same code matcher + + + Removes instructions backwards from the current position to the previous match (exclusive) + Some code matches + The same code matcher + + + Repeats a match action until boundaries are met + The match action + An optional action that is executed when no match is found + The same code matcher + + + Gets a match by its name + The match name + An instruction + + + General extensions for common cases + + + Joins an enumeration with a value converter and a delimiter to a string + The inner type of the enumeration + The enumeration + An optional value converter (from T to string) + An optional delimiter + The values joined into a string + + + Converts an array of types (for example methods arguments) into a human readable form + The array of types + A human readable description including brackets + + + A full description of a type + The type + A human readable description + + + A a full description of a method or a constructor without assembly details but with generics + The method/constructor + A human readable description + + + A helper converting parameter infos to types + The array of parameter infos + An array of types + + + Tests if a type has the + The class/type to test + True if the type has the + + + A helper to access a value via key from a dictionary + The key type + The value type + The dictionary + The key + The value for the key or the default value (of T) if that key does not exist + + + A helper to access a value via key from a dictionary with extra casting + The value type + The dictionary + The key + The value for the key or the default value (of T) if that key does not exist or cannot be cast to T + + + Escapes Unicode and ASCII non printable characters + The string to convert + The string to convert + A string literal surrounded by + + + Extensions for + + + Returns if an is initialized and valid + The + + + + Shortcut for testing whether the operand is equal to a non-null value + The + The value + True if the operand has the same type and is equal to the value + + + Shortcut for testing whether the operand is equal to a non-null value + The + The value + True if the operand is equal to the value + This is an optimized version of for + + + Shortcut for code.opcode == opcode && code.OperandIs(operand) + The + The + The operand value + True if the opcode is equal to the given opcode and the operand has the same type and is equal to the given operand + + + Shortcut for code.opcode == opcode && code.OperandIs(operand) + The + The + The operand value + True if the opcode is equal to the given opcode and the operand is equal to the given operand + This is an optimized version of for + + + Tests for any form of Ldarg* + The + The (optional) index + True if it matches one of the variations + + + Tests for Ldarga/Ldarga_S + The + The (optional) index + True if it matches one of the variations + + + Tests for Starg/Starg_S + The + The (optional) index + True if it matches one of the variations + + + Tests for any form of Ldloc* + The + The optional local variable + True if it matches one of the variations + + + Tests for any form of Stloc* + The + The optional local variable + True if it matches one of the variations + + + Tests if the code instruction branches + The + The label if the instruction is a branch operation or if not + True if the instruction branches + + + Tests if the code instruction calls the method/constructor + The + The method + True if the instruction calls the method or constructor + + + Tests if the code instruction loads a constant + The + True if the instruction loads a constant + + + Tests if the code instruction loads an integer constant + The + The integer constant + True if the instruction loads the constant + + + Tests if the code instruction loads a floating point constant + The + The floating point constant + True if the instruction loads the constant + + + Tests if the code instruction loads an enum constant + The + The enum + True if the instruction loads the constant + + + Tests if the code instruction loads a string constant + The + The string + True if the instruction loads the constant + + + Tests if the code instruction loads a field + The + The field + Set to true if the address of the field is loaded + True if the instruction loads the field + + + Tests if the code instruction stores a field + The + The field + True if the instruction stores this field + + + Returns the index targeted by this ldloc, ldloca, or stloc + The + The index it targets + + + + + Returns the index targeted by this ldarg, ldarga, or starg + The + The index it targets + + + + + Adds labels to the code instruction and return it + The + One or several to add + The same code instruction + + + Adds labels to the code instruction and return it + The + An enumeration of + The same code instruction + + + Extracts all labels from the code instruction and returns them + The + A list of + + + Moves all labels from the code instruction to another one + The to move the labels from + The other to move the labels to + The code instruction labels were moved from (now empty) + + + Moves all labels from another code instruction to the current one + The to move the labels to + The other to move the labels from + The code instruction that received the labels + + + Adds ExceptionBlocks to the code instruction and return it + The + One or several to add + The same code instruction + + + Adds ExceptionBlocks to the code instruction and return it + The + An enumeration of + The same code instruction + + + Extracts all ExceptionBlocks from the code instruction and returns them + The + A list of + + + Moves all ExceptionBlocks from the code instruction to another one + The to move the ExceptionBlocks from + The other to move the ExceptionBlocks to + The code instruction blocks were moved from (now empty) + + + Moves all ExceptionBlocks from another code instruction to the current one + The to move the ExceptionBlocks to + The other to move the ExceptionBlocks from + The code instruction that received the blocks + + + Extensions for a sequence of + + + Searches a list of by running a sequence of against it + The CodeInstructions (like a body of a method) to search in + An array of representing the sequence of codes you want to search for + + + + General extensions for collections + + + A simple way to execute code for every element in a collection + The inner type of the collection + The collection + The action to execute + + + A simple way to execute code for elements in a collection matching a condition + The inner type of the collection + The collection + The predicate + The action to execute + + + A helper to add an item to a collection + The inner type of the collection + The collection + The item to add + The collection containing the item + + + A helper to add an item to an array + The inner type of the collection + The array + The item to add + The array containing the item + + + A helper to add items to an array + The inner type of the collection + The array + The items to add + The array containing the items + + + General extensions for collections + + + Tests a class member if it has an IL method body (external methods for example don't have a body) + The member to test + Returns true if the member has an IL body or false if not + + + A file log for debugging + + + Set this to make Harmony write its log content to this stream + + + Full pathname of the log file, defaults to a file called harmony.log.txt on your Desktop + + + The indent character. The default is tab + + + The current indent level + + + Changes the indentation level + The value to add to the indentation level + + + Log a string in a buffered way. Use this method only if you are sure that FlushBuffer will be called + or else logging information is incomplete in case of a crash + The string to log + + + Logs a list of string in a buffered way. Use this method only if you are sure that FlushBuffer will be called + or else logging information is incomplete in case of a crash + A list of strings to log (they will not be re-indented) + + + Returns the log buffer and optionally empties it + True to empty the buffer + The buffer. + + + Replaces the buffer with new lines + The lines to store + + + Flushes the log buffer to disk (use in combination with LogBuffered) + + + Logs a string directly to disk to avoid losing information in case of a crash + The string to log. + + + Logs an inline comment at the specified code position + This method formats the comment with the code position and logs it. + The position in the code where the comment should be logged. + The comment text to log. Cannot be null or empty. + + + Logs the specified Intermediate Language (IL) operation code and its position in the code stream + This method formats the IL operation code and its position into a string and logs it. + The position of the IL operation code in the code stream. + The IL operation code to log. + + + Logs information about an Intermediate Language (IL) instruction, including its position, opcode, and operand + This method formats and logs details about an IL instruction for debugging or analysis purposes. + The logged output includes the instruction's position, opcode, and operand (if any). + The position of the IL instruction within the method body. + The representing the operation to be performed. + The operand associated with the IL instruction, or if the instruction has no operand. + + + Logs information about a local variable in Intermediate Language (IL) code + The logged information includes the variable's index, type, and whether it is pinned. + The representing the local variable to log. Must not be . + + + Logs the intermediate language (IL) code at the specified position with the given label operand + Formats and logs the IL code position and label operand for detailed IL tracking or debugging. + The position in the IL code to log. + The label operand associated with the IL code to log. + + + Logs the beginning of an intermediate language (IL) exception handling block + Logs the start of an exception handling block (e.g., .try, .catch, .finally, .fault), + adjusts indentation, and simulates a LEAVE opcode for consistency. + The position of the IL code where the block begins. + The representing the type of exception handling block to log. This includes + information about the block type (e.g., try, catch, finally) and any associated metadata. + + + Logs the end of an intermediate language (IL) exception block + This method handles the logging of specific types of exception blocks, such as the end of a try-catch or + similar constructs. It adjusts the indentation level and outputs relevant information about the block's conclusion. + The position in the IL code where the block ends. + The exception block to log. Must have a valid block type. + + + Log a string directly to disk if Harmony.DEBUG is true. Slower method that prevents missing information in case of a crash + The string to log. + + + Resets and deletes the log + + + Logs some bytes as hex values + The pointer to some memory + The length of bytes to log + + + A helper class to retrieve reflection info for non-private methods + + + Given a lambda expression that calls a method, returns the method info + The lambda expression using the method + The method in the lambda expression + + + Given a lambda expression that calls a method, returns the method info + The generic type + The lambda expression using the method + The method in the lambda expression + + + Given a lambda expression that calls a method, returns the method info + The generic type + The generic result type + The lambda expression using the method + The method in the lambda expression + + + Given a lambda expression that calls a method, returns the method info + The lambda expression using the method + The method in the lambda expression + + + A reflection helper to read and write private elements + The result type defined by GetValue() + + + Creates a traverse instance from an existing instance + The existing instance + + + Gets/Sets the current value + The value to read or write + + + A reflection helper to read and write private elements + + + Creates a new traverse instance from a class/type + The class/type + A instance + + + Creates a new traverse instance from a class T + The class + A instance + + + Creates a new traverse instance from an instance + The object + A instance + + + Creates a new traverse instance from a named type + The type name, for format see + A instance + + + Creates a new and empty traverse instance + + + Creates a new traverse instance from a class/type + The class/type + + + Creates a new traverse instance from an instance + The object + + + Gets the current value + The value + + + Gets the current value + The type of the value + The value + + + Invokes the current method with arguments and returns the result + The method arguments + The value returned by the method + + + Invokes the current method with arguments and returns the result + The type of the value + The method arguments + The value returned by the method + + + Sets a value of the current field or property + The value + The same traverse instance + + + Gets the type of the current field or property + The type + + + Checks if the current traverse instance is for a field + True if its a field + + + Checks if the current traverse instance is for a property + True if its a property + + + Checks if the current field or property is writeable + True if writing is possible + + + Moves the current traverse instance to a inner type + The type name + A traverse instance + + + Moves the current traverse instance to a field + The type name + A traverse instance + + + Moves the current traverse instance to a field + The type of the field + The type name + A traverse instance + + + Gets all fields of the current type + A list of field names + + + Moves the current traverse instance to a property + The type name + Optional property index + A traverse instance + + + Moves the current traverse instance to a field + The type of the property + The type name + Optional property index + A traverse instance + + + Gets all properties of the current type + A list of property names + + + Moves the current traverse instance to a method + The name of the method + The arguments defining the argument types of the method overload + A traverse instance + + + Moves the current traverse instance to a method + The name of the method + The argument types of the method + The arguments for the method + A traverse instance + + + Gets all methods of the current type + A list of method names + + + Checks if the current traverse instance is for a field + True if its a field + + + Checks if the current traverse instance is for a property + True if its a property + + + Checks if the current traverse instance is for a method + True if its a method + + + Checks if the current traverse instance is for a type + True if its a type + + + Iterates over all fields of the current type and executes a traverse action + Original object + The action receiving a instance for each field + + + Iterates over all fields of the current type and executes a traverse action + Original object + Target object + The action receiving a pair of instances for each field pair + + + Iterates over all fields of the current type and executes a traverse action + Original object + Target object + The action receiving a dot path representing the field pair and the instances + + + Iterates over all properties of the current type and executes a traverse action + Original object + The action receiving a instance for each property + + + Iterates over all properties of the current type and executes a traverse action + Original object + Target object + The action receiving a pair of instances for each property pair + + + Iterates over all properties of the current type and executes a traverse action + Original object + Target object + The action receiving a dot path representing the property pair and the instances + + + A default field action that copies fields to fields + + + Returns a string that represents the current traverse + A string representation + + + \ No newline at end of file