Re: question about the usage of opentoken-4.0b

[Charly <carl.weierstrass@googlemail.com>]

Am Mittwoch, 25. April 2012 14:03:59 UTC+2 schrieb Stephen Leake:
> Charly writes:
> 
> > Hi,
> >
> > I have a question about the usage of opentoken-4.0b, a scanner/parser-library written in Ada.
> > So my question isn't about the language Ada itself but only about this library.
> >
> > I define a Grammar starting with 
> >
> >    Grammar : constant Production_List.Instance :=
> >      Prog      <= Def_List & EOF + Program_Token.Create     and
> >      Def_List  <= Def_List & Ent + Element_List.Concat      and
> >      Def_List  <= Ent            + Element_List.Create      and
> >      Ent       <= Entity_Key & Ident & Colon & El_List & End_Key &
> >                   Semicolon      + Entity_Token.Create      and
> > ...
> >
> > and I create and call the parser with 
> >
> >    Text_Parser := LALR_Parser.Generate (Grammar, Analyzer, False);
> >
> >    LALR_Parser.Parse (Text_Parser);
> >
> > It works fine, but to use the result of the parsing, which happens to
> > be the start element 'Prog' of the above Grammar, I had to store it in
> > a global variable, as one of the actions of the procedure
> > 'Program_Token.Create'. But I would like to avoid this, because I
> > don't like global variables;
> >
> > The variable 'Prog' in the Grammar definition has the right type, but
> > does not contain any data, as I expected.
> >
> > Any help would be appreciated.
> 
> I think I understand; you want the side-effect output of
> Program_Token.Create for Prog to be stored in some non-global variable.
> 
Yes, thats right.

> I'll assume that by 'global' here you mean 'declared in some package,
> and thus allocated statically' as opposed to 'declared in some
> subroutine, and thus allocated dynamically'.
> 
Yes, right again. My working solution - that I don't like - stores it in the 
Program_Token package.

> You want dynamic allocation (either stack or heap, but with the heap
> root reference on the stack) for the side-effect output.
> 
> I've never tried to do that; I always have a few root global variables
> in my most complex code (_something_ has to store the symbol table :),
> so it has not come up.
> 
> The examples in OpenToken essentially do all processing inside the
> various action subroutines, so they don't help here.
> 
I could not find the answer in the docu. Of cource I could do all
processing in the final Program_Token.Create procedure, but I would
like to do it in the main program after the call of LALR_Parser.Parse(...),
something like
Result := LALR_Parser.Get_Result, 
that returns the Instance defined in Program_Token. This Instance contains
all the stuff collected while parsing the input file.

> If you could post a small compilable example, I'd be able to think about
> it more concretely. You might get somewhere with access discriminants,
> but I don't see how immediately.


My program consists of about 15 packages, so I will try do create a trivial
working example and post it again.

> 
> -- 
> -- Stephe

Thanks for your answer.

Charly