1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
package cuchaz.enigma.analysis.index;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
import cuchaz.enigma.analysis.EntryReference;
import cuchaz.enigma.translation.mapping.EntryResolver;
import cuchaz.enigma.translation.mapping.ResolutionStrategy;
import cuchaz.enigma.translation.representation.entry.*;
import java.util.Collection;
import java.util.Map;
public class ReferenceIndex implements JarIndexer {
private Multimap<MethodEntry, MethodEntry> methodReferences = HashMultimap.create();
private Multimap<MethodEntry, EntryReference<MethodEntry, MethodDefEntry>> referencesToMethods = HashMultimap.create();
private Multimap<ClassEntry, EntryReference<ClassEntry, MethodDefEntry>> referencesToClasses = HashMultimap.create();
private Multimap<FieldEntry, EntryReference<FieldEntry, MethodDefEntry>> referencesToFields = HashMultimap.create();
@Override
public void indexMethodReference(MethodDefEntry callerEntry, MethodEntry referencedEntry) {
referencesToMethods.put(referencedEntry, new EntryReference<>(referencedEntry, referencedEntry.getName(), callerEntry));
methodReferences.put(callerEntry, referencedEntry);
if (referencedEntry.isConstructor()) {
ClassEntry referencedClass = referencedEntry.getParent();
referencesToClasses.put(referencedClass, new EntryReference<>(referencedClass, referencedEntry.getName(), callerEntry));
}
}
@Override
public void indexFieldReference(MethodDefEntry callerEntry, FieldEntry referencedEntry) {
referencesToFields.put(referencedEntry, new EntryReference<>(referencedEntry, referencedEntry.getName(), callerEntry));
}
@Override
public void processIndex(EntryResolver resolver) {
methodReferences = resolveReferences(resolver, methodReferences);
referencesToMethods = resolveReferencesTo(resolver, referencesToMethods);
referencesToClasses = resolveReferencesTo(resolver, referencesToClasses);
referencesToFields = resolveReferencesTo(resolver, referencesToFields);
}
private <K extends Entry<?>, V extends Entry<?>> Multimap<K, V> resolveReferences(EntryResolver resolver, Multimap<K, V> multimap) {
Multimap<K, V> resolved = HashMultimap.create();
for (Map.Entry<K, V> entry : multimap.entries()) {
resolved.put(resolve(resolver, entry.getKey()), resolve(resolver, entry.getValue()));
}
return resolved;
}
private <E extends Entry<?>, C extends Entry<?>> Multimap<E, EntryReference<E, C>> resolveReferencesTo(EntryResolver resolver, Multimap<E, EntryReference<E, C>> multimap) {
Multimap<E, EntryReference<E, C>> resolved = HashMultimap.create();
for (Map.Entry<E, EntryReference<E, C>> entry : multimap.entries()) {
resolved.put(resolve(resolver, entry.getKey()), resolve(resolver, entry.getValue()));
}
return resolved;
}
private <E extends Entry<?>> E resolve(EntryResolver resolver, E entry) {
return resolver.resolveFirstEntry(entry, ResolutionStrategy.RESOLVE_CLOSEST);
}
private <E extends Entry<?>, C extends Entry<?>> EntryReference<E, C> resolve(EntryResolver resolver, EntryReference<E, C> reference) {
return resolver.resolveFirstReference(reference, ResolutionStrategy.RESOLVE_CLOSEST);
}
public Collection<MethodEntry> getMethodsReferencedBy(MethodEntry entry) {
return methodReferences.get(entry);
}
public Collection<EntryReference<FieldEntry, MethodDefEntry>> getReferencesToField(FieldEntry entry) {
return referencesToFields.get(entry);
}
public Collection<EntryReference<ClassEntry, MethodDefEntry>> getReferencesToClass(ClassEntry entry) {
return referencesToClasses.get(entry);
}
public Collection<EntryReference<MethodEntry, MethodDefEntry>> getReferencesToMethod(MethodEntry entry) {
return referencesToMethods.get(entry);
}
}
|
