HelloWorld! An Instructive Case for the Transformation Tool Contest

This case comprises several primitive tasks that can be solved straight away with most transformation tools. The aim is to cover the most important kinds of primitive operations on models, i.e. create, read, update and delete (CRUD). To this end, tasks such as a constant transformation, a model-to-text transformation, a very basic migration transformation or diverse simple queries or in-place operations on graphs have to be solved. The motivation for this case is that the results expectedly will be very instructive for beginners. Also, it is really hard to compare transformation languages along complex cases, because the complexity of the respective case might hide the basic language concepts and constructs.Comment: In Proceedings TTC 2011, arXiv:1111.440

Parsing of Hyperedge Replacement Grammars with Graph Parser Combinators

Graph parsing is known to be computationally expensive. For this reason the construction of special-purpose parsers may be beneficial for particular graph languages. In the domain of string languages so-called parser combinators are very popular for writing efficient parsers. Inspired by this approach, we have proposed graph parser combinators in a recent paper, a framework for the rapid development of special-purpose graph parsers. Our basic idea has been to define primitive graph parsers for elementary graph components and a set of combinators for the flexible construction of more advanced graph parsers. Following this approach, a declarative, but also more operational description of a graph language can be given that is a parser at the same time. In this paper we address the question how the process of writing correct parsers on top of our framework can be simplified by demonstrating the translation of hyperedge replacement grammars into graph parsers. The result are recursive descent parsers as known from string parsing with some additional nondeterminism

Generating Correctness-Preserving Editing Operations for Diagram Editors

In previous work it has already been shown that syntax-directed and free-hand editing can be gainfully integrated into a single diagram editor. That way, the user can arrange diagram components on the screen without any restrictions in free-hand editing mode, whereas syntax-directed editing operations provide powerful assistance. So far, editing operations had to be specified or programmed by the editor developer. In contrast, this paper proposes an approach where diagram-specific editing operations are generated on the fly during the editing process and without any additional specification effort. These operations provably preserve the correctness of the diagram. The proposed approach requires a specification of the visual language by a hypergraph grammar

Contraction of Unconnected Diagrams using Least Cost Parsing

A free-hand diagram editor allows the user to place diagram components on the pane without any restrictions. This increase in flexibility often comes at the cost of editing performance, though. In particular it is tedious to manually establish the spatial relations between diagram components that are required by the visual language. Even worse are certain graph-like languages where it is a quite annoying task to explicitly link the node components. In this paper diagram contraction is proposed for solving these issues. The editor user can just roughly arrange a set of diagram components. On request the editor automatically creates a correct diagram from these components while preserving their layout as far as possible. Moreover, for several languages diagram contraction corresponds to linking node components appropriately. Such auto-linking is considered useful. It even has been integrated into first commercial modeling tools. The proposed approach can be applied to visual languages that are specified by means of hypergraph grammars. For syntax analysis an error-tolerant hypergraph parser is used, which computes a cost function by attribute evaluation. That way, unfavorable derivation (sub-)trees can be excluded at an early stage, and combinatorial explosion is mostly prevented

Saying Hello World with GReTL - A Solution to the TTC 2011 Instructive Case

This paper discusses the GReTL solution of the TTC 2011 Hello World case. The submitted solution covers all tasks including the optional ones.Comment: In Proceedings TTC 2011, arXiv:1111.440

Saying Hello World with GROOVE - A Solution to the TTC 2011 Instructive Case

This report presents a solution to the Hello World case study of TTC 2011 using GROOVE. We provide and explain the grammar that we used to solve the case study. Every requested question of the case study was solved by a single rule application.Comment: In Proceedings TTC 2011, arXiv:1111.440

Solving the TTC 2011 Compiler Optimization Task with metatools

The authors' "metatools" are a collection of tools for generic programming. This includes generating Java sources from mathematically well-founded specifications, as well as the creation of strictly typed document object models for XML encoded texts. In this context, almost every computer-internal structure is treated as a "model", and every computation is a kind of model transformation. This concept differs significantly from "classical model transformation" executed by specialized tools and languages. Therefore it seemed promising to the organizers of the TTC 2011, as well as to the authors, to apply metatools to one of the challenges, namely to the "compiler optimization task". This is a report on the resulting experiences.Comment: In Proceedings TTC 2011, arXiv:1111.440

Exploiting the Layout Engine to Assess Diagram Completions

A practicable approach to diagram completion is to first compute model completions on the abstract syntax level. These can be translated to corresponding diagram changes by the layout engine afterwards. Normally, several different model completions are possible though. One way to deal with this issue is to let the user choose among them explicitly, which is already helpful. However, such a choice step is a quite time-consuming interruption of the editing process. We argue that users often are mainly interested in completions that preserve their original diagram as far as possible. This criterion cannot be checked on the abstract syntax level though. In fact, minimal model changes might still result in enormous changes of the original diagram. Therefore, we suggest to use the layout engine in advance for assessing all possible model completions with respect to the diagram changes they eventually cause

Layout Specification on the Concrete and Abstract Syntax Level of a Diagram Language

A visual language consists of several visual component types, e.g. states or transitions in DFAs. Nowadays, the language itself is usually specified via a meta model. To make a diagram look nice, a layouter is required. This layouter may either operate on the concrete syntax level, i.e., on the visual components, or on the abstract syntax level, i.e., on the model instance. In this paper we present an approach that is capable of specifying a flexible layout on both, the concrete as well as the abstract syntax level of a diagram. The approach uses pattern-based transformations. Besides structured editing, it also supports free-hand editing, a challenging task for the layouter. We introduce how such a specification can be created and examine the advantages and shortcomings of each of either operating on the concrete syntax level or on the abstract syntax level