Showing papers on "Source transformation published in 2006"

Source transformation, analysis and generation in TXL

Abstract: The TXL transformation framework has been widely used in practical source transformation tasks in industry and academia for many years. At the core of the framework is the TXL language, a functional programming language specifically designed for expressing source transformation tasks. TXL programs are self-contained, specifying and implementing all aspects of parsing, pattern matching, transformation rules, application strategies and unparsing in a single uniform notation with no dependence on other tools or technologies. Programs are directly interpreted by the TXL processor without any compile or build step, making it particularly well suited to rapid turnaround, test-driven development. In this paper we provide a practical introduction to using TXL in rapidly developing source transformations from concrete examples, and review experience in applying TXL to a number of practical large scale applications in source code analysis, renovation and migration.

Source-to-source transformation for language dialects

Abstract: An analysis and source-to-source transformation framework covers dialects of programming languages that lack formal definition for all individual dialects. Multiple instantiations of the same compiler front-end tools can be used with different settings to create distinct intermediate forms and maps. Intermediate forms and maps are used in an individual analysis and source-to-source transformation context, and performing the analysis and source-to-source transformation thereupon. A unified tool set is desirably provided, including standard compiler front-end tools and code transformation/generation tools, wherein source code edits are carried out in order to make the source code more amenable to translation to intermediate forms. The analysis results or intermediate forms created by individual tools are used by other tools as well as further analyzed to create a map of the regions of validity and invalidity of the intermediate forms, and tracking the source-code edits performed in order to obtain the same. Among other benefits, this provides a choice of the best tools combination for maximum code analysis coverage.

Search Strategies in CHR(Prolog)

Abstract: We extend the refined operational semantics of the Constraint Handling Rules language to support the implementation of different search strategies. Such search strategies are necessary to build efficient Constraint Logic Programming systems. This semantics is then further refined so that it is more suitable as a basis for a trailing based implementation. We propose a source to source transformation to implement breadth first search in CHR(Prolog): CHR with Prolog as the host language. Breadth first is chosen because it exhibits the main difficulties in the implementation of search strategies, while being easy to understand. We evaluate our implementation and give directions for future work.

Evolving TXL

Abstract: TXL is a functional programming language specifically designed for expressing source transformation tasks. Originally designed for the rapid prototyping of modest syntactic enhancements, in recent years it has been extensively used in large scale source code analysis and reengineering applications that are much more challenging. As a result, many common programming techniques needed in these larger scale applications are difficult or impossible to express in TXL. Examples include multi-way decisions, generic rules and functions, polymorphism and information hiding. In this paper we introduce ETXL, an experimental extension of TXL which includes convenient features designed to address these issues. Designed to be a compatible variant that remains faithful to the original TXL syntax and semantics, ETXL has itself been prototyped as a source transformation to original TXL.

Using source transformation to test and model check implicit-invocation systems

Abstract: In this paper we present a source transformation-based framework to support uniform testing and model checking of implicit-invocation software systems. The framework includes a new domain-specific programming language, the Implicit-Invocation Language (IIL), explicitly designed for directly expressing implicit-invocation software systems, and a set of formal rule-based source transformation tools that allow automatic generation of both executable and formal verification artifacts. We provide details of these transformation tools, evaluate the framework in practice, and discuss the benefits of formal automatic transformation in this context. Our approach is designed not only to advance the state-of-the-art in validating implicit-invocation systems, but also to further explore the use of automated source transformation as a uniform vehicle to assist in the implementation, validation and verification of programming languages and software systems in general.