-*- mode:outline; minor-mode:outl-mouse -*-

* Bugs:

** strategies that go through an abstract class

Things like this don't work correctly:

    Foo = Bar *common* Fred.
    Bar : Baz.
    Baz = .

    Foo { traversal f(V v) { via Bar to Fred; } }

It never gets to the Fred object.

** syntax between optional parts

The generated PrintVisitor won't compile if your CD has something like
the following:

    Foo = [ Bar ";" ] "*" [ Baz ].

It creates two after__bar(Foo foo, Bar dest) methods on PrintVisitor.

** default part names for lowercase types

The default part name is the type converted to lowercase, but this
doesn't work if the type (class or primitive type) is already
lowercase.

** optional parts of builtin type

An optional part that's a builtin type produces bad code, because you
can't compare (e.g.) an int to null.

** globbing problems with edges

"before -> *,*,*" is somewhat broken.

** multiple wrappers for the same class

A visitor may not have two wrappers for the same class, e.g.

    before { Foo, Bar } (@ ... @)
    before Foo (@ ... @)

This should be allowed, and they should be called in the order seen in
the .beh file.  A similar problem exists with "before *" and "before Foo".

** abstract visitors need empty wrappers

If you have an abstract visitor:

    Foo = .
    AbstractVisitor : ConcreteVisitor.
    ConcreteVisitor = .

and you have a traversal that uses the abstract visitor:

  Foo { traversal foo(AbstractVisitor v) { to *; } }
  ConcreteVisitor { before Foo (@ ... @) }

The before method for Foo won't be seen.  You have to add:

  AbstractVisitor { before Foo (@ @) }

This should rather be deduced automatically.

** cannot inherit from parameterized classes

This doesn't work:

  Foo = *extends* List(Bar).

** cannot have "deep" parameterization

This doesn't work:

  Foo(X) = Bar(X).

** error reporting sucks

Error messages should have line numbers, and in general be more
informative.

** comment propagation

Comments in .beh files outside Text blocks should be propagated to the
generated .java files.

** DisplayVisitor

The DisplayVisitors that are generated don't do a great job with
repetition classes.

* Missing features:

** strategies through an edge

You should be able to say "through -> *,x,*" in a strategy.

** compound strategies

Join (concatenation), merge (union), and intersection.

** named strategies

You should be able to name a strategy and refer to it in a later
strategy expression.

** name mappings for strategies

There should be a way to map the names in a strategy to names in a
class graph.  In particular, there should be a way to map several
nodes in the strategy graph to the same class in the class graph.
E.g.

    { X -> A, A -> B, B -> A, A -> C }

would differ from

    { X -> A, A -> B, B -> A2, A2 -> C } mapping A2:A

in that only the former admits the path A C.  Path directives which
mention the same node twice, e.g.

    via A via B via A to C

should automatically be converted into the second form.

** general way to initialize visitors and compute return value in adaptive methods

Adaptive methods with multiple visitors should allow some way to
initialize the visitors other than the first, as well as compute a
return value from multiple visitors.

** less output

There should be an option to control how many debugging/status
messages demjava should print, with the default being something less
than what it is currently (probably nothing for a successful run).

** multiple CD files

The user should be able to list multiple .cd files on the command line.

** handle dependencies in demjava

The dependency checking should be moved out of the GNUmakefile, for
finer-grained control of compilation.

** parsing external classes

There should be a way to specify how an external (terminal) class can
be parsed.

** container classes

The user should be able to make repetition classes use any class for
the container (e.g. Vector), not just a linked list.

** interface support

The user should be able to define interfaces in the CD file (and
traverse them?)

** composite visitors

Visitors should be able to add subvisitors to the current traversal.
E.g. AverageVisitor adds SumVisitor and CountVisitor.

** parameterized visitors

Visitors should be able to be parameterized with the classes where
behavior is attached.  E.g. CountVisitor<Basket,Apple>

** extend Java

Add syntax to Java for traversals & visitors.

** subtraversals

Should be able to restrict a visitor to a portion of a traversal.

** structural extension

Visitors should be able to add structure as well as behavior.

** context objects

General context objects (Linda's thesis).

** parallelism

Multiple visitors in parallel on a traversal, or visit aggregates
(repetition object) in parallel.


$Id: BUGS,v 1.9 1997/08/05 05:23:24 dougo Exp $