function_method: 'function' identifier paren_statement brace
                 { $return = $item[2]; }
[download]

function_method: 'function' identifier paren_statement brace
                 { $return = \@item; }
[download]

The power of writting Parsers like this is that you can build your data structures as you parse the file. By flattening out the results from your parser, you're throwing away a lot of the functionality you could have. Considering your goal, you might want to make all of your handlers just return \@item, that should cause your parser to build "a complete parse tree" of your javascript files. Then you can walk it and do whatever you want with it.

Update: Don't try \@item. On a whim I installed Parse::RecDescent to see if I was right, and ran into a deep recursion problem. Evidently @item is a more complicated array then I thought (i figured it was just the individual tokens ... now i'm curios to go read the docs and understand how this module works).
Bottom line: dmmiller2k is probably right, your grammer seems very specific in some ways and very general in others -- you should try to make it more specific about the things you care about, and more general about the things you don't.

I'm not sure how to help you with your Parse::RecDescent problem (I've never used it), but here is a pure-regex solution that I whipped up (half to help, half for fun) for your original problem:

my $data = join('',<DATA>);
my $quoted_string =
qr/
    "
    (?:
        (?: [^"]* )
        |
        (?: (?<= \\ ) " )
    )*
    "
/x;
my $balenced_brackets =
qr/
    \{
    (?:
        (?> [^{}"] *)
        |
        (??{$quoted_string})
        |
        (??{$balenced_brackets})
    )*
    \}
/x;
my $function_header = qr/ function \s+ \w+ \s* \( [^)]* \) \s* /x;

my @matches = $data =~ /($function_header $balenced_brackets)/gx;
print join("\n\n",@matches);
[download]

It worked with the sample code that you provided, but I have a feeling it will blow up when presented when it encounters something whacky (an unclosed brace, a brace inside quotes, etc). Consider it a preliminary solution :)

Update I added a bit of robustness to consider the case of the unclosed brace, but it now needs  re 'eval'. I also added a bit of explanation... Its still going to blow up on a brace inside quotes, however...

Update: Update: With some better structure, it can now handle brackets in quotes with no problem.

Just looking at your grammar, it seems to me that statement and function_method are infinitely recursive with respect to brace_statement, paren_statement and bracket_statement (which themselves are defined in terms of statement).

Since you are not trying to actually parse the contents of functions, but simply return the contents wholesale (in order to associate it with the function name in a hash), why not make it simple for yourself?

For each function, there are two things you need: the contents of the parentheses and those of the curly braces, either of which may be nonexistent (empty). In order to recognize the end of a particular set of parens (or braces), you need to be able to identify any embedded matching pairs (or parens, braces or square brackets), which is why you should identify symbols, quoted strings, etc. as well.

Okay, you have these basic building blocks. Now you need to combine them in ways in which they might actually appear within programs without overcomplicating your task.

For instance, I think in your grammar, the statement rule is over-used (incorrectly). I'm uncertain, but I don't think the parameter list of a function can consist of arbitrarily complex statements; likewise, for the contents of expressions within square brackets. Perhaps you should describe expression in a rule. Then, your definition of statement could be comprised of several different kinds of expressions (e.g., assignment).

It would be interesting to know where you are taking this; are you building a Javascript debugger in Perl?

dmm

$_ = join'',<DATA>;
(my $re=$_) =~ s/(({)|(})|.)/${['(','']}[!$2]\Q$1\E${[')','']}[!$3]/gs
+;
$re = join'|',map quotemeta,eval{/$re/};
warn $@ if $@ =~ /unmatched/;
print join "\n",/(\bfunction\b[^()]*\([^()]*\)\s*(?:$re))/g,'';


__DATA__

 function functStart () {};
 var g1, g2 = __QUOTE__; var g3 = 10000000;
 if (g1) { var XXXXXXX = __QUOTE__; }
 if ( ! defaultCookieCrumbNav ) { cookieCrumbNavBarHTML = __QUOTE__ ; 
+} 
 else { function funct1 () { }; var xxx = __QUOTE__ ; }
 if (true == false) { alert(var1); }
 if (1) { if (1) { function funct2 (X) { x = funct3 (1,2); }; function
+ funct3 () { alert(1); } } }

 function funct4 (a,b) { alert (1,2,3,4); return (a + b); }
 function funct5 () { var aaa = 1; }

 var g4; var g7 = __QUOTE__;

 function funct6 () { var b = __REGEX__; c = __REGEX__; if (test333())
+ { return true; } }
 function funct7 () { var a = 111; }
 alert ( 3 );
 funct5 ( funct6 ( funct2 () ) );
 function functEnd () {}
[download]