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

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

On 03.11.11 12:36, Stephen Leake wrote:

> In my opinion, this recursive descent style is much harder to
> understand. In particular, it is very difficult to see that the program
> structure matches the grammar structure.

Yes, recursion does take getting used to.  I am sketching a generator
that will remove the burden of writing the recursive subprograms.
Its input will be compatible with OpenToken's operator based notation.
Currently, the interesting part looks like the following. This is
just exploring ideas, there is no real business going on.
(The usual suspects like proper lexical scanning, generating tokens,
etc., might be compatible.)

with Tokens,  -- tokens, and lists of tokens
       Rules;   -- productions, and lists of productions
with Templates;   -- what should a recursive subprogram look like

procedure Generate_Recursive_Descent is

    ------------------------------------------------------------------------
    --  "Define the Grammar productions.
    --
    --  "The text in the example in the book looks something like:
    --
    --  S' -> S
    --  S  -> L = R | R
    --  L  -> * R | id
    --  R  -> L"
    --

    type Token_ID is (S_Prime_Nonterminal,
                      S_Nonterminal,
                      L_Nonterminal,
                      R_Nonterminal);

    package Example_Tokens is new Tokens (Token_ID);
    package Example_Rules is new Rules (Example_Tokens);
    package Writers is new Templates (Example_Tokens);

    S_Prime : Example_Tokens.Nonterminal(S_Prime_Nonterminal);
    S : Example_Tokens.Nonterminal(S_Nonterminal);
    L : Example_Tokens.Nonterminal(L_Nonterminal);
    R : Example_Tokens.Nonterminal(R_Nonterminal);

    Asterisk : Example_Tokens.Terminal
        (Name => new String'("Asterisk"),
         Match => '*');

    ID : Example_Tokens.Terminal
        (Name => new String'("id"),
         Match => 'I');

    Equals :  Example_Tokens.Terminal
        (Name => new String'("EQ"),
         Match => '=');

    use Example_Rules;  -- operators

    Example : constant Example_Rules.Grammar := Example_Rules.Null_Grammar and
        S_Prime <= S and
        S       <= L & Equals & R and
        S       <= R and
        L       <= Asterisk & R and
        L       <= ID and
        R       <= L;

    procedure Produce_Subprograms (Position: Lists_of_Rules.Cursor);

That is it, if one of the parsing models and Templates is acceptable
for the hypothetical programmer.


> Perhaps we should
> put both on the Ada Programming Wikibook somewhere?

It might be a starting point, although I'd prefer more generally relevant,
stripped down topics. For example the design pattern of delegation and its
consequences, or the meaning of distributed overhead of design choices:
show classical opposites, such as passive vs active, call vs callback,
Iterate vs for-loop, assignment-then-loop vs new-parameter-then-recursion,
heap allocation vs automatic objects etc.

If parsers can be stripped to the minimum matching one such subject,
they should serve as good examples? (Surely my example would need
overhaul, and polishing.)