[abc] parsing !@Foo

I've managed to coerce the grammar to handle !@Foo and still be LALR(1).

It now accepts all of the following:

    pointcut pc1(): set(@Foo Object *.foo);
    pointcut pc2(): set(@Foo @Goo Object *.foo);
    pointcut pc3(): set(@Foo (@Goo Object) *.foo);
    pointcut pc4(): set((@Foo @Goo Object) *.foo);
    pointcut pc5(): set((@Foo @Goo Object) *.foo);
    pointcut pc6(): set(@Foo @Goo Bar *.foo);
    pointcut pc7(): set(@Foo (@Goo Bar) *.foo);
    pointcut pc8(): set((@Foo Bar && @Goo Bar) *.foo);
    pointcut pc9(): set(((@Foo *) && (@Goo *) && Bar) *.foo);
    pointcut pc10(): set((@(Foo* && *Goo) Bar) *.foo);
    pointcut pc11(): set((@(@Foo Goo) Bar) *.foo);

    pointcut pc12(): set(!@Foo Object *.foo);
    pointcut pc13(): set(!@Foo !@Goo Object *.foo);
    pointcut pc14(): set(!@Foo (!@Goo Object) *.foo);
    pointcut pc15(): set((!@Foo !@Goo Object) *.foo);
    pointcut pc16(): set((!@Foo !@Goo Object) *.foo);
    pointcut pc17(): set(!@Foo !@Goo Bar *.foo);
    pointcut pc18(): set(!@Foo (!@Goo Bar) *.foo);
    pointcut pc19(): set((!@Foo Bar && !@Goo Bar) *.foo);
    pointcut pc20(): set(((!@Foo *) && (!@Goo *) && Bar) *.foo);
    pointcut pc21(): set((!@(Foo* && *Goo) Bar) *.foo);
    pointcut pc22(): set((!@(!@Foo Goo) Bar) *.foo);

    pointcut pc23(): call(@Foo Object *.foo());
    pointcut pc24(): call(@Foo @Goo Object *.foo());
    pointcut pc25(): call(@Foo (@Goo Object) *.foo());
    pointcut pc26(): call((@Foo @Goo Object) *.foo());
    pointcut pc27(): call((@Foo @Goo Object) *.foo());
    pointcut pc28(): call(@Foo @Goo Bar *.foo());
    pointcut pc29(): call(@Foo (@Goo Bar) *.foo());
    pointcut pc30(): call((@Foo Bar && @Goo Bar) *.foo());
    pointcut pc31(): call(((@Foo *) && (@Goo *) && Bar) *.foo());
    pointcut pc32(): call((@(Foo* && *Goo) Bar) *.foo());
    pointcut pc33(): call((@(@Foo Goo) Bar) *.foo());

    pointcut pc34(): call(!@Foo Object *.foo());
    pointcut pc35(): call(!@Foo !@Goo Object *.foo());
    pointcut pc36(): call(!@Foo (!@Goo Object) *.foo());
    pointcut pc37(): call((!@Foo !@Goo Object) *.foo());
    pointcut pc38(): call((!@Foo !@Goo Object) *.foo());
    pointcut pc39(): call(!@Foo !@Goo Bar *.foo());
    pointcut pc40(): call(!@Foo (!@Goo Bar) *.foo());
    pointcut pc41(): call((!@Foo Bar && !@Goo Bar) *.foo());
    pointcut pc42(): call(((!@Foo *) && (!@Goo *) && Bar) *.foo());
    pointcut pc43(): call((!@(Foo* && *Goo) Bar) *.foo());
    pointcut pc44(): call((!@(!@Foo Goo) Bar) *.foo());

    declare parents: @Foo Object extends Object;
    declare parents: @Foo @Goo Object extends Object;
    declare parents: @Foo (@Goo Object) extends Object;
    declare parents: @Foo @Goo Object extends Object;
    declare parents: @Foo @Goo Object extends Object;
    declare parents: @Foo @Goo Bar extends Object;
    declare parents: @Foo (@Goo Bar) extends Object;
    declare parents: @Foo Bar && @Goo Bar extends Object;
    declare parents: (@Foo *) && (@Goo *) && Bar extends Object;
    declare parents: @(Foo* && *Goo) Bar extends Object;
    declare parents: @(@Foo Goo) Bar extends Object;

    declare parents: !@Foo Object extends Object;
    declare parents: !@Foo !@Goo Object extends Object;
    declare parents: !@Foo (!@Goo Object) extends Object;
    declare parents: !@Foo !@Goo Object extends Object;
    declare parents: !@Foo !@Goo Object extends Object;
    declare parents: !@Foo !@Goo Bar extends Object;
    declare parents: !@Foo (!@Goo Bar) extends Object;
    declare parents: !@Foo Bar && !@Goo Bar extends Object;
    declare parents: (!@Foo *) && (!@Goo *) && Bar extends Object;
    declare parents: !@(Foo* && *Goo) Bar extends Object;
    declare parents: !@(!@Foo Goo) Bar extends Object;

Some caveats:

1) It requires the change to the underlying grammar that Oege emailed
the ajc team about. This change causes test 390 to fail.

2) There is no support for annotations on parameters, because as far as
I remember, we did not reach a consensus on how to specify them.

3) It needs more test cases.

4) It currently extends the Java 1.4 grammar, not the Java 1.5 grammar
(which Oege is in the process of procuring, if I understand correctly).

5) It is implemented, but not in a nice form. What form do we want it
in? It seems it doesn't make much sense to make it a ppg extension
of the normal grammar, because it needs to eventually extend Java
1.5, but the normal grammar extends Java 1.4. Also, it includes the
change mentioned in 1) above, which is not really an extension. Also,
I may need some help from someone with a sense of aesthetics to devise
meaningful names for some of the non-terminals I've introduced.

Ondrej
Received on Wed Dec 8 02:33:17 2004