An integrated program representation and toolkit for the maintenance of C programs

Platoff, M. A.; Wagner, Marko; Camaratta, Joseph

doi:10.1109/icsm.1991.160319

Cited by 19 publications

(8 citation statements)

References 16 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…One of the earliest papers on handling the C preprocessor in a software maintenance tools is due to Platoff et al [23]. Badros and Notkin [2] describe an infrastructure for handling the C preprocessor in static analysis tools, which invokes user-defined callbacks when "interesting" preprocessing events occur.…”

Section: Related Workmentioning

confidence: 99%

A foundation for refactoring C with macros

Overbey

Behrang

Hafiz

2014

Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering

View full text Add to dashboard Cite

This paper establishes the concept of preprocessor dependences as a foundation for building automated refactoring tools that transform source code containing lexical macros and conditional compilation directives, such as those provided by the C preprocessor (CPP). We define a preprocessor dependence graph (PPDG) that models the relationships among macro definitions, macro invocations, and conditional compilation directives in a file-the relationships that must be maintained for the semantics of the C preprocessor to be preserved. For many refactorings, a tool can construct a PPDG from the code before and after it is transformed, then perform a linear-time comparison of the two graphs to determine whether the refactoring will operate correctly in the presence of macros and conditional compilation directives. The proposed technique was implemented in OpenRefactory/C and tested by applying refactorings to GNU Coreutils version 8.21. Empirical results indicate that the technique is effective; it successfully handled refactoring scenarios in which Eclipse CDT, Visual Assist X, and XRefactory all refactored code incorrectly.

show abstract

Section: Related Workmentioning

confidence: 99%

A foundation for refactoring C with macros

Overbey

Behrang

Hafiz

2014

Proceedings of the 22nd ACM SIGSOFT International Symposium on Foundations of Software Engineering

View full text Add to dashboard Cite

show abstract

“…First, Platoff et al sketched a similar parser as part of a general maintenance framework [50]. At #ifdef directives, they clone the parser state of an LALR parser and join when both parsers reach an identical state.…”

Section: Variability-aware Parsersmentioning

confidence: 99%

Variability-aware parsing in the presence of lexical macros and conditional compilation

Kästner

Giarrusso

Rendel

et al. 2011

Proceedings of the 2011 ACM International Conference on Object Oriented Programming Systems Languages and Applications

190

128

View full text Add to dashboard Cite

In many projects, lexical preprocessors are used to manage different variants of the project (using conditional compilation) and to define compile-time code transformations (using macros). Unfortunately, while being a simple way to implement variability, conditional compilation and lexical macros hinder automatic analysis, even though such analysis is urgently needed to combat variability-induced complexity. To analyze code with its variability, we need to parse it without preprocessing it. However, current parsing solutions use unsound heuristics, support only a subset of the language, or suffer from exponential explosion. As part of the TypeChef project, we contribute a novel variability-aware parser that can parse almost all unpreprocessed code without heuristics in practicable time. Beyond the obvious task of detecting syntax errors, our parser paves the road for further analysis, such as variability-aware type checking. We implement variability-aware parsers for Java and GNU C and demonstrate practicability by parsing the product line MobileMedia and the entire X86 architecture of the Linux kernel with 6065 variable features.

show abstract

“…Since refactoring engines require structured input, usually in the form of an abstract syntax tree (AST), a common idea is to disallow arbitrary annotations of code [6], [47], and limit the developer to a subset of disciplined annotations [36]: Annotations on entire functions, type definitions, and statements. If developers use solely disciplined annotations, #ifdef-annotated source code can be parsed based on preprocessor-enriched grammars [6], [36], and an AST with variability information can be used for further pro- cessing.…”

Section: State Of the Artmentioning

confidence: 99%

“…To apply such a disciplined-subset approach, arbitrary, undisciplined annotations have to be transformed (manually) to disciplined annotations. Although researchers experienced that such manual labor is feasible and scales to medium-sized software systems [6], [47], a recent study showed that undisciplined annotations occur frequently in practice [36]. Consequently, manually disciplining annotations for such systems is a tedious and error-prone task that will hardly be adopted in practice.…”

Section: State Of the Artmentioning

confidence: 99%

“…Existing refactoring approaches and tools use heuristics to reason about variability (which does not guarantee behavior preservation) [21], [46], employ a brute-force strategy to process all variants individually (which does not scale to realistic systems) [60], [61], [56], or limit the use of variability (which makes many systems unrefactorable) [39], [7], [25], [47]. To make matters worse, state-of-the-art refactoring engines of widely used IDEs, such as ECLIPSE and XCODE, even produce erroneous code when applying standard refactorings in the presence of preprocessor directives (e.g., RENAME IDENTIFIER or EXTRACT FUNCTION).…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Morpheus: Variability-Aware Refactoring in the Wild

Liebig

Apel

Janker

et al. 2015

2015 IEEE/ACM 37th IEEE International Conference on Software Engineering

View full text Add to dashboard Cite

Abstract-Today, many software systems are configurable with conditional compilation. Just like any software system, configurable systems need to be refactored in their evolution, but their inherent variability induces an additional dimension of complexity that is not addressed well by current academic and industrial refactoring engines. To improve the state of the art, we propose a variability-aware refactoring approach that relies on a canonical variability representation and recent work on variability-aware analysis. The goal is to preserve the behavior of all variants of a configurable system, without compromising general applicability and scalability. To demonstrate practicality, we developed MORPHEUS, a sound, variability-aware refactoring engine for C code with preprocessor directives. We applied MORPHEUS to three substantial real-world systems (BUSYBOX, OPENSSL, and SQLITE) showing that it scales reasonably well, despite of its heavy reliance on satisfiability solvers. By extending a standard approach of testing refactoring engines with support for variability, we provide evidence for the correctness of the refactorings implemented.

show abstract

An integrated program representation and toolkit for the maintenance of C programs

Cited by 19 publications

References 16 publications

A foundation for refactoring C with macros

A foundation for refactoring C with macros

Variability-aware parsing in the presence of lexical macros and conditional compilation

Morpheus: Variability-Aware Refactoring in the Wild

Contact Info

Product

Resources

About