This paper describes ongoing work toward the development of a standard software exchange format (SEF), for exchanging information among tools that analyze computer programs. A particular exchange format called GXL (Graph Exchange Language) is proposed. GXL can be viewed as a merger of well known formats (e. g. GraX, PROGRES, RPA, RSF, and TA) for exchanging typed, attributed, directed graphs. By using XML as notation, GXL offers a scaleable and adaptable means to facilitate interoperability of reengineering tools.

Grammarware comprises grammars and all grammar-dependent software, i.e., software artifacts that directly involve grammar knowledge. The term grammar is meant here in the widest sense to include XML schemas, syntax definitions, interface descriptions, APIs, and interaction protocols. The most obvious examples of grammar-dependent software are document processors, parsers, import/export functionality, and generative programming tools. Even though grammarware is so omnipresent, it is somewhat neglected --- from an engineering point of view. We lay out an agenda that is meant to promote research on improving the quality of grammarware and on increasing the productivity of grammarware development.

We present an approach for the generation of components for a software renovation factory. These components are generated from a context-free grammar definition that recognizes the code that has to be renovated. We generate analysis and transformation components that can be instantiated with a specific transformation or analysis task. We apply our approach to COBOL and we discuss the construction of realistic software renovation components using our approach.

A lightweight fact extractor is presented that utilizes XML tools, such as XPath and XSLT, to extract static information from C++ source code programs. The source code is first converted into an XML representation, srcML, to facilitate the use of a wide variety of XML tools. The method is deemed lightweight because only a partial parsing of the source is done. Additionally, the technique is quite robust and can be applied to incomplete and non-compile-able source code. The trade off to this approach is that queries on some low level details cannot be directly addressed. This approach is applied to a fact extractor benchmark as comparison with other, abet heavier weight, fact extractors. Fact extractors are widely used to support understanding tasks associated with maintenance, reverse engineering and various other software engineering tasks. 1.

Abstract not found

We proposed a new approach for the construction of grammars and parsers for existing languages. The approach is both very powerful and simple. We provided a structured process and explained our methods in detail so that others can apply our ideas for their own grammar construction activities. We illustrated the proposed approach with a nontrivial case study. Using our process, we constructed in a few weeks a complete and correct VS COBOL II grammar specification for IBM mainframes. We not only constructed a parser for it, but also published a web-enabled grammar specification so that others can use this result to conveniently construct their own grammar-based tools for VS COBOL II, or derivatives.

A means to add explicit structure to program source code is presented. XML is used to augment source code with syntactic information from the parse tree. More importantly, comments and formatting are preserved and identified for future use by development environments and program comprehension tools. The focus is to construct a document representation in XML instead of a more traditional data representation of the source code. This type of representation supports a programmer centric view of the source rather than a compiler centric view. Our representation is made relevant with respect to other research on XML representations of parse trees and program code. The highlights of the representation are presented and the use of queries and transformations discussed.

We provide a strategy to restructure transaction processing systems. Such systems are core assets of most modern business operations, so their enhancement is crucial. Before large-scale renovation of transaction processing systems can take place, they need to be restructured. We argue that teleprocessing systems are unstructured by their nature. In this paper we approach the problems from a technical viewpoint and we report on the methods and tools that are necessary to bring structure in transaction systems.

We generate a native pattern language from a context-free grammar. So if we have the underlying grammar of code that needs to be analyzed, or renovated the pattern language comes for free. We use native patterns for recognition and renovation of code. The pattern language is global in the sense that patterns can match entire programs. We illustrate native patterns by discussing a tool that remediates a notoriously difficult Year 2000 problem using native patterns. Categories and Subject Description: D.2.6 [Software Engineering ]: Programming Environments---Interactive; D.2.7 [Software Engineering]: Distribution and Maintenance--- Restructuring; D.3.4. [Processors]: Parsing. Additional Key Words and Phrases: Reengineering, System renovation, Patterns, Plans, Clich'es, Native pattern language, Year 2000 problem, Leap year problem. 1 Introduction One key task in reengineering software is the recognition of problematic code. For example, for Year 2000 related remediation, it is necessa...

preprocessor, program transformations Preprocessors with conditionals are often used as software configuration management tools, with preprocessor variables naming configuration aspects. The preprocessor conditionals found in large systems often have complex enabling Boolean equations and nesting. Over long periods, some configuration aspects lose all utility. Removal of all traces of a configuration variable and code dependent on that aspect becomes a significant task if performed manually. An industrial-strength transformation system can remove such configuration aspects in a much shorter period of time, by symbolically simplifying away the configuration aspect. This paper sketches the problem, and