Generator User Guide Demo5

Generator User Guide Demo 5

In this demo we will learn how to use generation scripts and utility classes.

There are two kinds of generation scripts: pre-processing and post-processing scripts.
Pre-processing scripts are invoked before applying the generator rules and they usually alter the  input model in a way that makes it easier for further processing by the rules.
Post-processing scripts are invoked after all generator rules have finished and they are applied to the  output model.

Additionally, in case of having multiple scripts in a generator you can influence the order, in which the scripts will run.

New Language

We'll start with an exact copy of the demoLang4 language.

• create new language 'generator_demo.demoLang5'

• in the language properties dialog add extended languages: 'jetbrains.mps.sampleXML' and 'jetbrains.mps.baseLanguage'

• create a new generator for this language if it has not been created (see Demo 1 for details)

• delete the (empty) mapping configuration 'main' from demoLang5 generator

• copy-paste all nodes from the demoLang4 generator to the demoLang5 generator

New Test Model

• in the 'test_models' solution clone the model 'test4' into 'test5'

• in the model properties dialog replace 'engaged on generation' language demoLang4 -> demoLang5 (see Demo 2 for details)

• in the model 'test5' open the 'Panel' document

• add a Text node to the 'panel' element:

Pre-processing Script

Our demoLang5 generator doesn't support text nodes, but text node in this context has the same meaning as a 'label' element with a 'text' attribute set. Therefore, instead of adding more rules to our generator, we will add a pre-processing script, which will convert all text nodes in the input model into 'label' elements and let existing rules do the rest of the job.

• in the 'main@generator' model if the demoLang5 generator create a root node of type  mapping script

• give it a name 'fix_text'

• set script kind = pre-process input model

• set modifies model = true, since we're going to alter the input model inside the script

• enter the code, which will perform a search and a replace of all text nodes in the input model:

• add the 'fix_text' script to mapping configuration 'main' to the pre-processing scripts section:

First Test

Re-build the language and check out the generated text from the 'test5' model:

You can see that a label was correctly created for the 'Hello everybody' text and that the label is being added into the panel.

Utility Classes in Generator

Now, let's suppose we got an idea to fix possible syntax and stylistic errors in the generated texts. We'll create a post-processing script to do that. These NLP algorithms tend to be quite complex, so let's develop them in a separate utility class, instead of embedding them into the script directly.

The issue here is that a utility class cannot be created in the  generator model 'main@generator' directly, because then it would be treated as a root template , just like any other root node in any 'generator'-stereotyped model would.
We'll have to create another model in the generator module:

• select the generator node (the demoLang5 generator) in the tree and choose New->Model in the popup menu:

• give the new model name: 'util':

• Make sure you clear our the Stereotype  text field

• in model 'util' create class 'TextUtil'

• add static method 'fixText()' to class 'TextUtil':

We are going to call the 'fixText()' method in a  post-processing script and pass the  output model as a parameter. The output model contains classes, methods, expressions and so on. Thus we are manipulating a java-like syntax tree here.
The 'fixText()' method will replace all strings starting with "MPS" with strings that start with "JetBrains MPS".

Post-processing Script

Now we can use this utility method 'fixText()' in a post-processing script:

• in model 'main@generator' (in the demoLang5 generator) create a new mapping script

• give it a name 'refine_text'

• import the  'generator_demo.demoLang5.generator.util' model to model 'main@generator' (see Demo 1 for details on model importing)

  

• in the 'refine_text' mapping script enter the code as shown:

• add the 'refine_text' script to the  post-processing scripts section in the mapping configuration 'main':

Re-build the generator.
You can use Ctrl/Cmd-F9 (generate all changed models in module). Note that Shift-F9 (generate current model) is not enough any more because now we have two models requiring generation.

Second Test

Generate model 'test5' and preview the generated text:

Notice the label now holds a "JetBrains MPS" text.