Transmorgify/ConditionalsDebug.pm untested

filter: Statementstmt 0.0% 0 / 4564 Branchbran 0.0% 0 / 2180 Conditioncond 0.0% 0 / 789 MC/DCmcdc 0.0% 0 / 490 Subroutinesub 0.0% 0 / 137 Podpod 0.0% 0 / 43 totaltotal 0.0% 0 / 8203 CC 1091 SCAR 72.8
CC
1091
Cov
0%
Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::term
4422.0
Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::constant
3540.0
Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr6
2862.0
CRAP 1456.2
1 package HTML::Transmorgify::ConditionalsDebug;
2 use Parse::RecDescent;
3  
4 { my $ERRORS;
5  
6  
7 package Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug;
8 use strict;
9 use vars qw($skip $AUTOLOAD );
10 @Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::ISA = ();
11 $skip = '\s*';
12  
13 use Carp qw(confess);
14  
15 our @rtmp;
16  
17 $::RD_TRACE = 1; sub db
18 {
19 require Data::Dumper;
20 print Data::Dumper::Dumper((caller(1))[3], @_);
21 }
22  
23 my $allowed_funcs = \%HTML::Transmorgify::allowed_functions;
24 sub run
25 {
26 return $_[0] unless ref $_[0];
27 return $_[0]->();
28 }
29  
30 sub binary
31 {
32 db(@_);
33 my ($t1, $op, $t2) = @_;
34 confess if ref $op;
35 my $eval = "sub { \$_[0] $op \$_[1] }";
36 $allowed_funcs->{$op} ||= eval $eval or die "eval $eval: $@";
37 return sub {
38 $allowed_funcs->{$op}->(run($t1), run($t2));
39 };
40 }
41  
42 sub unary
43 {
44 db(@_);
45 my ($op, $t1) = @_;
46 confess if ref $op;
47 my $eval = "sub { $op \$_[0] }";
48 $allowed_funcs->{$op} ||= eval $eval or die "eval $eval: $@";
49 return sub {
50 $allowed_funcs->{$op}->(run($t1));
51 };
52 }
53
54 sub assoc
55 {
56 db(@_);
57 my ($r, @ops) = @_;
58 while (my ($op, $term) = splice(@ops, 0, 2)) {
59 confess if ref $op;
60 my $eval = "sub { \$_[0] $op \$_[1] }";
61 $allowed_funcs->{$op} ||= eval $eval or die "eval $eval: $@";
62 my $left = $r;
63 $r = sub {
64 $allowed_funcs->{$op}->(run($left), run($term));
65 };
66 }
67 return $r;
68 }
69  
70 sub left
71 {
72 db(@_);
73 assoc(@{$_[1]});
74 }
75  
76 sub right
77 {
78 db(@_);
79 assoc(reverse @{$_[1]});
80 }
81  
82 sub nonassoc
83 {
84 db(@_);
85 die if @{$_[1]} > 3;
86 left(@_);
87 }
88 ;
89  
90  
91 {
92 local $SIG{__WARN__} = sub {0};
93 # PRETEND TO BE IN Parse::RecDescent NAMESPACE
94 *Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::AUTOLOAD = sub
95 {
96 no strict 'refs';
97 $AUTOLOAD =~ s/^Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug/Parse::RecDescent/;
98 goto &{$AUTOLOAD};
99 }
100 }
101  
102 push @Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::ISA, 'Parse::RecDescent';
103 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
104 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr2
105 {
106 my $thisparser = $_[0];
107 use vars q{$tracelevel};
108 local $tracelevel = ($tracelevel||0)+1;
109 $ERRORS = 0;
110 my $thisrule = $thisparser->{"rules"}{"expr2"};
111
112 Parse::RecDescent::_trace(q{Trying rule: [expr2]},
113 Parse::RecDescent::_tracefirst($_[1]),
114 q{expr2},
115 $tracelevel)
116 if defined $::RD_TRACE;
117  
118
119 my $err_at = @{$thisparser->{errors}};
120  
121 my $score;
122 my $score_return;
123 my $_tok;
124 my $return = undef;
125 my $_matched=0;
126 my $commit=0;
127 my @item = ();
128 my %item = ();
129 my $repeating = defined($_[2]) && $_[2];
130 my $_noactions = defined($_[3]) && $_[3];
131 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
132 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
133 my $text;
134 my $lastsep="";
135 my $current_match;
136 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr5 expr2op expr5>});
137 $expectation->at($_[1]);
138
139 my $thisline;
140 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
141  
142
143  
144 while (!$_matched && !$commit)
145 {
146
147 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr5 expr2op expr5>]},
148 Parse::RecDescent::_tracefirst($_[1]),
149 q{expr2},
150 $tracelevel)
151 if defined $::RD_TRACE;
152 my $thisprod = $thisrule->{"prods"}[0];
153 $text = $_[1];
154 my $_savetext;
155 @item = (q{expr2});
156 %item = (__RULE__ => q{expr2});
157 my $repcount = 0;
158  
159  
160 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr5 expr2op expr5>]},
161 Parse::RecDescent::_tracefirst($text),
162 q{expr2},
163 $tracelevel)
164 if defined $::RD_TRACE;
165 $expectation->is(q{})->at($text);
166  
167 $_tok = undef;
168 OPLOOP: while (1)
169 {
170 $repcount = 0;
171 my @item;
172
173 # MATCH LEFTARG
174
175 Parse::RecDescent::_trace(q{Trying subrule: [expr5]},
176 Parse::RecDescent::_tracefirst($text),
177 q{expr2},
178 $tracelevel)
179 if defined $::RD_TRACE;
180 if (1) { no strict qw{refs};
181 $expectation->is(q{expr5})->at($text);
182 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr5($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
183 {
184
185 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr5]>>},
186 Parse::RecDescent::_tracefirst($text),
187 q{expr2},
188 $tracelevel)
189 if defined $::RD_TRACE;
190 $expectation->failed();
191 last;
192 }
193 Parse::RecDescent::_trace(q{>>Matched subrule: [expr5]<< (return value: [}
194 . $_tok . q{]},
195
196 Parse::RecDescent::_tracefirst($text),
197 q{expr2},
198 $tracelevel)
199 if defined $::RD_TRACE;
200 $item{q{expr5}} = $_tok;
201 push @item, $_tok;
202
203 }
204  
205  
206 $repcount++;
207  
208 my $savetext = $text;
209 my $backtrack;
210  
211 # MATCH (OP RIGHTARG)(s)
212 while ($repcount < 100000000)
213 {
214 $backtrack = 0;
215
216 Parse::RecDescent::_trace(q{Trying subrule: [expr2op]},
217 Parse::RecDescent::_tracefirst($text),
218 q{expr2},
219 $tracelevel)
220 if defined $::RD_TRACE;
221 if (1) { no strict qw{refs};
222 $expectation->is(q{expr2op})->at($text);
223 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr2op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
224 {
225
226 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr2op]>>},
227 Parse::RecDescent::_tracefirst($text),
228 q{expr2},
229 $tracelevel)
230 if defined $::RD_TRACE;
231 $expectation->failed();
232 last;
233 }
234 Parse::RecDescent::_trace(q{>>Matched subrule: [expr2op]<< (return value: [}
235 . $_tok . q{]},
236
237 Parse::RecDescent::_tracefirst($text),
238 q{expr2},
239 $tracelevel)
240 if defined $::RD_TRACE;
241 $item{q{expr2op}} = $_tok;
242 push @item, $_tok;
243
244 }
245  
246 $backtrack=1;
247
248
249 Parse::RecDescent::_trace(q{Trying subrule: [expr5]},
250 Parse::RecDescent::_tracefirst($text),
251 q{expr2},
252 $tracelevel)
253 if defined $::RD_TRACE;
254 if (1) { no strict qw{refs};
255 $expectation->is(q{expr5})->at($text);
256 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr5($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
257 {
258
259 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr5]>>},
260 Parse::RecDescent::_tracefirst($text),
261 q{expr2},
262 $tracelevel)
263 if defined $::RD_TRACE;
264 $expectation->failed();
265 last;
266 }
267 Parse::RecDescent::_trace(q{>>Matched subrule: [expr5]<< (return value: [}
268 . $_tok . q{]},
269
270 Parse::RecDescent::_tracefirst($text),
271 q{expr2},
272 $tracelevel)
273 if defined $::RD_TRACE;
274 $item{q{expr5}} = $_tok;
275 push @item, $_tok;
276
277 }
278  
279 $savetext = $text;
280 $repcount++;
281 }
282 $text = $savetext;
283 pop @item if $backtrack;
284  
285 unless (@item) { undef $_tok; last }
286 $_tok = [ @item ];
287 last;
288 }
289  
290 unless ($repcount>=1)
291 {
292 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr5 expr2op expr5>]>>},
293 Parse::RecDescent::_tracefirst($text),
294 q{expr2},
295 $tracelevel)
296 if defined $::RD_TRACE;
297 $expectation->failed();
298 last;
299 }
300 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr5 expr2op expr5>]<< (return value: [}
301 . qq{@{$_tok||[]}} . q{]},
302 Parse::RecDescent::_tracefirst($text),
303 q{expr2},
304 $tracelevel)
305 if defined $::RD_TRACE;
306  
307 push @item, $item{__DIRECTIVE1__}=$_tok||[];
308  
309  
310 Parse::RecDescent::_trace(q{Trying action},
311 Parse::RecDescent::_tracefirst($text),
312 q{expr2},
313 $tracelevel)
314 if defined $::RD_TRACE;
315
316  
317 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
318 unless (defined $_tok)
319 {
320 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
321 if defined $::RD_TRACE;
322 last;
323 }
324 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
325 . $_tok . q{])},
326 Parse::RecDescent::_tracefirst($text))
327 if defined $::RD_TRACE;
328 push @item, $_tok;
329 $item{__ACTION1__}=$_tok;
330
331  
332  
333 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr5 expr2op expr5>]<<},
334 Parse::RecDescent::_tracefirst($text),
335 q{expr2},
336 $tracelevel)
337 if defined $::RD_TRACE;
338 $_matched = 1;
339 last;
340 }
341  
342  
343 unless ( $_matched || defined($score) )
344 {
345
346  
347 $_[1] = $text; # NOT SURE THIS IS NEEDED
348 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
349 Parse::RecDescent::_tracefirst($_[1]),
350 q{expr2},
351 $tracelevel)
352 if defined $::RD_TRACE;
353 return undef;
354 }
355 if (!defined($return) && defined($score))
356 {
357 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
358 q{expr2},
359 $tracelevel)
360 if defined $::RD_TRACE;
361 $return = $score_return;
362 }
363 splice @{$thisparser->{errors}}, $err_at;
364 $return = $item[$#item] unless defined $return;
365 if (defined $::RD_TRACE)
366 {
367 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
368 $return . q{])}, "",
369 q{expr2},
370 $tracelevel);
371 Parse::RecDescent::_trace(q{(consumed: [} .
372 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
373 Parse::RecDescent::_tracefirst($text),
374 , q{expr2},
375 $tracelevel)
376 }
377 $_[1] = $text;
378 return $return;
379 }
380  
381 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
382 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15op
383 {
384 my $thisparser = $_[0];
385 use vars q{$tracelevel};
386 local $tracelevel = ($tracelevel||0)+1;
387 $ERRORS = 0;
388 my $thisrule = $thisparser->{"rules"}{"expr15op"};
389
390 Parse::RecDescent::_trace(q{Trying rule: [expr15op]},
391 Parse::RecDescent::_tracefirst($_[1]),
392 q{expr15op},
393 $tracelevel)
394 if defined $::RD_TRACE;
395  
396
397 my $err_at = @{$thisparser->{errors}};
398  
399 my $score;
400 my $score_return;
401 my $_tok;
402 my $return = undef;
403 my $_matched=0;
404 my $commit=0;
405 my @item = ();
406 my %item = ();
407 my $repeating = defined($_[2]) && $_[2];
408 my $_noactions = defined($_[3]) && $_[3];
409 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
410 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
411 my $text;
412 my $lastsep="";
413 my $current_match;
414 my $expectation = new Parse::RecDescent::Expectation(q{/(\\*|\\/|%|x)/});
415 $expectation->at($_[1]);
416
417 my $thisline;
418 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
419  
420
421  
422 while (!$_matched && !$commit)
423 {
424
425 Parse::RecDescent::_trace(q{Trying production: [/(\\*|\\/|%|x)/]},
426 Parse::RecDescent::_tracefirst($_[1]),
427 q{expr15op},
428 $tracelevel)
429 if defined $::RD_TRACE;
430 my $thisprod = $thisrule->{"prods"}[0];
431 $text = $_[1];
432 my $_savetext;
433 @item = (q{expr15op});
434 %item = (__RULE__ => q{expr15op});
435 my $repcount = 0;
436  
437  
438 Parse::RecDescent::_trace(q{Trying terminal: [/(\\*|\\/|%|x)/]}, Parse::RecDescent::_tracefirst($text),
439 q{expr15op},
440 $tracelevel)
441 if defined $::RD_TRACE;
442 $lastsep = "";
443 $expectation->is(q{})->at($text);
444
445  
446 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(\*|\/|%|x))/)
447 {
448
449 $expectation->failed();
450 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
451 Parse::RecDescent::_tracefirst($text))
452 if defined $::RD_TRACE;
453  
454 last;
455 }
456 $current_match = substr($text, $-[0], $+[0] - $-[0]);
457 substr($text,0,length($current_match),q{});
458 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
459 . $current_match . q{])},
460 Parse::RecDescent::_tracefirst($text))
461 if defined $::RD_TRACE;
462 push @item, $item{__PATTERN1__}=$current_match;
463
464  
465 Parse::RecDescent::_trace(q{Trying action},
466 Parse::RecDescent::_tracefirst($text),
467 q{expr15op},
468 $tracelevel)
469 if defined $::RD_TRACE;
470
471  
472 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
473 unless (defined $_tok)
474 {
475 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
476 if defined $::RD_TRACE;
477 last;
478 }
479 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
480 . $_tok . q{])},
481 Parse::RecDescent::_tracefirst($text))
482 if defined $::RD_TRACE;
483 push @item, $_tok;
484 $item{__ACTION1__}=$_tok;
485
486  
487  
488 Parse::RecDescent::_trace(q{>>Matched production: [/(\\*|\\/|%|x)/]<<},
489 Parse::RecDescent::_tracefirst($text),
490 q{expr15op},
491 $tracelevel)
492 if defined $::RD_TRACE;
493 $_matched = 1;
494 last;
495 }
496  
497  
498 unless ( $_matched || defined($score) )
499 {
500
501  
502 $_[1] = $text; # NOT SURE THIS IS NEEDED
503 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
504 Parse::RecDescent::_tracefirst($_[1]),
505 q{expr15op},
506 $tracelevel)
507 if defined $::RD_TRACE;
508 return undef;
509 }
510 if (!defined($return) && defined($score))
511 {
512 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
513 q{expr15op},
514 $tracelevel)
515 if defined $::RD_TRACE;
516 $return = $score_return;
517 }
518 splice @{$thisparser->{errors}}, $err_at;
519 $return = $item[$#item] unless defined $return;
520 if (defined $::RD_TRACE)
521 {
522 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
523 $return . q{])}, "",
524 q{expr15op},
525 $tracelevel);
526 Parse::RecDescent::_trace(q{(consumed: [} .
527 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
528 Parse::RecDescent::_tracefirst($text),
529 , q{expr15op},
530 $tracelevel)
531 }
532 $_[1] = $text;
533 return $return;
534 }
535  
536 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
537 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15a
538 {
539 my $thisparser = $_[0];
540 use vars q{$tracelevel};
541 local $tracelevel = ($tracelevel||0)+1;
542 $ERRORS = 0;
543 my $thisrule = $thisparser->{"rules"}{"expr15a"};
544
545 Parse::RecDescent::_trace(q{Trying rule: [expr15a]},
546 Parse::RecDescent::_tracefirst($_[1]),
547 q{expr15a},
548 $tracelevel)
549 if defined $::RD_TRACE;
550  
551
552 my $err_at = @{$thisparser->{errors}};
553  
554 my $score;
555 my $score_return;
556 my $_tok;
557 my $return = undef;
558 my $_matched=0;
559 my $commit=0;
560 my @item = ();
561 my %item = ();
562 my $repeating = defined($_[2]) && $_[2];
563 my $_noactions = defined($_[3]) && $_[3];
564 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
565 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
566 my $text;
567 my $lastsep="";
568 my $current_match;
569 my $expectation = new Parse::RecDescent::Expectation(q{'-', or expr16});
570 $expectation->at($_[1]);
571
572 my $thisline;
573 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
574  
575
576  
577 while (!$_matched && !$commit)
578 {
579
580 Parse::RecDescent::_trace(q{Trying production: ['-' expr16]},
581 Parse::RecDescent::_tracefirst($_[1]),
582 q{expr15a},
583 $tracelevel)
584 if defined $::RD_TRACE;
585 my $thisprod = $thisrule->{"prods"}[0];
586 $text = $_[1];
587 my $_savetext;
588 @item = (q{expr15a});
589 %item = (__RULE__ => q{expr15a});
590 my $repcount = 0;
591  
592  
593 Parse::RecDescent::_trace(q{Trying terminal: ['-']},
594 Parse::RecDescent::_tracefirst($text),
595 q{expr15a},
596 $tracelevel)
597 if defined $::RD_TRACE;
598 $lastsep = "";
599 $expectation->is(q{})->at($text);
600
601  
602 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\-/)
603 {
604
605 $expectation->failed();
606 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
607 Parse::RecDescent::_tracefirst($text))
608 if defined $::RD_TRACE;
609 last;
610 }
611 $current_match = substr($text, $-[0], $+[0] - $-[0]);
612 substr($text,0,length($current_match),q{});
613 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
614 . $current_match . q{])},
615 Parse::RecDescent::_tracefirst($text))
616 if defined $::RD_TRACE;
617 push @item, $item{__STRING1__}=$current_match;
618
619  
620 Parse::RecDescent::_trace(q{Trying subrule: [expr16]},
621 Parse::RecDescent::_tracefirst($text),
622 q{expr15a},
623 $tracelevel)
624 if defined $::RD_TRACE;
625 if (1) { no strict qw{refs};
626 $expectation->is(q{expr16})->at($text);
627 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr16($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
628 {
629
630 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr16]>>},
631 Parse::RecDescent::_tracefirst($text),
632 q{expr15a},
633 $tracelevel)
634 if defined $::RD_TRACE;
635 $expectation->failed();
636 last;
637 }
638 Parse::RecDescent::_trace(q{>>Matched subrule: [expr16]<< (return value: [}
639 . $_tok . q{]},
640
641 Parse::RecDescent::_tracefirst($text),
642 q{expr15a},
643 $tracelevel)
644 if defined $::RD_TRACE;
645 $item{q{expr16}} = $_tok;
646 push @item, $_tok;
647
648 }
649  
650 Parse::RecDescent::_trace(q{Trying action},
651 Parse::RecDescent::_tracefirst($text),
652 q{expr15a},
653 $tracelevel)
654 if defined $::RD_TRACE;
655
656  
657 $_tok = ($_noactions) ? 0 : do { db(@item); binary(0, '-', $item[1]) };
658 unless (defined $_tok)
659 {
660 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
661 if defined $::RD_TRACE;
662 last;
663 }
664 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
665 . $_tok . q{])},
666 Parse::RecDescent::_tracefirst($text))
667 if defined $::RD_TRACE;
668 push @item, $_tok;
669 $item{__ACTION1__}=$_tok;
670
671  
672  
673 Parse::RecDescent::_trace(q{>>Matched production: ['-' expr16]<<},
674 Parse::RecDescent::_tracefirst($text),
675 q{expr15a},
676 $tracelevel)
677 if defined $::RD_TRACE;
678 $_matched = 1;
679 last;
680 }
681  
682  
683 while (!$_matched && !$commit)
684 {
685
686 Parse::RecDescent::_trace(q{Trying production: [expr16]},
687 Parse::RecDescent::_tracefirst($_[1]),
688 q{expr15a},
689 $tracelevel)
690 if defined $::RD_TRACE;
691 my $thisprod = $thisrule->{"prods"}[1];
692 $text = $_[1];
693 my $_savetext;
694 @item = (q{expr15a});
695 %item = (__RULE__ => q{expr15a});
696 my $repcount = 0;
697  
698  
699 Parse::RecDescent::_trace(q{Trying subrule: [expr16]},
700 Parse::RecDescent::_tracefirst($text),
701 q{expr15a},
702 $tracelevel)
703 if defined $::RD_TRACE;
704 if (1) { no strict qw{refs};
705 $expectation->is(q{})->at($text);
706 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr16($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
707 {
708
709 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr16]>>},
710 Parse::RecDescent::_tracefirst($text),
711 q{expr15a},
712 $tracelevel)
713 if defined $::RD_TRACE;
714 $expectation->failed();
715 last;
716 }
717 Parse::RecDescent::_trace(q{>>Matched subrule: [expr16]<< (return value: [}
718 . $_tok . q{]},
719
720 Parse::RecDescent::_tracefirst($text),
721 q{expr15a},
722 $tracelevel)
723 if defined $::RD_TRACE;
724 $item{q{expr16}} = $_tok;
725 push @item, $_tok;
726
727 }
728  
729 Parse::RecDescent::_trace(q{Trying action},
730 Parse::RecDescent::_tracefirst($text),
731 q{expr15a},
732 $tracelevel)
733 if defined $::RD_TRACE;
734
735  
736 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
737 unless (defined $_tok)
738 {
739 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
740 if defined $::RD_TRACE;
741 last;
742 }
743 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
744 . $_tok . q{])},
745 Parse::RecDescent::_tracefirst($text))
746 if defined $::RD_TRACE;
747 push @item, $_tok;
748 $item{__ACTION1__}=$_tok;
749
750  
751  
752 Parse::RecDescent::_trace(q{>>Matched production: [expr16]<<},
753 Parse::RecDescent::_tracefirst($text),
754 q{expr15a},
755 $tracelevel)
756 if defined $::RD_TRACE;
757 $_matched = 1;
758 last;
759 }
760  
761  
762 unless ( $_matched || defined($score) )
763 {
764
765  
766 $_[1] = $text; # NOT SURE THIS IS NEEDED
767 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
768 Parse::RecDescent::_tracefirst($_[1]),
769 q{expr15a},
770 $tracelevel)
771 if defined $::RD_TRACE;
772 return undef;
773 }
774 if (!defined($return) && defined($score))
775 {
776 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
777 q{expr15a},
778 $tracelevel)
779 if defined $::RD_TRACE;
780 $return = $score_return;
781 }
782 splice @{$thisparser->{errors}}, $err_at;
783 $return = $item[$#item] unless defined $return;
784 if (defined $::RD_TRACE)
785 {
786 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
787 $return . q{])}, "",
788 q{expr15a},
789 $tracelevel);
790 Parse::RecDescent::_trace(q{(consumed: [} .
791 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
792 Parse::RecDescent::_tracefirst($text),
793 , q{expr15a},
794 $tracelevel)
795 }
796 $_[1] = $text;
797 return $return;
798 }
799  
800 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
801 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr10
802 {
803 my $thisparser = $_[0];
804 use vars q{$tracelevel};
805 local $tracelevel = ($tracelevel||0)+1;
806 $ERRORS = 0;
807 my $thisrule = $thisparser->{"rules"}{"expr10"};
808
809 Parse::RecDescent::_trace(q{Trying rule: [expr10]},
810 Parse::RecDescent::_tracefirst($_[1]),
811 q{expr10},
812 $tracelevel)
813 if defined $::RD_TRACE;
814  
815
816 my $err_at = @{$thisparser->{errors}};
817  
818 my $score;
819 my $score_return;
820 my $_tok;
821 my $return = undef;
822 my $_matched=0;
823 my $commit=0;
824 my @item = ();
825 my %item = ();
826 my $repeating = defined($_[2]) && $_[2];
827 my $_noactions = defined($_[3]) && $_[3];
828 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
829 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
830 my $text;
831 my $lastsep="";
832 my $current_match;
833 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr11 expr10op expr11>});
834 $expectation->at($_[1]);
835
836 my $thisline;
837 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
838  
839
840  
841 while (!$_matched && !$commit)
842 {
843
844 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr11 expr10op expr11>]},
845 Parse::RecDescent::_tracefirst($_[1]),
846 q{expr10},
847 $tracelevel)
848 if defined $::RD_TRACE;
849 my $thisprod = $thisrule->{"prods"}[0];
850 $text = $_[1];
851 my $_savetext;
852 @item = (q{expr10});
853 %item = (__RULE__ => q{expr10});
854 my $repcount = 0;
855  
856  
857 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr11 expr10op expr11>]},
858 Parse::RecDescent::_tracefirst($text),
859 q{expr10},
860 $tracelevel)
861 if defined $::RD_TRACE;
862 $expectation->is(q{})->at($text);
863  
864 $_tok = undef;
865 OPLOOP: while (1)
866 {
867 $repcount = 0;
868 my @item;
869
870 # MATCH LEFTARG
871
872 Parse::RecDescent::_trace(q{Trying subrule: [expr11]},
873 Parse::RecDescent::_tracefirst($text),
874 q{expr10},
875 $tracelevel)
876 if defined $::RD_TRACE;
877 if (1) { no strict qw{refs};
878 $expectation->is(q{expr11})->at($text);
879 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr11($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
880 {
881
882 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr11]>>},
883 Parse::RecDescent::_tracefirst($text),
884 q{expr10},
885 $tracelevel)
886 if defined $::RD_TRACE;
887 $expectation->failed();
888 last;
889 }
890 Parse::RecDescent::_trace(q{>>Matched subrule: [expr11]<< (return value: [}
891 . $_tok . q{]},
892
893 Parse::RecDescent::_tracefirst($text),
894 q{expr10},
895 $tracelevel)
896 if defined $::RD_TRACE;
897 $item{q{expr11}} = $_tok;
898 push @item, $_tok;
899
900 }
901  
902  
903 $repcount++;
904  
905 my $savetext = $text;
906 my $backtrack;
907  
908 # MATCH (OP RIGHTARG)(s)
909 while ($repcount < 100000000)
910 {
911 $backtrack = 0;
912
913 Parse::RecDescent::_trace(q{Trying subrule: [expr10op]},
914 Parse::RecDescent::_tracefirst($text),
915 q{expr10},
916 $tracelevel)
917 if defined $::RD_TRACE;
918 if (1) { no strict qw{refs};
919 $expectation->is(q{expr10op})->at($text);
920 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr10op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
921 {
922
923 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr10op]>>},
924 Parse::RecDescent::_tracefirst($text),
925 q{expr10},
926 $tracelevel)
927 if defined $::RD_TRACE;
928 $expectation->failed();
929 last;
930 }
931 Parse::RecDescent::_trace(q{>>Matched subrule: [expr10op]<< (return value: [}
932 . $_tok . q{]},
933
934 Parse::RecDescent::_tracefirst($text),
935 q{expr10},
936 $tracelevel)
937 if defined $::RD_TRACE;
938 $item{q{expr10op}} = $_tok;
939 push @item, $_tok;
940
941 }
942  
943 $backtrack=1;
944
945
946 Parse::RecDescent::_trace(q{Trying subrule: [expr11]},
947 Parse::RecDescent::_tracefirst($text),
948 q{expr10},
949 $tracelevel)
950 if defined $::RD_TRACE;
951 if (1) { no strict qw{refs};
952 $expectation->is(q{expr11})->at($text);
953 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr11($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
954 {
955
956 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr11]>>},
957 Parse::RecDescent::_tracefirst($text),
958 q{expr10},
959 $tracelevel)
960 if defined $::RD_TRACE;
961 $expectation->failed();
962 last;
963 }
964 Parse::RecDescent::_trace(q{>>Matched subrule: [expr11]<< (return value: [}
965 . $_tok . q{]},
966
967 Parse::RecDescent::_tracefirst($text),
968 q{expr10},
969 $tracelevel)
970 if defined $::RD_TRACE;
971 $item{q{expr11}} = $_tok;
972 push @item, $_tok;
973
974 }
975  
976 $savetext = $text;
977 $repcount++;
978 }
979 $text = $savetext;
980 pop @item if $backtrack;
981  
982 unless (@item) { undef $_tok; last }
983 $_tok = [ @item ];
984 last;
985 }
986  
987 unless ($repcount>=1)
988 {
989 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr11 expr10op expr11>]>>},
990 Parse::RecDescent::_tracefirst($text),
991 q{expr10},
992 $tracelevel)
993 if defined $::RD_TRACE;
994 $expectation->failed();
995 last;
996 }
997 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr11 expr10op expr11>]<< (return value: [}
998 . qq{@{$_tok||[]}} . q{]},
999 Parse::RecDescent::_tracefirst($text),
1000 q{expr10},
1001 $tracelevel)
1002 if defined $::RD_TRACE;
1003  
1004 push @item, $item{__DIRECTIVE1__}=$_tok||[];
1005  
1006  
1007 Parse::RecDescent::_trace(q{Trying action},
1008 Parse::RecDescent::_tracefirst($text),
1009 q{expr10},
1010 $tracelevel)
1011 if defined $::RD_TRACE;
1012
1013  
1014 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
1015 unless (defined $_tok)
1016 {
1017 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1018 if defined $::RD_TRACE;
1019 last;
1020 }
1021 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1022 . $_tok . q{])},
1023 Parse::RecDescent::_tracefirst($text))
1024 if defined $::RD_TRACE;
1025 push @item, $_tok;
1026 $item{__ACTION1__}=$_tok;
1027
1028  
1029  
1030 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr11 expr10op expr11>]<<},
1031 Parse::RecDescent::_tracefirst($text),
1032 q{expr10},
1033 $tracelevel)
1034 if defined $::RD_TRACE;
1035 $_matched = 1;
1036 last;
1037 }
1038  
1039  
1040 unless ( $_matched || defined($score) )
1041 {
1042
1043  
1044 $_[1] = $text; # NOT SURE THIS IS NEEDED
1045 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1046 Parse::RecDescent::_tracefirst($_[1]),
1047 q{expr10},
1048 $tracelevel)
1049 if defined $::RD_TRACE;
1050 return undef;
1051 }
1052 if (!defined($return) && defined($score))
1053 {
1054 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1055 q{expr10},
1056 $tracelevel)
1057 if defined $::RD_TRACE;
1058 $return = $score_return;
1059 }
1060 splice @{$thisparser->{errors}}, $err_at;
1061 $return = $item[$#item] unless defined $return;
1062 if (defined $::RD_TRACE)
1063 {
1064 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1065 $return . q{])}, "",
1066 q{expr10},
1067 $tracelevel);
1068 Parse::RecDescent::_trace(q{(consumed: [} .
1069 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1070 Parse::RecDescent::_tracefirst($text),
1071 , q{expr10},
1072 $tracelevel)
1073 }
1074 $_[1] = $text;
1075 return $return;
1076 }
1077  
1078 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1079 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15
1080 {
1081 my $thisparser = $_[0];
1082 use vars q{$tracelevel};
1083 local $tracelevel = ($tracelevel||0)+1;
1084 $ERRORS = 0;
1085 my $thisrule = $thisparser->{"rules"}{"expr15"};
1086
1087 Parse::RecDescent::_trace(q{Trying rule: [expr15]},
1088 Parse::RecDescent::_tracefirst($_[1]),
1089 q{expr15},
1090 $tracelevel)
1091 if defined $::RD_TRACE;
1092  
1093
1094 my $err_at = @{$thisparser->{errors}};
1095  
1096 my $score;
1097 my $score_return;
1098 my $_tok;
1099 my $return = undef;
1100 my $_matched=0;
1101 my $commit=0;
1102 my @item = ();
1103 my %item = ();
1104 my $repeating = defined($_[2]) && $_[2];
1105 my $_noactions = defined($_[3]) && $_[3];
1106 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1107 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1108 my $text;
1109 my $lastsep="";
1110 my $current_match;
1111 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr15a expr15op expr15a>});
1112 $expectation->at($_[1]);
1113
1114 my $thisline;
1115 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1116  
1117
1118  
1119 while (!$_matched && !$commit)
1120 {
1121
1122 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr15a expr15op expr15a>]},
1123 Parse::RecDescent::_tracefirst($_[1]),
1124 q{expr15},
1125 $tracelevel)
1126 if defined $::RD_TRACE;
1127 my $thisprod = $thisrule->{"prods"}[0];
1128 $text = $_[1];
1129 my $_savetext;
1130 @item = (q{expr15});
1131 %item = (__RULE__ => q{expr15});
1132 my $repcount = 0;
1133  
1134  
1135 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr15a expr15op expr15a>]},
1136 Parse::RecDescent::_tracefirst($text),
1137 q{expr15},
1138 $tracelevel)
1139 if defined $::RD_TRACE;
1140 $expectation->is(q{})->at($text);
1141  
1142 $_tok = undef;
1143 OPLOOP: while (1)
1144 {
1145 $repcount = 0;
1146 my @item;
1147
1148 # MATCH LEFTARG
1149
1150 Parse::RecDescent::_trace(q{Trying subrule: [expr15a]},
1151 Parse::RecDescent::_tracefirst($text),
1152 q{expr15},
1153 $tracelevel)
1154 if defined $::RD_TRACE;
1155 if (1) { no strict qw{refs};
1156 $expectation->is(q{expr15a})->at($text);
1157 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15a($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1158 {
1159
1160 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr15a]>>},
1161 Parse::RecDescent::_tracefirst($text),
1162 q{expr15},
1163 $tracelevel)
1164 if defined $::RD_TRACE;
1165 $expectation->failed();
1166 last;
1167 }
1168 Parse::RecDescent::_trace(q{>>Matched subrule: [expr15a]<< (return value: [}
1169 . $_tok . q{]},
1170
1171 Parse::RecDescent::_tracefirst($text),
1172 q{expr15},
1173 $tracelevel)
1174 if defined $::RD_TRACE;
1175 $item{q{expr15a}} = $_tok;
1176 push @item, $_tok;
1177
1178 }
1179  
1180  
1181 $repcount++;
1182  
1183 my $savetext = $text;
1184 my $backtrack;
1185  
1186 # MATCH (OP RIGHTARG)(s)
1187 while ($repcount < 100000000)
1188 {
1189 $backtrack = 0;
1190
1191 Parse::RecDescent::_trace(q{Trying subrule: [expr15op]},
1192 Parse::RecDescent::_tracefirst($text),
1193 q{expr15},
1194 $tracelevel)
1195 if defined $::RD_TRACE;
1196 if (1) { no strict qw{refs};
1197 $expectation->is(q{expr15op})->at($text);
1198 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1199 {
1200
1201 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr15op]>>},
1202 Parse::RecDescent::_tracefirst($text),
1203 q{expr15},
1204 $tracelevel)
1205 if defined $::RD_TRACE;
1206 $expectation->failed();
1207 last;
1208 }
1209 Parse::RecDescent::_trace(q{>>Matched subrule: [expr15op]<< (return value: [}
1210 . $_tok . q{]},
1211
1212 Parse::RecDescent::_tracefirst($text),
1213 q{expr15},
1214 $tracelevel)
1215 if defined $::RD_TRACE;
1216 $item{q{expr15op}} = $_tok;
1217 push @item, $_tok;
1218
1219 }
1220  
1221 $backtrack=1;
1222
1223
1224 Parse::RecDescent::_trace(q{Trying subrule: [expr15a]},
1225 Parse::RecDescent::_tracefirst($text),
1226 q{expr15},
1227 $tracelevel)
1228 if defined $::RD_TRACE;
1229 if (1) { no strict qw{refs};
1230 $expectation->is(q{expr15a})->at($text);
1231 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15a($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1232 {
1233
1234 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr15a]>>},
1235 Parse::RecDescent::_tracefirst($text),
1236 q{expr15},
1237 $tracelevel)
1238 if defined $::RD_TRACE;
1239 $expectation->failed();
1240 last;
1241 }
1242 Parse::RecDescent::_trace(q{>>Matched subrule: [expr15a]<< (return value: [}
1243 . $_tok . q{]},
1244
1245 Parse::RecDescent::_tracefirst($text),
1246 q{expr15},
1247 $tracelevel)
1248 if defined $::RD_TRACE;
1249 $item{q{expr15a}} = $_tok;
1250 push @item, $_tok;
1251
1252 }
1253  
1254 $savetext = $text;
1255 $repcount++;
1256 }
1257 $text = $savetext;
1258 pop @item if $backtrack;
1259  
1260 unless (@item) { undef $_tok; last }
1261 $_tok = [ @item ];
1262 last;
1263 }
1264  
1265 unless ($repcount>=1)
1266 {
1267 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr15a expr15op expr15a>]>>},
1268 Parse::RecDescent::_tracefirst($text),
1269 q{expr15},
1270 $tracelevel)
1271 if defined $::RD_TRACE;
1272 $expectation->failed();
1273 last;
1274 }
1275 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr15a expr15op expr15a>]<< (return value: [}
1276 . qq{@{$_tok||[]}} . q{]},
1277 Parse::RecDescent::_tracefirst($text),
1278 q{expr15},
1279 $tracelevel)
1280 if defined $::RD_TRACE;
1281  
1282 push @item, $item{__DIRECTIVE1__}=$_tok||[];
1283  
1284  
1285 Parse::RecDescent::_trace(q{Trying action},
1286 Parse::RecDescent::_tracefirst($text),
1287 q{expr15},
1288 $tracelevel)
1289 if defined $::RD_TRACE;
1290
1291  
1292 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
1293 unless (defined $_tok)
1294 {
1295 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1296 if defined $::RD_TRACE;
1297 last;
1298 }
1299 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1300 . $_tok . q{])},
1301 Parse::RecDescent::_tracefirst($text))
1302 if defined $::RD_TRACE;
1303 push @item, $_tok;
1304 $item{__ACTION1__}=$_tok;
1305
1306  
1307  
1308 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr15a expr15op expr15a>]<<},
1309 Parse::RecDescent::_tracefirst($text),
1310 q{expr15},
1311 $tracelevel)
1312 if defined $::RD_TRACE;
1313 $_matched = 1;
1314 last;
1315 }
1316  
1317  
1318 unless ( $_matched || defined($score) )
1319 {
1320
1321  
1322 $_[1] = $text; # NOT SURE THIS IS NEEDED
1323 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1324 Parse::RecDescent::_tracefirst($_[1]),
1325 q{expr15},
1326 $tracelevel)
1327 if defined $::RD_TRACE;
1328 return undef;
1329 }
1330 if (!defined($return) && defined($score))
1331 {
1332 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1333 q{expr15},
1334 $tracelevel)
1335 if defined $::RD_TRACE;
1336 $return = $score_return;
1337 }
1338 splice @{$thisparser->{errors}}, $err_at;
1339 $return = $item[$#item] unless defined $return;
1340 if (defined $::RD_TRACE)
1341 {
1342 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1343 $return . q{])}, "",
1344 q{expr15},
1345 $tracelevel);
1346 Parse::RecDescent::_trace(q{(consumed: [} .
1347 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1348 Parse::RecDescent::_tracefirst($text),
1349 , q{expr15},
1350 $tracelevel)
1351 }
1352 $_[1] = $text;
1353 return $return;
1354 }
1355  
1356 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1357 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr11
1358 {
1359 my $thisparser = $_[0];
1360 use vars q{$tracelevel};
1361 local $tracelevel = ($tracelevel||0)+1;
1362 $ERRORS = 0;
1363 my $thisrule = $thisparser->{"rules"}{"expr11"};
1364
1365 Parse::RecDescent::_trace(q{Trying rule: [expr11]},
1366 Parse::RecDescent::_tracefirst($_[1]),
1367 q{expr11},
1368 $tracelevel)
1369 if defined $::RD_TRACE;
1370  
1371
1372 my $err_at = @{$thisparser->{errors}};
1373  
1374 my $score;
1375 my $score_return;
1376 my $_tok;
1377 my $return = undef;
1378 my $_matched=0;
1379 my $commit=0;
1380 my @item = ();
1381 my %item = ();
1382 my $repeating = defined($_[2]) && $_[2];
1383 my $_noactions = defined($_[3]) && $_[3];
1384 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1385 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1386 my $text;
1387 my $lastsep="";
1388 my $current_match;
1389 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr12 expr11op expr12>});
1390 $expectation->at($_[1]);
1391
1392 my $thisline;
1393 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1394  
1395
1396  
1397 while (!$_matched && !$commit)
1398 {
1399
1400 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr12 expr11op expr12>]},
1401 Parse::RecDescent::_tracefirst($_[1]),
1402 q{expr11},
1403 $tracelevel)
1404 if defined $::RD_TRACE;
1405 my $thisprod = $thisrule->{"prods"}[0];
1406 $text = $_[1];
1407 my $_savetext;
1408 @item = (q{expr11});
1409 %item = (__RULE__ => q{expr11});
1410 my $repcount = 0;
1411  
1412  
1413 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr12 expr11op expr12>]},
1414 Parse::RecDescent::_tracefirst($text),
1415 q{expr11},
1416 $tracelevel)
1417 if defined $::RD_TRACE;
1418 $expectation->is(q{})->at($text);
1419  
1420 $_tok = undef;
1421 OPLOOP: while (1)
1422 {
1423 $repcount = 0;
1424 my @item;
1425
1426 # MATCH LEFTARG
1427
1428 Parse::RecDescent::_trace(q{Trying subrule: [expr12]},
1429 Parse::RecDescent::_tracefirst($text),
1430 q{expr11},
1431 $tracelevel)
1432 if defined $::RD_TRACE;
1433 if (1) { no strict qw{refs};
1434 $expectation->is(q{expr12})->at($text);
1435 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr12($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1436 {
1437
1438 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr12]>>},
1439 Parse::RecDescent::_tracefirst($text),
1440 q{expr11},
1441 $tracelevel)
1442 if defined $::RD_TRACE;
1443 $expectation->failed();
1444 last;
1445 }
1446 Parse::RecDescent::_trace(q{>>Matched subrule: [expr12]<< (return value: [}
1447 . $_tok . q{]},
1448
1449 Parse::RecDescent::_tracefirst($text),
1450 q{expr11},
1451 $tracelevel)
1452 if defined $::RD_TRACE;
1453 $item{q{expr12}} = $_tok;
1454 push @item, $_tok;
1455
1456 }
1457  
1458  
1459 $repcount++;
1460  
1461 my $savetext = $text;
1462 my $backtrack;
1463  
1464 # MATCH (OP RIGHTARG)(s)
1465 while ($repcount < 100000000)
1466 {
1467 $backtrack = 0;
1468
1469 Parse::RecDescent::_trace(q{Trying subrule: [expr11op]},
1470 Parse::RecDescent::_tracefirst($text),
1471 q{expr11},
1472 $tracelevel)
1473 if defined $::RD_TRACE;
1474 if (1) { no strict qw{refs};
1475 $expectation->is(q{expr11op})->at($text);
1476 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr11op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1477 {
1478
1479 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr11op]>>},
1480 Parse::RecDescent::_tracefirst($text),
1481 q{expr11},
1482 $tracelevel)
1483 if defined $::RD_TRACE;
1484 $expectation->failed();
1485 last;
1486 }
1487 Parse::RecDescent::_trace(q{>>Matched subrule: [expr11op]<< (return value: [}
1488 . $_tok . q{]},
1489
1490 Parse::RecDescent::_tracefirst($text),
1491 q{expr11},
1492 $tracelevel)
1493 if defined $::RD_TRACE;
1494 $item{q{expr11op}} = $_tok;
1495 push @item, $_tok;
1496
1497 }
1498  
1499 $backtrack=1;
1500
1501
1502 Parse::RecDescent::_trace(q{Trying subrule: [expr12]},
1503 Parse::RecDescent::_tracefirst($text),
1504 q{expr11},
1505 $tracelevel)
1506 if defined $::RD_TRACE;
1507 if (1) { no strict qw{refs};
1508 $expectation->is(q{expr12})->at($text);
1509 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr12($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1510 {
1511
1512 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr12]>>},
1513 Parse::RecDescent::_tracefirst($text),
1514 q{expr11},
1515 $tracelevel)
1516 if defined $::RD_TRACE;
1517 $expectation->failed();
1518 last;
1519 }
1520 Parse::RecDescent::_trace(q{>>Matched subrule: [expr12]<< (return value: [}
1521 . $_tok . q{]},
1522
1523 Parse::RecDescent::_tracefirst($text),
1524 q{expr11},
1525 $tracelevel)
1526 if defined $::RD_TRACE;
1527 $item{q{expr12}} = $_tok;
1528 push @item, $_tok;
1529
1530 }
1531  
1532 $savetext = $text;
1533 $repcount++;
1534 }
1535 $text = $savetext;
1536 pop @item if $backtrack;
1537  
1538 unless (@item) { undef $_tok; last }
1539 $_tok = [ @item ];
1540 last;
1541 }
1542  
1543 unless ($repcount>=1)
1544 {
1545 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr12 expr11op expr12>]>>},
1546 Parse::RecDescent::_tracefirst($text),
1547 q{expr11},
1548 $tracelevel)
1549 if defined $::RD_TRACE;
1550 $expectation->failed();
1551 last;
1552 }
1553 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr12 expr11op expr12>]<< (return value: [}
1554 . qq{@{$_tok||[]}} . q{]},
1555 Parse::RecDescent::_tracefirst($text),
1556 q{expr11},
1557 $tracelevel)
1558 if defined $::RD_TRACE;
1559  
1560 push @item, $item{__DIRECTIVE1__}=$_tok||[];
1561  
1562  
1563 Parse::RecDescent::_trace(q{Trying action},
1564 Parse::RecDescent::_tracefirst($text),
1565 q{expr11},
1566 $tracelevel)
1567 if defined $::RD_TRACE;
1568
1569  
1570 $_tok = ($_noactions) ? 0 : do { db(@item); nonassoc(@item) };
1571 unless (defined $_tok)
1572 {
1573 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1574 if defined $::RD_TRACE;
1575 last;
1576 }
1577 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1578 . $_tok . q{])},
1579 Parse::RecDescent::_tracefirst($text))
1580 if defined $::RD_TRACE;
1581 push @item, $_tok;
1582 $item{__ACTION1__}=$_tok;
1583
1584  
1585  
1586 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr12 expr11op expr12>]<<},
1587 Parse::RecDescent::_tracefirst($text),
1588 q{expr11},
1589 $tracelevel)
1590 if defined $::RD_TRACE;
1591 $_matched = 1;
1592 last;
1593 }
1594  
1595  
1596 unless ( $_matched || defined($score) )
1597 {
1598
1599  
1600 $_[1] = $text; # NOT SURE THIS IS NEEDED
1601 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1602 Parse::RecDescent::_tracefirst($_[1]),
1603 q{expr11},
1604 $tracelevel)
1605 if defined $::RD_TRACE;
1606 return undef;
1607 }
1608 if (!defined($return) && defined($score))
1609 {
1610 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1611 q{expr11},
1612 $tracelevel)
1613 if defined $::RD_TRACE;
1614 $return = $score_return;
1615 }
1616 splice @{$thisparser->{errors}}, $err_at;
1617 $return = $item[$#item] unless defined $return;
1618 if (defined $::RD_TRACE)
1619 {
1620 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1621 $return . q{])}, "",
1622 q{expr11},
1623 $tracelevel);
1624 Parse::RecDescent::_trace(q{(consumed: [} .
1625 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1626 Parse::RecDescent::_tracefirst($text),
1627 , q{expr11},
1628 $tracelevel)
1629 }
1630 $_[1] = $text;
1631 return $return;
1632 }
1633  
1634 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1635 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr12op
1636 {
1637 my $thisparser = $_[0];
1638 use vars q{$tracelevel};
1639 local $tracelevel = ($tracelevel||0)+1;
1640 $ERRORS = 0;
1641 my $thisrule = $thisparser->{"rules"}{"expr12op"};
1642
1643 Parse::RecDescent::_trace(q{Trying rule: [expr12op]},
1644 Parse::RecDescent::_tracefirst($_[1]),
1645 q{expr12op},
1646 $tracelevel)
1647 if defined $::RD_TRACE;
1648  
1649
1650 my $err_at = @{$thisparser->{errors}};
1651  
1652 my $score;
1653 my $score_return;
1654 my $_tok;
1655 my $return = undef;
1656 my $_matched=0;
1657 my $commit=0;
1658 my @item = ();
1659 my %item = ();
1660 my $repeating = defined($_[2]) && $_[2];
1661 my $_noactions = defined($_[3]) && $_[3];
1662 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1663 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1664 my $text;
1665 my $lastsep="";
1666 my $current_match;
1667 my $expectation = new Parse::RecDescent::Expectation(q{/(<|>|<=|>=|lt|gt|le|ge)/});
1668 $expectation->at($_[1]);
1669
1670 my $thisline;
1671 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1672  
1673
1674  
1675 while (!$_matched && !$commit)
1676 {
1677
1678 Parse::RecDescent::_trace(q{Trying production: [/(<|>|<=|>=|lt|gt|le|ge)/]},
1679 Parse::RecDescent::_tracefirst($_[1]),
1680 q{expr12op},
1681 $tracelevel)
1682 if defined $::RD_TRACE;
1683 my $thisprod = $thisrule->{"prods"}[0];
1684 $text = $_[1];
1685 my $_savetext;
1686 @item = (q{expr12op});
1687 %item = (__RULE__ => q{expr12op});
1688 my $repcount = 0;
1689  
1690  
1691 Parse::RecDescent::_trace(q{Trying terminal: [/(<|>|<=|>=|lt|gt|le|ge)/]}, Parse::RecDescent::_tracefirst($text),
1692 q{expr12op},
1693 $tracelevel)
1694 if defined $::RD_TRACE;
1695 $lastsep = "";
1696 $expectation->is(q{})->at($text);
1697
1698  
1699 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(<|>|<=|>=|lt|gt|le|ge))/)
1700 {
1701
1702 $expectation->failed();
1703 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
1704 Parse::RecDescent::_tracefirst($text))
1705 if defined $::RD_TRACE;
1706  
1707 last;
1708 }
1709 $current_match = substr($text, $-[0], $+[0] - $-[0]);
1710 substr($text,0,length($current_match),q{});
1711 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1712 . $current_match . q{])},
1713 Parse::RecDescent::_tracefirst($text))
1714 if defined $::RD_TRACE;
1715 push @item, $item{__PATTERN1__}=$current_match;
1716
1717  
1718 Parse::RecDescent::_trace(q{Trying action},
1719 Parse::RecDescent::_tracefirst($text),
1720 q{expr12op},
1721 $tracelevel)
1722 if defined $::RD_TRACE;
1723
1724  
1725 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
1726 unless (defined $_tok)
1727 {
1728 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
1729 if defined $::RD_TRACE;
1730 last;
1731 }
1732 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1733 . $_tok . q{])},
1734 Parse::RecDescent::_tracefirst($text))
1735 if defined $::RD_TRACE;
1736 push @item, $_tok;
1737 $item{__ACTION1__}=$_tok;
1738
1739  
1740  
1741 Parse::RecDescent::_trace(q{>>Matched production: [/(<|>|<=|>=|lt|gt|le|ge)/]<<},
1742 Parse::RecDescent::_tracefirst($text),
1743 q{expr12op},
1744 $tracelevel)
1745 if defined $::RD_TRACE;
1746 $_matched = 1;
1747 last;
1748 }
1749  
1750  
1751 unless ( $_matched || defined($score) )
1752 {
1753
1754  
1755 $_[1] = $text; # NOT SURE THIS IS NEEDED
1756 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1757 Parse::RecDescent::_tracefirst($_[1]),
1758 q{expr12op},
1759 $tracelevel)
1760 if defined $::RD_TRACE;
1761 return undef;
1762 }
1763 if (!defined($return) && defined($score))
1764 {
1765 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1766 q{expr12op},
1767 $tracelevel)
1768 if defined $::RD_TRACE;
1769 $return = $score_return;
1770 }
1771 splice @{$thisparser->{errors}}, $err_at;
1772 $return = $item[$#item] unless defined $return;
1773 if (defined $::RD_TRACE)
1774 {
1775 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1776 $return . q{])}, "",
1777 q{expr12op},
1778 $tracelevel);
1779 Parse::RecDescent::_trace(q{(consumed: [} .
1780 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1781 Parse::RecDescent::_tracefirst($text),
1782 , q{expr12op},
1783 $tracelevel)
1784 }
1785 $_[1] = $text;
1786 return $return;
1787 }
1788  
1789 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1790 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr8
1791 {
1792 my $thisparser = $_[0];
1793 use vars q{$tracelevel};
1794 local $tracelevel = ($tracelevel||0)+1;
1795 $ERRORS = 0;
1796 my $thisrule = $thisparser->{"rules"}{"expr8"};
1797
1798 Parse::RecDescent::_trace(q{Trying rule: [expr8]},
1799 Parse::RecDescent::_tracefirst($_[1]),
1800 q{expr8},
1801 $tracelevel)
1802 if defined $::RD_TRACE;
1803  
1804
1805 my $err_at = @{$thisparser->{errors}};
1806  
1807 my $score;
1808 my $score_return;
1809 my $_tok;
1810 my $return = undef;
1811 my $_matched=0;
1812 my $commit=0;
1813 my @item = ();
1814 my %item = ();
1815 my $repeating = defined($_[2]) && $_[2];
1816 my $_noactions = defined($_[3]) && $_[3];
1817 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1818 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1819 my $text;
1820 my $lastsep="";
1821 my $current_match;
1822 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr9 expr8op expr9>});
1823 $expectation->at($_[1]);
1824
1825 my $thisline;
1826 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1827  
1828
1829  
1830 while (!$_matched && !$commit)
1831 {
1832
1833 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr9 expr8op expr9>]},
1834 Parse::RecDescent::_tracefirst($_[1]),
1835 q{expr8},
1836 $tracelevel)
1837 if defined $::RD_TRACE;
1838 my $thisprod = $thisrule->{"prods"}[0];
1839 $text = $_[1];
1840 my $_savetext;
1841 @item = (q{expr8});
1842 %item = (__RULE__ => q{expr8});
1843 my $repcount = 0;
1844  
1845  
1846 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr9 expr8op expr9>]},
1847 Parse::RecDescent::_tracefirst($text),
1848 q{expr8},
1849 $tracelevel)
1850 if defined $::RD_TRACE;
1851 $expectation->is(q{})->at($text);
1852  
1853 $_tok = undef;
1854 OPLOOP: while (1)
1855 {
1856 $repcount = 0;
1857 my @item;
1858
1859 # MATCH LEFTARG
1860
1861 Parse::RecDescent::_trace(q{Trying subrule: [expr9]},
1862 Parse::RecDescent::_tracefirst($text),
1863 q{expr8},
1864 $tracelevel)
1865 if defined $::RD_TRACE;
1866 if (1) { no strict qw{refs};
1867 $expectation->is(q{expr9})->at($text);
1868 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr9($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1869 {
1870
1871 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr9]>>},
1872 Parse::RecDescent::_tracefirst($text),
1873 q{expr8},
1874 $tracelevel)
1875 if defined $::RD_TRACE;
1876 $expectation->failed();
1877 last;
1878 }
1879 Parse::RecDescent::_trace(q{>>Matched subrule: [expr9]<< (return value: [}
1880 . $_tok . q{]},
1881
1882 Parse::RecDescent::_tracefirst($text),
1883 q{expr8},
1884 $tracelevel)
1885 if defined $::RD_TRACE;
1886 $item{q{expr9}} = $_tok;
1887 push @item, $_tok;
1888
1889 }
1890  
1891  
1892 $repcount++;
1893  
1894 my $savetext = $text;
1895 my $backtrack;
1896  
1897 # MATCH (OP RIGHTARG)(s)
1898 while ($repcount < 100000000)
1899 {
1900 $backtrack = 0;
1901
1902 Parse::RecDescent::_trace(q{Trying subrule: [expr8op]},
1903 Parse::RecDescent::_tracefirst($text),
1904 q{expr8},
1905 $tracelevel)
1906 if defined $::RD_TRACE;
1907 if (1) { no strict qw{refs};
1908 $expectation->is(q{expr8op})->at($text);
1909 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr8op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1910 {
1911
1912 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr8op]>>},
1913 Parse::RecDescent::_tracefirst($text),
1914 q{expr8},
1915 $tracelevel)
1916 if defined $::RD_TRACE;
1917 $expectation->failed();
1918 last;
1919 }
1920 Parse::RecDescent::_trace(q{>>Matched subrule: [expr8op]<< (return value: [}
1921 . $_tok . q{]},
1922
1923 Parse::RecDescent::_tracefirst($text),
1924 q{expr8},
1925 $tracelevel)
1926 if defined $::RD_TRACE;
1927 $item{q{expr8op}} = $_tok;
1928 push @item, $_tok;
1929
1930 }
1931  
1932 $backtrack=1;
1933
1934
1935 Parse::RecDescent::_trace(q{Trying subrule: [expr9]},
1936 Parse::RecDescent::_tracefirst($text),
1937 q{expr8},
1938 $tracelevel)
1939 if defined $::RD_TRACE;
1940 if (1) { no strict qw{refs};
1941 $expectation->is(q{expr9})->at($text);
1942 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr9($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1943 {
1944
1945 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr9]>>},
1946 Parse::RecDescent::_tracefirst($text),
1947 q{expr8},
1948 $tracelevel)
1949 if defined $::RD_TRACE;
1950 $expectation->failed();
1951 last;
1952 }
1953 Parse::RecDescent::_trace(q{>>Matched subrule: [expr9]<< (return value: [}
1954 . $_tok . q{]},
1955
1956 Parse::RecDescent::_tracefirst($text),
1957 q{expr8},
1958 $tracelevel)
1959 if defined $::RD_TRACE;
1960 $item{q{expr9}} = $_tok;
1961 push @item, $_tok;
1962
1963 }
1964  
1965 $savetext = $text;
1966 $repcount++;
1967 }
1968 $text = $savetext;
1969 pop @item if $backtrack;
1970  
1971 unless (@item) { undef $_tok; last }
1972 $_tok = [ @item ];
1973 last;
1974 }
1975  
1976 unless ($repcount>=1)
1977 {
1978 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr9 expr8op expr9>]>>},
1979 Parse::RecDescent::_tracefirst($text),
1980 q{expr8},
1981 $tracelevel)
1982 if defined $::RD_TRACE;
1983 $expectation->failed();
1984 last;
1985 }
1986 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr9 expr8op expr9>]<< (return value: [}
1987 . qq{@{$_tok||[]}} . q{]},
1988 Parse::RecDescent::_tracefirst($text),
1989 q{expr8},
1990 $tracelevel)
1991 if defined $::RD_TRACE;
1992  
1993 push @item, $item{__DIRECTIVE1__}=$_tok||[];
1994  
1995  
1996 Parse::RecDescent::_trace(q{Trying action},
1997 Parse::RecDescent::_tracefirst($text),
1998 q{expr8},
1999 $tracelevel)
2000 if defined $::RD_TRACE;
2001
2002  
2003 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
2004 unless (defined $_tok)
2005 {
2006 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2007 if defined $::RD_TRACE;
2008 last;
2009 }
2010 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2011 . $_tok . q{])},
2012 Parse::RecDescent::_tracefirst($text))
2013 if defined $::RD_TRACE;
2014 push @item, $_tok;
2015 $item{__ACTION1__}=$_tok;
2016
2017  
2018  
2019 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr9 expr8op expr9>]<<},
2020 Parse::RecDescent::_tracefirst($text),
2021 q{expr8},
2022 $tracelevel)
2023 if defined $::RD_TRACE;
2024 $_matched = 1;
2025 last;
2026 }
2027  
2028  
2029 unless ( $_matched || defined($score) )
2030 {
2031
2032  
2033 $_[1] = $text; # NOT SURE THIS IS NEEDED
2034 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2035 Parse::RecDescent::_tracefirst($_[1]),
2036 q{expr8},
2037 $tracelevel)
2038 if defined $::RD_TRACE;
2039 return undef;
2040 }
2041 if (!defined($return) && defined($score))
2042 {
2043 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2044 q{expr8},
2045 $tracelevel)
2046 if defined $::RD_TRACE;
2047 $return = $score_return;
2048 }
2049 splice @{$thisparser->{errors}}, $err_at;
2050 $return = $item[$#item] unless defined $return;
2051 if (defined $::RD_TRACE)
2052 {
2053 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2054 $return . q{])}, "",
2055 q{expr8},
2056 $tracelevel);
2057 Parse::RecDescent::_trace(q{(consumed: [} .
2058 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2059 Parse::RecDescent::_tracefirst($text),
2060 , q{expr8},
2061 $tracelevel)
2062 }
2063 $_[1] = $text;
2064 return $return;
2065 }
2066  
2067 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2068 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr5
2069 {
2070 my $thisparser = $_[0];
2071 use vars q{$tracelevel};
2072 local $tracelevel = ($tracelevel||0)+1;
2073 $ERRORS = 0;
2074 my $thisrule = $thisparser->{"rules"}{"expr5"};
2075
2076 Parse::RecDescent::_trace(q{Trying rule: [expr5]},
2077 Parse::RecDescent::_tracefirst($_[1]),
2078 q{expr5},
2079 $tracelevel)
2080 if defined $::RD_TRACE;
2081  
2082
2083 my $err_at = @{$thisparser->{errors}};
2084  
2085 my $score;
2086 my $score_return;
2087 my $_tok;
2088 my $return = undef;
2089 my $_matched=0;
2090 my $commit=0;
2091 my @item = ();
2092 my %item = ();
2093 my $repeating = defined($_[2]) && $_[2];
2094 my $_noactions = defined($_[3]) && $_[3];
2095 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2096 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2097 my $text;
2098 my $lastsep="";
2099 my $current_match;
2100 my $expectation = new Parse::RecDescent::Expectation(q{'not', or expr6});
2101 $expectation->at($_[1]);
2102
2103 my $thisline;
2104 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2105  
2106
2107  
2108 while (!$_matched && !$commit)
2109 {
2110
2111 Parse::RecDescent::_trace(q{Trying production: ['not' expr6]},
2112 Parse::RecDescent::_tracefirst($_[1]),
2113 q{expr5},
2114 $tracelevel)
2115 if defined $::RD_TRACE;
2116 my $thisprod = $thisrule->{"prods"}[0];
2117 $text = $_[1];
2118 my $_savetext;
2119 @item = (q{expr5});
2120 %item = (__RULE__ => q{expr5});
2121 my $repcount = 0;
2122  
2123  
2124 Parse::RecDescent::_trace(q{Trying terminal: ['not']},
2125 Parse::RecDescent::_tracefirst($text),
2126 q{expr5},
2127 $tracelevel)
2128 if defined $::RD_TRACE;
2129 $lastsep = "";
2130 $expectation->is(q{})->at($text);
2131
2132  
2133 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "not"; 1 } and
2134 substr($text,0,length($_tok)) eq $_tok and
2135 do { substr($text,0,length($_tok)) = ""; 1; }
2136 )
2137 {
2138
2139 $expectation->failed();
2140 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2141 Parse::RecDescent::_tracefirst($text))
2142 if defined $::RD_TRACE;
2143 last;
2144 }
2145 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2146 . $_tok . q{])},
2147 Parse::RecDescent::_tracefirst($text))
2148 if defined $::RD_TRACE;
2149 push @item, $item{__STRING1__}=$_tok;
2150
2151  
2152 Parse::RecDescent::_trace(q{Trying subrule: [expr6]},
2153 Parse::RecDescent::_tracefirst($text),
2154 q{expr5},
2155 $tracelevel)
2156 if defined $::RD_TRACE;
2157 if (1) { no strict qw{refs};
2158 $expectation->is(q{expr6})->at($text);
2159 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr6($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2160 {
2161
2162 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr6]>>},
2163 Parse::RecDescent::_tracefirst($text),
2164 q{expr5},
2165 $tracelevel)
2166 if defined $::RD_TRACE;
2167 $expectation->failed();
2168 last;
2169 }
2170 Parse::RecDescent::_trace(q{>>Matched subrule: [expr6]<< (return value: [}
2171 . $_tok . q{]},
2172
2173 Parse::RecDescent::_tracefirst($text),
2174 q{expr5},
2175 $tracelevel)
2176 if defined $::RD_TRACE;
2177 $item{q{expr6}} = $_tok;
2178 push @item, $_tok;
2179
2180 }
2181  
2182 Parse::RecDescent::_trace(q{Trying action},
2183 Parse::RecDescent::_tracefirst($text),
2184 q{expr5},
2185 $tracelevel)
2186 if defined $::RD_TRACE;
2187
2188  
2189 $_tok = ($_noactions) ? 0 : do { db(@item); unary('not', $item[2]) };
2190 unless (defined $_tok)
2191 {
2192 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2193 if defined $::RD_TRACE;
2194 last;
2195 }
2196 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2197 . $_tok . q{])},
2198 Parse::RecDescent::_tracefirst($text))
2199 if defined $::RD_TRACE;
2200 push @item, $_tok;
2201 $item{__ACTION1__}=$_tok;
2202
2203  
2204  
2205 Parse::RecDescent::_trace(q{>>Matched production: ['not' expr6]<<},
2206 Parse::RecDescent::_tracefirst($text),
2207 q{expr5},
2208 $tracelevel)
2209 if defined $::RD_TRACE;
2210 $_matched = 1;
2211 last;
2212 }
2213  
2214  
2215 while (!$_matched && !$commit)
2216 {
2217
2218 Parse::RecDescent::_trace(q{Trying production: [expr6]},
2219 Parse::RecDescent::_tracefirst($_[1]),
2220 q{expr5},
2221 $tracelevel)
2222 if defined $::RD_TRACE;
2223 my $thisprod = $thisrule->{"prods"}[1];
2224 $text = $_[1];
2225 my $_savetext;
2226 @item = (q{expr5});
2227 %item = (__RULE__ => q{expr5});
2228 my $repcount = 0;
2229  
2230  
2231 Parse::RecDescent::_trace(q{Trying subrule: [expr6]},
2232 Parse::RecDescent::_tracefirst($text),
2233 q{expr5},
2234 $tracelevel)
2235 if defined $::RD_TRACE;
2236 if (1) { no strict qw{refs};
2237 $expectation->is(q{})->at($text);
2238 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr6($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2239 {
2240
2241 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr6]>>},
2242 Parse::RecDescent::_tracefirst($text),
2243 q{expr5},
2244 $tracelevel)
2245 if defined $::RD_TRACE;
2246 $expectation->failed();
2247 last;
2248 }
2249 Parse::RecDescent::_trace(q{>>Matched subrule: [expr6]<< (return value: [}
2250 . $_tok . q{]},
2251
2252 Parse::RecDescent::_tracefirst($text),
2253 q{expr5},
2254 $tracelevel)
2255 if defined $::RD_TRACE;
2256 $item{q{expr6}} = $_tok;
2257 push @item, $_tok;
2258
2259 }
2260  
2261 Parse::RecDescent::_trace(q{Trying action},
2262 Parse::RecDescent::_tracefirst($text),
2263 q{expr5},
2264 $tracelevel)
2265 if defined $::RD_TRACE;
2266
2267  
2268 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
2269 unless (defined $_tok)
2270 {
2271 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2272 if defined $::RD_TRACE;
2273 last;
2274 }
2275 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2276 . $_tok . q{])},
2277 Parse::RecDescent::_tracefirst($text))
2278 if defined $::RD_TRACE;
2279 push @item, $_tok;
2280 $item{__ACTION1__}=$_tok;
2281
2282  
2283  
2284 Parse::RecDescent::_trace(q{>>Matched production: [expr6]<<},
2285 Parse::RecDescent::_tracefirst($text),
2286 q{expr5},
2287 $tracelevel)
2288 if defined $::RD_TRACE;
2289 $_matched = 1;
2290 last;
2291 }
2292  
2293  
2294 unless ( $_matched || defined($score) )
2295 {
2296
2297  
2298 $_[1] = $text; # NOT SURE THIS IS NEEDED
2299 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2300 Parse::RecDescent::_tracefirst($_[1]),
2301 q{expr5},
2302 $tracelevel)
2303 if defined $::RD_TRACE;
2304 return undef;
2305 }
2306 if (!defined($return) && defined($score))
2307 {
2308 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2309 q{expr5},
2310 $tracelevel)
2311 if defined $::RD_TRACE;
2312 $return = $score_return;
2313 }
2314 splice @{$thisparser->{errors}}, $err_at;
2315 $return = $item[$#item] unless defined $return;
2316 if (defined $::RD_TRACE)
2317 {
2318 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2319 $return . q{])}, "",
2320 q{expr5},
2321 $tracelevel);
2322 Parse::RecDescent::_trace(q{(consumed: [} .
2323 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2324 Parse::RecDescent::_tracefirst($text),
2325 , q{expr5},
2326 $tracelevel)
2327 }
2328 $_[1] = $text;
2329 return $return;
2330 }
2331  
2332 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2333 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr14
2334 {
2335 my $thisparser = $_[0];
2336 use vars q{$tracelevel};
2337 local $tracelevel = ($tracelevel||0)+1;
2338 $ERRORS = 0;
2339 my $thisrule = $thisparser->{"rules"}{"expr14"};
2340
2341 Parse::RecDescent::_trace(q{Trying rule: [expr14]},
2342 Parse::RecDescent::_tracefirst($_[1]),
2343 q{expr14},
2344 $tracelevel)
2345 if defined $::RD_TRACE;
2346  
2347
2348 my $err_at = @{$thisparser->{errors}};
2349  
2350 my $score;
2351 my $score_return;
2352 my $_tok;
2353 my $return = undef;
2354 my $_matched=0;
2355 my $commit=0;
2356 my @item = ();
2357 my %item = ();
2358 my $repeating = defined($_[2]) && $_[2];
2359 my $_noactions = defined($_[3]) && $_[3];
2360 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2361 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2362 my $text;
2363 my $lastsep="";
2364 my $current_match;
2365 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr15 expr14op expr15>});
2366 $expectation->at($_[1]);
2367
2368 my $thisline;
2369 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2370  
2371
2372  
2373 while (!$_matched && !$commit)
2374 {
2375
2376 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr15 expr14op expr15>]},
2377 Parse::RecDescent::_tracefirst($_[1]),
2378 q{expr14},
2379 $tracelevel)
2380 if defined $::RD_TRACE;
2381 my $thisprod = $thisrule->{"prods"}[0];
2382 $text = $_[1];
2383 my $_savetext;
2384 @item = (q{expr14});
2385 %item = (__RULE__ => q{expr14});
2386 my $repcount = 0;
2387  
2388  
2389 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr15 expr14op expr15>]},
2390 Parse::RecDescent::_tracefirst($text),
2391 q{expr14},
2392 $tracelevel)
2393 if defined $::RD_TRACE;
2394 $expectation->is(q{})->at($text);
2395  
2396 $_tok = undef;
2397 OPLOOP: while (1)
2398 {
2399 $repcount = 0;
2400 my @item;
2401
2402 # MATCH LEFTARG
2403
2404 Parse::RecDescent::_trace(q{Trying subrule: [expr15]},
2405 Parse::RecDescent::_tracefirst($text),
2406 q{expr14},
2407 $tracelevel)
2408 if defined $::RD_TRACE;
2409 if (1) { no strict qw{refs};
2410 $expectation->is(q{expr15})->at($text);
2411 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2412 {
2413
2414 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr15]>>},
2415 Parse::RecDescent::_tracefirst($text),
2416 q{expr14},
2417 $tracelevel)
2418 if defined $::RD_TRACE;
2419 $expectation->failed();
2420 last;
2421 }
2422 Parse::RecDescent::_trace(q{>>Matched subrule: [expr15]<< (return value: [}
2423 . $_tok . q{]},
2424
2425 Parse::RecDescent::_tracefirst($text),
2426 q{expr14},
2427 $tracelevel)
2428 if defined $::RD_TRACE;
2429 $item{q{expr15}} = $_tok;
2430 push @item, $_tok;
2431
2432 }
2433  
2434  
2435 $repcount++;
2436  
2437 my $savetext = $text;
2438 my $backtrack;
2439  
2440 # MATCH (OP RIGHTARG)(s)
2441 while ($repcount < 100000000)
2442 {
2443 $backtrack = 0;
2444
2445 Parse::RecDescent::_trace(q{Trying subrule: [expr14op]},
2446 Parse::RecDescent::_tracefirst($text),
2447 q{expr14},
2448 $tracelevel)
2449 if defined $::RD_TRACE;
2450 if (1) { no strict qw{refs};
2451 $expectation->is(q{expr14op})->at($text);
2452 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr14op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2453 {
2454
2455 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr14op]>>},
2456 Parse::RecDescent::_tracefirst($text),
2457 q{expr14},
2458 $tracelevel)
2459 if defined $::RD_TRACE;
2460 $expectation->failed();
2461 last;
2462 }
2463 Parse::RecDescent::_trace(q{>>Matched subrule: [expr14op]<< (return value: [}
2464 . $_tok . q{]},
2465
2466 Parse::RecDescent::_tracefirst($text),
2467 q{expr14},
2468 $tracelevel)
2469 if defined $::RD_TRACE;
2470 $item{q{expr14op}} = $_tok;
2471 push @item, $_tok;
2472
2473 }
2474  
2475 $backtrack=1;
2476
2477
2478 Parse::RecDescent::_trace(q{Trying subrule: [expr15]},
2479 Parse::RecDescent::_tracefirst($text),
2480 q{expr14},
2481 $tracelevel)
2482 if defined $::RD_TRACE;
2483 if (1) { no strict qw{refs};
2484 $expectation->is(q{expr15})->at($text);
2485 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr15($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2486 {
2487
2488 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr15]>>},
2489 Parse::RecDescent::_tracefirst($text),
2490 q{expr14},
2491 $tracelevel)
2492 if defined $::RD_TRACE;
2493 $expectation->failed();
2494 last;
2495 }
2496 Parse::RecDescent::_trace(q{>>Matched subrule: [expr15]<< (return value: [}
2497 . $_tok . q{]},
2498
2499 Parse::RecDescent::_tracefirst($text),
2500 q{expr14},
2501 $tracelevel)
2502 if defined $::RD_TRACE;
2503 $item{q{expr15}} = $_tok;
2504 push @item, $_tok;
2505
2506 }
2507  
2508 $savetext = $text;
2509 $repcount++;
2510 }
2511 $text = $savetext;
2512 pop @item if $backtrack;
2513  
2514 unless (@item) { undef $_tok; last }
2515 $_tok = [ @item ];
2516 last;
2517 }
2518  
2519 unless ($repcount>=1)
2520 {
2521 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr15 expr14op expr15>]>>},
2522 Parse::RecDescent::_tracefirst($text),
2523 q{expr14},
2524 $tracelevel)
2525 if defined $::RD_TRACE;
2526 $expectation->failed();
2527 last;
2528 }
2529 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr15 expr14op expr15>]<< (return value: [}
2530 . qq{@{$_tok||[]}} . q{]},
2531 Parse::RecDescent::_tracefirst($text),
2532 q{expr14},
2533 $tracelevel)
2534 if defined $::RD_TRACE;
2535  
2536 push @item, $item{__DIRECTIVE1__}=$_tok||[];
2537  
2538  
2539 Parse::RecDescent::_trace(q{Trying action},
2540 Parse::RecDescent::_tracefirst($text),
2541 q{expr14},
2542 $tracelevel)
2543 if defined $::RD_TRACE;
2544
2545  
2546 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
2547 unless (defined $_tok)
2548 {
2549 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2550 if defined $::RD_TRACE;
2551 last;
2552 }
2553 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2554 . $_tok . q{])},
2555 Parse::RecDescent::_tracefirst($text))
2556 if defined $::RD_TRACE;
2557 push @item, $_tok;
2558 $item{__ACTION1__}=$_tok;
2559
2560  
2561  
2562 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr15 expr14op expr15>]<<},
2563 Parse::RecDescent::_tracefirst($text),
2564 q{expr14},
2565 $tracelevel)
2566 if defined $::RD_TRACE;
2567 $_matched = 1;
2568 last;
2569 }
2570  
2571  
2572 unless ( $_matched || defined($score) )
2573 {
2574
2575  
2576 $_[1] = $text; # NOT SURE THIS IS NEEDED
2577 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2578 Parse::RecDescent::_tracefirst($_[1]),
2579 q{expr14},
2580 $tracelevel)
2581 if defined $::RD_TRACE;
2582 return undef;
2583 }
2584 if (!defined($return) && defined($score))
2585 {
2586 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2587 q{expr14},
2588 $tracelevel)
2589 if defined $::RD_TRACE;
2590 $return = $score_return;
2591 }
2592 splice @{$thisparser->{errors}}, $err_at;
2593 $return = $item[$#item] unless defined $return;
2594 if (defined $::RD_TRACE)
2595 {
2596 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2597 $return . q{])}, "",
2598 q{expr14},
2599 $tracelevel);
2600 Parse::RecDescent::_trace(q{(consumed: [} .
2601 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2602 Parse::RecDescent::_tracefirst($text),
2603 , q{expr14},
2604 $tracelevel)
2605 }
2606 $_[1] = $text;
2607 return $return;
2608 }
2609  
2610 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2611 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr6
2612 {
2613 my $thisparser = $_[0];
2614 use vars q{$tracelevel};
2615 local $tracelevel = ($tracelevel||0)+1;
2616 $ERRORS = 0;
2617 my $thisrule = $thisparser->{"rules"}{"expr6"};
2618
2619 Parse::RecDescent::_trace(q{Trying rule: [expr6]},
2620 Parse::RecDescent::_tracefirst($_[1]),
2621 q{expr6},
2622 $tracelevel)
2623 if defined $::RD_TRACE;
2624  
2625
2626 my $err_at = @{$thisparser->{errors}};
2627  
2628 my $score;
2629 my $score_return;
2630 my $_tok;
2631 my $return = undef;
2632 my $_matched=0;
2633 my $commit=0;
2634 my @item = ();
2635 my %item = ();
2636 my $repeating = defined($_[2]) && $_[2];
2637 my $_noactions = defined($_[3]) && $_[3];
2638 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2639 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2640 my $text;
2641 my $lastsep="";
2642 my $current_match;
2643 my $expectation = new Parse::RecDescent::Expectation(q{expr7});
2644 $expectation->at($_[1]);
2645
2646 my $thisline;
2647 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2648  
2649
2650  
2651 while (!$_matched && !$commit)
2652 {
2653
2654 Parse::RecDescent::_trace(q{Trying production: [expr7 '?' expr7 ':' expr6]},
2655 Parse::RecDescent::_tracefirst($_[1]),
2656 q{expr6},
2657 $tracelevel)
2658 if defined $::RD_TRACE;
2659 my $thisprod = $thisrule->{"prods"}[0];
2660 $text = $_[1];
2661 my $_savetext;
2662 @item = (q{expr6});
2663 %item = (__RULE__ => q{expr6});
2664 my $repcount = 0;
2665  
2666  
2667 Parse::RecDescent::_trace(q{Trying subrule: [expr7]},
2668 Parse::RecDescent::_tracefirst($text),
2669 q{expr6},
2670 $tracelevel)
2671 if defined $::RD_TRACE;
2672 if (1) { no strict qw{refs};
2673 $expectation->is(q{})->at($text);
2674 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr7($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2675 {
2676
2677 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr7]>>},
2678 Parse::RecDescent::_tracefirst($text),
2679 q{expr6},
2680 $tracelevel)
2681 if defined $::RD_TRACE;
2682 $expectation->failed();
2683 last;
2684 }
2685 Parse::RecDescent::_trace(q{>>Matched subrule: [expr7]<< (return value: [}
2686 . $_tok . q{]},
2687
2688 Parse::RecDescent::_tracefirst($text),
2689 q{expr6},
2690 $tracelevel)
2691 if defined $::RD_TRACE;
2692 $item{q{expr7}} = $_tok;
2693 push @item, $_tok;
2694
2695 }
2696  
2697 Parse::RecDescent::_trace(q{Trying terminal: ['?']},
2698 Parse::RecDescent::_tracefirst($text),
2699 q{expr6},
2700 $tracelevel)
2701 if defined $::RD_TRACE;
2702 $lastsep = "";
2703 $expectation->is(q{'?'})->at($text);
2704
2705  
2706 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "?"; 1 } and
2707 substr($text,0,length($_tok)) eq $_tok and
2708 do { substr($text,0,length($_tok)) = ""; 1; }
2709 )
2710 {
2711
2712 $expectation->failed();
2713 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2714 Parse::RecDescent::_tracefirst($text))
2715 if defined $::RD_TRACE;
2716 last;
2717 }
2718 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2719 . $_tok . q{])},
2720 Parse::RecDescent::_tracefirst($text))
2721 if defined $::RD_TRACE;
2722 push @item, $item{__STRING1__}=$_tok;
2723
2724  
2725 Parse::RecDescent::_trace(q{Trying subrule: [expr7]},
2726 Parse::RecDescent::_tracefirst($text),
2727 q{expr6},
2728 $tracelevel)
2729 if defined $::RD_TRACE;
2730 if (1) { no strict qw{refs};
2731 $expectation->is(q{expr7})->at($text);
2732 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr7($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2733 {
2734
2735 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr7]>>},
2736 Parse::RecDescent::_tracefirst($text),
2737 q{expr6},
2738 $tracelevel)
2739 if defined $::RD_TRACE;
2740 $expectation->failed();
2741 last;
2742 }
2743 Parse::RecDescent::_trace(q{>>Matched subrule: [expr7]<< (return value: [}
2744 . $_tok . q{]},
2745
2746 Parse::RecDescent::_tracefirst($text),
2747 q{expr6},
2748 $tracelevel)
2749 if defined $::RD_TRACE;
2750 $item{q{expr7}} = $_tok;
2751 push @item, $_tok;
2752
2753 }
2754  
2755 Parse::RecDescent::_trace(q{Trying terminal: [':']},
2756 Parse::RecDescent::_tracefirst($text),
2757 q{expr6},
2758 $tracelevel)
2759 if defined $::RD_TRACE;
2760 $lastsep = "";
2761 $expectation->is(q{':'})->at($text);
2762
2763  
2764 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = ":"; 1 } and
2765 substr($text,0,length($_tok)) eq $_tok and
2766 do { substr($text,0,length($_tok)) = ""; 1; }
2767 )
2768 {
2769
2770 $expectation->failed();
2771 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
2772 Parse::RecDescent::_tracefirst($text))
2773 if defined $::RD_TRACE;
2774 last;
2775 }
2776 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2777 . $_tok . q{])},
2778 Parse::RecDescent::_tracefirst($text))
2779 if defined $::RD_TRACE;
2780 push @item, $item{__STRING2__}=$_tok;
2781
2782  
2783 Parse::RecDescent::_trace(q{Trying subrule: [expr6]},
2784 Parse::RecDescent::_tracefirst($text),
2785 q{expr6},
2786 $tracelevel)
2787 if defined $::RD_TRACE;
2788 if (1) { no strict qw{refs};
2789 $expectation->is(q{expr6})->at($text);
2790 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr6($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2791 {
2792
2793 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr6]>>},
2794 Parse::RecDescent::_tracefirst($text),
2795 q{expr6},
2796 $tracelevel)
2797 if defined $::RD_TRACE;
2798 $expectation->failed();
2799 last;
2800 }
2801 Parse::RecDescent::_trace(q{>>Matched subrule: [expr6]<< (return value: [}
2802 . $_tok . q{]},
2803
2804 Parse::RecDescent::_tracefirst($text),
2805 q{expr6},
2806 $tracelevel)
2807 if defined $::RD_TRACE;
2808 $item{q{expr6}} = $_tok;
2809 push @item, $_tok;
2810
2811 }
2812  
2813 Parse::RecDescent::_trace(q{Trying action},
2814 Parse::RecDescent::_tracefirst($text),
2815 q{expr6},
2816 $tracelevel)
2817 if defined $::RD_TRACE;
2818
2819  
2820 $_tok = ($_noactions) ? 0 : do { db(@item); sub { run($item[1]) ? run($item[3]) : run($item[5]) } };
2821 unless (defined $_tok)
2822 {
2823 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2824 if defined $::RD_TRACE;
2825 last;
2826 }
2827 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2828 . $_tok . q{])},
2829 Parse::RecDescent::_tracefirst($text))
2830 if defined $::RD_TRACE;
2831 push @item, $_tok;
2832 $item{__ACTION1__}=$_tok;
2833
2834  
2835  
2836 Parse::RecDescent::_trace(q{>>Matched production: [expr7 '?' expr7 ':' expr6]<<},
2837 Parse::RecDescent::_tracefirst($text),
2838 q{expr6},
2839 $tracelevel)
2840 if defined $::RD_TRACE;
2841 $_matched = 1;
2842 last;
2843 }
2844  
2845  
2846 while (!$_matched && !$commit)
2847 {
2848
2849 Parse::RecDescent::_trace(q{Trying production: [expr7]},
2850 Parse::RecDescent::_tracefirst($_[1]),
2851 q{expr6},
2852 $tracelevel)
2853 if defined $::RD_TRACE;
2854 my $thisprod = $thisrule->{"prods"}[1];
2855 $text = $_[1];
2856 my $_savetext;
2857 @item = (q{expr6});
2858 %item = (__RULE__ => q{expr6});
2859 my $repcount = 0;
2860  
2861  
2862 Parse::RecDescent::_trace(q{Trying subrule: [expr7]},
2863 Parse::RecDescent::_tracefirst($text),
2864 q{expr6},
2865 $tracelevel)
2866 if defined $::RD_TRACE;
2867 if (1) { no strict qw{refs};
2868 $expectation->is(q{})->at($text);
2869 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr7($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2870 {
2871
2872 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr7]>>},
2873 Parse::RecDescent::_tracefirst($text),
2874 q{expr6},
2875 $tracelevel)
2876 if defined $::RD_TRACE;
2877 $expectation->failed();
2878 last;
2879 }
2880 Parse::RecDescent::_trace(q{>>Matched subrule: [expr7]<< (return value: [}
2881 . $_tok . q{]},
2882
2883 Parse::RecDescent::_tracefirst($text),
2884 q{expr6},
2885 $tracelevel)
2886 if defined $::RD_TRACE;
2887 $item{q{expr7}} = $_tok;
2888 push @item, $_tok;
2889
2890 }
2891  
2892 Parse::RecDescent::_trace(q{Trying action},
2893 Parse::RecDescent::_tracefirst($text),
2894 q{expr6},
2895 $tracelevel)
2896 if defined $::RD_TRACE;
2897
2898  
2899 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
2900 unless (defined $_tok)
2901 {
2902 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
2903 if defined $::RD_TRACE;
2904 last;
2905 }
2906 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2907 . $_tok . q{])},
2908 Parse::RecDescent::_tracefirst($text))
2909 if defined $::RD_TRACE;
2910 push @item, $_tok;
2911 $item{__ACTION1__}=$_tok;
2912
2913  
2914  
2915 Parse::RecDescent::_trace(q{>>Matched production: [expr7]<<},
2916 Parse::RecDescent::_tracefirst($text),
2917 q{expr6},
2918 $tracelevel)
2919 if defined $::RD_TRACE;
2920 $_matched = 1;
2921 last;
2922 }
2923  
2924  
2925 unless ( $_matched || defined($score) )
2926 {
2927
2928  
2929 $_[1] = $text; # NOT SURE THIS IS NEEDED
2930 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
2931 Parse::RecDescent::_tracefirst($_[1]),
2932 q{expr6},
2933 $tracelevel)
2934 if defined $::RD_TRACE;
2935 return undef;
2936 }
2937 if (!defined($return) && defined($score))
2938 {
2939 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2940 q{expr6},
2941 $tracelevel)
2942 if defined $::RD_TRACE;
2943 $return = $score_return;
2944 }
2945 splice @{$thisparser->{errors}}, $err_at;
2946 $return = $item[$#item] unless defined $return;
2947 if (defined $::RD_TRACE)
2948 {
2949 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2950 $return . q{])}, "",
2951 q{expr6},
2952 $tracelevel);
2953 Parse::RecDescent::_trace(q{(consumed: [} .
2954 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2955 Parse::RecDescent::_tracefirst($text),
2956 , q{expr6},
2957 $tracelevel)
2958 }
2959 $_[1] = $text;
2960 return $return;
2961 }
2962  
2963 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2964 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr13op
2965 {
2966 my $thisparser = $_[0];
2967 use vars q{$tracelevel};
2968 local $tracelevel = ($tracelevel||0)+1;
2969 $ERRORS = 0;
2970 my $thisrule = $thisparser->{"rules"}{"expr13op"};
2971
2972 Parse::RecDescent::_trace(q{Trying rule: [expr13op]},
2973 Parse::RecDescent::_tracefirst($_[1]),
2974 q{expr13op},
2975 $tracelevel)
2976 if defined $::RD_TRACE;
2977  
2978
2979 my $err_at = @{$thisparser->{errors}};
2980  
2981 my $score;
2982 my $score_return;
2983 my $_tok;
2984 my $return = undef;
2985 my $_matched=0;
2986 my $commit=0;
2987 my @item = ();
2988 my %item = ();
2989 my $repeating = defined($_[2]) && $_[2];
2990 my $_noactions = defined($_[3]) && $_[3];
2991 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2992 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2993 my $text;
2994 my $lastsep="";
2995 my $current_match;
2996 my $expectation = new Parse::RecDescent::Expectation(q{/(<<|>>)/});
2997 $expectation->at($_[1]);
2998
2999 my $thisline;
3000 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3001  
3002
3003  
3004 while (!$_matched && !$commit)
3005 {
3006
3007 Parse::RecDescent::_trace(q{Trying production: [/(<<|>>)/]},
3008 Parse::RecDescent::_tracefirst($_[1]),
3009 q{expr13op},
3010 $tracelevel)
3011 if defined $::RD_TRACE;
3012 my $thisprod = $thisrule->{"prods"}[0];
3013 $text = $_[1];
3014 my $_savetext;
3015 @item = (q{expr13op});
3016 %item = (__RULE__ => q{expr13op});
3017 my $repcount = 0;
3018  
3019  
3020 Parse::RecDescent::_trace(q{Trying terminal: [/(<<|>>)/]}, Parse::RecDescent::_tracefirst($text),
3021 q{expr13op},
3022 $tracelevel)
3023 if defined $::RD_TRACE;
3024 $lastsep = "";
3025 $expectation->is(q{})->at($text);
3026
3027  
3028 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(<<|>>))/)
3029 {
3030
3031 $expectation->failed();
3032 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3033 Parse::RecDescent::_tracefirst($text))
3034 if defined $::RD_TRACE;
3035  
3036 last;
3037 }
3038 $current_match = substr($text, $-[0], $+[0] - $-[0]);
3039 substr($text,0,length($current_match),q{});
3040 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3041 . $current_match . q{])},
3042 Parse::RecDescent::_tracefirst($text))
3043 if defined $::RD_TRACE;
3044 push @item, $item{__PATTERN1__}=$current_match;
3045
3046  
3047 Parse::RecDescent::_trace(q{Trying action},
3048 Parse::RecDescent::_tracefirst($text),
3049 q{expr13op},
3050 $tracelevel)
3051 if defined $::RD_TRACE;
3052
3053  
3054 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
3055 unless (defined $_tok)
3056 {
3057 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3058 if defined $::RD_TRACE;
3059 last;
3060 }
3061 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3062 . $_tok . q{])},
3063 Parse::RecDescent::_tracefirst($text))
3064 if defined $::RD_TRACE;
3065 push @item, $_tok;
3066 $item{__ACTION1__}=$_tok;
3067
3068  
3069  
3070 Parse::RecDescent::_trace(q{>>Matched production: [/(<<|>>)/]<<},
3071 Parse::RecDescent::_tracefirst($text),
3072 q{expr13op},
3073 $tracelevel)
3074 if defined $::RD_TRACE;
3075 $_matched = 1;
3076 last;
3077 }
3078  
3079  
3080 unless ( $_matched || defined($score) )
3081 {
3082
3083  
3084 $_[1] = $text; # NOT SURE THIS IS NEEDED
3085 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3086 Parse::RecDescent::_tracefirst($_[1]),
3087 q{expr13op},
3088 $tracelevel)
3089 if defined $::RD_TRACE;
3090 return undef;
3091 }
3092 if (!defined($return) && defined($score))
3093 {
3094 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3095 q{expr13op},
3096 $tracelevel)
3097 if defined $::RD_TRACE;
3098 $return = $score_return;
3099 }
3100 splice @{$thisparser->{errors}}, $err_at;
3101 $return = $item[$#item] unless defined $return;
3102 if (defined $::RD_TRACE)
3103 {
3104 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3105 $return . q{])}, "",
3106 q{expr13op},
3107 $tracelevel);
3108 Parse::RecDescent::_trace(q{(consumed: [} .
3109 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3110 Parse::RecDescent::_tracefirst($text),
3111 , q{expr13op},
3112 $tracelevel)
3113 }
3114 $_[1] = $text;
3115 return $return;
3116 }
3117  
3118 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3119 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr8op
3120 {
3121 my $thisparser = $_[0];
3122 use vars q{$tracelevel};
3123 local $tracelevel = ($tracelevel||0)+1;
3124 $ERRORS = 0;
3125 my $thisrule = $thisparser->{"rules"}{"expr8op"};
3126
3127 Parse::RecDescent::_trace(q{Trying rule: [expr8op]},
3128 Parse::RecDescent::_tracefirst($_[1]),
3129 q{expr8op},
3130 $tracelevel)
3131 if defined $::RD_TRACE;
3132  
3133
3134 my $err_at = @{$thisparser->{errors}};
3135  
3136 my $score;
3137 my $score_return;
3138 my $_tok;
3139 my $return = undef;
3140 my $_matched=0;
3141 my $commit=0;
3142 my @item = ();
3143 my %item = ();
3144 my $repeating = defined($_[2]) && $_[2];
3145 my $_noactions = defined($_[3]) && $_[3];
3146 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3147 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3148 my $text;
3149 my $lastsep="";
3150 my $current_match;
3151 my $expectation = new Parse::RecDescent::Expectation(q{'&&'});
3152 $expectation->at($_[1]);
3153
3154 my $thisline;
3155 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3156  
3157
3158  
3159 while (!$_matched && !$commit)
3160 {
3161
3162 Parse::RecDescent::_trace(q{Trying production: ['&&']},
3163 Parse::RecDescent::_tracefirst($_[1]),
3164 q{expr8op},
3165 $tracelevel)
3166 if defined $::RD_TRACE;
3167 my $thisprod = $thisrule->{"prods"}[0];
3168 $text = $_[1];
3169 my $_savetext;
3170 @item = (q{expr8op});
3171 %item = (__RULE__ => q{expr8op});
3172 my $repcount = 0;
3173  
3174  
3175 Parse::RecDescent::_trace(q{Trying terminal: ['&&']},
3176 Parse::RecDescent::_tracefirst($text),
3177 q{expr8op},
3178 $tracelevel)
3179 if defined $::RD_TRACE;
3180 $lastsep = "";
3181 $expectation->is(q{})->at($text);
3182
3183  
3184 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "&&"; 1 } and
3185 substr($text,0,length($_tok)) eq $_tok and
3186 do { substr($text,0,length($_tok)) = ""; 1; }
3187 )
3188 {
3189
3190 $expectation->failed();
3191 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3192 Parse::RecDescent::_tracefirst($text))
3193 if defined $::RD_TRACE;
3194 last;
3195 }
3196 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3197 . $_tok . q{])},
3198 Parse::RecDescent::_tracefirst($text))
3199 if defined $::RD_TRACE;
3200 push @item, $item{__STRING1__}=$_tok;
3201
3202  
3203 Parse::RecDescent::_trace(q{Trying action},
3204 Parse::RecDescent::_tracefirst($text),
3205 q{expr8op},
3206 $tracelevel)
3207 if defined $::RD_TRACE;
3208
3209  
3210 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
3211 unless (defined $_tok)
3212 {
3213 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3214 if defined $::RD_TRACE;
3215 last;
3216 }
3217 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3218 . $_tok . q{])},
3219 Parse::RecDescent::_tracefirst($text))
3220 if defined $::RD_TRACE;
3221 push @item, $_tok;
3222 $item{__ACTION1__}=$_tok;
3223
3224  
3225  
3226 Parse::RecDescent::_trace(q{>>Matched production: ['&&']<<},
3227 Parse::RecDescent::_tracefirst($text),
3228 q{expr8op},
3229 $tracelevel)
3230 if defined $::RD_TRACE;
3231 $_matched = 1;
3232 last;
3233 }
3234  
3235  
3236 unless ( $_matched || defined($score) )
3237 {
3238
3239  
3240 $_[1] = $text; # NOT SURE THIS IS NEEDED
3241 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3242 Parse::RecDescent::_tracefirst($_[1]),
3243 q{expr8op},
3244 $tracelevel)
3245 if defined $::RD_TRACE;
3246 return undef;
3247 }
3248 if (!defined($return) && defined($score))
3249 {
3250 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3251 q{expr8op},
3252 $tracelevel)
3253 if defined $::RD_TRACE;
3254 $return = $score_return;
3255 }
3256 splice @{$thisparser->{errors}}, $err_at;
3257 $return = $item[$#item] unless defined $return;
3258 if (defined $::RD_TRACE)
3259 {
3260 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3261 $return . q{])}, "",
3262 q{expr8op},
3263 $tracelevel);
3264 Parse::RecDescent::_trace(q{(consumed: [} .
3265 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3266 Parse::RecDescent::_tracefirst($text),
3267 , q{expr8op},
3268 $tracelevel)
3269 }
3270 $_[1] = $text;
3271 return $return;
3272 }
3273  
3274 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3275 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::macro
3276 {
3277 my $thisparser = $_[0];
3278 use vars q{$tracelevel};
3279 local $tracelevel = ($tracelevel||0)+1;
3280 $ERRORS = 0;
3281 my $thisrule = $thisparser->{"rules"}{"macro"};
3282
3283 Parse::RecDescent::_trace(q{Trying rule: [macro]},
3284 Parse::RecDescent::_tracefirst($_[1]),
3285 q{macro},
3286 $tracelevel)
3287 if defined $::RD_TRACE;
3288  
3289
3290 my $err_at = @{$thisparser->{errors}};
3291  
3292 my $score;
3293 my $score_return;
3294 my $_tok;
3295 my $return = undef;
3296 my $_matched=0;
3297 my $commit=0;
3298 my @item = ();
3299 my %item = ();
3300 my $repeating = defined($_[2]) && $_[2];
3301 my $_noactions = defined($_[3]) && $_[3];
3302 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3303 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3304 my $text;
3305 my $lastsep="";
3306 my $current_match;
3307 my $expectation = new Parse::RecDescent::Expectation(q{/<macro (?: [^'">] | '[^'<>]*' | "[^"<>]*" )* >/x});
3308 $expectation->at($_[1]);
3309
3310 my $thisline;
3311 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3312  
3313
3314  
3315 while (!$_matched && !$commit)
3316 {
3317
3318 Parse::RecDescent::_trace(q{Trying production: [/<macro (?: [^'">] | '[^'<>]*' | "[^"<>]*" )* >/x]},
3319 Parse::RecDescent::_tracefirst($_[1]),
3320 q{macro},
3321 $tracelevel)
3322 if defined $::RD_TRACE;
3323 my $thisprod = $thisrule->{"prods"}[0];
3324 $text = $_[1];
3325 my $_savetext;
3326 @item = (q{macro});
3327 %item = (__RULE__ => q{macro});
3328 my $repcount = 0;
3329  
3330  
3331 Parse::RecDescent::_trace(q{Trying terminal: [/<macro (?: [^'">] | '[^'<>]*' | "[^"<>]*" )* >/x]}, Parse::RecDescent::_tracefirst($text),
3332 q{macro},
3333 $tracelevel)
3334 if defined $::RD_TRACE;
3335 $lastsep = "";
3336 $expectation->is(q{})->at($text);
3337
3338  
3339 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:<macro (?: [^'">] | '[^'<>]*' | "[^"<>]*" )* >)/x)
3340 {
3341
3342 $expectation->failed();
3343 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3344 Parse::RecDescent::_tracefirst($text))
3345 if defined $::RD_TRACE;
3346  
3347 last;
3348 }
3349 $current_match = substr($text, $-[0], $+[0] - $-[0]);
3350 substr($text,0,length($current_match),q{});
3351 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3352 . $current_match . q{])},
3353 Parse::RecDescent::_tracefirst($text))
3354 if defined $::RD_TRACE;
3355 push @item, $item{__PATTERN1__}=$current_match;
3356
3357  
3358 Parse::RecDescent::_trace(q{Trying action},
3359 Parse::RecDescent::_tracefirst($text),
3360 q{macro},
3361 $tracelevel)
3362 if defined $::RD_TRACE;
3363
3364  
3365 $_tok = ($_noactions) ? 0 : do {
3366 db(@item);
3367 my $buf = HTML::Transmorgify::compile($HTML::Transmorgify::modules, \$item[1]);
3368 $return = sub {
3369 local(@rtmp) = ( '' );
3370 run($buf, \@rtmp);
3371 return $rtmp[0];
3372 };
3373 };
3374 unless (defined $_tok)
3375 {
3376 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3377 if defined $::RD_TRACE;
3378 last;
3379 }
3380 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3381 . $_tok . q{])},
3382 Parse::RecDescent::_tracefirst($text))
3383 if defined $::RD_TRACE;
3384 push @item, $_tok;
3385 $item{__ACTION1__}=$_tok;
3386
3387  
3388  
3389 Parse::RecDescent::_trace(q{>>Matched production: [/<macro (?: [^'">] | '[^'<>]*' | "[^"<>]*" )* >/x]<<},
3390 Parse::RecDescent::_tracefirst($text),
3391 q{macro},
3392 $tracelevel)
3393 if defined $::RD_TRACE;
3394 $_matched = 1;
3395 last;
3396 }
3397  
3398  
3399 unless ( $_matched || defined($score) )
3400 {
3401
3402  
3403 $_[1] = $text; # NOT SURE THIS IS NEEDED
3404 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3405 Parse::RecDescent::_tracefirst($_[1]),
3406 q{macro},
3407 $tracelevel)
3408 if defined $::RD_TRACE;
3409 return undef;
3410 }
3411 if (!defined($return) && defined($score))
3412 {
3413 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3414 q{macro},
3415 $tracelevel)
3416 if defined $::RD_TRACE;
3417 $return = $score_return;
3418 }
3419 splice @{$thisparser->{errors}}, $err_at;
3420 $return = $item[$#item] unless defined $return;
3421 if (defined $::RD_TRACE)
3422 {
3423 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3424 $return . q{])}, "",
3425 q{macro},
3426 $tracelevel);
3427 Parse::RecDescent::_trace(q{(consumed: [} .
3428 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3429 Parse::RecDescent::_tracefirst($text),
3430 , q{macro},
3431 $tracelevel)
3432 }
3433 $_[1] = $text;
3434 return $return;
3435 }
3436  
3437 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3438 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr16op
3439 {
3440 my $thisparser = $_[0];
3441 use vars q{$tracelevel};
3442 local $tracelevel = ($tracelevel||0)+1;
3443 $ERRORS = 0;
3444 my $thisrule = $thisparser->{"rules"}{"expr16op"};
3445
3446 Parse::RecDescent::_trace(q{Trying rule: [expr16op]},
3447 Parse::RecDescent::_tracefirst($_[1]),
3448 q{expr16op},
3449 $tracelevel)
3450 if defined $::RD_TRACE;
3451  
3452
3453 my $err_at = @{$thisparser->{errors}};
3454  
3455 my $score;
3456 my $score_return;
3457 my $_tok;
3458 my $return = undef;
3459 my $_matched=0;
3460 my $commit=0;
3461 my @item = ();
3462 my %item = ();
3463 my $repeating = defined($_[2]) && $_[2];
3464 my $_noactions = defined($_[3]) && $_[3];
3465 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3466 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3467 my $text;
3468 my $lastsep="";
3469 my $current_match;
3470 my $expectation = new Parse::RecDescent::Expectation(q{/(=~|\\!~)/});
3471 $expectation->at($_[1]);
3472
3473 my $thisline;
3474 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3475  
3476
3477  
3478 while (!$_matched && !$commit)
3479 {
3480
3481 Parse::RecDescent::_trace(q{Trying production: [/(=~|\\!~)/]},
3482 Parse::RecDescent::_tracefirst($_[1]),
3483 q{expr16op},
3484 $tracelevel)
3485 if defined $::RD_TRACE;
3486 my $thisprod = $thisrule->{"prods"}[0];
3487 $text = $_[1];
3488 my $_savetext;
3489 @item = (q{expr16op});
3490 %item = (__RULE__ => q{expr16op});
3491 my $repcount = 0;
3492  
3493  
3494 Parse::RecDescent::_trace(q{Trying terminal: [/(=~|\\!~)/]}, Parse::RecDescent::_tracefirst($text),
3495 q{expr16op},
3496 $tracelevel)
3497 if defined $::RD_TRACE;
3498 $lastsep = "";
3499 $expectation->is(q{})->at($text);
3500
3501  
3502 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(=~|\!~))/)
3503 {
3504
3505 $expectation->failed();
3506 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3507 Parse::RecDescent::_tracefirst($text))
3508 if defined $::RD_TRACE;
3509  
3510 last;
3511 }
3512 $current_match = substr($text, $-[0], $+[0] - $-[0]);
3513 substr($text,0,length($current_match),q{});
3514 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3515 . $current_match . q{])},
3516 Parse::RecDescent::_tracefirst($text))
3517 if defined $::RD_TRACE;
3518 push @item, $item{__PATTERN1__}=$current_match;
3519
3520  
3521 Parse::RecDescent::_trace(q{Trying action},
3522 Parse::RecDescent::_tracefirst($text),
3523 q{expr16op},
3524 $tracelevel)
3525 if defined $::RD_TRACE;
3526
3527  
3528 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
3529 unless (defined $_tok)
3530 {
3531 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3532 if defined $::RD_TRACE;
3533 last;
3534 }
3535 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3536 . $_tok . q{])},
3537 Parse::RecDescent::_tracefirst($text))
3538 if defined $::RD_TRACE;
3539 push @item, $_tok;
3540 $item{__ACTION1__}=$_tok;
3541
3542  
3543  
3544 Parse::RecDescent::_trace(q{>>Matched production: [/(=~|\\!~)/]<<},
3545 Parse::RecDescent::_tracefirst($text),
3546 q{expr16op},
3547 $tracelevel)
3548 if defined $::RD_TRACE;
3549 $_matched = 1;
3550 last;
3551 }
3552  
3553  
3554 unless ( $_matched || defined($score) )
3555 {
3556
3557  
3558 $_[1] = $text; # NOT SURE THIS IS NEEDED
3559 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3560 Parse::RecDescent::_tracefirst($_[1]),
3561 q{expr16op},
3562 $tracelevel)
3563 if defined $::RD_TRACE;
3564 return undef;
3565 }
3566 if (!defined($return) && defined($score))
3567 {
3568 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3569 q{expr16op},
3570 $tracelevel)
3571 if defined $::RD_TRACE;
3572 $return = $score_return;
3573 }
3574 splice @{$thisparser->{errors}}, $err_at;
3575 $return = $item[$#item] unless defined $return;
3576 if (defined $::RD_TRACE)
3577 {
3578 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3579 $return . q{])}, "",
3580 q{expr16op},
3581 $tracelevel);
3582 Parse::RecDescent::_trace(q{(consumed: [} .
3583 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3584 Parse::RecDescent::_tracefirst($text),
3585 , q{expr16op},
3586 $tracelevel)
3587 }
3588 $_[1] = $text;
3589 return $return;
3590 }
3591  
3592 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3593 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr10op
3594 {
3595 my $thisparser = $_[0];
3596 use vars q{$tracelevel};
3597 local $tracelevel = ($tracelevel||0)+1;
3598 $ERRORS = 0;
3599 my $thisrule = $thisparser->{"rules"}{"expr10op"};
3600
3601 Parse::RecDescent::_trace(q{Trying rule: [expr10op]},
3602 Parse::RecDescent::_tracefirst($_[1]),
3603 q{expr10op},
3604 $tracelevel)
3605 if defined $::RD_TRACE;
3606  
3607
3608 my $err_at = @{$thisparser->{errors}};
3609  
3610 my $score;
3611 my $score_return;
3612 my $_tok;
3613 my $return = undef;
3614 my $_matched=0;
3615 my $commit=0;
3616 my @item = ();
3617 my %item = ();
3618 my $repeating = defined($_[2]) && $_[2];
3619 my $_noactions = defined($_[3]) && $_[3];
3620 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3621 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3622 my $text;
3623 my $lastsep="";
3624 my $current_match;
3625 my $expectation = new Parse::RecDescent::Expectation(q{/(\\&)/});
3626 $expectation->at($_[1]);
3627
3628 my $thisline;
3629 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3630  
3631
3632  
3633 while (!$_matched && !$commit)
3634 {
3635
3636 Parse::RecDescent::_trace(q{Trying production: [/(\\&)/]},
3637 Parse::RecDescent::_tracefirst($_[1]),
3638 q{expr10op},
3639 $tracelevel)
3640 if defined $::RD_TRACE;
3641 my $thisprod = $thisrule->{"prods"}[0];
3642 $text = $_[1];
3643 my $_savetext;
3644 @item = (q{expr10op});
3645 %item = (__RULE__ => q{expr10op});
3646 my $repcount = 0;
3647  
3648  
3649 Parse::RecDescent::_trace(q{Trying terminal: [/(\\&)/]}, Parse::RecDescent::_tracefirst($text),
3650 q{expr10op},
3651 $tracelevel)
3652 if defined $::RD_TRACE;
3653 $lastsep = "";
3654 $expectation->is(q{})->at($text);
3655
3656  
3657 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(\&))/)
3658 {
3659
3660 $expectation->failed();
3661 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3662 Parse::RecDescent::_tracefirst($text))
3663 if defined $::RD_TRACE;
3664  
3665 last;
3666 }
3667 $current_match = substr($text, $-[0], $+[0] - $-[0]);
3668 substr($text,0,length($current_match),q{});
3669 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3670 . $current_match . q{])},
3671 Parse::RecDescent::_tracefirst($text))
3672 if defined $::RD_TRACE;
3673 push @item, $item{__PATTERN1__}=$current_match;
3674
3675  
3676 Parse::RecDescent::_trace(q{Trying action},
3677 Parse::RecDescent::_tracefirst($text),
3678 q{expr10op},
3679 $tracelevel)
3680 if defined $::RD_TRACE;
3681
3682  
3683 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
3684 unless (defined $_tok)
3685 {
3686 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3687 if defined $::RD_TRACE;
3688 last;
3689 }
3690 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3691 . $_tok . q{])},
3692 Parse::RecDescent::_tracefirst($text))
3693 if defined $::RD_TRACE;
3694 push @item, $_tok;
3695 $item{__ACTION1__}=$_tok;
3696
3697  
3698  
3699 Parse::RecDescent::_trace(q{>>Matched production: [/(\\&)/]<<},
3700 Parse::RecDescent::_tracefirst($text),
3701 q{expr10op},
3702 $tracelevel)
3703 if defined $::RD_TRACE;
3704 $_matched = 1;
3705 last;
3706 }
3707  
3708  
3709 unless ( $_matched || defined($score) )
3710 {
3711
3712  
3713 $_[1] = $text; # NOT SURE THIS IS NEEDED
3714 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3715 Parse::RecDescent::_tracefirst($_[1]),
3716 q{expr10op},
3717 $tracelevel)
3718 if defined $::RD_TRACE;
3719 return undef;
3720 }
3721 if (!defined($return) && defined($score))
3722 {
3723 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3724 q{expr10op},
3725 $tracelevel)
3726 if defined $::RD_TRACE;
3727 $return = $score_return;
3728 }
3729 splice @{$thisparser->{errors}}, $err_at;
3730 $return = $item[$#item] unless defined $return;
3731 if (defined $::RD_TRACE)
3732 {
3733 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3734 $return . q{])}, "",
3735 q{expr10op},
3736 $tracelevel);
3737 Parse::RecDescent::_trace(q{(consumed: [} .
3738 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3739 Parse::RecDescent::_tracefirst($text),
3740 , q{expr10op},
3741 $tracelevel)
3742 }
3743 $_[1] = $text;
3744 return $return;
3745 }
3746  
3747 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3748 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr11op
3749 {
3750 my $thisparser = $_[0];
3751 use vars q{$tracelevel};
3752 local $tracelevel = ($tracelevel||0)+1;
3753 $ERRORS = 0;
3754 my $thisrule = $thisparser->{"rules"}{"expr11op"};
3755
3756 Parse::RecDescent::_trace(q{Trying rule: [expr11op]},
3757 Parse::RecDescent::_tracefirst($_[1]),
3758 q{expr11op},
3759 $tracelevel)
3760 if defined $::RD_TRACE;
3761  
3762
3763 my $err_at = @{$thisparser->{errors}};
3764  
3765 my $score;
3766 my $score_return;
3767 my $_tok;
3768 my $return = undef;
3769 my $_matched=0;
3770 my $commit=0;
3771 my @item = ();
3772 my %item = ();
3773 my $repeating = defined($_[2]) && $_[2];
3774 my $_noactions = defined($_[3]) && $_[3];
3775 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3776 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3777 my $text;
3778 my $lastsep="";
3779 my $current_match;
3780 my $expectation = new Parse::RecDescent::Expectation(q{/(==|\\!=|<=>|eq|ne|cmp)/});
3781 $expectation->at($_[1]);
3782
3783 my $thisline;
3784 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3785  
3786
3787  
3788 while (!$_matched && !$commit)
3789 {
3790
3791 Parse::RecDescent::_trace(q{Trying production: [/(==|\\!=|<=>|eq|ne|cmp)/]},
3792 Parse::RecDescent::_tracefirst($_[1]),
3793 q{expr11op},
3794 $tracelevel)
3795 if defined $::RD_TRACE;
3796 my $thisprod = $thisrule->{"prods"}[0];
3797 $text = $_[1];
3798 my $_savetext;
3799 @item = (q{expr11op});
3800 %item = (__RULE__ => q{expr11op});
3801 my $repcount = 0;
3802  
3803  
3804 Parse::RecDescent::_trace(q{Trying terminal: [/(==|\\!=|<=>|eq|ne|cmp)/]}, Parse::RecDescent::_tracefirst($text),
3805 q{expr11op},
3806 $tracelevel)
3807 if defined $::RD_TRACE;
3808 $lastsep = "";
3809 $expectation->is(q{})->at($text);
3810
3811  
3812 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(==|\!=|<=>|eq|ne|cmp))/)
3813 {
3814
3815 $expectation->failed();
3816 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3817 Parse::RecDescent::_tracefirst($text))
3818 if defined $::RD_TRACE;
3819  
3820 last;
3821 }
3822 $current_match = substr($text, $-[0], $+[0] - $-[0]);
3823 substr($text,0,length($current_match),q{});
3824 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3825 . $current_match . q{])},
3826 Parse::RecDescent::_tracefirst($text))
3827 if defined $::RD_TRACE;
3828 push @item, $item{__PATTERN1__}=$current_match;
3829
3830  
3831 Parse::RecDescent::_trace(q{Trying action},
3832 Parse::RecDescent::_tracefirst($text),
3833 q{expr11op},
3834 $tracelevel)
3835 if defined $::RD_TRACE;
3836
3837  
3838 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
3839 unless (defined $_tok)
3840 {
3841 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
3842 if defined $::RD_TRACE;
3843 last;
3844 }
3845 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3846 . $_tok . q{])},
3847 Parse::RecDescent::_tracefirst($text))
3848 if defined $::RD_TRACE;
3849 push @item, $_tok;
3850 $item{__ACTION1__}=$_tok;
3851
3852  
3853  
3854 Parse::RecDescent::_trace(q{>>Matched production: [/(==|\\!=|<=>|eq|ne|cmp)/]<<},
3855 Parse::RecDescent::_tracefirst($text),
3856 q{expr11op},
3857 $tracelevel)
3858 if defined $::RD_TRACE;
3859 $_matched = 1;
3860 last;
3861 }
3862  
3863  
3864 unless ( $_matched || defined($score) )
3865 {
3866
3867  
3868 $_[1] = $text; # NOT SURE THIS IS NEEDED
3869 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
3870 Parse::RecDescent::_tracefirst($_[1]),
3871 q{expr11op},
3872 $tracelevel)
3873 if defined $::RD_TRACE;
3874 return undef;
3875 }
3876 if (!defined($return) && defined($score))
3877 {
3878 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3879 q{expr11op},
3880 $tracelevel)
3881 if defined $::RD_TRACE;
3882 $return = $score_return;
3883 }
3884 splice @{$thisparser->{errors}}, $err_at;
3885 $return = $item[$#item] unless defined $return;
3886 if (defined $::RD_TRACE)
3887 {
3888 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3889 $return . q{])}, "",
3890 q{expr11op},
3891 $tracelevel);
3892 Parse::RecDescent::_trace(q{(consumed: [} .
3893 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3894 Parse::RecDescent::_tracefirst($text),
3895 , q{expr11op},
3896 $tracelevel)
3897 }
3898 $_[1] = $text;
3899 return $return;
3900 }
3901  
3902 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3903 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::function
3904 {
3905 my $thisparser = $_[0];
3906 use vars q{$tracelevel};
3907 local $tracelevel = ($tracelevel||0)+1;
3908 $ERRORS = 0;
3909 my $thisrule = $thisparser->{"rules"}{"function"};
3910
3911 Parse::RecDescent::_trace(q{Trying rule: [function]},
3912 Parse::RecDescent::_tracefirst($_[1]),
3913 q{function},
3914 $tracelevel)
3915 if defined $::RD_TRACE;
3916  
3917
3918 my $err_at = @{$thisparser->{errors}};
3919  
3920 my $score;
3921 my $score_return;
3922 my $_tok;
3923 my $return = undef;
3924 my $_matched=0;
3925 my $commit=0;
3926 my @item = ();
3927 my %item = ();
3928 my $repeating = defined($_[2]) && $_[2];
3929 my $_noactions = defined($_[3]) && $_[3];
3930 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3931 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3932 my $text;
3933 my $lastsep="";
3934 my $current_match;
3935 my $expectation = new Parse::RecDescent::Expectation(q{/[A-Za-z_](?:\\w|::(?=[^:]))*/});
3936 $expectation->at($_[1]);
3937
3938 my $thisline;
3939 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3940  
3941
3942  
3943 while (!$_matched && !$commit)
3944 {
3945
3946 Parse::RecDescent::_trace(q{Trying production: [/[A-Za-z_](?:\\w|::(?=[^:]))*/ '(' <leftop: expr /,/ expr> ')']},
3947 Parse::RecDescent::_tracefirst($_[1]),
3948 q{function},
3949 $tracelevel)
3950 if defined $::RD_TRACE;
3951 my $thisprod = $thisrule->{"prods"}[0];
3952 $text = $_[1];
3953 my $_savetext;
3954 @item = (q{function});
3955 %item = (__RULE__ => q{function});
3956 my $repcount = 0;
3957  
3958  
3959 Parse::RecDescent::_trace(q{Trying terminal: [/[A-Za-z_](?:\\w|::(?=[^:]))*/]}, Parse::RecDescent::_tracefirst($text),
3960 q{function},
3961 $tracelevel)
3962 if defined $::RD_TRACE;
3963 $lastsep = "";
3964 $expectation->is(q{})->at($text);
3965
3966  
3967 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[A-Za-z_](?:\w|::(?=[^:]))*)/)
3968 {
3969
3970 $expectation->failed();
3971 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
3972 Parse::RecDescent::_tracefirst($text))
3973 if defined $::RD_TRACE;
3974  
3975 last;
3976 }
3977 $current_match = substr($text, $-[0], $+[0] - $-[0]);
3978 substr($text,0,length($current_match),q{});
3979 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3980 . $current_match . q{])},
3981 Parse::RecDescent::_tracefirst($text))
3982 if defined $::RD_TRACE;
3983 push @item, $item{__PATTERN1__}=$current_match;
3984
3985  
3986 Parse::RecDescent::_trace(q{Trying terminal: ['(']},
3987 Parse::RecDescent::_tracefirst($text),
3988 q{function},
3989 $tracelevel)
3990 if defined $::RD_TRACE;
3991 $lastsep = "";
3992 $expectation->is(q{'('})->at($text);
3993
3994  
3995 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
3996 {
3997
3998 $expectation->failed();
3999 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
4000 Parse::RecDescent::_tracefirst($text))
4001 if defined $::RD_TRACE;
4002 last;
4003 }
4004 $current_match = substr($text, $-[0], $+[0] - $-[0]);
4005 substr($text,0,length($current_match),q{});
4006 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4007 . $current_match . q{])},
4008 Parse::RecDescent::_tracefirst($text))
4009 if defined $::RD_TRACE;
4010 push @item, $item{__STRING1__}=$current_match;
4011
4012  
4013 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr /,/ expr>]},
4014 Parse::RecDescent::_tracefirst($text),
4015 q{function},
4016 $tracelevel)
4017 if defined $::RD_TRACE;
4018 $expectation->is(q{<leftop: expr /,/ expr>})->at($text);
4019  
4020 $_tok = undef;
4021 OPLOOP: while (1)
4022 {
4023 $repcount = 0;
4024 my @item;
4025
4026 # MATCH LEFTARG
4027
4028 Parse::RecDescent::_trace(q{Trying subrule: [expr]},
4029 Parse::RecDescent::_tracefirst($text),
4030 q{function},
4031 $tracelevel)
4032 if defined $::RD_TRACE;
4033 if (1) { no strict qw{refs};
4034 $expectation->is(q{expr})->at($text);
4035 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4036 {
4037
4038 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
4039 Parse::RecDescent::_tracefirst($text),
4040 q{function},
4041 $tracelevel)
4042 if defined $::RD_TRACE;
4043 $expectation->failed();
4044 last;
4045 }
4046 Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
4047 . $_tok . q{]},
4048
4049 Parse::RecDescent::_tracefirst($text),
4050 q{function},
4051 $tracelevel)
4052 if defined $::RD_TRACE;
4053 $item{q{expr}} = $_tok;
4054 push @item, $_tok;
4055
4056 }
4057  
4058  
4059 $repcount++;
4060  
4061 my $savetext = $text;
4062 my $backtrack;
4063  
4064 # MATCH (OP RIGHTARG)(s)
4065 while ($repcount < 100000000)
4066 {
4067 $backtrack = 0;
4068
4069 Parse::RecDescent::_trace(q{Trying terminal: [/,/]}, Parse::RecDescent::_tracefirst($text),
4070 q{function},
4071 $tracelevel)
4072 if defined $::RD_TRACE;
4073 $lastsep = "";
4074 $expectation->is(q{/,/})->at($text);
4075
4076  
4077 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:,)/)
4078 {
4079
4080 $expectation->failed();
4081 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
4082 Parse::RecDescent::_tracefirst($text))
4083 if defined $::RD_TRACE;
4084  
4085 last;
4086 }
4087 $current_match = substr($text, $-[0], $+[0] - $-[0]);
4088 substr($text,0,length($current_match),q{});
4089 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4090 . $current_match . q{])},
4091 Parse::RecDescent::_tracefirst($text))
4092 if defined $::RD_TRACE;
4093 push @item, $item{__PATTERN2__}=$current_match;
4094
4095  
4096 pop @item;
4097 if (defined $1) {push @item, $item{'expr(s)'}=$1; $backtrack=1;}
4098
4099 Parse::RecDescent::_trace(q{Trying subrule: [expr]},
4100 Parse::RecDescent::_tracefirst($text),
4101 q{function},
4102 $tracelevel)
4103 if defined $::RD_TRACE;
4104 if (1) { no strict qw{refs};
4105 $expectation->is(q{expr})->at($text);
4106 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4107 {
4108
4109 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
4110 Parse::RecDescent::_tracefirst($text),
4111 q{function},
4112 $tracelevel)
4113 if defined $::RD_TRACE;
4114 $expectation->failed();
4115 last;
4116 }
4117 Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
4118 . $_tok . q{]},
4119
4120 Parse::RecDescent::_tracefirst($text),
4121 q{function},
4122 $tracelevel)
4123 if defined $::RD_TRACE;
4124 $item{q{expr}} = $_tok;
4125 push @item, $_tok;
4126
4127 }
4128  
4129 $savetext = $text;
4130 $repcount++;
4131 }
4132 $text = $savetext;
4133 pop @item if $backtrack;
4134  
4135 unless (@item) { undef $_tok; last }
4136 $_tok = [ @item ];
4137 last;
4138 }
4139  
4140 unless ($repcount>=1)
4141 {
4142 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr /,/ expr>]>>},
4143 Parse::RecDescent::_tracefirst($text),
4144 q{function},
4145 $tracelevel)
4146 if defined $::RD_TRACE;
4147 $expectation->failed();
4148 last;
4149 }
4150 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr /,/ expr>]<< (return value: [}
4151 . qq{@{$_tok||[]}} . q{]},
4152 Parse::RecDescent::_tracefirst($text),
4153 q{function},
4154 $tracelevel)
4155 if defined $::RD_TRACE;
4156  
4157 push @item, $item{'expr(s)'}=$_tok||[];
4158  
4159  
4160 Parse::RecDescent::_trace(q{Trying terminal: [')']},
4161 Parse::RecDescent::_tracefirst($text),
4162 q{function},
4163 $tracelevel)
4164 if defined $::RD_TRACE;
4165 $lastsep = "";
4166 $expectation->is(q{')'})->at($text);
4167
4168  
4169 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
4170 {
4171
4172 $expectation->failed();
4173 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
4174 Parse::RecDescent::_tracefirst($text))
4175 if defined $::RD_TRACE;
4176 last;
4177 }
4178 $current_match = substr($text, $-[0], $+[0] - $-[0]);
4179 substr($text,0,length($current_match),q{});
4180 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4181 . $current_match . q{])},
4182 Parse::RecDescent::_tracefirst($text))
4183 if defined $::RD_TRACE;
4184 push @item, $item{__STRING2__}=$current_match;
4185
4186  
4187 Parse::RecDescent::_trace(q{Trying action},
4188 Parse::RecDescent::_tracefirst($text),
4189 q{function},
4190 $tracelevel)
4191 if defined $::RD_TRACE;
4192
4193  
4194 $_tok = ($_noactions) ? 0 : do {
4195 db(@item);
4196 die unless $allowed_funcs->{$item[1]};
4197 $return = sub {
4198 $allowed_funcs->{$item[1]}->( map { run($_) } @item[3..$#item] );
4199 };
4200 };
4201 unless (defined $_tok)
4202 {
4203 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4204 if defined $::RD_TRACE;
4205 last;
4206 }
4207 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4208 . $_tok . q{])},
4209 Parse::RecDescent::_tracefirst($text))
4210 if defined $::RD_TRACE;
4211 push @item, $_tok;
4212 $item{__ACTION1__}=$_tok;
4213
4214  
4215  
4216 Parse::RecDescent::_trace(q{>>Matched production: [/[A-Za-z_](?:\\w|::(?=[^:]))*/ '(' <leftop: expr /,/ expr> ')']<<},
4217 Parse::RecDescent::_tracefirst($text),
4218 q{function},
4219 $tracelevel)
4220 if defined $::RD_TRACE;
4221 $_matched = 1;
4222 last;
4223 }
4224  
4225  
4226 unless ( $_matched || defined($score) )
4227 {
4228
4229  
4230 $_[1] = $text; # NOT SURE THIS IS NEEDED
4231 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
4232 Parse::RecDescent::_tracefirst($_[1]),
4233 q{function},
4234 $tracelevel)
4235 if defined $::RD_TRACE;
4236 return undef;
4237 }
4238 if (!defined($return) && defined($score))
4239 {
4240 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4241 q{function},
4242 $tracelevel)
4243 if defined $::RD_TRACE;
4244 $return = $score_return;
4245 }
4246 splice @{$thisparser->{errors}}, $err_at;
4247 $return = $item[$#item] unless defined $return;
4248 if (defined $::RD_TRACE)
4249 {
4250 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4251 $return . q{])}, "",
4252 q{function},
4253 $tracelevel);
4254 Parse::RecDescent::_trace(q{(consumed: [} .
4255 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4256 Parse::RecDescent::_tracefirst($text),
4257 , q{function},
4258 $tracelevel)
4259 }
4260 $_[1] = $text;
4261 return $return;
4262 }
4263  
4264 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4265 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr7op
4266 {
4267 my $thisparser = $_[0];
4268 use vars q{$tracelevel};
4269 local $tracelevel = ($tracelevel||0)+1;
4270 $ERRORS = 0;
4271 my $thisrule = $thisparser->{"rules"}{"expr7op"};
4272
4273 Parse::RecDescent::_trace(q{Trying rule: [expr7op]},
4274 Parse::RecDescent::_tracefirst($_[1]),
4275 q{expr7op},
4276 $tracelevel)
4277 if defined $::RD_TRACE;
4278  
4279
4280 my $err_at = @{$thisparser->{errors}};
4281  
4282 my $score;
4283 my $score_return;
4284 my $_tok;
4285 my $return = undef;
4286 my $_matched=0;
4287 my $commit=0;
4288 my @item = ();
4289 my %item = ();
4290 my $repeating = defined($_[2]) && $_[2];
4291 my $_noactions = defined($_[3]) && $_[3];
4292 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
4293 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4294 my $text;
4295 my $lastsep="";
4296 my $current_match;
4297 my $expectation = new Parse::RecDescent::Expectation(q{'||'});
4298 $expectation->at($_[1]);
4299
4300 my $thisline;
4301 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4302  
4303
4304  
4305 while (!$_matched && !$commit)
4306 {
4307
4308 Parse::RecDescent::_trace(q{Trying production: ['||']},
4309 Parse::RecDescent::_tracefirst($_[1]),
4310 q{expr7op},
4311 $tracelevel)
4312 if defined $::RD_TRACE;
4313 my $thisprod = $thisrule->{"prods"}[0];
4314 $text = $_[1];
4315 my $_savetext;
4316 @item = (q{expr7op});
4317 %item = (__RULE__ => q{expr7op});
4318 my $repcount = 0;
4319  
4320  
4321 Parse::RecDescent::_trace(q{Trying terminal: ['||']},
4322 Parse::RecDescent::_tracefirst($text),
4323 q{expr7op},
4324 $tracelevel)
4325 if defined $::RD_TRACE;
4326 $lastsep = "";
4327 $expectation->is(q{})->at($text);
4328
4329  
4330 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "||"; 1 } and
4331 substr($text,0,length($_tok)) eq $_tok and
4332 do { substr($text,0,length($_tok)) = ""; 1; }
4333 )
4334 {
4335
4336 $expectation->failed();
4337 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
4338 Parse::RecDescent::_tracefirst($text))
4339 if defined $::RD_TRACE;
4340 last;
4341 }
4342 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4343 . $_tok . q{])},
4344 Parse::RecDescent::_tracefirst($text))
4345 if defined $::RD_TRACE;
4346 push @item, $item{__STRING1__}=$_tok;
4347
4348  
4349 Parse::RecDescent::_trace(q{Trying action},
4350 Parse::RecDescent::_tracefirst($text),
4351 q{expr7op},
4352 $tracelevel)
4353 if defined $::RD_TRACE;
4354
4355  
4356 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
4357 unless (defined $_tok)
4358 {
4359 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4360 if defined $::RD_TRACE;
4361 last;
4362 }
4363 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4364 . $_tok . q{])},
4365 Parse::RecDescent::_tracefirst($text))
4366 if defined $::RD_TRACE;
4367 push @item, $_tok;
4368 $item{__ACTION1__}=$_tok;
4369
4370  
4371  
4372 Parse::RecDescent::_trace(q{>>Matched production: ['||']<<},
4373 Parse::RecDescent::_tracefirst($text),
4374 q{expr7op},
4375 $tracelevel)
4376 if defined $::RD_TRACE;
4377 $_matched = 1;
4378 last;
4379 }
4380  
4381  
4382 unless ( $_matched || defined($score) )
4383 {
4384
4385  
4386 $_[1] = $text; # NOT SURE THIS IS NEEDED
4387 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
4388 Parse::RecDescent::_tracefirst($_[1]),
4389 q{expr7op},
4390 $tracelevel)
4391 if defined $::RD_TRACE;
4392 return undef;
4393 }
4394 if (!defined($return) && defined($score))
4395 {
4396 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4397 q{expr7op},
4398 $tracelevel)
4399 if defined $::RD_TRACE;
4400 $return = $score_return;
4401 }
4402 splice @{$thisparser->{errors}}, $err_at;
4403 $return = $item[$#item] unless defined $return;
4404 if (defined $::RD_TRACE)
4405 {
4406 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4407 $return . q{])}, "",
4408 q{expr7op},
4409 $tracelevel);
4410 Parse::RecDescent::_trace(q{(consumed: [} .
4411 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4412 Parse::RecDescent::_tracefirst($text),
4413 , q{expr7op},
4414 $tracelevel)
4415 }
4416 $_[1] = $text;
4417 return $return;
4418 }
4419  
4420 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4421 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::term
4422 {
4423 my $thisparser = $_[0];
4424 use vars q{$tracelevel};
4425 local $tracelevel = ($tracelevel||0)+1;
4426 $ERRORS = 0;
4427 my $thisrule = $thisparser->{"rules"}{"term"};
4428
4429 Parse::RecDescent::_trace(q{Trying rule: [term]},
4430 Parse::RecDescent::_tracefirst($_[1]),
4431 q{term},
4432 $tracelevel)
4433 if defined $::RD_TRACE;
4434  
4435
4436 my $err_at = @{$thisparser->{errors}};
4437  
4438 my $score;
4439 my $score_return;
4440 my $_tok;
4441 my $return = undef;
4442 my $_matched=0;
4443 my $commit=0;
4444 my @item = ();
4445 my %item = ();
4446 my $repeating = defined($_[2]) && $_[2];
4447 my $_noactions = defined($_[3]) && $_[3];
4448 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
4449 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4450 my $text;
4451 my $lastsep="";
4452 my $current_match;
4453 my $expectation = new Parse::RecDescent::Expectation(q{'(', or constant, or macro, or function});
4454 $expectation->at($_[1]);
4455
4456 my $thisline;
4457 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4458  
4459
4460  
4461 while (!$_matched && !$commit)
4462 {
4463
4464 Parse::RecDescent::_trace(q{Trying production: ['(' expr ')']},
4465 Parse::RecDescent::_tracefirst($_[1]),
4466 q{term},
4467 $tracelevel)
4468 if defined $::RD_TRACE;
4469 my $thisprod = $thisrule->{"prods"}[0];
4470 $text = $_[1];
4471 my $_savetext;
4472 @item = (q{term});
4473 %item = (__RULE__ => q{term});
4474 my $repcount = 0;
4475  
4476  
4477 Parse::RecDescent::_trace(q{Trying terminal: ['(']},
4478 Parse::RecDescent::_tracefirst($text),
4479 q{term},
4480 $tracelevel)
4481 if defined $::RD_TRACE;
4482 $lastsep = "";
4483 $expectation->is(q{})->at($text);
4484
4485  
4486 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
4487 {
4488
4489 $expectation->failed();
4490 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
4491 Parse::RecDescent::_tracefirst($text))
4492 if defined $::RD_TRACE;
4493 last;
4494 }
4495 $current_match = substr($text, $-[0], $+[0] - $-[0]);
4496 substr($text,0,length($current_match),q{});
4497 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4498 . $current_match . q{])},
4499 Parse::RecDescent::_tracefirst($text))
4500 if defined $::RD_TRACE;
4501 push @item, $item{__STRING1__}=$current_match;
4502
4503  
4504 Parse::RecDescent::_trace(q{Trying subrule: [expr]},
4505 Parse::RecDescent::_tracefirst($text),
4506 q{term},
4507 $tracelevel)
4508 if defined $::RD_TRACE;
4509 if (1) { no strict qw{refs};
4510 $expectation->is(q{expr})->at($text);
4511 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4512 {
4513
4514 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
4515 Parse::RecDescent::_tracefirst($text),
4516 q{term},
4517 $tracelevel)
4518 if defined $::RD_TRACE;
4519 $expectation->failed();
4520 last;
4521 }
4522 Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
4523 . $_tok . q{]},
4524
4525 Parse::RecDescent::_tracefirst($text),
4526 q{term},
4527 $tracelevel)
4528 if defined $::RD_TRACE;
4529 $item{q{expr}} = $_tok;
4530 push @item, $_tok;
4531
4532 }
4533  
4534 Parse::RecDescent::_trace(q{Trying terminal: [')']},
4535 Parse::RecDescent::_tracefirst($text),
4536 q{term},
4537 $tracelevel)
4538 if defined $::RD_TRACE;
4539 $lastsep = "";
4540 $expectation->is(q{')'})->at($text);
4541
4542  
4543 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
4544 {
4545
4546 $expectation->failed();
4547 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
4548 Parse::RecDescent::_tracefirst($text))
4549 if defined $::RD_TRACE;
4550 last;
4551 }
4552 $current_match = substr($text, $-[0], $+[0] - $-[0]);
4553 substr($text,0,length($current_match),q{});
4554 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4555 . $current_match . q{])},
4556 Parse::RecDescent::_tracefirst($text))
4557 if defined $::RD_TRACE;
4558 push @item, $item{__STRING2__}=$current_match;
4559
4560  
4561 Parse::RecDescent::_trace(q{Trying action},
4562 Parse::RecDescent::_tracefirst($text),
4563 q{term},
4564 $tracelevel)
4565 if defined $::RD_TRACE;
4566
4567  
4568 $_tok = ($_noactions) ? 0 : do { db(@item); $return = $item[2] };
4569 unless (defined $_tok)
4570 {
4571 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4572 if defined $::RD_TRACE;
4573 last;
4574 }
4575 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4576 . $_tok . q{])},
4577 Parse::RecDescent::_tracefirst($text))
4578 if defined $::RD_TRACE;
4579 push @item, $_tok;
4580 $item{__ACTION1__}=$_tok;
4581
4582  
4583  
4584 Parse::RecDescent::_trace(q{>>Matched production: ['(' expr ')']<<},
4585 Parse::RecDescent::_tracefirst($text),
4586 q{term},
4587 $tracelevel)
4588 if defined $::RD_TRACE;
4589 $_matched = 1;
4590 last;
4591 }
4592  
4593  
4594 while (!$_matched && !$commit)
4595 {
4596
4597 Parse::RecDescent::_trace(q{Trying production: [constant]},
4598 Parse::RecDescent::_tracefirst($_[1]),
4599 q{term},
4600 $tracelevel)
4601 if defined $::RD_TRACE;
4602 my $thisprod = $thisrule->{"prods"}[1];
4603 $text = $_[1];
4604 my $_savetext;
4605 @item = (q{term});
4606 %item = (__RULE__ => q{term});
4607 my $repcount = 0;
4608  
4609  
4610 Parse::RecDescent::_trace(q{Trying subrule: [constant]},
4611 Parse::RecDescent::_tracefirst($text),
4612 q{term},
4613 $tracelevel)
4614 if defined $::RD_TRACE;
4615 if (1) { no strict qw{refs};
4616 $expectation->is(q{})->at($text);
4617 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::constant($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4618 {
4619
4620 Parse::RecDescent::_trace(q{<<Didn't match subrule: [constant]>>},
4621 Parse::RecDescent::_tracefirst($text),
4622 q{term},
4623 $tracelevel)
4624 if defined $::RD_TRACE;
4625 $expectation->failed();
4626 last;
4627 }
4628 Parse::RecDescent::_trace(q{>>Matched subrule: [constant]<< (return value: [}
4629 . $_tok . q{]},
4630
4631 Parse::RecDescent::_tracefirst($text),
4632 q{term},
4633 $tracelevel)
4634 if defined $::RD_TRACE;
4635 $item{q{constant}} = $_tok;
4636 push @item, $_tok;
4637
4638 }
4639  
4640 Parse::RecDescent::_trace(q{Trying action},
4641 Parse::RecDescent::_tracefirst($text),
4642 q{term},
4643 $tracelevel)
4644 if defined $::RD_TRACE;
4645
4646  
4647 $_tok = ($_noactions) ? 0 : do { db(@item); $return = $item[1] };
4648 unless (defined $_tok)
4649 {
4650 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4651 if defined $::RD_TRACE;
4652 last;
4653 }
4654 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4655 . $_tok . q{])},
4656 Parse::RecDescent::_tracefirst($text))
4657 if defined $::RD_TRACE;
4658 push @item, $_tok;
4659 $item{__ACTION1__}=$_tok;
4660
4661  
4662  
4663 Parse::RecDescent::_trace(q{>>Matched production: [constant]<<},
4664 Parse::RecDescent::_tracefirst($text),
4665 q{term},
4666 $tracelevel)
4667 if defined $::RD_TRACE;
4668 $_matched = 1;
4669 last;
4670 }
4671  
4672  
4673 while (!$_matched && !$commit)
4674 {
4675
4676 Parse::RecDescent::_trace(q{Trying production: [macro]},
4677 Parse::RecDescent::_tracefirst($_[1]),
4678 q{term},
4679 $tracelevel)
4680 if defined $::RD_TRACE;
4681 my $thisprod = $thisrule->{"prods"}[2];
4682 $text = $_[1];
4683 my $_savetext;
4684 @item = (q{term});
4685 %item = (__RULE__ => q{term});
4686 my $repcount = 0;
4687  
4688  
4689 Parse::RecDescent::_trace(q{Trying subrule: [macro]},
4690 Parse::RecDescent::_tracefirst($text),
4691 q{term},
4692 $tracelevel)
4693 if defined $::RD_TRACE;
4694 if (1) { no strict qw{refs};
4695 $expectation->is(q{})->at($text);
4696 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::macro($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4697 {
4698
4699 Parse::RecDescent::_trace(q{<<Didn't match subrule: [macro]>>},
4700 Parse::RecDescent::_tracefirst($text),
4701 q{term},
4702 $tracelevel)
4703 if defined $::RD_TRACE;
4704 $expectation->failed();
4705 last;
4706 }
4707 Parse::RecDescent::_trace(q{>>Matched subrule: [macro]<< (return value: [}
4708 . $_tok . q{]},
4709
4710 Parse::RecDescent::_tracefirst($text),
4711 q{term},
4712 $tracelevel)
4713 if defined $::RD_TRACE;
4714 $item{q{macro}} = $_tok;
4715 push @item, $_tok;
4716
4717 }
4718  
4719 Parse::RecDescent::_trace(q{Trying action},
4720 Parse::RecDescent::_tracefirst($text),
4721 q{term},
4722 $tracelevel)
4723 if defined $::RD_TRACE;
4724
4725  
4726 $_tok = ($_noactions) ? 0 : do { db(@item); $return = $item[1] };
4727 unless (defined $_tok)
4728 {
4729 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4730 if defined $::RD_TRACE;
4731 last;
4732 }
4733 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4734 . $_tok . q{])},
4735 Parse::RecDescent::_tracefirst($text))
4736 if defined $::RD_TRACE;
4737 push @item, $_tok;
4738 $item{__ACTION1__}=$_tok;
4739
4740  
4741  
4742 Parse::RecDescent::_trace(q{>>Matched production: [macro]<<},
4743 Parse::RecDescent::_tracefirst($text),
4744 q{term},
4745 $tracelevel)
4746 if defined $::RD_TRACE;
4747 $_matched = 1;
4748 last;
4749 }
4750  
4751  
4752 while (!$_matched && !$commit)
4753 {
4754
4755 Parse::RecDescent::_trace(q{Trying production: [function]},
4756 Parse::RecDescent::_tracefirst($_[1]),
4757 q{term},
4758 $tracelevel)
4759 if defined $::RD_TRACE;
4760 my $thisprod = $thisrule->{"prods"}[3];
4761 $text = $_[1];
4762 my $_savetext;
4763 @item = (q{term});
4764 %item = (__RULE__ => q{term});
4765 my $repcount = 0;
4766  
4767  
4768 Parse::RecDescent::_trace(q{Trying subrule: [function]},
4769 Parse::RecDescent::_tracefirst($text),
4770 q{term},
4771 $tracelevel)
4772 if defined $::RD_TRACE;
4773 if (1) { no strict qw{refs};
4774 $expectation->is(q{})->at($text);
4775 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::function($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4776 {
4777
4778 Parse::RecDescent::_trace(q{<<Didn't match subrule: [function]>>},
4779 Parse::RecDescent::_tracefirst($text),
4780 q{term},
4781 $tracelevel)
4782 if defined $::RD_TRACE;
4783 $expectation->failed();
4784 last;
4785 }
4786 Parse::RecDescent::_trace(q{>>Matched subrule: [function]<< (return value: [}
4787 . $_tok . q{]},
4788
4789 Parse::RecDescent::_tracefirst($text),
4790 q{term},
4791 $tracelevel)
4792 if defined $::RD_TRACE;
4793 $item{q{function}} = $_tok;
4794 push @item, $_tok;
4795
4796 }
4797  
4798 Parse::RecDescent::_trace(q{Trying action},
4799 Parse::RecDescent::_tracefirst($text),
4800 q{term},
4801 $tracelevel)
4802 if defined $::RD_TRACE;
4803
4804  
4805 $_tok = ($_noactions) ? 0 : do { db(@item); $return = $item[1] };
4806 unless (defined $_tok)
4807 {
4808 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
4809 if defined $::RD_TRACE;
4810 last;
4811 }
4812 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4813 . $_tok . q{])},
4814 Parse::RecDescent::_tracefirst($text))
4815 if defined $::RD_TRACE;
4816 push @item, $_tok;
4817 $item{__ACTION1__}=$_tok;
4818
4819  
4820  
4821 Parse::RecDescent::_trace(q{>>Matched production: [function]<<},
4822 Parse::RecDescent::_tracefirst($text),
4823 q{term},
4824 $tracelevel)
4825 if defined $::RD_TRACE;
4826 $_matched = 1;
4827 last;
4828 }
4829  
4830  
4831 unless ( $_matched || defined($score) )
4832 {
4833
4834  
4835 $_[1] = $text; # NOT SURE THIS IS NEEDED
4836 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
4837 Parse::RecDescent::_tracefirst($_[1]),
4838 q{term},
4839 $tracelevel)
4840 if defined $::RD_TRACE;
4841 return undef;
4842 }
4843 if (!defined($return) && defined($score))
4844 {
4845 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4846 q{term},
4847 $tracelevel)
4848 if defined $::RD_TRACE;
4849 $return = $score_return;
4850 }
4851 splice @{$thisparser->{errors}}, $err_at;
4852 $return = $item[$#item] unless defined $return;
4853 if (defined $::RD_TRACE)
4854 {
4855 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4856 $return . q{])}, "",
4857 q{term},
4858 $tracelevel);
4859 Parse::RecDescent::_trace(q{(consumed: [} .
4860 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4861 Parse::RecDescent::_tracefirst($text),
4862 , q{term},
4863 $tracelevel)
4864 }
4865 $_[1] = $text;
4866 return $return;
4867 }
4868  
4869 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4870 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr13
4871 {
4872 my $thisparser = $_[0];
4873 use vars q{$tracelevel};
4874 local $tracelevel = ($tracelevel||0)+1;
4875 $ERRORS = 0;
4876 my $thisrule = $thisparser->{"rules"}{"expr13"};
4877
4878 Parse::RecDescent::_trace(q{Trying rule: [expr13]},
4879 Parse::RecDescent::_tracefirst($_[1]),
4880 q{expr13},
4881 $tracelevel)
4882 if defined $::RD_TRACE;
4883  
4884
4885 my $err_at = @{$thisparser->{errors}};
4886  
4887 my $score;
4888 my $score_return;
4889 my $_tok;
4890 my $return = undef;
4891 my $_matched=0;
4892 my $commit=0;
4893 my @item = ();
4894 my %item = ();
4895 my $repeating = defined($_[2]) && $_[2];
4896 my $_noactions = defined($_[3]) && $_[3];
4897 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
4898 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4899 my $text;
4900 my $lastsep="";
4901 my $current_match;
4902 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr14 expr13op expr14>});
4903 $expectation->at($_[1]);
4904
4905 my $thisline;
4906 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4907  
4908
4909  
4910 while (!$_matched && !$commit)
4911 {
4912
4913 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr14 expr13op expr14>]},
4914 Parse::RecDescent::_tracefirst($_[1]),
4915 q{expr13},
4916 $tracelevel)
4917 if defined $::RD_TRACE;
4918 my $thisprod = $thisrule->{"prods"}[0];
4919 $text = $_[1];
4920 my $_savetext;
4921 @item = (q{expr13});
4922 %item = (__RULE__ => q{expr13});
4923 my $repcount = 0;
4924  
4925  
4926 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr14 expr13op expr14>]},
4927 Parse::RecDescent::_tracefirst($text),
4928 q{expr13},
4929 $tracelevel)
4930 if defined $::RD_TRACE;
4931 $expectation->is(q{})->at($text);
4932  
4933 $_tok = undef;
4934 OPLOOP: while (1)
4935 {
4936 $repcount = 0;
4937 my @item;
4938
4939 # MATCH LEFTARG
4940
4941 Parse::RecDescent::_trace(q{Trying subrule: [expr14]},
4942 Parse::RecDescent::_tracefirst($text),
4943 q{expr13},
4944 $tracelevel)
4945 if defined $::RD_TRACE;
4946 if (1) { no strict qw{refs};
4947 $expectation->is(q{expr14})->at($text);
4948 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr14($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4949 {
4950
4951 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr14]>>},
4952 Parse::RecDescent::_tracefirst($text),
4953 q{expr13},
4954 $tracelevel)
4955 if defined $::RD_TRACE;
4956 $expectation->failed();
4957 last;
4958 }
4959 Parse::RecDescent::_trace(q{>>Matched subrule: [expr14]<< (return value: [}
4960 . $_tok . q{]},
4961
4962 Parse::RecDescent::_tracefirst($text),
4963 q{expr13},
4964 $tracelevel)
4965 if defined $::RD_TRACE;
4966 $item{q{expr14}} = $_tok;
4967 push @item, $_tok;
4968
4969 }
4970  
4971  
4972 $repcount++;
4973  
4974 my $savetext = $text;
4975 my $backtrack;
4976  
4977 # MATCH (OP RIGHTARG)(s)
4978 while ($repcount < 100000000)
4979 {
4980 $backtrack = 0;
4981
4982 Parse::RecDescent::_trace(q{Trying subrule: [expr13op]},
4983 Parse::RecDescent::_tracefirst($text),
4984 q{expr13},
4985 $tracelevel)
4986 if defined $::RD_TRACE;
4987 if (1) { no strict qw{refs};
4988 $expectation->is(q{expr13op})->at($text);
4989 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr13op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4990 {
4991
4992 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr13op]>>},
4993 Parse::RecDescent::_tracefirst($text),
4994 q{expr13},
4995 $tracelevel)
4996 if defined $::RD_TRACE;
4997 $expectation->failed();
4998 last;
4999 }
5000 Parse::RecDescent::_trace(q{>>Matched subrule: [expr13op]<< (return value: [}
5001 . $_tok . q{]},
5002
5003 Parse::RecDescent::_tracefirst($text),
5004 q{expr13},
5005 $tracelevel)
5006 if defined $::RD_TRACE;
5007 $item{q{expr13op}} = $_tok;
5008 push @item, $_tok;
5009
5010 }
5011  
5012 $backtrack=1;
5013
5014
5015 Parse::RecDescent::_trace(q{Trying subrule: [expr14]},
5016 Parse::RecDescent::_tracefirst($text),
5017 q{expr13},
5018 $tracelevel)
5019 if defined $::RD_TRACE;
5020 if (1) { no strict qw{refs};
5021 $expectation->is(q{expr14})->at($text);
5022 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr14($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5023 {
5024
5025 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr14]>>},
5026 Parse::RecDescent::_tracefirst($text),
5027 q{expr13},
5028 $tracelevel)
5029 if defined $::RD_TRACE;
5030 $expectation->failed();
5031 last;
5032 }
5033 Parse::RecDescent::_trace(q{>>Matched subrule: [expr14]<< (return value: [}
5034 . $_tok . q{]},
5035
5036 Parse::RecDescent::_tracefirst($text),
5037 q{expr13},
5038 $tracelevel)
5039 if defined $::RD_TRACE;
5040 $item{q{expr14}} = $_tok;
5041 push @item, $_tok;
5042
5043 }
5044  
5045 $savetext = $text;
5046 $repcount++;
5047 }
5048 $text = $savetext;
5049 pop @item if $backtrack;
5050  
5051 unless (@item) { undef $_tok; last }
5052 $_tok = [ @item ];
5053 last;
5054 }
5055  
5056 unless ($repcount>=1)
5057 {
5058 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr14 expr13op expr14>]>>},
5059 Parse::RecDescent::_tracefirst($text),
5060 q{expr13},
5061 $tracelevel)
5062 if defined $::RD_TRACE;
5063 $expectation->failed();
5064 last;
5065 }
5066 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr14 expr13op expr14>]<< (return value: [}
5067 . qq{@{$_tok||[]}} . q{]},
5068 Parse::RecDescent::_tracefirst($text),
5069 q{expr13},
5070 $tracelevel)
5071 if defined $::RD_TRACE;
5072  
5073 push @item, $item{__DIRECTIVE1__}=$_tok||[];
5074  
5075  
5076 Parse::RecDescent::_trace(q{Trying action},
5077 Parse::RecDescent::_tracefirst($text),
5078 q{expr13},
5079 $tracelevel)
5080 if defined $::RD_TRACE;
5081
5082  
5083 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
5084 unless (defined $_tok)
5085 {
5086 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5087 if defined $::RD_TRACE;
5088 last;
5089 }
5090 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5091 . $_tok . q{])},
5092 Parse::RecDescent::_tracefirst($text))
5093 if defined $::RD_TRACE;
5094 push @item, $_tok;
5095 $item{__ACTION1__}=$_tok;
5096
5097  
5098  
5099 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr14 expr13op expr14>]<<},
5100 Parse::RecDescent::_tracefirst($text),
5101 q{expr13},
5102 $tracelevel)
5103 if defined $::RD_TRACE;
5104 $_matched = 1;
5105 last;
5106 }
5107  
5108  
5109 unless ( $_matched || defined($score) )
5110 {
5111
5112  
5113 $_[1] = $text; # NOT SURE THIS IS NEEDED
5114 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5115 Parse::RecDescent::_tracefirst($_[1]),
5116 q{expr13},
5117 $tracelevel)
5118 if defined $::RD_TRACE;
5119 return undef;
5120 }
5121 if (!defined($return) && defined($score))
5122 {
5123 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5124 q{expr13},
5125 $tracelevel)
5126 if defined $::RD_TRACE;
5127 $return = $score_return;
5128 }
5129 splice @{$thisparser->{errors}}, $err_at;
5130 $return = $item[$#item] unless defined $return;
5131 if (defined $::RD_TRACE)
5132 {
5133 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5134 $return . q{])}, "",
5135 q{expr13},
5136 $tracelevel);
5137 Parse::RecDescent::_trace(q{(consumed: [} .
5138 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5139 Parse::RecDescent::_tracefirst($text),
5140 , q{expr13},
5141 $tracelevel)
5142 }
5143 $_[1] = $text;
5144 return $return;
5145 }
5146  
5147 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5148 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr17op
5149 {
5150 my $thisparser = $_[0];
5151 use vars q{$tracelevel};
5152 local $tracelevel = ($tracelevel||0)+1;
5153 $ERRORS = 0;
5154 my $thisrule = $thisparser->{"rules"}{"expr17op"};
5155
5156 Parse::RecDescent::_trace(q{Trying rule: [expr17op]},
5157 Parse::RecDescent::_tracefirst($_[1]),
5158 q{expr17op},
5159 $tracelevel)
5160 if defined $::RD_TRACE;
5161  
5162
5163 my $err_at = @{$thisparser->{errors}};
5164  
5165 my $score;
5166 my $score_return;
5167 my $_tok;
5168 my $return = undef;
5169 my $_matched=0;
5170 my $commit=0;
5171 my @item = ();
5172 my %item = ();
5173 my $repeating = defined($_[2]) && $_[2];
5174 my $_noactions = defined($_[3]) && $_[3];
5175 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5176 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5177 my $text;
5178 my $lastsep="";
5179 my $current_match;
5180 my $expectation = new Parse::RecDescent::Expectation(q{/(\\*\\*)/});
5181 $expectation->at($_[1]);
5182
5183 my $thisline;
5184 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5185  
5186
5187  
5188 while (!$_matched && !$commit)
5189 {
5190
5191 Parse::RecDescent::_trace(q{Trying production: [/(\\*\\*)/]},
5192 Parse::RecDescent::_tracefirst($_[1]),
5193 q{expr17op},
5194 $tracelevel)
5195 if defined $::RD_TRACE;
5196 my $thisprod = $thisrule->{"prods"}[0];
5197 $text = $_[1];
5198 my $_savetext;
5199 @item = (q{expr17op});
5200 %item = (__RULE__ => q{expr17op});
5201 my $repcount = 0;
5202  
5203  
5204 Parse::RecDescent::_trace(q{Trying terminal: [/(\\*\\*)/]}, Parse::RecDescent::_tracefirst($text),
5205 q{expr17op},
5206 $tracelevel)
5207 if defined $::RD_TRACE;
5208 $lastsep = "";
5209 $expectation->is(q{})->at($text);
5210
5211  
5212 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(\*\*))/)
5213 {
5214
5215 $expectation->failed();
5216 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
5217 Parse::RecDescent::_tracefirst($text))
5218 if defined $::RD_TRACE;
5219  
5220 last;
5221 }
5222 $current_match = substr($text, $-[0], $+[0] - $-[0]);
5223 substr($text,0,length($current_match),q{});
5224 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5225 . $current_match . q{])},
5226 Parse::RecDescent::_tracefirst($text))
5227 if defined $::RD_TRACE;
5228 push @item, $item{__PATTERN1__}=$current_match;
5229
5230  
5231 Parse::RecDescent::_trace(q{Trying action},
5232 Parse::RecDescent::_tracefirst($text),
5233 q{expr17op},
5234 $tracelevel)
5235 if defined $::RD_TRACE;
5236
5237  
5238 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
5239 unless (defined $_tok)
5240 {
5241 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5242 if defined $::RD_TRACE;
5243 last;
5244 }
5245 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5246 . $_tok . q{])},
5247 Parse::RecDescent::_tracefirst($text))
5248 if defined $::RD_TRACE;
5249 push @item, $_tok;
5250 $item{__ACTION1__}=$_tok;
5251
5252  
5253  
5254 Parse::RecDescent::_trace(q{>>Matched production: [/(\\*\\*)/]<<},
5255 Parse::RecDescent::_tracefirst($text),
5256 q{expr17op},
5257 $tracelevel)
5258 if defined $::RD_TRACE;
5259 $_matched = 1;
5260 last;
5261 }
5262  
5263  
5264 unless ( $_matched || defined($score) )
5265 {
5266
5267  
5268 $_[1] = $text; # NOT SURE THIS IS NEEDED
5269 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5270 Parse::RecDescent::_tracefirst($_[1]),
5271 q{expr17op},
5272 $tracelevel)
5273 if defined $::RD_TRACE;
5274 return undef;
5275 }
5276 if (!defined($return) && defined($score))
5277 {
5278 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5279 q{expr17op},
5280 $tracelevel)
5281 if defined $::RD_TRACE;
5282 $return = $score_return;
5283 }
5284 splice @{$thisparser->{errors}}, $err_at;
5285 $return = $item[$#item] unless defined $return;
5286 if (defined $::RD_TRACE)
5287 {
5288 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5289 $return . q{])}, "",
5290 q{expr17op},
5291 $tracelevel);
5292 Parse::RecDescent::_trace(q{(consumed: [} .
5293 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5294 Parse::RecDescent::_tracefirst($text),
5295 , q{expr17op},
5296 $tracelevel)
5297 }
5298 $_[1] = $text;
5299 return $return;
5300 }
5301  
5302 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5303 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr17
5304 {
5305 my $thisparser = $_[0];
5306 use vars q{$tracelevel};
5307 local $tracelevel = ($tracelevel||0)+1;
5308 $ERRORS = 0;
5309 my $thisrule = $thisparser->{"rules"}{"expr17"};
5310
5311 Parse::RecDescent::_trace(q{Trying rule: [expr17]},
5312 Parse::RecDescent::_tracefirst($_[1]),
5313 q{expr17},
5314 $tracelevel)
5315 if defined $::RD_TRACE;
5316  
5317
5318 my $err_at = @{$thisparser->{errors}};
5319  
5320 my $score;
5321 my $score_return;
5322 my $_tok;
5323 my $return = undef;
5324 my $_matched=0;
5325 my $commit=0;
5326 my @item = ();
5327 my %item = ();
5328 my $repeating = defined($_[2]) && $_[2];
5329 my $_noactions = defined($_[3]) && $_[3];
5330 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5331 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5332 my $text;
5333 my $lastsep="";
5334 my $current_match;
5335 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: term expr17op term>});
5336 $expectation->at($_[1]);
5337
5338 my $thisline;
5339 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5340  
5341
5342  
5343 while (!$_matched && !$commit)
5344 {
5345
5346 Parse::RecDescent::_trace(q{Trying production: [<leftop: term expr17op term>]},
5347 Parse::RecDescent::_tracefirst($_[1]),
5348 q{expr17},
5349 $tracelevel)
5350 if defined $::RD_TRACE;
5351 my $thisprod = $thisrule->{"prods"}[0];
5352 $text = $_[1];
5353 my $_savetext;
5354 @item = (q{expr17});
5355 %item = (__RULE__ => q{expr17});
5356 my $repcount = 0;
5357  
5358  
5359 Parse::RecDescent::_trace(q{Trying operator: [<leftop: term expr17op term>]},
5360 Parse::RecDescent::_tracefirst($text),
5361 q{expr17},
5362 $tracelevel)
5363 if defined $::RD_TRACE;
5364 $expectation->is(q{})->at($text);
5365  
5366 $_tok = undef;
5367 OPLOOP: while (1)
5368 {
5369 $repcount = 0;
5370 my @item;
5371
5372 # MATCH LEFTARG
5373
5374 Parse::RecDescent::_trace(q{Trying subrule: [term]},
5375 Parse::RecDescent::_tracefirst($text),
5376 q{expr17},
5377 $tracelevel)
5378 if defined $::RD_TRACE;
5379 if (1) { no strict qw{refs};
5380 $expectation->is(q{term})->at($text);
5381 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::term($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5382 {
5383
5384 Parse::RecDescent::_trace(q{<<Didn't match subrule: [term]>>},
5385 Parse::RecDescent::_tracefirst($text),
5386 q{expr17},
5387 $tracelevel)
5388 if defined $::RD_TRACE;
5389 $expectation->failed();
5390 last;
5391 }
5392 Parse::RecDescent::_trace(q{>>Matched subrule: [term]<< (return value: [}
5393 . $_tok . q{]},
5394
5395 Parse::RecDescent::_tracefirst($text),
5396 q{expr17},
5397 $tracelevel)
5398 if defined $::RD_TRACE;
5399 $item{q{term}} = $_tok;
5400 push @item, $_tok;
5401
5402 }
5403  
5404  
5405 $repcount++;
5406  
5407 my $savetext = $text;
5408 my $backtrack;
5409  
5410 # MATCH (OP RIGHTARG)(s)
5411 while ($repcount < 100000000)
5412 {
5413 $backtrack = 0;
5414
5415 Parse::RecDescent::_trace(q{Trying subrule: [expr17op]},
5416 Parse::RecDescent::_tracefirst($text),
5417 q{expr17},
5418 $tracelevel)
5419 if defined $::RD_TRACE;
5420 if (1) { no strict qw{refs};
5421 $expectation->is(q{expr17op})->at($text);
5422 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr17op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5423 {
5424
5425 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr17op]>>},
5426 Parse::RecDescent::_tracefirst($text),
5427 q{expr17},
5428 $tracelevel)
5429 if defined $::RD_TRACE;
5430 $expectation->failed();
5431 last;
5432 }
5433 Parse::RecDescent::_trace(q{>>Matched subrule: [expr17op]<< (return value: [}
5434 . $_tok . q{]},
5435
5436 Parse::RecDescent::_tracefirst($text),
5437 q{expr17},
5438 $tracelevel)
5439 if defined $::RD_TRACE;
5440 $item{q{expr17op}} = $_tok;
5441 push @item, $_tok;
5442
5443 }
5444  
5445 $backtrack=1;
5446
5447
5448 Parse::RecDescent::_trace(q{Trying subrule: [term]},
5449 Parse::RecDescent::_tracefirst($text),
5450 q{expr17},
5451 $tracelevel)
5452 if defined $::RD_TRACE;
5453 if (1) { no strict qw{refs};
5454 $expectation->is(q{term})->at($text);
5455 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::term($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5456 {
5457
5458 Parse::RecDescent::_trace(q{<<Didn't match subrule: [term]>>},
5459 Parse::RecDescent::_tracefirst($text),
5460 q{expr17},
5461 $tracelevel)
5462 if defined $::RD_TRACE;
5463 $expectation->failed();
5464 last;
5465 }
5466 Parse::RecDescent::_trace(q{>>Matched subrule: [term]<< (return value: [}
5467 . $_tok . q{]},
5468
5469 Parse::RecDescent::_tracefirst($text),
5470 q{expr17},
5471 $tracelevel)
5472 if defined $::RD_TRACE;
5473 $item{q{term}} = $_tok;
5474 push @item, $_tok;
5475
5476 }
5477  
5478 $savetext = $text;
5479 $repcount++;
5480 }
5481 $text = $savetext;
5482 pop @item if $backtrack;
5483  
5484 unless (@item) { undef $_tok; last }
5485 $_tok = [ @item ];
5486 last;
5487 }
5488  
5489 unless ($repcount>=1)
5490 {
5491 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: term expr17op term>]>>},
5492 Parse::RecDescent::_tracefirst($text),
5493 q{expr17},
5494 $tracelevel)
5495 if defined $::RD_TRACE;
5496 $expectation->failed();
5497 last;
5498 }
5499 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: term expr17op term>]<< (return value: [}
5500 . qq{@{$_tok||[]}} . q{]},
5501 Parse::RecDescent::_tracefirst($text),
5502 q{expr17},
5503 $tracelevel)
5504 if defined $::RD_TRACE;
5505  
5506 push @item, $item{__DIRECTIVE1__}=$_tok||[];
5507  
5508  
5509 Parse::RecDescent::_trace(q{Trying action},
5510 Parse::RecDescent::_tracefirst($text),
5511 q{expr17},
5512 $tracelevel)
5513 if defined $::RD_TRACE;
5514
5515  
5516 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
5517 unless (defined $_tok)
5518 {
5519 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5520 if defined $::RD_TRACE;
5521 last;
5522 }
5523 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5524 . $_tok . q{])},
5525 Parse::RecDescent::_tracefirst($text))
5526 if defined $::RD_TRACE;
5527 push @item, $_tok;
5528 $item{__ACTION1__}=$_tok;
5529
5530  
5531  
5532 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: term expr17op term>]<<},
5533 Parse::RecDescent::_tracefirst($text),
5534 q{expr17},
5535 $tracelevel)
5536 if defined $::RD_TRACE;
5537 $_matched = 1;
5538 last;
5539 }
5540  
5541  
5542 unless ( $_matched || defined($score) )
5543 {
5544
5545  
5546 $_[1] = $text; # NOT SURE THIS IS NEEDED
5547 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5548 Parse::RecDescent::_tracefirst($_[1]),
5549 q{expr17},
5550 $tracelevel)
5551 if defined $::RD_TRACE;
5552 return undef;
5553 }
5554 if (!defined($return) && defined($score))
5555 {
5556 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5557 q{expr17},
5558 $tracelevel)
5559 if defined $::RD_TRACE;
5560 $return = $score_return;
5561 }
5562 splice @{$thisparser->{errors}}, $err_at;
5563 $return = $item[$#item] unless defined $return;
5564 if (defined $::RD_TRACE)
5565 {
5566 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5567 $return . q{])}, "",
5568 q{expr17},
5569 $tracelevel);
5570 Parse::RecDescent::_trace(q{(consumed: [} .
5571 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5572 Parse::RecDescent::_tracefirst($text),
5573 , q{expr17},
5574 $tracelevel)
5575 }
5576 $_[1] = $text;
5577 return $return;
5578 }
5579  
5580 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5581 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr
5582 {
5583 my $thisparser = $_[0];
5584 use vars q{$tracelevel};
5585 local $tracelevel = ($tracelevel||0)+1;
5586 $ERRORS = 0;
5587 my $thisrule = $thisparser->{"rules"}{"expr"};
5588
5589 Parse::RecDescent::_trace(q{Trying rule: [expr]},
5590 Parse::RecDescent::_tracefirst($_[1]),
5591 q{expr},
5592 $tracelevel)
5593 if defined $::RD_TRACE;
5594  
5595
5596 my $err_at = @{$thisparser->{errors}};
5597  
5598 my $score;
5599 my $score_return;
5600 my $_tok;
5601 my $return = undef;
5602 my $_matched=0;
5603 my $commit=0;
5604 my @item = ();
5605 my %item = ();
5606 my $repeating = defined($_[2]) && $_[2];
5607 my $_noactions = defined($_[3]) && $_[3];
5608 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5609 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5610 my $text;
5611 my $lastsep="";
5612 my $current_match;
5613 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr2 expr_op expr2>});
5614 $expectation->at($_[1]);
5615
5616 my $thisline;
5617 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5618  
5619
5620  
5621 while (!$_matched && !$commit)
5622 {
5623
5624 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr2 expr_op expr2>]},
5625 Parse::RecDescent::_tracefirst($_[1]),
5626 q{expr},
5627 $tracelevel)
5628 if defined $::RD_TRACE;
5629 my $thisprod = $thisrule->{"prods"}[0];
5630 $text = $_[1];
5631 my $_savetext;
5632 @item = (q{expr});
5633 %item = (__RULE__ => q{expr});
5634 my $repcount = 0;
5635  
5636  
5637 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr2 expr_op expr2>]},
5638 Parse::RecDescent::_tracefirst($text),
5639 q{expr},
5640 $tracelevel)
5641 if defined $::RD_TRACE;
5642 $expectation->is(q{})->at($text);
5643  
5644 $_tok = undef;
5645 OPLOOP: while (1)
5646 {
5647 $repcount = 0;
5648 my @item;
5649
5650 # MATCH LEFTARG
5651
5652 Parse::RecDescent::_trace(q{Trying subrule: [expr2]},
5653 Parse::RecDescent::_tracefirst($text),
5654 q{expr},
5655 $tracelevel)
5656 if defined $::RD_TRACE;
5657 if (1) { no strict qw{refs};
5658 $expectation->is(q{expr2})->at($text);
5659 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr2($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5660 {
5661
5662 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr2]>>},
5663 Parse::RecDescent::_tracefirst($text),
5664 q{expr},
5665 $tracelevel)
5666 if defined $::RD_TRACE;
5667 $expectation->failed();
5668 last;
5669 }
5670 Parse::RecDescent::_trace(q{>>Matched subrule: [expr2]<< (return value: [}
5671 . $_tok . q{]},
5672
5673 Parse::RecDescent::_tracefirst($text),
5674 q{expr},
5675 $tracelevel)
5676 if defined $::RD_TRACE;
5677 $item{q{expr2}} = $_tok;
5678 push @item, $_tok;
5679
5680 }
5681  
5682  
5683 $repcount++;
5684  
5685 my $savetext = $text;
5686 my $backtrack;
5687  
5688 # MATCH (OP RIGHTARG)(s)
5689 while ($repcount < 100000000)
5690 {
5691 $backtrack = 0;
5692
5693 Parse::RecDescent::_trace(q{Trying subrule: [expr_op]},
5694 Parse::RecDescent::_tracefirst($text),
5695 q{expr},
5696 $tracelevel)
5697 if defined $::RD_TRACE;
5698 if (1) { no strict qw{refs};
5699 $expectation->is(q{expr_op})->at($text);
5700 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr_op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5701 {
5702
5703 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr_op]>>},
5704 Parse::RecDescent::_tracefirst($text),
5705 q{expr},
5706 $tracelevel)
5707 if defined $::RD_TRACE;
5708 $expectation->failed();
5709 last;
5710 }
5711 Parse::RecDescent::_trace(q{>>Matched subrule: [expr_op]<< (return value: [}
5712 . $_tok . q{]},
5713
5714 Parse::RecDescent::_tracefirst($text),
5715 q{expr},
5716 $tracelevel)
5717 if defined $::RD_TRACE;
5718 $item{q{expr_op}} = $_tok;
5719 push @item, $_tok;
5720
5721 }
5722  
5723 $backtrack=1;
5724
5725
5726 Parse::RecDescent::_trace(q{Trying subrule: [expr2]},
5727 Parse::RecDescent::_tracefirst($text),
5728 q{expr},
5729 $tracelevel)
5730 if defined $::RD_TRACE;
5731 if (1) { no strict qw{refs};
5732 $expectation->is(q{expr2})->at($text);
5733 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr2($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5734 {
5735
5736 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr2]>>},
5737 Parse::RecDescent::_tracefirst($text),
5738 q{expr},
5739 $tracelevel)
5740 if defined $::RD_TRACE;
5741 $expectation->failed();
5742 last;
5743 }
5744 Parse::RecDescent::_trace(q{>>Matched subrule: [expr2]<< (return value: [}
5745 . $_tok . q{]},
5746
5747 Parse::RecDescent::_tracefirst($text),
5748 q{expr},
5749 $tracelevel)
5750 if defined $::RD_TRACE;
5751 $item{q{expr2}} = $_tok;
5752 push @item, $_tok;
5753
5754 }
5755  
5756 $savetext = $text;
5757 $repcount++;
5758 }
5759 $text = $savetext;
5760 pop @item if $backtrack;
5761  
5762 unless (@item) { undef $_tok; last }
5763 $_tok = [ @item ];
5764 last;
5765 }
5766  
5767 unless ($repcount>=1)
5768 {
5769 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr2 expr_op expr2>]>>},
5770 Parse::RecDescent::_tracefirst($text),
5771 q{expr},
5772 $tracelevel)
5773 if defined $::RD_TRACE;
5774 $expectation->failed();
5775 last;
5776 }
5777 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr2 expr_op expr2>]<< (return value: [}
5778 . qq{@{$_tok||[]}} . q{]},
5779 Parse::RecDescent::_tracefirst($text),
5780 q{expr},
5781 $tracelevel)
5782 if defined $::RD_TRACE;
5783  
5784 push @item, $item{__DIRECTIVE1__}=$_tok||[];
5785  
5786  
5787 Parse::RecDescent::_trace(q{Trying action},
5788 Parse::RecDescent::_tracefirst($text),
5789 q{expr},
5790 $tracelevel)
5791 if defined $::RD_TRACE;
5792
5793  
5794 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
5795 unless (defined $_tok)
5796 {
5797 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
5798 if defined $::RD_TRACE;
5799 last;
5800 }
5801 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5802 . $_tok . q{])},
5803 Parse::RecDescent::_tracefirst($text))
5804 if defined $::RD_TRACE;
5805 push @item, $_tok;
5806 $item{__ACTION1__}=$_tok;
5807
5808  
5809  
5810 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr2 expr_op expr2>]<<},
5811 Parse::RecDescent::_tracefirst($text),
5812 q{expr},
5813 $tracelevel)
5814 if defined $::RD_TRACE;
5815 $_matched = 1;
5816 last;
5817 }
5818  
5819  
5820 unless ( $_matched || defined($score) )
5821 {
5822
5823  
5824 $_[1] = $text; # NOT SURE THIS IS NEEDED
5825 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
5826 Parse::RecDescent::_tracefirst($_[1]),
5827 q{expr},
5828 $tracelevel)
5829 if defined $::RD_TRACE;
5830 return undef;
5831 }
5832 if (!defined($return) && defined($score))
5833 {
5834 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5835 q{expr},
5836 $tracelevel)
5837 if defined $::RD_TRACE;
5838 $return = $score_return;
5839 }
5840 splice @{$thisparser->{errors}}, $err_at;
5841 $return = $item[$#item] unless defined $return;
5842 if (defined $::RD_TRACE)
5843 {
5844 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5845 $return . q{])}, "",
5846 q{expr},
5847 $tracelevel);
5848 Parse::RecDescent::_trace(q{(consumed: [} .
5849 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5850 Parse::RecDescent::_tracefirst($text),
5851 , q{expr},
5852 $tracelevel)
5853 }
5854 $_[1] = $text;
5855 return $return;
5856 }
5857  
5858 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5859 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr12
5860 {
5861 my $thisparser = $_[0];
5862 use vars q{$tracelevel};
5863 local $tracelevel = ($tracelevel||0)+1;
5864 $ERRORS = 0;
5865 my $thisrule = $thisparser->{"rules"}{"expr12"};
5866
5867 Parse::RecDescent::_trace(q{Trying rule: [expr12]},
5868 Parse::RecDescent::_tracefirst($_[1]),
5869 q{expr12},
5870 $tracelevel)
5871 if defined $::RD_TRACE;
5872  
5873
5874 my $err_at = @{$thisparser->{errors}};
5875  
5876 my $score;
5877 my $score_return;
5878 my $_tok;
5879 my $return = undef;
5880 my $_matched=0;
5881 my $commit=0;
5882 my @item = ();
5883 my %item = ();
5884 my $repeating = defined($_[2]) && $_[2];
5885 my $_noactions = defined($_[3]) && $_[3];
5886 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5887 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5888 my $text;
5889 my $lastsep="";
5890 my $current_match;
5891 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr13 expr12op expr13>});
5892 $expectation->at($_[1]);
5893
5894 my $thisline;
5895 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5896  
5897
5898  
5899 while (!$_matched && !$commit)
5900 {
5901
5902 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr13 expr12op expr13>]},
5903 Parse::RecDescent::_tracefirst($_[1]),
5904 q{expr12},
5905 $tracelevel)
5906 if defined $::RD_TRACE;
5907 my $thisprod = $thisrule->{"prods"}[0];
5908 $text = $_[1];
5909 my $_savetext;
5910 @item = (q{expr12});
5911 %item = (__RULE__ => q{expr12});
5912 my $repcount = 0;
5913  
5914  
5915 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr13 expr12op expr13>]},
5916 Parse::RecDescent::_tracefirst($text),
5917 q{expr12},
5918 $tracelevel)
5919 if defined $::RD_TRACE;
5920 $expectation->is(q{})->at($text);
5921  
5922 $_tok = undef;
5923 OPLOOP: while (1)
5924 {
5925 $repcount = 0;
5926 my @item;
5927
5928 # MATCH LEFTARG
5929
5930 Parse::RecDescent::_trace(q{Trying subrule: [expr13]},
5931 Parse::RecDescent::_tracefirst($text),
5932 q{expr12},
5933 $tracelevel)
5934 if defined $::RD_TRACE;
5935 if (1) { no strict qw{refs};
5936 $expectation->is(q{expr13})->at($text);
5937 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr13($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5938 {
5939
5940 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr13]>>},
5941 Parse::RecDescent::_tracefirst($text),
5942 q{expr12},
5943 $tracelevel)
5944 if defined $::RD_TRACE;
5945 $expectation->failed();
5946 last;
5947 }
5948 Parse::RecDescent::_trace(q{>>Matched subrule: [expr13]<< (return value: [}
5949 . $_tok . q{]},
5950
5951 Parse::RecDescent::_tracefirst($text),
5952 q{expr12},
5953 $tracelevel)
5954 if defined $::RD_TRACE;
5955 $item{q{expr13}} = $_tok;
5956 push @item, $_tok;
5957
5958 }
5959  
5960  
5961 $repcount++;
5962  
5963 my $savetext = $text;
5964 my $backtrack;
5965  
5966 # MATCH (OP RIGHTARG)(s)
5967 while ($repcount < 100000000)
5968 {
5969 $backtrack = 0;
5970
5971 Parse::RecDescent::_trace(q{Trying subrule: [expr12op]},
5972 Parse::RecDescent::_tracefirst($text),
5973 q{expr12},
5974 $tracelevel)
5975 if defined $::RD_TRACE;
5976 if (1) { no strict qw{refs};
5977 $expectation->is(q{expr12op})->at($text);
5978 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr12op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5979 {
5980
5981 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr12op]>>},
5982 Parse::RecDescent::_tracefirst($text),
5983 q{expr12},
5984 $tracelevel)
5985 if defined $::RD_TRACE;
5986 $expectation->failed();
5987 last;
5988 }
5989 Parse::RecDescent::_trace(q{>>Matched subrule: [expr12op]<< (return value: [}
5990 . $_tok . q{]},
5991
5992 Parse::RecDescent::_tracefirst($text),
5993 q{expr12},
5994 $tracelevel)
5995 if defined $::RD_TRACE;
5996 $item{q{expr12op}} = $_tok;
5997 push @item, $_tok;
5998
5999 }
6000  
6001 $backtrack=1;
6002
6003
6004 Parse::RecDescent::_trace(q{Trying subrule: [expr13]},
6005 Parse::RecDescent::_tracefirst($text),
6006 q{expr12},
6007 $tracelevel)
6008 if defined $::RD_TRACE;
6009 if (1) { no strict qw{refs};
6010 $expectation->is(q{expr13})->at($text);
6011 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr13($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6012 {
6013
6014 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr13]>>},
6015 Parse::RecDescent::_tracefirst($text),
6016 q{expr12},
6017 $tracelevel)
6018 if defined $::RD_TRACE;
6019 $expectation->failed();
6020 last;
6021 }
6022 Parse::RecDescent::_trace(q{>>Matched subrule: [expr13]<< (return value: [}
6023 . $_tok . q{]},
6024
6025 Parse::RecDescent::_tracefirst($text),
6026 q{expr12},
6027 $tracelevel)
6028 if defined $::RD_TRACE;
6029 $item{q{expr13}} = $_tok;
6030 push @item, $_tok;
6031
6032 }
6033  
6034 $savetext = $text;
6035 $repcount++;
6036 }
6037 $text = $savetext;
6038 pop @item if $backtrack;
6039  
6040 unless (@item) { undef $_tok; last }
6041 $_tok = [ @item ];
6042 last;
6043 }
6044  
6045 unless ($repcount>=1)
6046 {
6047 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr13 expr12op expr13>]>>},
6048 Parse::RecDescent::_tracefirst($text),
6049 q{expr12},
6050 $tracelevel)
6051 if defined $::RD_TRACE;
6052 $expectation->failed();
6053 last;
6054 }
6055 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr13 expr12op expr13>]<< (return value: [}
6056 . qq{@{$_tok||[]}} . q{]},
6057 Parse::RecDescent::_tracefirst($text),
6058 q{expr12},
6059 $tracelevel)
6060 if defined $::RD_TRACE;
6061  
6062 push @item, $item{__DIRECTIVE1__}=$_tok||[];
6063  
6064  
6065 Parse::RecDescent::_trace(q{Trying action},
6066 Parse::RecDescent::_tracefirst($text),
6067 q{expr12},
6068 $tracelevel)
6069 if defined $::RD_TRACE;
6070
6071  
6072 $_tok = ($_noactions) ? 0 : do { db(@item); nonassoc(@item) };
6073 unless (defined $_tok)
6074 {
6075 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6076 if defined $::RD_TRACE;
6077 last;
6078 }
6079 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6080 . $_tok . q{])},
6081 Parse::RecDescent::_tracefirst($text))
6082 if defined $::RD_TRACE;
6083 push @item, $_tok;
6084 $item{__ACTION1__}=$_tok;
6085
6086  
6087  
6088 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr13 expr12op expr13>]<<},
6089 Parse::RecDescent::_tracefirst($text),
6090 q{expr12},
6091 $tracelevel)
6092 if defined $::RD_TRACE;
6093 $_matched = 1;
6094 last;
6095 }
6096  
6097  
6098 unless ( $_matched || defined($score) )
6099 {
6100
6101  
6102 $_[1] = $text; # NOT SURE THIS IS NEEDED
6103 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6104 Parse::RecDescent::_tracefirst($_[1]),
6105 q{expr12},
6106 $tracelevel)
6107 if defined $::RD_TRACE;
6108 return undef;
6109 }
6110 if (!defined($return) && defined($score))
6111 {
6112 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6113 q{expr12},
6114 $tracelevel)
6115 if defined $::RD_TRACE;
6116 $return = $score_return;
6117 }
6118 splice @{$thisparser->{errors}}, $err_at;
6119 $return = $item[$#item] unless defined $return;
6120 if (defined $::RD_TRACE)
6121 {
6122 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6123 $return . q{])}, "",
6124 q{expr12},
6125 $tracelevel);
6126 Parse::RecDescent::_trace(q{(consumed: [} .
6127 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
6128 Parse::RecDescent::_tracefirst($text),
6129 , q{expr12},
6130 $tracelevel)
6131 }
6132 $_[1] = $text;
6133 return $return;
6134 }
6135  
6136 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6137 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr16
6138 {
6139 my $thisparser = $_[0];
6140 use vars q{$tracelevel};
6141 local $tracelevel = ($tracelevel||0)+1;
6142 $ERRORS = 0;
6143 my $thisrule = $thisparser->{"rules"}{"expr16"};
6144
6145 Parse::RecDescent::_trace(q{Trying rule: [expr16]},
6146 Parse::RecDescent::_tracefirst($_[1]),
6147 q{expr16},
6148 $tracelevel)
6149 if defined $::RD_TRACE;
6150  
6151
6152 my $err_at = @{$thisparser->{errors}};
6153  
6154 my $score;
6155 my $score_return;
6156 my $_tok;
6157 my $return = undef;
6158 my $_matched=0;
6159 my $commit=0;
6160 my @item = ();
6161 my %item = ();
6162 my $repeating = defined($_[2]) && $_[2];
6163 my $_noactions = defined($_[3]) && $_[3];
6164 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
6165 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
6166 my $text;
6167 my $lastsep="";
6168 my $current_match;
6169 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr17 expr16op expr17>});
6170 $expectation->at($_[1]);
6171
6172 my $thisline;
6173 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6174  
6175
6176  
6177 while (!$_matched && !$commit)
6178 {
6179
6180 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr17 expr16op expr17>]},
6181 Parse::RecDescent::_tracefirst($_[1]),
6182 q{expr16},
6183 $tracelevel)
6184 if defined $::RD_TRACE;
6185 my $thisprod = $thisrule->{"prods"}[0];
6186 $text = $_[1];
6187 my $_savetext;
6188 @item = (q{expr16});
6189 %item = (__RULE__ => q{expr16});
6190 my $repcount = 0;
6191  
6192  
6193 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr17 expr16op expr17>]},
6194 Parse::RecDescent::_tracefirst($text),
6195 q{expr16},
6196 $tracelevel)
6197 if defined $::RD_TRACE;
6198 $expectation->is(q{})->at($text);
6199  
6200 $_tok = undef;
6201 OPLOOP: while (1)
6202 {
6203 $repcount = 0;
6204 my @item;
6205
6206 # MATCH LEFTARG
6207
6208 Parse::RecDescent::_trace(q{Trying subrule: [expr17]},
6209 Parse::RecDescent::_tracefirst($text),
6210 q{expr16},
6211 $tracelevel)
6212 if defined $::RD_TRACE;
6213 if (1) { no strict qw{refs};
6214 $expectation->is(q{expr17})->at($text);
6215 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr17($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6216 {
6217
6218 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr17]>>},
6219 Parse::RecDescent::_tracefirst($text),
6220 q{expr16},
6221 $tracelevel)
6222 if defined $::RD_TRACE;
6223 $expectation->failed();
6224 last;
6225 }
6226 Parse::RecDescent::_trace(q{>>Matched subrule: [expr17]<< (return value: [}
6227 . $_tok . q{]},
6228
6229 Parse::RecDescent::_tracefirst($text),
6230 q{expr16},
6231 $tracelevel)
6232 if defined $::RD_TRACE;
6233 $item{q{expr17}} = $_tok;
6234 push @item, $_tok;
6235
6236 }
6237  
6238  
6239 $repcount++;
6240  
6241 my $savetext = $text;
6242 my $backtrack;
6243  
6244 # MATCH (OP RIGHTARG)(s)
6245 while ($repcount < 100000000)
6246 {
6247 $backtrack = 0;
6248
6249 Parse::RecDescent::_trace(q{Trying subrule: [expr16op]},
6250 Parse::RecDescent::_tracefirst($text),
6251 q{expr16},
6252 $tracelevel)
6253 if defined $::RD_TRACE;
6254 if (1) { no strict qw{refs};
6255 $expectation->is(q{expr16op})->at($text);
6256 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr16op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6257 {
6258
6259 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr16op]>>},
6260 Parse::RecDescent::_tracefirst($text),
6261 q{expr16},
6262 $tracelevel)
6263 if defined $::RD_TRACE;
6264 $expectation->failed();
6265 last;
6266 }
6267 Parse::RecDescent::_trace(q{>>Matched subrule: [expr16op]<< (return value: [}
6268 . $_tok . q{]},
6269
6270 Parse::RecDescent::_tracefirst($text),
6271 q{expr16},
6272 $tracelevel)
6273 if defined $::RD_TRACE;
6274 $item{q{expr16op}} = $_tok;
6275 push @item, $_tok;
6276
6277 }
6278  
6279 $backtrack=1;
6280
6281
6282 Parse::RecDescent::_trace(q{Trying subrule: [expr17]},
6283 Parse::RecDescent::_tracefirst($text),
6284 q{expr16},
6285 $tracelevel)
6286 if defined $::RD_TRACE;
6287 if (1) { no strict qw{refs};
6288 $expectation->is(q{expr17})->at($text);
6289 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr17($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6290 {
6291
6292 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr17]>>},
6293 Parse::RecDescent::_tracefirst($text),
6294 q{expr16},
6295 $tracelevel)
6296 if defined $::RD_TRACE;
6297 $expectation->failed();
6298 last;
6299 }
6300 Parse::RecDescent::_trace(q{>>Matched subrule: [expr17]<< (return value: [}
6301 . $_tok . q{]},
6302
6303 Parse::RecDescent::_tracefirst($text),
6304 q{expr16},
6305 $tracelevel)
6306 if defined $::RD_TRACE;
6307 $item{q{expr17}} = $_tok;
6308 push @item, $_tok;
6309
6310 }
6311  
6312 $savetext = $text;
6313 $repcount++;
6314 }
6315 $text = $savetext;
6316 pop @item if $backtrack;
6317  
6318 unless (@item) { undef $_tok; last }
6319 $_tok = [ @item ];
6320 last;
6321 }
6322  
6323 unless ($repcount>=1)
6324 {
6325 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr17 expr16op expr17>]>>},
6326 Parse::RecDescent::_tracefirst($text),
6327 q{expr16},
6328 $tracelevel)
6329 if defined $::RD_TRACE;
6330 $expectation->failed();
6331 last;
6332 }
6333 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr17 expr16op expr17>]<< (return value: [}
6334 . qq{@{$_tok||[]}} . q{]},
6335 Parse::RecDescent::_tracefirst($text),
6336 q{expr16},
6337 $tracelevel)
6338 if defined $::RD_TRACE;
6339  
6340 push @item, $item{__DIRECTIVE1__}=$_tok||[];
6341  
6342  
6343 Parse::RecDescent::_trace(q{Trying action},
6344 Parse::RecDescent::_tracefirst($text),
6345 q{expr16},
6346 $tracelevel)
6347 if defined $::RD_TRACE;
6348
6349  
6350 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
6351 unless (defined $_tok)
6352 {
6353 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6354 if defined $::RD_TRACE;
6355 last;
6356 }
6357 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6358 . $_tok . q{])},
6359 Parse::RecDescent::_tracefirst($text))
6360 if defined $::RD_TRACE;
6361 push @item, $_tok;
6362 $item{__ACTION1__}=$_tok;
6363
6364  
6365  
6366 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr17 expr16op expr17>]<<},
6367 Parse::RecDescent::_tracefirst($text),
6368 q{expr16},
6369 $tracelevel)
6370 if defined $::RD_TRACE;
6371 $_matched = 1;
6372 last;
6373 }
6374  
6375  
6376 unless ( $_matched || defined($score) )
6377 {
6378
6379  
6380 $_[1] = $text; # NOT SURE THIS IS NEEDED
6381 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6382 Parse::RecDescent::_tracefirst($_[1]),
6383 q{expr16},
6384 $tracelevel)
6385 if defined $::RD_TRACE;
6386 return undef;
6387 }
6388 if (!defined($return) && defined($score))
6389 {
6390 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6391 q{expr16},
6392 $tracelevel)
6393 if defined $::RD_TRACE;
6394 $return = $score_return;
6395 }
6396 splice @{$thisparser->{errors}}, $err_at;
6397 $return = $item[$#item] unless defined $return;
6398 if (defined $::RD_TRACE)
6399 {
6400 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6401 $return . q{])}, "",
6402 q{expr16},
6403 $tracelevel);
6404 Parse::RecDescent::_trace(q{(consumed: [} .
6405 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
6406 Parse::RecDescent::_tracefirst($text),
6407 , q{expr16},
6408 $tracelevel)
6409 }
6410 $_[1] = $text;
6411 return $return;
6412 }
6413  
6414 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6415 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr2op
6416 {
6417 my $thisparser = $_[0];
6418 use vars q{$tracelevel};
6419 local $tracelevel = ($tracelevel||0)+1;
6420 $ERRORS = 0;
6421 my $thisrule = $thisparser->{"rules"}{"expr2op"};
6422
6423 Parse::RecDescent::_trace(q{Trying rule: [expr2op]},
6424 Parse::RecDescent::_tracefirst($_[1]),
6425 q{expr2op},
6426 $tracelevel)
6427 if defined $::RD_TRACE;
6428  
6429
6430 my $err_at = @{$thisparser->{errors}};
6431  
6432 my $score;
6433 my $score_return;
6434 my $_tok;
6435 my $return = undef;
6436 my $_matched=0;
6437 my $commit=0;
6438 my @item = ();
6439 my %item = ();
6440 my $repeating = defined($_[2]) && $_[2];
6441 my $_noactions = defined($_[3]) && $_[3];
6442 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
6443 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
6444 my $text;
6445 my $lastsep="";
6446 my $current_match;
6447 my $expectation = new Parse::RecDescent::Expectation(q{'and'});
6448 $expectation->at($_[1]);
6449
6450 my $thisline;
6451 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6452  
6453
6454  
6455 while (!$_matched && !$commit)
6456 {
6457
6458 Parse::RecDescent::_trace(q{Trying production: ['and']},
6459 Parse::RecDescent::_tracefirst($_[1]),
6460 q{expr2op},
6461 $tracelevel)
6462 if defined $::RD_TRACE;
6463 my $thisprod = $thisrule->{"prods"}[0];
6464 $text = $_[1];
6465 my $_savetext;
6466 @item = (q{expr2op});
6467 %item = (__RULE__ => q{expr2op});
6468 my $repcount = 0;
6469  
6470  
6471 Parse::RecDescent::_trace(q{Trying terminal: ['and']},
6472 Parse::RecDescent::_tracefirst($text),
6473 q{expr2op},
6474 $tracelevel)
6475 if defined $::RD_TRACE;
6476 $lastsep = "";
6477 $expectation->is(q{})->at($text);
6478
6479  
6480 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "and"; 1 } and
6481 substr($text,0,length($_tok)) eq $_tok and
6482 do { substr($text,0,length($_tok)) = ""; 1; }
6483 )
6484 {
6485
6486 $expectation->failed();
6487 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
6488 Parse::RecDescent::_tracefirst($text))
6489 if defined $::RD_TRACE;
6490 last;
6491 }
6492 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
6493 . $_tok . q{])},
6494 Parse::RecDescent::_tracefirst($text))
6495 if defined $::RD_TRACE;
6496 push @item, $item{__STRING1__}=$_tok;
6497
6498  
6499 Parse::RecDescent::_trace(q{Trying action},
6500 Parse::RecDescent::_tracefirst($text),
6501 q{expr2op},
6502 $tracelevel)
6503 if defined $::RD_TRACE;
6504
6505  
6506 $_tok = ($_noactions) ? 0 : do { db(@item); return $item[1] };
6507 unless (defined $_tok)
6508 {
6509 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6510 if defined $::RD_TRACE;
6511 last;
6512 }
6513 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6514 . $_tok . q{])},
6515 Parse::RecDescent::_tracefirst($text))
6516 if defined $::RD_TRACE;
6517 push @item, $_tok;
6518 $item{__ACTION1__}=$_tok;
6519
6520  
6521  
6522 Parse::RecDescent::_trace(q{>>Matched production: ['and']<<},
6523 Parse::RecDescent::_tracefirst($text),
6524 q{expr2op},
6525 $tracelevel)
6526 if defined $::RD_TRACE;
6527 $_matched = 1;
6528 last;
6529 }
6530  
6531  
6532 unless ( $_matched || defined($score) )
6533 {
6534
6535  
6536 $_[1] = $text; # NOT SURE THIS IS NEEDED
6537 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6538 Parse::RecDescent::_tracefirst($_[1]),
6539 q{expr2op},
6540 $tracelevel)
6541 if defined $::RD_TRACE;
6542 return undef;
6543 }
6544 if (!defined($return) && defined($score))
6545 {
6546 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6547 q{expr2op},
6548 $tracelevel)
6549 if defined $::RD_TRACE;
6550 $return = $score_return;
6551 }
6552 splice @{$thisparser->{errors}}, $err_at;
6553 $return = $item[$#item] unless defined $return;
6554 if (defined $::RD_TRACE)
6555 {
6556 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6557 $return . q{])}, "",
6558 q{expr2op},
6559 $tracelevel);
6560 Parse::RecDescent::_trace(q{(consumed: [} .
6561 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
6562 Parse::RecDescent::_tracefirst($text),
6563 , q{expr2op},
6564 $tracelevel)
6565 }
6566 $_[1] = $text;
6567 return $return;
6568 }
6569  
6570 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6571 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr_op
6572 {
6573 my $thisparser = $_[0];
6574 use vars q{$tracelevel};
6575 local $tracelevel = ($tracelevel||0)+1;
6576 $ERRORS = 0;
6577 my $thisrule = $thisparser->{"rules"}{"expr_op"};
6578
6579 Parse::RecDescent::_trace(q{Trying rule: [expr_op]},
6580 Parse::RecDescent::_tracefirst($_[1]),
6581 q{expr_op},
6582 $tracelevel)
6583 if defined $::RD_TRACE;
6584  
6585
6586 my $err_at = @{$thisparser->{errors}};
6587  
6588 my $score;
6589 my $score_return;
6590 my $_tok;
6591 my $return = undef;
6592 my $_matched=0;
6593 my $commit=0;
6594 my @item = ();
6595 my %item = ();
6596 my $repeating = defined($_[2]) && $_[2];
6597 my $_noactions = defined($_[3]) && $_[3];
6598 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
6599 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
6600 my $text;
6601 my $lastsep="";
6602 my $current_match;
6603 my $expectation = new Parse::RecDescent::Expectation(q{/or|xor/});
6604 $expectation->at($_[1]);
6605
6606 my $thisline;
6607 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6608  
6609
6610  
6611 while (!$_matched && !$commit)
6612 {
6613
6614 Parse::RecDescent::_trace(q{Trying production: [/or|xor/]},
6615 Parse::RecDescent::_tracefirst($_[1]),
6616 q{expr_op},
6617 $tracelevel)
6618 if defined $::RD_TRACE;
6619 my $thisprod = $thisrule->{"prods"}[0];
6620 $text = $_[1];
6621 my $_savetext;
6622 @item = (q{expr_op});
6623 %item = (__RULE__ => q{expr_op});
6624 my $repcount = 0;
6625  
6626  
6627 Parse::RecDescent::_trace(q{Trying terminal: [/or|xor/]}, Parse::RecDescent::_tracefirst($text),
6628 q{expr_op},
6629 $tracelevel)
6630 if defined $::RD_TRACE;
6631 $lastsep = "";
6632 $expectation->is(q{})->at($text);
6633
6634  
6635 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:or|xor)/)
6636 {
6637
6638 $expectation->failed();
6639 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
6640 Parse::RecDescent::_tracefirst($text))
6641 if defined $::RD_TRACE;
6642  
6643 last;
6644 }
6645 $current_match = substr($text, $-[0], $+[0] - $-[0]);
6646 substr($text,0,length($current_match),q{});
6647 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
6648 . $current_match . q{])},
6649 Parse::RecDescent::_tracefirst($text))
6650 if defined $::RD_TRACE;
6651 push @item, $item{__PATTERN1__}=$current_match;
6652
6653  
6654 Parse::RecDescent::_trace(q{Trying action},
6655 Parse::RecDescent::_tracefirst($text),
6656 q{expr_op},
6657 $tracelevel)
6658 if defined $::RD_TRACE;
6659
6660  
6661 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
6662 unless (defined $_tok)
6663 {
6664 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6665 if defined $::RD_TRACE;
6666 last;
6667 }
6668 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6669 . $_tok . q{])},
6670 Parse::RecDescent::_tracefirst($text))
6671 if defined $::RD_TRACE;
6672 push @item, $_tok;
6673 $item{__ACTION1__}=$_tok;
6674
6675  
6676  
6677 Parse::RecDescent::_trace(q{>>Matched production: [/or|xor/]<<},
6678 Parse::RecDescent::_tracefirst($text),
6679 q{expr_op},
6680 $tracelevel)
6681 if defined $::RD_TRACE;
6682 $_matched = 1;
6683 last;
6684 }
6685  
6686  
6687 unless ( $_matched || defined($score) )
6688 {
6689
6690  
6691 $_[1] = $text; # NOT SURE THIS IS NEEDED
6692 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6693 Parse::RecDescent::_tracefirst($_[1]),
6694 q{expr_op},
6695 $tracelevel)
6696 if defined $::RD_TRACE;
6697 return undef;
6698 }
6699 if (!defined($return) && defined($score))
6700 {
6701 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6702 q{expr_op},
6703 $tracelevel)
6704 if defined $::RD_TRACE;
6705 $return = $score_return;
6706 }
6707 splice @{$thisparser->{errors}}, $err_at;
6708 $return = $item[$#item] unless defined $return;
6709 if (defined $::RD_TRACE)
6710 {
6711 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6712 $return . q{])}, "",
6713 q{expr_op},
6714 $tracelevel);
6715 Parse::RecDescent::_trace(q{(consumed: [} .
6716 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
6717 Parse::RecDescent::_tracefirst($text),
6718 , q{expr_op},
6719 $tracelevel)
6720 }
6721 $_[1] = $text;
6722 return $return;
6723 }
6724  
6725 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
6726 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr7
6727 {
6728 my $thisparser = $_[0];
6729 use vars q{$tracelevel};
6730 local $tracelevel = ($tracelevel||0)+1;
6731 $ERRORS = 0;
6732 my $thisrule = $thisparser->{"rules"}{"expr7"};
6733
6734 Parse::RecDescent::_trace(q{Trying rule: [expr7]},
6735 Parse::RecDescent::_tracefirst($_[1]),
6736 q{expr7},
6737 $tracelevel)
6738 if defined $::RD_TRACE;
6739  
6740
6741 my $err_at = @{$thisparser->{errors}};
6742  
6743 my $score;
6744 my $score_return;
6745 my $_tok;
6746 my $return = undef;
6747 my $_matched=0;
6748 my $commit=0;
6749 my @item = ();
6750 my %item = ();
6751 my $repeating = defined($_[2]) && $_[2];
6752 my $_noactions = defined($_[3]) && $_[3];
6753 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
6754 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
6755 my $text;
6756 my $lastsep="";
6757 my $current_match;
6758 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr8 expr7op expr8>});
6759 $expectation->at($_[1]);
6760
6761 my $thisline;
6762 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
6763  
6764
6765  
6766 while (!$_matched && !$commit)
6767 {
6768
6769 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr8 expr7op expr8>]},
6770 Parse::RecDescent::_tracefirst($_[1]),
6771 q{expr7},
6772 $tracelevel)
6773 if defined $::RD_TRACE;
6774 my $thisprod = $thisrule->{"prods"}[0];
6775 $text = $_[1];
6776 my $_savetext;
6777 @item = (q{expr7});
6778 %item = (__RULE__ => q{expr7});
6779 my $repcount = 0;
6780  
6781  
6782 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr8 expr7op expr8>]},
6783 Parse::RecDescent::_tracefirst($text),
6784 q{expr7},
6785 $tracelevel)
6786 if defined $::RD_TRACE;
6787 $expectation->is(q{})->at($text);
6788  
6789 $_tok = undef;
6790 OPLOOP: while (1)
6791 {
6792 $repcount = 0;
6793 my @item;
6794
6795 # MATCH LEFTARG
6796
6797 Parse::RecDescent::_trace(q{Trying subrule: [expr8]},
6798 Parse::RecDescent::_tracefirst($text),
6799 q{expr7},
6800 $tracelevel)
6801 if defined $::RD_TRACE;
6802 if (1) { no strict qw{refs};
6803 $expectation->is(q{expr8})->at($text);
6804 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr8($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6805 {
6806
6807 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr8]>>},
6808 Parse::RecDescent::_tracefirst($text),
6809 q{expr7},
6810 $tracelevel)
6811 if defined $::RD_TRACE;
6812 $expectation->failed();
6813 last;
6814 }
6815 Parse::RecDescent::_trace(q{>>Matched subrule: [expr8]<< (return value: [}
6816 . $_tok . q{]},
6817
6818 Parse::RecDescent::_tracefirst($text),
6819 q{expr7},
6820 $tracelevel)
6821 if defined $::RD_TRACE;
6822 $item{q{expr8}} = $_tok;
6823 push @item, $_tok;
6824
6825 }
6826  
6827  
6828 $repcount++;
6829  
6830 my $savetext = $text;
6831 my $backtrack;
6832  
6833 # MATCH (OP RIGHTARG)(s)
6834 while ($repcount < 100000000)
6835 {
6836 $backtrack = 0;
6837
6838 Parse::RecDescent::_trace(q{Trying subrule: [expr7op]},
6839 Parse::RecDescent::_tracefirst($text),
6840 q{expr7},
6841 $tracelevel)
6842 if defined $::RD_TRACE;
6843 if (1) { no strict qw{refs};
6844 $expectation->is(q{expr7op})->at($text);
6845 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr7op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6846 {
6847
6848 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr7op]>>},
6849 Parse::RecDescent::_tracefirst($text),
6850 q{expr7},
6851 $tracelevel)
6852 if defined $::RD_TRACE;
6853 $expectation->failed();
6854 last;
6855 }
6856 Parse::RecDescent::_trace(q{>>Matched subrule: [expr7op]<< (return value: [}
6857 . $_tok . q{]},
6858
6859 Parse::RecDescent::_tracefirst($text),
6860 q{expr7},
6861 $tracelevel)
6862 if defined $::RD_TRACE;
6863 $item{q{expr7op}} = $_tok;
6864 push @item, $_tok;
6865
6866 }
6867  
6868 $backtrack=1;
6869
6870
6871 Parse::RecDescent::_trace(q{Trying subrule: [expr8]},
6872 Parse::RecDescent::_tracefirst($text),
6873 q{expr7},
6874 $tracelevel)
6875 if defined $::RD_TRACE;
6876 if (1) { no strict qw{refs};
6877 $expectation->is(q{expr8})->at($text);
6878 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr8($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
6879 {
6880
6881 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr8]>>},
6882 Parse::RecDescent::_tracefirst($text),
6883 q{expr7},
6884 $tracelevel)
6885 if defined $::RD_TRACE;
6886 $expectation->failed();
6887 last;
6888 }
6889 Parse::RecDescent::_trace(q{>>Matched subrule: [expr8]<< (return value: [}
6890 . $_tok . q{]},
6891
6892 Parse::RecDescent::_tracefirst($text),
6893 q{expr7},
6894 $tracelevel)
6895 if defined $::RD_TRACE;
6896 $item{q{expr8}} = $_tok;
6897 push @item, $_tok;
6898
6899 }
6900  
6901 $savetext = $text;
6902 $repcount++;
6903 }
6904 $text = $savetext;
6905 pop @item if $backtrack;
6906  
6907 unless (@item) { undef $_tok; last }
6908 $_tok = [ @item ];
6909 last;
6910 }
6911  
6912 unless ($repcount>=1)
6913 {
6914 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr8 expr7op expr8>]>>},
6915 Parse::RecDescent::_tracefirst($text),
6916 q{expr7},
6917 $tracelevel)
6918 if defined $::RD_TRACE;
6919 $expectation->failed();
6920 last;
6921 }
6922 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr8 expr7op expr8>]<< (return value: [}
6923 . qq{@{$_tok||[]}} . q{]},
6924 Parse::RecDescent::_tracefirst($text),
6925 q{expr7},
6926 $tracelevel)
6927 if defined $::RD_TRACE;
6928  
6929 push @item, $item{__DIRECTIVE1__}=$_tok||[];
6930  
6931  
6932 Parse::RecDescent::_trace(q{Trying action},
6933 Parse::RecDescent::_tracefirst($text),
6934 q{expr7},
6935 $tracelevel)
6936 if defined $::RD_TRACE;
6937
6938  
6939 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
6940 unless (defined $_tok)
6941 {
6942 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
6943 if defined $::RD_TRACE;
6944 last;
6945 }
6946 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
6947 . $_tok . q{])},
6948 Parse::RecDescent::_tracefirst($text))
6949 if defined $::RD_TRACE;
6950 push @item, $_tok;
6951 $item{__ACTION1__}=$_tok;
6952
6953  
6954  
6955 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr8 expr7op expr8>]<<},
6956 Parse::RecDescent::_tracefirst($text),
6957 q{expr7},
6958 $tracelevel)
6959 if defined $::RD_TRACE;
6960 $_matched = 1;
6961 last;
6962 }
6963  
6964  
6965 unless ( $_matched || defined($score) )
6966 {
6967
6968  
6969 $_[1] = $text; # NOT SURE THIS IS NEEDED
6970 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
6971 Parse::RecDescent::_tracefirst($_[1]),
6972 q{expr7},
6973 $tracelevel)
6974 if defined $::RD_TRACE;
6975 return undef;
6976 }
6977 if (!defined($return) && defined($score))
6978 {
6979 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
6980 q{expr7},
6981 $tracelevel)
6982 if defined $::RD_TRACE;
6983 $return = $score_return;
6984 }
6985 splice @{$thisparser->{errors}}, $err_at;
6986 $return = $item[$#item] unless defined $return;
6987 if (defined $::RD_TRACE)
6988 {
6989 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
6990 $return . q{])}, "",
6991 q{expr7},
6992 $tracelevel);
6993 Parse::RecDescent::_trace(q{(consumed: [} .
6994 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
6995 Parse::RecDescent::_tracefirst($text),
6996 , q{expr7},
6997 $tracelevel)
6998 }
6999 $_[1] = $text;
7000 return $return;
7001 }
7002  
7003 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7004 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::constant
7005 {
7006 my $thisparser = $_[0];
7007 use vars q{$tracelevel};
7008 local $tracelevel = ($tracelevel||0)+1;
7009 $ERRORS = 0;
7010 my $thisrule = $thisparser->{"rules"}{"constant"};
7011
7012 Parse::RecDescent::_trace(q{Trying rule: [constant]},
7013 Parse::RecDescent::_tracefirst($_[1]),
7014 q{constant},
7015 $tracelevel)
7016 if defined $::RD_TRACE;
7017  
7018
7019 my $err_at = @{$thisparser->{errors}};
7020  
7021 my $score;
7022 my $score_return;
7023 my $_tok;
7024 my $return = undef;
7025 my $_matched=0;
7026 my $commit=0;
7027 my @item = ();
7028 my %item = ();
7029 my $repeating = defined($_[2]) && $_[2];
7030 my $_noactions = defined($_[3]) && $_[3];
7031 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
7032 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
7033 my $text;
7034 my $lastsep="";
7035 my $current_match;
7036 my $expectation = new Parse::RecDescent::Expectation(q{/ -? (?: \\d+ (?: \\.\\d+ )? | (?: \\.\\d+) ) (?:[eE]-?\\d+)? /x, or ''', or '"'});
7037 $expectation->at($_[1]);
7038
7039 my $thisline;
7040 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7041  
7042
7043  
7044 while (!$_matched && !$commit)
7045 {
7046
7047 Parse::RecDescent::_trace(q{Trying production: [/ -? (?: \\d+ (?: \\.\\d+ )? | (?: \\.\\d+) ) (?:[eE]-?\\d+)? /x]},
7048 Parse::RecDescent::_tracefirst($_[1]),
7049 q{constant},
7050 $tracelevel)
7051 if defined $::RD_TRACE;
7052 my $thisprod = $thisrule->{"prods"}[0];
7053 $text = $_[1];
7054 my $_savetext;
7055 @item = (q{constant});
7056 %item = (__RULE__ => q{constant});
7057 my $repcount = 0;
7058  
7059  
7060 Parse::RecDescent::_trace(q{Trying terminal: [/ -? (?: \\d+ (?: \\.\\d+ )? | (?: \\.\\d+) ) (?:[eE]-?\\d+)? /x]}, Parse::RecDescent::_tracefirst($text),
7061 q{constant},
7062 $tracelevel)
7063 if defined $::RD_TRACE;
7064 $lastsep = "";
7065 $expectation->is(q{})->at($text);
7066
7067  
7068 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?: -? (?: \d+ (?: \.\d+ )? | (?: \.\d+) ) (?:[eE]-?\d+)? )/x)
7069 {
7070
7071 $expectation->failed();
7072 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7073 Parse::RecDescent::_tracefirst($text))
7074 if defined $::RD_TRACE;
7075  
7076 last;
7077 }
7078 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7079 substr($text,0,length($current_match),q{});
7080 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7081 . $current_match . q{])},
7082 Parse::RecDescent::_tracefirst($text))
7083 if defined $::RD_TRACE;
7084 push @item, $item{__PATTERN1__}=$current_match;
7085
7086  
7087 Parse::RecDescent::_trace(q{Trying action},
7088 Parse::RecDescent::_tracefirst($text),
7089 q{constant},
7090 $tracelevel)
7091 if defined $::RD_TRACE;
7092
7093  
7094 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
7095 unless (defined $_tok)
7096 {
7097 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7098 if defined $::RD_TRACE;
7099 last;
7100 }
7101 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7102 . $_tok . q{])},
7103 Parse::RecDescent::_tracefirst($text))
7104 if defined $::RD_TRACE;
7105 push @item, $_tok;
7106 $item{__ACTION1__}=$_tok;
7107
7108  
7109  
7110 Parse::RecDescent::_trace(q{>>Matched production: [/ -? (?: \\d+ (?: \\.\\d+ )? | (?: \\.\\d+) ) (?:[eE]-?\\d+)? /x]<<},
7111 Parse::RecDescent::_tracefirst($text),
7112 q{constant},
7113 $tracelevel)
7114 if defined $::RD_TRACE;
7115 $_matched = 1;
7116 last;
7117 }
7118  
7119  
7120 while (!$_matched && !$commit)
7121 {
7122
7123 Parse::RecDescent::_trace(q{Trying production: [''' /[^"]*/ '"']},
7124 Parse::RecDescent::_tracefirst($_[1]),
7125 q{constant},
7126 $tracelevel)
7127 if defined $::RD_TRACE;
7128 my $thisprod = $thisrule->{"prods"}[1];
7129 $text = $_[1];
7130 my $_savetext;
7131 @item = (q{constant});
7132 %item = (__RULE__ => q{constant});
7133 my $repcount = 0;
7134  
7135  
7136 Parse::RecDescent::_trace(q{Trying terminal: [''']},
7137 Parse::RecDescent::_tracefirst($text),
7138 q{constant},
7139 $tracelevel)
7140 if defined $::RD_TRACE;
7141 $lastsep = "";
7142 $expectation->is(q{})->at($text);
7143
7144  
7145 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "'"; 1 } and
7146 substr($text,0,length($_tok)) eq $_tok and
7147 do { substr($text,0,length($_tok)) = ""; 1; }
7148 )
7149 {
7150
7151 $expectation->failed();
7152 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7153 Parse::RecDescent::_tracefirst($text))
7154 if defined $::RD_TRACE;
7155 last;
7156 }
7157 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7158 . $_tok . q{])},
7159 Parse::RecDescent::_tracefirst($text))
7160 if defined $::RD_TRACE;
7161 push @item, $item{__STRING1__}=$_tok;
7162
7163  
7164 Parse::RecDescent::_trace(q{Trying terminal: [/[^"]*/]}, Parse::RecDescent::_tracefirst($text),
7165 q{constant},
7166 $tracelevel)
7167 if defined $::RD_TRACE;
7168 $lastsep = "";
7169 $expectation->is(q{/[^"]*/})->at($text);
7170
7171  
7172 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[^"]*)/)
7173 {
7174
7175 $expectation->failed();
7176 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7177 Parse::RecDescent::_tracefirst($text))
7178 if defined $::RD_TRACE;
7179  
7180 last;
7181 }
7182 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7183 substr($text,0,length($current_match),q{});
7184 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7185 . $current_match . q{])},
7186 Parse::RecDescent::_tracefirst($text))
7187 if defined $::RD_TRACE;
7188 push @item, $item{__PATTERN1__}=$current_match;
7189
7190  
7191 Parse::RecDescent::_trace(q{Trying terminal: ['"']},
7192 Parse::RecDescent::_tracefirst($text),
7193 q{constant},
7194 $tracelevel)
7195 if defined $::RD_TRACE;
7196 $lastsep = "";
7197 $expectation->is(q{'"'})->at($text);
7198
7199  
7200 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\"/)
7201 {
7202
7203 $expectation->failed();
7204 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
7205 Parse::RecDescent::_tracefirst($text))
7206 if defined $::RD_TRACE;
7207 last;
7208 }
7209 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7210 substr($text,0,length($current_match),q{});
7211 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7212 . $current_match . q{])},
7213 Parse::RecDescent::_tracefirst($text))
7214 if defined $::RD_TRACE;
7215 push @item, $item{__STRING2__}=$current_match;
7216
7217  
7218 Parse::RecDescent::_trace(q{Trying action},
7219 Parse::RecDescent::_tracefirst($text),
7220 q{constant},
7221 $tracelevel)
7222 if defined $::RD_TRACE;
7223
7224  
7225 $_tok = ($_noactions) ? 0 : do { db(@item); $item[2] };
7226 unless (defined $_tok)
7227 {
7228 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7229 if defined $::RD_TRACE;
7230 last;
7231 }
7232 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7233 . $_tok . q{])},
7234 Parse::RecDescent::_tracefirst($text))
7235 if defined $::RD_TRACE;
7236 push @item, $_tok;
7237 $item{__ACTION1__}=$_tok;
7238
7239  
7240  
7241 Parse::RecDescent::_trace(q{>>Matched production: [''' /[^"]*/ '"']<<},
7242 Parse::RecDescent::_tracefirst($text),
7243 q{constant},
7244 $tracelevel)
7245 if defined $::RD_TRACE;
7246 $_matched = 1;
7247 last;
7248 }
7249  
7250  
7251 while (!$_matched && !$commit)
7252 {
7253
7254 Parse::RecDescent::_trace(q{Trying production: ['"' /[^']*/ ''']},
7255 Parse::RecDescent::_tracefirst($_[1]),
7256 q{constant},
7257 $tracelevel)
7258 if defined $::RD_TRACE;
7259 my $thisprod = $thisrule->{"prods"}[2];
7260 $text = $_[1];
7261 my $_savetext;
7262 @item = (q{constant});
7263 %item = (__RULE__ => q{constant});
7264 my $repcount = 0;
7265  
7266  
7267 Parse::RecDescent::_trace(q{Trying terminal: ['"']},
7268 Parse::RecDescent::_tracefirst($text),
7269 q{constant},
7270 $tracelevel)
7271 if defined $::RD_TRACE;
7272 $lastsep = "";
7273 $expectation->is(q{})->at($text);
7274
7275  
7276 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\"/)
7277 {
7278
7279 $expectation->failed();
7280 Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
7281 Parse::RecDescent::_tracefirst($text))
7282 if defined $::RD_TRACE;
7283 last;
7284 }
7285 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7286 substr($text,0,length($current_match),q{});
7287 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7288 . $current_match . q{])},
7289 Parse::RecDescent::_tracefirst($text))
7290 if defined $::RD_TRACE;
7291 push @item, $item{__STRING1__}=$current_match;
7292
7293  
7294 Parse::RecDescent::_trace(q{Trying terminal: [/[^']*/]}, Parse::RecDescent::_tracefirst($text),
7295 q{constant},
7296 $tracelevel)
7297 if defined $::RD_TRACE;
7298 $lastsep = "";
7299 $expectation->is(q{/[^']*/})->at($text);
7300
7301  
7302 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:[^']*)/)
7303 {
7304
7305 $expectation->failed();
7306 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7307 Parse::RecDescent::_tracefirst($text))
7308 if defined $::RD_TRACE;
7309  
7310 last;
7311 }
7312 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7313 substr($text,0,length($current_match),q{});
7314 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7315 . $current_match . q{])},
7316 Parse::RecDescent::_tracefirst($text))
7317 if defined $::RD_TRACE;
7318 push @item, $item{__PATTERN1__}=$current_match;
7319
7320  
7321 Parse::RecDescent::_trace(q{Trying terminal: [''']},
7322 Parse::RecDescent::_tracefirst($text),
7323 q{constant},
7324 $tracelevel)
7325 if defined $::RD_TRACE;
7326 $lastsep = "";
7327 $expectation->is(q{'''})->at($text);
7328
7329  
7330 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "'"; 1 } and
7331 substr($text,0,length($_tok)) eq $_tok and
7332 do { substr($text,0,length($_tok)) = ""; 1; }
7333 )
7334 {
7335
7336 $expectation->failed();
7337 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7338 Parse::RecDescent::_tracefirst($text))
7339 if defined $::RD_TRACE;
7340 last;
7341 }
7342 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7343 . $_tok . q{])},
7344 Parse::RecDescent::_tracefirst($text))
7345 if defined $::RD_TRACE;
7346 push @item, $item{__STRING2__}=$_tok;
7347
7348  
7349 Parse::RecDescent::_trace(q{Trying action},
7350 Parse::RecDescent::_tracefirst($text),
7351 q{constant},
7352 $tracelevel)
7353 if defined $::RD_TRACE;
7354
7355  
7356 $_tok = ($_noactions) ? 0 : do { db(@item); $item[2] };
7357 unless (defined $_tok)
7358 {
7359 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7360 if defined $::RD_TRACE;
7361 last;
7362 }
7363 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7364 . $_tok . q{])},
7365 Parse::RecDescent::_tracefirst($text))
7366 if defined $::RD_TRACE;
7367 push @item, $_tok;
7368 $item{__ACTION1__}=$_tok;
7369
7370  
7371  
7372 Parse::RecDescent::_trace(q{>>Matched production: ['"' /[^']*/ ''']<<},
7373 Parse::RecDescent::_tracefirst($text),
7374 q{constant},
7375 $tracelevel)
7376 if defined $::RD_TRACE;
7377 $_matched = 1;
7378 last;
7379 }
7380  
7381  
7382 unless ( $_matched || defined($score) )
7383 {
7384
7385  
7386 $_[1] = $text; # NOT SURE THIS IS NEEDED
7387 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7388 Parse::RecDescent::_tracefirst($_[1]),
7389 q{constant},
7390 $tracelevel)
7391 if defined $::RD_TRACE;
7392 return undef;
7393 }
7394 if (!defined($return) && defined($score))
7395 {
7396 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7397 q{constant},
7398 $tracelevel)
7399 if defined $::RD_TRACE;
7400 $return = $score_return;
7401 }
7402 splice @{$thisparser->{errors}}, $err_at;
7403 $return = $item[$#item] unless defined $return;
7404 if (defined $::RD_TRACE)
7405 {
7406 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7407 $return . q{])}, "",
7408 q{constant},
7409 $tracelevel);
7410 Parse::RecDescent::_trace(q{(consumed: [} .
7411 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
7412 Parse::RecDescent::_tracefirst($text),
7413 , q{constant},
7414 $tracelevel)
7415 }
7416 $_[1] = $text;
7417 return $return;
7418 }
7419  
7420 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7421 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr9op
7422 {
7423 my $thisparser = $_[0];
7424 use vars q{$tracelevel};
7425 local $tracelevel = ($tracelevel||0)+1;
7426 $ERRORS = 0;
7427 my $thisrule = $thisparser->{"rules"}{"expr9op"};
7428
7429 Parse::RecDescent::_trace(q{Trying rule: [expr9op]},
7430 Parse::RecDescent::_tracefirst($_[1]),
7431 q{expr9op},
7432 $tracelevel)
7433 if defined $::RD_TRACE;
7434  
7435
7436 my $err_at = @{$thisparser->{errors}};
7437  
7438 my $score;
7439 my $score_return;
7440 my $_tok;
7441 my $return = undef;
7442 my $_matched=0;
7443 my $commit=0;
7444 my @item = ();
7445 my %item = ();
7446 my $repeating = defined($_[2]) && $_[2];
7447 my $_noactions = defined($_[3]) && $_[3];
7448 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
7449 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
7450 my $text;
7451 my $lastsep="";
7452 my $current_match;
7453 my $expectation = new Parse::RecDescent::Expectation(q{/(\\||\\^)/});
7454 $expectation->at($_[1]);
7455
7456 my $thisline;
7457 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7458  
7459
7460  
7461 while (!$_matched && !$commit)
7462 {
7463
7464 Parse::RecDescent::_trace(q{Trying production: [/(\\||\\^)/]},
7465 Parse::RecDescent::_tracefirst($_[1]),
7466 q{expr9op},
7467 $tracelevel)
7468 if defined $::RD_TRACE;
7469 my $thisprod = $thisrule->{"prods"}[0];
7470 $text = $_[1];
7471 my $_savetext;
7472 @item = (q{expr9op});
7473 %item = (__RULE__ => q{expr9op});
7474 my $repcount = 0;
7475  
7476  
7477 Parse::RecDescent::_trace(q{Trying terminal: [/(\\||\\^)/]}, Parse::RecDescent::_tracefirst($text),
7478 q{expr9op},
7479 $tracelevel)
7480 if defined $::RD_TRACE;
7481 $lastsep = "";
7482 $expectation->is(q{})->at($text);
7483
7484  
7485 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(\||\^))/)
7486 {
7487
7488 $expectation->failed();
7489 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7490 Parse::RecDescent::_tracefirst($text))
7491 if defined $::RD_TRACE;
7492  
7493 last;
7494 }
7495 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7496 substr($text,0,length($current_match),q{});
7497 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7498 . $current_match . q{])},
7499 Parse::RecDescent::_tracefirst($text))
7500 if defined $::RD_TRACE;
7501 push @item, $item{__PATTERN1__}=$current_match;
7502
7503  
7504 Parse::RecDescent::_trace(q{Trying action},
7505 Parse::RecDescent::_tracefirst($text),
7506 q{expr9op},
7507 $tracelevel)
7508 if defined $::RD_TRACE;
7509
7510  
7511 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
7512 unless (defined $_tok)
7513 {
7514 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7515 if defined $::RD_TRACE;
7516 last;
7517 }
7518 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7519 . $_tok . q{])},
7520 Parse::RecDescent::_tracefirst($text))
7521 if defined $::RD_TRACE;
7522 push @item, $_tok;
7523 $item{__ACTION1__}=$_tok;
7524
7525  
7526  
7527 Parse::RecDescent::_trace(q{>>Matched production: [/(\\||\\^)/]<<},
7528 Parse::RecDescent::_tracefirst($text),
7529 q{expr9op},
7530 $tracelevel)
7531 if defined $::RD_TRACE;
7532 $_matched = 1;
7533 last;
7534 }
7535  
7536  
7537 unless ( $_matched || defined($score) )
7538 {
7539
7540  
7541 $_[1] = $text; # NOT SURE THIS IS NEEDED
7542 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7543 Parse::RecDescent::_tracefirst($_[1]),
7544 q{expr9op},
7545 $tracelevel)
7546 if defined $::RD_TRACE;
7547 return undef;
7548 }
7549 if (!defined($return) && defined($score))
7550 {
7551 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7552 q{expr9op},
7553 $tracelevel)
7554 if defined $::RD_TRACE;
7555 $return = $score_return;
7556 }
7557 splice @{$thisparser->{errors}}, $err_at;
7558 $return = $item[$#item] unless defined $return;
7559 if (defined $::RD_TRACE)
7560 {
7561 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7562 $return . q{])}, "",
7563 q{expr9op},
7564 $tracelevel);
7565 Parse::RecDescent::_trace(q{(consumed: [} .
7566 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
7567 Parse::RecDescent::_tracefirst($text),
7568 , q{expr9op},
7569 $tracelevel)
7570 }
7571 $_[1] = $text;
7572 return $return;
7573 }
7574  
7575 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7576 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::conditional
7577 {
7578 my $thisparser = $_[0];
7579 use vars q{$tracelevel};
7580 local $tracelevel = ($tracelevel||0)+1;
7581 $ERRORS = 0;
7582 my $thisrule = $thisparser->{"rules"}{"conditional"};
7583
7584 Parse::RecDescent::_trace(q{Trying rule: [conditional]},
7585 Parse::RecDescent::_tracefirst($_[1]),
7586 q{conditional},
7587 $tracelevel)
7588 if defined $::RD_TRACE;
7589  
7590
7591 my $err_at = @{$thisparser->{errors}};
7592  
7593 my $score;
7594 my $score_return;
7595 my $_tok;
7596 my $return = undef;
7597 my $_matched=0;
7598 my $commit=0;
7599 my @item = ();
7600 my %item = ();
7601 my $repeating = defined($_[2]) && $_[2];
7602 my $_noactions = defined($_[3]) && $_[3];
7603 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
7604 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
7605 my $text;
7606 my $lastsep="";
7607 my $current_match;
7608 my $expectation = new Parse::RecDescent::Expectation(q{expr});
7609 $expectation->at($_[1]);
7610
7611 my $thisline;
7612 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7613  
7614
7615  
7616 while (!$_matched && !$commit)
7617 {
7618
7619 Parse::RecDescent::_trace(q{Trying production: [expr /\\Z/]},
7620 Parse::RecDescent::_tracefirst($_[1]),
7621 q{conditional},
7622 $tracelevel)
7623 if defined $::RD_TRACE;
7624 my $thisprod = $thisrule->{"prods"}[0];
7625 $text = $_[1];
7626 my $_savetext;
7627 @item = (q{conditional});
7628 %item = (__RULE__ => q{conditional});
7629 my $repcount = 0;
7630  
7631  
7632 Parse::RecDescent::_trace(q{Trying subrule: [expr]},
7633 Parse::RecDescent::_tracefirst($text),
7634 q{conditional},
7635 $tracelevel)
7636 if defined $::RD_TRACE;
7637 if (1) { no strict qw{refs};
7638 $expectation->is(q{})->at($text);
7639 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7640 {
7641
7642 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr]>>},
7643 Parse::RecDescent::_tracefirst($text),
7644 q{conditional},
7645 $tracelevel)
7646 if defined $::RD_TRACE;
7647 $expectation->failed();
7648 last;
7649 }
7650 Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [}
7651 . $_tok . q{]},
7652
7653 Parse::RecDescent::_tracefirst($text),
7654 q{conditional},
7655 $tracelevel)
7656 if defined $::RD_TRACE;
7657 $item{q{expr}} = $_tok;
7658 push @item, $_tok;
7659
7660 }
7661  
7662 Parse::RecDescent::_trace(q{Trying terminal: [/\\Z/]}, Parse::RecDescent::_tracefirst($text),
7663 q{conditional},
7664 $tracelevel)
7665 if defined $::RD_TRACE;
7666 $lastsep = "";
7667 $expectation->is(q{/\\Z/})->at($text);
7668
7669  
7670 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\Z)/)
7671 {
7672
7673 $expectation->failed();
7674 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7675 Parse::RecDescent::_tracefirst($text))
7676 if defined $::RD_TRACE;
7677  
7678 last;
7679 }
7680 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7681 substr($text,0,length($current_match),q{});
7682 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7683 . $current_match . q{])},
7684 Parse::RecDescent::_tracefirst($text))
7685 if defined $::RD_TRACE;
7686 push @item, $item{__PATTERN1__}=$current_match;
7687
7688  
7689 Parse::RecDescent::_trace(q{Trying action},
7690 Parse::RecDescent::_tracefirst($text),
7691 q{conditional},
7692 $tracelevel)
7693 if defined $::RD_TRACE;
7694
7695  
7696 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
7697 unless (defined $_tok)
7698 {
7699 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7700 if defined $::RD_TRACE;
7701 last;
7702 }
7703 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7704 . $_tok . q{])},
7705 Parse::RecDescent::_tracefirst($text))
7706 if defined $::RD_TRACE;
7707 push @item, $_tok;
7708 $item{__ACTION1__}=$_tok;
7709
7710  
7711  
7712 Parse::RecDescent::_trace(q{>>Matched production: [expr /\\Z/]<<},
7713 Parse::RecDescent::_tracefirst($text),
7714 q{conditional},
7715 $tracelevel)
7716 if defined $::RD_TRACE;
7717 $_matched = 1;
7718 last;
7719 }
7720  
7721  
7722 unless ( $_matched || defined($score) )
7723 {
7724
7725  
7726 $_[1] = $text; # NOT SURE THIS IS NEEDED
7727 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7728 Parse::RecDescent::_tracefirst($_[1]),
7729 q{conditional},
7730 $tracelevel)
7731 if defined $::RD_TRACE;
7732 return undef;
7733 }
7734 if (!defined($return) && defined($score))
7735 {
7736 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7737 q{conditional},
7738 $tracelevel)
7739 if defined $::RD_TRACE;
7740 $return = $score_return;
7741 }
7742 splice @{$thisparser->{errors}}, $err_at;
7743 $return = $item[$#item] unless defined $return;
7744 if (defined $::RD_TRACE)
7745 {
7746 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7747 $return . q{])}, "",
7748 q{conditional},
7749 $tracelevel);
7750 Parse::RecDescent::_trace(q{(consumed: [} .
7751 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
7752 Parse::RecDescent::_tracefirst($text),
7753 , q{conditional},
7754 $tracelevel)
7755 }
7756 $_[1] = $text;
7757 return $return;
7758 }
7759  
7760 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7761 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr14op
7762 {
7763 my $thisparser = $_[0];
7764 use vars q{$tracelevel};
7765 local $tracelevel = ($tracelevel||0)+1;
7766 $ERRORS = 0;
7767 my $thisrule = $thisparser->{"rules"}{"expr14op"};
7768
7769 Parse::RecDescent::_trace(q{Trying rule: [expr14op]},
7770 Parse::RecDescent::_tracefirst($_[1]),
7771 q{expr14op},
7772 $tracelevel)
7773 if defined $::RD_TRACE;
7774  
7775
7776 my $err_at = @{$thisparser->{errors}};
7777  
7778 my $score;
7779 my $score_return;
7780 my $_tok;
7781 my $return = undef;
7782 my $_matched=0;
7783 my $commit=0;
7784 my @item = ();
7785 my %item = ();
7786 my $repeating = defined($_[2]) && $_[2];
7787 my $_noactions = defined($_[3]) && $_[3];
7788 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
7789 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
7790 my $text;
7791 my $lastsep="";
7792 my $current_match;
7793 my $expectation = new Parse::RecDescent::Expectation(q{/(\\+|-|\\.)/});
7794 $expectation->at($_[1]);
7795
7796 my $thisline;
7797 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7798  
7799
7800  
7801 while (!$_matched && !$commit)
7802 {
7803
7804 Parse::RecDescent::_trace(q{Trying production: [/(\\+|-|\\.)/]},
7805 Parse::RecDescent::_tracefirst($_[1]),
7806 q{expr14op},
7807 $tracelevel)
7808 if defined $::RD_TRACE;
7809 my $thisprod = $thisrule->{"prods"}[0];
7810 $text = $_[1];
7811 my $_savetext;
7812 @item = (q{expr14op});
7813 %item = (__RULE__ => q{expr14op});
7814 my $repcount = 0;
7815  
7816  
7817 Parse::RecDescent::_trace(q{Trying terminal: [/(\\+|-|\\.)/]}, Parse::RecDescent::_tracefirst($text),
7818 q{expr14op},
7819 $tracelevel)
7820 if defined $::RD_TRACE;
7821 $lastsep = "";
7822 $expectation->is(q{})->at($text);
7823
7824  
7825 unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:(\+|-|\.))/)
7826 {
7827
7828 $expectation->failed();
7829 Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
7830 Parse::RecDescent::_tracefirst($text))
7831 if defined $::RD_TRACE;
7832  
7833 last;
7834 }
7835 $current_match = substr($text, $-[0], $+[0] - $-[0]);
7836 substr($text,0,length($current_match),q{});
7837 Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
7838 . $current_match . q{])},
7839 Parse::RecDescent::_tracefirst($text))
7840 if defined $::RD_TRACE;
7841 push @item, $item{__PATTERN1__}=$current_match;
7842
7843  
7844 Parse::RecDescent::_trace(q{Trying action},
7845 Parse::RecDescent::_tracefirst($text),
7846 q{expr14op},
7847 $tracelevel)
7848 if defined $::RD_TRACE;
7849
7850  
7851 $_tok = ($_noactions) ? 0 : do { db(@item); $item[1] };
7852 unless (defined $_tok)
7853 {
7854 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
7855 if defined $::RD_TRACE;
7856 last;
7857 }
7858 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
7859 . $_tok . q{])},
7860 Parse::RecDescent::_tracefirst($text))
7861 if defined $::RD_TRACE;
7862 push @item, $_tok;
7863 $item{__ACTION1__}=$_tok;
7864
7865  
7866  
7867 Parse::RecDescent::_trace(q{>>Matched production: [/(\\+|-|\\.)/]<<},
7868 Parse::RecDescent::_tracefirst($text),
7869 q{expr14op},
7870 $tracelevel)
7871 if defined $::RD_TRACE;
7872 $_matched = 1;
7873 last;
7874 }
7875  
7876  
7877 unless ( $_matched || defined($score) )
7878 {
7879
7880  
7881 $_[1] = $text; # NOT SURE THIS IS NEEDED
7882 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
7883 Parse::RecDescent::_tracefirst($_[1]),
7884 q{expr14op},
7885 $tracelevel)
7886 if defined $::RD_TRACE;
7887 return undef;
7888 }
7889 if (!defined($return) && defined($score))
7890 {
7891 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
7892 q{expr14op},
7893 $tracelevel)
7894 if defined $::RD_TRACE;
7895 $return = $score_return;
7896 }
7897 splice @{$thisparser->{errors}}, $err_at;
7898 $return = $item[$#item] unless defined $return;
7899 if (defined $::RD_TRACE)
7900 {
7901 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
7902 $return . q{])}, "",
7903 q{expr14op},
7904 $tracelevel);
7905 Parse::RecDescent::_trace(q{(consumed: [} .
7906 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
7907 Parse::RecDescent::_tracefirst($text),
7908 , q{expr14op},
7909 $tracelevel)
7910 }
7911 $_[1] = $text;
7912 return $return;
7913 }
7914  
7915 # ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
7916 sub Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr9
7917 {
7918 my $thisparser = $_[0];
7919 use vars q{$tracelevel};
7920 local $tracelevel = ($tracelevel||0)+1;
7921 $ERRORS = 0;
7922 my $thisrule = $thisparser->{"rules"}{"expr9"};
7923
7924 Parse::RecDescent::_trace(q{Trying rule: [expr9]},
7925 Parse::RecDescent::_tracefirst($_[1]),
7926 q{expr9},
7927 $tracelevel)
7928 if defined $::RD_TRACE;
7929  
7930
7931 my $err_at = @{$thisparser->{errors}};
7932  
7933 my $score;
7934 my $score_return;
7935 my $_tok;
7936 my $return = undef;
7937 my $_matched=0;
7938 my $commit=0;
7939 my @item = ();
7940 my %item = ();
7941 my $repeating = defined($_[2]) && $_[2];
7942 my $_noactions = defined($_[3]) && $_[3];
7943 my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
7944 my %arg = ($#arg & 01) ? @arg : (@arg, undef);
7945 my $text;
7946 my $lastsep="";
7947 my $current_match;
7948 my $expectation = new Parse::RecDescent::Expectation(q{<leftop: expr10 expr9op expr10>});
7949 $expectation->at($_[1]);
7950
7951 my $thisline;
7952 tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
7953  
7954
7955  
7956 while (!$_matched && !$commit)
7957 {
7958
7959 Parse::RecDescent::_trace(q{Trying production: [<leftop: expr10 expr9op expr10>]},
7960 Parse::RecDescent::_tracefirst($_[1]),
7961 q{expr9},
7962 $tracelevel)
7963 if defined $::RD_TRACE;
7964 my $thisprod = $thisrule->{"prods"}[0];
7965 $text = $_[1];
7966 my $_savetext;
7967 @item = (q{expr9});
7968 %item = (__RULE__ => q{expr9});
7969 my $repcount = 0;
7970  
7971  
7972 Parse::RecDescent::_trace(q{Trying operator: [<leftop: expr10 expr9op expr10>]},
7973 Parse::RecDescent::_tracefirst($text),
7974 q{expr9},
7975 $tracelevel)
7976 if defined $::RD_TRACE;
7977 $expectation->is(q{})->at($text);
7978  
7979 $_tok = undef;
7980 OPLOOP: while (1)
7981 {
7982 $repcount = 0;
7983 my @item;
7984
7985 # MATCH LEFTARG
7986
7987 Parse::RecDescent::_trace(q{Trying subrule: [expr10]},
7988 Parse::RecDescent::_tracefirst($text),
7989 q{expr9},
7990 $tracelevel)
7991 if defined $::RD_TRACE;
7992 if (1) { no strict qw{refs};
7993 $expectation->is(q{expr10})->at($text);
7994 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr10($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
7995 {
7996
7997 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr10]>>},
7998 Parse::RecDescent::_tracefirst($text),
7999 q{expr9},
8000 $tracelevel)
8001 if defined $::RD_TRACE;
8002 $expectation->failed();
8003 last;
8004 }
8005 Parse::RecDescent::_trace(q{>>Matched subrule: [expr10]<< (return value: [}
8006 . $_tok . q{]},
8007
8008 Parse::RecDescent::_tracefirst($text),
8009 q{expr9},
8010 $tracelevel)
8011 if defined $::RD_TRACE;
8012 $item{q{expr10}} = $_tok;
8013 push @item, $_tok;
8014
8015 }
8016  
8017  
8018 $repcount++;
8019  
8020 my $savetext = $text;
8021 my $backtrack;
8022  
8023 # MATCH (OP RIGHTARG)(s)
8024 while ($repcount < 100000000)
8025 {
8026 $backtrack = 0;
8027
8028 Parse::RecDescent::_trace(q{Trying subrule: [expr9op]},
8029 Parse::RecDescent::_tracefirst($text),
8030 q{expr9},
8031 $tracelevel)
8032 if defined $::RD_TRACE;
8033 if (1) { no strict qw{refs};
8034 $expectation->is(q{expr9op})->at($text);
8035 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr9op($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
8036 {
8037
8038 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr9op]>>},
8039 Parse::RecDescent::_tracefirst($text),
8040 q{expr9},
8041 $tracelevel)
8042 if defined $::RD_TRACE;
8043 $expectation->failed();
8044 last;
8045 }
8046 Parse::RecDescent::_trace(q{>>Matched subrule: [expr9op]<< (return value: [}
8047 . $_tok . q{]},
8048
8049 Parse::RecDescent::_tracefirst($text),
8050 q{expr9},
8051 $tracelevel)
8052 if defined $::RD_TRACE;
8053 $item{q{expr9op}} = $_tok;
8054 push @item, $_tok;
8055
8056 }
8057  
8058 $backtrack=1;
8059
8060
8061 Parse::RecDescent::_trace(q{Trying subrule: [expr10]},
8062 Parse::RecDescent::_tracefirst($text),
8063 q{expr9},
8064 $tracelevel)
8065 if defined $::RD_TRACE;
8066 if (1) { no strict qw{refs};
8067 $expectation->is(q{expr10})->at($text);
8068 unless (defined ($_tok = Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug::expr10($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
8069 {
8070
8071 Parse::RecDescent::_trace(q{<<Didn't match subrule: [expr10]>>},
8072 Parse::RecDescent::_tracefirst($text),
8073 q{expr9},
8074 $tracelevel)
8075 if defined $::RD_TRACE;
8076 $expectation->failed();
8077 last;
8078 }
8079 Parse::RecDescent::_trace(q{>>Matched subrule: [expr10]<< (return value: [}
8080 . $_tok . q{]},
8081
8082 Parse::RecDescent::_tracefirst($text),
8083 q{expr9},
8084 $tracelevel)
8085 if defined $::RD_TRACE;
8086 $item{q{expr10}} = $_tok;
8087 push @item, $_tok;
8088
8089 }
8090  
8091 $savetext = $text;
8092 $repcount++;
8093 }
8094 $text = $savetext;
8095 pop @item if $backtrack;
8096  
8097 unless (@item) { undef $_tok; last }
8098 $_tok = [ @item ];
8099 last;
8100 }
8101  
8102 unless ($repcount>=1)
8103 {
8104 Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: expr10 expr9op expr10>]>>},
8105 Parse::RecDescent::_tracefirst($text),
8106 q{expr9},
8107 $tracelevel)
8108 if defined $::RD_TRACE;
8109 $expectation->failed();
8110 last;
8111 }
8112 Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: expr10 expr9op expr10>]<< (return value: [}
8113 . qq{@{$_tok||[]}} . q{]},
8114 Parse::RecDescent::_tracefirst($text),
8115 q{expr9},
8116 $tracelevel)
8117 if defined $::RD_TRACE;
8118  
8119 push @item, $item{__DIRECTIVE1__}=$_tok||[];
8120  
8121  
8122 Parse::RecDescent::_trace(q{Trying action},
8123 Parse::RecDescent::_tracefirst($text),
8124 q{expr9},
8125 $tracelevel)
8126 if defined $::RD_TRACE;
8127
8128  
8129 $_tok = ($_noactions) ? 0 : do { db(@item); left(@item) };
8130 unless (defined $_tok)
8131 {
8132 Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
8133 if defined $::RD_TRACE;
8134 last;
8135 }
8136 Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
8137 . $_tok . q{])},
8138 Parse::RecDescent::_tracefirst($text))
8139 if defined $::RD_TRACE;
8140 push @item, $_tok;
8141 $item{__ACTION1__}=$_tok;
8142
8143  
8144  
8145 Parse::RecDescent::_trace(q{>>Matched production: [<leftop: expr10 expr9op expr10>]<<},
8146 Parse::RecDescent::_tracefirst($text),
8147 q{expr9},
8148 $tracelevel)
8149 if defined $::RD_TRACE;
8150 $_matched = 1;
8151 last;
8152 }
8153  
8154  
8155 unless ( $_matched || defined($score) )
8156 {
8157
8158  
8159 $_[1] = $text; # NOT SURE THIS IS NEEDED
8160 Parse::RecDescent::_trace(q{<<Didn't match rule>>},
8161 Parse::RecDescent::_tracefirst($_[1]),
8162 q{expr9},
8163 $tracelevel)
8164 if defined $::RD_TRACE;
8165 return undef;
8166 }
8167 if (!defined($return) && defined($score))
8168 {
8169 Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
8170 q{expr9},
8171 $tracelevel)
8172 if defined $::RD_TRACE;
8173 $return = $score_return;
8174 }
8175 splice @{$thisparser->{errors}}, $err_at;
8176 $return = $item[$#item] unless defined $return;
8177 if (defined $::RD_TRACE)
8178 {
8179 Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
8180 $return . q{])}, "",
8181 q{expr9},
8182 $tracelevel);
8183 Parse::RecDescent::_trace(q{(consumed: [} .
8184 Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
8185 Parse::RecDescent::_tracefirst($text),
8186 , q{expr9},
8187 $tracelevel)
8188 }
8189 $_[1] = $text;
8190 return $return;
8191 }
8192 }
8193 package HTML::Transmorgify::ConditionalsDebug; sub new { my $self = bless( {
8194 '_precompiled' => 1,
8195 'localvars' => '',
8196 'startcode' => '',
8197 'namespace' => 'Parse::RecDescent::HTML::Transmorgify::ConditionalsDebug',
8198 'rules' => {
8199 'expr2' => bless( {
8200 'impcount' => 0,
8201 'calls' => [
8202 'expr5',
8203 'expr2op'
8204 ],
8205 'changed' => 0,
8206 'opcount' => 0,
8207 'prods' => [
8208 bless( {
8209 'number' => 0,
8210 'strcount' => 0,
8211 'dircount' => 1,
8212 'uncommit' => undef,
8213 'error' => undef,
8214 'patcount' => 0,
8215 'actcount' => 1,
8216 'op' => [],
8217 'items' => [
8218 bless( {
8219 'expected' => '<leftop: expr5 expr2op expr5>',
8220 'min' => 1,
8221 'name' => '',
8222 'max' => 100000000,
8223 'leftarg' => bless( {
8224 'subrule' => 'expr5',
8225 'matchrule' => 0,
8226 'implicit' => undef,
8227 'argcode' => undef,
8228 'lookahead' => 0,
8229 'line' => 93
8230 }, 'Parse::RecDescent::Subrule' ),
8231 'rightarg' => bless( {
8232 'subrule' => 'expr5',
8233 'matchrule' => 0,
8234 'implicit' => undef,
8235 'argcode' => undef,
8236 'lookahead' => 0,
8237 'line' => 93
8238 }, 'Parse::RecDescent::Subrule' ),
8239 'hashname' => '__DIRECTIVE1__',
8240 'type' => 'leftop',
8241 'op' => bless( {
8242 'subrule' => 'expr2op',
8243 'matchrule' => 0,
8244 'implicit' => undef,
8245 'argcode' => undef,
8246 'lookahead' => 0,
8247 'line' => 93
8248 }, 'Parse::RecDescent::Subrule' )
8249 }, 'Parse::RecDescent::Operator' ),
8250 bless( {
8251 'hashname' => '__ACTION1__',
8252 'lookahead' => 0,
8253 'line' => 94,
8254 'code' => '{ db(@item); left(@item) }'
8255 }, 'Parse::RecDescent::Action' )
8256 ],
8257 'line' => undef
8258 }, 'Parse::RecDescent::Production' )
8259 ],
8260 'name' => 'expr2',
8261 'vars' => '',
8262 'line' => 93
8263 }, 'Parse::RecDescent::Rule' ),
8264 'expr15op' => bless( {
8265 'impcount' => 0,
8266 'calls' => [],
8267 'changed' => 0,
8268 'opcount' => 0,
8269 'prods' => [
8270 bless( {
8271 'number' => 0,
8272 'strcount' => 0,
8273 'dircount' => 0,
8274 'uncommit' => undef,
8275 'error' => undef,
8276 'patcount' => 1,
8277 'actcount' => 1,
8278 'items' => [
8279 bless( {
8280 'pattern' => '(\\*|\\/|%|x)',
8281 'hashname' => '__PATTERN1__',
8282 'description' => '/(\\\\*|\\\\/|%|x)/',
8283 'lookahead' => 0,
8284 'rdelim' => '/',
8285 'line' => 160,
8286 'mod' => '',
8287 'ldelim' => '/'
8288 }, 'Parse::RecDescent::Token' ),
8289 bless( {
8290 'hashname' => '__ACTION1__',
8291 'lookahead' => 0,
8292 'line' => 161,
8293 'code' => '{ db(@item); $item[1] }'
8294 }, 'Parse::RecDescent::Action' )
8295 ],
8296 'line' => undef
8297 }, 'Parse::RecDescent::Production' )
8298 ],
8299 'name' => 'expr15op',
8300 'vars' => '',
8301 'line' => 160
8302 }, 'Parse::RecDescent::Rule' ),
8303 'expr15a' => bless( {
8304 'impcount' => 0,
8305 'calls' => [
8306 'expr16'
8307 ],
8308 'changed' => 0,
8309 'opcount' => 0,
8310 'prods' => [
8311 bless( {
8312 'number' => 0,
8313 'strcount' => 1,
8314 'dircount' => 0,
8315 'uncommit' => undef,
8316 'error' => undef,
8317 'patcount' => 0,
8318 'actcount' => 1,
8319 'items' => [
8320 bless( {
8321 'pattern' => '-',
8322 'hashname' => '__STRING1__',
8323 'description' => '\'-\'',
8324 'lookahead' => 0,
8325 'line' => 163
8326 }, 'Parse::RecDescent::Literal' ),
8327 bless( {
8328 'subrule' => 'expr16',
8329 'matchrule' => 0,
8330 'implicit' => undef,
8331 'argcode' => undef,
8332 'lookahead' => 0,
8333 'line' => 163
8334 }, 'Parse::RecDescent::Subrule' ),
8335 bless( {
8336 'hashname' => '__ACTION1__',
8337 'lookahead' => 0,
8338 'line' => 164,
8339 'code' => '{ db(@item); binary(0, \'-\', $item[1]) }'
8340 }, 'Parse::RecDescent::Action' )
8341 ],
8342 'line' => undef
8343 }, 'Parse::RecDescent::Production' ),
8344 bless( {
8345 'number' => 1,
8346 'strcount' => 0,
8347 'dircount' => 0,
8348 'uncommit' => undef,
8349 'error' => undef,
8350 'patcount' => 0,
8351 'actcount' => 1,
8352 'items' => [
8353 bless( {
8354 'subrule' => 'expr16',
8355 'matchrule' => 0,
8356 'implicit' => undef,
8357 'argcode' => undef,
8358 'lookahead' => 0,
8359 'line' => 165
8360 }, 'Parse::RecDescent::Subrule' ),
8361 bless( {
8362 'hashname' => '__ACTION1__',
8363 'lookahead' => 0,
8364 'line' => 166,
8365 'code' => '{ db(@item); $item[1] }'
8366 }, 'Parse::RecDescent::Action' )
8367 ],
8368 'line' => 165
8369 }, 'Parse::RecDescent::Production' )
8370 ],
8371 'name' => 'expr15a',
8372 'vars' => '',
8373 'line' => 163
8374 }, 'Parse::RecDescent::Rule' ),
8375 'expr10' => bless( {
8376 'impcount' => 0,
8377 'calls' => [
8378 'expr11',
8379 'expr10op'
8380 ],
8381 'changed' => 0,
8382 'opcount' => 0,
8383 'prods' => [
8384 bless( {
8385 'number' => 0,
8386 'strcount' => 0,
8387 'dircount' => 1,
8388 'uncommit' => undef,
8389 'error' => undef,
8390 'patcount' => 0,
8391 'actcount' => 1,
8392 'op' => [],
8393 'items' => [
8394 bless( {
8395 'expected' => '<leftop: expr11 expr10op expr11>',
8396 'min' => 1,
8397 'name' => '',
8398 'max' => 100000000,
8399 'leftarg' => bless( {
8400 'subrule' => 'expr11',
8401 'matchrule' => 0,
8402 'implicit' => undef,
8403 'argcode' => undef,
8404 'lookahead' => 0,
8405 'line' => 127
8406 }, 'Parse::RecDescent::Subrule' ),
8407 'rightarg' => bless( {
8408 'subrule' => 'expr11',
8409 'matchrule' => 0,
8410 'implicit' => undef,
8411 'argcode' => undef,
8412 'lookahead' => 0,
8413 'line' => 127
8414 }, 'Parse::RecDescent::Subrule' ),
8415 'hashname' => '__DIRECTIVE1__',
8416 'type' => 'leftop',
8417 'op' => bless( {
8418 'subrule' => 'expr10op',
8419 'matchrule' => 0,
8420 'implicit' => undef,
8421 'argcode' => undef,
8422 'lookahead' => 0,
8423 'line' => 127
8424 }, 'Parse::RecDescent::Subrule' )
8425 }, 'Parse::RecDescent::Operator' ),
8426 bless( {
8427 'hashname' => '__ACTION1__',
8428 'lookahead' => 0,
8429 'line' => 128,
8430 'code' => '{ db(@item); left(@item) }'
8431 }, 'Parse::RecDescent::Action' )
8432 ],
8433 'line' => undef
8434 }, 'Parse::RecDescent::Production' )
8435 ],
8436 'name' => 'expr10',
8437 'vars' => '',
8438 'line' => 127
8439 }, 'Parse::RecDescent::Rule' ),
8440 'expr15' => bless( {
8441 'impcount' => 0,
8442 'calls' => [
8443 'expr15a',
8444 'expr15op'
8445 ],
8446 'changed' => 0,
8447 'opcount' => 0,
8448 'prods' => [
8449 bless( {
8450 'number' => 0,
8451 'strcount' => 0,
8452 'dircount' => 1,
8453 'uncommit' => undef,
8454 'error' => undef,
8455 'patcount' => 0,
8456 'actcount' => 1,
8457 'op' => [],
8458 'items' => [
8459 bless( {
8460 'expected' => '<leftop: expr15a expr15op expr15a>',
8461 'min' => 1,
8462 'name' => '',
8463 'max' => 100000000,
8464 'leftarg' => bless( {
8465 'subrule' => 'expr15a',
8466 'matchrule' => 0,
8467 'implicit' => undef,
8468 'argcode' => undef,
8469 'lookahead' => 0,
8470 'line' => 157
8471 }, 'Parse::RecDescent::Subrule' ),
8472 'rightarg' => bless( {
8473 'subrule' => 'expr15a',
8474 'matchrule' => 0,
8475 'implicit' => undef,
8476 'argcode' => undef,
8477 'lookahead' => 0,
8478 'line' => 157
8479 }, 'Parse::RecDescent::Subrule' ),
8480 'hashname' => '__DIRECTIVE1__',
8481 'type' => 'leftop',
8482 'op' => bless( {
8483 'subrule' => 'expr15op',
8484 'matchrule' => 0,
8485 'implicit' => undef,
8486 'argcode' => undef,
8487 'lookahead' => 0,
8488 'line' => 157
8489 }, 'Parse::RecDescent::Subrule' )
8490 }, 'Parse::RecDescent::Operator' ),
8491 bless( {
8492 'hashname' => '__ACTION1__',
8493 'lookahead' => 0,
8494 'line' => 158,
8495 'code' => '{ db(@item); left(@item) }'
8496 }, 'Parse::RecDescent::Action' )
8497 ],
8498 'line' => undef
8499 }, 'Parse::RecDescent::Production' )
8500 ],
8501 'name' => 'expr15',
8502 'vars' => '',
8503 'line' => 157
8504 }, 'Parse::RecDescent::Rule' ),
8505 'expr11' => bless( {
8506 'impcount' => 0,
8507 'calls' => [
8508 'expr12',
8509 'expr11op'
8510 ],
8511 'changed' => 0,
8512 'opcount' => 0,
8513 'prods' => [
8514 bless( {
8515 'number' => 0,
8516 'strcount' => 0,
8517 'dircount' => 1,
8518 'uncommit' => undef,
8519 'error' => undef,
8520 'patcount' => 0,
8521 'actcount' => 1,
8522 'op' => [],
8523 'items' => [
8524 bless( {
8525 'expected' => '<leftop: expr12 expr11op expr12>',
8526 'min' => 1,
8527 'name' => '',
8528 'max' => 100000000,
8529 'leftarg' => bless( {
8530 'subrule' => 'expr12',
8531 'matchrule' => 0,
8532 'implicit' => undef,
8533 'argcode' => undef,
8534 'lookahead' => 0,
8535 'line' => 133
8536 }, 'Parse::RecDescent::Subrule' ),
8537 'rightarg' => bless( {
8538 'subrule' => 'expr12',
8539 'matchrule' => 0,
8540 'implicit' => undef,
8541 'argcode' => undef,
8542 'lookahead' => 0,
8543 'line' => 133
8544 }, 'Parse::RecDescent::Subrule' ),
8545 'hashname' => '__DIRECTIVE1__',
8546 'type' => 'leftop',
8547 'op' => bless( {
8548 'subrule' => 'expr11op',
8549 'matchrule' => 0,
8550 'implicit' => undef,
8551 'argcode' => undef,
8552 'lookahead' => 0,
8553 'line' => 133
8554 }, 'Parse::RecDescent::Subrule' )
8555 }, 'Parse::RecDescent::Operator' ),
8556 bless( {
8557 'hashname' => '__ACTION1__',
8558 'lookahead' => 0,
8559 'line' => 134,
8560 'code' => '{ db(@item); nonassoc(@item) }'
8561 }, 'Parse::RecDescent::Action' )
8562 ],
8563 'line' => undef
8564 }, 'Parse::RecDescent::Production' )
8565 ],
8566 'name' => 'expr11',
8567 'vars' => '',
8568 'line' => 133
8569 }, 'Parse::RecDescent::Rule' ),
8570 'expr12op' => bless( {
8571 'impcount' => 0,
8572 'calls' => [],
8573 'changed' => 0,
8574 'opcount' => 0,
8575 'prods' => [
8576 bless( {
8577 'number' => 0,
8578 'strcount' => 0,
8579 'dircount' => 0,
8580 'uncommit' => undef,
8581 'error' => undef,
8582 'patcount' => 1,
8583 'actcount' => 1,
8584 'items' => [
8585 bless( {
8586 'pattern' => '(<|>|<=|>=|lt|gt|le|ge)',
8587 'hashname' => '__PATTERN1__',
8588 'description' => '/(<|>|<=|>=|lt|gt|le|ge)/',
8589 'lookahead' => 0,
8590 'rdelim' => '/',
8591 'line' => 142,
8592 'mod' => '',
8593 'ldelim' => '/'
8594 }, 'Parse::RecDescent::Token' ),
8595 bless( {
8596 'hashname' => '__ACTION1__',
8597 'lookahead' => 0,
8598 'line' => 143,
8599 'code' => '{ db(@item); $item[1] }'
8600 }, 'Parse::RecDescent::Action' )
8601 ],
8602 'line' => undef
8603 }, 'Parse::RecDescent::Production' )
8604 ],
8605 'name' => 'expr12op',
8606 'vars' => '',
8607 'line' => 142
8608 }, 'Parse::RecDescent::Rule' ),
8609 'expr8' => bless( {
8610 'impcount' => 0,
8611 'calls' => [
8612 'expr9',
8613 'expr8op'
8614 ],
8615 'changed' => 0,
8616 'opcount' => 0,
8617 'prods' => [
8618 bless( {
8619 'number' => 0,
8620 'strcount' => 0,
8621 'dircount' => 1,
8622 'uncommit' => undef,
8623 'error' => undef,
8624 'patcount' => 0,
8625 'actcount' => 1,
8626 'op' => [],
8627 'items' => [
8628 bless( {
8629 'expected' => '<leftop: expr9 expr8op expr9>',
8630 'min' => 1,
8631 'name' => '',
8632 'max' => 100000000,
8633 'leftarg' => bless( {
8634 'subrule' => 'expr9',
8635 'matchrule' => 0,
8636 'implicit' => undef,
8637 'argcode' => undef,
8638 'lookahead' => 0,
8639 'line' => 115
8640 }, 'Parse::RecDescent::Subrule' ),
8641 'rightarg' => bless( {
8642 'subrule' => 'expr9',
8643 'matchrule' => 0,
8644 'implicit' => undef,
8645 'argcode' => undef,
8646 'lookahead' => 0,
8647 'line' => 115
8648 }, 'Parse::RecDescent::Subrule' ),
8649 'hashname' => '__DIRECTIVE1__',
8650 'type' => 'leftop',
8651 'op' => bless( {
8652 'subrule' => 'expr8op',
8653 'matchrule' => 0,
8654 'implicit' => undef,
8655 'argcode' => undef,
8656 'lookahead' => 0,
8657 'line' => 115
8658 }, 'Parse::RecDescent::Subrule' )
8659 }, 'Parse::RecDescent::Operator' ),
8660 bless( {
8661 'hashname' => '__ACTION1__',
8662 'lookahead' => 0,
8663 'line' => 116,
8664 'code' => '{ db(@item); left(@item) }'
8665 }, 'Parse::RecDescent::Action' )
8666 ],
8667 'line' => undef
8668 }, 'Parse::RecDescent::Production' )
8669 ],
8670 'name' => 'expr8',
8671 'vars' => '',
8672 'line' => 115
8673 }, 'Parse::RecDescent::Rule' ),
8674 'expr5' => bless( {
8675 'impcount' => 0,
8676 'calls' => [
8677 'expr6'
8678 ],
8679 'changed' => 0,
8680 'opcount' => 0,
8681 'prods' => [
8682 bless( {
8683 'number' => 0,
8684 'strcount' => 1,
8685 'dircount' => 0,
8686 'uncommit' => undef,
8687 'error' => undef,
8688 'patcount' => 0,
8689 'actcount' => 1,
8690 'items' => [
8691 bless( {
8692 'pattern' => 'not',
8693 'hashname' => '__STRING1__',
8694 'description' => '\'not\'',
8695 'lookahead' => 0,
8696 'line' => 99
8697 }, 'Parse::RecDescent::InterpLit' ),
8698 bless( {
8699 'subrule' => 'expr6',
8700 'matchrule' => 0,
8701 'implicit' => undef,
8702 'argcode' => undef,
8703 'lookahead' => 0,
8704 'line' => 99
8705 }, 'Parse::RecDescent::Subrule' ),
8706 bless( {
8707 'hashname' => '__ACTION1__',
8708 'lookahead' => 0,
8709 'line' => 100,
8710 'code' => '{ db(@item); unary(\'not\', $item[2]) }'
8711 }, 'Parse::RecDescent::Action' )
8712 ],
8713 'line' => undef
8714 }, 'Parse::RecDescent::Production' ),
8715 bless( {
8716 'number' => 1,
8717 'strcount' => 0,
8718 'dircount' => 0,
8719 'uncommit' => undef,
8720 'error' => undef,
8721 'patcount' => 0,
8722 'actcount' => 1,
8723 'items' => [
8724 bless( {
8725 'subrule' => 'expr6',
8726 'matchrule' => 0,
8727 'implicit' => undef,
8728 'argcode' => undef,
8729 'lookahead' => 0,
8730 'line' => 101
8731 }, 'Parse::RecDescent::Subrule' ),
8732 bless( {
8733 'hashname' => '__ACTION1__',
8734 'lookahead' => 0,
8735 'line' => 102,
8736 'code' => '{ db(@item); $item[1] }'
8737 }, 'Parse::RecDescent::Action' )
8738 ],
8739 'line' => 101
8740 }, 'Parse::RecDescent::Production' )
8741 ],
8742 'name' => 'expr5',
8743 'vars' => '',
8744 'line' => 99
8745 }, 'Parse::RecDescent::Rule' ),
8746 'expr14' => bless( {
8747 'impcount' => 0,
8748 'calls' => [
8749 'expr15',
8750 'expr14op'
8751 ],
8752 'changed' => 0,
8753 'opcount' => 0,
8754 'prods' => [
8755 bless( {
8756 'number' => 0,
8757 'strcount' => 0,
8758 'dircount' => 1,
8759 'uncommit' => undef,
8760 'error' => undef,
8761 'patcount' => 0,
8762 'actcount' => 1,
8763 'op' => [],
8764 'items' => [
8765 bless( {
8766 'expected' => '<leftop: expr15 expr14op expr15>',
8767 'min' => 1,
8768 'name' => '',
8769 'max' => 100000000,
8770 'leftarg' => bless( {
8771 'subrule' => 'expr15',
8772 'matchrule' => 0,
8773 'implicit' => undef,
8774 'argcode' => undef,
8775 'lookahead' => 0,
8776 'line' => 151
8777 }, 'Parse::RecDescent::Subrule' ),
8778 'rightarg' => bless( {
8779 'subrule' => 'expr15',
8780 'matchrule' => 0,
8781 'implicit' => undef,
8782 'argcode' => undef,
8783 'lookahead' => 0,
8784 'line' => 151
8785 }, 'Parse::RecDescent::Subrule' ),
8786 'hashname' => '__DIRECTIVE1__',
8787 'type' => 'leftop',
8788 'op' => bless( {
8789 'subrule' => 'expr14op',
8790 'matchrule' => 0,
8791 'implicit' => undef,
8792 'argcode' => undef,
8793 'lookahead' => 0,
8794 'line' => 151
8795 }, 'Parse::RecDescent::Subrule' )
8796 }, 'Parse::RecDescent::Operator' ),
8797 bless( {
8798 'hashname' => '__ACTION1__',
8799 'lookahead' => 0,
8800 'line' => 152,
8801 'code' => '{ db(@item); left(@item) }'
8802 }, 'Parse::RecDescent::Action' )
8803 ],
8804 'line' => undef
8805 }, 'Parse::RecDescent::Production' )
8806 ],
8807 'name' => 'expr14',
8808 'vars' => '',
8809 'line' => 151
8810 }, 'Parse::RecDescent::Rule' ),
8811 'expr6' => bless( {
8812 'impcount' => 0,
8813 'calls' => [
8814 'expr7',
8815 'expr6'
8816 ],
8817 'changed' => 0,
8818 'opcount' => 0,
8819 'prods' => [
8820 bless( {
8821 'number' => 0,
8822 'strcount' => 2,
8823 'dircount' => 0,
8824 'uncommit' => undef,
8825 'error' => undef,
8826 'patcount' => 0,
8827 'actcount' => 1,
8828 'items' => [
8829 bless( {
8830 'subrule' => 'expr7',
8831 'matchrule' => 0,
8832 'implicit' => undef,
8833 'argcode' => undef,
8834 'lookahead' => 0,
8835 'line' => 104
8836 }, 'Parse::RecDescent::Subrule' ),
8837 bless( {
8838 'pattern' => '?',
8839 'hashname' => '__STRING1__',
8840 'description' => '\'?\'',
8841 'lookahead' => 0,
8842 'line' => 104
8843 }, 'Parse::RecDescent::InterpLit' ),
8844 bless( {
8845 'subrule' => 'expr7',
8846 'matchrule' => 0,
8847 'implicit' => undef,
8848 'argcode' => undef,
8849 'lookahead' => 0,
8850 'line' => 104
8851 }, 'Parse::RecDescent::Subrule' ),
8852 bless( {
8853 'pattern' => ':',
8854 'hashname' => '__STRING2__',
8855 'description' => '\':\'',
8856 'lookahead' => 0,
8857 'line' => 104
8858 }, 'Parse::RecDescent::InterpLit' ),
8859 bless( {
8860 'subrule' => 'expr6',
8861 'matchrule' => 0,
8862 'implicit' => undef,
8863 'argcode' => undef,
8864 'lookahead' => 0,
8865 'line' => 104
8866 }, 'Parse::RecDescent::Subrule' ),
8867 bless( {
8868 'hashname' => '__ACTION1__',
8869 'lookahead' => 0,
8870 'line' => 105,
8871 'code' => '{ db(@item); sub { run($item[1]) ? run($item[3]) : run($item[5]) } }'
8872 }, 'Parse::RecDescent::Action' )
8873 ],
8874 'line' => undef
8875 }, 'Parse::RecDescent::Production' ),
8876 bless( {
8877 'number' => 1,
8878 'strcount' => 0,
8879 'dircount' => 0,
8880 'uncommit' => undef,
8881 'error' => undef,
8882 'patcount' => 0,
8883 'actcount' => 1,
8884 'items' => [
8885 bless( {
8886 'subrule' => 'expr7',
8887 'matchrule' => 0,
8888 'implicit' => undef,
8889 'argcode' => undef,
8890 'lookahead' => 0,
8891 'line' => 106
8892 }, 'Parse::RecDescent::Subrule' ),
8893 bless( {
8894 'hashname' => '__ACTION1__',
8895 'lookahead' => 0,
8896 'line' => 107,
8897 'code' => '{ db(@item); $item[1] }'
8898 }, 'Parse::RecDescent::Action' )
8899 ],
8900 'line' => 106
8901 }, 'Parse::RecDescent::Production' )
8902 ],
8903 'name' => 'expr6',
8904 'vars' => '',
8905 'line' => 104
8906 }, 'Parse::RecDescent::Rule' ),
8907 'expr13op' => bless( {
8908 'impcount' => 0,
8909 'calls' => [],
8910 'changed' => 0,
8911 'opcount' => 0,
8912 'prods' => [
8913 bless( {
8914 'number' => 0,
8915 'strcount' => 0,
8916 'dircount' => 0,
8917 'uncommit' => undef,
8918 'error' => undef,
8919 'patcount' => 1,
8920 'actcount' => 1,
8921 'items' => [
8922 bless( {
8923 'pattern' => '(<<|>>)',
8924 'hashname' => '__PATTERN1__',
8925 'description' => '/(<<|>>)/',
8926 'lookahead' => 0,
8927 'rdelim' => '/',
8928 'line' => 148,
8929 'mod' => '',
8930 'ldelim' => '/'
8931 }, 'Parse::RecDescent::Token' ),
8932 bless( {
8933 'hashname' => '__ACTION1__',
8934 'lookahead' => 0,
8935 'line' => 149,
8936 'code' => '{ db(@item); $item[1] }'
8937 }, 'Parse::RecDescent::Action' )
8938 ],
8939 'line' => undef
8940 }, 'Parse::RecDescent::Production' )
8941 ],
8942 'name' => 'expr13op',
8943 'vars' => '',
8944 'line' => 148
8945 }, 'Parse::RecDescent::Rule' ),
8946 'expr8op' => bless( {
8947 'impcount' => 0,
8948 'calls' => [],
8949 'changed' => 0,
8950 'opcount' => 0,
8951 'prods' => [
8952 bless( {
8953 'number' => 0,
8954 'strcount' => 1,
8955 'dircount' => 0,
8956 'uncommit' => undef,
8957 'error' => undef,
8958 'patcount' => 0,
8959 'actcount' => 1,
8960 'items' => [
8961 bless( {
8962 'pattern' => '&&',
8963 'hashname' => '__STRING1__',
8964 'description' => '\'&&\'',
8965 'lookahead' => 0,
8966 'line' => 118
8967 }, 'Parse::RecDescent::InterpLit' ),
8968 bless( {
8969 'hashname' => '__ACTION1__',
8970 'lookahead' => 0,
8971 'line' => 119,
8972 'code' => '{ db(@item); $item[1] }'
8973 }, 'Parse::RecDescent::Action' )
8974 ],
8975 'line' => undef
8976 }, 'Parse::RecDescent::Production' )
8977 ],
8978 'name' => 'expr8op',
8979 'vars' => '',
8980 'line' => 118
8981 }, 'Parse::RecDescent::Rule' ),
8982 'macro' => bless( {
8983 'impcount' => 0,
8984 'calls' => [],
8985 'changed' => 0,
8986 'opcount' => 0,
8987 'prods' => [
8988 bless( {
8989 'number' => 0,
8990 'strcount' => 0,
8991 'dircount' => 0,
8992 'uncommit' => undef,
8993 'error' => undef,
8994 'patcount' => 1,
8995 'actcount' => 1,
8996 'items' => [
8997 bless( {
8998 'pattern' => '<macro (?: [^\'">] | \'[^\'<>]*\' | "[^"<>]*" )* >',
8999 'hashname' => '__PATTERN1__',
9000 'description' => '/<macro (?: [^\'">] | \'[^\'<>]*\' | "[^"<>]*" )* >/x',
9001 'lookahead' => 0,
9002 'rdelim' => '/',
9003 'line' => 205,
9004 'mod' => 'x',
9005 'ldelim' => '/'
9006 }, 'Parse::RecDescent::Token' ),
9007 bless( {
9008 'hashname' => '__ACTION1__',
9009 'lookahead' => 0,
9010 'line' => 206,
9011 'code' => '{
9012 db(@item);
9013 my $buf = HTML::Transmorgify::compile($HTML::Transmorgify::modules, \\$item[1]);
9014 $return = sub {
9015 local(@rtmp) = ( \'\' );
9016 run($buf, \\@rtmp);
9017 return $rtmp[0];
9018 };
9019 }'
9020 }, 'Parse::RecDescent::Action' )
9021 ],
9022 'line' => undef
9023 }, 'Parse::RecDescent::Production' )
9024 ],
9025 'name' => 'macro',
9026 'vars' => '',
9027 'line' => 205
9028 }, 'Parse::RecDescent::Rule' ),
9029 'expr16op' => bless( {
9030 'impcount' => 0,
9031 'calls' => [],
9032 'changed' => 0,
9033 'opcount' => 0,
9034 'prods' => [
9035 bless( {
9036 'number' => 0,
9037 'strcount' => 0,
9038 'dircount' => 0,
9039 'uncommit' => undef,
9040 'error' => undef,
9041 'patcount' => 1,
9042 'actcount' => 1,
9043 'items' => [
9044 bless( {
9045 'pattern' => '(=~|\\!~)',
9046 'hashname' => '__PATTERN1__',
9047 'description' => '/(=~|\\\\!~)/',
9048 'lookahead' => 0,
9049 'rdelim' => '/',
9050 'line' => 171,
9051 'mod' => '',
9052 'ldelim' => '/'
9053 }, 'Parse::RecDescent::Token' ),
9054 bless( {
9055 'hashname' => '__ACTION1__',
9056 'lookahead' => 0,
9057 'line' => 172,
9058 'code' => '{ db(@item); $item[1] }'
9059 }, 'Parse::RecDescent::Action' )
9060 ],
9061 'line' => undef
9062 }, 'Parse::RecDescent::Production' )
9063 ],
9064 'name' => 'expr16op',
9065 'vars' => '',
9066 'line' => 171
9067 }, 'Parse::RecDescent::Rule' ),
9068 'expr10op' => bless( {
9069 'impcount' => 0,
9070 'calls' => [],
9071 'changed' => 0,
9072 'opcount' => 0,
9073 'prods' => [
9074 bless( {
9075 'number' => 0,
9076 'strcount' => 0,
9077 'dircount' => 0,
9078 'uncommit' => undef,
9079 'error' => undef,
9080 'patcount' => 1,
9081 'actcount' => 1,
9082 'items' => [
9083 bless( {
9084 'pattern' => '(\\&)',
9085 'hashname' => '__PATTERN1__',
9086 'description' => '/(\\\\&)/',
9087 'lookahead' => 0,
9088 'rdelim' => '/',
9089 'line' => 130,
9090 'mod' => '',
9091 'ldelim' => '/'
9092 }, 'Parse::RecDescent::Token' ),
9093 bless( {
9094 'hashname' => '__ACTION1__',
9095 'lookahead' => 0,
9096 'line' => 131,
9097 'code' => '{ db(@item); $item[1] }'
9098 }, 'Parse::RecDescent::Action' )
9099 ],
9100 'line' => undef
9101 }, 'Parse::RecDescent::Production' )
9102 ],
9103 'name' => 'expr10op',
9104 'vars' => '',
9105 'line' => 130
9106 }, 'Parse::RecDescent::Rule' ),
9107 'expr11op' => bless( {
9108 'impcount' => 0,
9109 'calls' => [],
9110 'changed' => 0,
9111 'opcount' => 0,
9112 'prods' => [
9113 bless( {
9114 'number' => 0,
9115 'strcount' => 0,
9116 'dircount' => 0,
9117 'uncommit' => undef,
9118 'error' => undef,
9119 'patcount' => 1,
9120 'actcount' => 1,
9121 'items' => [
9122 bless( {
9123 'pattern' => '(==|\\!=|<=>|eq|ne|cmp)',
9124 'hashname' => '__PATTERN1__',
9125 'description' => '/(==|\\\\!=|<=>|eq|ne|cmp)/',
9126 'lookahead' => 0,
9127 'rdelim' => '/',
9128 'line' => 136,
9129 'mod' => '',
9130 'ldelim' => '/'
9131 }, 'Parse::RecDescent::Token' ),
9132 bless( {
9133 'hashname' => '__ACTION1__',
9134 'lookahead' => 0,
9135 'line' => 137,
9136 'code' => '{ db(@item); $item[1] }'
9137 }, 'Parse::RecDescent::Action' )
9138 ],
9139 'line' => undef
9140 }, 'Parse::RecDescent::Production' )
9141 ],
9142 'name' => 'expr11op',
9143 'vars' => '',
9144 'line' => 136
9145 }, 'Parse::RecDescent::Rule' ),
9146 'function' => bless( {
9147 'impcount' => 0,
9148 'calls' => [
9149 'expr'
9150 ],
9151 'changed' => 0,
9152 'opcount' => 0,
9153 'prods' => [
9154 bless( {
9155 'number' => 0,
9156 'strcount' => 2,
9157 'dircount' => 1,
9158 'uncommit' => undef,
9159 'error' => undef,
9160 'patcount' => 2,
9161 'actcount' => 1,
9162 'op' => [],
9163 'items' => [
9164 bless( {
9165 'pattern' => '[A-Za-z_](?:\\w|::(?=[^:]))*',
9166 'hashname' => '__PATTERN1__',
9167 'description' => '/[A-Za-z_](?:\\\\w|::(?=[^:]))*/',
9168 'lookahead' => 0,
9169 'rdelim' => '/',
9170 'line' => 189,
9171 'mod' => '',
9172 'ldelim' => '/'
9173 }, 'Parse::RecDescent::Token' ),
9174 bless( {
9175 'pattern' => '(',
9176 'hashname' => '__STRING1__',
9177 'description' => '\'(\'',
9178 'lookahead' => 0,
9179 'line' => 189
9180 }, 'Parse::RecDescent::Literal' ),
9181 bless( {
9182 'expected' => '<leftop: expr /,/ expr>',
9183 'min' => 1,
9184 'name' => '\'expr(s)\'',
9185 'max' => 100000000,
9186 'leftarg' => bless( {
9187 'subrule' => 'expr',
9188 'matchrule' => 0,
9189 'implicit' => undef,
9190 'argcode' => undef,
9191 'lookahead' => 0,
9192 'line' => 189
9193 }, 'Parse::RecDescent::Subrule' ),
9194 'rightarg' => bless( {
9195 'subrule' => 'expr',
9196 'matchrule' => 0,
9197 'implicit' => undef,
9198 'argcode' => undef,
9199 'lookahead' => 0,
9200 'line' => 189
9201 }, 'Parse::RecDescent::Subrule' ),
9202 'hashname' => '__DIRECTIVE1__',
9203 'type' => 'leftop',
9204 'op' => bless( {
9205 'pattern' => ',',
9206 'hashname' => '__PATTERN2__',
9207 'description' => '/,/',
9208 'lookahead' => 0,
9209 'rdelim' => '/',
9210 'line' => 189,
9211 'mod' => '',
9212 'ldelim' => '/'
9213 }, 'Parse::RecDescent::Token' )
9214 }, 'Parse::RecDescent::Operator' ),
9215 bless( {
9216 'pattern' => ')',
9217 'hashname' => '__STRING2__',
9218 'description' => '\')\'',
9219 'lookahead' => 0,
9220 'line' => 189
9221 }, 'Parse::RecDescent::Literal' ),
9222 bless( {
9223 'hashname' => '__ACTION1__',
9224 'lookahead' => 0,
9225 'line' => 190,
9226 'code' => '{
9227 db(@item);
9228 die unless $allowed_funcs->{$item[1]};
9229 $return = sub {
9230 $allowed_funcs->{$item[1]}->( map { run($_) } @item[3..$#item] );
9231 };
9232 }'
9233 }, 'Parse::RecDescent::Action' )
9234 ],
9235 'line' => undef
9236 }, 'Parse::RecDescent::Production' )
9237 ],
9238 'name' => 'function',
9239 'vars' => '',
9240 'line' => 189
9241 }, 'Parse::RecDescent::Rule' ),
9242 'expr7op' => bless( {
9243 'impcount' => 0,
9244 'calls' => [],
9245 'changed' => 0,
9246 'opcount' => 0,
9247 'prods' => [
9248 bless( {
9249 'number' => 0,
9250 'strcount' => 1,
9251 'dircount' => 0,
9252 'uncommit' => undef,
9253 'error' => undef,
9254 'patcount' => 0,
9255 'actcount' => 1,
9256 'items' => [
9257 bless( {
9258 'pattern' => '||',
9259 'hashname' => '__STRING1__',
9260 'description' => '\'||\'',
9261 'lookahead' => 0,
9262 'line' => 112
9263 }, 'Parse::RecDescent::InterpLit' ),
9264 bless( {
9265 'hashname' => '__ACTION1__',
9266 'lookahead' => 0,
9267 'line' => 113,
9268 'code' => '{ db(@item); $item[1] }'
9269 }, 'Parse::RecDescent::Action' )
9270 ],
9271 'line' => undef
9272 }, 'Parse::RecDescent::Production' )
9273 ],
9274 'name' => 'expr7op',
9275 'vars' => '',
9276 'line' => 112
9277 }, 'Parse::RecDescent::Rule' ),
9278 'term' => bless( {
9279 'impcount' => 0,
9280 'calls' => [
9281 'expr',
9282 'constant',
9283 'macro',
9284 'function'
9285 ],
9286 'changed' => 0,
9287 'opcount' => 0,
9288 'prods' => [
9289 bless( {
9290 'number' => 0,
9291 'strcount' => 2,
9292 'dircount' => 0,
9293 'uncommit' => undef,
9294 'error' => undef,
9295 'patcount' => 0,
9296 'actcount' => 1,
9297 'items' => [
9298 bless( {
9299 'pattern' => '(',
9300 'hashname' => '__STRING1__',
9301 'description' => '\'(\'',
9302 'lookahead' => 0,
9303 'line' => 180
9304 }, 'Parse::RecDescent::Literal' ),
9305 bless( {
9306 'subrule' => 'expr',
9307 'matchrule' => 0,
9308 'implicit' => undef,
9309 'argcode' => undef,
9310 'lookahead' => 0,
9311 'line' => 180
9312 }, 'Parse::RecDescent::Subrule' ),
9313 bless( {
9314 'pattern' => ')',
9315 'hashname' => '__STRING2__',
9316 'description' => '\')\'',
9317 'lookahead' => 0,
9318 'line' => 180
9319 }, 'Parse::RecDescent::Literal' ),
9320 bless( {
9321 'hashname' => '__ACTION1__',
9322 'lookahead' => 0,
9323 'line' => 181,
9324 'code' => '{ db(@item); $return = $item[2] }'
9325 }, 'Parse::RecDescent::Action' )
9326 ],
9327 'line' => undef
9328 }, 'Parse::RecDescent::Production' ),
9329 bless( {
9330 'number' => 1,
9331 'strcount' => 0,
9332 'dircount' => 0,
9333 'uncommit' => undef,
9334 'error' => undef,
9335 'patcount' => 0,
9336 'actcount' => 1,
9337 'items' => [
9338 bless( {
9339 'subrule' => 'constant',
9340 'matchrule' => 0,
9341 'implicit' => undef,
9342 'argcode' => undef,
9343 'lookahead' => 0,
9344 'line' => 182
9345 }, 'Parse::RecDescent::Subrule' ),
9346 bless( {
9347 'hashname' => '__ACTION1__',
9348 'lookahead' => 0,
9349 'line' => 183,
9350 'code' => '{ db(@item); $return = $item[1] }'
9351 }, 'Parse::RecDescent::Action' )
9352 ],
9353 'line' => 182
9354 }, 'Parse::RecDescent::Production' ),
9355 bless( {
9356 'number' => 2,
9357 'strcount' => 0,
9358 'dircount' => 0,
9359 'uncommit' => undef,
9360 'error' => undef,
9361 'patcount' => 0,
9362 'actcount' => 1,
9363 'items' => [
9364 bless( {
9365 'subrule' => 'macro',
9366 'matchrule' => 0,
9367 'implicit' => undef,
9368 'argcode' => undef,
9369 'lookahead' => 0,
9370 'line' => 184
9371 }, 'Parse::RecDescent::Subrule' ),
9372 bless( {
9373 'hashname' => '__ACTION1__',
9374 'lookahead' => 0,
9375 'line' => 185,
9376 'code' => '{ db(@item); $return = $item[1] }'
9377 }, 'Parse::RecDescent::Action' )
9378 ],
9379 'line' => 184
9380 }, 'Parse::RecDescent::Production' ),
9381 bless( {
9382 'number' => 3,
9383 'strcount' => 0,
9384 'dircount' => 0,
9385 'uncommit' => undef,
9386 'error' => undef,
9387 'patcount' => 0,
9388 'actcount' => 1,
9389 'items' => [
9390 bless( {
9391 'subrule' => 'function',
9392 'matchrule' => 0,
9393 'implicit' => undef,
9394 'argcode' => undef,
9395 'lookahead' => 0,
9396 'line' => 186
9397 }, 'Parse::RecDescent::Subrule' ),
9398 bless( {
9399 'hashname' => '__ACTION1__',
9400 'lookahead' => 0,
9401 'line' => 187,
9402 'code' => '{ db(@item); $return = $item[1] }'
9403 }, 'Parse::RecDescent::Action' )
9404 ],
9405 'line' => 186
9406 }, 'Parse::RecDescent::Production' )
9407 ],
9408 'name' => 'term',
9409 'vars' => '',
9410 'line' => 180
9411 }, 'Parse::RecDescent::Rule' ),
9412 'expr13' => bless( {
9413 'impcount' => 0,
9414 'calls' => [
9415 'expr14',
9416 'expr13op'
9417 ],
9418 'changed' => 0,
9419 'opcount' => 0,
9420 'prods' => [
9421 bless( {
9422 'number' => 0,
9423 'strcount' => 0,
9424 'dircount' => 1,
9425 'uncommit' => undef,
9426 'error' => undef,
9427 'patcount' => 0,
9428 'actcount' => 1,
9429 'op' => [],
9430 'items' => [
9431 bless( {
9432 'expected' => '<leftop: expr14 expr13op expr14>',
9433 'min' => 1,
9434 'name' => '',
9435 'max' => 100000000,
9436 'leftarg' => bless( {
9437 'subrule' => 'expr14',
9438 'matchrule' => 0,
9439 'implicit' => undef,
9440 'argcode' => undef,
9441 'lookahead' => 0,
9442 'line' => 145
9443 }, 'Parse::RecDescent::Subrule' ),
9444 'rightarg' => bless( {
9445 'subrule' => 'expr14',
9446 'matchrule' => 0,
9447 'implicit' => undef,
9448 'argcode' => undef,
9449 'lookahead' => 0,
9450 'line' => 145
9451 }, 'Parse::RecDescent::Subrule' ),
9452 'hashname' => '__DIRECTIVE1__',
9453 'type' => 'leftop',
9454 'op' => bless( {
9455 'subrule' => 'expr13op',
9456 'matchrule' => 0,
9457 'implicit' => undef,
9458 'argcode' => undef,
9459 'lookahead' => 0,
9460 'line' => 145
9461 }, 'Parse::RecDescent::Subrule' )
9462 }, 'Parse::RecDescent::Operator' ),
9463 bless( {
9464 'hashname' => '__ACTION1__',
9465 'lookahead' => 0,
9466 'line' => 146,
9467 'code' => '{ db(@item); left(@item) }'
9468 }, 'Parse::RecDescent::Action' )
9469 ],
9470 'line' => undef
9471 }, 'Parse::RecDescent::Production' )
9472 ],
9473 'name' => 'expr13',
9474 'vars' => '',
9475 'line' => 145
9476 }, 'Parse::RecDescent::Rule' ),
9477 'expr17op' => bless( {
9478 'impcount' => 0,
9479 'calls' => [],
9480 'changed' => 0,
9481 'opcount' => 0,
9482 'prods' => [
9483 bless( {
9484 'number' => 0,
9485 'strcount' => 0,
9486 'dircount' => 0,
9487 'uncommit' => undef,
9488 'error' => undef,
9489 'patcount' => 1,
9490 'actcount' => 1,
9491 'items' => [
9492 bless( {
9493 'pattern' => '(\\*\\*)',
9494 'hashname' => '__PATTERN1__',
9495 'description' => '/(\\\\*\\\\*)/',
9496 'lookahead' => 0,
9497 'rdelim' => '/',
9498 'line' => 177,
9499 'mod' => '',
9500 'ldelim' => '/'
9501 }, 'Parse::RecDescent::Token' ),
9502 bless( {
9503 'hashname' => '__ACTION1__',
9504 'lookahead' => 0,
9505 'line' => 178,
9506 'code' => '{ db(@item); $item[1] }'
9507 }, 'Parse::RecDescent::Action' )
9508 ],
9509 'line' => undef
9510 }, 'Parse::RecDescent::Production' )
9511 ],
9512 'name' => 'expr17op',
9513 'vars' => '',
9514 'line' => 177
9515 }, 'Parse::RecDescent::Rule' ),
9516 'expr17' => bless( {
9517 'impcount' => 0,
9518 'calls' => [
9519 'term',
9520 'expr17op'
9521 ],
9522 'changed' => 0,
9523 'opcount' => 0,
9524 'prods' => [
9525 bless( {
9526 'number' => 0,
9527 'strcount' => 0,
9528 'dircount' => 1,
9529 'uncommit' => undef,
9530 'error' => undef,
9531 'patcount' => 0,
9532 'actcount' => 1,
9533 'op' => [],
9534 'items' => [
9535 bless( {
9536 'expected' => '<leftop: term expr17op term>',
9537 'min' => 1,
9538 'name' => '',
9539 'max' => 100000000,
9540 'leftarg' => bless( {
9541 'subrule' => 'term',
9542 'matchrule' => 0,
9543 'implicit' => undef,
9544 'argcode' => undef,
9545 'lookahead' => 0,
9546 'line' => 174
9547 }, 'Parse::RecDescent::Subrule' ),
9548 'rightarg' => bless( {
9549 'subrule' => 'term',
9550 'matchrule' => 0,
9551 'implicit' => undef,
9552 'argcode' => undef,
9553 'lookahead' => 0,
9554 'line' => 174
9555 }, 'Parse::RecDescent::Subrule' ),
9556 'hashname' => '__DIRECTIVE1__',
9557 'type' => 'leftop',
9558 'op' => bless( {
9559 'subrule' => 'expr17op',
9560 'matchrule' => 0,
9561 'implicit' => undef,
9562 'argcode' => undef,
9563 'lookahead' => 0,
9564 'line' => 174
9565 }, 'Parse::RecDescent::Subrule' )
9566 }, 'Parse::RecDescent::Operator' ),
9567 bless( {
9568 'hashname' => '__ACTION1__',
9569 'lookahead' => 0,
9570 'line' => 175,
9571 'code' => '{ db(@item); left(@item) }'
9572 }, 'Parse::RecDescent::Action' )
9573 ],
9574 'line' => undef
9575 }, 'Parse::RecDescent::Production' )
9576 ],
9577 'name' => 'expr17',
9578 'vars' => '',
9579 'line' => 174
9580 }, 'Parse::RecDescent::Rule' ),
9581 'expr' => bless( {
9582 'impcount' => 0,
9583 'calls' => [
9584 'expr2',
9585 'expr_op'
9586 ],
9587 'changed' => 0,
9588 'opcount' => 0,
9589 'prods' => [
9590 bless( {
9591 'number' => 0,
9592 'strcount' => 0,
9593 'dircount' => 1,
9594 'uncommit' => undef,
9595 'error' => undef,
9596 'patcount' => 0,
9597 'actcount' => 1,
9598 'op' => [],
9599 'items' => [
9600 bless( {
9601 'expected' => '<leftop: expr2 expr_op expr2>',
9602 'min' => 1,
9603 'name' => '',
9604 'max' => 100000000,
9605 'leftarg' => bless( {
9606 'subrule' => 'expr2',
9607 'matchrule' => 0,
9608 'implicit' => undef,
9609 'argcode' => undef,
9610 'lookahead' => 0,
9611 'line' => 87
9612 }, 'Parse::RecDescent::Subrule' ),
9613 'rightarg' => bless( {
9614 'subrule' => 'expr2',
9615 'matchrule' => 0,
9616 'implicit' => undef,
9617 'argcode' => undef,
9618 'lookahead' => 0,
9619 'line' => 87
9620 }, 'Parse::RecDescent::Subrule' ),
9621 'hashname' => '__DIRECTIVE1__',
9622 'type' => 'leftop',
9623 'op' => bless( {
9624 'subrule' => 'expr_op',
9625 'matchrule' => 0,
9626 'implicit' => undef,
9627 'argcode' => undef,
9628 'lookahead' => 0,
9629 'line' => 87
9630 }, 'Parse::RecDescent::Subrule' )
9631 }, 'Parse::RecDescent::Operator' ),
9632 bless( {
9633 'hashname' => '__ACTION1__',
9634 'lookahead' => 0,
9635 'line' => 88,
9636 'code' => '{ db(@item); left(@item) }'
9637 }, 'Parse::RecDescent::Action' )
9638 ],
9639 'line' => undef
9640 }, 'Parse::RecDescent::Production' )
9641 ],
9642 'name' => 'expr',
9643 'vars' => '',
9644 'line' => 87
9645 }, 'Parse::RecDescent::Rule' ),
9646 'expr12' => bless( {
9647 'impcount' => 0,
9648 'calls' => [
9649 'expr13',
9650 'expr12op'
9651 ],
9652 'changed' => 0,
9653 'opcount' => 0,
9654 'prods' => [
9655 bless( {
9656 'number' => 0,
9657 'strcount' => 0,
9658 'dircount' => 1,
9659 'uncommit' => undef,
9660 'error' => undef,
9661 'patcount' => 0,
9662 'actcount' => 1,
9663 'op' => [],
9664 'items' => [
9665 bless( {
9666 'expected' => '<leftop: expr13 expr12op expr13>',
9667 'min' => 1,
9668 'name' => '',
9669 'max' => 100000000,
9670 'leftarg' => bless( {
9671 'subrule' => 'expr13',
9672 'matchrule' => 0,
9673 'implicit' => undef,
9674 'argcode' => undef,
9675 'lookahead' => 0,
9676 'line' => 139
9677 }, 'Parse::RecDescent::Subrule' ),
9678 'rightarg' => bless( {
9679 'subrule' => 'expr13',
9680 'matchrule' => 0,
9681 'implicit' => undef,
9682 'argcode' => undef,
9683 'lookahead' => 0,
9684 'line' => 139
9685 }, 'Parse::RecDescent::Subrule' ),
9686 'hashname' => '__DIRECTIVE1__',
9687 'type' => 'leftop',
9688 'op' => bless( {
9689 'subrule' => 'expr12op',
9690 'matchrule' => 0,
9691 'implicit' => undef,
9692 'argcode' => undef,
9693 'lookahead' => 0,
9694 'line' => 139
9695 }, 'Parse::RecDescent::Subrule' )
9696 }, 'Parse::RecDescent::Operator' ),
9697 bless( {
9698 'hashname' => '__ACTION1__',
9699 'lookahead' => 0,
9700 'line' => 140,
9701 'code' => '{ db(@item); nonassoc(@item) }'
9702 }, 'Parse::RecDescent::Action' )
9703 ],
9704 'line' => undef
9705 }, 'Parse::RecDescent::Production' )
9706 ],
9707 'name' => 'expr12',
9708 'vars' => '',
9709 'line' => 139
9710 }, 'Parse::RecDescent::Rule' ),
9711 'expr16' => bless( {
9712 'impcount' => 0,
9713 'calls' => [
9714 'expr17',
9715 'expr16op'
9716 ],
9717 'changed' => 0,
9718 'opcount' => 0,
9719 'prods' => [
9720 bless( {
9721 'number' => 0,
9722 'strcount' => 0,
9723 'dircount' => 1,
9724 'uncommit' => undef,
9725 'error' => undef,
9726 'patcount' => 0,
9727 'actcount' => 1,
9728 'op' => [],
9729 'items' => [
9730 bless( {
9731 'expected' => '<leftop: expr17 expr16op expr17>',
9732 'min' => 1,
9733 'name' => '',
9734 'max' => 100000000,
9735 'leftarg' => bless( {
9736 'subrule' => 'expr17',
9737 'matchrule' => 0,
9738 'implicit' => undef,
9739 'argcode' => undef,
9740 'lookahead' => 0,
9741 'line' => 168
9742 }, 'Parse::RecDescent::Subrule' ),
9743 'rightarg' => bless( {
9744 'subrule' => 'expr17',
9745 'matchrule' => 0,
9746 'implicit' => undef,
9747 'argcode' => undef,
9748 'lookahead' => 0,
9749 'line' => 168
9750 }, 'Parse::RecDescent::Subrule' ),
9751 'hashname' => '__DIRECTIVE1__',
9752 'type' => 'leftop',
9753 'op' => bless( {
9754 'subrule' => 'expr16op',
9755 'matchrule' => 0,
9756 'implicit' => undef,
9757 'argcode' => undef,
9758 'lookahead' => 0,
9759 'line' => 168
9760 }, 'Parse::RecDescent::Subrule' )
9761 }, 'Parse::RecDescent::Operator' ),
9762 bless( {
9763 'hashname' => '__ACTION1__',
9764 'lookahead' => 0,
9765 'line' => 169,
9766 'code' => '{ db(@item); left(@item) }'
9767 }, 'Parse::RecDescent::Action' )
9768 ],
9769 'line' => undef
9770 }, 'Parse::RecDescent::Production' )
9771 ],
9772 'name' => 'expr16',
9773 'vars' => '',
9774 'line' => 168
9775 }, 'Parse::RecDescent::Rule' ),
9776 'expr2op' => bless( {
9777 'impcount' => 0,
9778 'calls' => [],
9779 'changed' => 0,
9780 'opcount' => 0,
9781 'prods' => [
9782 bless( {
9783 'number' => 0,
9784 'strcount' => 1,
9785 'dircount' => 0,
9786 'uncommit' => undef,
9787 'error' => undef,
9788 'patcount' => 0,
9789 'actcount' => 1,
9790 'items' => [
9791 bless( {
9792 'pattern' => 'and',
9793 'hashname' => '__STRING1__',
9794 'description' => '\'and\'',
9795 'lookahead' => 0,
9796 'line' => 96
9797 }, 'Parse::RecDescent::InterpLit' ),
9798 bless( {
9799 'hashname' => '__ACTION1__',
9800 'lookahead' => 0,
9801 'line' => 97,
9802 'code' => '{ db(@item); return $item[1] }'
9803 }, 'Parse::RecDescent::Action' )
9804 ],
9805 'line' => undef
9806 }, 'Parse::RecDescent::Production' )
9807 ],
9808 'name' => 'expr2op',
9809 'vars' => '',
9810 'line' => 96
9811 }, 'Parse::RecDescent::Rule' ),
9812 'expr_op' => bless( {
9813 'impcount' => 0,
9814 'calls' => [],
9815 'changed' => 0,
9816 'opcount' => 0,
9817 'prods' => [
9818 bless( {
9819 'number' => 0,
9820 'strcount' => 0,
9821 'dircount' => 0,
9822 'uncommit' => undef,
9823 'error' => undef,
9824 'patcount' => 1,
9825 'actcount' => 1,
9826 'items' => [
9827 bless( {
9828 'pattern' => 'or|xor',
9829 'hashname' => '__PATTERN1__',
9830 'description' => '/or|xor/',
9831 'lookahead' => 0,
9832 'rdelim' => '/',
9833 'line' => 90,
9834 'mod' => '',
9835 'ldelim' => '/'
9836 }, 'Parse::RecDescent::Token' ),
9837 bless( {
9838 'hashname' => '__ACTION1__',
9839 'lookahead' => 0,
9840 'line' => 91,
9841 'code' => '{ db(@item); $item[1] }'
9842 }, 'Parse::RecDescent::Action' )
9843 ],
9844 'line' => undef
9845 }, 'Parse::RecDescent::Production' )
9846 ],
9847 'name' => 'expr_op',
9848 'vars' => '',
9849 'line' => 90
9850 }, 'Parse::RecDescent::Rule' ),
9851 'expr7' => bless( {
9852 'impcount' => 0,
9853 'calls' => [
9854 'expr8',
9855 'expr7op'
9856 ],
9857 'changed' => 0,
9858 'opcount' => 0,
9859 'prods' => [
9860 bless( {
9861 'number' => 0,
9862 'strcount' => 0,
9863 'dircount' => 1,
9864 'uncommit' => undef,
9865 'error' => undef,
9866 'patcount' => 0,
9867 'actcount' => 1,
9868 'op' => [],
9869 'items' => [
9870 bless( {
9871 'expected' => '<leftop: expr8 expr7op expr8>',
9872 'min' => 1,
9873 'name' => '',
9874 'max' => 100000000,
9875 'leftarg' => bless( {
9876 'subrule' => 'expr8',
9877 'matchrule' => 0,
9878 'implicit' => undef,
9879 'argcode' => undef,
9880 'lookahead' => 0,
9881 'line' => 109
9882 }, 'Parse::RecDescent::Subrule' ),
9883 'rightarg' => bless( {
9884 'subrule' => 'expr8',
9885 'matchrule' => 0,
9886 'implicit' => undef,
9887 'argcode' => undef,
9888 'lookahead' => 0,
9889 'line' => 109
9890 }, 'Parse::RecDescent::Subrule' ),
9891 'hashname' => '__DIRECTIVE1__',
9892 'type' => 'leftop',
9893 'op' => bless( {
9894 'subrule' => 'expr7op',
9895 'matchrule' => 0,
9896 'implicit' => undef,
9897 'argcode' => undef,
9898 'lookahead' => 0,
9899 'line' => 109
9900 }, 'Parse::RecDescent::Subrule' )
9901 }, 'Parse::RecDescent::Operator' ),
9902 bless( {
9903 'hashname' => '__ACTION1__',
9904 'lookahead' => 0,
9905 'line' => 110,
9906 'code' => '{ db(@item); left(@item) }'
9907 }, 'Parse::RecDescent::Action' )
9908 ],
9909 'line' => undef
9910 }, 'Parse::RecDescent::Production' )
9911 ],
9912 'name' => 'expr7',
9913 'vars' => '',
9914 'line' => 109
9915 }, 'Parse::RecDescent::Rule' ),
9916 'constant' => bless( {
9917 'impcount' => 0,
9918 'calls' => [],
9919 'changed' => 0,
9920 'opcount' => 0,
9921 'prods' => [
9922 bless( {
9923 'number' => 0,
9924 'strcount' => 0,
9925 'dircount' => 0,
9926 'uncommit' => undef,
9927 'error' => undef,
9928 'patcount' => 1,
9929 'actcount' => 1,
9930 'items' => [
9931 bless( {
9932 'pattern' => ' -? (?: \\d+ (?: \\.\\d+ )? | (?: \\.\\d+) ) (?:[eE]-?\\d+)? ',
9933 'hashname' => '__PATTERN1__',
9934 'description' => '/ -? (?: \\\\d+ (?: \\\\.\\\\d+ )? | (?: \\\\.\\\\d+) ) (?:[eE]-?\\\\d+)? /x',
9935 'lookahead' => 0,
9936 'rdelim' => '/',
9937 'line' => 198,
9938 'mod' => 'x',
9939 'ldelim' => '/'
9940 }, 'Parse::RecDescent::Token' ),
9941 bless( {
9942 'hashname' => '__ACTION1__',
9943 'lookahead' => 0,
9944 'line' => 199,
9945 'code' => '{ db(@item); $item[1] }'
9946 }, 'Parse::RecDescent::Action' )
9947 ],
9948 'line' => undef
9949 }, 'Parse::RecDescent::Production' ),
9950 bless( {
9951 'number' => 1,
9952 'strcount' => 2,
9953 'dircount' => 0,
9954 'uncommit' => undef,
9955 'error' => undef,
9956 'patcount' => 1,
9957 'actcount' => 1,
9958 'items' => [
9959 bless( {
9960 'pattern' => '\'',
9961 'hashname' => '__STRING1__',
9962 'description' => '\'\'\'',
9963 'lookahead' => 0,
9964 'line' => 200
9965 }, 'Parse::RecDescent::InterpLit' ),
9966 bless( {
9967 'pattern' => '[^"]*',
9968 'hashname' => '__PATTERN1__',
9969 'description' => '/[^"]*/',
9970 'lookahead' => 0,
9971 'rdelim' => '/',
9972 'line' => 200,
9973 'mod' => '',
9974 'ldelim' => '/'
9975 }, 'Parse::RecDescent::Token' ),
9976 bless( {
9977 'pattern' => '"',
9978 'hashname' => '__STRING2__',
9979 'description' => '\'"\'',
9980 'lookahead' => 0,
9981 'line' => 200
9982 }, 'Parse::RecDescent::Literal' ),
9983 bless( {
9984 'hashname' => '__ACTION1__',
9985 'lookahead' => 0,
9986 'line' => 201,
9987 'code' => '{ db(@item); $item[2] }'
9988 }, 'Parse::RecDescent::Action' )
9989 ],
9990 'line' => 200
9991 }, 'Parse::RecDescent::Production' ),
9992 bless( {
9993 'number' => 2,
9994 'strcount' => 2,
9995 'dircount' => 0,
9996 'uncommit' => undef,
9997 'error' => undef,
9998 'patcount' => 1,
9999 'actcount' => 1,
10000 'items' => [
10001 bless( {
10002 'pattern' => '"',
10003 'hashname' => '__STRING1__',
10004 'description' => '\'"\'',
10005 'lookahead' => 0,
10006 'line' => 202
10007 }, 'Parse::RecDescent::Literal' ),
10008 bless( {
10009 'pattern' => '[^\']*',
10010 'hashname' => '__PATTERN1__',
10011 'description' => '/[^\']*/',
10012 'lookahead' => 0,
10013 'rdelim' => '/',
10014 'line' => 202,
10015 'mod' => '',
10016 'ldelim' => '/'
10017 }, 'Parse::RecDescent::Token' ),
10018 bless( {
10019 'pattern' => '\'',
10020 'hashname' => '__STRING2__',
10021 'description' => '\'\'\'',
10022 'lookahead' => 0,
10023 'line' => 202
10024 }, 'Parse::RecDescent::InterpLit' ),
10025 bless( {
10026 'hashname' => '__ACTION1__',
10027 'lookahead' => 0,
10028 'line' => 203,
10029 'code' => '{ db(@item); $item[2] }'
10030 }, 'Parse::RecDescent::Action' )
10031 ],
10032 'line' => 202
10033 }, 'Parse::RecDescent::Production' )
10034 ],
10035 'name' => 'constant',
10036 'vars' => '',
10037 'line' => 198
10038 }, 'Parse::RecDescent::Rule' ),
10039 'expr9op' => bless( {
10040 'impcount' => 0,
10041 'calls' => [],
10042 'changed' => 0,
10043 'opcount' => 0,
10044 'prods' => [
10045 bless( {
10046 'number' => 0,
10047 'strcount' => 0,
10048 'dircount' => 0,
10049 'uncommit' => undef,
10050 'error' => undef,
10051 'patcount' => 1,
10052 'actcount' => 1,
10053 'items' => [
10054 bless( {
10055 'pattern' => '(\\||\\^)',
10056 'hashname' => '__PATTERN1__',
10057 'description' => '/(\\\\||\\\\^)/',
10058 'lookahead' => 0,
10059 'rdelim' => '/',
10060 'line' => 124,
10061 'mod' => '',
10062 'ldelim' => '/'
10063 }, 'Parse::RecDescent::Token' ),
10064 bless( {
10065 'hashname' => '__ACTION1__',
10066 'lookahead' => 0,
10067 'line' => 125,
10068 'code' => '{ db(@item); $item[1] }'
10069 }, 'Parse::RecDescent::Action' )
10070 ],
10071 'line' => undef
10072 }, 'Parse::RecDescent::Production' )
10073 ],
10074 'name' => 'expr9op',
10075 'vars' => '',
10076 'line' => 124
10077 }, 'Parse::RecDescent::Rule' ),
10078 'conditional' => bless( {
10079 'impcount' => 0,
10080 'calls' => [
10081 'expr'
10082 ],
10083 'changed' => 0,
10084 'opcount' => 0,
10085 'prods' => [
10086 bless( {
10087 'number' => 0,
10088 'strcount' => 0,
10089 'dircount' => 0,
10090 'uncommit' => undef,
10091 'error' => undef,
10092 'patcount' => 1,
10093 'actcount' => 1,
10094 'items' => [
10095 bless( {
10096 'subrule' => 'expr',
10097 'matchrule' => 0,
10098 'implicit' => undef,
10099 'argcode' => undef,
10100 'lookahead' => 0,
10101 'line' => 84
10102 }, 'Parse::RecDescent::Subrule' ),
10103 bless( {
10104 'pattern' => '\\Z',
10105 'hashname' => '__PATTERN1__',
10106 'description' => '/\\\\Z/',
10107 'lookahead' => 0,
10108 'rdelim' => '/',
10109 'line' => 84,
10110 'mod' => '',
10111 'ldelim' => '/'
10112 }, 'Parse::RecDescent::Token' ),
10113 bless( {
10114 'hashname' => '__ACTION1__',
10115 'lookahead' => 0,
10116 'line' => 85,
10117 'code' => '{ db(@item); $item[1] }'
10118 }, 'Parse::RecDescent::Action' )
10119 ],
10120 'line' => undef
10121 }, 'Parse::RecDescent::Production' )
10122 ],
10123 'name' => 'conditional',
10124 'vars' => '',
10125 'line' => 84
10126 }, 'Parse::RecDescent::Rule' ),
10127 'expr14op' => bless( {
10128 'impcount' => 0,
10129 'calls' => [],
10130 'changed' => 0,
10131 'opcount' => 0,
10132 'prods' => [
10133 bless( {
10134 'number' => 0,
10135 'strcount' => 0,
10136 'dircount' => 0,
10137 'uncommit' => undef,
10138 'error' => undef,
10139 'patcount' => 1,
10140 'actcount' => 1,
10141 'items' => [
10142 bless( {
10143 'pattern' => '(\\+|-|\\.)',
10144 'hashname' => '__PATTERN1__',
10145 'description' => '/(\\\\+|-|\\\\.)/',
10146 'lookahead' => 0,
10147 'rdelim' => '/',
10148 'line' => 154,
10149 'mod' => '',
10150 'ldelim' => '/'
10151 }, 'Parse::RecDescent::Token' ),
10152 bless( {
10153 'hashname' => '__ACTION1__',
10154 'lookahead' => 0,
10155 'line' => 155,
10156 'code' => '{ db(@item); $item[1] }'
10157 }, 'Parse::RecDescent::Action' )
10158 ],
10159 'line' => undef
10160 }, 'Parse::RecDescent::Production' )
10161 ],
10162 'name' => 'expr14op',
10163 'vars' => '',
10164 'line' => 154
10165 }, 'Parse::RecDescent::Rule' ),
10166 'expr9' => bless( {
10167 'impcount' => 0,
10168 'calls' => [
10169 'expr10',
10170 'expr9op'
10171 ],
10172 'changed' => 0,
10173 'opcount' => 0,
10174 'prods' => [
10175 bless( {
10176 'number' => 0,
10177 'strcount' => 0,
10178 'dircount' => 1,
10179 'uncommit' => undef,
10180 'error' => undef,
10181 'patcount' => 0,
10182 'actcount' => 1,
10183 'op' => [],
10184 'items' => [
10185 bless( {
10186 'expected' => '<leftop: expr10 expr9op expr10>',
10187 'min' => 1,
10188 'name' => '',
10189 'max' => 100000000,
10190 'leftarg' => bless( {
10191 'subrule' => 'expr10',
10192 'matchrule' => 0,
10193 'implicit' => undef,
10194 'argcode' => undef,
10195 'lookahead' => 0,
10196 'line' => 121
10197 }, 'Parse::RecDescent::Subrule' ),
10198 'rightarg' => bless( {
10199 'subrule' => 'expr10',
10200 'matchrule' => 0,
10201 'implicit' => undef,
10202 'argcode' => undef,
10203 'lookahead' => 0,
10204 'line' => 121
10205 }, 'Parse::RecDescent::Subrule' ),
10206 'hashname' => '__DIRECTIVE1__',
10207 'type' => 'leftop',
10208 'op' => bless( {
10209 'subrule' => 'expr9op',
10210 'matchrule' => 0,
10211 'implicit' => undef,
10212 'argcode' => undef,
10213 'lookahead' => 0,
10214 'line' => 121
10215 }, 'Parse::RecDescent::Subrule' )
10216 }, 'Parse::RecDescent::Operator' ),
10217 bless( {
10218 'hashname' => '__ACTION1__',
10219 'lookahead' => 0,
10220 'line' => 122,
10221 'code' => '{ db(@item); left(@item) }'
10222 }, 'Parse::RecDescent::Action' )
10223 ],
10224 'line' => undef
10225 }, 'Parse::RecDescent::Production' )
10226 ],
10227 'name' => 'expr9',
10228 'vars' => '',
10229 'line' => 121
10230 }, 'Parse::RecDescent::Rule' )
10231 },
10232 '_AUTOTREE' => undef,
10233 '_check' => {
10234 'thisoffset' => '',
10235 'itempos' => '',
10236 'prevoffset' => '',
10237 'prevline' => '',
10238 'prevcolumn' => '',
10239 'thiscolumn' => ''
10240 },
10241 '_AUTOACTION' => undef
10242 }, 'Parse::RecDescent' );
10243 }