From e7febe4549c9fcdf1e82239959b3c6a83fad8934 Mon Sep 17 00:00:00 2001 From: jeff Date: Sun, 10 Aug 2014 19:29:43 -0400 Subject: added go to entry feature --- src/cuchaz/enigma/analysis/SourceIndex.java | 11 +- src/cuchaz/enigma/analysis/SourceIndexVisitor.java | 48 +- src/cuchaz/enigma/analysis/TreeDumpVisitor.java | 550 +++++++++++++++++++++ src/cuchaz/enigma/gui/Gui.java | 52 +- src/cuchaz/enigma/gui/GuiController.java | 47 +- src/cuchaz/enigma/mapping/ArgumentEntry.java | 1 + src/cuchaz/enigma/mapping/ClassEntry.java | 6 + src/cuchaz/enigma/mapping/Entry.java | 1 + src/cuchaz/enigma/mapping/FieldEntry.java | 1 + src/cuchaz/enigma/mapping/MethodEntry.java | 1 + 10 files changed, 621 insertions(+), 97 deletions(-) create mode 100644 src/cuchaz/enigma/analysis/TreeDumpVisitor.java (limited to 'src') diff --git a/src/cuchaz/enigma/analysis/SourceIndex.java b/src/cuchaz/enigma/analysis/SourceIndex.java index 7981f87..ad94cf0 100644 --- a/src/cuchaz/enigma/analysis/SourceIndex.java +++ b/src/cuchaz/enigma/analysis/SourceIndex.java @@ -25,12 +25,14 @@ public class SourceIndex { private String m_source; private TreeMap m_tokens; + private Map m_declarations; private List m_lineOffsets; public SourceIndex( String source ) { m_source = source; m_tokens = Maps.newTreeMap(); + m_declarations = Maps.newHashMap(); m_lineOffsets = Lists.newArrayList(); // count the lines @@ -82,9 +84,11 @@ public class SourceIndex m_tokens.put( getToken( node ), entry ); } - public void add( Token token, Entry entry ) + public void addDeclaration( AstNode node, Entry entry ) { + Token token = getToken( node ); m_tokens.put( token, entry ); + m_declarations.put( entry, token ); } public Token getToken( int pos ) @@ -116,6 +120,11 @@ public class SourceIndex return m_tokens.keySet(); } + public Token getDeclarationToken( Entry entry ) + { + return m_declarations.get( entry ); + } + private int toPos( int line, int col ) { // line and col are 1-based diff --git a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java index 5a64e4e..0ba5996 100644 --- a/src/cuchaz/enigma/analysis/SourceIndexVisitor.java +++ b/src/cuchaz/enigma/analysis/SourceIndexVisitor.java @@ -16,7 +16,6 @@ import com.strobel.assembler.metadata.MethodDefinition; import com.strobel.assembler.metadata.ParameterDefinition; import com.strobel.assembler.metadata.TypeDefinition; import com.strobel.assembler.metadata.TypeReference; -import com.strobel.componentmodel.Key; import com.strobel.decompiler.languages.TextLocation; import com.strobel.decompiler.languages.java.ast.Annotation; import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression; @@ -149,7 +148,7 @@ public class SourceIndexVisitor implements IAstVisitor { ClassEntry classEntry = new ClassEntry( def.getDeclaringType().getInternalName() ); MethodEntry methodEntry = new MethodEntry( classEntry, def.getName(), def.getSignature() ); - index.add( node.getNameToken(), methodEntry ); + index.addDeclaration( node.getNameToken(), methodEntry ); } return recurse( node, index ); @@ -172,7 +171,7 @@ public class SourceIndexVisitor implements IAstVisitor MethodDefinition methodDef = (MethodDefinition)def.getMethod(); MethodEntry methodEntry = new MethodEntry( classEntry, methodDef.getName(), methodDef.getSignature() ); ArgumentEntry argumentEntry = new ArgumentEntry( methodEntry, def.getPosition(), def.getName() ); - index.add( node.getNameToken(), argumentEntry ); + index.addDeclaration( node.getNameToken(), argumentEntry ); return recurse( node, index ); } @@ -185,7 +184,7 @@ public class SourceIndexVisitor implements IAstVisitor FieldEntry fieldEntry = new FieldEntry( classEntry, def.getName() ); assert( node.getVariables().size() == 1 ); VariableInitializer variable = node.getVariables().firstOrNullObject(); - index.add( variable.getNameToken(), fieldEntry ); + index.addDeclaration( variable.getNameToken(), fieldEntry ); return recurse( node, index ); } @@ -194,16 +193,13 @@ public class SourceIndexVisitor implements IAstVisitor public Void visitTypeDeclaration( TypeDeclaration node, SourceIndex index ) { TypeDefinition def = node.getUserData( Keys.TYPE_DEFINITION ); - index.add( node.getNameToken(), new ClassEntry( def.getInternalName() ) ); + index.addDeclaration( node.getNameToken(), new ClassEntry( def.getInternalName() ) ); return recurse( node, index ); } private Void recurse( AstNode node, SourceIndex index ) { - // TEMP: show the tree - System.out.println( getIndent( node ) + node.getClass().getSimpleName() + dumpUserData( node ) + " " + node.getRegion() ); - for( final AstNode child : node.getChildren() ) { child.acceptVisitor( this, index ); @@ -211,42 +207,6 @@ public class SourceIndexVisitor implements IAstVisitor return null; } - private String dumpUserData( AstNode node ) - { - StringBuilder buf = new StringBuilder(); - for( Key key : Keys.ALL_KEYS ) - { - Object val = node.getUserData( key ); - if( val != null ) - { - buf.append( String.format( " [%s=%s]", key, val ) ); - } - } - return buf.toString(); - } - - private String getIndent( AstNode node ) - { - StringBuilder buf = new StringBuilder(); - int depth = getDepth( node ); - for( int i = 0; i < depth; i++ ) - { - buf.append( "\t" ); - } - return buf.toString(); - } - - private int getDepth( AstNode node ) - { - int depth = -1; - while( node != null ) - { - depth++; - node = node.getParent(); - } - return depth; - } - // OVERRIDES WE DON'T CARE ABOUT @Override diff --git a/src/cuchaz/enigma/analysis/TreeDumpVisitor.java b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java new file mode 100644 index 0000000..32607db --- /dev/null +++ b/src/cuchaz/enigma/analysis/TreeDumpVisitor.java @@ -0,0 +1,550 @@ +package cuchaz.enigma.analysis; + +import com.strobel.componentmodel.Key; +import com.strobel.decompiler.languages.java.ast.Annotation; +import com.strobel.decompiler.languages.java.ast.AnonymousObjectCreationExpression; +import com.strobel.decompiler.languages.java.ast.ArrayCreationExpression; +import com.strobel.decompiler.languages.java.ast.ArrayInitializerExpression; +import com.strobel.decompiler.languages.java.ast.ArraySpecifier; +import com.strobel.decompiler.languages.java.ast.AssertStatement; +import com.strobel.decompiler.languages.java.ast.AssignmentExpression; +import com.strobel.decompiler.languages.java.ast.AstNode; +import com.strobel.decompiler.languages.java.ast.BinaryOperatorExpression; +import com.strobel.decompiler.languages.java.ast.BlockStatement; +import com.strobel.decompiler.languages.java.ast.BreakStatement; +import com.strobel.decompiler.languages.java.ast.CaseLabel; +import com.strobel.decompiler.languages.java.ast.CastExpression; +import com.strobel.decompiler.languages.java.ast.CatchClause; +import com.strobel.decompiler.languages.java.ast.ClassOfExpression; +import com.strobel.decompiler.languages.java.ast.Comment; +import com.strobel.decompiler.languages.java.ast.CompilationUnit; +import com.strobel.decompiler.languages.java.ast.ComposedType; +import com.strobel.decompiler.languages.java.ast.ConditionalExpression; +import com.strobel.decompiler.languages.java.ast.ConstructorDeclaration; +import com.strobel.decompiler.languages.java.ast.ContinueStatement; +import com.strobel.decompiler.languages.java.ast.DoWhileStatement; +import com.strobel.decompiler.languages.java.ast.EmptyStatement; +import com.strobel.decompiler.languages.java.ast.EnumValueDeclaration; +import com.strobel.decompiler.languages.java.ast.ExpressionStatement; +import com.strobel.decompiler.languages.java.ast.FieldDeclaration; +import com.strobel.decompiler.languages.java.ast.ForEachStatement; +import com.strobel.decompiler.languages.java.ast.ForStatement; +import com.strobel.decompiler.languages.java.ast.GotoStatement; +import com.strobel.decompiler.languages.java.ast.IAstVisitor; +import com.strobel.decompiler.languages.java.ast.Identifier; +import com.strobel.decompiler.languages.java.ast.IdentifierExpression; +import com.strobel.decompiler.languages.java.ast.IfElseStatement; +import com.strobel.decompiler.languages.java.ast.ImportDeclaration; +import com.strobel.decompiler.languages.java.ast.IndexerExpression; +import com.strobel.decompiler.languages.java.ast.InstanceInitializer; +import com.strobel.decompiler.languages.java.ast.InstanceOfExpression; +import com.strobel.decompiler.languages.java.ast.InvocationExpression; +import com.strobel.decompiler.languages.java.ast.JavaTokenNode; +import com.strobel.decompiler.languages.java.ast.Keys; +import com.strobel.decompiler.languages.java.ast.LabelStatement; +import com.strobel.decompiler.languages.java.ast.LabeledStatement; +import com.strobel.decompiler.languages.java.ast.LambdaExpression; +import com.strobel.decompiler.languages.java.ast.LocalTypeDeclarationStatement; +import com.strobel.decompiler.languages.java.ast.MemberReferenceExpression; +import com.strobel.decompiler.languages.java.ast.MethodDeclaration; +import com.strobel.decompiler.languages.java.ast.MethodGroupExpression; +import com.strobel.decompiler.languages.java.ast.NewLineNode; +import com.strobel.decompiler.languages.java.ast.NullReferenceExpression; +import com.strobel.decompiler.languages.java.ast.ObjectCreationExpression; +import com.strobel.decompiler.languages.java.ast.PackageDeclaration; +import com.strobel.decompiler.languages.java.ast.ParameterDeclaration; +import com.strobel.decompiler.languages.java.ast.ParenthesizedExpression; +import com.strobel.decompiler.languages.java.ast.PrimitiveExpression; +import com.strobel.decompiler.languages.java.ast.ReturnStatement; +import com.strobel.decompiler.languages.java.ast.SimpleType; +import com.strobel.decompiler.languages.java.ast.SuperReferenceExpression; +import com.strobel.decompiler.languages.java.ast.SwitchSection; +import com.strobel.decompiler.languages.java.ast.SwitchStatement; +import com.strobel.decompiler.languages.java.ast.SynchronizedStatement; +import com.strobel.decompiler.languages.java.ast.TextNode; +import com.strobel.decompiler.languages.java.ast.ThisReferenceExpression; +import com.strobel.decompiler.languages.java.ast.ThrowStatement; +import com.strobel.decompiler.languages.java.ast.TryCatchStatement; +import com.strobel.decompiler.languages.java.ast.TypeDeclaration; +import com.strobel.decompiler.languages.java.ast.TypeParameterDeclaration; +import com.strobel.decompiler.languages.java.ast.TypeReferenceExpression; +import com.strobel.decompiler.languages.java.ast.UnaryOperatorExpression; +import com.strobel.decompiler.languages.java.ast.VariableDeclarationStatement; +import com.strobel.decompiler.languages.java.ast.VariableInitializer; +import com.strobel.decompiler.languages.java.ast.WhileStatement; +import com.strobel.decompiler.languages.java.ast.WildcardType; +import com.strobel.decompiler.patterns.Pattern; + +public class TreeDumpVisitor implements IAstVisitor +{ + private Void recurse( AstNode node, Void ignored ) + { + // show the tree + System.out.println( getIndent( node ) + node.getClass().getSimpleName() + dumpUserData( node ) + " " + node.getRegion() ); + + // recurse + for( final AstNode child : node.getChildren() ) + { + child.acceptVisitor( this, ignored ); + } + return null; + } + + private String dumpUserData( AstNode node ) + { + StringBuilder buf = new StringBuilder(); + for( Key key : Keys.ALL_KEYS ) + { + Object val = node.getUserData( key ); + if( val != null ) + { + buf.append( String.format( " [%s=%s]", key, val ) ); + } + } + return buf.toString(); + } + + private String getIndent( AstNode node ) + { + StringBuilder buf = new StringBuilder(); + int depth = getDepth( node ); + for( int i = 0; i < depth; i++ ) + { + buf.append( "\t" ); + } + return buf.toString(); + } + + private int getDepth( AstNode node ) + { + int depth = -1; + while( node != null ) + { + depth++; + node = node.getParent(); + } + return depth; + } + + // OVERRIDES WE DON'T CARE ABOUT + + @Override + public Void visitInvocationExpression( InvocationExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitMemberReferenceExpression( MemberReferenceExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitSimpleType( SimpleType node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitMethodDeclaration( MethodDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitConstructorDeclaration( ConstructorDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitParameterDeclaration( ParameterDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitFieldDeclaration( FieldDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitTypeDeclaration( TypeDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitComment( Comment node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitPatternPlaceholder( AstNode node, Pattern pattern, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitTypeReference( TypeReferenceExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitJavaTokenNode( JavaTokenNode node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitIdentifier( Identifier node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitNullReferenceExpression( NullReferenceExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitThisReferenceExpression( ThisReferenceExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitSuperReferenceExpression( SuperReferenceExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitClassOfExpression( ClassOfExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitBlockStatement( BlockStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitExpressionStatement( ExpressionStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitBreakStatement( BreakStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitContinueStatement( ContinueStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitDoWhileStatement( DoWhileStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitEmptyStatement( EmptyStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitIfElseStatement( IfElseStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitLabelStatement( LabelStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitLabeledStatement( LabeledStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitReturnStatement( ReturnStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitSwitchStatement( SwitchStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitSwitchSection( SwitchSection node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitCaseLabel( CaseLabel node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitThrowStatement( ThrowStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitCatchClause( CatchClause node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitAnnotation( Annotation node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitNewLine( NewLineNode node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitVariableDeclaration( VariableDeclarationStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitVariableInitializer( VariableInitializer node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitText( TextNode node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitImportDeclaration( ImportDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitInitializerBlock( InstanceInitializer node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitTypeParameterDeclaration( TypeParameterDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitCompilationUnit( CompilationUnit node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitPackageDeclaration( PackageDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitArraySpecifier( ArraySpecifier node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitComposedType( ComposedType node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitWhileStatement( WhileStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitPrimitiveExpression( PrimitiveExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitCastExpression( CastExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitBinaryOperatorExpression( BinaryOperatorExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitInstanceOfExpression( InstanceOfExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitIndexerExpression( IndexerExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitIdentifierExpression( IdentifierExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitUnaryOperatorExpression( UnaryOperatorExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitConditionalExpression( ConditionalExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitArrayInitializerExpression( ArrayInitializerExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitObjectCreationExpression( ObjectCreationExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitArrayCreationExpression( ArrayCreationExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitAssignmentExpression( AssignmentExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitForStatement( ForStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitForEachStatement( ForEachStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitTryCatchStatement( TryCatchStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitGotoStatement( GotoStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitParenthesizedExpression( ParenthesizedExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitSynchronizedStatement( SynchronizedStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitAnonymousObjectCreationExpression( AnonymousObjectCreationExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitWildcardType( WildcardType node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitMethodGroupExpression( MethodGroupExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitEnumValueDeclaration( EnumValueDeclaration node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitAssertStatement( AssertStatement node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitLambdaExpression( LambdaExpression node, Void ignored ) + { + return recurse( node, ignored ); + } + + @Override + public Void visitLocalTypeDeclarationStatement( LocalTypeDeclarationStatement node, Void ignored ) + { + return recurse( node, ignored ); + } +} diff --git a/src/cuchaz/enigma/gui/Gui.java b/src/cuchaz/enigma/gui/Gui.java index 79becf8..bf72c85 100644 --- a/src/cuchaz/enigma/gui/Gui.java +++ b/src/cuchaz/enigma/gui/Gui.java @@ -63,7 +63,6 @@ import javax.swing.tree.TreeNode; import javax.swing.tree.TreePath; import jsyntaxpane.DefaultSyntaxKit; -import jsyntaxpane.SyntaxDocument; import com.google.common.collect.Lists; @@ -257,6 +256,10 @@ public class Gui startRename(); break; + case KeyEvent.VK_I: + showInheritance(); + break; + case KeyEvent.VK_O: openEntry(); break; @@ -296,10 +299,11 @@ public class Gui } } ); popupMenu.add( menu ); + menu.setAccelerator( KeyStroke.getKeyStroke( KeyEvent.VK_I, 0 ) ); m_inheritanceMenu = menu; } { - JMenuItem menu = new JMenuItem( "Open Class" ); + JMenuItem menu = new JMenuItem( "Go to Declaration" ); menu.addActionListener( new ActionListener( ) { @Override @@ -598,34 +602,13 @@ public class Gui public void setSource( String source ) { - setSource( source, 0 ); + m_editor.getHighlighter().removeAllHighlights(); + m_editor.setText( source ); } - public void setSource( String source, int lineNum ) + public void showToken( Token token ) { - // remove any old highlighters - m_editor.getHighlighter().removeAllHighlights(); - - m_editor.setText( source ); - - // count the offset of the target line - String text = m_editor.getText(); - int pos = 0; - int numLines = 0; - for( ; pos < text.length(); pos++ ) - { - if( numLines == lineNum ) - { - break; - } - if( text.charAt( pos ) == '\n' ) - { - numLines++; - } - } - - // put the caret at the line number - m_editor.setCaretPosition( pos ); + m_editor.setCaretPosition( token.start ); m_editor.grabFocus(); } @@ -760,12 +743,13 @@ public class Gui m_selectedEntryPair = m_controller.getEntryPair( token ); boolean isClassEntry = m_selectedEntryPair.obf instanceof ClassEntry; + boolean isFieldEntry = m_selectedEntryPair.obf instanceof FieldEntry; boolean isMethodEntry = m_selectedEntryPair.obf instanceof MethodEntry; showEntryPair( m_selectedEntryPair ); m_inheritanceMenu.setEnabled( isClassEntry || isMethodEntry ); - m_openEntryMenu.setEnabled( isClassEntry ); + m_openEntryMenu.setEnabled( isClassEntry || isFieldEntry || isMethodEntry ); } private void startRename( ) @@ -807,12 +791,9 @@ public class Gui String newName = text.getText(); if( saveName && newName != null && newName.length() > 0 ) { - SyntaxDocument doc = (SyntaxDocument)m_editor.getDocument(); - int lineNum = doc.getLineNumberAt( m_editor.getCaretPosition() ); try { - // TODO: give token to the controller so we can put the caret back there - m_controller.rename( m_selectedEntryPair.obf, newName, lineNum ); + m_controller.rename( m_selectedEntryPair.obf, newName ); } catch( IllegalNameException ex ) { @@ -869,12 +850,7 @@ public class Gui { return; } - - // get the current class - if( m_selectedEntryPair.obf instanceof ClassEntry ) - { - m_controller.deobfuscateClass( new ClassFile( m_selectedEntryPair.obf.getName() ) ); - } + m_controller.openEntry( m_selectedEntryPair.obf ); } private void close( ) diff --git a/src/cuchaz/enigma/gui/GuiController.java b/src/cuchaz/enigma/gui/GuiController.java index e0aad86..834afec 100644 --- a/src/cuchaz/enigma/gui/GuiController.java +++ b/src/cuchaz/enigma/gui/GuiController.java @@ -77,7 +77,7 @@ public class GuiController m_isDirty = false; m_gui.setMappingsFile( file ); refreshClasses(); - refreshOpenFiles(); + refreshCurrentClass(); } public void saveMappings( File file ) @@ -94,7 +94,7 @@ public class GuiController m_deobfuscator.setMappings( null ); m_gui.setMappingsFile( null ); refreshClasses(); - refreshOpenFiles(); + refreshCurrentClass(); } public void deobfuscateClass( ClassFile classFile ) @@ -157,12 +157,26 @@ public class GuiController return thisNode; } - public void rename( Entry obfsEntry, String newName, int lineNum ) + public void rename( Entry obfEntry, String newName ) { - m_deobfuscator.rename( obfsEntry, newName ); + m_deobfuscator.rename( obfEntry, newName ); m_isDirty = true; refreshClasses(); - refreshOpenFiles( lineNum ); + refreshCurrentClass( m_deobfuscator.deobfuscateEntry( obfEntry ) ); + } + + public void openEntry( Entry obfEntry ) + { + Entry deobfEntry = m_deobfuscator.deobfuscateEntry( obfEntry ); + if( !m_currentFile.getName().equals( obfEntry.getClassName() ) ) + { + m_currentFile = new ClassFile( obfEntry.getClassName() ); + deobfuscate( m_currentFile, deobfEntry ); + } + else + { + m_gui.showToken( m_index.getDeclarationToken( deobfEntry ) ); + } } private void refreshClasses( ) @@ -173,27 +187,28 @@ public class GuiController m_gui.setObfClasses( obfClasses ); m_gui.setDeobfClasses( deobfClasses ); } - - private void refreshOpenFiles( ) + + private void refreshCurrentClass( ) { - refreshOpenFiles( 0 ); + refreshCurrentClass( null ); } - private void refreshOpenFiles( int lineNum ) + private void refreshCurrentClass( Entry entryToShow ) { if( m_currentFile != null ) { - deobfuscate( m_currentFile, lineNum ); + deobfuscate( m_currentFile, entryToShow ); } } private void deobfuscate( final ClassFile classFile ) { - deobfuscate( classFile, 0 ); + deobfuscate( classFile, null ); } - private void deobfuscate( final ClassFile classFile, final int lineNum ) + private void deobfuscate( final ClassFile classFile, final Entry entryToShow ) { + m_currentFile = classFile; m_gui.setSource( "(deobfuscating...)" ); // run the deobfuscator in a separate thread so we don't block the GUI event queue @@ -202,9 +217,13 @@ public class GuiController @Override public void run( ) { - // decopmile,deobfuscate the bytecode + // decompile,deobfuscate the bytecode m_index = m_deobfuscator.getSource( classFile ); - m_gui.setSource( m_index.getSource(), lineNum ); + m_gui.setSource( m_index.getSource() ); + if( entryToShow != null ) + { + m_gui.showToken( m_index.getDeclarationToken( entryToShow ) ); + } // set the highlighted tokens List obfuscatedTokens = Lists.newArrayList(); diff --git a/src/cuchaz/enigma/mapping/ArgumentEntry.java b/src/cuchaz/enigma/mapping/ArgumentEntry.java index c1624a8..0c25c4d 100644 --- a/src/cuchaz/enigma/mapping/ArgumentEntry.java +++ b/src/cuchaz/enigma/mapping/ArgumentEntry.java @@ -70,6 +70,7 @@ public class ArgumentEntry implements Entry, Serializable return m_methodEntry.getClassEntry(); } + @Override public String getClassName( ) { return m_methodEntry.getClassName(); diff --git a/src/cuchaz/enigma/mapping/ClassEntry.java b/src/cuchaz/enigma/mapping/ClassEntry.java index 0968e95..513862d 100644 --- a/src/cuchaz/enigma/mapping/ClassEntry.java +++ b/src/cuchaz/enigma/mapping/ClassEntry.java @@ -44,6 +44,12 @@ public class ClassEntry implements Entry, Serializable return m_name; } + @Override + public String getClassName( ) + { + return m_name; + } + @Override public int hashCode( ) { diff --git a/src/cuchaz/enigma/mapping/Entry.java b/src/cuchaz/enigma/mapping/Entry.java index 1443532..3ff8027 100644 --- a/src/cuchaz/enigma/mapping/Entry.java +++ b/src/cuchaz/enigma/mapping/Entry.java @@ -13,4 +13,5 @@ package cuchaz.enigma.mapping; public interface Entry { String getName( ); + String getClassName( ); } diff --git a/src/cuchaz/enigma/mapping/FieldEntry.java b/src/cuchaz/enigma/mapping/FieldEntry.java index eefc4c4..6148c84 100644 --- a/src/cuchaz/enigma/mapping/FieldEntry.java +++ b/src/cuchaz/enigma/mapping/FieldEntry.java @@ -60,6 +60,7 @@ public class FieldEntry implements Entry, Serializable return m_name; } + @Override public String getClassName( ) { return m_classEntry.getName(); diff --git a/src/cuchaz/enigma/mapping/MethodEntry.java b/src/cuchaz/enigma/mapping/MethodEntry.java index 9ea2d08..ff232c5 100644 --- a/src/cuchaz/enigma/mapping/MethodEntry.java +++ b/src/cuchaz/enigma/mapping/MethodEntry.java @@ -72,6 +72,7 @@ public class MethodEntry implements Entry, Serializable return m_signature; } + @Override public String getClassName( ) { return m_classEntry.getName(); -- cgit v1.2.3