This thesis defines a set of program restructuring operations (refactorings) that support the design, evolution and reuse of object-oriented application frameworks. The focus of the thesis is on automating the refactorings in a way that preserves the behavior of a program. The refactorings are defined to be behavior preserving, provided that their preconditions are met. Most of the refactorings are simple to implement and it is almost trivial to show that they are behavior preserving. However, for a few refactorings, one or more of their preconditions are in general undecidable. Fortunately, for some cases it can be determined whether these refactorings can be applied safely. Three of the most complex refactorings are defined in detail: generalizing the inheritance hierarchy, specializing the inheritance hierarchy and using aggregations to model the relationships among classes. These operations are decomposed into more primitive parts, and the power of these operations is discussed from the perspectives of automatability and usefulness in supporting design. Two design constraints needed in refactoring are class invariants and exclusive components. These constraints are needed to ensure that behavior is preserved across some refactorings. This thesis gives some conservative algorithms for determining whether a program satisfies these constraints, and describes how to use this design information to refactor a program.

Objective measurement of test quality is one of the key issues in software testing. It has been a major research focus for the last two decades. Many test criteria have been proposed and studied for this purpose. Various kinds of rationales have been presented in support of one criterion or another. We survey the research work in

this paper is to refine this definition somewhat, adapting it to the purposes of the research community in computer science. Accordingly, we shall attempt to provide a reasonable definition of or, rather, criteria for folk theorems, followed by a detailed example illustrating the ideas. The latter endeavor might take one of two possible forms. We could take a piece of folklore and show that it is a theorem, or take a theorem and show that it is folklore. As an example of the first form we could have shown that the statement P NP, which is folklore, is also a theorem. However, since we have resolved to introduce no new technical material in this paper, and moreover, since researchers in our community seem to be less familiar with folklore than with theorems, Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for direct commercial advantage, the ACM copyright notice and the title of the publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission

. A structuring algorithm for arbitrary control flow graphs is presented. Graphs are structured into functional, semantical and structural equivalent graphs, without code replication or introduction of new variables. The algorithm makes use of a set of generic high-level language structures that includes different types of loops and conditionals. Gotos are used only when the graph cannot be structured with the structures in the generic set. This algorithm is adequate for the control flow analysis required when decompiling programs, given that a pure binary program does not contain information on the high-level structures used by the initial high-level language program (i.e. before compilation). The algorithm has been implemented as part of the dcc decompiler, an i80286 decompiler of DOS binary programs, and has proved successful in its aim of structuring decompiled graphs. 1 Introduction A decompiler is a software tool that reverses the compilation process by translating a pure binar...

This paper presents a structuring algorithm for arbitrary reducible, unstructured graphs. Graphs are structured into semantically equivalent graphs, without the need of code replication or introduction of new variables. The algorithm makes use of structures such as, if..then..elses, while, repeat and loop loops, and case statements. Gotos are only used when the graph cannot be structured with any of the above constructs. This algorithm is adequate for the analysis needed in the decompilation of programs, given that a binary program does not contain information as to the language and compiler used to compile the original source program. And given that unstructuredness is introduced by the use of gotos (still widely available in today's compilers) and optimizations produced by the compiler, we have to assume an unstructured graph for our decompilation analysis. This algorithm has been implemented as part of the dcc decompiler, currently under development at the Queensland University of ...

A proposed methodology for decompilation of binary programs is presented, along with a description of a particular implementation of this methodology, dcc. dcc is a decompiler for the Intel 80x86 architecture, which takes as input a binary program from a DOS environment and produces C programs as output. The decompiler has been divided into three separate modules which resemble the structure of the compiler. The front-end module is machine dependent and performs the loading and parsing of the program, as well as the generation of an intermediate representation. The universal decompiling machine module is machine and language independent, and performs all the flow analysis of the program. Finally, the back-end module is language dependent and deals with the details of the target high level language. Even though the problem of decompilation is insoluble in general, a partial solution can be found, which gives information about the binary program. This paper describes some of the results ...

In order to increase productivity of program development, several diagramming techniques have been developed to compliment conventional pure-textual program representation methods. To handle real software, it is important to have tools for processing also non-structured programs. In this paper, the concept of quasi-structured programs and the corresponding formal notation are introduced. It is proved constructively that any reducible flowgraph can be represented by a quasi-structured program under the strong equivalence. On the other hand, there exists a quite natural way to represent quasi-structured programs in the form of most comprehensible diagrams. Therefore the concept may serve as a basis for further theoretical research as well as for developing effective tools for quasi-structured programming and software engineering. Categories and Subject Descriptors: D.3.3 [Programming Languages]: Language Constructs and Features; F.3.3 [Logics and Meanings of Programs]: Studie...

Abstract. The Böhm–Jacopini theorem (Böhm and Jacopini, 1966) is a classical result of program schematology. It states that any deterministic flowchart program is equivalent to a while program. The theorem is usually formulated at the first-order interpreted or first-order uninterpreted (schematic) level, because the construction requires the introduction of auxiliary variables. Ashcroft and Manna (1972) and Kosaraju (1973) showed that this is unavoidable. As observed by a number of authors, a slightly more powerful structured programming construct, namely loop programs with multi-level breaks, is sufficient to represent all deterministic flowcharts without introducing auxiliary variables. Kosaraju (1973) established a strict hierarchy determined by the maximum depth of nesting allowed. In this paper we give a purely propositional account of these results. We reformulate the problems at the propositional level in terms of automata on guarded strings, the automata-theoretic counterpart to Kleene algebra with tests. Whereas the classical approaches do not distinguish between first-order and propositional levels of abstraction, we find that the purely propositional formulation allows a more streamlined mathematical treatment, using algebraic and topological concepts such as bisimulation and coinduction. Using these tools, we can give more mathematically rigorous formulations and simpler and more revealing proofs. 1

Branch-coverage testability transformation for unstructured programs