I've been thinking about writing a column on that, but haven't finished. I saw a good example of that in theDamian's class notes though.

-- Randal L. Schwartz, Perl hacker

I'm currently doing something like that, though I'm not actually updating $text:

macro:  identifier ":" expr
{
   if (defined $_macro{$item[2]->getVal()}) {
      # ERROR -- duplicate macro definitions
   }
   else {
      $_macro{$item[2]->getVal()} = $item[4];
      $return = $item[2];
   }
}
[download]

Rather than update $text, I build my op-tree branch directly from expr. (And it's working so far...)
Adding arg's to this seems harder, since the instantiation-points can be many subrules deeper.
- Jim

Macros will have to be defined prior to use then though, unless I'm a mile off on how this'd work. (Not that that's bad, but it would differ from a two pass compiler in this respect and might be a point to consider.)

Makeshifts last the longest.

(Merlyn, I look forward to seeing your column on this, by the way. - Jim)

Macros are most often implemented as a separate grammar, and macro processing is done by a separate logical process done prior to parsing (possibly even prior to lexical analysis). Trying to mix macros into your primary grammar is going to be an uphill battle. The received wisdom is "keep the two separate", though you might learning something by trying.

Thanks, Mark.
I suspect two passes is somehow necessary, one way or the other, but I thought maybe I was missing one of the deeper features of the amazing P::RD.
- Jim

When you recognize the macro, modify the text to replace the macro with what should be there, throw an exception, and then retry the parse.

Inefficient? Well you are using Parse::RecDescent so you obviously cannot be worried about that!

sub demacro($)
{
    my $text = shift;
    while (($macro,$pkg) = each %macro )
    {
        my $defn = $$pkg[0];
        if (defined $$pkg[1]) {
            my @args = @{$$pkg[1]};
            while ($text =~ m/($macro\((.*?)\))/g) {
                my $oA = length($`), $oZ = length($&);
                my @vals = split /\s*,\s*/, $2;
                (@args eq @vals)
                    or die "Bad arg count for macro '$macro'\n";
                my $_defn = $defn;
                for ($i=0; $i<@args; $i++) {
                    $_defn =~ s/$args[$i]/($vals[$i])/g;
                }
                substr($text, $oA, $oZ) = $_defn;
            }
        }
        else {
            $text =~ s/$macro/$defn/;
        }
    }
    return $text;
}
[download]

    macrodef : '#define' /[a-z]\w*/i
        '(' <leftop: /[a-z]+/i ',' /[a-z]+/i> ')'  /.*/
            { $::macro{$item[2]} = [ $item[-1], $item[4] ]; }
         | '#define' /[a-z]\w*/i  /.*/
            { $::macro{$item[2]} = [ $item[-1] ]; }
[download]

#define        add(a,b,c)        (a+b+c)
#define        mult(d,e)        (d*e)
#define        pi            (3.1415)
main( ) {
    add(1,2,3);
    mult(4,5);
    float p = pi;
}
[download]