Source tree composition

Dividing software systems in components improves software reusability as well as software maintainability. Components live at several levels, we concentrate on the implementation level where components are formed by source files, divided over directory structures. Such source code components are usually strongly coupled in the directory structure of a software system. Their compilation is usually controlled by a single global build process. This entangling of source trees and build processes often makes reuse of source code components in different software systems difficult. It also makes software systems inflexible because integration of additional source code components in source trees and build processes is difficult. This paper's subject is to increase software reuse by decreasing coupling of source code components. It is achieved by automized assembly of software systems from reusable source code components and involves integration of source trees, build processes, and configuration processes. Application domains include generative programming, product-line architectures, and commercial off-the-shelf (COTS) software engineering

The Linux kernel as flexible product-line architecture

The Linux kernel source tree is huge ($>$ 125 MB) and inflexible (because it is difficult to add new kernel components). We propose to make this architecture more flexible by assembling kernel source trees dynamically from individual kernel components. Users then, can select what component they really need. Hardware vendors can easily support the Linux platform by providing additional separately developed kernel components. We demonstrate how the kernel's build process can be setup for this approach and how individual build processes look like. We use a technique called source tree composition to assemble source trees of components. We demonstrate how it is automated by the tool autobundle. We also propose a kernel component base as central repository of kernel components. It forms a central meeting point for kernel developers and users

Boxenv.sty : a LATEX style file for formatting BOX expressions

Box is a language independent mark-up language. It is designed for use within a generic pretty-print framework to connect source language dependent front-ends to target language dependent back-ends. A front-end translates a term over a language to Box to describe its intended layout. Back-ends translate Box terms to arbitrary output formats. The tool box2latex is a back-end that generates LaTeX code using specialized LaTeX commands and environments defined in the style file boxenv.sty. This style file is required in order to process the generated document by LaTeX. This paper describes how to integrate the generated LaTeX files within your documents, and it describes the low-level interface and implementation of the boxenv.sty style file

Pretty-printing for software reengineering

Automatic software reengineerings change or repair existing software systems. They are usually tailor-made for a specific customer and language dependent. Maintaining similar reengineerings for multiple customers and different language dialects might therefore soon become problematic unless advanced language technology is being used. Generic pretty-printing is part of such technology and is the subject of this paper. We discuss specific pretty-print aspects of software reengineering such as fulfilling customer-specific format conventions, preserving existing layout, and producing multiple output formats. In addition, we describe pretty-print techniques that help to reduce maintenance effort of tailor-made reengineerings supporting multiple language dialects. Applications, such as COLBOL reengineering and SDL documentation generation show that our techniques, implemented in the generic pretty-printer GPP, are feasible

A pretty-printer for every occasion

Tool builders dealing with many different languages, and language designers require sophisticated pretty-print techniques to minimize the time needed for constructing and adapting pretty-printers. We combined new and existing pretty-print techniques in a generic pretty-printer that satisfies modern pretty-print requirements. Its features include language independence, customization, and incremental pretty-printer generation. Furthermore, we emphasize that the recent acceptance of XML as international standard for the representation of structured data demands flexible pretty-print techniques, and we demonstrate that our pretty-printer provides such technology

Pretty-printing within the ASF+SDF meta-environment : a generic approach

The automatic generation of formatters for (programming) languages within the Asf+Sdf Meta-Environment is a research topic that is concerned with the construction of language specific formatters (or pretty-printers) given a language definition in Sdf. In this paper, we give an overview of pretty-printers that have been developed within this project and observe that these pretty-printers are either language dependent or non-customizable. Language independence and customizability are inevitable properties of pretty-printers however, when faced with the problem of formatting many different, evolving languages. Therefore, we introduce in this paper a generic framework for pretty-printing and describe an instantiation of the framework that forms a language independent and customizable pretty-printer

XT: a bundle of program transformation tools : system description

{sc xt bundles existing and newly developed program transformation libraries and tools into an open framework that supports component-based development of program transformations. We discuss the roles of {sc xt's constituents in the development process of program transformation tools, as well as some experiences with building program transformation systems with {sc xt. <pr