Re: Ada grammar

[Ray Blaak <blaak@infomatch.com>]

bradders <bradNObrSPAM@england.com.invalid> writes:
> My company produces a UML based Real-time modelling tool. We
> generate and reverse engineer code for C, C++ and Java and soon
> we will be supporting Ada 95. Basically I need to be able to
> Parse Ada code to build up a symbol table and populate a class
> model.

Everyone is telling you to use ASIS, but I think you should go for it and parse
the sources directly. I have written both Ada parsers and UML reverse
engineering tools, and in my opinion things are a lot more manageable if your
tool does not require an ASIS-compliant Ada compiler to be installed.  Your
tool is more stand-alone and can work anywhere with a minimum of fuss (no
configuration issues to interface to a client's existing Ada compiler) if it
has minimal external dependencies.

Certainly if one is reverse engineering Ada code, there is bound to be an Ada
compiler nearby, but that is not reason enough to require it. A designer
playing with a UML model is not necessarily the same person as the programmer
compiling the Ada program.

The main reasons you want your own parser are:

- For design purposes you are interested a subset of the language and so can
  cut corners when parsing the uninteresting stuff (e.g. perhaps parsing
  routine bodies just enough to find the correct "end" token, but otherwise
  ignoring statements).

- You can do tricks that a normal parser cannot do, like play games with
  whitespace, reconstructing comments, etc. (How good is ASIS at getting
  perfect reconstruction of the source)?

- Even if ASIS is "perfect" with regards to giving access to absolutely every
  character of the source, having your own parser gives you the freedom to
  tailor your parsing to fit the design of your tool, so you can get access to
  the desired source information in the most natural way.

  Consider, for example, that your tool might require all sources of a project
  to be loaded simultaneously (i.e. if one is doing "interactive"
  forward/reverse engineering from UML to code and vice versa). With your own
  parser and parse trees you can optimize things to reduce space cost
  (e.g. loading on the fly, indirect token references to the source file
  instead of actually having contents in memory, etc.).

  This freedom of design is *the* reason to write your own parser.

An Ada parser is non-trivial, but its not *that* hard. Tedious maybe, but not
hard. The benefits are worth it, in my opinion, for a tool such as you are
describing.

-- 
Cheers,                                        The Rhythm is around me,
                                               The Rhythm has control.
Ray Blaak                                      The Rhythm is inside me,
blaak@infomatch.com                            The Rhythm has my soul.