Printing and concatenation with Parse::RecDescent

Question

I am testing the grammar from P::RD tutorial in order to develop my own grammar. I haven't figured out how to print a string declaration and append '$' to the front of it. For example "STRING sDir" should print out "$sDir". It is simple enough to just do a $string =~ s/STRING /\$/, but what about the case where there is assignment? eg. "STRING sDir = aNewDir".

Here is the grammar

OP       : m([-+*/%])      # Mathematical operators
INTEGER  : /[-+]?\d+/      # Signed integers
VARIABLE : /\w[a-z0-9_]*/i # Variable
STRING   : /STRING/i       # String declaration

expression : INTEGER OP expression
          { return main::expression(@item) }
          | VARIABLE OP expression
          { return main::expression(@item) }
          | INTEGER
          | VARIABLE
          { return $main::VARIABLE{$item{VARIABLE}} }

I am starting to think that regex will suffice, but want to know how to create a complex one for comma separated declarations such as "STRING, foo, bar" -> $foo; $bar;

Answer 1

I'm not completely following your question. You've only defined STRING as a token, you haven't given it any semantic actions. It's the rules below--which appear in the tutorial--which tell us what to do with the tokens.

print_instruction : /print/i expression
                  { print $item{expression}."\n" }
assign_instruction : VARIABLE "=" expression
                   { $main::VARIABLE{$item{VARIABLE}} = $item{expression} }

instruction : print_instruction
            | assign_instruction

startrule: instruction(s /;/)

• The bottom rule says that we're looking for one or more instructions, separated by a semi-colon.
• The instruction rule says an instruction is either a assignment or a print instruction.
• The print instruction takes the word print and an expression and prints the result of the expression.
• The assignment instruction takes a variable, literal '=', and an expression and assigns the result of the expression to the name in the %main::VARIABLE hash.
• expression has two actions, one for a compound expression which calls &main::expression and one for variables which retrieves the named value from the %main::VARIABLE hash.

You have just created a token type, but no rule depends on that token. Further more, I get a gist of what you want to do, but not enough that I can give guidance on creating semantic actions for what you want to do.

Not knowing where exactly you wanted to put the instruction, I just added the following case to expression:

         | 'STRING' /[\p{Alpha}_]\w*/
         { return '$' . $item[2] }

It means it looks for the exact string 'STRING' followed by an identifier sequence. So you can use it like so:

print STRING vvv

And get $vvv.

---

EDIT:

If I understand your comment correctly, I added a string_instruction rule to instruction and defined it as:

string_instruction : 'STRING' /[\p{Alpha}_]\w*/
                   { print "\$$item[2]"; }

And I added to the examples:

print "STRING v\n";  $parser->startrule( "STRING v" );

which prints $v.