Re: Ada 'hello world' for Android; success!

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 02.11.11 16:55, Stephen Leake wrote:

>>> http://www.stephe-leake.org/ada/access_vs_object.html).
>>
>> (When the problem domain is grammars, my goal of an application is to allow
>> the user to build a structure of subprograms that represent a grammar,
>> so the application can then call the subprogram matching the start symbol
>> (or other symbols) to parse input strings.
>
> I'd love to see your solution to this problem. It's easy to talk about
> general principles and design goals; only complete actual solutions
> flesh out all the problems and details.

http://home.arcor.de/bauhaus/Ada/recdecnoptr.ada

This example features:

- a hierarchy of "tokens", though barely: Terminal and Non_Terminal,
with some info in each, derived from abstract Token.

- a handler derived from an abstract handler type, overriding a
primitive operation. The operation, On_Token, receives an object
of type Token'Class when some "grammatical event" happens.

       procedure On_Token
           (Manager : in out Handler;
            Found   : in Tokens.Token'Class)
          is abstract;

- a recursive descent parser (exhaustive). The parser is structured
just as the grammar, which in this demo is

   S -> a S | a

A similar program using the same parsing technique was
built around 28 productions. It also had the necessary level of
abstraction that is absent from the above demo, such as functions
that would query the state of a token (Image etc.).

No token is ever stored, though the handler types are free to
do whatever they want with the tokens, including storing them.
There are no allocators for tokens. The program uses access,
but for different purposes.

In a different program, I had used objects separate from tokens
for keeping more information about the tokens. The tokens and
the info objects were then associated in a has-a relationship,
using pointers to 'Class.  But I could have passed these
additional objects without using pointers, too, just for the record.

In summary, then, I do not see that it is necessity to add pointers
to a parser interface. Storing polymorphic objects of polymorphic
components seems a different subject of a very general nature.