MadMongers

mcholste wrote:

Wow, a lot to go through here.  Yes, Jon, there was a typo in the example with the extra closing paren.  I think that Marpa and a full grammar may be a bit overkill, but then again, maybe not.  I'm trying to get Chris's continued match to work in a demo but am thus far unsuccessful.

On Tue, Dec 18, 2012 at 9:08 PM, <chris@chrisdolan.net> wrote:

chrisdolan wrote:

If you want to parse with regexps, then a good pattern to consider is:

  m/ \G ... /c

That's the continued match, which lets you mix a collection of regexp snippets with code to do the stuff that doesn't come naturally to regexps. I used that pattern extensively in CAM::PDF which needed to support arbitrarily deep recursive data structures.

Chris

On Dec 18, 2012, at 6:39 PM, <afbach@gmail.com> <afbach@gmail.com> wrote:

afbach wrote:

On Tue, Dec 18, 2012 at 4:23 PM, <mcholste@gmail.com> wrote:

It's parsing user input, so the spacing and number of params are completely variable.  From what I can tell (didn't dig into any man pages), "?0" will refer to the other paren in the paren pairs when matching, but that's more of a guess.

Cool!  I did not know about ?0 etc - but my reading is a bit different. But 
qr/([^\(]+)    \(?  ( [^()]*+ | (?0) )  \)? $  /x;

Nope. "[^()]*+" seems a syntax error (to me) yet I see [^()]++ in perlre [1] and while i sort of get the first example there ... and I can't see why you're using "\(?" - thought you'd need one literal paren (not zero or one) but I can't get it to work, though I get:
$ perl -le 'my $re = qr/([^\(]+)    \(?  ( [^()]*+ | (?0) )  \)? $  /x; $str = "funcOne(funcTwo | funcThree(a,b),c,d)"; if (@m = $str =~ $re){ print "y: " . join("#", @m); }'
y: funcOne#funcTwo | funcThree(a,b),c,d)

Sorry, no help.

a

[1]
 perldoc perlre says:
  "(?PARNO)" "(?−PARNO)" "(?+PARNO)" "(?R)" "(?0)"
                 Similar to "(??{ code })" except it does not involve
                 compiling any code, instead it treats the contents of a
                 capture buffer as an independent pattern that must match at
                 the current position.  Capture buffers contained by the
                 pattern will have the value as determined by the outermost
                 recursion.

                 PARNO is a sequence of digits (not starting with 0) whose
                 value reflects the paren‐number of the capture buffer to
                 recurse to. "(?R)" recurses to the beginning of the whole
                 pattern. "(?0)" is an alternate syntax for "(?R)". If PARNO
                 is preceded by a plus or minus sign then it is assumed to be
                 relative, with negative numbers indicating preceding capture
                 buffers and positive ones following. Thus "(?−1)" refers to
                 the most recently declared buffer, and "(?+1)" indicates the
                 next buffer to be declared.  Note that the counting for
                 relative recursion differs from that of relative
                 backreferences, in that with recursion unclosed buffers are
                 included.

                 The following pattern matches a function foo() which may
                 contain balanced parentheses as the argument.

                   $re = qr{ (                    # paren group 1 (full function)
                               foo
                               (                  # paren group 2 (parens)
                                 \(
                                   (              # paren group 3 (contents of parens)
                                   (?:
                                    (?> [^()]+ )  # Non−parens without backtracking
                                   |
                                    (?2)          # Recurse to start of paren group 2
                                   )*
                                   )
                                 \)
                               )
                             )
                           }x;

                 If the pattern was used as follows

                     'foo(bar(baz)+baz(bop))'=~/$re/
                         and print "\$1 = $1\n",
                                   "\$2 = $2\n",
                                   "\$3 = $3\n";


                 the output produced should be the following:

                     $1 = foo(bar(baz)+baz(bop))
                     $2 = (bar(baz)+baz(bop))
                     $3 = bar(baz)+baz(bop)


             If there is no corresponding capture buffer defined, then it
                 is a fatal error.  Recursing deeper than 50 times without
                 consuming any input string will also result in a fatal error.
                 The maximum depth is compiled into perl, so changing it
                 requires a custom build.

                 The following shows how using negative indexing can make it
                 easier to embed recursive patterns inside of a "qr//"
                 construct for later use:

                     my $parens = qr/(\((?:[^()]++|(?−1))*+\))/;
                     if (/foo $parens \s+ + \s+ bar $parens/x) {
                        # do something here...
                     }

                 Note that this pattern does not behave the same way as the
                 equivalent PCRE or Python construct of the same form. In Perl
                 you can backtrack into a recursed group, in PCRE and Python
                 the recursed into group is treated as atomic. Also, modifiers
                 are resolved at compile time, so constructs like (?i:(?1)) or
                 (?:(?i)(?1)) do not affect how the sub‐pattern will be
                 processed.








--

a

Andy Bach,
afbach@gmail.com
608 658-1890 cell
608 261-5738 wk

View Online

Madison Area Perl Mongers - MadMongers
http://www.madmongers.org

View Online

Madison Area Perl Mongers - MadMongers
http://www.madmongers.org

View Online

Madison Area Perl Mongers - MadMongers
http://www.madmongers.org