From c4e35f2d516ade27e8e1a863b4bc356f182f43c2 Mon Sep 17 00:00:00 2001 From: jeff Date: Tue, 19 Aug 2014 00:25:32 -0400 Subject: started new reference navigation system --- .../enigma/analysis/BehaviorReferenceTreeNode.java | 105 +++++++++++++++ src/cuchaz/enigma/analysis/EntryReference.java | 28 ++++ src/cuchaz/enigma/analysis/FieldCallsTreeNode.java | 82 ------------ .../enigma/analysis/FieldReferenceTreeNode.java | 92 +++++++++++++ src/cuchaz/enigma/analysis/JarIndex.java | 141 +++++++++++++------- .../enigma/analysis/MethodCallsTreeNode.java | 144 --------------------- src/cuchaz/enigma/analysis/ReferenceTreeNode.java | 19 +++ src/cuchaz/enigma/analysis/SourceIndexVisitor.java | 20 ++- src/cuchaz/enigma/analysis/TreeDumpVisitor.java | 11 +- 9 files changed, 361 insertions(+), 281 deletions(-) create mode 100644 src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java create mode 100644 src/cuchaz/enigma/analysis/EntryReference.java delete mode 100644 src/cuchaz/enigma/analysis/FieldCallsTreeNode.java create mode 100644 src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java delete mode 100644 src/cuchaz/enigma/analysis/MethodCallsTreeNode.java create mode 100644 src/cuchaz/enigma/analysis/ReferenceTreeNode.java (limited to 'src/cuchaz/enigma/analysis') diff --git a/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java b/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java new file mode 100644 index 0000000..158aad7 --- /dev/null +++ b/src/cuchaz/enigma/analysis/BehaviorReferenceTreeNode.java @@ -0,0 +1,105 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma.analysis; + +import java.util.Set; + +import javax.swing.tree.DefaultMutableTreeNode; +import javax.swing.tree.TreeNode; + +import com.google.common.collect.Sets; + +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.Entry; +import cuchaz.enigma.mapping.Translator; + +public class BehaviorReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode +{ + private static final long serialVersionUID = -3658163700783307520L; + + private Translator m_deobfuscatingTranslator; + private BehaviorEntry m_entry; + private EntryReference m_reference; + + public BehaviorReferenceTreeNode( Translator deobfuscatingTranslator, BehaviorEntry entry ) + { + m_deobfuscatingTranslator = deobfuscatingTranslator; + m_entry = entry; + m_reference = null; + } + + public BehaviorReferenceTreeNode( Translator deobfuscatingTranslator, EntryReference reference ) + { + m_deobfuscatingTranslator = deobfuscatingTranslator; + m_entry = reference.entry; + m_reference = reference; + } + + @Override + public BehaviorEntry getEntry( ) + { + return m_entry; + } + + @Override + public EntryReference getReference( ) + { + return m_reference; + } + + @Override + public String toString( ) + { + if( m_reference != null ) + { + return m_deobfuscatingTranslator.translateEntry( m_reference.caller ).toString(); + } + return m_deobfuscatingTranslator.translateEntry( m_entry ).toString(); + } + + public void load( JarIndex index, boolean recurse ) + { + // get all the child nodes + for( EntryReference reference : index.getBehaviorReferences( m_entry ) ) + { + add( new BehaviorReferenceTreeNode( m_deobfuscatingTranslator, reference ) ); + } + + if( recurse && children != null ) + { + for( Object child : children ) + { + if( child instanceof BehaviorReferenceTreeNode ) + { + BehaviorReferenceTreeNode node = (BehaviorReferenceTreeNode)child; + + // don't recurse into ancestor + Set ancestors = Sets.newHashSet(); + TreeNode n = (TreeNode)node; + while( n.getParent() != null ) + { + n = n.getParent(); + if( n instanceof BehaviorReferenceTreeNode ) + { + ancestors.add( ((BehaviorReferenceTreeNode)n).getEntry() ); + } + } + if( ancestors.contains( node.getEntry() ) ) + { + continue; + } + + node.load( index, true ); + } + } + } + } +} diff --git a/src/cuchaz/enigma/analysis/EntryReference.java b/src/cuchaz/enigma/analysis/EntryReference.java new file mode 100644 index 0000000..f462210 --- /dev/null +++ b/src/cuchaz/enigma/analysis/EntryReference.java @@ -0,0 +1,28 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma.analysis; + +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.Entry; + +public class EntryReference +{ + public T entry; + public BehaviorEntry caller; + public int pos; + + public EntryReference( T entry, BehaviorEntry caller, int pos ) + { + this.entry = entry; + this.caller = caller; + this.pos = pos; + } +} diff --git a/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java b/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java deleted file mode 100644 index 0427b3b..0000000 --- a/src/cuchaz/enigma/analysis/FieldCallsTreeNode.java +++ /dev/null @@ -1,82 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ -package cuchaz.enigma.analysis; - -import javax.swing.tree.DefaultMutableTreeNode; - -import cuchaz.enigma.mapping.ConstructorEntry; -import cuchaz.enigma.mapping.Entry; -import cuchaz.enigma.mapping.FieldEntry; -import cuchaz.enigma.mapping.MethodEntry; -import cuchaz.enigma.mapping.Translator; - -public class FieldCallsTreeNode extends DefaultMutableTreeNode -{ - private static final long serialVersionUID = -7934108091928699835L; - - private Translator m_deobfuscatingTranslator; - private FieldEntry m_entry; - - public FieldCallsTreeNode( Translator deobfuscatingTranslator, FieldEntry fieldEntry ) - { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_entry = fieldEntry; - } - - public FieldEntry getFieldEntry( ) - { - return m_entry; - } - - @Override - public String toString( ) - { - String className = m_deobfuscatingTranslator.translateClass( m_entry.getClassName() ); - if( className == null ) - { - className = m_entry.getClassName(); - } - - String targetName = m_deobfuscatingTranslator.translate( m_entry ); - if( targetName == null ) - { - targetName = m_entry.getName(); - } - return className + "." + targetName; - } - - public void load( JarIndex index, boolean recurse ) - { - // get all the child nodes - for( Entry entry : index.getFieldCallers( m_entry ) ) - { - if( entry instanceof MethodEntry ) - { - add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (MethodEntry)entry ) ); - } - else if( entry instanceof ConstructorEntry ) - { - add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (ConstructorEntry)entry ) ); - } - } - - if( recurse && children != null ) - { - for( Object node : children ) - { - if( node instanceof MethodCallsTreeNode ) - { - ((MethodCallsTreeNode)node).load( index, true ); - } - } - } - } -} diff --git a/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java b/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java new file mode 100644 index 0000000..dd552d6 --- /dev/null +++ b/src/cuchaz/enigma/analysis/FieldReferenceTreeNode.java @@ -0,0 +1,92 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma.analysis; + +import javax.swing.tree.DefaultMutableTreeNode; + +import cuchaz.enigma.mapping.BehaviorEntry; +import cuchaz.enigma.mapping.FieldEntry; +import cuchaz.enigma.mapping.Translator; + +public class FieldReferenceTreeNode extends DefaultMutableTreeNode implements ReferenceTreeNode +{ + private static final long serialVersionUID = -7934108091928699835L; + + private Translator m_deobfuscatingTranslator; + private FieldEntry m_entry; + private EntryReference m_reference; + + public FieldReferenceTreeNode( Translator deobfuscatingTranslator, FieldEntry entry ) + { + m_deobfuscatingTranslator = deobfuscatingTranslator; + m_entry = entry; + m_reference = null; + } + + private FieldReferenceTreeNode( Translator deobfuscatingTranslator, EntryReference reference ) + { + m_deobfuscatingTranslator = deobfuscatingTranslator; + m_entry = reference.entry; + m_reference = reference; + } + + @Override + public FieldEntry getEntry( ) + { + return m_entry; + } + + @Override + public EntryReference getReference( ) + { + return m_reference; + } + + @Override + public String toString( ) + { + if( m_reference != null ) + { + return m_deobfuscatingTranslator.translateEntry( m_reference.caller ).toString(); + } + return m_deobfuscatingTranslator.translateEntry( m_entry ).toString(); + } + + public void load( JarIndex index, boolean recurse ) + { + // get all the child nodes + if( m_reference == null ) + { + for( EntryReference reference : index.getFieldReferences( m_entry ) ) + { + add( new FieldReferenceTreeNode( m_deobfuscatingTranslator, reference ) ); + } + } + else + { + for( EntryReference reference : index.getBehaviorReferences( m_reference.caller ) ) + { + add( new BehaviorReferenceTreeNode( m_deobfuscatingTranslator, reference ) ); + } + } + + if( recurse && children != null ) + { + for( Object node : children ) + { + if( node instanceof BehaviorReferenceTreeNode ) + { + ((BehaviorReferenceTreeNode)node).load( index, true ); + } + } + } + } +} diff --git a/src/cuchaz/enigma/analysis/JarIndex.java b/src/cuchaz/enigma/analysis/JarIndex.java index 7d68c35..f1c29c5 100644 --- a/src/cuchaz/enigma/analysis/JarIndex.java +++ b/src/cuchaz/enigma/analysis/JarIndex.java @@ -35,12 +35,15 @@ import javassist.expr.MethodCall; import javassist.expr.NewExpr; import com.google.common.collect.HashMultimap; +import com.google.common.collect.HashMultiset; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Multimap; +import com.google.common.collect.Multiset; import com.google.common.collect.Sets; import cuchaz.enigma.mapping.ArgumentEntry; +import cuchaz.enigma.mapping.BehaviorEntry; import cuchaz.enigma.mapping.ClassEntry; import cuchaz.enigma.mapping.ConstructorEntry; import cuchaz.enigma.mapping.Entry; @@ -53,8 +56,8 @@ public class JarIndex private Set m_obfClassNames; private Ancestries m_ancestries; private Multimap m_methodImplementations; - private Multimap m_methodCalls; - private Multimap m_fieldCalls; + private Multimap> m_behaviorReferences; + private Multimap> m_fieldReferences; private Multimap m_innerClasses; private Map m_outerClasses; private Set m_anonymousClasses; @@ -64,8 +67,8 @@ public class JarIndex m_obfClassNames = Sets.newHashSet(); m_ancestries = new Ancestries(); m_methodImplementations = HashMultimap.create(); - m_methodCalls = HashMultimap.create(); - m_fieldCalls = HashMultimap.create(); + m_behaviorReferences = HashMultimap.create(); + m_fieldReferences = HashMultimap.create(); m_innerClasses = HashMultimap.create(); m_outerClasses = Maps.newHashMap(); m_anonymousClasses = Sets.newHashSet(); @@ -128,7 +131,7 @@ public class JarIndex { // get the method entry String className = Descriptor.toJvmName( behavior.getDeclaringClass().getName() ); - final Entry thisEntry; + final BehaviorEntry thisEntry; if( behavior instanceof CtMethod ) { MethodEntry methodEntry = new MethodEntry( @@ -156,6 +159,7 @@ public class JarIndex // index method calls try { + final Multiset callNumbers = HashMultiset.create(); behavior.instrument( new ExprEditor( ) { @Override @@ -167,7 +171,13 @@ public class JarIndex call.getMethodName(), call.getSignature() ); - m_methodCalls.put( calledMethodEntry, thisEntry ); + callNumbers.add( calledMethodEntry ); + EntryReference reference = new EntryReference( + calledMethodEntry, + thisEntry, + callNumbers.count( calledMethodEntry ) - 1 + ); + m_behaviorReferences.put( calledMethodEntry, reference ); } @Override @@ -178,22 +188,33 @@ public class JarIndex new ClassEntry( className ), call.getFieldName() ); - m_fieldCalls.put( calledFieldEntry, thisEntry ); + callNumbers.add( calledFieldEntry ); + EntryReference reference = new EntryReference( + calledFieldEntry, + thisEntry, + callNumbers.count( calledFieldEntry ) - 1 + ); + m_fieldReferences.put( calledFieldEntry, reference ); } @Override public void edit( ConstructorCall call ) { + // TODO: save isSuper in the reference somehow boolean isSuper = call.getMethodName().equals( "super" ); - // TODO: make method reference class, update method calls tree to use Invocation instances - // this might end up being a big refactor... =( String className = Descriptor.toJvmName( call.getClassName() ); ConstructorEntry calledConstructorEntry = new ConstructorEntry( new ClassEntry( className ), call.getSignature() ); - m_methodCalls.put( calledConstructorEntry, thisEntry ); + callNumbers.add( calledConstructorEntry ); + EntryReference reference = new EntryReference( + calledConstructorEntry, + thisEntry, + callNumbers.count( calledConstructorEntry ) - 1 + ); + m_behaviorReferences.put( calledConstructorEntry, reference ); } @Override @@ -204,7 +225,13 @@ public class JarIndex new ClassEntry( className ), call.getSignature() ); - m_methodCalls.put( calledConstructorEntry, thisEntry ); + callNumbers.add( calledConstructorEntry ); + EntryReference reference = new EntryReference( + calledConstructorEntry, + thisEntry, + callNumbers.count( calledConstructorEntry ) - 1 + ); + m_behaviorReferences.put( calledConstructorEntry, reference ); } } ); } @@ -234,9 +261,9 @@ public class JarIndex new ClassEntry( Descriptor.toJvmName( c.getName() ) ), constructor.getMethodInfo().getDescriptor() ); - for( Entry callerEntry : getMethodCallers( constructorEntry ) ) + for( EntryReference reference : getBehaviorReferences( constructorEntry ) ) { - callerClasses.add( callerEntry.getClassEntry() ); + callerClasses.add( reference.caller.getClassEntry() ); } // is this called by exactly one class? @@ -388,7 +415,7 @@ public class JarIndex new ClassEntry( innerClassName ), constructor.getMethodInfo().getDescriptor() ); - if( getMethodCallers( constructorEntry ).size() != 1 ) + if( getBehaviorReferences( constructorEntry ).size() != 1 ) { return false; } @@ -469,14 +496,26 @@ public class JarIndex return rootNode; } - public Collection getFieldCallers( FieldEntry fieldEntry ) + @SuppressWarnings( "unchecked" ) + public Collection> getFieldReferences( FieldEntry fieldEntry ) { - return m_fieldCalls.get( fieldEntry ); + List> references = Lists.newArrayList(); + for( EntryReference reference : m_fieldReferences.get( fieldEntry ) ) + { + references.add( (EntryReference)reference ); + } + return references; } - public Collection getMethodCallers( Entry entry ) + @SuppressWarnings( "unchecked" ) + public Collection> getBehaviorReferences( BehaviorEntry behaviorEntry ) { - return m_methodCalls.get( entry ); + List> references = Lists.newArrayList(); + for( EntryReference reference : m_behaviorReferences.get( behaviorEntry ) ) + { + references.add( (EntryReference)reference ); + } + return references; } public Collection getInnerClasses( String obfOuterClassName ) @@ -498,85 +537,91 @@ public class JarIndex { m_ancestries.renameClasses( renames ); renameMultimap( renames, m_methodImplementations ); - renameMultimap( renames, m_methodCalls ); - renameMultimap( renames, m_fieldCalls ); + renameMultimap( renames, m_behaviorReferences ); + renameMultimap( renames, m_fieldReferences ); } - private void renameMultimap( Map renames, Multimap map ) + private void renameMultimap( Map renames, Multimap map ) { // for each key/value pair... - Set> entriesToAdd = Sets.newHashSet(); - Iterator> iter = map.entries().iterator(); + Set> entriesToAdd = Sets.newHashSet(); + Iterator> iter = map.entries().iterator(); while( iter.hasNext() ) { - Map.Entry entry = iter.next(); + Map.Entry entry = iter.next(); iter.remove(); - entriesToAdd.add( new AbstractMap.SimpleEntry( - renameEntry( renames, entry.getKey() ), - renameEntry( renames, entry.getValue() ) + entriesToAdd.add( new AbstractMap.SimpleEntry( + renameThing( renames, entry.getKey() ), + renameThing( renames, entry.getValue() ) ) ); } - for( Map.Entry entry : entriesToAdd ) + for( Map.Entry entry : entriesToAdd ) { map.put( entry.getKey(), entry.getValue() ); } } @SuppressWarnings( "unchecked" ) - private T renameEntry( Map renames, T entry ) + private T renameThing( Map renames, T thing ) { - if( entry instanceof String ) + if( thing instanceof String ) { - String stringEntry = (String)entry; + String stringEntry = (String)thing; if( renames.containsKey( stringEntry ) ) { return (T)renames.get( stringEntry ); } } - else if( entry instanceof ClassEntry ) + else if( thing instanceof ClassEntry ) { - ClassEntry classEntry = (ClassEntry)entry; - return (T)new ClassEntry( renameEntry( renames, classEntry.getClassName() ) ); + ClassEntry classEntry = (ClassEntry)thing; + return (T)new ClassEntry( renameThing( renames, classEntry.getClassName() ) ); } - else if( entry instanceof FieldEntry ) + else if( thing instanceof FieldEntry ) { - FieldEntry fieldEntry = (FieldEntry)entry; + FieldEntry fieldEntry = (FieldEntry)thing; return (T)new FieldEntry( - renameEntry( renames, fieldEntry.getClassEntry() ), + renameThing( renames, fieldEntry.getClassEntry() ), fieldEntry.getName() ); } - else if( entry instanceof ConstructorEntry ) + else if( thing instanceof ConstructorEntry ) { - ConstructorEntry constructorEntry = (ConstructorEntry)entry; + ConstructorEntry constructorEntry = (ConstructorEntry)thing; return (T)new ConstructorEntry( - renameEntry( renames, constructorEntry.getClassEntry() ), + renameThing( renames, constructorEntry.getClassEntry() ), constructorEntry.getSignature() ); } - else if( entry instanceof MethodEntry ) + else if( thing instanceof MethodEntry ) { - MethodEntry methodEntry = (MethodEntry)entry; + MethodEntry methodEntry = (MethodEntry)thing; return (T)new MethodEntry( - renameEntry( renames, methodEntry.getClassEntry() ), + renameThing( renames, methodEntry.getClassEntry() ), methodEntry.getName(), methodEntry.getSignature() ); } - else if( entry instanceof ArgumentEntry ) + else if( thing instanceof ArgumentEntry ) { - ArgumentEntry argumentEntry = (ArgumentEntry)entry; + ArgumentEntry argumentEntry = (ArgumentEntry)thing; return (T)new ArgumentEntry( - renameEntry( renames, argumentEntry.getMethodEntry() ), + renameThing( renames, argumentEntry.getMethodEntry() ), argumentEntry.getIndex(), argumentEntry.getName() ); } + else if( thing instanceof EntryReference ) + { + EntryReference reference = (EntryReference)thing; + reference.entry = renameThing( renames, reference.entry ); + return thing; + } else { - throw new Error( "Not an entry: " + entry ); + throw new Error( "Not an entry: " + thing ); } - return entry; + return thing; } } diff --git a/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java b/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java deleted file mode 100644 index b5cf4c3..0000000 --- a/src/cuchaz/enigma/analysis/MethodCallsTreeNode.java +++ /dev/null @@ -1,144 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2014 Jeff Martin. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Public License v3.0 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/gpl.html - * - * Contributors: - * Jeff Martin - initial API and implementation - ******************************************************************************/ -package cuchaz.enigma.analysis; - -import java.util.Set; - -import javax.swing.tree.DefaultMutableTreeNode; -import javax.swing.tree.TreeNode; - -import com.google.common.collect.Sets; - -import cuchaz.enigma.mapping.ConstructorEntry; -import cuchaz.enigma.mapping.Entry; -import cuchaz.enigma.mapping.MethodEntry; -import cuchaz.enigma.mapping.Translator; - -public class MethodCallsTreeNode extends DefaultMutableTreeNode -{ - private static final long serialVersionUID = -3658163700783307520L; - - private Translator m_deobfuscatingTranslator; - private MethodEntry m_methodEntry; - private ConstructorEntry m_constructorEntry; - - public MethodCallsTreeNode( Translator deobfuscatingTranslator, MethodEntry entry ) - { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_methodEntry = entry; - m_constructorEntry = null; - } - - public MethodCallsTreeNode( Translator deobfuscatingTranslator, ConstructorEntry entry ) - { - m_deobfuscatingTranslator = deobfuscatingTranslator; - m_methodEntry = null; - m_constructorEntry = entry; - } - - public MethodEntry getMethodEntry( ) - { - return m_methodEntry; - } - - public ConstructorEntry getConstructorEntry( ) - { - return m_constructorEntry; - } - - public Entry getEntry( ) - { - if( m_methodEntry != null ) - { - return m_methodEntry; - } - else if( m_constructorEntry != null ) - { - return m_constructorEntry; - } - throw new Error( "Illegal state!" ); - } - - @Override - public String toString( ) - { - if( m_methodEntry != null ) - { - String className = m_deobfuscatingTranslator.translateClass( m_methodEntry.getClassName() ); - if( className == null ) - { - className = m_methodEntry.getClassName(); - } - - String methodName = m_deobfuscatingTranslator.translate( m_methodEntry ); - if( methodName == null ) - { - methodName = m_methodEntry.getName(); - } - return className + "." + methodName + "()"; - } - else if( m_constructorEntry != null ) - { - String className = m_deobfuscatingTranslator.translateClass( m_constructorEntry.getClassName() ); - if( className == null ) - { - className = m_constructorEntry.getClassName(); - } - return className + "()"; - } - throw new Error( "Illegal state!" ); - } - - public void load( JarIndex index, boolean recurse ) - { - // get all the child nodes - for( Entry entry : index.getMethodCallers( getEntry() ) ) - { - if( entry instanceof MethodEntry ) - { - add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (MethodEntry)entry ) ); - } - else if( entry instanceof ConstructorEntry ) - { - add( new MethodCallsTreeNode( m_deobfuscatingTranslator, (ConstructorEntry)entry ) ); - } - } - - if( recurse && children != null ) - { - for( Object child : children ) - { - if( child instanceof MethodCallsTreeNode ) - { - MethodCallsTreeNode node = (MethodCallsTreeNode)child; - - // don't recurse into ancestor - Set ancestors = Sets.newHashSet(); - TreeNode n = (TreeNode)node; - while( n.getParent() != null ) - { - n = n.getParent(); - if( n instanceof MethodCallsTreeNode ) - { - ancestors.add( ((MethodCallsTreeNode)n).getEntry() ); - } - } - if( ancestors.contains( node.getEntry() ) ) - { - continue; - } - - node.load( index, true ); - } - } - } - } -} diff --git a/src/cuchaz/enigma/analysis/ReferenceTreeNode.java b/src/cuchaz/enigma/analysis/ReferenceTreeNode.java new file mode 100644 index 0000000..08ae39d --- /dev/null +++ b/src/cuchaz/enigma/analysis/ReferenceTreeNode.java @@ -0,0 +1,19 @@ +/******************************************************************************* + * Copyright (c) 2014 Jeff Martin. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Public License v3.0 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/gpl.html + * + * Contributors: + * Jeff Martin - initial API and implementation + ******************************************************************************/ +package cuchaz.enigma.analysis; + +import cuchaz.enigma.mapping.Entry; + +public interface ReferenceTreeNode +{ + T getEntry(); + EntryReference getReference(); +} diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java index f31eb1a..841d176 100644 --- a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java +++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java @@ -213,6 +213,20 @@ public class SourceIndexVisitor implements IAstVisitor return recurse( node, index ); } + @Override + public Void visitIdentifierExpression( IdentifierExpression node, SourceIndex index ) + { + MemberReference ref = node.getUserData( Keys.MEMBER_REFERENCE ); + if( ref != null ) + { + ClassEntry classEntry = new ClassEntry( ref.getDeclaringType().getInternalName() ); + FieldEntry fieldEntry = new FieldEntry( classEntry, ref.getName() ); + index.add( node.getIdentifierToken(), fieldEntry ); + } + + return recurse( node, index ); + } + private Void recurse( AstNode node, SourceIndex index ) { for( final AstNode child : node.getChildren() ) @@ -476,12 +490,6 @@ public class SourceIndexVisitor implements IAstVisitor return recurse( node, index ); } - @Override - public Void visitIdentifierExpression( IdentifierExpression node, SourceIndex index ) - { - return recurse( node, index ); - } - @Override public Void visitUnaryOperatorExpression( UnaryOperatorExpression node, SourceIndex index ) { diff --git a/src/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java index ac3e92d..12febef 100644 --- a/src/cuchaz/enigma/analysis/TreeDumpVisitor.java +++ b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java @@ -122,7 +122,7 @@ public class TreeDumpVisitor implements IAstVisitor // show the tree try { - m_out.write( getIndent( node ) + node.getClass().getSimpleName() + dumpUserData( node ) + " " + node.getRegion() + "\n" ); + m_out.write( getIndent( node ) + node.getClass().getSimpleName() + " " + getText( node ) + " " + dumpUserData( node ) + " " + node.getRegion() + "\n" ); } catch( IOException ex ) { @@ -137,6 +137,15 @@ public class TreeDumpVisitor implements IAstVisitor return null; } + private String getText( AstNode node ) + { + if( node instanceof Identifier ) + { + return "\"" + node.getText() + "\""; + } + return ""; + } + private String dumpUserData( AstNode node ) { StringBuilder buf = new StringBuilder(); -- cgit v1.2.3