Katsuhiko Gondow

Toward mining "concept keywords" from identifiers in large software projects

We propose the Concept Keyword Term Frequency/Inverse Document Frequency (ckTF/IDF) method as a novel technique to efficiency mine concept keywords from identifiers in large software projects. ckTF/IDF is suitable for mining concept keywords, since the ckTF/IDF is more lightweight than the TF/IDF method, and the ckTF/IDFs heuristics is tuned for identifiers in programs.We then experimentally apply the ckTF/IDF to our educational operating system udos, consisting of around 5,000 lines in C code, which produced promising results; the udoss source code was processed in 1.4 seconds with an accuracy of around 57%. This preliminary result suggests that our approach is useful for mining concept keywords from identifiers, although we need more research and experience.

Towards ANSI C Program Slicing using XML

Abstract In this paper, we consider ANSI C program slicing using XML (Extensible Markup Language). Our goal is to build a flexible, useful and uniform data interchange format for CASE tools, which is a key issue to make it much easier to develop CASE tools such as program slicers. Although XML has a great potential for such data interchange formats, we first point out that there are still a lot of challenging problems to be solved. Then, as a first step to our goal, we introduce ACML (ANSI C Markup Language), which describes the syntactic structure and static semantics for ANSI C code. In our preliminary experiment, we had a good result; it took only 0.5 man-month to implement Weisers slicer based on ACML, whereas it took about 2 man-months to implement an ANSI C parser and static semantics analyzer of XCI (Experimental C Interpreter).

DRACULA: Detector of Data Races in Signals Handlers

Data races can occur even in sequential programs due to asynchronous software interrupts (e.g., UNIX signals). In this paper, we propose and implement a new tool DRACULA that dynamically detects data races caused by UNIX signals. DRACULA has many positive characteristics like full-automation, no source code required, high scalability, and synchronization mechanism independence, which make DRACULA highly practical. Our preliminary evaluation of applying DRACULA on SPARC and IA32 platforms to Bash-3.0, consisting of around 89 KLOC in C code, produced promising results; the rates of false-positives are very low (2.6% and 7.0%) and DRACULA automatically reported 3 actual data races in Bash-3.0.

Binary-level lightweight data integration to develop program understanding tools for embedded software in C

In embedded software development, the programming language C and inline assembly code are traditionally widely used. However, tools for C program-understanding, e.g., cross-referencers or call graph extractors, are not mature still today. In this paper, we introduce a novel technique for developing program-understanding tools, based on binary-level lightweight data integration. To verify this idea, we first propose a new markup language for DWARF2 debugging information, and then, using the technique, we experimentally developed two cross-referencers (called dxref and rxref) and a call graph extractor (called bscg) for C. Our preliminary evaluation shows that the technique enabled us to efficiently develop practical and flexible tools.

A case study for XML semantics checker model

The aim of this paper is to demonstrate the significance of XML semantics checker approach. We apply this novel approach to check the semantic consistencies of the Quran holy book that is mentioned by Jon Bosak in Religion 2.00 Web site. Religion 2.00 is a group of four religious works marked up for electronic publication from publicly available sources. In this paper, we will concentrate mainly on studying the case study of the Quran holy book that is mentioned in the previous web site. We successfully applied our approach of XML semantics to check that the number of verses in each chapter was correctly written in the Quran XML format document. We also checked that the Quran XML document contains exactly the same number of chapters as in the real Quran holy book. In addition, we computed automatically the total number of verses in the holy book.

Static Call Graph Generator for C++ using Debugging Information

In this paper, we present a novel method to detect virtual functions in C+ + programs using a light-weight binary-level analysis. We developed a tool, dcgg, that statically generates call graphs for C++ using DWARF2 debugging information based on this method. We use a combination of a binary analysis and debugging information to detect static function calls (including inline expanded functions) simply and precisely, and also virtual function calls (dynamic function calls in C++). Virtual function calls are detected by tracing types in registers and the stack. In a preliminary evaluation dcgg generated precise call graphs including inline expansions and virtual function calls. These techniques are important to C++ programmers as they help in creating efficient and maintainable code.

Change Management and Consistency Maintenance in Software Development Environments Using Object-Oriented Attribute Grammars

In this paper, we consider describing software development environments (SDEs) using a computational model OOAG (Object Oriented Attribute Grammar) [Shi89] [SK90], which incorporates functions for managing changes and maintaining consistency. In SDEs, the change managenent and consistency maintenance are key issues and OOAG is suitable for describing them. Software objects in SDEs have many derived values, and software objects and their derived values have complex relations with each other. Careless human activities often cause inconsistencies among software objects and it usually costs a lot to recover them. OOAG provides declarative descriptions to re-compute automatically derived values based on change propagation and to check relations among software objects, which help recovering activities of programmers.

Optimizing the Execution Time for Checking the Consistency of XML Documents

The problem of checking the consistency of the semantics associated with extensible markup language (XML) documents is considered. We propose a novel technique to add semantics to XML documents by attaching semantic information to the XML element tag attributes. We call this XML semantics. This approach is based on the same concept of attribute grammars (AGs), attaching and checking static semantics of programming languages through their attributes. The goal of this paper is to introduce the notions of copy rules and copy attributes that can be deployed in the XML semantics. Moreover, we will show how it can be represented in the SLXS language. The SLXS language is a description language based on XML; we have designed it to describe the semantic dependencies of XML documents. In addition, we demonstrate the copy bypass attribute propagation algorithm that can be used to eliminate the evaluation of copy attributes in copy rule chains. It dynamically replaces copy rules with non-local dependencies. Given such elimination, we get a faster attribute evaluator and avoid evaluating unnecessary attributes. Furthermore, more than half of the generated code associated with copy rules is reduced. In this way, we gain an optimization technique to evaluate and check the consistency of XML documents that may contain such attributes. Finally, we evaluate experimentally the performance benefits of our technique using a variety of XML documents.

Experience with ANSI C markup language for a cross-referencer

The purpose of this paper is twofold: (1) to examine the properties of our ANSI C markup language (ACML) as a domain-specific language (DSL); and (2) to show that ACML is useful as a DSL by implementing an ANSI C cross-referencer using ACML. We have introduced ACML as a DSL for developing CASE tools. ACML is defined as a set of XML tags and attributes, and describes ANSI C programs syntax trees, types, symbol tables, and so on. That is, ACML is the DSL which plays the role of intermediate representation among CASE tools. ACML-tagged documents are automatically generated, from ANSI C programs, and then used as input of CASE tools. ACML is self-descriptive and has CASE-tool specific information, which results in high productivity of CASE tools. To show this, we experimentally implemented an ANSI C cross-referencer based on ACML. In the implementation, we had a good result; it took only 0.5 man-month.

A practical example of XML semantics

We describe a case study applying XML semantics approach to specify the consistency of holy books published in XML format. The goal of the study was to understand the application of XML semantics in a problem domain that is appropriated for the method, and to determine some of the strengths of XML semantics in this domain. The case study uses a new specification language for XML semantics (SLXS) that is employed to specify semantic rules. These semantic rules associated with the holy books, which are written in XML format, to check the variant semantic consistency problems that exist inside these holy books.