openrs2
/
openrs2
3
1
Fork 3
Code Issues 68 Pull Requests Releases Activity

Use smart casts in the AST deobfuscator

Browse Source 
Many of the old is/as calls were left over from the original Java code.

Signed-off-by: Graham <gpe@openrs2.dev>
pull/132/head
Graham 4 years ago
parent bde818230b
commit 880be759b7
11 changed files with 187 additions and 185 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 8
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/AddSubTransformer.kt
  2. 4
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BinaryExprOrderTransformer.kt
  3. 45
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BitMaskTransformer.kt
  4. 11
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ComplementTransformer.kt
  5. 83
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/EncloseTransformer.kt
  6. 9
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ForLoopConditionTransformer.kt
  7. 54
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/GlTransformer.kt
  8. 14
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IdentityTransformer.kt
  9. 70
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IfElseTransformer.kt
  10. 11
      deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IncrementTransformer.kt
  11. 63
      deob-ast/src/main/java/dev/openrs2/deob/ast/util/ExprUtils.kt

8
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/AddSubTransformer.kt
Unescape View File

@ -88,14 +88,14 @@ class AddSubTransformer : Transformer() {
} }
private fun Expression.isNegative(): Boolean { private fun Expression.isNegative(): Boolean {
return when { return when (this) {
isUnaryExpr -> asUnaryExpr().operator == UnaryExpr.Operator.MINUS is UnaryExpr -> operator == UnaryExpr.Operator.MINUS
isIntegerLiteralExpr -> when (val n = asIntegerLiteralExpr().asNumber()) { is IntegerLiteralExpr -> when (val n = asNumber()) {
IntegerLiteralExpr.MAX_31_BIT_UNSIGNED_VALUE_AS_LONG -> false IntegerLiteralExpr.MAX_31_BIT_UNSIGNED_VALUE_AS_LONG -> false
is Int -> n < 0 is Int -> n < 0
else -> error("Invalid IntegerLiteralExpr type") else -> error("Invalid IntegerLiteralExpr type")
} }
isLongLiteralExpr -> when (val n = asLongLiteralExpr().asNumber()) { is LongLiteralExpr -> when (val n = asNumber()) {
LongLiteralExpr.MAX_63_BIT_UNSIGNED_VALUE_AS_BIG_INTEGER -> false LongLiteralExpr.MAX_63_BIT_UNSIGNED_VALUE_AS_BIG_INTEGER -> false
is Long -> n < 0 is Long -> n < 0
else -> error("Invalid LongLiteralExpr type") else -> error("Invalid LongLiteralExpr type")

4
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BinaryExprOrderTransformer.kt
Unescape View File

@ -3,6 +3,8 @@ package dev.openrs2.deob.ast.transform
import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.CompilationUnit
import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.BinaryExpr
import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.Expression
import com.github.javaparser.ast.expr.LiteralExpr
import com.github.javaparser.ast.expr.ThisExpr
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.LibraryGroup
import dev.openrs2.deob.ast.util.flip import dev.openrs2.deob.ast.util.flip
@ -32,5 +34,5 @@ class BinaryExprOrderTransformer : Transformer() {
} }
private val Expression.isLiteralOrThisExpr: Boolean private val Expression.isLiteralOrThisExpr: Boolean
get() = isLiteralExpr || isThisExpr get() = this is LiteralExpr || this is ThisExpr
} }

45
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/BitMaskTransformer.kt
Unescape View File

@ -3,11 +3,11 @@ package dev.openrs2.deob.ast.transform
import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.CompilationUnit
import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.BinaryExpr
import com.github.javaparser.ast.expr.IntegerLiteralExpr import com.github.javaparser.ast.expr.IntegerLiteralExpr
import com.github.javaparser.ast.expr.LongLiteralExpr
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.LibraryGroup
import dev.openrs2.deob.ast.util.checkedAsInt import dev.openrs2.deob.ast.util.checkedAsInt
import dev.openrs2.deob.ast.util.checkedAsLong import dev.openrs2.deob.ast.util.checkedAsLong
import dev.openrs2.deob.ast.util.isIntegerOrLongLiteral
import dev.openrs2.deob.ast.util.toLongLiteralExpr import dev.openrs2.deob.ast.util.toLongLiteralExpr
import dev.openrs2.deob.ast.util.walk import dev.openrs2.deob.ast.util.walk
import javax.inject.Singleton import javax.inject.Singleton
@ -17,43 +17,46 @@ class BitMaskTransformer : Transformer() {
override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) { override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) {
unit.walk { expr: BinaryExpr -> unit.walk { expr: BinaryExpr ->
val shiftOp = expr.operator val shiftOp = expr.operator
val left = expr.left val bitwiseExpr = expr.left
val shamtExpr = expr.right val shamtExpr = expr.right
if (shiftOp !in SHIFT_OPS || !left.isBinaryExpr || !shamtExpr.isIntegerLiteralExpr) { if (shiftOp !in SHIFT_OPS || bitwiseExpr !is BinaryExpr || shamtExpr !is IntegerLiteralExpr) {
return@walk return@walk
} }
val bitwiseExpr = left.asBinaryExpr()
val bitwiseOp = bitwiseExpr.operator val bitwiseOp = bitwiseExpr.operator
val argExpr = bitwiseExpr.left val argExpr = bitwiseExpr.left
var maskExpr = bitwiseExpr.right var maskExpr = bitwiseExpr.right
if (bitwiseOp !in BITWISE_OPS || !maskExpr.isIntegerOrLongLiteral()) { if (bitwiseOp !in BITWISE_OPS) {
return@walk return@walk
} }
val shamt = shamtExpr.asIntegerLiteralExpr().checkedAsInt() val shamt = shamtExpr.checkedAsInt()
if (maskExpr.isIntegerLiteralExpr) { when (maskExpr) {
var mask = maskExpr.asIntegerLiteralExpr().checkedAsInt() is IntegerLiteralExpr -> {
var mask = maskExpr.checkedAsInt()
mask = when (shiftOp) { mask = when (shiftOp) {
BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt
BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt
else -> error("Invalid shiftOp") else -> error("Invalid shiftOp")
}
maskExpr = IntegerLiteralExpr(mask.toString())
} }
is LongLiteralExpr -> {
var mask = maskExpr.checkedAsLong()
maskExpr = IntegerLiteralExpr(mask.toString()) mask = when (shiftOp) {
} else { BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt
var mask = maskExpr.asLongLiteralExpr().checkedAsLong() BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt
else -> error("Invalid shiftOp")
}
mask = when (shiftOp) { maskExpr = mask.toLongLiteralExpr()
BinaryExpr.Operator.SIGNED_RIGHT_SHIFT -> mask shr shamt
BinaryExpr.Operator.UNSIGNED_RIGHT_SHIFT -> mask ushr shamt
else -> error("Invalid shiftOp")
} }
else -> return@walk
maskExpr = mask.toLongLiteralExpr()
} }
expr.replace(BinaryExpr(BinaryExpr(argExpr.clone(), shamtExpr.clone(), shiftOp), maskExpr, bitwiseOp)) expr.replace(BinaryExpr(BinaryExpr(argExpr.clone(), shamtExpr.clone(), shiftOp), maskExpr, bitwiseOp))

11
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ComplementTransformer.kt
Unescape View File

@ -4,6 +4,7 @@ import com.github.javaparser.ast.CompilationUnit
import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.BinaryExpr
import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.Expression
import com.github.javaparser.ast.expr.IntegerLiteralExpr import com.github.javaparser.ast.expr.IntegerLiteralExpr
import com.github.javaparser.ast.expr.LongLiteralExpr
import com.github.javaparser.ast.expr.UnaryExpr import com.github.javaparser.ast.expr.UnaryExpr
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.LibraryGroup
@ -34,7 +35,7 @@ class ComplementTransformer : Transformer() {
private companion object { private companion object {
private fun Expression.isComplement(): Boolean { private fun Expression.isComplement(): Boolean {
return isUnaryExpr && asUnaryExpr().operator == UnaryExpr.Operator.BITWISE_COMPLEMENT return this is UnaryExpr && operator == UnaryExpr.Operator.BITWISE_COMPLEMENT
} }
private fun Expression.isComplementOrLiteral(): Boolean { private fun Expression.isComplementOrLiteral(): Boolean {
@ -53,10 +54,10 @@ class ComplementTransformer : Transformer() {
} }
private fun Expression.complement(): Expression { private fun Expression.complement(): Expression {
return when { return when (this) {
isUnaryExpr -> asUnaryExpr().expression is UnaryExpr -> expression
isIntegerLiteralExpr -> IntegerLiteralExpr(asIntegerLiteralExpr().checkedAsInt().inv().toString()) is IntegerLiteralExpr -> IntegerLiteralExpr(checkedAsInt().inv().toString())
isLongLiteralExpr -> asLongLiteralExpr().checkedAsLong().inv().toLongLiteralExpr() is LongLiteralExpr -> checkedAsLong().inv().toLongLiteralExpr()
else -> throw IllegalArgumentException() else -> throw IllegalArgumentException()
} }
} }

83
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/EncloseTransformer.kt
Unescape View File

@ -1,9 +1,19 @@
package dev.openrs2.deob.ast.transform package dev.openrs2.deob.ast.transform
import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.CompilationUnit
import com.github.javaparser.ast.expr.ArrayAccessExpr
import com.github.javaparser.ast.expr.ArrayCreationExpr
import com.github.javaparser.ast.expr.AssignExpr
import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.BinaryExpr
import com.github.javaparser.ast.expr.CastExpr
import com.github.javaparser.ast.expr.ConditionalExpr
import com.github.javaparser.ast.expr.EnclosedExpr import com.github.javaparser.ast.expr.EnclosedExpr
import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.Expression
import com.github.javaparser.ast.expr.FieldAccessExpr
import com.github.javaparser.ast.expr.InstanceOfExpr
import com.github.javaparser.ast.expr.MethodCallExpr
import com.github.javaparser.ast.expr.ObjectCreationExpr
import com.github.javaparser.ast.expr.UnaryExpr
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.LibraryGroup
import dev.openrs2.deob.ast.util.walk import dev.openrs2.deob.ast.util.walk
@ -45,12 +55,12 @@ class EncloseTransformer : Transformer() {
companion object { companion object {
fun from(expr: Expression): Op? { fun from(expr: Expression): Op? {
return when { return when (expr) {
expr.isArrayAccessExpr || expr.isFieldAccessExpr -> ACCESS_PARENS is ArrayAccessExpr, is FieldAccessExpr -> ACCESS_PARENS
expr.isMethodCallExpr || expr.isEnclosedExpr -> ACCESS_PARENS is MethodCallExpr, is EnclosedExpr -> ACCESS_PARENS
expr.isUnaryExpr -> if (expr.asUnaryExpr().operator.isPostfix) POSTFIX else UNARY is UnaryExpr -> if (expr.operator.isPostfix) POSTFIX else UNARY
expr.isCastExpr || expr.isObjectCreationExpr || expr.isArrayCreationExpr -> CAST_NEW is CastExpr, is ObjectCreationExpr, is ArrayCreationExpr -> CAST_NEW
expr.isBinaryExpr -> when (expr.asBinaryExpr().operator) { is BinaryExpr -> when (expr.operator) {
BinaryExpr.Operator.MULTIPLY -> MULTIPLICATIVE BinaryExpr.Operator.MULTIPLY -> MULTIPLICATIVE
BinaryExpr.Operator.DIVIDE, BinaryExpr.Operator.REMAINDER -> MULTIPLICATIVE BinaryExpr.Operator.DIVIDE, BinaryExpr.Operator.REMAINDER -> MULTIPLICATIVE
BinaryExpr.Operator.PLUS, BinaryExpr.Operator.MINUS -> ADDITIVE BinaryExpr.Operator.PLUS, BinaryExpr.Operator.MINUS -> ADDITIVE
@ -66,9 +76,9 @@ class EncloseTransformer : Transformer() {
BinaryExpr.Operator.OR -> LOGICAL_OR BinaryExpr.Operator.OR -> LOGICAL_OR
else -> null else -> null
} }
expr.isInstanceOfExpr -> RELATIONAL is InstanceOfExpr -> RELATIONAL
expr.isConditionalExpr -> TERNARY is ConditionalExpr -> TERNARY
expr.isAssignExpr -> ASSIGNMENT is AssignExpr -> ASSIGNMENT
else -> null else -> null
} }
} }
@ -77,49 +87,34 @@ class EncloseTransformer : Transformer() {
override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) { override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) {
unit.walk { expr: Expression -> unit.walk { expr: Expression ->
when { when (expr) {
expr.isArrayAccessExpr -> { is ArrayAccessExpr -> encloseLeft(expr, expr.name)
val accessExpr = expr.asArrayAccessExpr() is FieldAccessExpr -> encloseLeft(expr, expr.scope)
encloseLeft(expr, accessExpr.name) is MethodCallExpr -> {
} expr.scope.ifPresent { scope ->
expr.isFieldAccessExpr -> {
encloseLeft(expr, expr.asFieldAccessExpr().scope)
}
expr.isMethodCallExpr -> {
expr.asMethodCallExpr().scope.ifPresent { scope ->
encloseLeft(expr, scope) encloseLeft(expr, scope)
} }
} }
expr.isUnaryExpr -> { is UnaryExpr -> encloseRight(expr, expr.expression)
val unaryExpr = expr.asUnaryExpr() is CastExpr -> encloseRight(expr, expr.expression)
encloseRight(expr, unaryExpr.expression) is ObjectCreationExpr -> {
} expr.scope.ifPresent { scope ->
expr.isCastExpr -> {
encloseRight(expr, expr.asCastExpr().expression)
}
expr.isObjectCreationExpr -> {
expr.asObjectCreationExpr().scope.ifPresent { scope ->
encloseLeft(expr, scope) encloseLeft(expr, scope)
} }
} }
expr.isBinaryExpr -> { is BinaryExpr -> {
val binaryExpr = expr.asBinaryExpr() encloseLeft(expr, expr.left)
encloseLeft(expr, binaryExpr.left) encloseRight(expr, expr.right)
encloseRight(expr, binaryExpr.right)
}
expr.isInstanceOfExpr -> {
encloseLeft(expr, expr.asInstanceOfExpr().expression)
} }
expr.isConditionalExpr -> { is InstanceOfExpr -> encloseLeft(expr, expr.expression)
val conditionalExpr = expr.asConditionalExpr() is ConditionalExpr -> {
encloseLeft(expr, conditionalExpr.condition) encloseLeft(expr, expr.condition)
encloseLeft(expr, conditionalExpr.thenExpr) encloseLeft(expr, expr.thenExpr)
encloseRight(expr, conditionalExpr.elseExpr) encloseRight(expr, expr.elseExpr)
} }
expr.isAssignExpr -> { is AssignExpr -> {
val assignExpr = expr.asAssignExpr() encloseLeft(expr, expr.target)
encloseLeft(expr, assignExpr.target) encloseRight(expr, expr.value)
encloseRight(expr, assignExpr.value)
} }
} }
} }

9
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/ForLoopConditionTransformer.kt
Unescape View File

@ -23,13 +23,10 @@ class ForLoopConditionTransformer : Transformer() {
unit.walk { stmt: ForStmt -> unit.walk { stmt: ForStmt ->
val updatedExprs = stmt.update.mapNotNull { it.getUpdatedExpr() } val updatedExprs = stmt.update.mapNotNull { it.getUpdatedExpr() }
stmt.compare.ifPresent { compare -> stmt.compare.ifPresent { expr ->
if (!compare.isBinaryExpr) { if (expr !is BinaryExpr) {
return@ifPresent return@ifPresent
} } else if (expr.hasSideEffects()) {
val expr = compare.asBinaryExpr()
if (expr.hasSideEffects()) {
return@ifPresent return@ifPresent
} }

54
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/GlTransformer.kt
Unescape View File

@ -9,13 +9,17 @@ import com.github.javaparser.ast.body.Parameter
import com.github.javaparser.ast.body.TypeDeclaration import com.github.javaparser.ast.body.TypeDeclaration
import com.github.javaparser.ast.body.VariableDeclarator import com.github.javaparser.ast.body.VariableDeclarator
import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.BinaryExpr
import com.github.javaparser.ast.expr.ConditionalExpr
import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.Expression
import com.github.javaparser.ast.expr.FieldAccessExpr import com.github.javaparser.ast.expr.FieldAccessExpr
import com.github.javaparser.ast.expr.IntegerLiteralExpr
import com.github.javaparser.ast.expr.MethodCallExpr import com.github.javaparser.ast.expr.MethodCallExpr
import com.github.javaparser.ast.expr.NameExpr import com.github.javaparser.ast.expr.NameExpr
import com.github.javaparser.ast.expr.SimpleName import com.github.javaparser.ast.expr.SimpleName
import com.github.javaparser.ast.type.PrimitiveType import com.github.javaparser.ast.type.PrimitiveType
import com.github.javaparser.resolution.types.ResolvedArrayType
import com.github.javaparser.resolution.types.ResolvedPrimitiveType import com.github.javaparser.resolution.types.ResolvedPrimitiveType
import com.github.javaparser.resolution.types.ResolvedReferenceType
import com.github.javaparser.resolution.types.ResolvedType import com.github.javaparser.resolution.types.ResolvedType
import com.github.michaelbull.logging.InlineLogger import com.github.michaelbull.logging.InlineLogger
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
@ -65,11 +69,11 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran
} }
private fun transformFramebufferStatus(unit: CompilationUnit, expr: Expression) { private fun transformFramebufferStatus(unit: CompilationUnit, expr: Expression) {
if (!expr.isIntegerLiteralExpr) { if (expr !is IntegerLiteralExpr) {
return return
} }
val value = expr.asIntegerLiteralExpr().checkedAsInt() val value = expr.checkedAsInt()
if (value.toLong() != GL_FRAMEBUFFER_COMPLETE.value) { if (value.toLong() != GL_FRAMEBUFFER_COMPLETE.value) {
return return
} }
@ -92,8 +96,8 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran
private fun ResolvedType.isFollowedByOffset(): Boolean { private fun ResolvedType.isFollowedByOffset(): Boolean {
return when { return when {
isArray && asArrayType().componentType.isPrimitive -> true this is ResolvedArrayType && componentType.isPrimitive -> true
isReferenceType && asReferenceType().qualifiedName == "java.lang.Object" -> true this is ResolvedReferenceType && qualifiedName == "java.lang.Object" -> true
else -> false else -> false
} }
} }
@ -164,11 +168,11 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran
expr.scope.ifPresent { scope -> expr.scope.ifPresent { scope ->
val type = scope.calculateResolvedType() val type = scope.calculateResolvedType()
if (!type.isReferenceType) { if (type !is ResolvedReferenceType) {
return@ifPresent return@ifPresent
} }
val name = type.asReferenceType().qualifiedName val name = type.qualifiedName
if (name in GL_CLASSES) { if (name in GL_CLASSES) {
transformArguments(unit, expr) transformArguments(unit, expr)
} }
@ -235,16 +239,18 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran
parameter: GlParameter, parameter: GlParameter,
expr: Expression expr: Expression
) { ) {
if (expr.isBinaryExpr) { when (expr) {
val binaryExpr = expr.asBinaryExpr() is BinaryExpr -> {
transformExpr(unit, command, parameter, binaryExpr.left) transformExpr(unit, command, parameter, expr.left)
transformExpr(unit, command, parameter, binaryExpr.right) transformExpr(unit, command, parameter, expr.right)
} else if (expr.isConditionalExpr) { }
val conditionalExpr = expr.asConditionalExpr() is ConditionalExpr -> {
transformExpr(unit, command, parameter, conditionalExpr.thenExpr) transformExpr(unit, command, parameter, expr.thenExpr)
transformExpr(unit, command, parameter, conditionalExpr.elseExpr) transformExpr(unit, command, parameter, expr.elseExpr)
} else if (expr.isIntegerLiteralExpr) { }
transformIntegerLiteralExpr(unit, command, parameter, expr) is IntegerLiteralExpr -> {
transformIntegerLiteralExpr(unit, command, parameter, expr)
}
} }
} }
@ -252,9 +258,9 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran
unit: CompilationUnit, unit: CompilationUnit,
command: GlCommand, command: GlCommand,
parameter: GlParameter, parameter: GlParameter,
expr: Expression expr: IntegerLiteralExpr
) { ) {
var value = expr.asIntegerLiteralExpr().checkedAsInt() var value = expr.checkedAsInt()
val group = parameter.group ?: return val group = parameter.group ?: return
if (parameter.bitfield) { if (parameter.bitfield) {
@ -320,21 +326,21 @@ class GlTransformer @Inject constructor(private val registry: GlRegistry) : Tran
private val FIELD_METHOD_COMPARATOR = Comparator<BodyDeclaration<*>> { a, b -> private val FIELD_METHOD_COMPARATOR = Comparator<BodyDeclaration<*>> { a, b ->
when { when {
a.isFieldDeclaration && !b.isFieldDeclaration -> -1 a is FieldDeclaration && b !is FieldDeclaration -> -1
!a.isFieldDeclaration && b.isFieldDeclaration -> 1 a !is FieldDeclaration && b is FieldDeclaration -> 1
else -> 0 else -> 0
} }
} }
private fun BodyDeclaration<*>.getIntValue(): Int? { private fun BodyDeclaration<*>.getIntValue(): Int? {
if (!isFieldDeclaration) { if (this !is FieldDeclaration) {
return null return null
} }
val variable = asFieldDeclaration().variables.firstOrNull() ?: return null val variable = variables.firstOrNull() ?: return null
return variable.initializer.map { return variable.initializer.map {
if (it.isIntegerLiteralExpr) { if (it is IntegerLiteralExpr) {
it.asIntegerLiteralExpr().checkedAsInt() it.checkedAsInt()
} else { } else {
null null
} }

14
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IdentityTransformer.kt
Unescape View File

@ -3,6 +3,8 @@ package dev.openrs2.deob.ast.transform
import com.github.javaparser.ast.CompilationUnit import com.github.javaparser.ast.CompilationUnit
import com.github.javaparser.ast.expr.BinaryExpr import com.github.javaparser.ast.expr.BinaryExpr
import com.github.javaparser.ast.expr.Expression import com.github.javaparser.ast.expr.Expression
import com.github.javaparser.ast.expr.IntegerLiteralExpr
import com.github.javaparser.ast.expr.LongLiteralExpr
import com.github.javaparser.ast.expr.UnaryExpr import com.github.javaparser.ast.expr.UnaryExpr
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.LibraryGroup
@ -47,17 +49,17 @@ class IdentityTransformer : Transformer() {
} }
private fun Expression.isZero(): Boolean { private fun Expression.isZero(): Boolean {
return when { return when (this) {
isIntegerLiteralExpr -> asIntegerLiteralExpr().asNumber() == 0 is IntegerLiteralExpr -> asNumber() == 0
isLongLiteralExpr -> asLongLiteralExpr().asNumber() == 0L is LongLiteralExpr -> asNumber() == 0L
else -> false else -> false
} }
} }
private fun Expression.isOne(): Boolean { private fun Expression.isOne(): Boolean {
return when { return when (this) {
isIntegerLiteralExpr -> asIntegerLiteralExpr().asNumber() == 1 is IntegerLiteralExpr -> asNumber() == 1
isLongLiteralExpr -> asLongLiteralExpr().asNumber() == 1L is LongLiteralExpr -> asNumber() == 1L
else -> false else -> false
} }
} }

70
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IfElseTransformer.kt
Unescape View File

@ -7,6 +7,7 @@ import com.github.javaparser.ast.stmt.BlockStmt
import com.github.javaparser.ast.stmt.IfStmt import com.github.javaparser.ast.stmt.IfStmt
import com.github.javaparser.ast.stmt.ReturnStmt import com.github.javaparser.ast.stmt.ReturnStmt
import com.github.javaparser.ast.stmt.Statement import com.github.javaparser.ast.stmt.Statement
import com.github.javaparser.ast.stmt.ThrowStmt
import dev.openrs2.deob.ast.Library import dev.openrs2.deob.ast.Library
import dev.openrs2.deob.ast.LibraryGroup import dev.openrs2.deob.ast.LibraryGroup
import dev.openrs2.deob.ast.util.countNots import dev.openrs2.deob.ast.util.countNots
@ -78,7 +79,7 @@ class IfElseTransformer : Transformer() {
val notCondition = condition.not() val notCondition = condition.not()
if (notCondition.countNots() < condition.countNots()) { if (notCondition.countNots() < condition.countNots()) {
stmt.condition = notCondition stmt.condition = notCondition
if (elseStmt.isIfStmt) { if (elseStmt is IfStmt) {
val block = BlockStmt() val block = BlockStmt()
block.statements.add(elseStmt.clone()) block.statements.add(elseStmt.clone())
stmt.thenStmt = block stmt.thenStmt = block
@ -136,23 +137,19 @@ class IfElseTransformer : Transformer() {
unit.walk { stmt: IfStmt -> unit.walk { stmt: IfStmt ->
stmt.elseStmt.ifPresent { elseStmt -> stmt.elseStmt.ifPresent { elseStmt ->
// match // match
if (!elseStmt.isBlockStmt) { if (elseStmt !is BlockStmt) {
return@ifPresent return@ifPresent
} }
val blockStmt = elseStmt.asBlockStmt() val statements = elseStmt.statements
val statements = blockStmt.statements
if (statements.isEmpty()) { if (statements.isEmpty()) {
return@ifPresent return@ifPresent
} }
val head = statements[0] val ifStmt = statements[0]
if (!head.isIfStmt) { if (ifStmt !is IfStmt) {
return@ifPresent return@ifPresent
} } else if (ifStmt.elseStmt.isPresent) {
val ifStmt = head.asIfStmt()
if (ifStmt.elseStmt.isPresent) {
return@ifPresent return@ifPresent
} }
@ -164,7 +161,7 @@ class IfElseTransformer : Transformer() {
// rewrite // rewrite
val condition = ifStmt.condition.not() val condition = ifStmt.condition.not()
val tail = blockStmt.clone() val tail = elseStmt.clone()
tail.statements.removeAt(0) tail.statements.removeAt(0)
elseStmt.replace(IfStmt(condition, tail, thenStmt.clone())) elseStmt.replace(IfStmt(condition, tail, thenStmt.clone()))
@ -213,25 +210,28 @@ class IfElseTransformer : Transformer() {
} }
private fun Statement.isIf(): Boolean { private fun Statement.isIf(): Boolean {
return when { return when (this) {
isIfStmt -> true is IfStmt -> true
isBlockStmt -> { is BlockStmt -> {
val stmts = asBlockStmt().statements val stmts = statements
stmts.size == 1 && stmts[0].isIfStmt stmts.size == 1 && stmts[0] is IfStmt
} }
else -> false else -> false
} }
} }
private fun Statement.getIf(): Statement { private fun Statement.getIf(): Statement {
if (isIfStmt) { when (this) {
return clone() is IfStmt -> {
} else if (isBlockStmt) { return clone()
val stmts = asBlockStmt().statements }
if (stmts.size == 1) { is BlockStmt -> {
val head = stmts[0] val stmts = statements
if (head.isIfStmt) { if (stmts.size == 1) {
return head.clone() val head = stmts[0]
if (head is IfStmt) {
return head.clone()
}
} }
} }
} }
@ -239,18 +239,18 @@ class IfElseTransformer : Transformer() {
} }
private fun Statement.isTailThrowOrReturn(): Boolean { private fun Statement.isTailThrowOrReturn(): Boolean {
return if (isThrowStmt || isReturnStmt) { return when (this) {
true is ThrowStmt, is ReturnStmt -> true
} else if (isBlockStmt) { is BlockStmt -> {
val stmts = asBlockStmt().statements val stmts = statements
if (stmts.isEmpty()) { if (stmts.isEmpty()) {
return false return false
} }
val tail = stmts[stmts.size - 1] val tail = stmts[stmts.size - 1]
tail.isThrowStmt || tail.isReturnStmt tail is ThrowStmt || tail is ReturnStmt
} else { }
false else -> false
} }
} }
} }

11
deob-ast/src/main/java/dev/openrs2/deob/ast/transform/IncrementTransformer.kt
Unescape View File

@ -13,22 +13,21 @@ import javax.inject.Singleton
class IncrementTransformer : Transformer() { class IncrementTransformer : Transformer() {
override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) { override fun transformUnit(group: LibraryGroup, library: Library, unit: CompilationUnit) {
unit.walk { stmt: ExpressionStmt -> unit.walk { stmt: ExpressionStmt ->
if (!stmt.expression.isUnaryExpr) { val expr = stmt.expression
if (expr !is UnaryExpr) {
return@walk return@walk
} }
val unaryExpr = stmt.expression.asUnaryExpr() expr.operator = expr.operator.toPostfix()
unaryExpr.operator = unaryExpr.operator.toPostfix()
} }
unit.walk { stmt: ForStmt -> unit.walk { stmt: ForStmt ->
for (expr in stmt.update) { for (expr in stmt.update) {
if (!expr.isUnaryExpr) { if (expr !is UnaryExpr) {
continue continue
} }
val unaryExpr = expr.asUnaryExpr() expr.operator = expr.operator.toPostfix()
unaryExpr.operator = unaryExpr.operator.toPostfix()
} }
} }
} }

63
deob-ast/src/main/java/dev/openrs2/deob/ast/util/ExprUtils.kt
Unescape View File

@ -37,7 +37,7 @@ fun Long.toHexLiteralExpr(): LongLiteralExpr {
} }
fun Expression.isIntegerOrLongLiteral(): Boolean { fun Expression.isIntegerOrLongLiteral(): Boolean {
return isIntegerLiteralExpr || isLongLiteralExpr return this is IntegerLiteralExpr || this is LongLiteralExpr
} }
fun Long.toLongLiteralExpr(): LongLiteralExpr { fun Long.toLongLiteralExpr(): LongLiteralExpr {
@ -66,48 +66,45 @@ fun Expression.negate(): Expression {
} }
fun Expression.not(): Expression { fun Expression.not(): Expression {
if (isUnaryExpr) { when (this) {
val unary = asUnaryExpr() is UnaryExpr -> {
if (unary.operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) { if (operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) {
return unary.expression.clone() return expression.clone()
}
} }
} else if (isBinaryExpr) { is BinaryExpr -> {
val binary = asBinaryExpr() @Suppress("NON_EXHAUSTIVE_WHEN")
when (operator) {
val left = binary.left BinaryExpr.Operator.EQUALS ->
val right = binary.right return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.NOT_EQUALS)
BinaryExpr.Operator.NOT_EQUALS ->
@Suppress("NON_EXHAUSTIVE_WHEN") return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.EQUALS)
when (binary.operator) { BinaryExpr.Operator.GREATER ->
BinaryExpr.Operator.EQUALS -> return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS_EQUALS)
return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.NOT_EQUALS) BinaryExpr.Operator.GREATER_EQUALS ->
BinaryExpr.Operator.NOT_EQUALS -> return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS)
return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.EQUALS) BinaryExpr.Operator.LESS ->
BinaryExpr.Operator.GREATER -> return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER_EQUALS)
return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS_EQUALS) BinaryExpr.Operator.LESS_EQUALS ->
BinaryExpr.Operator.GREATER_EQUALS -> return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER)
return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.LESS) BinaryExpr.Operator.AND ->
BinaryExpr.Operator.LESS -> return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.OR)
return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER_EQUALS) BinaryExpr.Operator.OR ->
BinaryExpr.Operator.LESS_EQUALS -> return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.AND)
return BinaryExpr(left.clone(), right.clone(), BinaryExpr.Operator.GREATER) }
BinaryExpr.Operator.AND ->
return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.OR)
BinaryExpr.Operator.OR ->
return BinaryExpr(left.not(), right.not(), BinaryExpr.Operator.AND)
} }
} else if (isBooleanLiteralExpr) { is BooleanLiteralExpr -> return BooleanLiteralExpr(!value)
return BooleanLiteralExpr(!asBooleanLiteralExpr().value)
} }
return UnaryExpr(clone(), UnaryExpr.Operator.LOGICAL_COMPLEMENT) return UnaryExpr(clone(), UnaryExpr.Operator.LOGICAL_COMPLEMENT)
} }
fun Expression.countNots(): Int { fun Expression.countNots(): Int {
var count = 0 var count = 0
if (isUnaryExpr && asUnaryExpr().operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) { if (this is UnaryExpr && operator == UnaryExpr.Operator.LOGICAL_COMPLEMENT) {
count++ count++
} else if (isBinaryExpr && asBinaryExpr().operator == BinaryExpr.Operator.NOT_EQUALS) { } else if (this is BinaryExpr && operator == BinaryExpr.Operator.NOT_EQUALS) {
count++ count++
} }

Write Preview
Loading…
Cancel
Save