Abstract
The paper presents a case study in the development of software modularisation tools. The tools are produced by using a system for developing code analysers that uses a database to store both a no-loss fine-grained intermediate representation and the analyses' results. The analysers are automatically generated from a high-level specification of the desired analyses expressed in a domain-oriented language. We use a program intermediate representation, called F(p), as the user-visible data base conceptual model. Analysers are specified in a declarative language, called F(p) − ℓ, which allows the specification of an analysis in the form of a traversal of an algebraic expression, with accesses to, and stores of, the database information the algebraic expression indexes. A foreign language interface allows the analysers to be embedded into C programs. This is useful, for example, to implement the user interface of an analyser or to facilitate interoperation of the generated analysers with pre-existing tools.
Article PDF
Similar content being viewed by others
References
Aho, A.V., Sethi, R., and Ullman, J.D. 1986. Compilers—Principles, Techniques, and Tools. Addison-Wesley.
Bache, R. and Mullerburg, M. 1990. Measures of testability as a basis for quality assurance. Software Engineering Journal, 5(2):68-92.
Berge, C. 1973. Graphs and Hypergraphs. Elsevier North-Holland.
Burd, E. and Munro, M. 1997. Enriching program comprehension for software reuse. Proc. of 5th International Workshop on Program Comprehension, Dearborn, Michigan: IEEE Computer Society Press, pp. 130-137.
Callis, F.W. 1989. Inter-Module Code Analysis for Software Maintenance, Ph.D. thesis, University of Durham, School of Engineering and Applied Science, Computer Science.
Callis, F.W. and Dietrich, S.W. 1991. The application of deductive databases to inter-module code analysis. Proc. of Conference on Software Maintenance, Sorrento, Italy: IEEE Computer Society Press, pp. 120-128.
Cameron, J.R. 1983, JSP & JSD: The Jackson Approach to Software Development. Tutorial: IEEE Computer Society Press.
Canfora, G., Cimitile, A., and DeLucia, A. 1996a. Specifying code analysis tools. Proc. of International Conference on Software Maintenance, Monterey, California: IEEE Computer Society Press, pp. 95-103.
Canfora, G., Cimitile, A., De Carlini, U., and De Lucia, A. 1998. An extensible system for source code analysis. IEEE Transactions on Software Engineering, 24(9):721-740.
Canfora, G., Cimitile, A., and Munro, M. 1996b. An improved algorithm for identifying reusable objects in code. Software—Practice and Experiences, 26(1):24-48.
Canfora, G., Cimitile, A., and Tortorella, M. 1995a. Prolog for software maintenance. Proc. of 7th International Conference on Software Engineering and Knowledge Engineering, Rockville, Maryland, pp. 478-486.
Canfora, G., Cimitile, A., and Visaggio, G. 1995b. Assessing modularisation and code scavenging techniques. Journal of Software Maintenance: Research and Practice, 7:317-331.
Canfora, G., De Lucia, A., Di Lucca, G.A., and Fasolino, A.R. 1994. Recovering the architectural design for software comprehension. Proc. of 3rd Workshop on Program Comprehension, Washington, District Columbia: IEEE Computer Society Press, pp. 30-38.
Canfora, G., De Lucia, A., and Di Lucca, G.A. 1997. A system for generating reverse engineering tools. Proc. of Workshop on Software Technology and Engineering Practice, London, U.K.: IEEE Computer Society Press, pp. 34-44.
Chen, Y.F., Nishimoto, M., and Ramamoorthy, C.V. 1990. The C information abstractor system. IEEE Transactions on Software Engineering, 16(3):325-334.
Chikofsky, E.J. and Cross II, J.H. 1990. Reverse engineering and design recovery: A taxonomy. IEEE Software, 7(1):13-17.
Choi, S.C. and Scacchi, W. 1990. Extracting and restructuring the design of large systems. IEEE Software, 7(1):66-71.
Cimitile, A. and De Carlini, U. 1991. Reverse engineering algorithms for program graph production. Software—Practice and Experience, 21(5):519-537.
Cimitile, A., De Lucia, A., and Munro, M. 1996. A specification driven slicing process for identifying reusable functions. Journal of Software Maintenance: Research and Practice, 8:145-178.
Cimitile, A., Fasolino, A.R., and Maresca, P. 1993. Reuse-reengineering and validation via concept assignment. Proc. of Conference on Software Maintenance, Montreal, Canada: IEEE Computer Society Press, pp. 216-225.
Cimitile, A. and Visaggio, G. 1995. Software salvaging and the call dominance tree. The Journal of Systems and Software, 28(2):117-127.
De Lucia, A., Di Lucca, G.A., Fasolino, A.R., Guerra, P., and Petruzzelli, S. 1997. Migrating legacy systems towards object-oriented platforms. Proc. of IEEE International Conference on Software Maintenance, Bari, Italy: IEEE Computer Society Press, pp. 122-129.
Dunn, M.F. and Knight, J.C. 1993. Automating the detection of reusable parts in existing software. Proc. of 15th International Conference on Software Engineering, Baltimore, Maryland: IEEE Computer Society Press, pp. 381-390.
Devanbu, P.T. 1992. GENOA—a customizable, language-and front-end independent code analyzer. Proc. of 14th International Conference on Software Engineering, Melbourne, Australia: IEEE Computer Society Press, pp. 307-319.
Evans, A., Butler, K.J., Goos, G., and Wulf, W.A. 1983. DIANA Reference Manual, Revision 3, Pitsburgh, PA, Tartan Laboratories Inc.
Fenton, N.E. and Kaposi, A.A. 1987. Metrics and software structure. Information and Software Technology, 29(6):301-320.
Ferrante, J., Ottenstein, K.J., and Warren, J. 1987. The program dependence graph and its use in optimization. ACM Transactions on Programming Languages and Systems, 9(3):319-349.
Ghezzi, C., Jazayeri, M., and Mandrioli, D. 1991. Fundamentals of Software Engineering, Englewood Cliffs: Prentice-Hall.
Girard, J.F. and Koschke, R. 1997. Finding components in a hierarchy of modules: A step towards architectural understanding. Proc. of International Conference on Software Maintenance, Bari, Italy: IEEE Computer Society Press, pp. 58-65.
Gupta, R. and Soffa, M.L. 1994. A framework for partial data flow analysis. Proc. of International Conference on Software Maintenance, Victoria, Canada: IEEE Computer Society Press, pp. 4-13.
Halstead, M.H. 1975. Elements of Software Science. Elsevier North-Holland.
Harandi, M.T. and Ning, J.Q. 1980. Knowledge based program analysis. IEEE Software, 7(1):74-81.
Harrold, M.J., Malloy, B., and Rothermel, G. 1993. Efficient construction of program dependence graphs. Proc. of ACM International Symposium on Software Testing and Analysis, pp. 160-170.
Hartman, J. 1991. Understanding natural programs using proper decomposition. Proc. of 13th International Conference on Software Engineering, Austin, TX: IEEE Computer Society Press, pp. 62-73.
Hausler, P.A. 1989. Denotational program slicing. Proc. of 22nd Annual Hawaii International Conference on System Science, Kailua-Kona, HI: IEEE Computer Society Press, pp. 486-494.
Hecht, M.S. 1977. Flow Analysis of Computer Programs. Elsevier North-Holland.
Jarzabek, S. and Keam, T.P. 1995. Design of a generic reverse engineering assistant tool. Proc. of 2nd Working Conference on Reverse Engineering, Toronto, Canada: IEEE Computer Society Press, pp. 61-70.
Johnson, S. 1979. Yacc: Yet Another Compiler-Compiler. Bell Laboratories.
Johnson, W.L. and Soloway, E. 1985. PROUST: Knowledge based program understanding. IEEE Transactions on Software Engineering, SE-11(3):267-275.
Lamb D.A. 1987. IDL: Sharing intermediate representations. ACM Transactions on Programming Languages and Systems, 9(3):297-318.
Lanubile, F. and Visaggio, G. 1997. Extracting reusable functions by flow graph-based program slicing. IEEE Transactions on Software Engineering, 23(4):246-256.
Lemke, I. and Sander, G. 1993. VCG: A Visualization Tool for Compiler Graphs, The COMPARE consortium, available from: ftp.es.uni-se.de (134.96.254.254):/pub/graphics/cdg/
Letovsky, S. 1988. Plan analysis of programs, Ph.D. thesis, Yale University, New Haven, CT.
Lindig, C. and Snelting, G. 1997. Assessing modular structure of legacy code based on mathematical concept analysis. Proc. of 19th International Conference on Software Engineering, Boston, MA: ACM Press: pp. 349-359.
Linton, M. 1984. Implementing relational views of programs. Proc. of ACM SIGSOFT Symposium on Practical Software Development Environments, Pittsburgh, PA, pp. 132-140.
Liu, S. and Wilde, N. 1990. Identifying objects in a conventional procedural language: An example of data design recovery. Proc. of Conference on Software Maintenance, San Diego, CA: IEEE Computer Society Press, pp. 266-271.
Livadas, P.E. and Johnson, T. 1994, A new approach to finding objects in programs. Journal of Software Maintenance: Research and Practice, 6:249-260.
Lukey, F.J. 1980. Understanding and debugging programs. International Journal of Man-Machine Studies, 12:189-202.
McCabe, T.J. 1976. A complexity measure. IEEE Transactions on Software Engineering, 2(4):308-320.
Müller, H.A., Orgun, M.A., Tilley, S.R., and Uhl, J.S. 1993. A reverse-engineering approach to subsystem structure identification. Journal of Software Maintenance: Research and Practice, 5:181-204.
Paul, S. and Prakash, A. 1996. A query algebra for program databases. IEEE Transactions on Software Engineering, 22(3):202-217.
Purtilo, J.J. and Callahan, J.R. 1989. Parse tree annotations. Communications of the ACM, 32(12):1467-1477.
Rapps, S. and Weyuker, E.J. 1985. Selecting software test data using data flow information. IEEE Transactions on Software Engineering, SE-11(4):367-375.
REFINE User's Guide, Palo Alto, CA: Reasoning Systems, 1989.
Rugaber, S. and Wills, L. 1996. Creating a research infrastructure for reengineering. Proc. of 4th Working Conference on Reverse Engineering, Monterey, CA: IEEE Computer Society Press, pp. 98-102.
Siff, M. and Reps, T. 1997. Identifying modules via concept analysis. Proc. of International Conference on Software Maintenance, Bari, Italy: IEEE Computer Society Press, pp. 170-179.
Snodgrass, R. 1989. The Interface Description Language—Definition and Use, Rockville, MD: Computer Science Press.
SPARCworks/Visual 1.1 User's Guide, Mountain View, CA: Sun Microsystems.
Weiser, M. 1984. Program slicing. IEEE Transactions on Software Engineering, SE-10(4):352-357.
Wielemaker, J. 1995. SWI-Prolog—Reference Manual, University of Amsterdam, available from: http://swi.psy.uva.nl/usr/jan/SWI-Prolog.html
Wille, R. 1981. Restructuring lattice theory: An approach based on hierarchies of concepts. In I. Rival (Ed.), Ordered Sets, NATO Advanced Study Institute, pp. 445-470.
Wills, L.M. 1992. Automated program recognition by graph parsing, Technical report n. AI-TR-1358, Ph.D. thesis, Massachusetts Institute of Technology, Cambridge, MA.
Woods, S. and Quilici, A. 1996. Some experiments toward understanding how program plan recognition algorithms scale. Proc. of 3rd Working Conference on Reverse Engineering, Monterey, CA: IEEE Computer Society Press, pp. 21-30.
Yeh, A.S., Harris, D.R., and Rubenstein, H.B. 1995. Recovering abstract data types and object instances from a conventional procedural language. Proc. of 2nd Working Conference on Reverse Engineering, Toronto, Canada: IEEE Computer Society Press, pp. 227-236.
Author information
Authors and Affiliations
Rights and permissions
About this article
Cite this article
Canfora, G., De lucia, A. & Di Lucca, G.A. A System for Generating Reverse Engineering Tools: A Case Study of Software Modularisation. Automated Software Engineering 6, 233–263 (1999). https://doi.org/10.1023/A:1008704710421
Issue Date:
DOI: https://doi.org/10.1023/A:1008704710421