Annotation based parser generator

The paper presents innovative parser construction method and parser generator prototype which generates a computer language parser directly from a set of annotated classes in contrast to standard parser generators which specify concrete syntax of a computer language using BNF notation. A language with textual concrete syntax is defined upon the abstract syntax definition extended with annotations in the presented approach. Annotations define instances of concrete syntax patterns in a language. Abstract syntax of a language is inevitable input of the parser generator as well as language's concrete syntax pattern definitions. The process of parser implementation is presented on the concrete computer language - the Simple Arithmetic Language. The paper summarizes results of the studies of implemented parser generator and describes its role in the university courses

Object Grammars: Compositional & Bidirectional Mapping Between Text and Graphs

Abstract: Object Grammars define mappings between text and object graphs. Parsing recognizes syntactic features and creates the corresponding object structure. In the reverse direction, formatting recognizes object graph features and generates an appropriate textual presentation. The key to Object Grammars is the expressive power of the mapping, which decouples the syntactic structure from the graph structure. To handle graphs, Object Grammars support declarative annotations for resolving textual names that refer to arbitrary objects in the graph structure. Predicates on the semantic structure provide additional control over the mapping. Furthermore, Object Grammars are compositional so that languages may be defined in a modular fashion. We have implemented our approach to Object Grammars as one of the foundations of the Ens\xc5\x8d system and illustrate the utility of our approach by showing how it enables definition and composition of domain-specific languages (DSLs)

Formal verification of automotive embedded UML designs

Software applications are increasingly dominating safety critical domains. Safety critical domains are domains where the failure of any application could impact human lives. Software application safety has been overlooked for quite some time but more focus and attention is currently directed to this area due to the exponential growth of software embedded applications. Software systems have continuously faced challenges in managing complexity associated with functional growth, flexibility of systems so that they can be easily modified, scalability of solutions across several product lines, quality and reliability of systems, and finally the ability to detect defects early in design phases. AUTOSAR was established to develop open standards to address these challenges. ISO-26262, automotive functional safety standard, aims to ensure functional safety of automotive systems by providing requirements and processes to govern software lifecycle to ensure safety. Each functional system needs to be classified in terms of safety goals, risks and Automotive Safety Integrity Level (ASIL: A, B, C and D) with ASIL D denoting the most stringent safety level. As risk of the system increases, ASIL level increases and the standard mandates more stringent methods to ensure safety. ISO-26262 mandates that ASILs C and D classified systems utilize walkthrough, semi-formal verification, inspection, control flow analysis, data flow analysis, static code analysis and semantic code analysis techniques to verify software unit design and implementation. Ensuring software specification compliance via formal methods has remained an academic endeavor for quite some time. Several factors discourage formal methods adoption in the industry. One major factor is the complexity of using formal methods. Software specification compliance in automotive remains in the bulk heavily dependent on traceability matrix, human based reviews, and testing activities conducted on either actual production software level or simulation level. ISO26262 automotive safety standard recommends, although not strongly, using formal notations in automotive systems that exhibit high risk in case of failure yet the industry still heavily relies on semi-formal notations such as UML. The use of semi-formal notations makes specification compliance still heavily dependent on manual processes and testing efforts. In this research, we propose a framework where UML finite state machines are compiled into formal notations, specification requirements are mapped into formal model theorems and SAT/SMT solvers are utilized to validate implementation compliance to specification. The framework will allow semi-formal verification of AUTOSAR UML designs via an automated formal framework backbone. This semi-formal verification framework will allow automotive software to comply with ISO-26262 ASIL C and D unit design and implementation formal verification guideline. Semi-formal UML finite state machines are automatically compiled into formal notations based on Symbolic Analysis Laboratory formal notation. Requirements are captured in the UML design and compiled automatically into theorems. Model Checkers are run against the compiled formal model and theorems to detect counterexamples that violate the requirements in the UML model. Semi-formal verification of the design allows us to uncover issues that were previously detected in testing and production stages. The methodology is applied on several automotive systems to show how the framework automates the verification of UML based designs, the de-facto standard for automotive systems design, based on an implicit formal methodology while hiding the cons that discouraged the industry from using it. Additionally, the framework automates ISO-26262 system design verification guideline which would otherwise be verified via human error prone approaches

Approche de métamodélisation pour la simulation et la vérification de modèle. Application à l'ingénierie des procédés

Nous proposons dans cette thèse une démarche permettant de décrire un DSML (Domain Specific Modeling Language) et les outils nécessaires à l'exécution, la vérification et la validation des modèles. La démarche que nous proposons offre une architecture générique de la syntaxe abstraite du DSML pour capturer les informations nécessaires à l'exécution d'un modèle et définir les propriétés temporelles qui doivent être vérifiées. Nous nous appuyons sur cette architecture pour expliciter la sémantique de référence et l'implanter. Plus particulièrement, nous étudions les moyens : – d'exprimer et de valider la définition d'une traduction vers un domaine formel dans le but de réutiliser des outils de model-checking. – de compléter la syntaxe abstraite par le comportement ; et profiter d'outils génériques pour pouvoir simuler les modèles construits. Enfin, de manière à valider les différentes sémantiques implantées vis-à-vis de la sémantique de référence, nous proposons un cadre formel de métamodélisation. ABSTRACT : We propose in this thesis a specific taxonomy of the mechanisms allowing to express an execution semantics for Domain Specific Modeling Languages (DSMLs). Then, we integrate these different mechanisms within a comprehensive approach describing DSMLs and tools required for model execution, verification and validation. The proposed approach provides a rigorous and generic architecture for DSML abstract syntax in order to capture the information required for model execution. We rely on this generic architecture to make the reference semantics explicit and implement it. More specifically, we study the means : – to express and validate the definition of a translation into a formal domain in order to re-use model-checking techniques. – to enrich the abstract syntax with the definition of the DSML behaviour and take advantage of generic tools so to simulate the built models. Finally, for the purpose of validating the equivalence of different semantics implemented according to the reference semantics, we also propose a formal metamodeling framewor

Modélisation en UML/OCL des langages de programmation et de leurs propriétés et processus IDM

Cette étude est axée sur l'activité de génération de composants logiciels se situant en phase terminale des processus de développement de logiciels dirigés par les modèles. Dans une première partie, nous présentons les travaux de recherche déjà existants sur les modèles et les transformations de modèles, ainsi que sur la modélisation en UML/OCL des langages de programmation limitée, la plupart du temps, aux aspects syntaxiques. Dans une deuxième partie, nous montrons comment nous modélisons en UML/OCL, les propriétés comportementales et axiomatiques des langages de programmation de style impératif. La modélisation des propriétés comportementales et axiomatiques d'un langage, en UML/OCL enrichi d'un langage d'actions, nous amène à montrer comment on peut, à l'aide de triplets de Hoare, vérifier que des segments de modèles de programmes sont corrects. Les assertions déduites des triplets de Hoare par application des propriétés axiomatiques du langage sont transmises à un Atelier B en vue d'étudier leurs éventuelles validités. Dans une troisième partie, nous montrons comment on peut injecter au niveau du Méta-Modèle UML des propriétés comportementales et axiomatiques spécifiques à un domaine d'applications particulier. Nous nous sommes limités au fragment du Méta-Modèle UML définissant les diagrammes d'activité se situant donc en amont des modèles de codes, avant la génération proprement dite des codes. La cohérence entre les modèles et les codes peut se vérifier à l'aide de propriétés comportementales et axiomatiques en comparant les modèles issues des exigences et les modèles des codes. Ces travaux de recherche ont été financés dans le cadre de l'ANR.Our work focuses on the software component generation phase that takes place at the last phase of a model driven development process. Our work is related to either the modelware or the grammarware because the model driven process can be considered as a successive of model transformations whereas the code generation is a specific transformation from the model to a language grammar. In the first part, we resume some relative works in the domain of the models and of the models transformation; we also present the language modeling in UML which is generally restricted by the syntax modeling. In the second part, we show how we model in UML/OCL the behavioral and axiomatic properties of imperative programming languages. The modeling of the behavioral properties helps to execute the code models if we dispose a right execution environment. In the other hand, the modeling of the axiomatic properties helps to demonstrate the correctness of the code model. In fact, the assertions obtained from the modeling of the axiomatic properties of the language will be transferred to a B atelier in order to have further validation. In the third part, we show how we inject into the UML metamodel the considered domain behavioral and axiomatic properties. We focus on the activity diagram metamodel of the UML which defines the behavior part of a UML model. The coherence between the models and the codes can be then verified in comparing the behavioral and axiomatic properties of the models issued from the requirements and that of the codes. Our work is financed by the ANR research projects

Model-driven analysis and synthesis of textual concrete syntax

Meta-modeling is raising more and more interest in the field of language engineering. While this approach is now well understood for defining abstract syntaxes, formally defining textual concrete syntaxes with meta-models is still a challenge. Textual concrete syntaxes are traditionally expressed with rules, conforming to EBNF-like grammars, which can be processed by compiler compilers to generate parsers. Unfortunately, these generated parsers produce concrete syntax trees, leaving a gap with the abstract syntax defined by meta-models, and further ad hoc hand-coding is required. In this paper we propose a new kind of specification for concrete syntaxes, which takes advantage of meta-models to generate fully operational tools (such as parsers or text generators). The principle is to map abstract syntaxes t