use strict;
use warnings;

use Parse::RecDescent;

use vars qw(
   %item @item $return
   @pair @store
);

my $data   = do {local $/;<DATA>};
my $parser = Parse::RecDescent->new($data);

my @code = (
   q/concat(int2string(counter, 1),result)/,
   q/concat("hello","world")/,
   q/concat(foo,bar)/,
);

$parser->startrule($_) for @code;

for (0..$#code) {
   print "$code[$_]\n";
   print "\targ 1 => ", $store[$_][0], "\n";
   print "\targ 2 => ", $store[$_][1], "\n";
}

__DATA__
startrule: function

function: label open_p arg comma arg close_p

arg: nested_function | quoted_literal | literal

nested_function: label open_p arg comma arg close_p
{ 
   push @main::pair, join('', @item[1..$#item]);
   pop @main::store;
   if (@main::pair == 2) {
      push @main::store,[@main::pair];
      @main::pair = ();
   }

   $return = join('', @item[1..$#item]);
   print STDERR "nested function: $return\n";
}

quoted_literal: quote /[^"]+/ quote
{
   push @main::pair, $item[2];
   if (@main::pair == 2) {
      push @main::store,[@main::pair];
      @main::pair = ();
   }

   print STDERR "quoted literal: $item[2]\n";
   $return = $item[2];
}

literal: /\w+/i
{
   push @main::pair, $item[1];
   if (@main::pair == 2) {
      push @main::store,[@main::pair];
      @main::pair = ();
   }

   print STDERR "literal: $item[1]\n";
   $return = $item[1];
}

label: /[a-zA-Z]\w*/

open_p: /\(/

close_p: /\)/

comma: /,/

quote: /"/
[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)

  concat(int2string(counter,1),result)
[download]

Can you say a bit more about the types of expressions that might occur as arguments to concat()? If there's a limited set, you can special-case them with one regular expression per combination.

Given the samples supplied, this does the trick. If your expressions can contain spaces, be split across lines or contain nested concats, then it will need further work.

#! perl -slw
use strict;

my $re_term   = qr[[^,)]+?];
my $re_func   = qr[\w+\($re_term,$re_term\)];
my $re_concat = qr[concat\((?:($re_func),($re_term|$re_func))\)];

while(<DATA>) {
    s[^$re_concat$][$1 & $2];
    print;
}

__DATA__
concat(int2str(count,1),result)
concat(bit2str(count,'10'B),result)
concat(int2str(count,1),bit2str(count,'10'B))
[download]

Gives

c:\test>249976
int2str(count,1) & result

bit2str(count,'10'B) & result

int2str(count,1) & bit2str(count,'10'B)
[download]

Sounds like a great job for Parse::RecDescent, except that you'll still need to give us access to the spec for "an earlier version of the test language". We specifically would need to know string-quoting-thingies that can hide a comma (like Perl's "" or '' or q()) and the nesting-thingies that can hide a comma recursively (like your concat function).

Until you provide that spec, any response here is pure speculation.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Mr. Muskrat thinks that you want JavaJunkies.org instead. ;-)

Or maybe this is JavaScript. It'd help to know what language you're expecting us to read.