Run Configurations

Run Configurations

Introduction

Run configurations allow you to define how to execute programs, written in your language.

An existing run configuration can be executed either from run configurations box, positioned on the main toolbar,

by the "Run" menu item in the main menu

or through the run/debug popup (Alt+Shift+F10/Alt+Shift+F9).

Also run configurations could be executed/created for nodes, models, modules and project. For example, JUnit run configuration could run all tests in selected project, module or model. See Run configurations creators on how to implement such behavior for you run configurations.

To summarize, run configurations define the following things:

• On creation stage:
  • configurations name, caption, icon;
  • configurations kind;
  • how to create a configuration from node(s), model(s), module(s), project.
• On configuration stage:
  • persistent parameters;
  • editor for persistent parameters;
  • checker of persistent parameters validity.
• On execution stage:
  • proccess which is actually executed;
  • console with all its tabs, action buttons and actual console window;
  • things required for debugging this configuration (if it is possible).

General purpose run configurations

In order to create a run configuration, you must create an instance of RunConfigurationTypeDeclaration concept to define a kind of your new run configuration and then create one or several instances of RunConfigurationDeclaration concept, defining the specific run configuration.

RunConfigurationDeclaration has the following structure:

Run configurations creators

Run configuration creators allow to specify how you run configurations could be created from context menu. To create run configuration creator use UniversalRunConfigCreator. Its elements are described in the following table:

Here is the example of run configuration creator written for JUnit run configuration:

In this example we see JUnitConfigFromModel creator created for JUnit type from a model. The create function at first check that there are tests in the model, gets model name, sets the model as context parameter and creates an instance of the DefaultJUnit run configuration. In the createRunConfig statement two persistent properties of configuration are set which specify the type of configuration and the model it runs tests for. The configuration name is set to model name and suggested name is set to "Tests in 'name'".

Run configurations for languages generated into java

Language jetbrains.mps.baseLanguage.runConfigurations define two special kinds of run configurations: JavaRunConfiguration and JavaNodeRunConfiguration. JavaRunConfiguration provides an editor for standart java run parameters: virtual machine options, program arguments, java location, working directory. JavaNodeRunConfiguration in addition to that defines the node to run.

General purpose java run configurations

Use JavaRunConfiguration concept if you want to create run configuration which runs java machine but not for a one specific node. It is in general the same as RunConfigurationDeclaration. The biggest difference is additional parameter in apply and reset block of the editor and in parametrized execute. It's javaParameter of type ConfigRunParameters. It contains:

• virtual machine parameters;
• program parameters;
• working directory;
• information whether to make before generation;
• alternative jre path.

JavaRunConfiguration generates an editor for this parameters automatically, so you do not have to worry about them. Use this parameters to start your java machine.

Java run configurations for a single node

If what you want to run is a single node, you can use JavaNodeRunConfiguration concept. Here is a run configuration written for lambda calculus language:

This configuration is quite simple. It runs nodes of concept Program, as specified in target concept block. parametrized execute has only process part defined. As you can see, the process creation function receives an additional node parameter. This is the node, selected by user. In this configuration we use ClassRunner class to execute the given node and create DefaultProcessHandler - a process handler for java. Also note is debuggable parameter set to true - this means this configuration could be executed under debugger. generate before run parameter means that configuration will automatically check whether user checked "Make Before Run" in configuration editor and generate selected node if he did. Setting this option to false means you have to do it yourself (for example if you want to use a non-standart way of generation).

Note that DefaultLambdaCalculusProgram does not define an editor. It is generated automatically. Check block is also not required. This is how the configuration editor look like:

Previous Next