Here is a letter that I sent to mozart developer Daveed
Daveed,

I am aware of the good work done by brad with the
gccxml project.

In that context you cannot forget
about cpp2xml
http://www.scl.csd.uwo.ca/Projects/cpp2xml

and CppX
http://www.swag.uwaterloo.ca/~cppx/

and Gasta from Guillaume Thouvenin
Gasta - Gcc Abstract Syntax Tree Analysis
http://gasta.sf.net

There is also the dct
http://dct.sourceforge.net/

The unique thing about the introspector is
that it concentrates on the nodes of the compiler
itself.
The layout of the data is similar to the
representation of the nodes of the compiler
internally.

Similar to GASTA it also gets the bodies of the
functions, which is not supported by gcc_xml.

What I am interested in is the client side
introspection, what does a client need to know about
its environment.

The Introspector uses introspection itself internally
to write to the database, write to xml, write to html
and other formats.

Please, can you tell me about your experiences using
introspection, what information do you get about an
object? The fields, the inheritances, other
relationships?

I Hope that I have shown the difference to other
projects and ideas.

Mike

SourceForge: Project Info - TouchGraph TouchGraph is a set of interfaces for visually manipulating associative networks. Written in java. There are many applications for this technology, the most interesting being the creation of mind managers, and graph-based newsgroups

Rigi C-Language Parser The Rigi C-Language Parser
The Rigi C-language parser is designed to extract entities and the relationships between entities from files of C source code. Currently the entities that the parser extracts are C functions and C structure definitions. The relationships that the parser extracts are function calls between function entities and data references between function and data structure entities. The parser represents these relationships as RSF (Rigi Standard Format) 3-tuples and writes them to the standard output. The parser also extracts other attributes of the entities, such as their type (either Function or Data) and the line number in the source code file that they were extracted from. For example, if we had the two functions given below in main.c, the RSF generated would look something like the following.

A Method of Program Understanding using Constraint Satisfaction for Software Reverse Engineering - Woods (ResearchIndex) The process of understanding a source code in a high-level programming language is a complex cognitive task. The provision of helpful decision aid subsystems would be of great benefit to software maintainers. Given a library of program plan templates, generating a partial understanding of a piece of software source code can be shown to correspond to the construction of mappings between segments of the source code and particular program plans represented in a library of domain source programs (plans).

Generation of Software Renovation Factories from Compilers - Sellink, Verhoef (ResearchIndex) When a compiler is designed carefully, it is possible to extract its grammar. We reengineer the extracted grammar to one that is geared towards reengineering. From this reengineering grammar we generate an architecture called a software renovation factory. This includes: generic analysis and transformation functionality and a native pattern language using the concrete syntax of the language for which the renovation is necessary. Moreover, we generate the grammar in HTML format so that reengineers can quickly understand the language. We applied our approach successfully to an exceptionally complex and large proprietary language.

Scaffolding for Software Renovation - Sellink, Verhoef (ResearchIndex) We discuss an approach that explores the use of scaffolding of source code to facilitate its renovation. We show that scaffolding is a useful paradigm for software renovation. We designed syntax and semantics for scaffolding, that enables all relevant applications of scaffolding. The automatic generation of extensions to a normal grammar, so that the resulting extension grammar can parse code with scaffolding, is discussed. We used the scaffolding paradigm itself to implement the generation process, thereby showing that our approach towards scaffolding is also useful in software development

A Two-phase Process for Software Architecture Improvement - Krikhaar, Postma, Sellink, Stroucken, Verhoef (ResearchIndex) Software architecture is important for large systems in which it is the main means for, among other things, controlling complexity. Current ideas on software architectures were not available more than ten years ago. Software developed at that time has been deteriorating from an architectural point of view over the years, as a result of adaptations made in the software because of changing system requirements. Parts of the old software are nevertheless still being used in new product lines. To make changes in that software, like adding features, it is imperative to first adapt the software to accommodate those changes.

ASTLOG: A Language for Examining Abstract Syntax Trees - Crew (ResearchIndex) Abstract: Syntax Trees Roger F. Crew Microsoft Research ASTLOG: A Language for Examining Abstract Syntax Trees Roger F. Crew Microsoft Research Microsoft Corporation Redmond, WA 98052 rfc@microsoft.com Abstract We desired a facility for locating#analyzing syntactic artifacts in abstract syntax trees of C#C programs, similar to the facility grep or awk provides for locating artifacts at the lexical level. Prolog, with its implicit pattern-matching and backtracking capabilities, is a natural choice for suchanapplication. We have developed a Prolog variant that avoids the overhead of translating the source syntactic structures into the form of a Prolog database; this is crucial to obtaining

Browsing and Searching Software Architectures - Sim, Clarke, Holt, Cox (ResearchIndex) Abstract: Software architecture visualization tools tend to support browsing, that is, exploration by following concepts. If architectural diagrams are to be used during daily software maintenance tasks, these tools also need to support specific fact-finding through searching. Searching is essential to program comprehension and hypothesis testing. Furthermore, searching allows users to reverse the abstractions in architectural diagrams and access facts in the underlying program code. In this paper, we consider the problem of searching and browsing software architectures using perspectives from information retrieval and program comprehension. After analyzing our own user studies and results from the...

Lackwit: A Program Understanding Tool Based on Type Inference - O'CALLAHAN, JACKSON (ResearchIndex)
Abstract: By determining, statically, where the structure of a program requires sets of variables to share a common representation, we can identify abstract data types, detect abstraction violations, find unused variables, functions, and fields of data structures, detect simple errors in operations on abstract datatypes, and locate sites of possible references to a value. We compute representation sharing with type inference, using types to encode representations. The method is efficient, fully automatic, and smoothly integrates pointer aliasing and higher-order functions. We show how we used a prototype tool to answer a user's questions about a 17,000 line program written in C. Keywords...

This is cool.
In our Mozilla Reverse Engineering Project, we are trying to extract architectural information from the publicly available Mozilla (Netscape) source code. Here's what we have done so far:

The C source files of Mozilla were parsed using our C parser cparse. The 4-tuple RSF output for each file was stored in a separate file.
All the RSF files were fed into sortrsf, to eliminate duplicate tuples and sort the tuples for faster processing.
The htmlrsf utility was used to create a HTML version of the Mozilla source code with hypertext cross references and a 3-tuple RSF file for use with rigiedit.
In ongoing work, the graph editor rigiedit is used to identify and extract subsystems of Mozilla.
Rigi Projects: Mozilla Reverse Engineering

Interesting post about Graphotron
xml-dev - Re: [xml-dev] Graph markup

Doxygen is really good
Doxygen homepage

Touchgraph Rocks
TG: News

From : Miloslav Nic [ nicmila@systinet.com ]
Graphotron - reference
Graphotron is a simple XML language for drawing graphs with XPath.
In this reference basic Graphotron elements are described.
ZvonGraphotron, a freely available Graphotron implementation, is available at download page.
The Graphotron history and a short summary of its features and underlying principles is given at about page. There is also a tutorial to wet your appetite. Graphotron documents can be tailored to a specific output program.
See references below for the relevant information.

Idea of introspection:
MARC: msg 'Re: Introspector Project Launch at SourceForge'

Announcement on gcc mailling list
MARC: msg 'Introspector Project Launch at SourceForge'

Link from Adrien Hernot

MARC: msg 'Re: xref info'

My Perlmonk Home Page
mdupont

Unrev maillist list
UnRev-II - headers sorted: [unrev-II] RE: Using of parse tree e

Mention on the Kernel Mailing lists
Linux-kernel mailing list archive 2001-42,: Re: DOT call graphs of Rik and AA VMs

Post to Debian GCC list
GCC 3.0 on potato

Prolog LIst
Archive of the ciao-users Mail List: RE: Database and memory limitations

SDS of course is interesting
Geocrawler.com - sds-devel - [sds-devel] GCC Introspector Project Announcement

I got another write up!

[Mono-list] RE: Compilers emitting parsetrees

http://luxik.cdi.cz/~devik/mm.htm
Contact : devik@cdi.cz
QUOTE about introspector :
25/10/2001 Scaling and feedback
Many (including John Ellson, one of graphviz authors) notified me that scaling can be done using graph [size="7,9.5"]
Sam Vilain pointed me to Introspector site. I will have to look at as I want to generate structure reference map of whole kernel someday ..

THe ABI is very important for compatability.
Lets look into it for ideas on linkage.
Oh, yeah and what about ELF and DWARF?
Where is gandalf.
C ABI Summary

This is a test post from perl