Package org.spongepowered.asm.mixin.injection

Annotation Type Constant

  • @Target({})
@Retention(RUNTIME)
public @interface Constant
    Annotation for specifying the injection point for an ModifyConstant injector. Leaving all values unset causes the injection point to match all constants with the same type as the ModifyConstant handler's return type.

    To match a specific constant, specify the appropriate value for the appropriate argument. Specifying values of different types will cause an error to be raised by the injector.

    • Optional Element Summary

      Optional Elements 
      Modifier and Type Optional Element Description
      java.lang.Class<?> classValue
      Specify a type literal to match
      double doubleValue
      Specify a double constant to match
      Constant.Condition[] expandZeroConditions
      Whilst most constants can be located in the compiled method with relative ease, there exists a special case when a zero is used in a conditional expression.
      float floatValue
      Specify a float constant to match
      int intValue
      Specify an integer constant to match, includes byte and short values.
      boolean log  
      long longValue
      Specify a long constant to match
      boolean nullValue
      Causes this injector to match ACONST_NULL (null object) literals
      int ordinal
      Ordinal offset.
      java.lang.String slice
      This specifies the ID of the slice to use for this query.
      java.lang.String stringValue
      Specify a String constant to match

    • Element Detail

      • nullValue

        boolean nullValue
        Causes this injector to match ACONST_NULL (null object) literals
        Returns:
        true to match null
        Default:
        false

      • intValue

        int intValue
        Specify an integer constant to match, includes byte and short values.

        Special note for referencing 0 (zero) which forms part of a comparison expression: See the expandZeroConditions() option below.

        Returns:
        integer value to match
        Default:
        0

      • floatValue

        float floatValue
        Specify a float constant to match
        Returns:
        float value to match
        Default:
        0.0f

      • longValue

        long longValue
        Specify a long constant to match
        Returns:
        long value to match
        Default:
        0L

      • doubleValue

        double doubleValue
        Specify a double constant to match
        Returns:
        double value to match
        Default:
        0.0

      • stringValue

        java.lang.String stringValue
        Specify a String constant to match
        Returns:
        string value to match
        Default:
        ""

      • classValue

        java.lang.Class<?> classValue
        Specify a type literal to match
        Returns:
        type literal to match
        Default:
        java.lang.Object.class

      • ordinal

        int ordinal
        Ordinal offset. Many InjectionPoints will return every opcode matching their criteria, specifying ordinal allows a particular opcode to be identified from the returned list. The default value of -1 does not alter the behaviour and returns all matching opcodes. Specifying a value of 0 or higher returns only the requested opcode (if one exists: for example specifying an ordinal of 4 when only 2 opcodes are matched by the InjectionPoint is not going to work particularly well!)
        Returns:
        ordinal value for supported InjectionPoint types
        Default:
        -1

      • slice

        java.lang.String slice
        This specifies the ID of the slice to use for this query.

        For more details see the Slice.id()

        Returns:
        the slice identifier, or empty string to use the default slice
        Default:
        ""

      • expandZeroConditions

        Constant.Condition[] expandZeroConditions
        Whilst most constants can be located in the compiled method with relative ease, there exists a special case when a zero is used in a conditional expression. For example:
        if (x >= 0)

        This special case occurs because java includes explicit instructions for this type of comparison, and thus the compiled code might look more like this:

        if (x.isGreaterThanOrEqualToZero())

        Of course if we know that the constant we are searching for is part of a comparison, then we can explicitly search for the isGreaterThanOrEqualToZero and convert it back to the original form in order to redirect it just like any other constant access.

        To enable this behaviour, you may specify one or more values for this argument based on the type of expression you wish to expand. Since the Java compiler is wont to compile certain expressions as the inverse of their source-level counterparts (eg. compiling a do this if greater than structure to a ignore this if less than or equal structure); specifying a particular expression type implicitly includes the inverse expression as well.

        It is worth noting that the effect on ordinals may be hard to predict, and thus care should be taken to ensure that the selected injection points match the expected locations.

        Specifying this option has the following effects:

        • Matching conditional opcodes in the target method are identified for injection candidacy.
        • An intValue of 0 is implied and does not need to be explicitly defined.
        • However, explicitly specifying an intValue of 0 will cause this selector to also match explicit 0 constants in the method body as well.
        Default:
        {}

      • log

        boolean log
        Returns:
        true to enable verbose debug logging for this injection point
        Default:
        false