Reversible Language Extensions and Their Application in Debugging

  title={Reversible Language Extensions and Their Application in Debugging},
  author={Zo{\'e} Drey and J. Morales and M. Hermenegildo and M. Carro},
A range of methodologies and techniques are available to guide the design and implementation of language extensions and domain-specific languages on top of a base language. A simple yet powerful technique to this end is to formulate the extension via source-to-source transformation rules that are interleaved across the different compilation passes of the base language. Despite being a very successful approach, it has the main drawback that the input source code is lost in the process. As a… Expand
Reversible and Quantum Circuit Synthesis
This thesis presents five major tools for the synthesis of reversible and quantum circuits, and proposes FTQLS, a tool that synthesizes and optimizes fault-tolerant quantum circuits by using logic identity rules for various physical machine descriptions. Expand


Weaving a debugging aspect into domain-specific language grammars
In this paper, separation of concerns within a programming language specification is demonstrated by considering debugging support within a domain-specific language (DSL) by describing the use of AspectJ to weave the debugging semantics into the code created by a parser generator. Expand
Declaratively defining domain-specific language debuggers
A meta-language for coordinating the debugger that abstracts over the complexity of writing a debugger by hand is introduced, and the implementation of a language-parametric infrastructure for debuggers that can be instantiated based on this specification is described. Expand
From programs to object code and back again using logic programming: Compilation and decompilation
A simple compiler and decompiler are presented in full as an example in the logic programming language Prolog, together with some sample output. Expand
Decompilation of Java bytecode to Prolog by partial evaluation
This paper presents the first modular scheme to enable interpretive decompilation of a realistic programming language to a high-level representation, namely of JBC to Prolog, and introduces two notions of optimality which together require that decompilation does not generate code more than once for each program point. Expand
An overview of Ciao and its design philosophy
An overall description of the Ciao multiparadigm programming system emphasizing some of the novel aspects and motivations behind its design and implementation is provided, and an informal overview of the language and program development environment is provided. Expand
A New Module System for Prolog
The Ciao module system is presented, which has been designed to meet a number of objectives: allowing separate compilation, extensibility in features and in syntax, amenability to modular global analysis and transformation, enhanced error detection, support for meta-programming and higher-order, compatibility to the extent possible with official and de-facto standards, etc. Expand
TIDE: A Generic Debugging Framework - Tool Demonstration
This work presents applications of TIDE: a generic debugging framework that is related to the ASF+SDF Meta-Environment, and demonstrates the common debugging interface, and indicates the amount of effort needed to instantiate new debuggers based on TIDE. Expand
A Syntactic Approach to Combining Functional Notation, Lazy Evaluation, and Higher-Order in LP Systems
A syntactic functional extension, used in the Ciao system, is presented, which can be implemented in ISO-standard Prolog systems and covers function application, predefined evaluable functors, functional definitions, quoting, and lazy evaluation. Expand
Modular Extensions for Modular (Logic) Languages
This work presents a detailed description of a code expansion-based framework that proposes novel solutions for the problem of developing mechanisms for easily implementing modular extensions to modular (logic) languages and argues that the approach can be adapted for other Prolog-based systems and languages. Expand
Monitoring semantics: a formal framework for specifying, implementing, and reasoning about execution monitors
Monitoring semantics is introduced, a non-standard model of program execution that captures “monitoring activity” as found in debuggers, profilers, tracers, etc, and can be automatically derived for any language for which a continuation semantics specific has been provided. Expand