use vars qw(%item %label @code);

my $parser = Parse::RecDescent->new(q(
   ...
    label: /[a-z]\w*/i {
        $main::label{$item[1]} = scalar @main::code;
    }
   ...
));
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

$a = 1;
{
  local $a = 2;
  print "$a\n";
}
print "$a\n";
[download]

2
1
[download]

So the answer is to not use local. This has a downside of course, if you don't use local then the alias will never go away, so you might have to do something funky like emulating localisation.

WARNING: doing this sucks, it's very easy to make a mistake. If I ever saw this in a module, I would have serious doubts about the author!

my $grammar = q{
  {our @a, @as}

  ruleX: r1 local_a r2 r3 unlocal_a
  local_a: {
    push(@as, \@a);
    *a{ARRAY} = undef;
  }
  unlocal_a: {
    *a{ARRAY} = pop(@as);
  }
  r2: 'keyword' /[a-z]+/ {
    local *a = \@::{$item[2]};
  }
  r3: 'value' /[a-z]+/ {
    print @a;
  }
}
[download]

r1 will be matched and executed

local_a will save a ref to the current @a onto the @as stack

r2 will alias something to @a

r3 can now use @a and get the value that r2 put into

finally unlocal_a will put @a back to whatever it was beforehand.

So using the above lets you share aliases between rules of the grammar and it lets you nest those rules too because it makes sure it always saves the previous alias and restores it when you're done. However it is very easy to forget the unlocal_a at the end. Plus it's a lot of work and you have to write 2 rules for every variable you want to use for aliases. So don't do this unless you really really really have to.

As to the second question, I don't really know what you mean. Can you rephrase it.

hmm.. thanx for the answers.
As I thought it seems counterproductive to use aliasing..
Lets rephrase the second question :

the idea is to have the result of the parsing as internal object data but not global..
this way I can create many objects that can parse different string-flows.. so that i do :


my $obj = new Parser();
$obj->parse;
print "$_\n" for @{$$obj{_data}};
[download]

this mean I have to write directly into $$obj{_data} array during the parse..
I can't figure out how to access object data from the parse..probably class var which will work as intermediate reference...


package Parser;
our $ref;

my $grammar = q{
    { my $data = $ref }
    start : ..... 
    ruleX : blah hmm { push @{$$data{_data}}, $item[2] }
}

sub parse {
   my $self = shift;
   $ref = $self{_data};
   $parser = new Parse::RecDescent;
   $parser->start($$self{str})
   ...
}
[download]

havent tested..is this the correct way of doing it ?! what bothers me in this variant is that $ref can be overwriten from different objects..(which can be problem in multiuser env., not that i will use it in such way but who know :"))
Using array/stack will not solve this problem either..