Code extraction algorithms which unify slicing and concept assignment

One approach to reverse engineering is to partially automate subcomponent extraction, improvement and subsequent recombination. Two previously proposed automated techniques for supporting this activity are slicing and concept assignment. However, neither is directly applicable in isolation; slicing criteria (sets of program variables) are simply too low level in many cases, while concept assignment typically fails to produce executable subcomponents. This paper introduces a unification of slicing and concept assignment which exploits their combined advantages, while overcoming their individual weaknesses. Our 'concept slices' are extracted using high level criteria, while producing executable subprograms. The paper introduces three ways of combining slicing, and concept assignment and algorithms for each. The application of the concept slicing algorithms is illustrated with a case study from a large financial organisation

An Introduction to Slice-Based Cohesion and Coupling Metrics

This report provides an overview of slice-based software metrics. It brings together information about the development of the metrics from Weiser’s original idea that program slices may be used in the measurement of program complexity, with alternative slice-based measures proposed by other researchers. In particular, it details two aspects of slice-based metric calculation not covered elsewhere in the literature: output variables and worked examples of the calculations. First, output variables are explained, their use explored and standard reference terms and usage proposed. Calculating slice-based metrics requires a clear understanding of ‘output variables’ because they form the basis for extracting the program slices on which the calculations depend. This report includes a survey of the variation in the definition of output variables used by different research groups and suggests standard terms of reference for these variables. Our study identifies four elements which are combined in the definition of output variables. These are the function return value, modified global variables, modified reference parameters and variables printed or otherwise output by the module. Second, slice-based metric calculations are explained with the aid of worked examples, to assist newcomers to the field. Step-by-step calculations of slice-based cohesion and coupling metrics based on the vertices output by the static analysis tool CodeSurfer (R) are presented and compared with line-based calculations

A Denotational Interprocedural Program Slicer

This paper extends a previously developed intraprocedural denotational program slicer to handle procedures. Using the denotational approach, slices can be defined in terms of the abstract syntax of the object language without the need of a control flow graph or similar intermediate structure. The algorithm presented here is capable of correctly handling the interplay between function and procedure calls, side-effects, and short-circuit expression evaluation. The ability to deal with these features is required in reverse engineering of legacy systems, where code often contains side-effects

pBWT: Achieving succinct data structures for parameterized pattern matching and related problems

The fields of succinct data structures and compressed text indexing have seen quite a bit of progress over the last two decades. An important achievement, primarily using techniques based on the Burrows-Wheeler Transform (BWT), was obtaining the full functionality of the suffix tree in the optimal number of bits. A crucial property that allows the use of BWT for designing compressed indexes is order-preserving suffix links. Specifically, the relative order between two suffixes in the subtree of an internal node is same as that of the suffixes obtained by truncating the furst character of the two suffixes. Unfortunately, in many variants of the text-indexing problem, for e.g., parameterized pattern matching, 2D pattern matching, and order-isomorphic pattern matching, this property does not hold. Consequently, the compressed indexes based on BWT do not directly apply. Furthermore, a compressed index for any of these variants has been elusive throughout the advancement of the field of succinct data structures. We achieve a positive breakthrough on one such problem, namely the Parameterized Pattern Matching problem. Let T be a text that contains n characters from an alphabet , which is the union of two disjoint sets: containing static characters (s-characters) and containing parameterized characters (p-characters). A pattern P (also over ) matches an equal-length substring S of T i the s-characters match exactly, and there exists a one-to-one function that renames the p-characters in S to that in P. The task is to find the starting positions (occurrences) of all such substrings S. Previous index [Baker, STOC 1993], known as Parameterized Suffix Tree, requires (n log n) bits of space, and can find all occ occurrences in time O(jPj log +occ), where = jj. We introduce an n log +O(n)-bit index with O(jPj log +occlog n log ) query time. At the core, lies a new BWT-like transform, which we call the Parame- terized Burrows-Wheeler Transform (pBWT). The techniques are extended to obtain a succinct index for the Parameterized Dictionary Matching problem of Idury and Schaer [CPM, 1994]

Executables from Program Slices for Java Programs

Program slicing is a popular program decomposition and analysis technique that extracts only those program statements that are relevant to particular points of interest. Executable slices are program slices that are independently executable and that correctly compute the values in the slicing criteria. Executable slices can be used during debugging and to improve program performance through paral- lelization of partially overlapping slices. While program slicing and the construction of executable slicers has been stud- ied in the past, there are few acceptable executable slicers available, even for pop- ular languages such as Java. In this work, we provide an extension to the T. J. Watson Libraries for Analysis (WALA), an open-source Java application static analysis suite, to generate fully executable slices. We analyze the problem of executable slice generation in the context of the capabilities provided and algorithms used by the WALA library. We then employ this understanding to augment the existing WALA static SSA slicer to efficiently track non-SSA data dependence, and couple this component with our executable slicer backend. We evaluate our slicer extension and find that it produces accurate executable slices for all programs that fall within the limitations of the WALA SSA slicer itself. Our extension to generate executable program slices facilitates one of the requirements of our larger project for a Java application automatic partitioner and parallelizer

Extraçao de regras de integridade referencial a partir do código fonte

Orientador: Marcos Sfair SunyeDissertaçao (mestrado) - Universidade Federal do Paraná, Setor de Ciencias Exatas, Programa de Pós-Graduaçao em Informática. Defesa: Curitiba, 2002Inclui bibliografiaResumo: Para atender a solicitações de manutenção em sistemas de informação, os responsáveis pelo sistema necessitam conhecer suas funcionalidades, regras de negócio, ou pelo menos, a parte do sistema que será afetada pela alteração. Esta pode ser uma tarefa simples quando executada por quem construiu o sistema, mas se torna complexa quando o projetista original foi deslocado para outras funções ou não está mais na empresa e não existe documentação para obter as informações necessárias. Neste caso, para ajudar a resolver o problema é necessário buscar informações em todos os lugares onde possam existir. Elas podem ser obtidas do esquema do banco de dados, com colegas que participaram na construção do sistema, com o usuário e nos códigos fonte dos programas, sendo este último um dos recursos mais utilizados. Quando se pretende obter informações gerenciais com cruzamento de variáveis, a falta do conhecimento das relações e regras de integridade, podem levar a resultados imprecisos ou equivocados e comprometer decisões importantes. Para fazer reengenharia de sistemas ou para criação de bases de informações gerencias o conhecimento de relações e regras de integridade são de igual forma fundamental. Por isso a proposta deste trabalho é mostrar que é possível identificar, extrair e armazenar regras de integridade referencial do código fonte para subsidiar estas atividades.Abstract: In order to attend the information system maintenance demands an information technology professional needs to know the system as well as its functionalities and business norms, or at least the system portion that will be affected by the alteration. This can be a simple task when performed by the one who developed the system, but it can become a complex one when the system original developer has been transferred to other activities or is no longer working for the company and there's not enough documentation to obtain the needed information. In this case, to help solving the problem, it's necessary to search for information everywhere it may be available. The information is often searched for in the data base schema, with other professionals who took place in the system developing process, with the system users and in the written programs, being this one of the most used ones. To extract relational semantics from source code program is not an easy nor a fast way of obtaining the needed information and this is a proposal for this task