EProvide (Eclipse Plugin for Prototyping Visual Interpreters and Debuggers) is a plug-in for the Eclipse development environment that allows you to quickly define operational semantics for subject-oriented languages based on Eclipse modeling technologies and integrated into the Eclipse program execution system. The approach used in this plugin is described in the articles [41, 48].
Description
Usually, the semantics of modeling languages are recorded using various model conversion rules, for example, using the OMG
Query/View/Transformation (QVT) standard. They can be used to translate models from one language to another. Often the second language is a general-purpose language that can be compiled or interpreted (e.g. Java, C++ or Python). This translational approach to semantic tasks reduces the abstraction level since the operator needs to understand two subject areas at once - the source and destination areas, into which the transition takes place. Providing reverse connections (e.g. in the case of errors) the target model and the source model are also quite complex a task. This approach is a roundtrip engineering procedure,13[43]).
The whole set of methods for setting semantics for any language can be divided into several classes. One of the main classes is operational semantics (OS).
The operating system of a language represents any particular object written with the help of this language in the form of a set of computational steps. Formally, it can be represented in the form of a pair of < Γ, →>, where Γ - a set of configurations, and → - binary ratio of transition to a set of configurations. There are two types of OS: Structural Operating Semantics (OS), proposed by Carpenter [38], and natural semantics. The main concept in SOS is the state. Usually, it is a set of certain variables and their values. The configuration is the pair < S, σ>, where S is the fragment and σ is the current status. The transition ratio is also binary by the ratio on a multitude of configurations. Thus, transitions in the CBS are described by According to abstract syntactic constructions of the language, it is possible to set abstract interpreters for languages based on their syntax. It also allows using structural induction, for example, when proving the correctness of interpreters and debuggers.
Wachsmuth suggested using a text-based CRL using the QVT Relations language [35], which is part of the OMG QVT standard. QVT Relations is a high-level declarative language designed to create both one-way and two-way model transformations. Later on, in [41], this approach was combined with visual modeling technologies, and an EProvide plug-in was implemented, allowing to prototype visual interpreters and debuggers for subject languages. Other languages were also added to describe semantics: Java, Abstract State Machines (ASM, [18]), Prolog and Scheme.
It is important to note that when interpreting or debugging, the model's state changes, which, firstly, should be returned to the original state at the end of interpretation or when stopping manually, and, secondly, this state should be able to change in the debugging mode through the graphical user interface. To do this, you need to manually create a separate model from the original meta-model, the state of which will change. You can also add additional structures there, for example, to provide the functionality of breakpoints.
Analysis
The approach proposed by Waxmouth is quite general and allows working with different specification languages, with the help of which the semantics will be directly specified, has a flexible position regarding the implementation of breakpoints and other standard debuggers' functions, is fully implemented under the Eclipse platform.
But if you look at it from usability, manual writing of semantics in any text language reduces the achieved level of abstraction. And for a successful In environments other than Eclipse, this approach requires an interpreter of this language, the implementation of which may prove to be a nontrivial task. EProvide differs from xUML in that it is enough just to describe the metamodel of the language and the way the models are transformed, e.g. by using the QVT standard Relations, and there is no need to draw many UML diagrams. In EProvide you can easily organize step-by-step execution, combined with support for different types of breakpoints and tracking for the values of the attributes of the elements. For xUML, as noted in paragraph 2.3.1, Many software tools support it, making it difficult to choose between they have to solve a certain problem if necessary.