All Classes and Interfaces
Class
Description
Defines an accessor method in a mixin, the method can be a getter (must
return the field type and take no arguments) or a setter (must take an
argument of the field type and return void).
Base class for accessor generators
Accessor generator for field accessors
Generator for instance field getters
Generator for field setters
Generator for proxy methods
Generator for factory methods (constructor invokers)
Information about an accessor
Accessor Name struct
Accessor types
Tracker for processors which want to express their activity stack on crash in
a user-readable way.
This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and
INVOKESPECIAL opcodes matching its arguments and returns a list of insns
after the matching instructions, with special handling for methods
invocations which return a value and immediately assign it to a local
variable.
This injection point is a companion for the
ModifyVariable
injector which searches for STORE operations which match the local variables
described by the injector's defined discriminators.Data bundle for an annotated method in a mixin
Utility class for working with ASM annotations
Wrapper for
AnnotationNode to support access via common interfaceDecoration which stores a linear offset of arguments when a node replacement
results in a call to a method with the same arguments as the original
(replaced) call but offset by some fixed amount.
Argument bundle class used in
ModifyArgs callbacks.Class generator which creates subclasses of
Args to be used by the
ModifyArgs injector.Exception thrown when varargs array passed into
Args.setAll(java.lang.Object...)
is of a different length than the argsException thrown when attempting to set an argument (via)
Args which
is out of boundsUtility methods for determining ASM version and other version-specific
shenanigans
Annotation for specifying the type of
InjectionPoint to use to
perform an Inject process.Shift is used to shift resulting opcodes
Special injection point which can be defined by an
Constant
annotation or using the at code CONSTANT.This injection point searches for GETFIELD and PUTFIELD (and static
equivalent) opcodes matching its arguments and returns a list of insns
immediately prior to matching instructions.
This injection point searches for the last RETURN opcode in the target
method and returns it.
This injection point searches for INVOKEVIRTUAL, INVOKESTATIC and
INVOKESPECIAL opcodes matching its arguments and returns a list of insns
immediately prior to matching instructions.
Member search type, the PERMISSIVE search is only used when
refmap remapping is enabled.
This injection point is a companion for the
ModifyVariable
injector which searches for LOAD operations which match the local variables
described by the injector's defined discriminators.This injection point searches for NEW opcodes matching its arguments and
returns a list of insns immediately prior to matching instructions.
This injection point searches for RETURN opcodes in the target method and
returns a list of insns immediately prior to matching instructions.
Like
BeforeInvoke, this injection point searches for
INVOKEVIRTUAL, INVOKESTATIC and INVOKESPECIAL opcodes matching its arguments
and returns a list of insns immediately prior to matching instructions.Utility methods for working with bytecode via ASM
Information bundle returned from
Bytecode.findDelegateInit(org.objectweb.asm.tree.MethodNode, java.lang.String, java.lang.String)Ordinal member visibility level.
CallbackInfo instances are passed to callbacks in order to provide
information and handling opportunities to the callback to interact with the
callback itself.
For callbacks with a non-void return type, a CallbackInfoReturnable is passed
to the callback instead to allow the callback to interact with the method
return value.
Information about a callback to inject, usually specified by
InjectThis class is responsible for generating the bytecode for injected callbacks,
for details of usage see
@Inject.Interface for things which can be cancelled
Exception thrown when a consumer attemtps to call cancel() on a
callback not marked as cancellable.
Information about a class, used as a way of keeping track of class hierarchy
information needed to support more complex mixin behaviour such as detached
superclass and mixin inheritance.
Information about frames in a method
Search type for the findInHierarchy methods, replaces a boolean flag
which made calling code difficult to read
To all intents and purposes, the "real" class hierarchy and the mixin
class hierarchy exist in parallel, this means that for some hierarchy
validation operations we need to walk across to the other
hierarchy in order to allow meaningful validation to occur.
When using
ClassInfo.forType, determines
whether an array type should be returned as declared (eg.Adapter for ClassNode to access members added after ASM 5
Represents an object-oriented view of a generic class signature.
Usage with callback injectors (@Inject)
Options passed in to Mixin via the command line
Handle for marshalling mixin configs outside of the transformer package
Annotation for specifying the injection point for an
ModifyConstant
injector.Available options for the
Constant.expandZeroConditions() setting.Miscellaneous shared constants
Shared Jar Manifest Attributes
Parser for constraints
A constraint.
A
Target which is a constructorLike
HEAD, this injection point can be used to specify
the first instruction in a method, but provides special handling for
constructors.Container handle which directly replaces the use of classpath location URIs
from previous mixin versions
A virtual container, used to marshal other containers around
Mutable integer for use in collections
Anotation used to decorate items you might wish to examine after mixin
application.
A descriptor for matching a target element, for details of usage see
DynamicSelectorDesc.Utility class which contains the logic for resolving descriptors
(
Desc annotations) starting from an element and recursing up the tree
of parent elements looking for a matching descriptorCollection type for
Desc to allow Repeatable to work.Decorator annotation for mixin elements whose targets are not available in
the original class and are either fabricated or transformed at runtime.
A
Target Selector which matches candidates using
descriptors contained in @Desc annotations.Wrapper for all node types supported by
target
selectors (FieldNode, MethodNode, FieldInsnNode,
MethodInsnNode and InvokeDynamicInsnNode) which allows access
to common properties of things which are basically "arbitrary node with
owner, name and descriptor"Element node type, returned by getType so consumers don't need
to do instanceof checks, and allows switching on element type in a more
expressive way
Mixin transformer module which runs CheckClassAdapter on the post-mixin
bytecode
Exception thrown when checkclass fails
Checks whether interfaces declared on mixin target classes are actually fully
implemented and generates reports to the console and to files on disk
Debug exporter
Strips synthetic local variables from the LVT after exporting to avoid debuggers becoming confused by them.
Mixin transformer extensions and common modules such as class generators
Utility class for file operations
This annotation has two uses:
On an
Shadow field, it can be used to raise an error-level log
message if any write occurrences appear in the mixin bytecode.Access to underlying global property service provided by the current
environment
Global property keys
This annotation can be used on any injector callback to define a value for
total required injections across multiple callbacks.
Utility class for working with method and field handles
Interface for objects which can be annotated since main classes may need to
read info from mirror annotations in the AP
Interface for annotation handle since some classes may need to read info from
both ASM
AnnotationNodes at runtime and mirror annotations in the AP
at compile time.An InjectionNode decoration which can chain to a previously registered
decoration with the same type and key.
Interface for object which can provide class bytecode
Base interface for class generators
Interface for marshal object which can retrieve classes from the environment
Class trackers are responsible for interacting with the class loading process
to for the purposes of tracking class load activity and class load
restrictions.
No Java 8 here but I need this interface
Interface for container handles.
Interface to allow the actual decompiler to be loaded on-demand
Provides a token value into the attached environment
Mixin Transformer extension interface for pre- and post-processors
Interface for the mixin Extensions registry
Global property service
Interface to allow the hot-swap agent to be loaded on-demand
Context for an injection point, used to access the mixin as well as the owner
method and annotation for the injection point
Interface for extensions for InsnList which provide additional context for
the InsnList.
Type of special nodes supported by
IInsnListEx.getSpecialNode(org.spongepowered.asm.mixin.injection.code.IInsnListEx.SpecialNodeType)Adapter interface for legacy class transformers.
Interface extracted from Log4j2's Logger (org.apache.logging.log4j.Logger
) with only the main methods used by Mixin included.
Base class for member mapping entries
Type of mapping
Interface for generic message consumers
Audit trail is responsible for logging activities during mixin application to
target classes for use as debugging information later on.
Interface for loaded mixin configurations
A companion plugin for a mixin configuration object.
Interface for loaded mixin configurations
A connector class is a bootstrap agent for a mixin consumer.
Context for performing reference mapping
Interface for objects which want to perform custom behaviour when fatal mixin
errors occur.
Action to take when handling an error.
Interface for MixinInfo, used in extensibility API
A mixin internal part, offered to services.
Base interface for platform agents.
Service agents provide additional platform-specific extensions leveraged by
mixin services.
Mixin Service interface.
Bootstrap interface for Mixin services.
Transformation engine
Factory for the mixin transformer, concrete instances of this class are only
provided to services since only the service should be able to decide when the
mixin transformer is initialised.
Pseudo-implements decorator for Mixins with conflicting methods in a
superclass to soft-implement an interface.
Strategy for injecting initialiser insns
Specifies that this mixin method should inject a callback (or
callbacks) to itself in the target method(s) identified by
Inject.method().Contructs information about an injection from an
Inject annotation
and allows the injection to be processed.Decoration for subclasses which indicates the injector annotation that
the subclass handles
Decoration for subclasses which specifies the prefix to use when
conforming annotated handler methods
Decoration for subclasses which specifies the order (phase) in which the
injector should be applied relative to other injectors.
Used to keep track of instruction nodes in a
Target method which are
targetted by various types of injector.A node targetted by one or more injectors.
Base class for injection point discovery classes.
Injection point code for
At annotations to useBoolean extensions for the At parser, mainly to avoid having to add many
booleans in the future
Target restriction level for different injection point types when used
by restricted injectors (eg.
Additional specifier for injection points.
Specialised SelectorAnnotationContext for injection points
Data read from an
At annotation
and passed into an InjectionPoint ctorBase class for bytecode injectors
Redirection data bundle base.
A nominated target node
Information store for injector groups
Storage for injector groups
Couples
method slices to a Target for injection
purposes.Utility class for finding instructions using static analysis
InsnList with extensions, see
IInsnListExRead-only wrapper for InsnList, defensively passed to InjectionPoint
instances so that custom InjectionPoint implementations cannot modify the
insn list whilst inspecting it.
Struct for representing a range of instructions
This annotation is used to define information for a soft-implemented
interface.
Describes the remapping strategy applied to methods matching this
interface.
This annotation allows fine-tuning of the overwrite policy for a
soft-implemented interface member method.
Thrown when an implicit discriminator (no args) fails to identify
a unique candidate.
Thrown when a
MemberInfo fails basic syntax validationSince the contract of
TargetSelector.parse(java.lang.Iterable<?>, org.spongepowered.asm.mixin.injection.selectors.ISelectorContext) prohibits returing
null, instances of this selector are returned when supplied arguments
are unparseable in order to throw exceptions only during validation.Exception to be thrown from
ITargetSelector.validate() when a target
selector fails verificationBase class for injectors which inject at method invokes
Defines an invoker method (also known as a proxy method in
a mixin, the method.
Marker interface for property keys
Interface for reference mapper objects
Interface for remap chain participants
A resolved descriptor, or rather the result of resolving a descriptor.
Context passed to a
Target Selector in order to
support context-sensitive behaviour for the selector.Context for a slice declaration
Interface for information bundle about a synthetic class provided by Mixin.
Registry for synthetic classes, used internally to track which classes need
to be generated at runtime by the mixin pipeline.
Interface for target classes passed into transformer modules via
IExtensionTarget Selectors are used to identify target members in a class, with the
criteria for selection being specified in a single string, effectively
defining the query parameters.
Available selector reconfigurations
A target selector which selects elements directly by name.
A target selector which can identify constructor types
Decoration interface for dynamic target selectors
Decoration for subclasses which indicates an annotation type from which
the selector can be parsed.
Decoration for subclasses which indicates id used for a specific selector
when specified, for example @MyNamespace:MySelector(argshere)
would specify "MySelector"
A target selector which can be remapped at compile time via an obfuscation
service
Agent which can supply token values to a
ConstraintParser.Constraint.Base interface for transformer types
Interface for interacting with transforming classloaders.
Adapter interface for tree class transformers.
Small helper to resolve the current java version
This injection point searches for JUMP opcodes (if, try/catch, continue,
break, conditional assignment, etc.) with either a particular opcode or at a
particular ordinal in the method body (eg.
Bitmask values for language features supported.
Specifies the behaviour for capturing local variables at an injection point.
Utility methods for working with local variables using ASM
Settings for getLocalsAt containing the tunable options for the
algorithm.
A local variable entry added by mixin itself, eg.
Encapsulates logic for identifying a local variable in a target method using
3 criteria: ordinal, index and name.
Discriminator context information, wraps all relevant information about
a target location for use when performing discrimination
Abstract base adapter which contains a convenience class for formatting
log4j2-style messages and also routes all level-specific overloads to calls
to log, which can simplify some implementations.
This is a very naive implementation of log4j2's ParameterizedMessage
which is less efficient and less defensive because it doesn't need
to handle all the cases that the log4j2 formatter does.
A very basic logger adapter which does not log anything to file and simply
emits formatted log messages to the console printstreams
Default logger adapter which sinks log messages but doesn't emit them
anywhere, used only in cases where no logging framework is available and no
logging is desired.
Logger adapter which uses the built-in Java logging functionality to emit
logging messages.
"Main" attribute cache for a URI container, mainly to avoid constantly
opening jar files just to read odd values out of the manifest.
Stores information about a field mapping during AP runs
An SRG field mapping
Stores information about a method mapping during AP runs
A label node used as a marker in the bytecode.
Result of a
target selector match operation
which describes the type of match.Struct which defines an Explcit Target selector, See
ITargetSelector for other supported selector types.A
Target Selector which matches an element of
candidate members using a regular expression.Reference to a field or method that also includes invocation instructions.
A static reference to a field backed by field get/put instruction
A reference to a field or method backed by a method handle
A static reference to a method backed by an invoke instruction
Logging router for objects which may need to log messages during standard
runtime or during Annotation Processor sessions.
This injection point simply returns the first instruction in the target
method body, allowing the injection to be placed at the "head" of the target
method.
MethodNode with some extra convenience functionality
Stores information about a defined method slice for a particular injector.
Represents a collection of
MethodSlices, mapped by ID.MethodVisitor with some extra convenience functionality
The main decorator for mixin classes, this annotation denotes a class as a
mixin and specifies two key attributes:
The target classes
Every mixin requires at least one target class in order to be valid.
Bootstraps the mixin subsystem.
Handles delegation of class generation tasks to the extensions
A ClassReader which returns a more verbose exception message when the
incoming class major version is higher than the version supported by the
active ASM.
ClassWriter which resolves common superclasses using Mixin's metadata instead
of calling Class.forName
Manager for Mixin containers bootstrapping via
IMixinConnectorA collection of
IMixinPlatformAgent platform agents) for a particular
containerThe mixin environment manages global state information for the mixin
subsystem.
Operational compatibility level for the mixin subsystem
Mixin features which can be specified in mixin configs as required for
the config to be valid.
Mixin options
Environment phase, deliberately not implemented as an enum
Represents a "side", client or dedicated server
Error raised when mixin subsystem initialisation fails
Decoration annotation used by the mixin inner class generator to mark inner
classes which have been generated from an existing inner class in a mixin
For internal use only! Contains small parts.
Platform agent base class
Default platform agent, handles the mixin manifest keys such as
MixinConfigs and MixinTokenProviders.
Handler for platform-specific behaviour required in different mixin
environments.
Decoration annotation used by postprocessor to mark methods which have had
their contents replaced with a proxy.
Internal use only.
Entry point for registering global mixin resources.
Provides access to the service layer which connects the mixin transformer to
a particular host environment.
Mixin Service base class
This object keeps track of data for applying a mixin to a specific target
class during a mixin application.
Verifier which handles class info lookups via
ClassInfoSpecifies that this mixin method should inject an argument modifier to itself
in the target method(s) identified by
ModifyArg.method().Information about a
ModifyArg injectorA bytecode injector which allows a single argument of a chosen method call to
be altered.
Specifies that this mixin method should inject an multi-argument modifier
callback to itself in the target method(s) identified by
ModifyArgs.method().Information about a
ModifyArgs injectorA bytecode injector which allows a single argument of a chosen method call to
be altered.
Specifies that this mixin method should inject a constant modifier callback
to itself in the target method(s) identified by
ModifyConstant.method() at the
specified LDC (or specialised const opcode) instruction in order to adjust
the constant value returned.Information about a constant modifier injector
A bytecode injector which allows a specific constant value to be identified
and replaced with a callback.
Specifies that this mixin method should inject a variable modifier callback
to itself in the target method(s) identified by
ModifyVariable.method().Information about a
ModifyVariable injectorA bytecode injector which allows a single local variable in the target method
to be captured and altered.
See
@Desc.nextUtility methods for obfuscation tasks
Interface for remapper proxies
Annotation used to indicate a mixin class member which must overwrite a
method in the target class.
Prints information in a pretty box
Table column alignment
Interface for object which supports printing to pretty printer
Performance profiler for Mixin.
Base abstract profiler section.
A Mixin marked as @Pseudo is allowed to target classes which are
not available at compile time and may not be available at runtime.
A regex-style quantifier, specified as a number or pair of numbers in braces.
Specifies that this mixin method should redirect the specified
method call, field access or object construction (via the new
keyword) to the method decorated with this annotation.
Information about a redirector injector
A bytecode injector which allows a method call, field access or
new object creation to be redirected to the annotated handler
method.
Re-entrance semaphore used to share re-entrance data with the metadata
service
Stores runtime information allowing field, method and type references which
cannot be hard remapped by the reobfuscation process to be remapped in a
"soft" manner at runtime.
Mixin environment remapper chain.
This adapter is designed to apply the same remapping used elsewhere in
the development chain (RemapperChain) to reference maps.
Narrowed context for selectors in annotations which are themselves inside
a parent annotation, for example @At annotations within a parent
@Inject annotation.
Exception thrown when a service fails during initialisation, expected if the
service is missing a dependency or is attempting to boot in an incompatible
environment
Error to throw when no service is available in the current environment
Error to throw when loaded service is out of date or mismatched
Used to indicate a Mixin class member which is acting as a placeholder for a
method or field in the target class
Generates callback signature for callback pretty-print
A Slice identifies a section of a method to search for injection
points.
Decorator for methods which override a method in a supermixin which the
containing mixin does not directly extend
Structure which contains information about a SourceDebugExtension SMAP
Defines a source code file within a source map stratum
Information about a special mixin method such as an injector or accessor
A centralised list of tokens supported by the AP for use in
SuppressWarnings annotations.Annotation used to decorate surrogate injector methods.
Information bundle about a synthetic class provided by Mixin
Information about the current injection target (method) which bundles common
injection context with the target method in order to allow injectors to
interoperate.
Exception thrown when target selector is not valid for the supplied target
context during
ITargetSelector.attach(org.spongepowered.asm.mixin.injection.selectors.ISelectorContext)Utility class for parsing selectors
Query result struct
Selected target method, paired with the selector which identified it
Base class for transformers which work with ASM tree model
This annotation, when applied to a member method or field in a mixin,
indicates that the member should never overwrite a matching member in
the target class.
Represents a software version number in
major.minor.revision.build
format as a sequence of four shorts packed into a long.