...
Table of Contents |
---|
Model Transformation
TODO: Write this sectionThe first half of this tutorial will be all about the metamodel of the simple programming language.
Preliminaries
Let's start by generating the model code and familiarizing ourselves with the metamodel:
- Download the metamodel (TODO: INSERT META MODEL LINK)
- Add a new plug-in project for the metamodel, import the ecore file, and generate a diagram for it.
- Familiarize yourself with the model. It basically follows the typical structure of common programming languages. In fact, if you're a bit familiar with the abstract syntax of Java, you should feel right at home. (If not, this might be an excellent opportunity to learn a bit about Java's abstract syntax – knowing about this kind of stuff will deepen your understanding of the language.)
- Generate code from the metamodel.
Writing the Transformation
Now that you have code-generated (yes, that's a verb) the metamodel it's time to start working on your transformation:
- Add a new plug-in project
de.cau.cs.rtprak.login.compiler
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. - Add an Xtend Class to your project. The class should be placed in a subpackage where all the transformation code will go, such as
de.cau.cs.rtprak.login.compiler.transform
. - 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
org.eclipse.xtext.xbase.lib
. If you hover over the error with your mouse, you can have Eclipse add all libraries required by Xtend to your project. Define an entry method for the transformation that takes a
TuringMachine
instance as an argument and returns aProgram
. You can use the following definition as a starting point:Code Block language java /** * Transforms a given Turing Machine into an imperative program model. * * @param machine the Turing Machine to transform into an imperative * program. * @return a program model that implements the Turing Machine. */ def Program transformTuringToImperative(TuringMachine machine) { // Create the program we will transform the Turing Machine into val program = ImperativeFactory::eINSTANCE.createProgram() // TODO: Initialize program appropriately // TODO: Call methods that generate the Program model // Return the transformed program program }
There's a few points to note here:
- Lines in Xtend code don't have to and with a semicolon.
- 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
declares a constant, whilevar
declares a variable. Try to make do with constants where possible. - The methods you call should be declared as
def private
since they are implementation details and shouldn't be called by other classes.
- Add code to transform the Turing Machine to an imperative program model. The imperative program metamodel contains enough stuff to implement Turing Machines.
Code Generation
TODO: Write this section.
...