VMTS Solution of Case Study: Reverse Engineering

Transcription

1 VMTS Solution of Case Study: Reverse Engineering László Angyal, Tamás Vajk, and Gergely Mezei Budapest University of Technology and Economics, Budapest 1111, Hungary, WWW home page: Abstract. Model-driven software development makes models and model transformations first-class citizens in software development. Program code and corresponding models evolve parallelly, thus round-trip engineering is highly required. Program code to model transformation plays a key role in program comprehension and examination as examining models is simpler than processing program code. In this paper, we introduce our solution to the reverse engineering case at GraBaTs 09 tool contest, in which filtering and transformation tasks have been proposed. The given solution utilizes model transformation described by graph transformation rules and a control flow language. 1 Introduction Model-driven software development approaches (for example Model-Integrated Computing and OMG s Model-Driven Architecture) emphasize the use of models at all stages of system development. They have placed model-based approaches to software development into focus. Model transformations appear in many, different situations in a model-based development process. Model-based development and model-based environments are driven by model transformations. Our environment, Visual Modeling and Transformation System (VMTS) [1] supports editing models according to their metamodels, and allows specifying constraints written in textual languages, such as OCL and C#. Models are formalized as directed, labeled graphs. VMTS uses a simplified class diagram for its root metamodel ( visual vocabulary ). VMTS not only facilitates rapid modeling language development and modeling, but also efficient model processing techniques. There are two main means to access the models: (i) traversing model processors and (ii) visual model processors. Traversing processors access the models via an automatically generated, object-oriented programming interface. It usually traverses the model graph, and the processing code is described in a general purpose language. In VMTS, the graph rewriting based transformations are defined with the use of two modeling languages: the Visual Control Flow Language (VCFL) and the Visual Transformation Definition Language (VTDL). The activity diagram-like VCFL models control the execution order of the rewriting rules, while the rewriting rules are

2 expressed with VTDL models. These VTDL models define the searched (left hand side, LHS) pattern and the replacement (right hand side, RHS) pattern of a rewriting rule. Actually in VMTS the LHS and the RHS patterns are merged into a single model. Our transformation engine applies an instance-based matcher with both OCL and C# script support for constraint definition. In case of this engine, both the control flow models and the rewriting rules are processed with traversing processors and converted into executable code. With this technique VMTS model transformation engine represents a performance efficient model processing environment. 2 Problem Interpretation This paper is based on a case study for the GraBaTs 09 contest. In the case description [2], three main tasks have been given to perform different analysis on models of Java source code. The first task is to find all the type definitions that contains factory methods, meaning public, static methods that return instances of the given type. The second task is to provide a transformation that translates a sample Java method body into a control-flow model. Finally, the third task is to convert the previously created control-flow model into a program dependency graph (PDG). The aim of these tasks is to facilitate program comprehension with generating the necessary models. The given tasks test the scalability of the utilized tool and that whether it is capable of working on several models corresponding to different metamodels. In this paper, we provide solutions for the first two problems cases. 3 Solution In this section, the solutions to the filtering and the program code to control-flow transformation are given. 3.1 Filtering Query In our tool, filtering the given input model is performed with the transformation rule depicted in Fig. 1. The illustrated rule matches a TypeDeclaration containing a SimpleName and a MethodDeclaration. VMTS matches only those method declaration elements that contains two Modifier elements: a public and a static one. These constraints are given in C# illustrated in Fig. 2. Furthermore, the method declaration matched needs to have a SimpleType as return type with a SimpleName element. A constraint has been given to check that the name of the return type equals the name of the type declaration (see Fig. 2). Finally, the rule copies the type declaration and its name to the output model. (Actually, the output model is not saved in the transformation, only the fullyqualifiedname attribute value is written to the console.)

3 Fig. 1. Filter rule in VMTS PublicModifier.Attributes.Ecpublic == true PublicModifier.Attributes.Ecstatic == true TypeName.Attributes.EcfullyQualifiedName == SimpleName.Attributes.EcfullyQualifiedName Fig. 2. Constraints in the filter transformation rule 3.2 Control-Flow Transformation In order to perform the Control-Flow transformation, we have created a sample instance model, a small piece of code taken from [2], that corresponds to the Java AST metamodel. The input model represented in textual form is as follows: prod = 1; k= 1; while(k<=10) { prod = prod *k; k++; } System.out.print(k); System.out.print(prod); In our tool, the computation of the CFG for the example was solved by 10 transformation rules depicted in Fig. 3. The algorithm implemented by the graph transformation rules is elaborated in Fig. 4. We have used four global transformation variables (called storages in VMTS) to store states of the processing and in order to implement a Breath-First Search traversal of the AST model. The idea behind the CFG building is the repetitive insertion of nodes between the previously inserted node PrevNode (AbstractNode) and the last node NextNode (AbstractNode) of the statement block BlockToProcess (Block). When inserting an IterationNode (e.g. While cycle) into the CFG, it will be added to the list

4 of special nodes: ComplexNodes. The inner blocks of nodes contained by ComplexNodes are also processed by setting the BlockToProcess and starting again while there are unprocessed statements. The presented algorithm can be easily completed to support all kinds of special nodes: conditional and iteration and jump statements as well. Fig. 3. The control flow of the graph transformation rules The rule illustrated in Fig. 5 is the transformation step InsertRule that is responsible for inserting a new Node into the CFG container between the two connected nodes, the Previous and the Next. The existing outgoing edge (a) is reconnected (b) to the newly inserted node and a new CFG flow edge (c) is also created. The inserted Node will store the statement from which it was created (using a custom property Tag provided for each node and edge in VMTS). 4 Conclusions and Results This paper has presented the VMTS-based solution for the querying transformations executed on the Java input models. The given filtering solution returns the name of the types that contains factory methods. (Apt6Plugin for the first input and Apt6Plugin and AptUIPlugin for the second input) Performance measurements have been executed on an Intel Core 2 Duo E8400 3GHz machine with 4 GB of memory and Windows Vista Business operating system. The measured results are illustrated in Table 1.

5 1 Create Enter, Exit and CFGraph container nodes 2 Set PrevNode = Enter, NextNode = Exit 3 Set BlockToProcess = the body block of the method 4 Set ComplexNodes = Empty List 5 6 While there is unprocessed statement in BlockToProcess 7 ForEach statement in BlockToProcess 8 9 If (statement == "WhileStatement") 10 Create IterationNode between PrevNode and NextNode 11 Add IterationNode into ComplexNodes 12 Set PrevNode = IterationNode Else if (PrevNode == NextNode) 15 Insert new Node into the SelfLoop edge of PrevNode Else if (PrevNode!= NextNode) 18 Create Node between PrevNode and NextNode ForEach expression in statement 21 Create Expression into Node 22 Set Expression.isIdentifier = (expression == "FieldAccess") ForEach innerexpression that can be reached from expression 25 Create Expression into its parentexpression 26 Set Expression.isIdentifier = (innerexpression == "FieldAccess") If (ComplexNodes!= Empty List) 29 Set ComplexNode = ComplexNodes.First() If (ComplexNode == WhileStatement) 32 Create a SelfLoop edge to ComplexNode 33 Set BlockToProcess = body block of ComplexNode 34 Set NextNode = PrevNode = ComplexNode Restore all modified Statements and Expressions in the Java model Fig. 4. The Java to CFG algorithm we have implemented by graph rewriting Fig. 5. Insert new Node rule

6 Table 1. Measured performance Load time (s) Execution time (s) Used memory (MB) Input Input Input 3 out of memory after Solving Task 2 demonstrates that our tool can work with different source and target metamodels: from a Java code model its Control-Flow Graph (CFG) can be computed. However, without a specific visualization engine (a plugin) for this CFG metamodel, the output models can only be viewed through the Abstract Syntax Visualization Plugin of VMTS. Fig. 6 depicts the computed output CFG with a manually created layout. This CFG model is suitable to be an input model for a Program Dependency Graph computation. Acknowledgment Fig. 6. Output CFG computed from the sample Java code The fund of Mobile Innovation Centre has partly supported the activities described in this paper. VMTS environment utilizes the user interface controls developed by Infragistics. References 1. VMTS Team, Visual Modeling and Transformation System website Jean-Sbastien Sottet and Frdric Jouault, Program Comprehension. grabats2009reverseengineering.pdf.