1 / 30

Reverse Engineering Java Using ASF+SDF and Rigi

Reverse Engineering Java Using ASF+SDF and Rigi. A preliminary experience report. Contents. Introduction to Rigi and the Rsf format Java2RSF: Translating with an ASF+SDF specification Visualizing Java code smells in Rigi. Intro to Rigi and RSF. What is Rigi?.

gagan
Télécharger la présentation

Reverse Engineering Java Using ASF+SDF and Rigi

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Reverse Engineering Java Using ASF+SDF and Rigi A preliminary experience report Eva van Emden, CWI

  2. Contents • Introduction to Rigi and the Rsf format • Java2RSF: Translating with an ASF+SDF specification • Visualizing Java code smells in Rigi Eva van Emden, CWI

  3. Intro to Rigi and RSF What is Rigi? • Visual reverse engineering tool • Rigi represents a program as a collection of nodes and arcs • Nodes represent features in the program, such as methods or classes • Arcs represent relationships between the nodes, such as “contain” or “call” • Different views can be created by: • Filtering out certain node and arc types • Using the built-in layout algorithms • Writing scripts in the Rigi command language (RCL) Eva van Emden, CWI

  4. Intro to Rigi and RSF Rigi Screenshot A subsystem hierarchy view for a C program Eva van Emden, CWI

  5. Intro to Rigi and RSF Rigi standard format (RSF) • Interchange format between parsing and processing • Graph description language • Simple text file • Each line describes a node, arc, or attribute • There are tools to translate between RSF and the GXL Graph Exchange Format Eva van Emden, CWI

  6. Intro to Rigi and RSF RSF rsf-file: <rsf-tuples> rsf-tuples: <rsf-tuple> “/n” <rsf-tuples> rsf-tuple: <node-definition> <arc-definition> <attribute-definition> node-definition: “type” <node-spec> <node-type> arc-definition: <arc-type> <node-spec> <node-spec> attribute-definition: <attribute-type> <node-spec> <attribute-value> node-spec: <identifier> node-type: <identifier> arc-type: <identifier> attribute-type: <identifier> attribute-value: <identifier> Eva van Emden, CWI

  7. Intro to Rigi and RSF Structured RSF • Each node has a unique number • The file must start with a root and there must be "level" arcs connecting the root node to every node in the top level of the graph Eva van Emden, CWI

  8. Intro to Rigi and RSF Rigi Domains • A collection of node, arc, and attribute types used to describe a particular language • Specified by creating a new directory with the name of the domain in the Rigi domain directory and adding text files specifying valid node, arc, and attribute types Eva van Emden, CWI

  9. Intro to Rigi and RSF The Rigi Java Domain • Nodes: Package, Class, Interface, Method, Constructor, Variable etc. • Arcs: contain, call, access, isSuper, implementedBy etc. • Attributes: visibility, static, abstract etc. Eva van Emden, CWI

  10. Java2RSF Java to RSF Translation SDF Java Specification SDF Java2RSF ASF Specification SDF Parser Generator ASF Compiler Java Sources Parser Java2RSF Parse Table RSF Eva van Emden, CWI

  11. Java2RSF SDF Java Specification • Java grammar taken from online grammar base • Some modifications made before it parsed all input files successfully Eva van Emden, CWI

  12. Java2RSF Java RSF Specification • Describes RSF in the Java domain • Makes use of standard ASF library components • Refers to certain Java modules Eva van Emden, CWI

  13. Java2RSF Specification of Full Translator Eva van Emden, CWI

  14. Java2RSF Rewriting • Recognize certain Java constructs and output corresponding RSF e.g. becomes public class Square { public Position xpos; } type Square Class type xpos Variable contain Square xpos Eva van Emden, CWI

  15. Java2RSF Rewriting: Traversal Functions • Function signature in SDF specification: • methodinv(Block, RsfTuple*, Name, Name) -> RsfTuple* {traversal(accu, bottom-up)} • methodinv(MethodInvocation, RsfTuple*, Name, Name) -> RsfTuple* {traversal(accu, bottom-up)} Eva van Emden, CWI

  16. Java2RSF Rewriting: TraversalFunctions (2) methodinv traversal function is called in ASF: [mb1] Methodbdy(_Block,_RsfTuple*,_MethodName,_ClassId) = _RsfTuple* methodinv(_Block, , _MethodName, _ClassId) Eva van Emden, CWI

  17. Java2RSF Rewriting: TraversalFunctions (3) Rewrite rule for a methodinv match: [mi1] _Type=getType(_Identifier0), _MethodName2 = _Type._Identifier1 ====================================================== methodinv(_Identifier0._Identifier1(_ExpressionList*), _RsfTuple*,_MethodName1,_ClassId) = _RsfTuple* call _MethodName1 _MethodName2 Eva van Emden, CWI

  18. Java2RSF The Power of Traversal Functions • Consider how many possibilities there are for a method invocation to appear in a statement: • s.draw(); • if (s.isBlue()){…}; • current = (Shape)list.getNext(); • java.lang.Math.max(s.getx(), s.gety()); • Very tedious and error-prone to write rules to match all of these possibilities by hand Eva van Emden, CWI

  19. Visualizing Code Smells Using Rigi to Provide Refactoring Support • Test system of 60 000+ loc • System is being refactored to improve maintainability • Decided to display code smells to see if visualizing them could be useful • What are code smells? • A code smell is a symptom that may indicate something wrong in the code (Beck and Fowler) • A clustering of a code smells visible in Rigi may indicate a class or package that needs to be refactored Eva van Emden, CWI

  20. Visualizing Code Smells Visualization Options • colour nodes according to degree of smell present (i.e. red smells, green does not), but this can’t be done in rigi • Each instance of a smell appears as a node attached to the method or class • Smells currently implemented: • Typecasts • Instanceof • Switch statements Eva van Emden, CWI

  21. Visualizing Code Smells Smell Detection: ASF+SDF • New smell detection module added to ASF+SDF specification SDF: smell(Block, RsfTuple*, Name, Name) -> RsfTuple* {traversal(accu,bottom-up)} smell(Expression, RsfTuple*, Name, Name) -> RsfTuple* {traversal(accu,bottom-up)} ASF: [s2] smell(_Expression instanceof _ReferenceType, _RsfTuple*,_MethodName, _ClassId) = _RsfTuple* type _NodeSpec Instanceof contain _MethodName _NodeSpec Eva van Emden, CWI

  22. Visualizing Code Smells Smell Detection: RSF • Now a problem shows up: if method “draw” in the Java code contains two instanceofs, we get the following RSF: type instanceof Instanceof type instanceof Instanceof contain draw instanceof contain draw instanceof Eva van Emden, CWI

  23. Visualizing Code Smells Solution: Adding Structure to the RSF • Standard RSF deletes all duplicate lines and therefore cannot have two nodes with the same name • To allow multiple smell nodes to show I had to switch to producing partially structured RSF type 1!Root Unknown type 2!draw Method level 1!Root 2!draw type 3!instanceof Instanceof level 1!Root 3!instanceof type 4!instanceof Instanceof level 1!Root 4!instanceof contain 2!draw 3!instanceof contain 2!draw 4!instanceof type instanceof Instanceof type instanceof Instanceof contain draw instanceof contain draw instanceof Becomes Eva van Emden, CWI

  24. Visualizing Code Smells Smell Detection: Adding Structure to the RSF • Add a structuring module to the existing specification structuring module unstructured rsf structured rsf • Structuring process: • Unique all the rsf tuples • Take all the node names and assign them unique node numbers • Replace all node names with the numbered version • Place a level tuple after each node definition Eva van Emden, CWI

  25. Visualizing Code Smells Smell Detection: Rigi Display • Add smell node types to the Java domain in Rigi • Write a script in the Rigi command language to produce a meaningful view in Rigi Eva van Emden, CWI

  26. Visualizing Code Smells Rigi View 1 All nodes except classes, methods, constructors and typecasts have been filtered out and a layout algorithm applied. Eva van Emden, CWI

  27. Visualizing Code Smells Rigi View 2: Show Smell By Class • methods collapsed into their classes • All the casts inside a class are attached to that class… Eva van Emden, CWI

  28. Visualizing Code Smells Rigi View 2: Show Smell By Class (2) • …but a class node can be opened to show the members inside with their cast nodes attached Eva van Emden, CWI

  29. Visualizing Code Smells Where to Go From Here? • Continue to experiment with views • Expand to displaying further code smells • Find a way to make the specification more efficient • Small programs (several kloc) ok • Does not finish in reasonable time (at all) on our 60 kloc test system • Finish making the specification correct and complete • Still some problems with getting types to show method calls properly Eva van Emden, CWI

  30. Eva van Emden, CWI

More Related