Generation of program patterns from source code is a difficult, time consuming and error-prone process when performed by programmers. We describe an implemented system which generates patterns from an abstract syntax tree with interaction by the user. Our approach is based on creating intermediate pattems by exploring data dependencies in the source code and allowing the user to change and/or eliminate parts of it in order to create a final pattern. We describe the architecture of our system as well as the pattem language used, and illustrate our upproach with examples.

The implementation of an efficient automatic test generation scheme for black-box testing is discussed. It uses checkpoint encoding and antirandom testing schemes. Checkpoint encoding converts test generation to a binary problem. The checkpoints are selected as the boundary and illegal cases in addition to valid cases to probe the input space. Antirandom testing selects each test case such that it is as different as possible from all the previous tests. The implementation is illustrated using benchmark examples that have been used in the literature. Use of random testing both with checkpoint encoding and without is also reported. Comparison and evaluation of the effectiveness of these methods is also presented. Implications of the observations for larger software systems are noted. Overall, antirandom testing gives higher code coverage than encoding random testing, which gives higher code coverage than pure random testing.

Digital Signal Processors (DSPs) are special purpose microprocessors optimised for embedded applications that require high arithmetic rates. These devices are often difficult to compile for: compared to modern general purpose processors DSPs often have very small address spaces. In addition they contain unusual hardware features and they require correct scheduling of operands against pipeline registers to extract the highest levels of available performance. As a result, high level language compilers for these devices generate poor quality code, and are rarely used in practice. Recently, new generation processors have been launched that are very hard to program by hand in assembler because of the complexity of their internal pipelines and arithmetic structures. DSP users are therefore having to migrate to using high level language compilers since this is the only practical development environment. However, there exist large quantities of legacy code written in assembler which represent a significant investment to the user who would like to be able to deploy core algorithms on the new processors without having to re-code from scratch. This paper presents a working report on the development and use of a tool to automatically reverse-compile assembler source for the ADSP-21xx family of DSPs to ANSI-C. We include a discussion of the architectural features of the ADSP-21xx processors and the ways in which they assist the translation process. We also identify a series of translation challenges which, in the limit, can only be handled with manual intervention and give some statistics for the frequency with which these pathological cases appear in real applications.

We describe the implementation and use of a reverse compiler from Analog Devices 21xx assembler source to ANSI-C (with optional use of the language extensions for the TMS320C6x processors) which has been used to port substantial applications. The main results of this work are that reverse compilation is feasible and that some of the features that make small DSP's hard to compile for actually assist the process of reverse compilation compared to that of a general purpose processor. We present statistics on the occurrence of non-statically visible features of hand-written assembler code and look at the quality of the code generated by an optimising ANSI-C compiler from our reverse compiled source and compare it to code generated from conventionally authored ANSI-C programs.

An application generator has resulted from the authors' efforts to improve the development of interactive database applications. The developed tool is based on a meta-base. The meta-base comprises an extended data model, the programming language description and some additional information to support the generation process. The procedures described in a proprietary specification language serve to generate the application over the database modeled in the meta-base. The specification language is based on the source code templates, standard program structures and on special statements for handling of the meta-data. Main ideas and operating principles of the original application generator are exposed. The specification language, its syntax and its basic components are described. The generator functionality is explained on some simple specification examples where the SQL code and pseudo-code for the corresponding hypothetical application are generated. Some experience gathered from the generator practical usage is discussed. A list of projects is included, where some complex applications were developed by the aid of the generator. An analysis is presented to show the proportions of the generated source code versus manually written statements.

Code Analysis tools provide support for such software engineering tasks as program understanding, software metrics, testing and re-engineering. In this paper we describe genoa, the framework underlying application generators such as Aria and gen++ which have been used to generate a wide range of practical code analysis tools. This experience illustrates front-end retargetability of genoa; we describe the features of the genoa framework that allow it to be used with diĈerent front ends. While permitting arbitrary parse tree computations, the genoa speciĜcation language has special, compact iteration operators that are tuned for expressing simple, polynomial time analysis programs; in fact, there is a useful sublanguage of the genoa language that can express precisely all (and only) polynomial time (PTIME) analysis programs on parse-trees. Thus, we argue that the genoa language is a simple and convenient vehicle for implementing a range of analysis tools. We also argue that the front-end reuse approach of GENOA oĈers an important advantage for tools aimed at large software projects: the reuse of complex, expensive build procedures to run generated tools over large source bases. In this paper, we describe the genoa framework and our experiences with it.