Xtend 1a - Model Transformations

This installment of our little series of tutorials will be all about [[Xtend>>url:http://www.eclipse.org/xtend/||rel="nofollow" style="line-height: 1.4285715;" shape="rect" class="external-link"]], a programming language that looks very similar to Java, but which adds some very convenient features. Xtend code compiles to Java and and was developed using Xtext. In fact, once you gain experience working with Xtend you will probably appreciate the power of Xtext even more.

3

4

In this and the following tutorial, we will focus on two particular areas where Xtend excels:

5

6

* Model transformation. You will be using Xtend to transform a given Turing Machine into a model of a simple programming language. (this tutorial)

7

* Code generation. You will be using Xtend to generate code for a given model of the simple programming language in an arbitrary programming language (except perhaps [[Brainfuck>>url:http://en.wikipedia.org/wiki/Brainfuck||rel="nofollow" shape="rect" class="external-link"]] or [[Whitespace>>url:http://en.wikipedia.org/wiki/Whitespace_%28programming_language%29||rel="nofollow" shape="rect" class="external-link"]]). The generated program will implement and simulate the Turing Machine without relying on its model. (the next tutorial)

8

9

In essence, you will be following the way compilers generate code: generate an abstract model representation of the program, and turn that representation into actual code.

10

11

As in the previous tutorial, we refer you to the [[Xtend documentation>>url:http://www.eclipse.org/xtend/documentation.html||rel="nofollow" shape="rect" class="external-link"]] instead of explaining everything in this tutorial. Oh, and [[here's the slides of our presentation>>url:http://rtsys.informatik.uni-kiel.de/confluence/download/attachments/3604633/presentation.pdf?version=1&modificationDate=1353946388000&api=v2||shape="rect"]] that accompanied this tutorial.

12

13

Exciting stuff, so let's begin

= Preliminaries =

We have prepared a metamodel of our simple imperative programming language:

24

25

[[image:url:http://rtsys.informatik.uni-kiel.de/confluence/download/thumbnails/3604633/imperative.png?version=2&modificationDate=1353320157000&api=v2&effects=drop-shadow]]

26

27

To work with the language, the first thing you will have to do is to download an [[archive of three plug-in projects>>url:http://rtsys.informatik.uni-kiel.de/confluence/download/attachments/3604633/imperative.zip?version=1&modificationDate=1353319543000&api=v2||shape="rect"]]. The projects contain the metamodel and a simple textual language for it. Here's some at-a-glance info:

28

29

* Model files have the file extension ".imperative", while textual files have the file extension ".pseudo". When saving a model using EMF, the file extension of the file you save the model into will determine the output format.

30

* Each {{code language="none"}}IfStatement{{/code}} requires both, a statement for the true case and a statement for the false case. You will not always need both. Use a {{code language="none"}}Block{{/code}} statement as an empty statement when required.

31

32

= Writing the Transformation =

33

34

Now that you have familiarized yourself with the programming language's metamodel it's time to start working on your transformation:

35

36

1. Add a new plug-in project {{code language="none"}}de.cau.cs.rtprak.<login>.compiler{{/code}} to your workspace. Be sure to uncheck the option //This plug-in will make contributions to the UI//. Add dependencies to the two projects containing the Turing Machine metamodel and the programming language metamodel.

37

1. Add an //Xtend Class// to your project. The class should be placed in a subpackage where all the transformation code will go, such as{{code language="none"}}de.cau.cs.rtprak.<login>.compiler.transform{{/code}}.

38

1. You will notice that your new class is marked with an error marker because of a missing dependency of the new plug-in project to {{code language="none"}}org.eclipse.xtext.xbase.lib{{/code}}. If you hover over the error with your mouse, you can have Eclipse add all libraries required by Xtend to your project.

39

1. (((

40

Define an entry method for the transformation that takes a {{code language="none"}}TuringMachine{{/code}} instance as an argument and returns a {{code language="none"}}Program{{/code}}. You can use the following (incomplete) method as a starting point:

/**

* Transforms a given Turing Machine into an imperative program model.

45

*

46

* @param machine the Turing Machine to transform into an imperative

47

* program.

48

* @return a program model that implements the Turing Machine.

49

*/

50

def Program transformTuringToImperative(TuringMachine machine) {

51

// Create the program we will transform the Turing Machine into

52

val program = ImperativeFactory::eINSTANCE.createProgram()

53

54

// TODO: Generate and initialize global variables

55

56

// TODO: Generate the program logic

57

58

// Return the transformed program

program

}

(((

(% class="syntaxhighlighter nogutter java" %)

65

(((

66

There's a few points to note here:

)))

)))

\\

* Lines in Xtend code don't have to and with a semicolon.

73

* We have been explicit about the method's return type, but we could have easily omitted it, letting Xtend infer the return type.

* The keyword

val

{{/code}} declares a constant, while

var

{{/code}} declares a variable. Try to make do with constants where possible.

83

* The methods you call should be declared as

def private

{{/code}} since they are implementation details and shouldn't be called by other classes.

88

* You may be tempted to add a few global variables that hold things like a global input variable or a pointer to the current state. While you could to that,

def create

{{/code}}methods might offer a better alternative...

93

)))

94

1. Add code to transform the Turing Machine to an imperative program model. The imperative program metamodel contains enough stuff to implement Turing Machines.

95

1. Open the //Plug-In Manifest Editor// and switch to the Runtime tab. Add the package containing your transformation to the list of exported packages. (You may have to check the //Show non-Java packages// option in the //Exported Packages// dialog to see the package.)

96

97

(% class="aui-message hint shadowed information-macro" %)

98

(((

99

(% class="title" %)

100

What Should the Imperative Program Do?

101

102

(% class="aui-icon icon-hint" %)Icon

103

104

(% class="message-content" %)

105

(((

106

The imperative program model should not describe a completely working program, complete with command-line parsing for input arguments and printing out the program's output. Instead, think of the program to magically receive those variables marked as input variables, and to magically output whatever it is the program returns (using the {{code language="none"}}Return{{/code}} statement). In the next tutorial, you will use Xtend's code generation features to generate working source code in your favourite programming language. The code you generate will contain a wrapper around your actual programming, including code that actually initializes the input variables and outputs the returned expression.

)))

)))

== Testing the Transformation ==

111

112

You will need a way to test the transformation, so we will have to make it available through the UI. Eclipse plug-ins often come with a separate UI plug-in that contains the UI contributions, with the base plug-in only offering the functionality itself. In our case, our base plug-in contains the transformation code, and the UI plug-in we will be creating next contains a menu contribution to make the transformation available.

113

114

1. Add a new plug-in project {{code language="none"}}de.cau.cs.rtprak.<login>.compiler.ui{{/code}} to your workspace. This time, leave the option //This plug-in will make contributions to the UI// checked. Add dependencies to the two projects containing the Turing Machine metamodel and the programming language metamodel. Also add a dependency to our base plug-in that contains the transformation.

115

1. Add a menu contribution that is visible if a file containing a Turing Machine model is selected in the project explorer. (this can be both, a regular Turing Machine model file or a textual representation of a Turing Machine) The previous tutorial taught you how to add menu contributions.

116

1. (((

117

Create a command handler that loads the turing machine model from the selected file, calls the transformation on the model, and saves the imperative program to a file with the same name, but different extension. You can use the following code as a template: (The code requires a dependency to {{code language="none"}}com.google.inject{{/code}} to work.)

@Override

public Object execute(ExecutionEvent event) throws ExecutionException {

122

ISelection selection = HandlerUtil.getCurrentSelection(event);

123

if (selection instanceof IStructuredSelection) {

124

Object element = ((IStructuredSelection) selection).getFirstElement();

125

if (element instanceof IFile) {

126

IFile machineFile = (IFile) element;

127

128

// Load Turing Machine

129

TuringMachine machine = loadTuringMachine(machineFile);

130

131

// Call the transformation

132

Injector injector = Guice.createInjector();

133

TuringToImperativeTransformation transformation =

134

injector.getInstance(TuringToImperativeTransformation.class);

135

Program program = transformation.transformTuringToImperative(machine);

136

137

// Save imperative program

138

IFile programFile = machineFile.getParent().getFile(

139

new Path(machineFile.getName() + ".imperative"));

140

saveImperativeProgram(programFile, program);

141

142

// Refresh the parent folder to have the new file show up in the UI

143

try {

144

machineFile.getParent().refreshLocal(IResource.DEPTH_ONE, null);

145

} catch (CoreException e) {

// Ignore

}

}

}

return null;

}

/**

* Load the turing machine model from the given file.

155

*

156

* @param turingFile the file to load the turing machine model from.

157

* @return the turing machine model.

158

* @throws ExecutionException if the file couldn't be opened.

159

*/

160

private TuringMachine loadTuringMachine(IFile turingFile) throws ExecutionException {

// TODO Implement.

}

/**

* Saves the given imperative program in the given file.

166

*

167

* @param programFile the file to save the program to.

168

* @param program the program to save.

169

* @throws ExecutionException if there was an error saving the file.

170

*/

171

private void saveImperativeProgram(IFile programFile, Program program) throws ExecutionException {

// TODO Implement

}

Note that replacing the ".imperative" file extension by ".pseudo", this code will generate a textual representation of the transformation's results. Even if saving the model in the ".imperative" format works, saving it in the textual format may still fail if the model is not correct. This includes things like forgetting to add a condition to a{{code language="none"}}WhileStatement{{/code}}, or forgetting to add a statement to an {{code language="none"}}IfStatement{{/code}}'s {{code language="none"}}falseStatement{{/code}}. Thus, generating the textual output is a good way to find problems with your transformation. You may even want to add a second menu contribution to have both output formats available at the same time without always having to change the source code. Note, however, that no errors when generating the textual output does not mean that your transformation is correct – it merely means that your model can be expressed by the grammar.

)))

This tutorial was originally created by Christoph Daniel Schulze and Miro Spönemann for the Eclipse Project WT 12/13.

183

Wiki source code of Xtend 1a - Model Transformations

Navigation

Quick Links