1 files changed, 184 insertions, 0 deletions

diff --git a/src/cuchaz/enigma/mapping/EntryFactory.java b/src/cuchaz/enigma/mapping/EntryFactory.java
new file mode 100644
index 0000000..dceea29
--- /dev/null
+++ b/src/cuchaz/enigma/mapping/EntryFactory.java
@@ -0,0 +1,184 @@
+package cuchaz.enigma.mapping;
+
+import java.util.List;
+
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtField;
+import javassist.CtMethod;
+import javassist.bytecode.Descriptor;
+import javassist.expr.ConstructorCall;
+import javassist.expr.FieldAccess;
+import javassist.expr.MethodCall;
+import javassist.expr.NewExpr;
+
+import com.beust.jcommander.internal.Lists;
+import com.strobel.assembler.metadata.MethodDefinition;
+
+import cuchaz.enigma.analysis.JarIndex;
+
+public class EntryFactory {
+        
+        public static ClassEntry getClassEntry(CtClass c) {
+                return new ClassEntry(Descriptor.toJvmName(c.getName()));
+        }
+        
+        public static ClassEntry getObfClassEntry(JarIndex jarIndex, ClassMapping classMapping) {
+                return new ClassEntry(getChainedOuterClassName(jarIndex, classMapping.getObfName()));
+        }
+        
+        private static String getChainedOuterClassName(JarIndex jarIndex, String obfClassName) {
+                
+                // lookup the chain of outer classes
+                List<String> obfOuterClassNames = Lists.newArrayList();
+                String checkName = obfClassName;
+                while (true) {
+                        
+                        // if this class name has a package, then it can't be an inner class
+                        if (!new ClassEntry(checkName).isInDefaultPackage()) {
+                                break;
+                        }
+                        
+                        String obfOuterClassName = jarIndex.getOuterClass(checkName);
+                        if (obfOuterClassName != null) {
+                                obfOuterClassNames.add(obfOuterClassName);
+                                checkName = obfOuterClassName;
+                        } else {
+                                break;
+                        }
+                }
+                
+                // build the chained class name
+                StringBuilder buf = new StringBuilder();
+                for (int i=obfOuterClassNames.size()-1; i>=0; i--) {
+                        buf.append(obfOuterClassNames.get(i));
+                        buf.append("$");
+                }
+                buf.append(obfClassName);
+                return buf.toString();
+        }
+        
+        public static ClassEntry getDeobfClassEntry(ClassMapping classMapping) {
+                return new ClassEntry(classMapping.getDeobfName());
+        }
+        
+        public static ClassEntry getSuperclassEntry(CtClass c) {
+                return new ClassEntry(Descriptor.toJvmName(c.getClassFile().getSuperclass()));
+        }
+        
+        public static FieldEntry getFieldEntry(CtField field) {
+                return new FieldEntry(
+                        getClassEntry(field.getDeclaringClass()),
+                        field.getName(),
+                        new Type(field.getFieldInfo().getDescriptor())
+                );
+        }
+        
+        public static FieldEntry getFieldEntry(FieldAccess call) {
+                return new FieldEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        call.getFieldName(),
+                        new Type(call.getSignature())
+                );
+        }
+        
+        public static MethodEntry getMethodEntry(CtMethod method) {
+                return new MethodEntry(
+                        getClassEntry(method.getDeclaringClass()),
+                        method.getName(),
+                        new Signature(method.getMethodInfo().getDescriptor())
+                );
+        }
+        
+        public static MethodEntry getMethodEntry(MethodCall call) {
+                return new MethodEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        call.getMethodName(),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static MethodEntry getMethodEntry(MethodDefinition def) {
+                return new MethodEntry(
+                        new ClassEntry(def.getDeclaringType().getInternalName()),
+                        def.getName(),
+                        new Signature(def.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(CtConstructor constructor) {
+                if (constructor.isClassInitializer()) {
+                        return new ConstructorEntry(
+                                getClassEntry(constructor.getDeclaringClass())
+                        );
+                } else {
+                        return new ConstructorEntry(
+                                getClassEntry(constructor.getDeclaringClass()),
+                                new Signature(constructor.getMethodInfo().getDescriptor())
+                        );
+                }
+        }
+        
+        public static ConstructorEntry getConstructorEntry(ConstructorCall call) {
+                return new ConstructorEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(NewExpr call) {
+                return new ConstructorEntry(
+                        new ClassEntry(Descriptor.toJvmName(call.getClassName())),
+                        new Signature(call.getSignature())
+                );
+        }
+        
+        public static ConstructorEntry getConstructorEntry(MethodDefinition def) {
+                if (def.isTypeInitializer()) {
+                        return new ConstructorEntry(
+                                new ClassEntry(def.getDeclaringType().getInternalName())
+                        );
+                } else {
+                        return new ConstructorEntry(
+                                new ClassEntry(def.getDeclaringType().getInternalName()),
+                                new Signature(def.getSignature())
+                        );
+                }
+        }
+        
+        public static BehaviorEntry getBehaviorEntry(CtBehavior behavior) {
+                if (behavior instanceof CtMethod) {
+                        return getMethodEntry((CtMethod)behavior);
+                } else if (behavior instanceof CtConstructor) {
+                        return getConstructorEntry((CtConstructor)behavior);
+                }
+                throw new Error("behavior is neither Method nor Constructor!");
+        }
+        
+        public static BehaviorEntry getBehaviorEntry(String className, String behaviorName, String behaviorSignature) {
+                return getBehaviorEntry(new ClassEntry(className), behaviorName, new Signature(behaviorSignature));
+        }
+        
+        public static BehaviorEntry getBehaviorEntry(ClassEntry classEntry, String behaviorName, Signature behaviorSignature) {
+                if (behaviorName.equals("<init>")) {
+                        return new ConstructorEntry(classEntry, behaviorSignature);
+                } else if(behaviorName.equals("<clinit>")) {
+                        return new ConstructorEntry(classEntry);
+                } else {
+                        return new MethodEntry(classEntry, behaviorName, behaviorSignature);
+                }
+        }
+        
+        public static BehaviorEntry getBehaviorEntry(MethodDefinition def) {
+                if (def.isConstructor() || def.isTypeInitializer()) {
+                        return getConstructorEntry(def);
+                } else {
+                        return getMethodEntry(def);
+                }
+        }
+        
+        public static BehaviorEntry getObfBehaviorEntry(ClassEntry classEntry, MethodMapping methodMapping) {
+                return getBehaviorEntry(classEntry, methodMapping.getObfName(), methodMapping.getObfSignature());
+        }
+}