File Coverage

blib/lib/Config/Magic/Grammar.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

line	stmt	sub	time	code
1				package Config::Magic::Grammar;
2	1	1	2083	use Parse::RecDescent;
	1		434699
	1		10
3				our $skip=qr{((\/[].?[]\/)\|((?:#\|;\|(?:\/\/)).?\n)\|\s)*}sm;
4
5				{ my $ERRORS;
6
7
8				package Parse::RecDescent::Config::Magic::Grammar;
9	1	1	126	use strict;
	1		2
	1		36
10	1	1	7	use vars qw($skip $AUTOLOAD );
	1		2
	1		49
11
12	1	1	558	use Tie::Hash::Indexed;
	0
	0
13				use Data::Dumper;
14				my $withoutnewline = qr{([\t\r ]\|(\/[].?[]\/))*};
15				my $withnewline =qr{(\s\|(\/[].?[]\/)\|((#\|;\|\/\/).?\n))}sm;
16
17				sub array2hash
18				{
19				my $hashref=shift;
20				my %hashed;
21				my $parser = shift;
22				if($parser->{'ordered'}) {
23				tie(%hashed, "Tie::Hash::Indexed");
24				};
25				my @unhashed=@{$hashref};
26				for my $elem (@unhashed)
27				{
28				if(ref $elem eq 'ARRAY')
29				{
30				if(scalar(@{$elem})==2)
31				{
32				if(exists($hashed{$$elem[0]}))
33				{
34				if(ref($hashed{$$elem[0]})=~/ARRAY/) {
35				my @temparry=@{$hashed{$$elem[0]}};
36				if(!($temparry[$#temparry]=~/loQuaTistop/)) { push(@{$hashed{$$elem[0]}},$$elem[1]); }
37				else {
38				delete($temparry[$#temparry]);
39				$hashed{$$elem[0]}=[\@temparry,$$elem[1]];
40				}
41				}
42				else { $hashed{$$elem[0]} = [$hashed{$$elem[0]},$$elem[1]]; }
43				}
44				else {
45				$hashed{$$elem[0]}=$$elem[1];
46				if(ref($hashed{$$elem[0]})=~/ARRAY/) {
47				push @{$hashed{$$elem[0]}},'loQuaTistop'; }
48				#Add this as a marker to show that nothing has yet been added to the array.
49				}
50				}
51				else { $hashed{$$elem[0]}={} if(!exists($hashed{$$elem[0]})); };
52				};
53				};
54				for my $key (%hashed) {
55				if(ref($hashed{$key})=~/ARRAY/)
56				{
57				delete($hashed{$key}[scalar(@{$hashed{$key}})-1]) if($hashed{$key}[scalar(@{$hashed{$key}})-1]=~/loQuaTistop/);
58				};
59				};
60				return \%hashed;
61				};
62
63				sub section_checker
64				{ return [shift,array2hash(shift,shift)]; };
65				;
66
67
68				{
69				local $SIG{__WARN__} = sub {0};
70				# PRETEND TO BE IN Parse::RecDescent NAMESPACE
71				*Parse::RecDescent::Config::Magic::Grammar::AUTOLOAD = sub
72				{
73				no strict 'refs';
74				$AUTOLOAD =~ s/^Parse::RecDescent::Config::Magic::Grammar/Parse::RecDescent/;
75				goto &{$AUTOLOAD};
76				}
77				}
78
79				push @Parse::RecDescent::Config::Magic::Grammar::ISA, 'Parse::RecDescent';
80				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
81				sub Parse::RecDescent::Config::Magic::Grammar::left
82				{
83				my $thisparser = $_[0];
84				use vars q{$tracelevel};
85				local $tracelevel = ($tracelevel\|\|0)+1;
86				$ERRORS = 0;
87				my $thisrule = $thisparser->{"rules"}{"left"};
88
89				Parse::RecDescent::_trace(q{Trying rule: [left]},
90				Parse::RecDescent::_tracefirst($_[1]),
91				q{left},
92				$tracelevel)
93				if defined $::RD_TRACE;
94
95
96				my $err_at = @{$thisparser->{errors}};
97
98				my $score;
99				my $score_return;
100				my $_tok;
101				my $return = undef;
102				my $_matched=0;
103				my $commit=0;
104				my @item = ();
105				my %item = ();
106				my $repeating = defined($_[2]) && $_[2];
107				my $_noactions = defined($_[3]) && $_[3];
108				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
109				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
110				my $text;
111				my $lastsep="";
112				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
113				$expectation->at($_[1]);
114
115				my $thisline;
116				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
117
118
119
120				while (!$_matched && !$commit)
121				{
122
123				Parse::RecDescent::_trace(q{Trying production: [svar /(=>\|:=\|:\|=)/]},
124				Parse::RecDescent::_tracefirst($_[1]),
125				q{left},
126				$tracelevel)
127				if defined $::RD_TRACE;
128				my $thisprod = $thisrule->{"prods"}[0];
129				$text = $_[1];
130				my $_savetext;
131				@item = (q{left});
132				%item = (__RULE__ => q{left});
133				my $repcount = 0;
134
135
136				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
137				Parse::RecDescent::_tracefirst($text),
138				q{left},
139				$tracelevel)
140				if defined $::RD_TRACE;
141				if (1) { no strict qw{refs};
142				$expectation->is(q{})->at($text);
143				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
144				{
145
146				Parse::RecDescent::_trace(q{<>},
147				Parse::RecDescent::_tracefirst($text),
148				q{left},
149				$tracelevel)
150				if defined $::RD_TRACE;
151				$expectation->failed();
152				last;
153				}
154				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
155				. $_tok . q{]},
156
157				Parse::RecDescent::_tracefirst($text),
158				q{left},
159				$tracelevel)
160				if defined $::RD_TRACE;
161				$item{q{svar}} = $_tok;
162				push @item, $_tok;
163
164				}
165
166				Parse::RecDescent::_trace(q{Trying terminal: [/(=>\|:=\|:\|=)/]}, Parse::RecDescent::_tracefirst($text),
167				q{left},
168				$tracelevel)
169				if defined $::RD_TRACE;
170				$lastsep = "";
171				$expectation->is(q{/(=>\|:=\|:\|=)/})->at($text);
172
173
174				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(=>\|:=\|:\|=))//)
175				{
176
177				$expectation->failed();
178				Parse::RecDescent::_trace(q{<>},
179				Parse::RecDescent::_tracefirst($text))
180				if defined $::RD_TRACE;
181
182				last;
183				}
184				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
185				. $& . q{])},
186				Parse::RecDescent::_tracefirst($text))
187				if defined $::RD_TRACE;
188				push @item, $item{__PATTERN1__}=$&;
189
190
191				Parse::RecDescent::_trace(q{Trying action},
192				Parse::RecDescent::_tracefirst($text),
193				q{left},
194				$tracelevel)
195				if defined $::RD_TRACE;
196
197
198				$_tok = ($_noactions) ? 0 : do {$item[1]};
199				unless (defined $_tok)
200				{
201				Parse::RecDescent::_trace(q{<> (return value: [undef])})
202				if defined $::RD_TRACE;
203				last;
204				}
205				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
206				. $_tok . q{])},
207				Parse::RecDescent::_tracefirst($text))
208				if defined $::RD_TRACE;
209				push @item, $_tok;
210				$item{__ACTION1__}=$_tok;
211
212
213
214				Parse::RecDescent::_trace(q{>>Matched production: [svar /(=>\|:=\|:\|=)/]<<},
215				Parse::RecDescent::_tracefirst($text),
216				q{left},
217				$tracelevel)
218				if defined $::RD_TRACE;
219				$_matched = 1;
220				last;
221				}
222
223
224				while (!$_matched && !$commit)
225				{
226
227				Parse::RecDescent::_trace(q{Trying production: [/([^\\\{\\\}<>\$\$\\[\\]\\n#]+?)((?:=>\|:\|=)=?)/]},
228				Parse::RecDescent::_tracefirst($_[1]),
229				q{left},
230				$tracelevel)
231				if defined $::RD_TRACE;
232				my $thisprod = $thisrule->{"prods"}[1];
233				$text = $_[1];
234				my $_savetext;
235				@item = (q{left});
236				%item = (__RULE__ => q{left});
237				my $repcount = 0;
238
239
240				Parse::RecDescent::_trace(q{Trying terminal: [/([^\\\{\\\}<>\$\$\\[\\]\\n#]+?)((?:=>\|:\|=)=?)/]}, Parse::RecDescent::_tracefirst($text),
241				q{left},
242				$tracelevel)
243				if defined $::RD_TRACE;
244				$lastsep = "";
245				$expectation->is(q{})->at($text);
246
247
248				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:([^\{\}<>\[\]\n#]+?)((?:=>\|:\|=)=?))//)
249				{
250
251				$expectation->failed();
252				Parse::RecDescent::_trace(q{<>},
253				Parse::RecDescent::_tracefirst($text))
254				if defined $::RD_TRACE;
255
256				last;
257				}
258				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
259				. $& . q{])},
260				Parse::RecDescent::_tracefirst($text))
261				if defined $::RD_TRACE;
262				push @item, $item{__PATTERN1__}=$&;
263
264
265				Parse::RecDescent::_trace(q{Trying action},
266				Parse::RecDescent::_tracefirst($text),
267				q{left},
268				$tracelevel)
269				if defined $::RD_TRACE;
270
271
272				$_tok = ($_noactions) ? 0 : do {$1;};
273				unless (defined $_tok)
274				{
275				Parse::RecDescent::_trace(q{<> (return value: [undef])})
276				if defined $::RD_TRACE;
277				last;
278				}
279				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
280				. $_tok . q{])},
281				Parse::RecDescent::_tracefirst($text))
282				if defined $::RD_TRACE;
283				push @item, $_tok;
284				$item{__ACTION1__}=$_tok;
285
286
287
288				Parse::RecDescent::_trace(q{>>Matched production: [/([^\\\{\\\}<>\$\$\\[\\]\\n#]+?)((?:=>\|:\|=)=?)/]<<},
289				Parse::RecDescent::_tracefirst($text),
290				q{left},
291				$tracelevel)
292				if defined $::RD_TRACE;
293				$_matched = 1;
294				last;
295				}
296
297
298				while (!$_matched && !$commit)
299				{
300
301				Parse::RecDescent::_trace(q{Trying production: [csv]},
302				Parse::RecDescent::_tracefirst($_[1]),
303				q{left},
304				$tracelevel)
305				if defined $::RD_TRACE;
306				my $thisprod = $thisrule->{"prods"}[2];
307				$text = $_[1];
308				my $_savetext;
309				@item = (q{left});
310				%item = (__RULE__ => q{left});
311				my $repcount = 0;
312
313
314				Parse::RecDescent::_trace(q{Trying subrule: [csv]},
315				Parse::RecDescent::_tracefirst($text),
316				q{left},
317				$tracelevel)
318				if defined $::RD_TRACE;
319				if (1) { no strict qw{refs};
320				$expectation->is(q{})->at($text);
321				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::csv($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
322				{
323
324				Parse::RecDescent::_trace(q{<>},
325				Parse::RecDescent::_tracefirst($text),
326				q{left},
327				$tracelevel)
328				if defined $::RD_TRACE;
329				$expectation->failed();
330				last;
331				}
332				Parse::RecDescent::_trace(q{>>Matched subrule: [csv]<< (return value: [}
333				. $_tok . q{]},
334
335				Parse::RecDescent::_tracefirst($text),
336				q{left},
337				$tracelevel)
338				if defined $::RD_TRACE;
339				$item{q{csv}} = $_tok;
340				push @item, $_tok;
341
342				}
343
344
345				Parse::RecDescent::_trace(q{>>Matched production: [csv]<<},
346				Parse::RecDescent::_tracefirst($text),
347				q{left},
348				$tracelevel)
349				if defined $::RD_TRACE;
350				$_matched = 1;
351				last;
352				}
353
354
355				while (!$_matched && !$commit)
356				{
357
358				Parse::RecDescent::_trace(q{Trying production: [svar]},
359				Parse::RecDescent::_tracefirst($_[1]),
360				q{left},
361				$tracelevel)
362				if defined $::RD_TRACE;
363				my $thisprod = $thisrule->{"prods"}[3];
364				$text = $_[1];
365				my $_savetext;
366				@item = (q{left});
367				%item = (__RULE__ => q{left});
368				my $repcount = 0;
369
370
371				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
372				Parse::RecDescent::_tracefirst($text),
373				q{left},
374				$tracelevel)
375				if defined $::RD_TRACE;
376				if (1) { no strict qw{refs};
377				$expectation->is(q{})->at($text);
378				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
379				{
380
381				Parse::RecDescent::_trace(q{<>},
382				Parse::RecDescent::_tracefirst($text),
383				q{left},
384				$tracelevel)
385				if defined $::RD_TRACE;
386				$expectation->failed();
387				last;
388				}
389				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
390				. $_tok . q{]},
391
392				Parse::RecDescent::_tracefirst($text),
393				q{left},
394				$tracelevel)
395				if defined $::RD_TRACE;
396				$item{q{svar}} = $_tok;
397				push @item, $_tok;
398
399				}
400
401
402				Parse::RecDescent::_trace(q{>>Matched production: [svar]<<},
403				Parse::RecDescent::_tracefirst($text),
404				q{left},
405				$tracelevel)
406				if defined $::RD_TRACE;
407				$_matched = 1;
408				last;
409				}
410
411
412				unless ( $_matched \|\| defined($return) \|\| defined($score) )
413				{
414
415
416				$_[1] = $text; # NOT SURE THIS IS NEEDED
417				Parse::RecDescent::_trace(q{<>},
418				Parse::RecDescent::_tracefirst($_[1]),
419				q{left},
420				$tracelevel)
421				if defined $::RD_TRACE;
422				return undef;
423				}
424				if (!defined($return) && defined($score))
425				{
426				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
427				q{left},
428				$tracelevel)
429				if defined $::RD_TRACE;
430				$return = $score_return;
431				}
432				splice @{$thisparser->{errors}}, $err_at;
433				$return = $item[$#item] unless defined $return;
434				if (defined $::RD_TRACE)
435				{
436				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
437				$return . q{])}, "",
438				q{left},
439				$tracelevel);
440				Parse::RecDescent::_trace(q{(consumed: [} .
441				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
442				Parse::RecDescent::_tracefirst($text),
443				, q{left},
444				$tracelevel)
445				}
446				$_[1] = $text;
447				return $return;
448				}
449
450				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
451				sub Parse::RecDescent::Config::Magic::Grammar::bracket_section
452				{
453				my $thisparser = $_[0];
454				use vars q{$tracelevel};
455				local $tracelevel = ($tracelevel\|\|0)+1;
456				$ERRORS = 0;
457				my $thisrule = $thisparser->{"rules"}{"bracket_section"};
458
459				Parse::RecDescent::_trace(q{Trying rule: [bracket_section]},
460				Parse::RecDescent::_tracefirst($_[1]),
461				q{bracket_section},
462				$tracelevel)
463				if defined $::RD_TRACE;
464
465
466				my $err_at = @{$thisparser->{errors}};
467
468				my $score;
469				my $score_return;
470				my $_tok;
471				my $return = undef;
472				my $_matched=0;
473				my $commit=0;
474				my @item = ();
475				my %item = ();
476				my $repeating = defined($_[2]) && $_[2];
477				my $_noactions = defined($_[3]) && $_[3];
478				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
479				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
480				my $text;
481				my $lastsep="";
482				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
483				$expectation->at($_[1]);
484
485				my $thisline;
486				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
487
488
489
490				while (!$_matched && !$commit)
491				{
492
493				Parse::RecDescent::_trace(q{Trying production: ['(' section ')']},
494				Parse::RecDescent::_tracefirst($_[1]),
495				q{bracket_section},
496				$tracelevel)
497				if defined $::RD_TRACE;
498				my $thisprod = $thisrule->{"prods"}[0];
499				$text = $_[1];
500				my $_savetext;
501				@item = (q{bracket_section});
502				%item = (__RULE__ => q{bracket_section});
503				my $repcount = 0;
504
505
506				Parse::RecDescent::_trace(q{Trying terminal: ['(']},
507				Parse::RecDescent::_tracefirst($text),
508				q{bracket_section},
509				$tracelevel)
510				if defined $::RD_TRACE;
511				$lastsep = "";
512				$expectation->is(q{})->at($text);
513
514
515				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(//)
516				{
517
518				$expectation->failed();
519				Parse::RecDescent::_trace(qq{<>},
520				Parse::RecDescent::_tracefirst($text))
521				if defined $::RD_TRACE;
522				last;
523				}
524				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
525				. $& . q{])},
526				Parse::RecDescent::_tracefirst($text))
527				if defined $::RD_TRACE;
528				push @item, $item{__STRING1__}=$&;
529
530
531				Parse::RecDescent::_trace(q{Trying repeated subrule: [section]},
532				Parse::RecDescent::_tracefirst($text),
533				q{bracket_section},
534				$tracelevel)
535				if defined $::RD_TRACE;
536				$expectation->is(q{section})->at($text);
537
538				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::section, 0, 100000000, $_noactions,$expectation,undef)))
539				{
540				Parse::RecDescent::_trace(q{<>},
541				Parse::RecDescent::_tracefirst($text),
542				q{bracket_section},
543				$tracelevel)
544				if defined $::RD_TRACE;
545				last;
546				}
547				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [section]<< (}
548				. @$_tok . q{ times)},
549
550				Parse::RecDescent::_tracefirst($text),
551				q{bracket_section},
552				$tracelevel)
553				if defined $::RD_TRACE;
554				$item{q{section(s?)}} = $_tok;
555				push @item, $_tok;
556
557
558
559				Parse::RecDescent::_trace(q{Trying terminal: [')']},
560				Parse::RecDescent::_tracefirst($text),
561				q{bracket_section},
562				$tracelevel)
563				if defined $::RD_TRACE;
564				$lastsep = "";
565				$expectation->is(q{')'})->at($text);
566
567
568				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\)//)
569				{
570
571				$expectation->failed();
572				Parse::RecDescent::_trace(qq{<>},
573				Parse::RecDescent::_tracefirst($text))
574				if defined $::RD_TRACE;
575				last;
576				}
577				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
578				. $& . q{])},
579				Parse::RecDescent::_tracefirst($text))
580				if defined $::RD_TRACE;
581				push @item, $item{__STRING2__}=$&;
582
583
584				Parse::RecDescent::_trace(q{Trying action},
585				Parse::RecDescent::_tracefirst($text),
586				q{bracket_section},
587				$tracelevel)
588				if defined $::RD_TRACE;
589
590
591				$_tok = ($_noactions) ? 0 : do {$item[2]};
592				unless (defined $_tok)
593				{
594				Parse::RecDescent::_trace(q{<> (return value: [undef])})
595				if defined $::RD_TRACE;
596				last;
597				}
598				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
599				. $_tok . q{])},
600				Parse::RecDescent::_tracefirst($text))
601				if defined $::RD_TRACE;
602				push @item, $_tok;
603				$item{__ACTION1__}=$_tok;
604
605
606
607				Parse::RecDescent::_trace(q{>>Matched production: ['(' section ')']<<},
608				Parse::RecDescent::_tracefirst($text),
609				q{bracket_section},
610				$tracelevel)
611				if defined $::RD_TRACE;
612				$_matched = 1;
613				last;
614				}
615
616
617				while (!$_matched && !$commit)
618				{
619
620				Parse::RecDescent::_trace(q{Trying production: ['\{' section '\}']},
621				Parse::RecDescent::_tracefirst($_[1]),
622				q{bracket_section},
623				$tracelevel)
624				if defined $::RD_TRACE;
625				my $thisprod = $thisrule->{"prods"}[1];
626				$text = $_[1];
627				my $_savetext;
628				@item = (q{bracket_section});
629				%item = (__RULE__ => q{bracket_section});
630				my $repcount = 0;
631
632
633				Parse::RecDescent::_trace(q{Trying terminal: ['\{']},
634				Parse::RecDescent::_tracefirst($text),
635				q{bracket_section},
636				$tracelevel)
637				if defined $::RD_TRACE;
638				$lastsep = "";
639				$expectation->is(q{})->at($text);
640
641
642				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\{//)
643				{
644
645				$expectation->failed();
646				Parse::RecDescent::_trace(qq{<>},
647				Parse::RecDescent::_tracefirst($text))
648				if defined $::RD_TRACE;
649				last;
650				}
651				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
652				. $& . q{])},
653				Parse::RecDescent::_tracefirst($text))
654				if defined $::RD_TRACE;
655				push @item, $item{__STRING1__}=$&;
656
657
658				Parse::RecDescent::_trace(q{Trying repeated subrule: [section]},
659				Parse::RecDescent::_tracefirst($text),
660				q{bracket_section},
661				$tracelevel)
662				if defined $::RD_TRACE;
663				$expectation->is(q{section})->at($text);
664
665				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::section, 0, 100000000, $_noactions,$expectation,undef)))
666				{
667				Parse::RecDescent::_trace(q{<>},
668				Parse::RecDescent::_tracefirst($text),
669				q{bracket_section},
670				$tracelevel)
671				if defined $::RD_TRACE;
672				last;
673				}
674				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [section]<< (}
675				. @$_tok . q{ times)},
676
677				Parse::RecDescent::_tracefirst($text),
678				q{bracket_section},
679				$tracelevel)
680				if defined $::RD_TRACE;
681				$item{q{section(s?)}} = $_tok;
682				push @item, $_tok;
683
684
685
686				Parse::RecDescent::_trace(q{Trying terminal: ['\}']},
687				Parse::RecDescent::_tracefirst($text),
688				q{bracket_section},
689				$tracelevel)
690				if defined $::RD_TRACE;
691				$lastsep = "";
692				$expectation->is(q{'\}'})->at($text);
693
694
695				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\}//)
696				{
697
698				$expectation->failed();
699				Parse::RecDescent::_trace(qq{<>},
700				Parse::RecDescent::_tracefirst($text))
701				if defined $::RD_TRACE;
702				last;
703				}
704				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
705				. $& . q{])},
706				Parse::RecDescent::_tracefirst($text))
707				if defined $::RD_TRACE;
708				push @item, $item{__STRING2__}=$&;
709
710
711				Parse::RecDescent::_trace(q{Trying action},
712				Parse::RecDescent::_tracefirst($text),
713				q{bracket_section},
714				$tracelevel)
715				if defined $::RD_TRACE;
716
717
718				$_tok = ($_noactions) ? 0 : do {$item[2]};
719				unless (defined $_tok)
720				{
721				Parse::RecDescent::_trace(q{<> (return value: [undef])})
722				if defined $::RD_TRACE;
723				last;
724				}
725				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
726				. $_tok . q{])},
727				Parse::RecDescent::_tracefirst($text))
728				if defined $::RD_TRACE;
729				push @item, $_tok;
730				$item{__ACTION1__}=$_tok;
731
732
733
734				Parse::RecDescent::_trace(q{>>Matched production: ['\{' section '\}']<<},
735				Parse::RecDescent::_tracefirst($text),
736				q{bracket_section},
737				$tracelevel)
738				if defined $::RD_TRACE;
739				$_matched = 1;
740				last;
741				}
742
743
744				while (!$_matched && !$commit)
745				{
746				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
747				Parse::RecDescent::_trace(q{Trying production: [ '[' section ']']},
748				Parse::RecDescent::_tracefirst($_[1]),
749				q{bracket_section},
750				$tracelevel)
751				if defined $::RD_TRACE;
752				my $thisprod = $thisrule->{"prods"}[2];
753				$text = $_[1];
754				my $_savetext;
755				@item = (q{bracket_section});
756				%item = (__RULE__ => q{bracket_section});
757				my $repcount = 0;
758
759
760
761
762				Parse::RecDescent::_trace(q{Trying directive: []},
763				Parse::RecDescent::_tracefirst($text),
764				q{bracket_section},
765				$tracelevel)
766				if defined $::RD_TRACE;
767				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline; $oldskip };
768				if (defined($_tok))
769				{
770				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
771				. $_tok . q{])},
772				Parse::RecDescent::_tracefirst($text))
773				if defined $::RD_TRACE;
774				}
775				else
776				{
777				Parse::RecDescent::_trace(q{<>},
778				Parse::RecDescent::_tracefirst($text))
779				if defined $::RD_TRACE;
780				}
781
782				last unless defined $_tok;
783				push @item, $item{__DIRECTIVE1__}=$_tok;
784
785
786				Parse::RecDescent::_trace(q{Trying terminal: ['[']},
787				Parse::RecDescent::_tracefirst($text),
788				q{bracket_section},
789				$tracelevel)
790				if defined $::RD_TRACE;
791				$lastsep = "";
792				$expectation->is(q{'['})->at($text);
793
794
795				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\[//)
796				{
797
798				$expectation->failed();
799				Parse::RecDescent::_trace(qq{<>},
800				Parse::RecDescent::_tracefirst($text))
801				if defined $::RD_TRACE;
802				last;
803				}
804				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
805				. $& . q{])},
806				Parse::RecDescent::_tracefirst($text))
807				if defined $::RD_TRACE;
808				push @item, $item{__STRING1__}=$&;
809
810
811
812
813				Parse::RecDescent::_trace(q{Trying directive: []},
814				Parse::RecDescent::_tracefirst($text),
815				q{bracket_section},
816				$tracelevel)
817				if defined $::RD_TRACE;
818				$_tok = do { my $oldskip = $skip; $skip= $withnewline; $oldskip };
819				if (defined($_tok))
820				{
821				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
822				. $_tok . q{])},
823				Parse::RecDescent::_tracefirst($text))
824				if defined $::RD_TRACE;
825				}
826				else
827				{
828				Parse::RecDescent::_trace(q{<>},
829				Parse::RecDescent::_tracefirst($text))
830				if defined $::RD_TRACE;
831				}
832
833				last unless defined $_tok;
834				push @item, $item{__DIRECTIVE2__}=$_tok;
835
836
837				Parse::RecDescent::_trace(q{Trying repeated subrule: [section]},
838				Parse::RecDescent::_tracefirst($text),
839				q{bracket_section},
840				$tracelevel)
841				if defined $::RD_TRACE;
842				$expectation->is(q{section})->at($text);
843
844				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::section, 0, 100000000, $_noactions,$expectation,undef)))
845				{
846				Parse::RecDescent::_trace(q{<>},
847				Parse::RecDescent::_tracefirst($text),
848				q{bracket_section},
849				$tracelevel)
850				if defined $::RD_TRACE;
851				last;
852				}
853				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [section]<< (}
854				. @$_tok . q{ times)},
855
856				Parse::RecDescent::_tracefirst($text),
857				q{bracket_section},
858				$tracelevel)
859				if defined $::RD_TRACE;
860				$item{q{section(s?)}} = $_tok;
861				push @item, $_tok;
862
863
864
865				Parse::RecDescent::_trace(q{Trying terminal: [']']},
866				Parse::RecDescent::_tracefirst($text),
867				q{bracket_section},
868				$tracelevel)
869				if defined $::RD_TRACE;
870				$lastsep = "";
871				$expectation->is(q{']'})->at($text);
872
873
874				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\]//)
875				{
876
877				$expectation->failed();
878				Parse::RecDescent::_trace(qq{<>},
879				Parse::RecDescent::_tracefirst($text))
880				if defined $::RD_TRACE;
881				last;
882				}
883				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
884				. $& . q{])},
885				Parse::RecDescent::_tracefirst($text))
886				if defined $::RD_TRACE;
887				push @item, $item{__STRING2__}=$&;
888
889
890				Parse::RecDescent::_trace(q{Trying action},
891				Parse::RecDescent::_tracefirst($text),
892				q{bracket_section},
893				$tracelevel)
894				if defined $::RD_TRACE;
895
896
897				$_tok = ($_noactions) ? 0 : do {$item[2]};
898				unless (defined $_tok)
899				{
900				Parse::RecDescent::_trace(q{<> (return value: [undef])})
901				if defined $::RD_TRACE;
902				last;
903				}
904				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
905				. $_tok . q{])},
906				Parse::RecDescent::_tracefirst($text))
907				if defined $::RD_TRACE;
908				push @item, $_tok;
909				$item{__ACTION1__}=$_tok;
910
911
912
913				Parse::RecDescent::_trace(q{>>Matched production: [ '[' section ']']<<},
914				Parse::RecDescent::_tracefirst($text),
915				q{bracket_section},
916				$tracelevel)
917				if defined $::RD_TRACE;
918				$_matched = 1;
919				last;
920				}
921
922
923				unless ( $_matched \|\| defined($return) \|\| defined($score) )
924				{
925
926
927				$_[1] = $text; # NOT SURE THIS IS NEEDED
928				Parse::RecDescent::_trace(q{<>},
929				Parse::RecDescent::_tracefirst($_[1]),
930				q{bracket_section},
931				$tracelevel)
932				if defined $::RD_TRACE;
933				return undef;
934				}
935				if (!defined($return) && defined($score))
936				{
937				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
938				q{bracket_section},
939				$tracelevel)
940				if defined $::RD_TRACE;
941				$return = $score_return;
942				}
943				splice @{$thisparser->{errors}}, $err_at;
944				$return = $item[$#item] unless defined $return;
945				if (defined $::RD_TRACE)
946				{
947				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
948				$return . q{])}, "",
949				q{bracket_section},
950				$tracelevel);
951				Parse::RecDescent::_trace(q{(consumed: [} .
952				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
953				Parse::RecDescent::_tracefirst($text),
954				, q{bracket_section},
955				$tracelevel)
956				}
957				$_[1] = $text;
958				return $return;
959				}
960
961				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
962				sub Parse::RecDescent::Config::Magic::Grammar::section
963				{
964				my $thisparser = $_[0];
965				use vars q{$tracelevel};
966				local $tracelevel = ($tracelevel\|\|0)+1;
967				$ERRORS = 0;
968				my $thisrule = $thisparser->{"rules"}{"section"};
969
970				Parse::RecDescent::_trace(q{Trying rule: [section]},
971				Parse::RecDescent::_tracefirst($_[1]),
972				q{section},
973				$tracelevel)
974				if defined $::RD_TRACE;
975
976
977				my $err_at = @{$thisparser->{errors}};
978
979				my $score;
980				my $score_return;
981				my $_tok;
982				my $return = undef;
983				my $_matched=0;
984				my $commit=0;
985				my @item = ();
986				my %item = ();
987				my $repeating = defined($_[2]) && $_[2];
988				my $_noactions = defined($_[3]) && $_[3];
989				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
990				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
991				my $text;
992				my $lastsep="";
993				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
994				$expectation->at($_[1]);
995
996				my $thisline;
997				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
998
999
1000
1001				while (!$_matched && !$commit)
1002				{
1003
1004				Parse::RecDescent::_trace(q{Trying production: ['<' svar xml_1]},
1005				Parse::RecDescent::_tracefirst($_[1]),
1006				q{section},
1007				$tracelevel)
1008				if defined $::RD_TRACE;
1009				my $thisprod = $thisrule->{"prods"}[0];
1010				$text = $_[1];
1011				my $_savetext;
1012				@item = (q{section});
1013				%item = (__RULE__ => q{section});
1014				my $repcount = 0;
1015
1016
1017				Parse::RecDescent::_trace(q{Trying terminal: ['<']},
1018				Parse::RecDescent::_tracefirst($text),
1019				q{section},
1020				$tracelevel)
1021				if defined $::RD_TRACE;
1022				$lastsep = "";
1023				$expectation->is(q{})->at($text);
1024
1025
1026				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\
1027				{
1028
1029				$expectation->failed();
1030				Parse::RecDescent::_trace(qq{<>},
1031				Parse::RecDescent::_tracefirst($text))
1032				if defined $::RD_TRACE;
1033				last;
1034				}
1035				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1036				. $& . q{])},
1037				Parse::RecDescent::_tracefirst($text))
1038				if defined $::RD_TRACE;
1039				push @item, $item{__STRING1__}=$&;
1040
1041
1042				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
1043				Parse::RecDescent::_tracefirst($text),
1044				q{section},
1045				$tracelevel)
1046				if defined $::RD_TRACE;
1047				if (1) { no strict qw{refs};
1048				$expectation->is(q{svar})->at($text);
1049				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1050				{
1051
1052				Parse::RecDescent::_trace(q{<>},
1053				Parse::RecDescent::_tracefirst($text),
1054				q{section},
1055				$tracelevel)
1056				if defined $::RD_TRACE;
1057				$expectation->failed();
1058				last;
1059				}
1060				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
1061				. $_tok . q{]},
1062
1063				Parse::RecDescent::_tracefirst($text),
1064				q{section},
1065				$tracelevel)
1066				if defined $::RD_TRACE;
1067				$item{q{svar}} = $_tok;
1068				push @item, $_tok;
1069
1070				}
1071
1072
1073
1074				Parse::RecDescent::_trace(q{Trying directive: []},
1075				Parse::RecDescent::_tracefirst($text),
1076				q{section},
1077				$tracelevel)
1078				if defined $::RD_TRACE;
1079				$_tok = do { $commit = 1 };
1080				if (defined($_tok))
1081				{
1082				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
1083				. $_tok . q{])},
1084				Parse::RecDescent::_tracefirst($text))
1085				if defined $::RD_TRACE;
1086				}
1087				else
1088				{
1089				Parse::RecDescent::_trace(q{<>},
1090				Parse::RecDescent::_tracefirst($text))
1091				if defined $::RD_TRACE;
1092				}
1093
1094				last unless defined $_tok;
1095				push @item, $item{__DIRECTIVE1__}=$_tok;
1096
1097
1098				Parse::RecDescent::_trace(q{Trying subrule: [xml_1]},
1099				Parse::RecDescent::_tracefirst($text),
1100				q{section},
1101				$tracelevel)
1102				if defined $::RD_TRACE;
1103				if (1) { no strict qw{refs};
1104				$expectation->is(q{xml_1})->at($text);
1105				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::xml_1($thisparser,$text,$repeating,$_noactions,sub { return [$item[2]] })))
1106				{
1107
1108				Parse::RecDescent::_trace(q{<>},
1109				Parse::RecDescent::_tracefirst($text),
1110				q{section},
1111				$tracelevel)
1112				if defined $::RD_TRACE;
1113				$expectation->failed();
1114				last;
1115				}
1116				Parse::RecDescent::_trace(q{>>Matched subrule: [xml_1]<< (return value: [}
1117				. $_tok . q{]},
1118
1119				Parse::RecDescent::_tracefirst($text),
1120				q{section},
1121				$tracelevel)
1122				if defined $::RD_TRACE;
1123				$item{q{xml_1}} = $_tok;
1124				push @item, $_tok;
1125
1126				}
1127
1128				Parse::RecDescent::_trace(q{Trying action},
1129				Parse::RecDescent::_tracefirst($text),
1130				q{section},
1131				$tracelevel)
1132				if defined $::RD_TRACE;
1133
1134
1135				$_tok = ($_noactions) ? 0 : do {[$item[2],$item[4]]};
1136				unless (defined $_tok)
1137				{
1138				Parse::RecDescent::_trace(q{<> (return value: [undef])})
1139				if defined $::RD_TRACE;
1140				last;
1141				}
1142				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1143				. $_tok . q{])},
1144				Parse::RecDescent::_tracefirst($text))
1145				if defined $::RD_TRACE;
1146				push @item, $_tok;
1147				$item{__ACTION1__}=$_tok;
1148
1149
1150
1151				Parse::RecDescent::_trace(q{>>Matched production: ['<' svar xml_1]<<},
1152				Parse::RecDescent::_tracefirst($text),
1153				q{section},
1154				$tracelevel)
1155				if defined $::RD_TRACE;
1156				$_matched = 1;
1157				last;
1158				}
1159
1160
1161				while (!$_matched && !$commit)
1162				{
1163
1164				Parse::RecDescent::_trace(q{Trying production: [ini_name strict_assign]},
1165				Parse::RecDescent::_tracefirst($_[1]),
1166				q{section},
1167				$tracelevel)
1168				if defined $::RD_TRACE;
1169				my $thisprod = $thisrule->{"prods"}[1];
1170				$text = $_[1];
1171				my $_savetext;
1172				@item = (q{section});
1173				%item = (__RULE__ => q{section});
1174				my $repcount = 0;
1175
1176
1177				Parse::RecDescent::_trace(q{Trying subrule: [ini_name]},
1178				Parse::RecDescent::_tracefirst($text),
1179				q{section},
1180				$tracelevel)
1181				if defined $::RD_TRACE;
1182				if (1) { no strict qw{refs};
1183				$expectation->is(q{})->at($text);
1184				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::ini_name($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1185				{
1186
1187				Parse::RecDescent::_trace(q{<>},
1188				Parse::RecDescent::_tracefirst($text),
1189				q{section},
1190				$tracelevel)
1191				if defined $::RD_TRACE;
1192				$expectation->failed();
1193				last;
1194				}
1195				Parse::RecDescent::_trace(q{>>Matched subrule: [ini_name]<< (return value: [}
1196				. $_tok . q{]},
1197
1198				Parse::RecDescent::_tracefirst($text),
1199				q{section},
1200				$tracelevel)
1201				if defined $::RD_TRACE;
1202				$item{q{ini_name}} = $_tok;
1203				push @item, $_tok;
1204
1205				}
1206
1207
1208
1209				Parse::RecDescent::_trace(q{Trying directive: []},
1210				Parse::RecDescent::_tracefirst($text),
1211				q{section},
1212				$tracelevel)
1213				if defined $::RD_TRACE;
1214				$_tok = do { $commit = 1 };
1215				if (defined($_tok))
1216				{
1217				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
1218				. $_tok . q{])},
1219				Parse::RecDescent::_tracefirst($text))
1220				if defined $::RD_TRACE;
1221				}
1222				else
1223				{
1224				Parse::RecDescent::_trace(q{<>},
1225				Parse::RecDescent::_tracefirst($text))
1226				if defined $::RD_TRACE;
1227				}
1228
1229				last unless defined $_tok;
1230				push @item, $item{__DIRECTIVE1__}=$_tok;
1231
1232
1233				Parse::RecDescent::_trace(q{Trying repeated subrule: [strict_assign]},
1234				Parse::RecDescent::_tracefirst($text),
1235				q{section},
1236				$tracelevel)
1237				if defined $::RD_TRACE;
1238				$expectation->is(q{strict_assign})->at($text);
1239
1240				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::strict_assign, 0, 100000000, $_noactions,$expectation,undef)))
1241				{
1242				Parse::RecDescent::_trace(q{<>},
1243				Parse::RecDescent::_tracefirst($text),
1244				q{section},
1245				$tracelevel)
1246				if defined $::RD_TRACE;
1247				last;
1248				}
1249				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [strict_assign]<< (}
1250				. @$_tok . q{ times)},
1251
1252				Parse::RecDescent::_tracefirst($text),
1253				q{section},
1254				$tracelevel)
1255				if defined $::RD_TRACE;
1256				$item{q{strict_assign(s?)}} = $_tok;
1257				push @item, $_tok;
1258
1259
1260
1261				Parse::RecDescent::_trace(q{Trying action},
1262				Parse::RecDescent::_tracefirst($text),
1263				q{section},
1264				$tracelevel)
1265				if defined $::RD_TRACE;
1266
1267
1268				$_tok = ($_noactions) ? 0 : do {section_checker($item[1],$item[3],$thisparser)};
1269				unless (defined $_tok)
1270				{
1271				Parse::RecDescent::_trace(q{<> (return value: [undef])})
1272				if defined $::RD_TRACE;
1273				last;
1274				}
1275				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1276				. $_tok . q{])},
1277				Parse::RecDescent::_tracefirst($text))
1278				if defined $::RD_TRACE;
1279				push @item, $_tok;
1280				$item{__ACTION1__}=$_tok;
1281
1282
1283
1284				Parse::RecDescent::_trace(q{>>Matched production: [ini_name strict_assign]<<},
1285				Parse::RecDescent::_tracefirst($text),
1286				q{section},
1287				$tracelevel)
1288				if defined $::RD_TRACE;
1289				$_matched = 1;
1290				last;
1291				}
1292
1293
1294				while (!$_matched && !$commit)
1295				{
1296
1297				Parse::RecDescent::_trace(q{Trying production: [varlist bracket_section]},
1298				Parse::RecDescent::_tracefirst($_[1]),
1299				q{section},
1300				$tracelevel)
1301				if defined $::RD_TRACE;
1302				my $thisprod = $thisrule->{"prods"}[2];
1303				$text = $_[1];
1304				my $_savetext;
1305				@item = (q{section});
1306				%item = (__RULE__ => q{section});
1307				my $repcount = 0;
1308
1309
1310				Parse::RecDescent::_trace(q{Trying subrule: [varlist]},
1311				Parse::RecDescent::_tracefirst($text),
1312				q{section},
1313				$tracelevel)
1314				if defined $::RD_TRACE;
1315				if (1) { no strict qw{refs};
1316				$expectation->is(q{})->at($text);
1317				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::varlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1318				{
1319
1320				Parse::RecDescent::_trace(q{<>},
1321				Parse::RecDescent::_tracefirst($text),
1322				q{section},
1323				$tracelevel)
1324				if defined $::RD_TRACE;
1325				$expectation->failed();
1326				last;
1327				}
1328				Parse::RecDescent::_trace(q{>>Matched subrule: [varlist]<< (return value: [}
1329				. $_tok . q{]},
1330
1331				Parse::RecDescent::_tracefirst($text),
1332				q{section},
1333				$tracelevel)
1334				if defined $::RD_TRACE;
1335				$item{q{varlist}} = $_tok;
1336				push @item, $_tok;
1337
1338				}
1339
1340				Parse::RecDescent::_trace(q{Trying subrule: [bracket_section]},
1341				Parse::RecDescent::_tracefirst($text),
1342				q{section},
1343				$tracelevel)
1344				if defined $::RD_TRACE;
1345				if (1) { no strict qw{refs};
1346				$expectation->is(q{bracket_section})->at($text);
1347				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::bracket_section($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1348				{
1349
1350				Parse::RecDescent::_trace(q{<>},
1351				Parse::RecDescent::_tracefirst($text),
1352				q{section},
1353				$tracelevel)
1354				if defined $::RD_TRACE;
1355				$expectation->failed();
1356				last;
1357				}
1358				Parse::RecDescent::_trace(q{>>Matched subrule: [bracket_section]<< (return value: [}
1359				. $_tok . q{]},
1360
1361				Parse::RecDescent::_tracefirst($text),
1362				q{section},
1363				$tracelevel)
1364				if defined $::RD_TRACE;
1365				$item{q{bracket_section}} = $_tok;
1366				push @item, $_tok;
1367
1368				}
1369
1370				Parse::RecDescent::_trace(q{Trying action},
1371				Parse::RecDescent::_tracefirst($text),
1372				q{section},
1373				$tracelevel)
1374				if defined $::RD_TRACE;
1375
1376
1377				$_tok = ($_noactions) ? 0 : do {my $title = $item[1];
1378				$title = join(' ',@{$item[1]}) if(ref $item[1] eq 'ARRAY');
1379				section_checker($title,$item[2],$thisparser);
1380				};
1381				unless (defined $_tok)
1382				{
1383				Parse::RecDescent::_trace(q{<> (return value: [undef])})
1384				if defined $::RD_TRACE;
1385				last;
1386				}
1387				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1388				. $_tok . q{])},
1389				Parse::RecDescent::_tracefirst($text))
1390				if defined $::RD_TRACE;
1391				push @item, $_tok;
1392				$item{__ACTION1__}=$_tok;
1393
1394
1395
1396				Parse::RecDescent::_trace(q{>>Matched production: [varlist bracket_section]<<},
1397				Parse::RecDescent::_tracefirst($text),
1398				q{section},
1399				$tracelevel)
1400				if defined $::RD_TRACE;
1401				$_matched = 1;
1402				last;
1403				}
1404
1405
1406				while (!$_matched && !$commit)
1407				{
1408
1409				Parse::RecDescent::_trace(q{Trying production: [assign]},
1410				Parse::RecDescent::_tracefirst($_[1]),
1411				q{section},
1412				$tracelevel)
1413				if defined $::RD_TRACE;
1414				my $thisprod = $thisrule->{"prods"}[3];
1415				$text = $_[1];
1416				my $_savetext;
1417				@item = (q{section});
1418				%item = (__RULE__ => q{section});
1419				my $repcount = 0;
1420
1421
1422				Parse::RecDescent::_trace(q{Trying subrule: [assign]},
1423				Parse::RecDescent::_tracefirst($text),
1424				q{section},
1425				$tracelevel)
1426				if defined $::RD_TRACE;
1427				if (1) { no strict qw{refs};
1428				$expectation->is(q{})->at($text);
1429				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::assign($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1430				{
1431
1432				Parse::RecDescent::_trace(q{<>},
1433				Parse::RecDescent::_tracefirst($text),
1434				q{section},
1435				$tracelevel)
1436				if defined $::RD_TRACE;
1437				$expectation->failed();
1438				last;
1439				}
1440				Parse::RecDescent::_trace(q{>>Matched subrule: [assign]<< (return value: [}
1441				. $_tok . q{]},
1442
1443				Parse::RecDescent::_tracefirst($text),
1444				q{section},
1445				$tracelevel)
1446				if defined $::RD_TRACE;
1447				$item{q{assign}} = $_tok;
1448				push @item, $_tok;
1449
1450				}
1451
1452
1453				Parse::RecDescent::_trace(q{>>Matched production: [assign]<<},
1454				Parse::RecDescent::_tracefirst($text),
1455				q{section},
1456				$tracelevel)
1457				if defined $::RD_TRACE;
1458				$_matched = 1;
1459				last;
1460				}
1461
1462
1463				unless ( $_matched \|\| defined($return) \|\| defined($score) )
1464				{
1465
1466
1467				$_[1] = $text; # NOT SURE THIS IS NEEDED
1468				Parse::RecDescent::_trace(q{<>},
1469				Parse::RecDescent::_tracefirst($_[1]),
1470				q{section},
1471				$tracelevel)
1472				if defined $::RD_TRACE;
1473				return undef;
1474				}
1475				if (!defined($return) && defined($score))
1476				{
1477				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1478				q{section},
1479				$tracelevel)
1480				if defined $::RD_TRACE;
1481				$return = $score_return;
1482				}
1483				splice @{$thisparser->{errors}}, $err_at;
1484				$return = $item[$#item] unless defined $return;
1485				if (defined $::RD_TRACE)
1486				{
1487				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1488				$return . q{])}, "",
1489				q{section},
1490				$tracelevel);
1491				Parse::RecDescent::_trace(q{(consumed: [} .
1492				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1493				Parse::RecDescent::_tracefirst($text),
1494				, q{section},
1495				$tracelevel)
1496				}
1497				$_[1] = $text;
1498				return $return;
1499				}
1500
1501				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1502				sub Parse::RecDescent::Config::Magic::Grammar::csv
1503				{
1504				my $thisparser = $_[0];
1505				use vars q{$tracelevel};
1506				local $tracelevel = ($tracelevel\|\|0)+1;
1507				$ERRORS = 0;
1508				my $thisrule = $thisparser->{"rules"}{"csv"};
1509
1510				Parse::RecDescent::_trace(q{Trying rule: [csv]},
1511				Parse::RecDescent::_tracefirst($_[1]),
1512				q{csv},
1513				$tracelevel)
1514				if defined $::RD_TRACE;
1515
1516
1517				my $err_at = @{$thisparser->{errors}};
1518
1519				my $score;
1520				my $score_return;
1521				my $_tok;
1522				my $return = undef;
1523				my $_matched=0;
1524				my $commit=0;
1525				my @item = ();
1526				my %item = ();
1527				my $repeating = defined($_[2]) && $_[2];
1528				my $_noactions = defined($_[3]) && $_[3];
1529				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1530				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1531				my $text;
1532				my $lastsep="";
1533				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1534				$expectation->at($_[1]);
1535
1536				my $thisline;
1537				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1538
1539
1540
1541				while (!$_matched && !$commit)
1542				{
1543
1544				Parse::RecDescent::_trace(q{Trying production: [svar ',']},
1545				Parse::RecDescent::_tracefirst($_[1]),
1546				q{csv},
1547				$tracelevel)
1548				if defined $::RD_TRACE;
1549				my $thisprod = $thisrule->{"prods"}[0];
1550				$text = $_[1];
1551				my $_savetext;
1552				@item = (q{csv});
1553				%item = (__RULE__ => q{csv});
1554				my $repcount = 0;
1555
1556
1557				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
1558				Parse::RecDescent::_tracefirst($text),
1559				q{csv},
1560				$tracelevel)
1561				if defined $::RD_TRACE;
1562				if (1) { no strict qw{refs};
1563				$expectation->is(q{})->at($text);
1564				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1565				{
1566
1567				Parse::RecDescent::_trace(q{<>},
1568				Parse::RecDescent::_tracefirst($text),
1569				q{csv},
1570				$tracelevel)
1571				if defined $::RD_TRACE;
1572				$expectation->failed();
1573				last;
1574				}
1575				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
1576				. $_tok . q{]},
1577
1578				Parse::RecDescent::_tracefirst($text),
1579				q{csv},
1580				$tracelevel)
1581				if defined $::RD_TRACE;
1582				$item{q{svar}} = $_tok;
1583				push @item, $_tok;
1584
1585				}
1586
1587				Parse::RecDescent::_trace(q{Trying terminal: [',']},
1588				Parse::RecDescent::_tracefirst($text),
1589				q{csv},
1590				$tracelevel)
1591				if defined $::RD_TRACE;
1592				$lastsep = "";
1593				$expectation->is(q{','})->at($text);
1594
1595
1596				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\,//)
1597				{
1598
1599				$expectation->failed();
1600				Parse::RecDescent::_trace(qq{<>},
1601				Parse::RecDescent::_tracefirst($text))
1602				if defined $::RD_TRACE;
1603				last;
1604				}
1605				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1606				. $& . q{])},
1607				Parse::RecDescent::_tracefirst($text))
1608				if defined $::RD_TRACE;
1609				push @item, $item{__STRING1__}=$&;
1610
1611
1612				Parse::RecDescent::_trace(q{Trying action},
1613				Parse::RecDescent::_tracefirst($text),
1614				q{csv},
1615				$tracelevel)
1616				if defined $::RD_TRACE;
1617
1618
1619				$_tok = ($_noactions) ? 0 : do {$item[1]};
1620				unless (defined $_tok)
1621				{
1622				Parse::RecDescent::_trace(q{<> (return value: [undef])})
1623				if defined $::RD_TRACE;
1624				last;
1625				}
1626				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1627				. $_tok . q{])},
1628				Parse::RecDescent::_tracefirst($text))
1629				if defined $::RD_TRACE;
1630				push @item, $_tok;
1631				$item{__ACTION1__}=$_tok;
1632
1633
1634
1635				Parse::RecDescent::_trace(q{>>Matched production: [svar ',']<<},
1636				Parse::RecDescent::_tracefirst($text),
1637				q{csv},
1638				$tracelevel)
1639				if defined $::RD_TRACE;
1640				$_matched = 1;
1641				last;
1642				}
1643
1644
1645				while (!$_matched && !$commit)
1646				{
1647
1648				Parse::RecDescent::_trace(q{Trying production: [/([^\\n#;]*?),/]},
1649				Parse::RecDescent::_tracefirst($_[1]),
1650				q{csv},
1651				$tracelevel)
1652				if defined $::RD_TRACE;
1653				my $thisprod = $thisrule->{"prods"}[1];
1654				$text = $_[1];
1655				my $_savetext;
1656				@item = (q{csv});
1657				%item = (__RULE__ => q{csv});
1658				my $repcount = 0;
1659
1660
1661				Parse::RecDescent::_trace(q{Trying terminal: [/([^\\n#;]*?),/]}, Parse::RecDescent::_tracefirst($text),
1662				q{csv},
1663				$tracelevel)
1664				if defined $::RD_TRACE;
1665				$lastsep = "";
1666				$expectation->is(q{})->at($text);
1667
1668
1669				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:([^\n#;]*?),)//)
1670				{
1671
1672				$expectation->failed();
1673				Parse::RecDescent::_trace(q{<>},
1674				Parse::RecDescent::_tracefirst($text))
1675				if defined $::RD_TRACE;
1676
1677				last;
1678				}
1679				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1680				. $& . q{])},
1681				Parse::RecDescent::_tracefirst($text))
1682				if defined $::RD_TRACE;
1683				push @item, $item{__PATTERN1__}=$&;
1684
1685
1686				Parse::RecDescent::_trace(q{Trying action},
1687				Parse::RecDescent::_tracefirst($text),
1688				q{csv},
1689				$tracelevel)
1690				if defined $::RD_TRACE;
1691
1692
1693				$_tok = ($_noactions) ? 0 : do {$1;};
1694				unless (defined $_tok)
1695				{
1696				Parse::RecDescent::_trace(q{<> (return value: [undef])})
1697				if defined $::RD_TRACE;
1698				last;
1699				}
1700				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1701				. $_tok . q{])},
1702				Parse::RecDescent::_tracefirst($text))
1703				if defined $::RD_TRACE;
1704				push @item, $_tok;
1705				$item{__ACTION1__}=$_tok;
1706
1707
1708
1709				Parse::RecDescent::_trace(q{>>Matched production: [/([^\\n#;]*?),/]<<},
1710				Parse::RecDescent::_tracefirst($text),
1711				q{csv},
1712				$tracelevel)
1713				if defined $::RD_TRACE;
1714				$_matched = 1;
1715				last;
1716				}
1717
1718
1719				unless ( $_matched \|\| defined($return) \|\| defined($score) )
1720				{
1721
1722
1723				$_[1] = $text; # NOT SURE THIS IS NEEDED
1724				Parse::RecDescent::_trace(q{<>},
1725				Parse::RecDescent::_tracefirst($_[1]),
1726				q{csv},
1727				$tracelevel)
1728				if defined $::RD_TRACE;
1729				return undef;
1730				}
1731				if (!defined($return) && defined($score))
1732				{
1733				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1734				q{csv},
1735				$tracelevel)
1736				if defined $::RD_TRACE;
1737				$return = $score_return;
1738				}
1739				splice @{$thisparser->{errors}}, $err_at;
1740				$return = $item[$#item] unless defined $return;
1741				if (defined $::RD_TRACE)
1742				{
1743				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1744				$return . q{])}, "",
1745				q{csv},
1746				$tracelevel);
1747				Parse::RecDescent::_trace(q{(consumed: [} .
1748				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1749				Parse::RecDescent::_tracefirst($text),
1750				, q{csv},
1751				$tracelevel)
1752				}
1753				$_[1] = $text;
1754				return $return;
1755				}
1756
1757				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1758				sub Parse::RecDescent::Config::Magic::Grammar::xml_assigns
1759				{
1760				my $thisparser = $_[0];
1761				use vars q{$tracelevel};
1762				local $tracelevel = ($tracelevel\|\|0)+1;
1763				$ERRORS = 0;
1764				my $thisrule = $thisparser->{"rules"}{"xml_assigns"};
1765
1766				Parse::RecDescent::_trace(q{Trying rule: [xml_assigns]},
1767				Parse::RecDescent::_tracefirst($_[1]),
1768				q{xml_assigns},
1769				$tracelevel)
1770				if defined $::RD_TRACE;
1771
1772
1773				my $err_at = @{$thisparser->{errors}};
1774
1775				my $score;
1776				my $score_return;
1777				my $_tok;
1778				my $return = undef;
1779				my $_matched=0;
1780				my $commit=0;
1781				my @item = ();
1782				my %item = ();
1783				my $repeating = defined($_[2]) && $_[2];
1784				my $_noactions = defined($_[3]) && $_[3];
1785				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1786				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1787				my $text;
1788				my $lastsep="";
1789				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1790				$expectation->at($_[1]);
1791
1792				my $thisline;
1793				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1794
1795
1796
1797				while (!$_matched && !$commit)
1798				{
1799
1800				Parse::RecDescent::_trace(q{Trying production: [xml_assign]},
1801				Parse::RecDescent::_tracefirst($_[1]),
1802				q{xml_assigns},
1803				$tracelevel)
1804				if defined $::RD_TRACE;
1805				my $thisprod = $thisrule->{"prods"}[0];
1806				$text = $_[1];
1807				my $_savetext;
1808				@item = (q{xml_assigns});
1809				%item = (__RULE__ => q{xml_assigns});
1810				my $repcount = 0;
1811
1812
1813				Parse::RecDescent::_trace(q{Trying repeated subrule: [xml_assign]},
1814				Parse::RecDescent::_tracefirst($text),
1815				q{xml_assigns},
1816				$tracelevel)
1817				if defined $::RD_TRACE;
1818				$expectation->is(q{})->at($text);
1819
1820				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::xml_assign, 0, 100000000, $_noactions,$expectation,undef)))
1821				{
1822				Parse::RecDescent::_trace(q{<>},
1823				Parse::RecDescent::_tracefirst($text),
1824				q{xml_assigns},
1825				$tracelevel)
1826				if defined $::RD_TRACE;
1827				last;
1828				}
1829				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [xml_assign]<< (}
1830				. @$_tok . q{ times)},
1831
1832				Parse::RecDescent::_tracefirst($text),
1833				q{xml_assigns},
1834				$tracelevel)
1835				if defined $::RD_TRACE;
1836				$item{q{xml_assign(s?)}} = $_tok;
1837				push @item, $_tok;
1838
1839
1840
1841				Parse::RecDescent::_trace(q{Trying action},
1842				Parse::RecDescent::_tracefirst($text),
1843				q{xml_assigns},
1844				$tracelevel)
1845				if defined $::RD_TRACE;
1846
1847
1848				$_tok = ($_noactions) ? 0 : do {array2hash($item[1])};
1849				unless (defined $_tok)
1850				{
1851				Parse::RecDescent::_trace(q{<> (return value: [undef])})
1852				if defined $::RD_TRACE;
1853				last;
1854				}
1855				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1856				. $_tok . q{])},
1857				Parse::RecDescent::_tracefirst($text))
1858				if defined $::RD_TRACE;
1859				push @item, $_tok;
1860				$item{__ACTION1__}=$_tok;
1861
1862
1863
1864				Parse::RecDescent::_trace(q{>>Matched production: [xml_assign]<<},
1865				Parse::RecDescent::_tracefirst($text),
1866				q{xml_assigns},
1867				$tracelevel)
1868				if defined $::RD_TRACE;
1869				$_matched = 1;
1870				last;
1871				}
1872
1873
1874				unless ( $_matched \|\| defined($return) \|\| defined($score) )
1875				{
1876
1877
1878				$_[1] = $text; # NOT SURE THIS IS NEEDED
1879				Parse::RecDescent::_trace(q{<>},
1880				Parse::RecDescent::_tracefirst($_[1]),
1881				q{xml_assigns},
1882				$tracelevel)
1883				if defined $::RD_TRACE;
1884				return undef;
1885				}
1886				if (!defined($return) && defined($score))
1887				{
1888				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1889				q{xml_assigns},
1890				$tracelevel)
1891				if defined $::RD_TRACE;
1892				$return = $score_return;
1893				}
1894				splice @{$thisparser->{errors}}, $err_at;
1895				$return = $item[$#item] unless defined $return;
1896				if (defined $::RD_TRACE)
1897				{
1898				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1899				$return . q{])}, "",
1900				q{xml_assigns},
1901				$tracelevel);
1902				Parse::RecDescent::_trace(q{(consumed: [} .
1903				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1904				Parse::RecDescent::_tracefirst($text),
1905				, q{xml_assigns},
1906				$tracelevel)
1907				}
1908				$_[1] = $text;
1909				return $return;
1910				}
1911
1912				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1913				sub Parse::RecDescent::Config::Magic::Grammar::xml_single
1914				{
1915				my $thisparser = $_[0];
1916				use vars q{$tracelevel};
1917				local $tracelevel = ($tracelevel\|\|0)+1;
1918				$ERRORS = 0;
1919				my $thisrule = $thisparser->{"rules"}{"xml_single"};
1920
1921				Parse::RecDescent::_trace(q{Trying rule: [xml_single]},
1922				Parse::RecDescent::_tracefirst($_[1]),
1923				q{xml_single},
1924				$tracelevel)
1925				if defined $::RD_TRACE;
1926
1927
1928				my $err_at = @{$thisparser->{errors}};
1929
1930				my $score;
1931				my $score_return;
1932				my $_tok;
1933				my $return = undef;
1934				my $_matched=0;
1935				my $commit=0;
1936				my @item = ();
1937				my %item = ();
1938				my $repeating = defined($_[2]) && $_[2];
1939				my $_noactions = defined($_[3]) && $_[3];
1940				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
1941				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1942				my $text;
1943				my $lastsep="";
1944				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1945				$expectation->at($_[1]);
1946
1947				my $thisline;
1948				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1949
1950
1951
1952				while (!$_matched && !$commit)
1953				{
1954
1955				Parse::RecDescent::_trace(q{Trying production: [varlist '\\/>']},
1956				Parse::RecDescent::_tracefirst($_[1]),
1957				q{xml_single},
1958				$tracelevel)
1959				if defined $::RD_TRACE;
1960				my $thisprod = $thisrule->{"prods"}[0];
1961				$text = $_[1];
1962				my $_savetext;
1963				@item = (q{xml_single});
1964				%item = (__RULE__ => q{xml_single});
1965				my $repcount = 0;
1966
1967
1968				Parse::RecDescent::_trace(q{Trying subrule: [varlist]},
1969				Parse::RecDescent::_tracefirst($text),
1970				q{xml_single},
1971				$tracelevel)
1972				if defined $::RD_TRACE;
1973				if (1) { no strict qw{refs};
1974				$expectation->is(q{})->at($text);
1975				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::varlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
1976				{
1977
1978				Parse::RecDescent::_trace(q{<>},
1979				Parse::RecDescent::_tracefirst($text),
1980				q{xml_single},
1981				$tracelevel)
1982				if defined $::RD_TRACE;
1983				$expectation->failed();
1984				last;
1985				}
1986				Parse::RecDescent::_trace(q{>>Matched subrule: [varlist]<< (return value: [}
1987				. $_tok . q{]},
1988
1989				Parse::RecDescent::_tracefirst($text),
1990				q{xml_single},
1991				$tracelevel)
1992				if defined $::RD_TRACE;
1993				$item{q{varlist}} = $_tok;
1994				push @item, $_tok;
1995
1996				}
1997
1998				Parse::RecDescent::_trace(q{Trying terminal: ['\\/>']},
1999				Parse::RecDescent::_tracefirst($text),
2000				q{xml_single},
2001				$tracelevel)
2002				if defined $::RD_TRACE;
2003				$lastsep = "";
2004				$expectation->is(q{'\\/>'})->at($text);
2005
2006
2007				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "\/>"; 1 } and
2008				substr($text,0,length($_tok)) eq $_tok and
2009				do { substr($text,0,length($_tok)) = ""; 1; }
2010				)
2011				{
2012
2013				$expectation->failed();
2014				Parse::RecDescent::_trace(q{<>},
2015				Parse::RecDescent::_tracefirst($text))
2016				if defined $::RD_TRACE;
2017				last;
2018				}
2019				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2020				. $_tok . q{])},
2021				Parse::RecDescent::_tracefirst($text))
2022				if defined $::RD_TRACE;
2023				push @item, $item{__STRING1__}=$_tok;
2024
2025
2026				Parse::RecDescent::_trace(q{Trying action},
2027				Parse::RecDescent::_tracefirst($text),
2028				q{xml_single},
2029				$tracelevel)
2030				if defined $::RD_TRACE;
2031
2032
2033				$_tok = ($_noactions) ? 0 : do {$item[1]};
2034				unless (defined $_tok)
2035				{
2036				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2037				if defined $::RD_TRACE;
2038				last;
2039				}
2040				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2041				. $_tok . q{])},
2042				Parse::RecDescent::_tracefirst($text))
2043				if defined $::RD_TRACE;
2044				push @item, $_tok;
2045				$item{__ACTION1__}=$_tok;
2046
2047
2048
2049				Parse::RecDescent::_trace(q{>>Matched production: [varlist '\\/>']<<},
2050				Parse::RecDescent::_tracefirst($text),
2051				q{xml_single},
2052				$tracelevel)
2053				if defined $::RD_TRACE;
2054				$_matched = 1;
2055				last;
2056				}
2057
2058
2059				while (!$_matched && !$commit)
2060				{
2061
2062				Parse::RecDescent::_trace(q{Trying production: [xml_assigns '\\/>']},
2063				Parse::RecDescent::_tracefirst($_[1]),
2064				q{xml_single},
2065				$tracelevel)
2066				if defined $::RD_TRACE;
2067				my $thisprod = $thisrule->{"prods"}[1];
2068				$text = $_[1];
2069				my $_savetext;
2070				@item = (q{xml_single});
2071				%item = (__RULE__ => q{xml_single});
2072				my $repcount = 0;
2073
2074
2075				Parse::RecDescent::_trace(q{Trying subrule: [xml_assigns]},
2076				Parse::RecDescent::_tracefirst($text),
2077				q{xml_single},
2078				$tracelevel)
2079				if defined $::RD_TRACE;
2080				if (1) { no strict qw{refs};
2081				$expectation->is(q{})->at($text);
2082				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::xml_assigns($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2083				{
2084
2085				Parse::RecDescent::_trace(q{<>},
2086				Parse::RecDescent::_tracefirst($text),
2087				q{xml_single},
2088				$tracelevel)
2089				if defined $::RD_TRACE;
2090				$expectation->failed();
2091				last;
2092				}
2093				Parse::RecDescent::_trace(q{>>Matched subrule: [xml_assigns]<< (return value: [}
2094				. $_tok . q{]},
2095
2096				Parse::RecDescent::_tracefirst($text),
2097				q{xml_single},
2098				$tracelevel)
2099				if defined $::RD_TRACE;
2100				$item{q{xml_assigns}} = $_tok;
2101				push @item, $_tok;
2102
2103				}
2104
2105				Parse::RecDescent::_trace(q{Trying terminal: ['\\/>']},
2106				Parse::RecDescent::_tracefirst($text),
2107				q{xml_single},
2108				$tracelevel)
2109				if defined $::RD_TRACE;
2110				$lastsep = "";
2111				$expectation->is(q{'\\/>'})->at($text);
2112
2113
2114				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "\/>"; 1 } and
2115				substr($text,0,length($_tok)) eq $_tok and
2116				do { substr($text,0,length($_tok)) = ""; 1; }
2117				)
2118				{
2119
2120				$expectation->failed();
2121				Parse::RecDescent::_trace(q{<>},
2122				Parse::RecDescent::_tracefirst($text))
2123				if defined $::RD_TRACE;
2124				last;
2125				}
2126				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2127				. $_tok . q{])},
2128				Parse::RecDescent::_tracefirst($text))
2129				if defined $::RD_TRACE;
2130				push @item, $item{__STRING1__}=$_tok;
2131
2132
2133				Parse::RecDescent::_trace(q{Trying action},
2134				Parse::RecDescent::_tracefirst($text),
2135				q{xml_single},
2136				$tracelevel)
2137				if defined $::RD_TRACE;
2138
2139
2140				$_tok = ($_noactions) ? 0 : do {$item[1]};
2141				unless (defined $_tok)
2142				{
2143				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2144				if defined $::RD_TRACE;
2145				last;
2146				}
2147				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2148				. $_tok . q{])},
2149				Parse::RecDescent::_tracefirst($text))
2150				if defined $::RD_TRACE;
2151				push @item, $_tok;
2152				$item{__ACTION1__}=$_tok;
2153
2154
2155
2156				Parse::RecDescent::_trace(q{>>Matched production: [xml_assigns '\\/>']<<},
2157				Parse::RecDescent::_tracefirst($text),
2158				q{xml_single},
2159				$tracelevel)
2160				if defined $::RD_TRACE;
2161				$_matched = 1;
2162				last;
2163				}
2164
2165
2166				while (!$_matched && !$commit)
2167				{
2168
2169				Parse::RecDescent::_trace(q{Trying production: ['\\/>']},
2170				Parse::RecDescent::_tracefirst($_[1]),
2171				q{xml_single},
2172				$tracelevel)
2173				if defined $::RD_TRACE;
2174				my $thisprod = $thisrule->{"prods"}[2];
2175				$text = $_[1];
2176				my $_savetext;
2177				@item = (q{xml_single});
2178				%item = (__RULE__ => q{xml_single});
2179				my $repcount = 0;
2180
2181
2182				Parse::RecDescent::_trace(q{Trying terminal: ['\\/>']},
2183				Parse::RecDescent::_tracefirst($text),
2184				q{xml_single},
2185				$tracelevel)
2186				if defined $::RD_TRACE;
2187				$lastsep = "";
2188				$expectation->is(q{})->at($text);
2189
2190
2191				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "\/>"; 1 } and
2192				substr($text,0,length($_tok)) eq $_tok and
2193				do { substr($text,0,length($_tok)) = ""; 1; }
2194				)
2195				{
2196
2197				$expectation->failed();
2198				Parse::RecDescent::_trace(q{<>},
2199				Parse::RecDescent::_tracefirst($text))
2200				if defined $::RD_TRACE;
2201				last;
2202				}
2203				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2204				. $_tok . q{])},
2205				Parse::RecDescent::_tracefirst($text))
2206				if defined $::RD_TRACE;
2207				push @item, $item{__STRING1__}=$_tok;
2208
2209
2210				Parse::RecDescent::_trace(q{Trying action},
2211				Parse::RecDescent::_tracefirst($text),
2212				q{xml_single},
2213				$tracelevel)
2214				if defined $::RD_TRACE;
2215
2216
2217				$_tok = ($_noactions) ? 0 : do {[]};
2218				unless (defined $_tok)
2219				{
2220				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2221				if defined $::RD_TRACE;
2222				last;
2223				}
2224				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2225				. $_tok . q{])},
2226				Parse::RecDescent::_tracefirst($text))
2227				if defined $::RD_TRACE;
2228				push @item, $_tok;
2229				$item{__ACTION1__}=$_tok;
2230
2231
2232
2233				Parse::RecDescent::_trace(q{>>Matched production: ['\\/>']<<},
2234				Parse::RecDescent::_tracefirst($text),
2235				q{xml_single},
2236				$tracelevel)
2237				if defined $::RD_TRACE;
2238				$_matched = 1;
2239				last;
2240				}
2241
2242
2243				unless ( $_matched \|\| defined($return) \|\| defined($score) )
2244				{
2245
2246
2247				$_[1] = $text; # NOT SURE THIS IS NEEDED
2248				Parse::RecDescent::_trace(q{<>},
2249				Parse::RecDescent::_tracefirst($_[1]),
2250				q{xml_single},
2251				$tracelevel)
2252				if defined $::RD_TRACE;
2253				return undef;
2254				}
2255				if (!defined($return) && defined($score))
2256				{
2257				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2258				q{xml_single},
2259				$tracelevel)
2260				if defined $::RD_TRACE;
2261				$return = $score_return;
2262				}
2263				splice @{$thisparser->{errors}}, $err_at;
2264				$return = $item[$#item] unless defined $return;
2265				if (defined $::RD_TRACE)
2266				{
2267				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2268				$return . q{])}, "",
2269				q{xml_single},
2270				$tracelevel);
2271				Parse::RecDescent::_trace(q{(consumed: [} .
2272				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2273				Parse::RecDescent::_tracefirst($text),
2274				, q{xml_single},
2275				$tracelevel)
2276				}
2277				$_[1] = $text;
2278				return $return;
2279				}
2280
2281				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2282				sub Parse::RecDescent::Config::Magic::Grammar::xml_assign
2283				{
2284				my $thisparser = $_[0];
2285				use vars q{$tracelevel};
2286				local $tracelevel = ($tracelevel\|\|0)+1;
2287				$ERRORS = 0;
2288				my $thisrule = $thisparser->{"rules"}{"xml_assign"};
2289
2290				Parse::RecDescent::_trace(q{Trying rule: [xml_assign]},
2291				Parse::RecDescent::_tracefirst($_[1]),
2292				q{xml_assign},
2293				$tracelevel)
2294				if defined $::RD_TRACE;
2295
2296
2297				my $err_at = @{$thisparser->{errors}};
2298
2299				my $score;
2300				my $score_return;
2301				my $_tok;
2302				my $return = undef;
2303				my $_matched=0;
2304				my $commit=0;
2305				my @item = ();
2306				my %item = ();
2307				my $repeating = defined($_[2]) && $_[2];
2308				my $_noactions = defined($_[3]) && $_[3];
2309				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2310				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2311				my $text;
2312				my $lastsep="";
2313				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2314				$expectation->at($_[1]);
2315
2316				my $thisline;
2317				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2318
2319
2320
2321				while (!$_matched && !$commit)
2322				{
2323				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
2324				Parse::RecDescent::_trace(q{Trying production: [left svar]},
2325				Parse::RecDescent::_tracefirst($_[1]),
2326				q{xml_assign},
2327				$tracelevel)
2328				if defined $::RD_TRACE;
2329				my $thisprod = $thisrule->{"prods"}[0];
2330				$text = $_[1];
2331				my $_savetext;
2332				@item = (q{xml_assign});
2333				%item = (__RULE__ => q{xml_assign});
2334				my $repcount = 0;
2335
2336
2337				Parse::RecDescent::_trace(q{Trying subrule: [left]},
2338				Parse::RecDescent::_tracefirst($text),
2339				q{xml_assign},
2340				$tracelevel)
2341				if defined $::RD_TRACE;
2342				if (1) { no strict qw{refs};
2343				$expectation->is(q{})->at($text);
2344				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::left($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2345				{
2346
2347				Parse::RecDescent::_trace(q{<>},
2348				Parse::RecDescent::_tracefirst($text),
2349				q{xml_assign},
2350				$tracelevel)
2351				if defined $::RD_TRACE;
2352				$expectation->failed();
2353				last;
2354				}
2355				Parse::RecDescent::_trace(q{>>Matched subrule: [left]<< (return value: [}
2356				. $_tok . q{]},
2357
2358				Parse::RecDescent::_tracefirst($text),
2359				q{xml_assign},
2360				$tracelevel)
2361				if defined $::RD_TRACE;
2362				$item{q{left}} = $_tok;
2363				push @item, $_tok;
2364
2365				}
2366
2367
2368
2369				Parse::RecDescent::_trace(q{Trying directive: []},
2370				Parse::RecDescent::_tracefirst($text),
2371				q{xml_assign},
2372				$tracelevel)
2373				if defined $::RD_TRACE;
2374				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline; $oldskip };
2375				if (defined($_tok))
2376				{
2377				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
2378				. $_tok . q{])},
2379				Parse::RecDescent::_tracefirst($text))
2380				if defined $::RD_TRACE;
2381				}
2382				else
2383				{
2384				Parse::RecDescent::_trace(q{<>},
2385				Parse::RecDescent::_tracefirst($text))
2386				if defined $::RD_TRACE;
2387				}
2388
2389				last unless defined $_tok;
2390				push @item, $item{__DIRECTIVE1__}=$_tok;
2391
2392
2393				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
2394				Parse::RecDescent::_tracefirst($text),
2395				q{xml_assign},
2396				$tracelevel)
2397				if defined $::RD_TRACE;
2398				if (1) { no strict qw{refs};
2399				$expectation->is(q{svar})->at($text);
2400				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2401				{
2402
2403				Parse::RecDescent::_trace(q{<>},
2404				Parse::RecDescent::_tracefirst($text),
2405				q{xml_assign},
2406				$tracelevel)
2407				if defined $::RD_TRACE;
2408				$expectation->failed();
2409				last;
2410				}
2411				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
2412				. $_tok . q{]},
2413
2414				Parse::RecDescent::_tracefirst($text),
2415				q{xml_assign},
2416				$tracelevel)
2417				if defined $::RD_TRACE;
2418				$item{q{svar}} = $_tok;
2419				push @item, $_tok;
2420
2421				}
2422
2423				Parse::RecDescent::_trace(q{Trying action},
2424				Parse::RecDescent::_tracefirst($text),
2425				q{xml_assign},
2426				$tracelevel)
2427				if defined $::RD_TRACE;
2428
2429
2430				$_tok = ($_noactions) ? 0 : do { [$item[1],$item[3]] };
2431				unless (defined $_tok)
2432				{
2433				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2434				if defined $::RD_TRACE;
2435				last;
2436				}
2437				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2438				. $_tok . q{])},
2439				Parse::RecDescent::_tracefirst($text))
2440				if defined $::RD_TRACE;
2441				push @item, $_tok;
2442				$item{__ACTION1__}=$_tok;
2443
2444
2445
2446				Parse::RecDescent::_trace(q{>>Matched production: [left svar]<<},
2447				Parse::RecDescent::_tracefirst($text),
2448				q{xml_assign},
2449				$tracelevel)
2450				if defined $::RD_TRACE;
2451				$_matched = 1;
2452				last;
2453				}
2454
2455
2456				unless ( $_matched \|\| defined($return) \|\| defined($score) )
2457				{
2458
2459
2460				$_[1] = $text; # NOT SURE THIS IS NEEDED
2461				Parse::RecDescent::_trace(q{<>},
2462				Parse::RecDescent::_tracefirst($_[1]),
2463				q{xml_assign},
2464				$tracelevel)
2465				if defined $::RD_TRACE;
2466				return undef;
2467				}
2468				if (!defined($return) && defined($score))
2469				{
2470				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2471				q{xml_assign},
2472				$tracelevel)
2473				if defined $::RD_TRACE;
2474				$return = $score_return;
2475				}
2476				splice @{$thisparser->{errors}}, $err_at;
2477				$return = $item[$#item] unless defined $return;
2478				if (defined $::RD_TRACE)
2479				{
2480				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2481				$return . q{])}, "",
2482				q{xml_assign},
2483				$tracelevel);
2484				Parse::RecDescent::_trace(q{(consumed: [} .
2485				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2486				Parse::RecDescent::_tracefirst($text),
2487				, q{xml_assign},
2488				$tracelevel)
2489				}
2490				$_[1] = $text;
2491				return $return;
2492				}
2493
2494				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2495				sub Parse::RecDescent::Config::Magic::Grammar::strict_right
2496				{
2497				my $thisparser = $_[0];
2498				use vars q{$tracelevel};
2499				local $tracelevel = ($tracelevel\|\|0)+1;
2500				$ERRORS = 0;
2501				my $thisrule = $thisparser->{"rules"}{"strict_right"};
2502
2503				Parse::RecDescent::_trace(q{Trying rule: [strict_right]},
2504				Parse::RecDescent::_tracefirst($_[1]),
2505				q{strict_right},
2506				$tracelevel)
2507				if defined $::RD_TRACE;
2508
2509
2510				my $err_at = @{$thisparser->{errors}};
2511
2512				my $score;
2513				my $score_return;
2514				my $_tok;
2515				my $return = undef;
2516				my $_matched=0;
2517				my $commit=0;
2518				my @item = ();
2519				my %item = ();
2520				my $repeating = defined($_[2]) && $_[2];
2521				my $_noactions = defined($_[3]) && $_[3];
2522				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2523				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2524				my $text;
2525				my $lastsep="";
2526				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2527				$expectation->at($_[1]);
2528
2529				my $thisline;
2530				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2531
2532
2533
2534				while (!$_matched && !$commit)
2535				{
2536
2537				Parse::RecDescent::_trace(q{Trying production: [csvlist '\\n']},
2538				Parse::RecDescent::_tracefirst($_[1]),
2539				q{strict_right},
2540				$tracelevel)
2541				if defined $::RD_TRACE;
2542				my $thisprod = $thisrule->{"prods"}[0];
2543				$text = $_[1];
2544				my $_savetext;
2545				@item = (q{strict_right});
2546				%item = (__RULE__ => q{strict_right});
2547				my $repcount = 0;
2548
2549
2550				Parse::RecDescent::_trace(q{Trying subrule: [csvlist]},
2551				Parse::RecDescent::_tracefirst($text),
2552				q{strict_right},
2553				$tracelevel)
2554				if defined $::RD_TRACE;
2555				if (1) { no strict qw{refs};
2556				$expectation->is(q{})->at($text);
2557				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::csvlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2558				{
2559
2560				Parse::RecDescent::_trace(q{<>},
2561				Parse::RecDescent::_tracefirst($text),
2562				q{strict_right},
2563				$tracelevel)
2564				if defined $::RD_TRACE;
2565				$expectation->failed();
2566				last;
2567				}
2568				Parse::RecDescent::_trace(q{>>Matched subrule: [csvlist]<< (return value: [}
2569				. $_tok . q{]},
2570
2571				Parse::RecDescent::_tracefirst($text),
2572				q{strict_right},
2573				$tracelevel)
2574				if defined $::RD_TRACE;
2575				$item{q{csvlist}} = $_tok;
2576				push @item, $_tok;
2577
2578				}
2579
2580				Parse::RecDescent::_trace(q{Trying terminal: ['\\n']},
2581				Parse::RecDescent::_tracefirst($text),
2582				q{strict_right},
2583				$tracelevel)
2584				if defined $::RD_TRACE;
2585				$lastsep = "";
2586				$expectation->is(q{'\\n'})->at($text);
2587
2588
2589				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "\n"; 1 } and
2590				substr($text,0,length($_tok)) eq $_tok and
2591				do { substr($text,0,length($_tok)) = ""; 1; }
2592				)
2593				{
2594
2595				$expectation->failed();
2596				Parse::RecDescent::_trace(q{<>},
2597				Parse::RecDescent::_tracefirst($text))
2598				if defined $::RD_TRACE;
2599				last;
2600				}
2601				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2602				. $_tok . q{])},
2603				Parse::RecDescent::_tracefirst($text))
2604				if defined $::RD_TRACE;
2605				push @item, $item{__STRING1__}=$_tok;
2606
2607
2608				Parse::RecDescent::_trace(q{Trying action},
2609				Parse::RecDescent::_tracefirst($text),
2610				q{strict_right},
2611				$tracelevel)
2612				if defined $::RD_TRACE;
2613
2614
2615				$_tok = ($_noactions) ? 0 : do {$item[1]};
2616				unless (defined $_tok)
2617				{
2618				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2619				if defined $::RD_TRACE;
2620				last;
2621				}
2622				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2623				. $_tok . q{])},
2624				Parse::RecDescent::_tracefirst($text))
2625				if defined $::RD_TRACE;
2626				push @item, $_tok;
2627				$item{__ACTION1__}=$_tok;
2628
2629
2630
2631				Parse::RecDescent::_trace(q{>>Matched production: [csvlist '\\n']<<},
2632				Parse::RecDescent::_tracefirst($text),
2633				q{strict_right},
2634				$tracelevel)
2635				if defined $::RD_TRACE;
2636				$_matched = 1;
2637				last;
2638				}
2639
2640
2641				while (!$_matched && !$commit)
2642				{
2643
2644				Parse::RecDescent::_trace(q{Trying production: [varlist '\\n']},
2645				Parse::RecDescent::_tracefirst($_[1]),
2646				q{strict_right},
2647				$tracelevel)
2648				if defined $::RD_TRACE;
2649				my $thisprod = $thisrule->{"prods"}[1];
2650				$text = $_[1];
2651				my $_savetext;
2652				@item = (q{strict_right});
2653				%item = (__RULE__ => q{strict_right});
2654				my $repcount = 0;
2655
2656
2657				Parse::RecDescent::_trace(q{Trying subrule: [varlist]},
2658				Parse::RecDescent::_tracefirst($text),
2659				q{strict_right},
2660				$tracelevel)
2661				if defined $::RD_TRACE;
2662				if (1) { no strict qw{refs};
2663				$expectation->is(q{})->at($text);
2664				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::varlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
2665				{
2666
2667				Parse::RecDescent::_trace(q{<>},
2668				Parse::RecDescent::_tracefirst($text),
2669				q{strict_right},
2670				$tracelevel)
2671				if defined $::RD_TRACE;
2672				$expectation->failed();
2673				last;
2674				}
2675				Parse::RecDescent::_trace(q{>>Matched subrule: [varlist]<< (return value: [}
2676				. $_tok . q{]},
2677
2678				Parse::RecDescent::_tracefirst($text),
2679				q{strict_right},
2680				$tracelevel)
2681				if defined $::RD_TRACE;
2682				$item{q{varlist}} = $_tok;
2683				push @item, $_tok;
2684
2685				}
2686
2687				Parse::RecDescent::_trace(q{Trying terminal: ['\\n']},
2688				Parse::RecDescent::_tracefirst($text),
2689				q{strict_right},
2690				$tracelevel)
2691				if defined $::RD_TRACE;
2692				$lastsep = "";
2693				$expectation->is(q{'\\n'})->at($text);
2694
2695
2696				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "\n"; 1 } and
2697				substr($text,0,length($_tok)) eq $_tok and
2698				do { substr($text,0,length($_tok)) = ""; 1; }
2699				)
2700				{
2701
2702				$expectation->failed();
2703				Parse::RecDescent::_trace(q{<>},
2704				Parse::RecDescent::_tracefirst($text))
2705				if defined $::RD_TRACE;
2706				last;
2707				}
2708				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2709				. $_tok . q{])},
2710				Parse::RecDescent::_tracefirst($text))
2711				if defined $::RD_TRACE;
2712				push @item, $item{__STRING1__}=$_tok;
2713
2714
2715				Parse::RecDescent::_trace(q{Trying action},
2716				Parse::RecDescent::_tracefirst($text),
2717				q{strict_right},
2718				$tracelevel)
2719				if defined $::RD_TRACE;
2720
2721
2722				$_tok = ($_noactions) ? 0 : do {$item[1]};
2723				unless (defined $_tok)
2724				{
2725				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2726				if defined $::RD_TRACE;
2727				last;
2728				}
2729				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2730				. $_tok . q{])},
2731				Parse::RecDescent::_tracefirst($text))
2732				if defined $::RD_TRACE;
2733				push @item, $_tok;
2734				$item{__ACTION1__}=$_tok;
2735
2736
2737
2738				Parse::RecDescent::_trace(q{>>Matched production: [varlist '\\n']<<},
2739				Parse::RecDescent::_tracefirst($text),
2740				q{strict_right},
2741				$tracelevel)
2742				if defined $::RD_TRACE;
2743				$_matched = 1;
2744				last;
2745				}
2746
2747
2748				unless ( $_matched \|\| defined($return) \|\| defined($score) )
2749				{
2750
2751
2752				$_[1] = $text; # NOT SURE THIS IS NEEDED
2753				Parse::RecDescent::_trace(q{<>},
2754				Parse::RecDescent::_tracefirst($_[1]),
2755				q{strict_right},
2756				$tracelevel)
2757				if defined $::RD_TRACE;
2758				return undef;
2759				}
2760				if (!defined($return) && defined($score))
2761				{
2762				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2763				q{strict_right},
2764				$tracelevel)
2765				if defined $::RD_TRACE;
2766				$return = $score_return;
2767				}
2768				splice @{$thisparser->{errors}}, $err_at;
2769				$return = $item[$#item] unless defined $return;
2770				if (defined $::RD_TRACE)
2771				{
2772				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2773				$return . q{])}, "",
2774				q{strict_right},
2775				$tracelevel);
2776				Parse::RecDescent::_trace(q{(consumed: [} .
2777				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2778				Parse::RecDescent::_tracefirst($text),
2779				, q{strict_right},
2780				$tracelevel)
2781				}
2782				$_[1] = $text;
2783				return $return;
2784				}
2785
2786				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2787				sub Parse::RecDescent::Config::Magic::Grammar::varname
2788				{
2789				my $thisparser = $_[0];
2790				use vars q{$tracelevel};
2791				local $tracelevel = ($tracelevel\|\|0)+1;
2792				$ERRORS = 0;
2793				my $thisrule = $thisparser->{"rules"}{"varname"};
2794
2795				Parse::RecDescent::_trace(q{Trying rule: [varname]},
2796				Parse::RecDescent::_tracefirst($_[1]),
2797				q{varname},
2798				$tracelevel)
2799				if defined $::RD_TRACE;
2800
2801
2802				my $err_at = @{$thisparser->{errors}};
2803
2804				my $score;
2805				my $score_return;
2806				my $_tok;
2807				my $return = undef;
2808				my $_matched=0;
2809				my $commit=0;
2810				my @item = ();
2811				my %item = ();
2812				my $repeating = defined($_[2]) && $_[2];
2813				my $_noactions = defined($_[3]) && $_[3];
2814				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2815				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2816				my $text;
2817				my $lastsep="";
2818				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2819				$expectation->at($_[1]);
2820
2821				my $thisline;
2822				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2823
2824
2825
2826				while (!$_matched && !$commit)
2827				{
2828
2829				Parse::RecDescent::_trace(q{Trying production: [/[^\\s]+?(?=[\\n\\\{\\\}\\[\\]\$\$=:<>]\|\\/>\|<\\/)/]},
2830				Parse::RecDescent::_tracefirst($_[1]),
2831				q{varname},
2832				$tracelevel)
2833				if defined $::RD_TRACE;
2834				my $thisprod = $thisrule->{"prods"}[0];
2835				$text = $_[1];
2836				my $_savetext;
2837				@item = (q{varname});
2838				%item = (__RULE__ => q{varname});
2839				my $repcount = 0;
2840
2841
2842				Parse::RecDescent::_trace(q{Trying terminal: [/[^\\s]+?(?=[\\n\\\{\\\}\\[\\]\$\$=:<>]\|\\/>\|<\\/)/]}, Parse::RecDescent::_tracefirst($text),
2843				q{varname},
2844				$tracelevel)
2845				if defined $::RD_TRACE;
2846				$lastsep = "";
2847				$expectation->is(q{})->at($text);
2848
2849
2850				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^\s]+?(?=[\n\{\}\[\]=:<>]\|\/>\|<\/))//)
2851				{
2852
2853				$expectation->failed();
2854				Parse::RecDescent::_trace(q{<>},
2855				Parse::RecDescent::_tracefirst($text))
2856				if defined $::RD_TRACE;
2857
2858				last;
2859				}
2860				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2861				. $& . q{])},
2862				Parse::RecDescent::_tracefirst($text))
2863				if defined $::RD_TRACE;
2864				push @item, $item{__PATTERN1__}=$&;
2865
2866
2867				Parse::RecDescent::_trace(q{Trying action},
2868				Parse::RecDescent::_tracefirst($text),
2869				q{varname},
2870				$tracelevel)
2871				if defined $::RD_TRACE;
2872
2873
2874				$_tok = ($_noactions) ? 0 : do {
2875				#Eliminate trailing spaces
2876				$item[1]=~s/([^\s])\s*$/$1/;
2877				undef;
2878				$item[1] if(length($item[1])>0);
2879				};
2880				unless (defined $_tok)
2881				{
2882				Parse::RecDescent::_trace(q{<> (return value: [undef])})
2883				if defined $::RD_TRACE;
2884				last;
2885				}
2886				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2887				. $_tok . q{])},
2888				Parse::RecDescent::_tracefirst($text))
2889				if defined $::RD_TRACE;
2890				push @item, $_tok;
2891				$item{__ACTION1__}=$_tok;
2892
2893
2894
2895				Parse::RecDescent::_trace(q{>>Matched production: [/[^\\s]+?(?=[\\n\\\{\\\}\\[\\]\$\$=:<>]\|\\/>\|<\\/)/]<<},
2896				Parse::RecDescent::_tracefirst($text),
2897				q{varname},
2898				$tracelevel)
2899				if defined $::RD_TRACE;
2900				$_matched = 1;
2901				last;
2902				}
2903
2904
2905				unless ( $_matched \|\| defined($return) \|\| defined($score) )
2906				{
2907
2908
2909				$_[1] = $text; # NOT SURE THIS IS NEEDED
2910				Parse::RecDescent::_trace(q{<>},
2911				Parse::RecDescent::_tracefirst($_[1]),
2912				q{varname},
2913				$tracelevel)
2914				if defined $::RD_TRACE;
2915				return undef;
2916				}
2917				if (!defined($return) && defined($score))
2918				{
2919				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2920				q{varname},
2921				$tracelevel)
2922				if defined $::RD_TRACE;
2923				$return = $score_return;
2924				}
2925				splice @{$thisparser->{errors}}, $err_at;
2926				$return = $item[$#item] unless defined $return;
2927				if (defined $::RD_TRACE)
2928				{
2929				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2930				$return . q{])}, "",
2931				q{varname},
2932				$tracelevel);
2933				Parse::RecDescent::_trace(q{(consumed: [} .
2934				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2935				Parse::RecDescent::_tracefirst($text),
2936				, q{varname},
2937				$tracelevel)
2938				}
2939				$_[1] = $text;
2940				return $return;
2941				}
2942
2943				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2944				sub Parse::RecDescent::Config::Magic::Grammar::varlist
2945				{
2946				my $thisparser = $_[0];
2947				use vars q{$tracelevel};
2948				local $tracelevel = ($tracelevel\|\|0)+1;
2949				$ERRORS = 0;
2950				my $thisrule = $thisparser->{"rules"}{"varlist"};
2951
2952				Parse::RecDescent::_trace(q{Trying rule: [varlist]},
2953				Parse::RecDescent::_tracefirst($_[1]),
2954				q{varlist},
2955				$tracelevel)
2956				if defined $::RD_TRACE;
2957
2958
2959				my $err_at = @{$thisparser->{errors}};
2960
2961				my $score;
2962				my $score_return;
2963				my $_tok;
2964				my $return = undef;
2965				my $_matched=0;
2966				my $commit=0;
2967				my @item = ();
2968				my %item = ();
2969				my $repeating = defined($_[2]) && $_[2];
2970				my $_noactions = defined($_[3]) && $_[3];
2971				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
2972				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2973				my $text;
2974				my $lastsep="";
2975				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2976				$expectation->at($_[1]);
2977
2978				my $thisline;
2979				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2980
2981
2982
2983				while (!$_matched && !$commit)
2984				{
2985
2986				Parse::RecDescent::_trace(q{Trying production: [svar]},
2987				Parse::RecDescent::_tracefirst($_[1]),
2988				q{varlist},
2989				$tracelevel)
2990				if defined $::RD_TRACE;
2991				my $thisprod = $thisrule->{"prods"}[0];
2992				$text = $_[1];
2993				my $_savetext;
2994				@item = (q{varlist});
2995				%item = (__RULE__ => q{varlist});
2996				my $repcount = 0;
2997
2998
2999				Parse::RecDescent::_trace(q{Trying repeated subrule: [svar]},
3000				Parse::RecDescent::_tracefirst($text),
3001				q{varlist},
3002				$tracelevel)
3003				if defined $::RD_TRACE;
3004				$expectation->is(q{})->at($text);
3005
3006				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::svar, 1, 100000000, $_noactions,$expectation,undef)))
3007				{
3008				Parse::RecDescent::_trace(q{<>},
3009				Parse::RecDescent::_tracefirst($text),
3010				q{varlist},
3011				$tracelevel)
3012				if defined $::RD_TRACE;
3013				last;
3014				}
3015				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [svar]<< (}
3016				. @$_tok . q{ times)},
3017
3018				Parse::RecDescent::_tracefirst($text),
3019				q{varlist},
3020				$tracelevel)
3021				if defined $::RD_TRACE;
3022				$item{q{svar(s)}} = $_tok;
3023				push @item, $_tok;
3024
3025
3026
3027				Parse::RecDescent::_trace(q{Trying action},
3028				Parse::RecDescent::_tracefirst($text),
3029				q{varlist},
3030				$tracelevel)
3031				if defined $::RD_TRACE;
3032
3033
3034				$_tok = ($_noactions) ? 0 : do {
3035				if(@{$item[1]}==1) { $item[1]->[0] ; }
3036				else {$item[1]};
3037				#print (@item);
3038				#if(scalar($item[2]) && scalar(@{$item[2]->[0]})) { unshift(@{$item[2]->[0]},$item[1]); $item[2]->[0];}
3039				#else {$item[1];};
3040				};
3041				unless (defined $_tok)
3042				{
3043				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3044				if defined $::RD_TRACE;
3045				last;
3046				}
3047				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3048				. $_tok . q{])},
3049				Parse::RecDescent::_tracefirst($text))
3050				if defined $::RD_TRACE;
3051				push @item, $_tok;
3052				$item{__ACTION1__}=$_tok;
3053
3054
3055
3056				Parse::RecDescent::_trace(q{>>Matched production: [svar]<<},
3057				Parse::RecDescent::_tracefirst($text),
3058				q{varlist},
3059				$tracelevel)
3060				if defined $::RD_TRACE;
3061				$_matched = 1;
3062				last;
3063				}
3064
3065
3066				unless ( $_matched \|\| defined($return) \|\| defined($score) )
3067				{
3068
3069
3070				$_[1] = $text; # NOT SURE THIS IS NEEDED
3071				Parse::RecDescent::_trace(q{<>},
3072				Parse::RecDescent::_tracefirst($_[1]),
3073				q{varlist},
3074				$tracelevel)
3075				if defined $::RD_TRACE;
3076				return undef;
3077				}
3078				if (!defined($return) && defined($score))
3079				{
3080				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3081				q{varlist},
3082				$tracelevel)
3083				if defined $::RD_TRACE;
3084				$return = $score_return;
3085				}
3086				splice @{$thisparser->{errors}}, $err_at;
3087				$return = $item[$#item] unless defined $return;
3088				if (defined $::RD_TRACE)
3089				{
3090				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3091				$return . q{])}, "",
3092				q{varlist},
3093				$tracelevel);
3094				Parse::RecDescent::_trace(q{(consumed: [} .
3095				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3096				Parse::RecDescent::_tracefirst($text),
3097				, q{varlist},
3098				$tracelevel)
3099				}
3100				$_[1] = $text;
3101				return $return;
3102				}
3103
3104				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3105				sub Parse::RecDescent::Config::Magic::Grammar::ini_name
3106				{
3107				my $thisparser = $_[0];
3108				use vars q{$tracelevel};
3109				local $tracelevel = ($tracelevel\|\|0)+1;
3110				$ERRORS = 0;
3111				my $thisrule = $thisparser->{"rules"}{"ini_name"};
3112
3113				Parse::RecDescent::_trace(q{Trying rule: [ini_name]},
3114				Parse::RecDescent::_tracefirst($_[1]),
3115				q{ini_name},
3116				$tracelevel)
3117				if defined $::RD_TRACE;
3118
3119
3120				my $err_at = @{$thisparser->{errors}};
3121
3122				my $score;
3123				my $score_return;
3124				my $_tok;
3125				my $return = undef;
3126				my $_matched=0;
3127				my $commit=0;
3128				my @item = ();
3129				my %item = ();
3130				my $repeating = defined($_[2]) && $_[2];
3131				my $_noactions = defined($_[3]) && $_[3];
3132				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3133				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3134				my $text;
3135				my $lastsep="";
3136				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3137				$expectation->at($_[1]);
3138
3139				my $thisline;
3140				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3141
3142
3143
3144				while (!$_matched && !$commit)
3145				{
3146
3147				Parse::RecDescent::_trace(q{Trying production: [/\\[([^\\n#]*)\\]/]},
3148				Parse::RecDescent::_tracefirst($_[1]),
3149				q{ini_name},
3150				$tracelevel)
3151				if defined $::RD_TRACE;
3152				my $thisprod = $thisrule->{"prods"}[0];
3153				$text = $_[1];
3154				my $_savetext;
3155				@item = (q{ini_name});
3156				%item = (__RULE__ => q{ini_name});
3157				my $repcount = 0;
3158
3159
3160				Parse::RecDescent::_trace(q{Trying terminal: [/\\[([^\\n#]*)\\]/]}, Parse::RecDescent::_tracefirst($text),
3161				q{ini_name},
3162				$tracelevel)
3163				if defined $::RD_TRACE;
3164				$lastsep = "";
3165				$expectation->is(q{})->at($text);
3166
3167
3168				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\[([^\n#]*)\])//)
3169				{
3170
3171				$expectation->failed();
3172				Parse::RecDescent::_trace(q{<>},
3173				Parse::RecDescent::_tracefirst($text))
3174				if defined $::RD_TRACE;
3175
3176				last;
3177				}
3178				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3179				. $& . q{])},
3180				Parse::RecDescent::_tracefirst($text))
3181				if defined $::RD_TRACE;
3182				push @item, $item{__PATTERN1__}=$&;
3183
3184
3185				Parse::RecDescent::_trace(q{Trying action},
3186				Parse::RecDescent::_tracefirst($text),
3187				q{ini_name},
3188				$tracelevel)
3189				if defined $::RD_TRACE;
3190
3191
3192				$_tok = ($_noactions) ? 0 : do {$1};
3193				unless (defined $_tok)
3194				{
3195				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3196				if defined $::RD_TRACE;
3197				last;
3198				}
3199				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3200				. $_tok . q{])},
3201				Parse::RecDescent::_tracefirst($text))
3202				if defined $::RD_TRACE;
3203				push @item, $_tok;
3204				$item{__ACTION1__}=$_tok;
3205
3206
3207
3208				Parse::RecDescent::_trace(q{>>Matched production: [/\\[([^\\n#]*)\\]/]<<},
3209				Parse::RecDescent::_tracefirst($text),
3210				q{ini_name},
3211				$tracelevel)
3212				if defined $::RD_TRACE;
3213				$_matched = 1;
3214				last;
3215				}
3216
3217
3218				unless ( $_matched \|\| defined($return) \|\| defined($score) )
3219				{
3220
3221
3222				$_[1] = $text; # NOT SURE THIS IS NEEDED
3223				Parse::RecDescent::_trace(q{<>},
3224				Parse::RecDescent::_tracefirst($_[1]),
3225				q{ini_name},
3226				$tracelevel)
3227				if defined $::RD_TRACE;
3228				return undef;
3229				}
3230				if (!defined($return) && defined($score))
3231				{
3232				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3233				q{ini_name},
3234				$tracelevel)
3235				if defined $::RD_TRACE;
3236				$return = $score_return;
3237				}
3238				splice @{$thisparser->{errors}}, $err_at;
3239				$return = $item[$#item] unless defined $return;
3240				if (defined $::RD_TRACE)
3241				{
3242				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3243				$return . q{])}, "",
3244				q{ini_name},
3245				$tracelevel);
3246				Parse::RecDescent::_trace(q{(consumed: [} .
3247				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3248				Parse::RecDescent::_tracefirst($text),
3249				, q{ini_name},
3250				$tracelevel)
3251				}
3252				$_[1] = $text;
3253				return $return;
3254				}
3255
3256				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3257				sub Parse::RecDescent::Config::Magic::Grammar::csvlist
3258				{
3259				my $thisparser = $_[0];
3260				use vars q{$tracelevel};
3261				local $tracelevel = ($tracelevel\|\|0)+1;
3262				$ERRORS = 0;
3263				my $thisrule = $thisparser->{"rules"}{"csvlist"};
3264
3265				Parse::RecDescent::_trace(q{Trying rule: [csvlist]},
3266				Parse::RecDescent::_tracefirst($_[1]),
3267				q{csvlist},
3268				$tracelevel)
3269				if defined $::RD_TRACE;
3270
3271
3272				my $err_at = @{$thisparser->{errors}};
3273
3274				my $score;
3275				my $score_return;
3276				my $_tok;
3277				my $return = undef;
3278				my $_matched=0;
3279				my $commit=0;
3280				my @item = ();
3281				my %item = ();
3282				my $repeating = defined($_[2]) && $_[2];
3283				my $_noactions = defined($_[3]) && $_[3];
3284				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3285				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3286				my $text;
3287				my $lastsep="";
3288				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3289				$expectation->at($_[1]);
3290
3291				my $thisline;
3292				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3293
3294
3295
3296				while (!$_matched && !$commit)
3297				{
3298				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
3299				Parse::RecDescent::_trace(q{Trying production: [csv /([^\\n#]*?)\\n/]},
3300				Parse::RecDescent::_tracefirst($_[1]),
3301				q{csvlist},
3302				$tracelevel)
3303				if defined $::RD_TRACE;
3304				my $thisprod = $thisrule->{"prods"}[0];
3305				$text = $_[1];
3306				my $_savetext;
3307				@item = (q{csvlist});
3308				%item = (__RULE__ => q{csvlist});
3309				my $repcount = 0;
3310
3311
3312				Parse::RecDescent::_trace(q{Trying repeated subrule: [csv]},
3313				Parse::RecDescent::_tracefirst($text),
3314				q{csvlist},
3315				$tracelevel)
3316				if defined $::RD_TRACE;
3317				$expectation->is(q{})->at($text);
3318
3319				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::csv, 1, 100000000, $_noactions,$expectation,undef)))
3320				{
3321				Parse::RecDescent::_trace(q{<>},
3322				Parse::RecDescent::_tracefirst($text),
3323				q{csvlist},
3324				$tracelevel)
3325				if defined $::RD_TRACE;
3326				last;
3327				}
3328				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [csv]<< (}
3329				. @$_tok . q{ times)},
3330
3331				Parse::RecDescent::_tracefirst($text),
3332				q{csvlist},
3333				$tracelevel)
3334				if defined $::RD_TRACE;
3335				$item{q{csv(s)}} = $_tok;
3336				push @item, $_tok;
3337
3338
3339
3340
3341
3342				Parse::RecDescent::_trace(q{Trying directive: []},
3343				Parse::RecDescent::_tracefirst($text),
3344				q{csvlist},
3345				$tracelevel)
3346				if defined $::RD_TRACE;
3347				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline ; $oldskip };
3348				if (defined($_tok))
3349				{
3350				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
3351				. $_tok . q{])},
3352				Parse::RecDescent::_tracefirst($text))
3353				if defined $::RD_TRACE;
3354				}
3355				else
3356				{
3357				Parse::RecDescent::_trace(q{<>},
3358				Parse::RecDescent::_tracefirst($text))
3359				if defined $::RD_TRACE;
3360				}
3361
3362				last unless defined $_tok;
3363				push @item, $item{__DIRECTIVE1__}=$_tok;
3364
3365
3366				Parse::RecDescent::_trace(q{Trying terminal: [/([^\\n#]*?)\\n/]}, Parse::RecDescent::_tracefirst($text),
3367				q{csvlist},
3368				$tracelevel)
3369				if defined $::RD_TRACE;
3370				$lastsep = "";
3371				$expectation->is(q{/([^\\n#]*?)\\n/})->at($text);
3372
3373
3374				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:([^\n#]*?)\n)//)
3375				{
3376
3377				$expectation->failed();
3378				Parse::RecDescent::_trace(q{<>},
3379				Parse::RecDescent::_tracefirst($text))
3380				if defined $::RD_TRACE;
3381
3382				last;
3383				}
3384				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3385				. $& . q{])},
3386				Parse::RecDescent::_tracefirst($text))
3387				if defined $::RD_TRACE;
3388				push @item, $item{__PATTERN1__}=$&;
3389
3390
3391				Parse::RecDescent::_trace(q{Trying action},
3392				Parse::RecDescent::_tracefirst($text),
3393				q{csvlist},
3394				$tracelevel)
3395				if defined $::RD_TRACE;
3396
3397
3398				$_tok = ($_noactions) ? 0 : do { [@{$item[1]},$1]; };
3399				unless (defined $_tok)
3400				{
3401				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3402				if defined $::RD_TRACE;
3403				last;
3404				}
3405				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3406				. $_tok . q{])},
3407				Parse::RecDescent::_tracefirst($text))
3408				if defined $::RD_TRACE;
3409				push @item, $_tok;
3410				$item{__ACTION1__}=$_tok;
3411
3412
3413
3414				Parse::RecDescent::_trace(q{>>Matched production: [csv /([^\\n#]*?)\\n/]<<},
3415				Parse::RecDescent::_tracefirst($text),
3416				q{csvlist},
3417				$tracelevel)
3418				if defined $::RD_TRACE;
3419				$_matched = 1;
3420				last;
3421				}
3422
3423
3424				unless ( $_matched \|\| defined($return) \|\| defined($score) )
3425				{
3426
3427
3428				$_[1] = $text; # NOT SURE THIS IS NEEDED
3429				Parse::RecDescent::_trace(q{<>},
3430				Parse::RecDescent::_tracefirst($_[1]),
3431				q{csvlist},
3432				$tracelevel)
3433				if defined $::RD_TRACE;
3434				return undef;
3435				}
3436				if (!defined($return) && defined($score))
3437				{
3438				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3439				q{csvlist},
3440				$tracelevel)
3441				if defined $::RD_TRACE;
3442				$return = $score_return;
3443				}
3444				splice @{$thisparser->{errors}}, $err_at;
3445				$return = $item[$#item] unless defined $return;
3446				if (defined $::RD_TRACE)
3447				{
3448				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3449				$return . q{])}, "",
3450				q{csvlist},
3451				$tracelevel);
3452				Parse::RecDescent::_trace(q{(consumed: [} .
3453				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3454				Parse::RecDescent::_tracefirst($text),
3455				, q{csvlist},
3456				$tracelevel)
3457				}
3458				$_[1] = $text;
3459				return $return;
3460				}
3461
3462				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3463				sub Parse::RecDescent::Config::Magic::Grammar::tsv
3464				{
3465				my $thisparser = $_[0];
3466				use vars q{$tracelevel};
3467				local $tracelevel = ($tracelevel\|\|0)+1;
3468				$ERRORS = 0;
3469				my $thisrule = $thisparser->{"rules"}{"tsv"};
3470
3471				Parse::RecDescent::_trace(q{Trying rule: [tsv]},
3472				Parse::RecDescent::_tracefirst($_[1]),
3473				q{tsv},
3474				$tracelevel)
3475				if defined $::RD_TRACE;
3476
3477
3478				my $err_at = @{$thisparser->{errors}};
3479
3480				my $score;
3481				my $score_return;
3482				my $_tok;
3483				my $return = undef;
3484				my $_matched=0;
3485				my $commit=0;
3486				my @item = ();
3487				my %item = ();
3488				my $repeating = defined($_[2]) && $_[2];
3489				my $_noactions = defined($_[3]) && $_[3];
3490				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3491				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3492				my $text;
3493				my $lastsep="";
3494				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3495				$expectation->at($_[1]);
3496
3497				my $thisline;
3498				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3499
3500
3501
3502				while (!$_matched && !$commit)
3503				{
3504
3505				Parse::RecDescent::_trace(q{Trying production: [/([^\\n#]*?)\\t/]},
3506				Parse::RecDescent::_tracefirst($_[1]),
3507				q{tsv},
3508				$tracelevel)
3509				if defined $::RD_TRACE;
3510				my $thisprod = $thisrule->{"prods"}[0];
3511				$text = $_[1];
3512				my $_savetext;
3513				@item = (q{tsv});
3514				%item = (__RULE__ => q{tsv});
3515				my $repcount = 0;
3516
3517
3518				Parse::RecDescent::_trace(q{Trying terminal: [/([^\\n#]*?)\\t/]}, Parse::RecDescent::_tracefirst($text),
3519				q{tsv},
3520				$tracelevel)
3521				if defined $::RD_TRACE;
3522				$lastsep = "";
3523				$expectation->is(q{})->at($text);
3524
3525
3526				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:([^\n#]*?)\t)//)
3527				{
3528
3529				$expectation->failed();
3530				Parse::RecDescent::_trace(q{<>},
3531				Parse::RecDescent::_tracefirst($text))
3532				if defined $::RD_TRACE;
3533
3534				last;
3535				}
3536				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3537				. $& . q{])},
3538				Parse::RecDescent::_tracefirst($text))
3539				if defined $::RD_TRACE;
3540				push @item, $item{__PATTERN1__}=$&;
3541
3542
3543				Parse::RecDescent::_trace(q{Trying action},
3544				Parse::RecDescent::_tracefirst($text),
3545				q{tsv},
3546				$tracelevel)
3547				if defined $::RD_TRACE;
3548
3549
3550				$_tok = ($_noactions) ? 0 : do {$1;};
3551				unless (defined $_tok)
3552				{
3553				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3554				if defined $::RD_TRACE;
3555				last;
3556				}
3557				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3558				. $_tok . q{])},
3559				Parse::RecDescent::_tracefirst($text))
3560				if defined $::RD_TRACE;
3561				push @item, $_tok;
3562				$item{__ACTION1__}=$_tok;
3563
3564
3565
3566				Parse::RecDescent::_trace(q{>>Matched production: [/([^\\n#]*?)\\t/]<<},
3567				Parse::RecDescent::_tracefirst($text),
3568				q{tsv},
3569				$tracelevel)
3570				if defined $::RD_TRACE;
3571				$_matched = 1;
3572				last;
3573				}
3574
3575
3576				unless ( $_matched \|\| defined($return) \|\| defined($score) )
3577				{
3578
3579
3580				$_[1] = $text; # NOT SURE THIS IS NEEDED
3581				Parse::RecDescent::_trace(q{<>},
3582				Parse::RecDescent::_tracefirst($_[1]),
3583				q{tsv},
3584				$tracelevel)
3585				if defined $::RD_TRACE;
3586				return undef;
3587				}
3588				if (!defined($return) && defined($score))
3589				{
3590				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3591				q{tsv},
3592				$tracelevel)
3593				if defined $::RD_TRACE;
3594				$return = $score_return;
3595				}
3596				splice @{$thisparser->{errors}}, $err_at;
3597				$return = $item[$#item] unless defined $return;
3598				if (defined $::RD_TRACE)
3599				{
3600				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3601				$return . q{])}, "",
3602				q{tsv},
3603				$tracelevel);
3604				Parse::RecDescent::_trace(q{(consumed: [} .
3605				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3606				Parse::RecDescent::_tracefirst($text),
3607				, q{tsv},
3608				$tracelevel)
3609				}
3610				$_[1] = $text;
3611				return $return;
3612				}
3613
3614				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3615				sub Parse::RecDescent::Config::Magic::Grammar::single
3616				{
3617				my $thisparser = $_[0];
3618				use vars q{$tracelevel};
3619				local $tracelevel = ($tracelevel\|\|0)+1;
3620				$ERRORS = 0;
3621				my $thisrule = $thisparser->{"rules"}{"single"};
3622
3623				Parse::RecDescent::_trace(q{Trying rule: [single]},
3624				Parse::RecDescent::_tracefirst($_[1]),
3625				q{single},
3626				$tracelevel)
3627				if defined $::RD_TRACE;
3628
3629
3630				my $err_at = @{$thisparser->{errors}};
3631
3632				my $score;
3633				my $score_return;
3634				my $_tok;
3635				my $return = undef;
3636				my $_matched=0;
3637				my $commit=0;
3638				my @item = ();
3639				my %item = ();
3640				my $repeating = defined($_[2]) && $_[2];
3641				my $_noactions = defined($_[3]) && $_[3];
3642				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3643				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3644				my $text;
3645				my $lastsep="";
3646				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3647				$expectation->at($_[1]);
3648
3649				my $thisline;
3650				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3651
3652
3653
3654				while (!$_matched && !$commit)
3655				{
3656
3657				Parse::RecDescent::_trace(q{Trying production: [/\\s(.?)(?=[\\n\\\{\\\}\\[\\]\$\$=:<>\\s]\|\\/>\|<\\/\|$)/]},
3658				Parse::RecDescent::_tracefirst($_[1]),
3659				q{single},
3660				$tracelevel)
3661				if defined $::RD_TRACE;
3662				my $thisprod = $thisrule->{"prods"}[0];
3663				$text = $_[1];
3664				my $_savetext;
3665				@item = (q{single});
3666				%item = (__RULE__ => q{single});
3667				my $repcount = 0;
3668
3669
3670				Parse::RecDescent::_trace(q{Trying terminal: [/\\s(.?)(?=[\\n\\\{\\\}\\[\\]\$\$=:<>\\s]\|\\/>\|<\\/\|$)/]}, Parse::RecDescent::_tracefirst($text),
3671				q{single},
3672				$tracelevel)
3673				if defined $::RD_TRACE;
3674				$lastsep = "";
3675				$expectation->is(q{})->at($text);
3676
3677
3678				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\s(.?)(?=[\n\{\}\[\]=:<>\s]\|\/>\|<\/\|$))//)
3679				{
3680
3681				$expectation->failed();
3682				Parse::RecDescent::_trace(q{<>},
3683				Parse::RecDescent::_tracefirst($text))
3684				if defined $::RD_TRACE;
3685
3686				last;
3687				}
3688				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3689				. $& . q{])},
3690				Parse::RecDescent::_tracefirst($text))
3691				if defined $::RD_TRACE;
3692				push @item, $item{__PATTERN1__}=$&;
3693
3694
3695				Parse::RecDescent::_trace(q{Trying action},
3696				Parse::RecDescent::_tracefirst($text),
3697				q{single},
3698				$tracelevel)
3699				if defined $::RD_TRACE;
3700
3701
3702				$_tok = ($_noactions) ? 0 : do { $1 if(length($1)>0); #This has been deprecated (too slow). Only using svar now.
3703				};
3704				unless (defined $_tok)
3705				{
3706				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3707				if defined $::RD_TRACE;
3708				last;
3709				}
3710				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3711				. $_tok . q{])},
3712				Parse::RecDescent::_tracefirst($text))
3713				if defined $::RD_TRACE;
3714				push @item, $_tok;
3715				$item{__ACTION1__}=$_tok;
3716
3717
3718
3719				Parse::RecDescent::_trace(q{>>Matched production: [/\\s(.?)(?=[\\n\\\{\\\}\\[\\]\$\$=:<>\\s]\|\\/>\|<\\/\|$)/]<<},
3720				Parse::RecDescent::_tracefirst($text),
3721				q{single},
3722				$tracelevel)
3723				if defined $::RD_TRACE;
3724				$_matched = 1;
3725				last;
3726				}
3727
3728
3729				unless ( $_matched \|\| defined($return) \|\| defined($score) )
3730				{
3731
3732
3733				$_[1] = $text; # NOT SURE THIS IS NEEDED
3734				Parse::RecDescent::_trace(q{<>},
3735				Parse::RecDescent::_tracefirst($_[1]),
3736				q{single},
3737				$tracelevel)
3738				if defined $::RD_TRACE;
3739				return undef;
3740				}
3741				if (!defined($return) && defined($score))
3742				{
3743				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3744				q{single},
3745				$tracelevel)
3746				if defined $::RD_TRACE;
3747				$return = $score_return;
3748				}
3749				splice @{$thisparser->{errors}}, $err_at;
3750				$return = $item[$#item] unless defined $return;
3751				if (defined $::RD_TRACE)
3752				{
3753				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3754				$return . q{])}, "",
3755				q{single},
3756				$tracelevel);
3757				Parse::RecDescent::_trace(q{(consumed: [} .
3758				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3759				Parse::RecDescent::_tracefirst($text),
3760				, q{single},
3761				$tracelevel)
3762				}
3763				$_[1] = $text;
3764				return $return;
3765				}
3766
3767				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3768				sub Parse::RecDescent::Config::Magic::Grammar::svar
3769				{
3770				my $thisparser = $_[0];
3771				use vars q{$tracelevel};
3772				local $tracelevel = ($tracelevel\|\|0)+1;
3773				$ERRORS = 0;
3774				my $thisrule = $thisparser->{"rules"}{"svar"};
3775
3776				Parse::RecDescent::_trace(q{Trying rule: [svar]},
3777				Parse::RecDescent::_tracefirst($_[1]),
3778				q{svar},
3779				$tracelevel)
3780				if defined $::RD_TRACE;
3781
3782
3783				my $err_at = @{$thisparser->{errors}};
3784
3785				my $score;
3786				my $score_return;
3787				my $_tok;
3788				my $return = undef;
3789				my $_matched=0;
3790				my $commit=0;
3791				my @item = ();
3792				my %item = ();
3793				my $repeating = defined($_[2]) && $_[2];
3794				my $_noactions = defined($_[3]) && $_[3];
3795				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
3796				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3797				my $text;
3798				my $lastsep="";
3799				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3800				$expectation->at($_[1]);
3801
3802				my $thisline;
3803				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3804
3805
3806
3807				while (!$_matched && !$commit)
3808				{
3809
3810				Parse::RecDescent::_trace(q{Trying production: [/\\'(.+?)\\'/sm]},
3811				Parse::RecDescent::_tracefirst($_[1]),
3812				q{svar},
3813				$tracelevel)
3814				if defined $::RD_TRACE;
3815				my $thisprod = $thisrule->{"prods"}[0];
3816				$text = $_[1];
3817				my $_savetext;
3818				@item = (q{svar});
3819				%item = (__RULE__ => q{svar});
3820				my $repcount = 0;
3821
3822
3823				Parse::RecDescent::_trace(q{Trying terminal: [/\\'(.+?)\\'/sm]}, Parse::RecDescent::_tracefirst($text),
3824				q{svar},
3825				$tracelevel)
3826				if defined $::RD_TRACE;
3827				$lastsep = "";
3828				$expectation->is(q{})->at($text);
3829
3830
3831				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\'(.+?)\')//sm)
3832				{
3833
3834				$expectation->failed();
3835				Parse::RecDescent::_trace(q{<>},
3836				Parse::RecDescent::_tracefirst($text))
3837				if defined $::RD_TRACE;
3838
3839				last;
3840				}
3841				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3842				. $& . q{])},
3843				Parse::RecDescent::_tracefirst($text))
3844				if defined $::RD_TRACE;
3845				push @item, $item{__PATTERN1__}=$&;
3846
3847
3848				Parse::RecDescent::_trace(q{Trying action},
3849				Parse::RecDescent::_tracefirst($text),
3850				q{svar},
3851				$tracelevel)
3852				if defined $::RD_TRACE;
3853
3854
3855				$_tok = ($_noactions) ? 0 : do {$1;};
3856				unless (defined $_tok)
3857				{
3858				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3859				if defined $::RD_TRACE;
3860				last;
3861				}
3862				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3863				. $_tok . q{])},
3864				Parse::RecDescent::_tracefirst($text))
3865				if defined $::RD_TRACE;
3866				push @item, $_tok;
3867				$item{__ACTION1__}=$_tok;
3868
3869
3870
3871				Parse::RecDescent::_trace(q{>>Matched production: [/\\'(.+?)\\'/sm]<<},
3872				Parse::RecDescent::_tracefirst($text),
3873				q{svar},
3874				$tracelevel)
3875				if defined $::RD_TRACE;
3876				$_matched = 1;
3877				last;
3878				}
3879
3880
3881				while (!$_matched && !$commit)
3882				{
3883
3884				Parse::RecDescent::_trace(q{Trying production: [/\\"(.+?)"/sm]},
3885				Parse::RecDescent::_tracefirst($_[1]),
3886				q{svar},
3887				$tracelevel)
3888				if defined $::RD_TRACE;
3889				my $thisprod = $thisrule->{"prods"}[1];
3890				$text = $_[1];
3891				my $_savetext;
3892				@item = (q{svar});
3893				%item = (__RULE__ => q{svar});
3894				my $repcount = 0;
3895
3896
3897				Parse::RecDescent::_trace(q{Trying terminal: [/\\"(.+?)"/sm]}, Parse::RecDescent::_tracefirst($text),
3898				q{svar},
3899				$tracelevel)
3900				if defined $::RD_TRACE;
3901				$lastsep = "";
3902				$expectation->is(q{})->at($text);
3903
3904
3905				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\"(.+?)")//sm)
3906				{
3907
3908				$expectation->failed();
3909				Parse::RecDescent::_trace(q{<>},
3910				Parse::RecDescent::_tracefirst($text))
3911				if defined $::RD_TRACE;
3912
3913				last;
3914				}
3915				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3916				. $& . q{])},
3917				Parse::RecDescent::_tracefirst($text))
3918				if defined $::RD_TRACE;
3919				push @item, $item{__PATTERN1__}=$&;
3920
3921
3922				Parse::RecDescent::_trace(q{Trying action},
3923				Parse::RecDescent::_tracefirst($text),
3924				q{svar},
3925				$tracelevel)
3926				if defined $::RD_TRACE;
3927
3928
3929				$_tok = ($_noactions) ? 0 : do {$1;};
3930				unless (defined $_tok)
3931				{
3932				Parse::RecDescent::_trace(q{<> (return value: [undef])})
3933				if defined $::RD_TRACE;
3934				last;
3935				}
3936				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3937				. $_tok . q{])},
3938				Parse::RecDescent::_tracefirst($text))
3939				if defined $::RD_TRACE;
3940				push @item, $_tok;
3941				$item{__ACTION1__}=$_tok;
3942
3943
3944
3945				Parse::RecDescent::_trace(q{>>Matched production: [/\\"(.+?)"/sm]<<},
3946				Parse::RecDescent::_tracefirst($text),
3947				q{svar},
3948				$tracelevel)
3949				if defined $::RD_TRACE;
3950				$_matched = 1;
3951				last;
3952				}
3953
3954
3955				while (!$_matched && !$commit)
3956				{
3957
3958				Parse::RecDescent::_trace(q{Trying production: [/((?:(?:\\/[^>\\/])\|(?:[^\\\{\\\}\\[\\]\$\$=:<>\\/\\\\,#;\\s]))+)/]},
3959				Parse::RecDescent::_tracefirst($_[1]),
3960				q{svar},
3961				$tracelevel)
3962				if defined $::RD_TRACE;
3963				my $thisprod = $thisrule->{"prods"}[2];
3964				$text = $_[1];
3965				my $_savetext;
3966				@item = (q{svar});
3967				%item = (__RULE__ => q{svar});
3968				my $repcount = 0;
3969
3970
3971				Parse::RecDescent::_trace(q{Trying terminal: [/((?:(?:\\/[^>\\/])\|(?:[^\\\{\\\}\\[\\]\$\$=:<>\\/\\\\,#;\\s]))+)/]}, Parse::RecDescent::_tracefirst($text),
3972				q{svar},
3973				$tracelevel)
3974				if defined $::RD_TRACE;
3975				$lastsep = "";
3976				$expectation->is(q{})->at($text);
3977
3978
3979				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:((?:(?:\/[^>\/])\|(?:[^\{\}\[\]=:<>\/\\,#;\s]))+))//)
3980				{
3981
3982				$expectation->failed();
3983				Parse::RecDescent::_trace(q{<>},
3984				Parse::RecDescent::_tracefirst($text))
3985				if defined $::RD_TRACE;
3986
3987				last;
3988				}
3989				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3990				. $& . q{])},
3991				Parse::RecDescent::_tracefirst($text))
3992				if defined $::RD_TRACE;
3993				push @item, $item{__PATTERN1__}=$&;
3994
3995
3996				Parse::RecDescent::_trace(q{Trying action},
3997				Parse::RecDescent::_tracefirst($text),
3998				q{svar},
3999				$tracelevel)
4000				if defined $::RD_TRACE;
4001
4002
4003				$_tok = ($_noactions) ? 0 : do {
4004				$1; #Old pattern: (?=[\n\{\}\[\]=:<>\s]\|\/>\|<\/\|$)
4005				#New pattern is more strict. No reserved characters allowed at all, and no spaces.
4006				};
4007				unless (defined $_tok)
4008				{
4009				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4010				if defined $::RD_TRACE;
4011				last;
4012				}
4013				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4014				. $_tok . q{])},
4015				Parse::RecDescent::_tracefirst($text))
4016				if defined $::RD_TRACE;
4017				push @item, $_tok;
4018				$item{__ACTION1__}=$_tok;
4019
4020
4021
4022				Parse::RecDescent::_trace(q{>>Matched production: [/((?:(?:\\/[^>\\/])\|(?:[^\\\{\\\}\\[\\]\$\$=:<>\\/\\\\,#;\\s]))+)/]<<},
4023				Parse::RecDescent::_tracefirst($text),
4024				q{svar},
4025				$tracelevel)
4026				if defined $::RD_TRACE;
4027				$_matched = 1;
4028				last;
4029				}
4030
4031
4032				unless ( $_matched \|\| defined($return) \|\| defined($score) )
4033				{
4034
4035
4036				$_[1] = $text; # NOT SURE THIS IS NEEDED
4037				Parse::RecDescent::_trace(q{<>},
4038				Parse::RecDescent::_tracefirst($_[1]),
4039				q{svar},
4040				$tracelevel)
4041				if defined $::RD_TRACE;
4042				return undef;
4043				}
4044				if (!defined($return) && defined($score))
4045				{
4046				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4047				q{svar},
4048				$tracelevel)
4049				if defined $::RD_TRACE;
4050				$return = $score_return;
4051				}
4052				splice @{$thisparser->{errors}}, $err_at;
4053				$return = $item[$#item] unless defined $return;
4054				if (defined $::RD_TRACE)
4055				{
4056				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4057				$return . q{])}, "",
4058				q{svar},
4059				$tracelevel);
4060				Parse::RecDescent::_trace(q{(consumed: [} .
4061				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4062				Parse::RecDescent::_tracefirst($text),
4063				, q{svar},
4064				$tracelevel)
4065				}
4066				$_[1] = $text;
4067				return $return;
4068				}
4069
4070				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4071				sub Parse::RecDescent::Config::Magic::Grammar::right
4072				{
4073				my $thisparser = $_[0];
4074				use vars q{$tracelevel};
4075				local $tracelevel = ($tracelevel\|\|0)+1;
4076				$ERRORS = 0;
4077				my $thisrule = $thisparser->{"rules"}{"right"};
4078
4079				Parse::RecDescent::_trace(q{Trying rule: [right]},
4080				Parse::RecDescent::_tracefirst($_[1]),
4081				q{right},
4082				$tracelevel)
4083				if defined $::RD_TRACE;
4084
4085
4086				my $err_at = @{$thisparser->{errors}};
4087
4088				my $score;
4089				my $score_return;
4090				my $_tok;
4091				my $return = undef;
4092				my $_matched=0;
4093				my $commit=0;
4094				my @item = ();
4095				my %item = ();
4096				my $repeating = defined($_[2]) && $_[2];
4097				my $_noactions = defined($_[3]) && $_[3];
4098				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
4099				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4100				my $text;
4101				my $lastsep="";
4102				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
4103				$expectation->at($_[1]);
4104
4105				my $thisline;
4106				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4107
4108
4109
4110				while (!$_matched && !$commit)
4111				{
4112
4113				Parse::RecDescent::_trace(q{Trying production: [csvlist]},
4114				Parse::RecDescent::_tracefirst($_[1]),
4115				q{right},
4116				$tracelevel)
4117				if defined $::RD_TRACE;
4118				my $thisprod = $thisrule->{"prods"}[0];
4119				$text = $_[1];
4120				my $_savetext;
4121				@item = (q{right});
4122				%item = (__RULE__ => q{right});
4123				my $repcount = 0;
4124
4125
4126				Parse::RecDescent::_trace(q{Trying subrule: [csvlist]},
4127				Parse::RecDescent::_tracefirst($text),
4128				q{right},
4129				$tracelevel)
4130				if defined $::RD_TRACE;
4131				if (1) { no strict qw{refs};
4132				$expectation->is(q{})->at($text);
4133				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::csvlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4134				{
4135
4136				Parse::RecDescent::_trace(q{<>},
4137				Parse::RecDescent::_tracefirst($text),
4138				q{right},
4139				$tracelevel)
4140				if defined $::RD_TRACE;
4141				$expectation->failed();
4142				last;
4143				}
4144				Parse::RecDescent::_trace(q{>>Matched subrule: [csvlist]<< (return value: [}
4145				. $_tok . q{]},
4146
4147				Parse::RecDescent::_tracefirst($text),
4148				q{right},
4149				$tracelevel)
4150				if defined $::RD_TRACE;
4151				$item{q{csvlist}} = $_tok;
4152				push @item, $_tok;
4153
4154				}
4155
4156				Parse::RecDescent::_trace(q{Trying action},
4157				Parse::RecDescent::_tracefirst($text),
4158				q{right},
4159				$tracelevel)
4160				if defined $::RD_TRACE;
4161
4162
4163				$_tok = ($_noactions) ? 0 : do {$item[1]};
4164				unless (defined $_tok)
4165				{
4166				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4167				if defined $::RD_TRACE;
4168				last;
4169				}
4170				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4171				. $_tok . q{])},
4172				Parse::RecDescent::_tracefirst($text))
4173				if defined $::RD_TRACE;
4174				push @item, $_tok;
4175				$item{__ACTION1__}=$_tok;
4176
4177
4178
4179				Parse::RecDescent::_trace(q{>>Matched production: [csvlist]<<},
4180				Parse::RecDescent::_tracefirst($text),
4181				q{right},
4182				$tracelevel)
4183				if defined $::RD_TRACE;
4184				$_matched = 1;
4185				last;
4186				}
4187
4188
4189				while (!$_matched && !$commit)
4190				{
4191
4192				Parse::RecDescent::_trace(q{Trying production: [varlist]},
4193				Parse::RecDescent::_tracefirst($_[1]),
4194				q{right},
4195				$tracelevel)
4196				if defined $::RD_TRACE;
4197				my $thisprod = $thisrule->{"prods"}[1];
4198				$text = $_[1];
4199				my $_savetext;
4200				@item = (q{right});
4201				%item = (__RULE__ => q{right});
4202				my $repcount = 0;
4203
4204
4205				Parse::RecDescent::_trace(q{Trying subrule: [varlist]},
4206				Parse::RecDescent::_tracefirst($text),
4207				q{right},
4208				$tracelevel)
4209				if defined $::RD_TRACE;
4210				if (1) { no strict qw{refs};
4211				$expectation->is(q{})->at($text);
4212				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::varlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4213				{
4214
4215				Parse::RecDescent::_trace(q{<>},
4216				Parse::RecDescent::_tracefirst($text),
4217				q{right},
4218				$tracelevel)
4219				if defined $::RD_TRACE;
4220				$expectation->failed();
4221				last;
4222				}
4223				Parse::RecDescent::_trace(q{>>Matched subrule: [varlist]<< (return value: [}
4224				. $_tok . q{]},
4225
4226				Parse::RecDescent::_tracefirst($text),
4227				q{right},
4228				$tracelevel)
4229				if defined $::RD_TRACE;
4230				$item{q{varlist}} = $_tok;
4231				push @item, $_tok;
4232
4233				}
4234
4235				Parse::RecDescent::_trace(q{Trying action},
4236				Parse::RecDescent::_tracefirst($text),
4237				q{right},
4238				$tracelevel)
4239				if defined $::RD_TRACE;
4240
4241
4242				$_tok = ($_noactions) ? 0 : do {$item[1]};
4243				unless (defined $_tok)
4244				{
4245				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4246				if defined $::RD_TRACE;
4247				last;
4248				}
4249				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4250				. $_tok . q{])},
4251				Parse::RecDescent::_tracefirst($text))
4252				if defined $::RD_TRACE;
4253				push @item, $_tok;
4254				$item{__ACTION1__}=$_tok;
4255
4256
4257
4258				Parse::RecDescent::_trace(q{>>Matched production: [varlist]<<},
4259				Parse::RecDescent::_tracefirst($text),
4260				q{right},
4261				$tracelevel)
4262				if defined $::RD_TRACE;
4263				$_matched = 1;
4264				last;
4265				}
4266
4267
4268				unless ( $_matched \|\| defined($return) \|\| defined($score) )
4269				{
4270
4271
4272				$_[1] = $text; # NOT SURE THIS IS NEEDED
4273				Parse::RecDescent::_trace(q{<>},
4274				Parse::RecDescent::_tracefirst($_[1]),
4275				q{right},
4276				$tracelevel)
4277				if defined $::RD_TRACE;
4278				return undef;
4279				}
4280				if (!defined($return) && defined($score))
4281				{
4282				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4283				q{right},
4284				$tracelevel)
4285				if defined $::RD_TRACE;
4286				$return = $score_return;
4287				}
4288				splice @{$thisparser->{errors}}, $err_at;
4289				$return = $item[$#item] unless defined $return;
4290				if (defined $::RD_TRACE)
4291				{
4292				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4293				$return . q{])}, "",
4294				q{right},
4295				$tracelevel);
4296				Parse::RecDescent::_trace(q{(consumed: [} .
4297				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4298				Parse::RecDescent::_tracefirst($text),
4299				, q{right},
4300				$tracelevel)
4301				}
4302				$_[1] = $text;
4303				return $return;
4304				}
4305
4306				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4307				sub Parse::RecDescent::Config::Magic::Grammar::xml_full
4308				{
4309				my $thisparser = $_[0];
4310				use vars q{$tracelevel};
4311				local $tracelevel = ($tracelevel\|\|0)+1;
4312				$ERRORS = 0;
4313				my $thisrule = $thisparser->{"rules"}{"xml_full"};
4314
4315				Parse::RecDescent::_trace(q{Trying rule: [xml_full]},
4316				Parse::RecDescent::_tracefirst($_[1]),
4317				q{xml_full},
4318				$tracelevel)
4319				if defined $::RD_TRACE;
4320
4321
4322				my $err_at = @{$thisparser->{errors}};
4323
4324				my $score;
4325				my $score_return;
4326				my $_tok;
4327				my $return = undef;
4328				my $_matched=0;
4329				my $commit=0;
4330				my @item = ();
4331				my %item = ();
4332				my $repeating = defined($_[2]) && $_[2];
4333				my $_noactions = defined($_[3]) && $_[3];
4334				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
4335				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4336				my $text;
4337				my $lastsep="";
4338				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
4339				$expectation->at($_[1]);
4340
4341				my $thisline;
4342				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4343
4344
4345
4346				while (!$_matched && !$commit)
4347				{
4348
4349				Parse::RecDescent::_trace(q{Trying production: [varlist '>']},
4350				Parse::RecDescent::_tracefirst($_[1]),
4351				q{xml_full},
4352				$tracelevel)
4353				if defined $::RD_TRACE;
4354				my $thisprod = $thisrule->{"prods"}[0];
4355				$text = $_[1];
4356				my $_savetext;
4357				@item = (q{xml_full});
4358				%item = (__RULE__ => q{xml_full});
4359				my $repcount = 0;
4360
4361
4362				Parse::RecDescent::_trace(q{Trying subrule: [varlist]},
4363				Parse::RecDescent::_tracefirst($text),
4364				q{xml_full},
4365				$tracelevel)
4366				if defined $::RD_TRACE;
4367				if (1) { no strict qw{refs};
4368				$expectation->is(q{})->at($text);
4369				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::varlist($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4370				{
4371
4372				Parse::RecDescent::_trace(q{<>},
4373				Parse::RecDescent::_tracefirst($text),
4374				q{xml_full},
4375				$tracelevel)
4376				if defined $::RD_TRACE;
4377				$expectation->failed();
4378				last;
4379				}
4380				Parse::RecDescent::_trace(q{>>Matched subrule: [varlist]<< (return value: [}
4381				. $_tok . q{]},
4382
4383				Parse::RecDescent::_tracefirst($text),
4384				q{xml_full},
4385				$tracelevel)
4386				if defined $::RD_TRACE;
4387				$item{q{varlist}} = $_tok;
4388				push @item, $_tok;
4389
4390				}
4391
4392				Parse::RecDescent::_trace(q{Trying terminal: ['>']},
4393				Parse::RecDescent::_tracefirst($text),
4394				q{xml_full},
4395				$tracelevel)
4396				if defined $::RD_TRACE;
4397				$lastsep = "";
4398				$expectation->is(q{'>'})->at($text);
4399
4400
4401				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = ">"; 1 } and
4402				substr($text,0,length($_tok)) eq $_tok and
4403				do { substr($text,0,length($_tok)) = ""; 1; }
4404				)
4405				{
4406
4407				$expectation->failed();
4408				Parse::RecDescent::_trace(q{<>},
4409				Parse::RecDescent::_tracefirst($text))
4410				if defined $::RD_TRACE;
4411				last;
4412				}
4413				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4414				. $_tok . q{])},
4415				Parse::RecDescent::_tracefirst($text))
4416				if defined $::RD_TRACE;
4417				push @item, $item{__STRING1__}=$_tok;
4418
4419
4420				Parse::RecDescent::_trace(q{Trying action},
4421				Parse::RecDescent::_tracefirst($text),
4422				q{xml_full},
4423				$tracelevel)
4424				if defined $::RD_TRACE;
4425
4426
4427				$_tok = ($_noactions) ? 0 : do {
4428				#if(ref($item[1])=~/ARRAY/) {
4429				["attribs",$item[1]];
4430				#for my $it (@{$item[1]})
4431				# { push(@return,$it); };
4432				# \@return;
4433				# }
4434				#else {["attribs",$item[1]]; };
4435				};
4436				unless (defined $_tok)
4437				{
4438				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4439				if defined $::RD_TRACE;
4440				last;
4441				}
4442				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4443				. $_tok . q{])},
4444				Parse::RecDescent::_tracefirst($text))
4445				if defined $::RD_TRACE;
4446				push @item, $_tok;
4447				$item{__ACTION1__}=$_tok;
4448
4449
4450
4451				Parse::RecDescent::_trace(q{>>Matched production: [varlist '>']<<},
4452				Parse::RecDescent::_tracefirst($text),
4453				q{xml_full},
4454				$tracelevel)
4455				if defined $::RD_TRACE;
4456				$_matched = 1;
4457				last;
4458				}
4459
4460
4461				while (!$_matched && !$commit)
4462				{
4463
4464				Parse::RecDescent::_trace(q{Trying production: [xml_assigns '>']},
4465				Parse::RecDescent::_tracefirst($_[1]),
4466				q{xml_full},
4467				$tracelevel)
4468				if defined $::RD_TRACE;
4469				my $thisprod = $thisrule->{"prods"}[1];
4470				$text = $_[1];
4471				my $_savetext;
4472				@item = (q{xml_full});
4473				%item = (__RULE__ => q{xml_full});
4474				my $repcount = 0;
4475
4476
4477				Parse::RecDescent::_trace(q{Trying subrule: [xml_assigns]},
4478				Parse::RecDescent::_tracefirst($text),
4479				q{xml_full},
4480				$tracelevel)
4481				if defined $::RD_TRACE;
4482				if (1) { no strict qw{refs};
4483				$expectation->is(q{})->at($text);
4484				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::xml_assigns($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4485				{
4486
4487				Parse::RecDescent::_trace(q{<>},
4488				Parse::RecDescent::_tracefirst($text),
4489				q{xml_full},
4490				$tracelevel)
4491				if defined $::RD_TRACE;
4492				$expectation->failed();
4493				last;
4494				}
4495				Parse::RecDescent::_trace(q{>>Matched subrule: [xml_assigns]<< (return value: [}
4496				. $_tok . q{]},
4497
4498				Parse::RecDescent::_tracefirst($text),
4499				q{xml_full},
4500				$tracelevel)
4501				if defined $::RD_TRACE;
4502				$item{q{xml_assigns}} = $_tok;
4503				push @item, $_tok;
4504
4505				}
4506
4507				Parse::RecDescent::_trace(q{Trying terminal: ['>']},
4508				Parse::RecDescent::_tracefirst($text),
4509				q{xml_full},
4510				$tracelevel)
4511				if defined $::RD_TRACE;
4512				$lastsep = "";
4513				$expectation->is(q{'>'})->at($text);
4514
4515
4516				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = ">"; 1 } and
4517				substr($text,0,length($_tok)) eq $_tok and
4518				do { substr($text,0,length($_tok)) = ""; 1; }
4519				)
4520				{
4521
4522				$expectation->failed();
4523				Parse::RecDescent::_trace(q{<>},
4524				Parse::RecDescent::_tracefirst($text))
4525				if defined $::RD_TRACE;
4526				last;
4527				}
4528				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4529				. $_tok . q{])},
4530				Parse::RecDescent::_tracefirst($text))
4531				if defined $::RD_TRACE;
4532				push @item, $item{__STRING1__}=$_tok;
4533
4534
4535				Parse::RecDescent::_trace(q{Trying action},
4536				Parse::RecDescent::_tracefirst($text),
4537				q{xml_full},
4538				$tracelevel)
4539				if defined $::RD_TRACE;
4540
4541
4542				$_tok = ($_noactions) ? 0 : do { ["attribs",$item[1]];};
4543				unless (defined $_tok)
4544				{
4545				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4546				if defined $::RD_TRACE;
4547				last;
4548				}
4549				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4550				. $_tok . q{])},
4551				Parse::RecDescent::_tracefirst($text))
4552				if defined $::RD_TRACE;
4553				push @item, $_tok;
4554				$item{__ACTION1__}=$_tok;
4555
4556
4557
4558				Parse::RecDescent::_trace(q{>>Matched production: [xml_assigns '>']<<},
4559				Parse::RecDescent::_tracefirst($text),
4560				q{xml_full},
4561				$tracelevel)
4562				if defined $::RD_TRACE;
4563				$_matched = 1;
4564				last;
4565				}
4566
4567
4568				while (!$_matched && !$commit)
4569				{
4570
4571				Parse::RecDescent::_trace(q{Trying production: ['>']},
4572				Parse::RecDescent::_tracefirst($_[1]),
4573				q{xml_full},
4574				$tracelevel)
4575				if defined $::RD_TRACE;
4576				my $thisprod = $thisrule->{"prods"}[2];
4577				$text = $_[1];
4578				my $_savetext;
4579				@item = (q{xml_full});
4580				%item = (__RULE__ => q{xml_full});
4581				my $repcount = 0;
4582
4583
4584				Parse::RecDescent::_trace(q{Trying terminal: ['>']},
4585				Parse::RecDescent::_tracefirst($text),
4586				q{xml_full},
4587				$tracelevel)
4588				if defined $::RD_TRACE;
4589				$lastsep = "";
4590				$expectation->is(q{})->at($text);
4591
4592
4593				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = ">"; 1 } and
4594				substr($text,0,length($_tok)) eq $_tok and
4595				do { substr($text,0,length($_tok)) = ""; 1; }
4596				)
4597				{
4598
4599				$expectation->failed();
4600				Parse::RecDescent::_trace(q{<>},
4601				Parse::RecDescent::_tracefirst($text))
4602				if defined $::RD_TRACE;
4603				last;
4604				}
4605				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
4606				. $_tok . q{])},
4607				Parse::RecDescent::_tracefirst($text))
4608				if defined $::RD_TRACE;
4609				push @item, $item{__STRING1__}=$_tok;
4610
4611
4612				Parse::RecDescent::_trace(q{Trying action},
4613				Parse::RecDescent::_tracefirst($text),
4614				q{xml_full},
4615				$tracelevel)
4616				if defined $::RD_TRACE;
4617
4618
4619				$_tok = ($_noactions) ? 0 : do {[]};
4620				unless (defined $_tok)
4621				{
4622				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4623				if defined $::RD_TRACE;
4624				last;
4625				}
4626				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4627				. $_tok . q{])},
4628				Parse::RecDescent::_tracefirst($text))
4629				if defined $::RD_TRACE;
4630				push @item, $_tok;
4631				$item{__ACTION1__}=$_tok;
4632
4633
4634
4635				Parse::RecDescent::_trace(q{>>Matched production: ['>']<<},
4636				Parse::RecDescent::_tracefirst($text),
4637				q{xml_full},
4638				$tracelevel)
4639				if defined $::RD_TRACE;
4640				$_matched = 1;
4641				last;
4642				}
4643
4644
4645				unless ( $_matched \|\| defined($return) \|\| defined($score) )
4646				{
4647
4648
4649				$_[1] = $text; # NOT SURE THIS IS NEEDED
4650				Parse::RecDescent::_trace(q{<>},
4651				Parse::RecDescent::_tracefirst($_[1]),
4652				q{xml_full},
4653				$tracelevel)
4654				if defined $::RD_TRACE;
4655				return undef;
4656				}
4657				if (!defined($return) && defined($score))
4658				{
4659				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4660				q{xml_full},
4661				$tracelevel)
4662				if defined $::RD_TRACE;
4663				$return = $score_return;
4664				}
4665				splice @{$thisparser->{errors}}, $err_at;
4666				$return = $item[$#item] unless defined $return;
4667				if (defined $::RD_TRACE)
4668				{
4669				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4670				$return . q{])}, "",
4671				q{xml_full},
4672				$tracelevel);
4673				Parse::RecDescent::_trace(q{(consumed: [} .
4674				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4675				Parse::RecDescent::_tracefirst($text),
4676				, q{xml_full},
4677				$tracelevel)
4678				}
4679				$_[1] = $text;
4680				return $return;
4681				}
4682
4683				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
4684				sub Parse::RecDescent::Config::Magic::Grammar::assign
4685				{
4686				my $thisparser = $_[0];
4687				use vars q{$tracelevel};
4688				local $tracelevel = ($tracelevel\|\|0)+1;
4689				$ERRORS = 0;
4690				my $thisrule = $thisparser->{"rules"}{"assign"};
4691
4692				Parse::RecDescent::_trace(q{Trying rule: [assign]},
4693				Parse::RecDescent::_tracefirst($_[1]),
4694				q{assign},
4695				$tracelevel)
4696				if defined $::RD_TRACE;
4697
4698
4699				my $err_at = @{$thisparser->{errors}};
4700
4701				my $score;
4702				my $score_return;
4703				my $_tok;
4704				my $return = undef;
4705				my $_matched=0;
4706				my $commit=0;
4707				my @item = ();
4708				my %item = ();
4709				my $repeating = defined($_[2]) && $_[2];
4710				my $_noactions = defined($_[3]) && $_[3];
4711				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
4712				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
4713				my $text;
4714				my $lastsep="";
4715				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
4716				$expectation->at($_[1]);
4717
4718				my $thisline;
4719				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
4720
4721
4722
4723				while (!$_matched && !$commit)
4724				{
4725				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
4726				Parse::RecDescent::_trace(q{Trying production: [left right]},
4727				Parse::RecDescent::_tracefirst($_[1]),
4728				q{assign},
4729				$tracelevel)
4730				if defined $::RD_TRACE;
4731				my $thisprod = $thisrule->{"prods"}[0];
4732				$text = $_[1];
4733				my $_savetext;
4734				@item = (q{assign});
4735				%item = (__RULE__ => q{assign});
4736				my $repcount = 0;
4737
4738
4739				Parse::RecDescent::_trace(q{Trying subrule: [left]},
4740				Parse::RecDescent::_tracefirst($text),
4741				q{assign},
4742				$tracelevel)
4743				if defined $::RD_TRACE;
4744				if (1) { no strict qw{refs};
4745				$expectation->is(q{})->at($text);
4746				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::left($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4747				{
4748
4749				Parse::RecDescent::_trace(q{<>},
4750				Parse::RecDescent::_tracefirst($text),
4751				q{assign},
4752				$tracelevel)
4753				if defined $::RD_TRACE;
4754				$expectation->failed();
4755				last;
4756				}
4757				Parse::RecDescent::_trace(q{>>Matched subrule: [left]<< (return value: [}
4758				. $_tok . q{]},
4759
4760				Parse::RecDescent::_tracefirst($text),
4761				q{assign},
4762				$tracelevel)
4763				if defined $::RD_TRACE;
4764				$item{q{left}} = $_tok;
4765				push @item, $_tok;
4766
4767				}
4768
4769
4770
4771				Parse::RecDescent::_trace(q{Trying directive: []},
4772				Parse::RecDescent::_tracefirst($text),
4773				q{assign},
4774				$tracelevel)
4775				if defined $::RD_TRACE;
4776				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline; $oldskip };
4777				if (defined($_tok))
4778				{
4779				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
4780				. $_tok . q{])},
4781				Parse::RecDescent::_tracefirst($text))
4782				if defined $::RD_TRACE;
4783				}
4784				else
4785				{
4786				Parse::RecDescent::_trace(q{<>},
4787				Parse::RecDescent::_tracefirst($text))
4788				if defined $::RD_TRACE;
4789				}
4790
4791				last unless defined $_tok;
4792				push @item, $item{__DIRECTIVE1__}=$_tok;
4793
4794
4795				Parse::RecDescent::_trace(q{Trying subrule: [right]},
4796				Parse::RecDescent::_tracefirst($text),
4797				q{assign},
4798				$tracelevel)
4799				if defined $::RD_TRACE;
4800				if (1) { no strict qw{refs};
4801				$expectation->is(q{right})->at($text);
4802				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::right($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4803				{
4804
4805				Parse::RecDescent::_trace(q{<>},
4806				Parse::RecDescent::_tracefirst($text),
4807				q{assign},
4808				$tracelevel)
4809				if defined $::RD_TRACE;
4810				$expectation->failed();
4811				last;
4812				}
4813				Parse::RecDescent::_trace(q{>>Matched subrule: [right]<< (return value: [}
4814				. $_tok . q{]},
4815
4816				Parse::RecDescent::_tracefirst($text),
4817				q{assign},
4818				$tracelevel)
4819				if defined $::RD_TRACE;
4820				$item{q{right}} = $_tok;
4821				push @item, $_tok;
4822
4823				}
4824
4825				Parse::RecDescent::_trace(q{Trying action},
4826				Parse::RecDescent::_tracefirst($text),
4827				q{assign},
4828				$tracelevel)
4829				if defined $::RD_TRACE;
4830
4831
4832				$_tok = ($_noactions) ? 0 : do {[$item[1],$item[3]]};
4833				unless (defined $_tok)
4834				{
4835				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4836				if defined $::RD_TRACE;
4837				last;
4838				}
4839				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4840				. $_tok . q{])},
4841				Parse::RecDescent::_tracefirst($text))
4842				if defined $::RD_TRACE;
4843				push @item, $_tok;
4844				$item{__ACTION1__}=$_tok;
4845
4846
4847
4848				Parse::RecDescent::_trace(q{>>Matched production: [left right]<<},
4849				Parse::RecDescent::_tracefirst($text),
4850				q{assign},
4851				$tracelevel)
4852				if defined $::RD_TRACE;
4853				$_matched = 1;
4854				last;
4855				}
4856
4857
4858				while (!$_matched && !$commit)
4859				{
4860				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
4861				Parse::RecDescent::_trace(q{Trying production: [ svar]},
4862				Parse::RecDescent::_tracefirst($_[1]),
4863				q{assign},
4864				$tracelevel)
4865				if defined $::RD_TRACE;
4866				my $thisprod = $thisrule->{"prods"}[1];
4867				$text = $_[1];
4868				my $_savetext;
4869				@item = (q{assign});
4870				%item = (__RULE__ => q{assign});
4871				my $repcount = 0;
4872
4873
4874
4875
4876				Parse::RecDescent::_trace(q{Trying directive: []},
4877				Parse::RecDescent::_tracefirst($text),
4878				q{assign},
4879				$tracelevel)
4880				if defined $::RD_TRACE;
4881				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline ; $oldskip };
4882				if (defined($_tok))
4883				{
4884				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
4885				. $_tok . q{])},
4886				Parse::RecDescent::_tracefirst($text))
4887				if defined $::RD_TRACE;
4888				}
4889				else
4890				{
4891				Parse::RecDescent::_trace(q{<>},
4892				Parse::RecDescent::_tracefirst($text))
4893				if defined $::RD_TRACE;
4894				}
4895
4896				last unless defined $_tok;
4897				push @item, $item{__DIRECTIVE1__}=$_tok;
4898
4899
4900				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
4901				Parse::RecDescent::_tracefirst($text),
4902				q{assign},
4903				$tracelevel)
4904				if defined $::RD_TRACE;
4905				if (1) { no strict qw{refs};
4906				$expectation->is(q{svar})->at($text);
4907				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
4908				{
4909
4910				Parse::RecDescent::_trace(q{<>},
4911				Parse::RecDescent::_tracefirst($text),
4912				q{assign},
4913				$tracelevel)
4914				if defined $::RD_TRACE;
4915				$expectation->failed();
4916				last;
4917				}
4918				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
4919				. $_tok . q{]},
4920
4921				Parse::RecDescent::_tracefirst($text),
4922				q{assign},
4923				$tracelevel)
4924				if defined $::RD_TRACE;
4925				$item{q{svar}} = $_tok;
4926				push @item, $_tok;
4927
4928				}
4929
4930				Parse::RecDescent::_trace(q{Trying action},
4931				Parse::RecDescent::_tracefirst($text),
4932				q{assign},
4933				$tracelevel)
4934				if defined $::RD_TRACE;
4935
4936
4937				$_tok = ($_noactions) ? 0 : do {[$item[2]]};
4938				unless (defined $_tok)
4939				{
4940				Parse::RecDescent::_trace(q{<> (return value: [undef])})
4941				if defined $::RD_TRACE;
4942				last;
4943				}
4944				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4945				. $_tok . q{])},
4946				Parse::RecDescent::_tracefirst($text))
4947				if defined $::RD_TRACE;
4948				push @item, $_tok;
4949				$item{__ACTION1__}=$_tok;
4950
4951
4952
4953				Parse::RecDescent::_trace(q{>>Matched production: [ svar]<<},
4954				Parse::RecDescent::_tracefirst($text),
4955				q{assign},
4956				$tracelevel)
4957				if defined $::RD_TRACE;
4958				$_matched = 1;
4959				last;
4960				}
4961
4962
4963				unless ( $_matched \|\| defined($return) \|\| defined($score) )
4964				{
4965
4966
4967				$_[1] = $text; # NOT SURE THIS IS NEEDED
4968				Parse::RecDescent::_trace(q{<>},
4969				Parse::RecDescent::_tracefirst($_[1]),
4970				q{assign},
4971				$tracelevel)
4972				if defined $::RD_TRACE;
4973				return undef;
4974				}
4975				if (!defined($return) && defined($score))
4976				{
4977				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4978				q{assign},
4979				$tracelevel)
4980				if defined $::RD_TRACE;
4981				$return = $score_return;
4982				}
4983				splice @{$thisparser->{errors}}, $err_at;
4984				$return = $item[$#item] unless defined $return;
4985				if (defined $::RD_TRACE)
4986				{
4987				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4988				$return . q{])}, "",
4989				q{assign},
4990				$tracelevel);
4991				Parse::RecDescent::_trace(q{(consumed: [} .
4992				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4993				Parse::RecDescent::_tracefirst($text),
4994				, q{assign},
4995				$tracelevel)
4996				}
4997				$_[1] = $text;
4998				return $return;
4999				}
5000
5001				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5002				sub Parse::RecDescent::Config::Magic::Grammar::strict_assign
5003				{
5004				my $thisparser = $_[0];
5005				use vars q{$tracelevel};
5006				local $tracelevel = ($tracelevel\|\|0)+1;
5007				$ERRORS = 0;
5008				my $thisrule = $thisparser->{"rules"}{"strict_assign"};
5009
5010				Parse::RecDescent::_trace(q{Trying rule: [strict_assign]},
5011				Parse::RecDescent::_tracefirst($_[1]),
5012				q{strict_assign},
5013				$tracelevel)
5014				if defined $::RD_TRACE;
5015
5016
5017				my $err_at = @{$thisparser->{errors}};
5018
5019				my $score;
5020				my $score_return;
5021				my $_tok;
5022				my $return = undef;
5023				my $_matched=0;
5024				my $commit=0;
5025				my @item = ();
5026				my %item = ();
5027				my $repeating = defined($_[2]) && $_[2];
5028				my $_noactions = defined($_[3]) && $_[3];
5029				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5030				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5031				my $text;
5032				my $lastsep="";
5033				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
5034				$expectation->at($_[1]);
5035
5036				my $thisline;
5037				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5038
5039
5040
5041				while (!$_matched && !$commit)
5042				{
5043				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
5044				Parse::RecDescent::_trace(q{Trying production: [left strict_right]},
5045				Parse::RecDescent::_tracefirst($_[1]),
5046				q{strict_assign},
5047				$tracelevel)
5048				if defined $::RD_TRACE;
5049				my $thisprod = $thisrule->{"prods"}[0];
5050				$text = $_[1];
5051				my $_savetext;
5052				@item = (q{strict_assign});
5053				%item = (__RULE__ => q{strict_assign});
5054				my $repcount = 0;
5055
5056
5057				Parse::RecDescent::_trace(q{Trying subrule: [left]},
5058				Parse::RecDescent::_tracefirst($text),
5059				q{strict_assign},
5060				$tracelevel)
5061				if defined $::RD_TRACE;
5062				if (1) { no strict qw{refs};
5063				$expectation->is(q{})->at($text);
5064				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::left($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5065				{
5066
5067				Parse::RecDescent::_trace(q{<>},
5068				Parse::RecDescent::_tracefirst($text),
5069				q{strict_assign},
5070				$tracelevel)
5071				if defined $::RD_TRACE;
5072				$expectation->failed();
5073				last;
5074				}
5075				Parse::RecDescent::_trace(q{>>Matched subrule: [left]<< (return value: [}
5076				. $_tok . q{]},
5077
5078				Parse::RecDescent::_tracefirst($text),
5079				q{strict_assign},
5080				$tracelevel)
5081				if defined $::RD_TRACE;
5082				$item{q{left}} = $_tok;
5083				push @item, $_tok;
5084
5085				}
5086
5087
5088
5089				Parse::RecDescent::_trace(q{Trying directive: []},
5090				Parse::RecDescent::_tracefirst($text),
5091				q{strict_assign},
5092				$tracelevel)
5093				if defined $::RD_TRACE;
5094				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline; $oldskip };
5095				if (defined($_tok))
5096				{
5097				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
5098				. $_tok . q{])},
5099				Parse::RecDescent::_tracefirst($text))
5100				if defined $::RD_TRACE;
5101				}
5102				else
5103				{
5104				Parse::RecDescent::_trace(q{<>},
5105				Parse::RecDescent::_tracefirst($text))
5106				if defined $::RD_TRACE;
5107				}
5108
5109				last unless defined $_tok;
5110				push @item, $item{__DIRECTIVE1__}=$_tok;
5111
5112
5113				Parse::RecDescent::_trace(q{Trying subrule: [strict_right]},
5114				Parse::RecDescent::_tracefirst($text),
5115				q{strict_assign},
5116				$tracelevel)
5117				if defined $::RD_TRACE;
5118				if (1) { no strict qw{refs};
5119				$expectation->is(q{strict_right})->at($text);
5120				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::strict_right($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5121				{
5122
5123				Parse::RecDescent::_trace(q{<>},
5124				Parse::RecDescent::_tracefirst($text),
5125				q{strict_assign},
5126				$tracelevel)
5127				if defined $::RD_TRACE;
5128				$expectation->failed();
5129				last;
5130				}
5131				Parse::RecDescent::_trace(q{>>Matched subrule: [strict_right]<< (return value: [}
5132				. $_tok . q{]},
5133
5134				Parse::RecDescent::_tracefirst($text),
5135				q{strict_assign},
5136				$tracelevel)
5137				if defined $::RD_TRACE;
5138				$item{q{strict_right}} = $_tok;
5139				push @item, $_tok;
5140
5141				}
5142
5143				Parse::RecDescent::_trace(q{Trying action},
5144				Parse::RecDescent::_tracefirst($text),
5145				q{strict_assign},
5146				$tracelevel)
5147				if defined $::RD_TRACE;
5148
5149
5150				$_tok = ($_noactions) ? 0 : do {[$item[1],$item[3]]};
5151				unless (defined $_tok)
5152				{
5153				Parse::RecDescent::_trace(q{<> (return value: [undef])})
5154				if defined $::RD_TRACE;
5155				last;
5156				}
5157				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5158				. $_tok . q{])},
5159				Parse::RecDescent::_tracefirst($text))
5160				if defined $::RD_TRACE;
5161				push @item, $_tok;
5162				$item{__ACTION1__}=$_tok;
5163
5164
5165
5166				Parse::RecDescent::_trace(q{>>Matched production: [left strict_right]<<},
5167				Parse::RecDescent::_tracefirst($text),
5168				q{strict_assign},
5169				$tracelevel)
5170				if defined $::RD_TRACE;
5171				$_matched = 1;
5172				last;
5173				}
5174
5175
5176				while (!$_matched && !$commit)
5177				{
5178				local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
5179				Parse::RecDescent::_trace(q{Trying production: [ svar '\\n']},
5180				Parse::RecDescent::_tracefirst($_[1]),
5181				q{strict_assign},
5182				$tracelevel)
5183				if defined $::RD_TRACE;
5184				my $thisprod = $thisrule->{"prods"}[1];
5185				$text = $_[1];
5186				my $_savetext;
5187				@item = (q{strict_assign});
5188				%item = (__RULE__ => q{strict_assign});
5189				my $repcount = 0;
5190
5191
5192
5193
5194				Parse::RecDescent::_trace(q{Trying directive: []},
5195				Parse::RecDescent::_tracefirst($text),
5196				q{strict_assign},
5197				$tracelevel)
5198				if defined $::RD_TRACE;
5199				$_tok = do { my $oldskip = $skip; $skip= $withoutnewline ; $oldskip };
5200				if (defined($_tok))
5201				{
5202				Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
5203				. $_tok . q{])},
5204				Parse::RecDescent::_tracefirst($text))
5205				if defined $::RD_TRACE;
5206				}
5207				else
5208				{
5209				Parse::RecDescent::_trace(q{<>},
5210				Parse::RecDescent::_tracefirst($text))
5211				if defined $::RD_TRACE;
5212				}
5213
5214				last unless defined $_tok;
5215				push @item, $item{__DIRECTIVE1__}=$_tok;
5216
5217
5218				Parse::RecDescent::_trace(q{Trying subrule: [svar]},
5219				Parse::RecDescent::_tracefirst($text),
5220				q{strict_assign},
5221				$tracelevel)
5222				if defined $::RD_TRACE;
5223				if (1) { no strict qw{refs};
5224				$expectation->is(q{svar})->at($text);
5225				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::svar($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5226				{
5227
5228				Parse::RecDescent::_trace(q{<>},
5229				Parse::RecDescent::_tracefirst($text),
5230				q{strict_assign},
5231				$tracelevel)
5232				if defined $::RD_TRACE;
5233				$expectation->failed();
5234				last;
5235				}
5236				Parse::RecDescent::_trace(q{>>Matched subrule: [svar]<< (return value: [}
5237				. $_tok . q{]},
5238
5239				Parse::RecDescent::_tracefirst($text),
5240				q{strict_assign},
5241				$tracelevel)
5242				if defined $::RD_TRACE;
5243				$item{q{svar}} = $_tok;
5244				push @item, $_tok;
5245
5246				}
5247
5248				Parse::RecDescent::_trace(q{Trying terminal: ['\\n']},
5249				Parse::RecDescent::_tracefirst($text),
5250				q{strict_assign},
5251				$tracelevel)
5252				if defined $::RD_TRACE;
5253				$lastsep = "";
5254				$expectation->is(q{'\\n'})->at($text);
5255
5256
5257				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "\n"; 1 } and
5258				substr($text,0,length($_tok)) eq $_tok and
5259				do { substr($text,0,length($_tok)) = ""; 1; }
5260				)
5261				{
5262
5263				$expectation->failed();
5264				Parse::RecDescent::_trace(q{<>},
5265				Parse::RecDescent::_tracefirst($text))
5266				if defined $::RD_TRACE;
5267				last;
5268				}
5269				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5270				. $_tok . q{])},
5271				Parse::RecDescent::_tracefirst($text))
5272				if defined $::RD_TRACE;
5273				push @item, $item{__STRING1__}=$_tok;
5274
5275
5276				Parse::RecDescent::_trace(q{Trying action},
5277				Parse::RecDescent::_tracefirst($text),
5278				q{strict_assign},
5279				$tracelevel)
5280				if defined $::RD_TRACE;
5281
5282
5283				$_tok = ($_noactions) ? 0 : do {[$item[2]]};
5284				unless (defined $_tok)
5285				{
5286				Parse::RecDescent::_trace(q{<> (return value: [undef])})
5287				if defined $::RD_TRACE;
5288				last;
5289				}
5290				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5291				. $_tok . q{])},
5292				Parse::RecDescent::_tracefirst($text))
5293				if defined $::RD_TRACE;
5294				push @item, $_tok;
5295				$item{__ACTION1__}=$_tok;
5296
5297
5298
5299				Parse::RecDescent::_trace(q{>>Matched production: [ svar '\\n']<<},
5300				Parse::RecDescent::_tracefirst($text),
5301				q{strict_assign},
5302				$tracelevel)
5303				if defined $::RD_TRACE;
5304				$_matched = 1;
5305				last;
5306				}
5307
5308
5309				unless ( $_matched \|\| defined($return) \|\| defined($score) )
5310				{
5311
5312
5313				$_[1] = $text; # NOT SURE THIS IS NEEDED
5314				Parse::RecDescent::_trace(q{<>},
5315				Parse::RecDescent::_tracefirst($_[1]),
5316				q{strict_assign},
5317				$tracelevel)
5318				if defined $::RD_TRACE;
5319				return undef;
5320				}
5321				if (!defined($return) && defined($score))
5322				{
5323				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5324				q{strict_assign},
5325				$tracelevel)
5326				if defined $::RD_TRACE;
5327				$return = $score_return;
5328				}
5329				splice @{$thisparser->{errors}}, $err_at;
5330				$return = $item[$#item] unless defined $return;
5331				if (defined $::RD_TRACE)
5332				{
5333				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5334				$return . q{])}, "",
5335				q{strict_assign},
5336				$tracelevel);
5337				Parse::RecDescent::_trace(q{(consumed: [} .
5338				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5339				Parse::RecDescent::_tracefirst($text),
5340				, q{strict_assign},
5341				$tracelevel)
5342				}
5343				$_[1] = $text;
5344				return $return;
5345				}
5346
5347				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5348				sub Parse::RecDescent::Config::Magic::Grammar::xml_1
5349				{
5350				my $thisparser = $_[0];
5351				use vars q{$tracelevel};
5352				local $tracelevel = ($tracelevel\|\|0)+1;
5353				$ERRORS = 0;
5354				my $thisrule = $thisparser->{"rules"}{"xml_1"};
5355
5356				Parse::RecDescent::_trace(q{Trying rule: [xml_1]},
5357				Parse::RecDescent::_tracefirst($_[1]),
5358				q{xml_1},
5359				$tracelevel)
5360				if defined $::RD_TRACE;
5361
5362
5363				my $err_at = @{$thisparser->{errors}};
5364
5365				my $score;
5366				my $score_return;
5367				my $_tok;
5368				my $return = undef;
5369				my $_matched=0;
5370				my $commit=0;
5371				my @item = ();
5372				my %item = ();
5373				my $repeating = defined($_[2]) && $_[2];
5374				my $_noactions = defined($_[3]) && $_[3];
5375				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5376				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5377				my $text;
5378				my $lastsep="";
5379				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
5380				$expectation->at($_[1]);
5381
5382				my $thisline;
5383				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5384
5385
5386
5387				while (!$_matched && !$commit)
5388				{
5389
5390				Parse::RecDescent::_trace(q{Trying production: [xml_single]},
5391				Parse::RecDescent::_tracefirst($_[1]),
5392				q{xml_1},
5393				$tracelevel)
5394				if defined $::RD_TRACE;
5395				my $thisprod = $thisrule->{"prods"}[0];
5396				$text = $_[1];
5397				my $_savetext;
5398				@item = (q{xml_1});
5399				%item = (__RULE__ => q{xml_1});
5400				my $repcount = 0;
5401
5402
5403				Parse::RecDescent::_trace(q{Trying subrule: [xml_single]},
5404				Parse::RecDescent::_tracefirst($text),
5405				q{xml_1},
5406				$tracelevel)
5407				if defined $::RD_TRACE;
5408				if (1) { no strict qw{refs};
5409				$expectation->is(q{})->at($text);
5410				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::xml_single($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5411				{
5412
5413				Parse::RecDescent::_trace(q{<>},
5414				Parse::RecDescent::_tracefirst($text),
5415				q{xml_1},
5416				$tracelevel)
5417				if defined $::RD_TRACE;
5418				$expectation->failed();
5419				last;
5420				}
5421				Parse::RecDescent::_trace(q{>>Matched subrule: [xml_single]<< (return value: [}
5422				. $_tok . q{]},
5423
5424				Parse::RecDescent::_tracefirst($text),
5425				q{xml_1},
5426				$tracelevel)
5427				if defined $::RD_TRACE;
5428				$item{q{xml_single}} = $_tok;
5429				push @item, $_tok;
5430
5431				}
5432
5433
5434				Parse::RecDescent::_trace(q{>>Matched production: [xml_single]<<},
5435				Parse::RecDescent::_tracefirst($text),
5436				q{xml_1},
5437				$tracelevel)
5438				if defined $::RD_TRACE;
5439				$_matched = 1;
5440				last;
5441				}
5442
5443
5444				while (!$_matched && !$commit)
5445				{
5446
5447				Parse::RecDescent::_trace(q{Trying production: [xml_full section '<\\/' '$arg[0]' '>']},
5448				Parse::RecDescent::_tracefirst($_[1]),
5449				q{xml_1},
5450				$tracelevel)
5451				if defined $::RD_TRACE;
5452				my $thisprod = $thisrule->{"prods"}[1];
5453				$text = $_[1];
5454				my $_savetext;
5455				@item = (q{xml_1});
5456				%item = (__RULE__ => q{xml_1});
5457				my $repcount = 0;
5458
5459
5460				Parse::RecDescent::_trace(q{Trying subrule: [xml_full]},
5461				Parse::RecDescent::_tracefirst($text),
5462				q{xml_1},
5463				$tracelevel)
5464				if defined $::RD_TRACE;
5465				if (1) { no strict qw{refs};
5466				$expectation->is(q{})->at($text);
5467				unless (defined ($_tok = Parse::RecDescent::Config::Magic::Grammar::xml_full($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
5468				{
5469
5470				Parse::RecDescent::_trace(q{<>},
5471				Parse::RecDescent::_tracefirst($text),
5472				q{xml_1},
5473				$tracelevel)
5474				if defined $::RD_TRACE;
5475				$expectation->failed();
5476				last;
5477				}
5478				Parse::RecDescent::_trace(q{>>Matched subrule: [xml_full]<< (return value: [}
5479				. $_tok . q{]},
5480
5481				Parse::RecDescent::_tracefirst($text),
5482				q{xml_1},
5483				$tracelevel)
5484				if defined $::RD_TRACE;
5485				$item{q{xml_full}} = $_tok;
5486				push @item, $_tok;
5487
5488				}
5489
5490				Parse::RecDescent::_trace(q{Trying repeated subrule: [section]},
5491				Parse::RecDescent::_tracefirst($text),
5492				q{xml_1},
5493				$tracelevel)
5494				if defined $::RD_TRACE;
5495				$expectation->is(q{section})->at($text);
5496
5497				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::section, 0, 100000000, $_noactions,$expectation,undef)))
5498				{
5499				Parse::RecDescent::_trace(q{<>},
5500				Parse::RecDescent::_tracefirst($text),
5501				q{xml_1},
5502				$tracelevel)
5503				if defined $::RD_TRACE;
5504				last;
5505				}
5506				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [section]<< (}
5507				. @$_tok . q{ times)},
5508
5509				Parse::RecDescent::_tracefirst($text),
5510				q{xml_1},
5511				$tracelevel)
5512				if defined $::RD_TRACE;
5513				$item{q{section(s?)}} = $_tok;
5514				push @item, $_tok;
5515
5516
5517
5518				Parse::RecDescent::_trace(q{Trying terminal: ['<\\/']},
5519				Parse::RecDescent::_tracefirst($text),
5520				q{xml_1},
5521				$tracelevel)
5522				if defined $::RD_TRACE;
5523				$lastsep = "";
5524				$expectation->is(q{'<\\/'})->at($text);
5525
5526
5527				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "<\/"; 1 } and
5528				substr($text,0,length($_tok)) eq $_tok and
5529				do { substr($text,0,length($_tok)) = ""; 1; }
5530				)
5531				{
5532
5533				$expectation->failed();
5534				Parse::RecDescent::_trace(q{<>},
5535				Parse::RecDescent::_tracefirst($text))
5536				if defined $::RD_TRACE;
5537				last;
5538				}
5539				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5540				. $_tok . q{])},
5541				Parse::RecDescent::_tracefirst($text))
5542				if defined $::RD_TRACE;
5543				push @item, $item{__STRING1__}=$_tok;
5544
5545
5546				Parse::RecDescent::_trace(q{Trying terminal: ['$arg[0]']},
5547				Parse::RecDescent::_tracefirst($text),
5548				q{xml_1},
5549				$tracelevel)
5550				if defined $::RD_TRACE;
5551				$lastsep = "";
5552				$expectation->is(q{'$arg[0]'})->at($text);
5553
5554
5555				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = "$arg[0]"; 1 } and
5556				substr($text,0,length($_tok)) eq $_tok and
5557				do { substr($text,0,length($_tok)) = ""; 1; }
5558				)
5559				{
5560
5561				$expectation->failed();
5562				Parse::RecDescent::_trace(q{<>},
5563				Parse::RecDescent::_tracefirst($text))
5564				if defined $::RD_TRACE;
5565				last;
5566				}
5567				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5568				. $_tok . q{])},
5569				Parse::RecDescent::_tracefirst($text))
5570				if defined $::RD_TRACE;
5571				push @item, $item{__STRING2__}=$_tok;
5572
5573
5574				Parse::RecDescent::_trace(q{Trying terminal: ['>']},
5575				Parse::RecDescent::_tracefirst($text),
5576				q{xml_1},
5577				$tracelevel)
5578				if defined $::RD_TRACE;
5579				$lastsep = "";
5580				$expectation->is(q{'>'})->at($text);
5581
5582
5583				unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and do { $_tok = ">"; 1 } and
5584				substr($text,0,length($_tok)) eq $_tok and
5585				do { substr($text,0,length($_tok)) = ""; 1; }
5586				)
5587				{
5588
5589				$expectation->failed();
5590				Parse::RecDescent::_trace(q{<>},
5591				Parse::RecDescent::_tracefirst($text))
5592				if defined $::RD_TRACE;
5593				last;
5594				}
5595				Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
5596				. $_tok . q{])},
5597				Parse::RecDescent::_tracefirst($text))
5598				if defined $::RD_TRACE;
5599				push @item, $item{__STRING3__}=$_tok;
5600
5601
5602				Parse::RecDescent::_trace(q{Trying action},
5603				Parse::RecDescent::_tracefirst($text),
5604				q{xml_1},
5605				$tracelevel)
5606				if defined $::RD_TRACE;
5607
5608
5609				$_tok = ($_noactions) ? 0 : do {
5610				unshift (@{$item[2]},$item[1]);
5611				#else {unshift(@{$item[2]},[$item[1]]);}
5612				array2hash($item[2],$thisparser);
5613				};
5614				unless (defined $_tok)
5615				{
5616				Parse::RecDescent::_trace(q{<> (return value: [undef])})
5617				if defined $::RD_TRACE;
5618				last;
5619				}
5620				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5621				. $_tok . q{])},
5622				Parse::RecDescent::_tracefirst($text))
5623				if defined $::RD_TRACE;
5624				push @item, $_tok;
5625				$item{__ACTION1__}=$_tok;
5626
5627
5628
5629				Parse::RecDescent::_trace(q{>>Matched production: [xml_full section '<\\/' '$arg[0]' '>']<<},
5630				Parse::RecDescent::_tracefirst($text),
5631				q{xml_1},
5632				$tracelevel)
5633				if defined $::RD_TRACE;
5634				$_matched = 1;
5635				last;
5636				}
5637
5638
5639				unless ( $_matched \|\| defined($return) \|\| defined($score) )
5640				{
5641
5642
5643				$_[1] = $text; # NOT SURE THIS IS NEEDED
5644				Parse::RecDescent::_trace(q{<>},
5645				Parse::RecDescent::_tracefirst($_[1]),
5646				q{xml_1},
5647				$tracelevel)
5648				if defined $::RD_TRACE;
5649				return undef;
5650				}
5651				if (!defined($return) && defined($score))
5652				{
5653				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5654				q{xml_1},
5655				$tracelevel)
5656				if defined $::RD_TRACE;
5657				$return = $score_return;
5658				}
5659				splice @{$thisparser->{errors}}, $err_at;
5660				$return = $item[$#item] unless defined $return;
5661				if (defined $::RD_TRACE)
5662				{
5663				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5664				$return . q{])}, "",
5665				q{xml_1},
5666				$tracelevel);
5667				Parse::RecDescent::_trace(q{(consumed: [} .
5668				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5669				Parse::RecDescent::_tracefirst($text),
5670				, q{xml_1},
5671				$tracelevel)
5672				}
5673				$_[1] = $text;
5674				return $return;
5675				}
5676
5677				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5678				sub Parse::RecDescent::Config::Magic::Grammar::assigns
5679				{
5680				my $thisparser = $_[0];
5681				use vars q{$tracelevel};
5682				local $tracelevel = ($tracelevel\|\|0)+1;
5683				$ERRORS = 0;
5684				my $thisrule = $thisparser->{"rules"}{"assigns"};
5685
5686				Parse::RecDescent::_trace(q{Trying rule: [assigns]},
5687				Parse::RecDescent::_tracefirst($_[1]),
5688				q{assigns},
5689				$tracelevel)
5690				if defined $::RD_TRACE;
5691
5692
5693				my $err_at = @{$thisparser->{errors}};
5694
5695				my $score;
5696				my $score_return;
5697				my $_tok;
5698				my $return = undef;
5699				my $_matched=0;
5700				my $commit=0;
5701				my @item = ();
5702				my %item = ();
5703				my $repeating = defined($_[2]) && $_[2];
5704				my $_noactions = defined($_[3]) && $_[3];
5705				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5706				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5707				my $text;
5708				my $lastsep="";
5709				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
5710				$expectation->at($_[1]);
5711
5712				my $thisline;
5713				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5714
5715
5716
5717				while (!$_matched && !$commit)
5718				{
5719
5720				Parse::RecDescent::_trace(q{Trying production: [assign]},
5721				Parse::RecDescent::_tracefirst($_[1]),
5722				q{assigns},
5723				$tracelevel)
5724				if defined $::RD_TRACE;
5725				my $thisprod = $thisrule->{"prods"}[0];
5726				$text = $_[1];
5727				my $_savetext;
5728				@item = (q{assigns});
5729				%item = (__RULE__ => q{assigns});
5730				my $repcount = 0;
5731
5732
5733				Parse::RecDescent::_trace(q{Trying repeated subrule: [assign]},
5734				Parse::RecDescent::_tracefirst($text),
5735				q{assigns},
5736				$tracelevel)
5737				if defined $::RD_TRACE;
5738				$expectation->is(q{})->at($text);
5739
5740				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::assign, 0, 100000000, $_noactions,$expectation,undef)))
5741				{
5742				Parse::RecDescent::_trace(q{<>},
5743				Parse::RecDescent::_tracefirst($text),
5744				q{assigns},
5745				$tracelevel)
5746				if defined $::RD_TRACE;
5747				last;
5748				}
5749				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [assign]<< (}
5750				. @$_tok . q{ times)},
5751
5752				Parse::RecDescent::_tracefirst($text),
5753				q{assigns},
5754				$tracelevel)
5755				if defined $::RD_TRACE;
5756				$item{q{assign(s?)}} = $_tok;
5757				push @item, $_tok;
5758
5759
5760
5761				Parse::RecDescent::_trace(q{Trying action},
5762				Parse::RecDescent::_tracefirst($text),
5763				q{assigns},
5764				$tracelevel)
5765				if defined $::RD_TRACE;
5766
5767
5768				$_tok = ($_noactions) ? 0 : do {array2hash($item[1],$thisparser)};
5769				unless (defined $_tok)
5770				{
5771				Parse::RecDescent::_trace(q{<> (return value: [undef])})
5772				if defined $::RD_TRACE;
5773				last;
5774				}
5775				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5776				. $_tok . q{])},
5777				Parse::RecDescent::_tracefirst($text))
5778				if defined $::RD_TRACE;
5779				push @item, $_tok;
5780				$item{__ACTION1__}=$_tok;
5781
5782
5783
5784				Parse::RecDescent::_trace(q{>>Matched production: [assign]<<},
5785				Parse::RecDescent::_tracefirst($text),
5786				q{assigns},
5787				$tracelevel)
5788				if defined $::RD_TRACE;
5789				$_matched = 1;
5790				last;
5791				}
5792
5793
5794				unless ( $_matched \|\| defined($return) \|\| defined($score) )
5795				{
5796
5797
5798				$_[1] = $text; # NOT SURE THIS IS NEEDED
5799				Parse::RecDescent::_trace(q{<>},
5800				Parse::RecDescent::_tracefirst($_[1]),
5801				q{assigns},
5802				$tracelevel)
5803				if defined $::RD_TRACE;
5804				return undef;
5805				}
5806				if (!defined($return) && defined($score))
5807				{
5808				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5809				q{assigns},
5810				$tracelevel)
5811				if defined $::RD_TRACE;
5812				$return = $score_return;
5813				}
5814				splice @{$thisparser->{errors}}, $err_at;
5815				$return = $item[$#item] unless defined $return;
5816				if (defined $::RD_TRACE)
5817				{
5818				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5819				$return . q{])}, "",
5820				q{assigns},
5821				$tracelevel);
5822				Parse::RecDescent::_trace(q{(consumed: [} .
5823				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5824				Parse::RecDescent::_tracefirst($text),
5825				, q{assigns},
5826				$tracelevel)
5827				}
5828				$_[1] = $text;
5829				return $return;
5830				}
5831
5832				# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
5833				sub Parse::RecDescent::Config::Magic::Grammar::start
5834				{
5835				my $thisparser = $_[0];
5836				use vars q{$tracelevel};
5837				local $tracelevel = ($tracelevel\|\|0)+1;
5838				$ERRORS = 0;
5839				my $thisrule = $thisparser->{"rules"}{"start"};
5840
5841				Parse::RecDescent::_trace(q{Trying rule: [start]},
5842				Parse::RecDescent::_tracefirst($_[1]),
5843				q{start},
5844				$tracelevel)
5845				if defined $::RD_TRACE;
5846
5847
5848				my $err_at = @{$thisparser->{errors}};
5849
5850				my $score;
5851				my $score_return;
5852				my $_tok;
5853				my $return = undef;
5854				my $_matched=0;
5855				my $commit=0;
5856				my @item = ();
5857				my %item = ();
5858				my $repeating = defined($_[2]) && $_[2];
5859				my $_noactions = defined($_[3]) && $_[3];
5860				my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
5861				my %arg = ($#arg & 01) ? @arg : (@arg, undef);
5862				my $text;
5863				my $lastsep="";
5864				my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
5865				$expectation->at($_[1]);
5866
5867				my $thisline;
5868				tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
5869
5870
5871
5872				while (!$_matched && !$commit)
5873				{
5874
5875				Parse::RecDescent::_trace(q{Trying production: [section]},
5876				Parse::RecDescent::_tracefirst($_[1]),
5877				q{start},
5878				$tracelevel)
5879				if defined $::RD_TRACE;
5880				my $thisprod = $thisrule->{"prods"}[0];
5881				$text = $_[1];
5882				my $_savetext;
5883				@item = (q{start});
5884				%item = (__RULE__ => q{start});
5885				my $repcount = 0;
5886
5887
5888				Parse::RecDescent::_trace(q{Trying repeated subrule: [section]},
5889				Parse::RecDescent::_tracefirst($text),
5890				q{start},
5891				$tracelevel)
5892				if defined $::RD_TRACE;
5893				$expectation->is(q{})->at($text);
5894
5895				unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::Magic::Grammar::section, 1, 100000000, $_noactions,$expectation,undef)))
5896				{
5897				Parse::RecDescent::_trace(q{<>},
5898				Parse::RecDescent::_tracefirst($text),
5899				q{start},
5900				$tracelevel)
5901				if defined $::RD_TRACE;
5902				last;
5903				}
5904				Parse::RecDescent::_trace(q{>>Matched repeated subrule: [section]<< (}
5905				. @$_tok . q{ times)},
5906
5907				Parse::RecDescent::_tracefirst($text),
5908				q{start},
5909				$tracelevel)
5910				if defined $::RD_TRACE;
5911				$item{q{section(s)}} = $_tok;
5912				push @item, $_tok;
5913
5914
5915
5916				Parse::RecDescent::_trace(q{Trying action},
5917				Parse::RecDescent::_tracefirst($text),
5918				q{start},
5919				$tracelevel)
5920				if defined $::RD_TRACE;
5921
5922
5923				$_tok = ($_noactions) ? 0 : do { array2hash($item[1],$thisparser);};
5924				unless (defined $_tok)
5925				{
5926				Parse::RecDescent::_trace(q{<> (return value: [undef])})
5927				if defined $::RD_TRACE;
5928				last;
5929				}
5930				Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
5931				. $_tok . q{])},
5932				Parse::RecDescent::_tracefirst($text))
5933				if defined $::RD_TRACE;
5934				push @item, $_tok;
5935				$item{__ACTION1__}=$_tok;
5936
5937
5938
5939				Parse::RecDescent::_trace(q{>>Matched production: [section]<<},
5940				Parse::RecDescent::_tracefirst($text),
5941				q{start},
5942				$tracelevel)
5943				if defined $::RD_TRACE;
5944				$_matched = 1;
5945				last;
5946				}
5947
5948
5949				unless ( $_matched \|\| defined($return) \|\| defined($score) )
5950				{
5951
5952
5953				$_[1] = $text; # NOT SURE THIS IS NEEDED
5954				Parse::RecDescent::_trace(q{<>},
5955				Parse::RecDescent::_tracefirst($_[1]),
5956				q{start},
5957				$tracelevel)
5958				if defined $::RD_TRACE;
5959				return undef;
5960				}
5961				if (!defined($return) && defined($score))
5962				{
5963				Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
5964				q{start},
5965				$tracelevel)
5966				if defined $::RD_TRACE;
5967				$return = $score_return;
5968				}
5969				splice @{$thisparser->{errors}}, $err_at;
5970				$return = $item[$#item] unless defined $return;
5971				if (defined $::RD_TRACE)
5972				{
5973				Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
5974				$return . q{])}, "",
5975				q{start},
5976				$tracelevel);
5977				Parse::RecDescent::_trace(q{(consumed: [} .
5978				Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
5979				Parse::RecDescent::_tracefirst($text),
5980				, q{start},
5981				$tracelevel)
5982				}
5983				$_[1] = $text;
5984				return $return;
5985				}
5986				}
5987				package Config::Magic::Grammar; sub new { my $self = bless( {
5988				'_AUTOTREE' => undef,
5989				'localvars' => '',
5990				'startcode' => '',
5991				'_check' => {
5992				'thisoffset' => '',
5993				'itempos' => '',
5994				'prevoffset' => '',
5995				'prevline' => '',
5996				'prevcolumn' => '',
5997				'thiscolumn' => ''
5998				},
5999				'namespace' => 'Parse::RecDescent::Config::Magic::Grammar',
6000				'_AUTOACTION' => undef,
6001				'rules' => {
6002				'left' => bless( {
6003				'impcount' => 0,
6004				'calls' => [
6005				'svar',
6006				'csv'
6007				],
6008				'changed' => 0,
6009				'opcount' => 0,
6010				'prods' => [
6011				bless( {
6012				'number' => '0',
6013				'strcount' => 0,
6014				'dircount' => 0,
6015				'uncommit' => undef,
6016				'error' => undef,
6017				'patcount' => 1,
6018				'actcount' => 1,
6019				'items' => [
6020				bless( {
6021				'subrule' => 'svar',
6022				'matchrule' => 0,
6023				'implicit' => undef,
6024				'argcode' => undef,
6025				'lookahead' => 0,
6026				'line' => 144
6027				}, 'Parse::RecDescent::Subrule' ),
6028				bless( {
6029				'pattern' => '(=>\|:=\|:\|=)',
6030				'hashname' => '__PATTERN1__',
6031				'description' => '/(=>\|:=\|:\|=)/',
6032				'lookahead' => 0,
6033				'rdelim' => '/',
6034				'line' => 144,
6035				'mod' => '',
6036				'ldelim' => '/'
6037				}, 'Parse::RecDescent::Token' ),
6038				bless( {
6039				'hashname' => '__ACTION1__',
6040				'lookahead' => 0,
6041				'line' => 144,
6042				'code' => '{$item[1]}'
6043				}, 'Parse::RecDescent::Action' )
6044				],
6045				'line' => undef
6046				}, 'Parse::RecDescent::Production' ),
6047				bless( {
6048				'number' => '1',
6049				'strcount' => 0,
6050				'dircount' => 0,
6051				'uncommit' => undef,
6052				'error' => undef,
6053				'patcount' => 1,
6054				'actcount' => 1,
6055				'items' => [
6056				bless( {
6057				'pattern' => '([^\\{\\}<>\$\$\\[\\]\\n#]+?)((?:=>\|:\|=)=?)',
6058				'hashname' => '__PATTERN1__',
6059				'description' => '/([^\\\\\\{\\\\\\}<>\\\$\\\$\\\\[\\\\]\\\\n#]+?)((?:=>\|:\|=)=?)/',
6060				'lookahead' => 0,
6061				'rdelim' => '/',
6062				'line' => 145,
6063				'mod' => '',
6064				'ldelim' => '/'
6065				}, 'Parse::RecDescent::Token' ),
6066				bless( {
6067				'hashname' => '__ACTION1__',
6068				'lookahead' => 0,
6069				'line' => 145,
6070				'code' => '{$1;}'
6071				}, 'Parse::RecDescent::Action' )
6072				],
6073				'line' => 145
6074				}, 'Parse::RecDescent::Production' ),
6075				bless( {
6076				'number' => '2',
6077				'strcount' => 0,
6078				'dircount' => 0,
6079				'uncommit' => undef,
6080				'error' => undef,
6081				'patcount' => 0,
6082				'actcount' => 0,
6083				'items' => [
6084				bless( {
6085				'subrule' => 'csv',
6086				'matchrule' => 0,
6087				'implicit' => undef,
6088				'argcode' => undef,
6089				'lookahead' => 0,
6090				'line' => 146
6091				}, 'Parse::RecDescent::Subrule' )
6092				],
6093				'line' => 146
6094				}, 'Parse::RecDescent::Production' ),
6095				bless( {
6096				'number' => '3',
6097				'strcount' => 0,
6098				'dircount' => 0,
6099				'uncommit' => undef,
6100				'error' => undef,
6101				'patcount' => 0,
6102				'actcount' => 0,
6103				'items' => [
6104				bless( {
6105				'subrule' => 'svar',
6106				'matchrule' => 0,
6107				'implicit' => undef,
6108				'argcode' => undef,
6109				'lookahead' => 0,
6110				'line' => 147
6111				}, 'Parse::RecDescent::Subrule' )
6112				],
6113				'line' => 147
6114				}, 'Parse::RecDescent::Production' )
6115				],
6116				'name' => 'left',
6117				'vars' => '',
6118				'line' => 143
6119				}, 'Parse::RecDescent::Rule' ),
6120				'bracket_section' => bless( {
6121				'impcount' => 0,
6122				'calls' => [
6123				'section'
6124				],
6125				'changed' => 0,
6126				'opcount' => 0,
6127				'prods' => [
6128				bless( {
6129				'number' => '0',
6130				'strcount' => 2,
6131				'dircount' => 0,
6132				'uncommit' => undef,
6133				'error' => undef,
6134				'patcount' => 0,
6135				'actcount' => 1,
6136				'items' => [
6137				bless( {
6138				'pattern' => '(',
6139				'hashname' => '__STRING1__',
6140				'description' => '\'(\'',
6141				'lookahead' => 0,
6142				'line' => 93
6143				}, 'Parse::RecDescent::Literal' ),
6144				bless( {
6145				'subrule' => 'section',
6146				'expected' => undef,
6147				'min' => 0,
6148				'argcode' => undef,
6149				'max' => 100000000,
6150				'matchrule' => 0,
6151				'repspec' => 's?',
6152				'lookahead' => 0,
6153				'line' => 93
6154				}, 'Parse::RecDescent::Repetition' ),
6155				bless( {
6156				'pattern' => ')',
6157				'hashname' => '__STRING2__',
6158				'description' => '\')\'',
6159				'lookahead' => 0,
6160				'line' => 93
6161				}, 'Parse::RecDescent::Literal' ),
6162				bless( {
6163				'hashname' => '__ACTION1__',
6164				'lookahead' => 0,
6165				'line' => 93,
6166				'code' => '{$item[2]}'
6167				}, 'Parse::RecDescent::Action' )
6168				],
6169				'line' => undef
6170				}, 'Parse::RecDescent::Production' ),
6171				bless( {
6172				'number' => '1',
6173				'strcount' => 2,
6174				'dircount' => 0,
6175				'uncommit' => undef,
6176				'error' => undef,
6177				'patcount' => 0,
6178				'actcount' => 1,
6179				'items' => [
6180				bless( {
6181				'pattern' => '{',
6182				'hashname' => '__STRING1__',
6183				'description' => '\'\\{\'',
6184				'lookahead' => 0,
6185				'line' => 94
6186				}, 'Parse::RecDescent::Literal' ),
6187				bless( {
6188				'subrule' => 'section',
6189				'expected' => undef,
6190				'min' => 0,
6191				'argcode' => undef,
6192				'max' => 100000000,
6193				'matchrule' => 0,
6194				'repspec' => 's?',
6195				'lookahead' => 0,
6196				'line' => 94
6197				}, 'Parse::RecDescent::Repetition' ),
6198				bless( {
6199				'pattern' => '}',
6200				'hashname' => '__STRING2__',
6201				'description' => '\'\\}\'',
6202				'lookahead' => 0,
6203				'line' => 94
6204				}, 'Parse::RecDescent::Literal' ),
6205				bless( {
6206				'hashname' => '__ACTION1__',
6207				'lookahead' => 0,
6208				'line' => 94,
6209				'code' => '{$item[2]}'
6210				}, 'Parse::RecDescent::Action' )
6211				],
6212				'line' => 94
6213				}, 'Parse::RecDescent::Production' ),
6214				bless( {
6215				'number' => '2',
6216				'strcount' => 2,
6217				'dircount' => 2,
6218				'uncommit' => undef,
6219				'error' => undef,
6220				'patcount' => 0,
6221				'actcount' => 1,
6222				'items' => [
6223				bless( {
6224				'hashname' => '__DIRECTIVE1__',
6225				'name' => '',
6226				'lookahead' => 0,
6227				'line' => 95,
6228				'code' => 'my $oldskip = $skip; $skip= $withoutnewline; $oldskip'
6229				}, 'Parse::RecDescent::Directive' ),
6230				bless( {
6231				'pattern' => '[',
6232				'hashname' => '__STRING1__',
6233				'description' => '\'[\'',
6234				'lookahead' => 0,
6235				'line' => 95
6236				}, 'Parse::RecDescent::Literal' ),
6237				bless( {
6238				'hashname' => '__DIRECTIVE2__',
6239				'name' => '',
6240				'lookahead' => 0,
6241				'line' => 95,
6242				'code' => 'my $oldskip = $skip; $skip= $withnewline; $oldskip'
6243				}, 'Parse::RecDescent::Directive' ),
6244				bless( {
6245				'subrule' => 'section',
6246				'expected' => undef,
6247				'min' => 0,
6248				'argcode' => undef,
6249				'max' => 100000000,
6250				'matchrule' => 0,
6251				'repspec' => 's?',
6252				'lookahead' => 0,
6253				'line' => 95
6254				}, 'Parse::RecDescent::Repetition' ),
6255				bless( {
6256				'pattern' => ']',
6257				'hashname' => '__STRING2__',
6258				'description' => '\']\'',
6259				'lookahead' => 0,
6260				'line' => 95
6261				}, 'Parse::RecDescent::Literal' ),
6262				bless( {
6263				'hashname' => '__ACTION1__',
6264				'lookahead' => 0,
6265				'line' => 95,
6266				'code' => '{$item[2]}'
6267				}, 'Parse::RecDescent::Action' )
6268				],
6269				'line' => 95
6270				}, 'Parse::RecDescent::Production' )
6271				],
6272				'name' => 'bracket_section',
6273				'vars' => '',
6274				'line' => 93
6275				}, 'Parse::RecDescent::Rule' ),
6276				'section' => bless( {
6277				'impcount' => 0,
6278				'calls' => [
6279				'svar',
6280				'xml_1',
6281				'ini_name',
6282				'strict_assign',
6283				'varlist',
6284				'bracket_section',
6285				'assign'
6286				],
6287				'changed' => 0,
6288				'opcount' => 0,
6289				'prods' => [
6290				bless( {
6291				'number' => '0',
6292				'strcount' => 1,
6293				'dircount' => 1,
6294				'uncommit' => undef,
6295				'error' => undef,
6296				'patcount' => 0,
6297				'actcount' => 1,
6298				'items' => [
6299				bless( {
6300				'pattern' => '<',
6301				'hashname' => '__STRING1__',
6302				'description' => '\'<\'',
6303				'lookahead' => 0,
6304				'line' => 85
6305				}, 'Parse::RecDescent::Literal' ),
6306				bless( {
6307				'subrule' => 'svar',
6308				'matchrule' => 0,
6309				'implicit' => undef,
6310				'argcode' => undef,
6311				'lookahead' => 0,
6312				'line' => 85
6313				}, 'Parse::RecDescent::Subrule' ),
6314				bless( {
6315				'hashname' => '__DIRECTIVE1__',
6316				'name' => '',
6317				'lookahead' => 0,
6318				'line' => 85,
6319				'code' => '$commit = 1'
6320				}, 'Parse::RecDescent::Directive' ),
6321				bless( {
6322				'subrule' => 'xml_1',
6323				'matchrule' => 0,
6324				'implicit' => undef,
6325				'argcode' => '[$item[2]]',
6326				'lookahead' => 0,
6327				'line' => 85
6328				}, 'Parse::RecDescent::Subrule' ),
6329				bless( {
6330				'hashname' => '__ACTION1__',
6331				'lookahead' => 0,
6332				'line' => 85,
6333				'code' => '{[$item[2],$item[4]]}'
6334				}, 'Parse::RecDescent::Action' )
6335				],
6336				'line' => undef
6337				}, 'Parse::RecDescent::Production' ),
6338				bless( {
6339				'number' => '1',
6340				'strcount' => 0,
6341				'dircount' => 1,
6342				'uncommit' => undef,
6343				'error' => undef,
6344				'patcount' => 0,
6345				'actcount' => 1,
6346				'items' => [
6347				bless( {
6348				'subrule' => 'ini_name',
6349				'matchrule' => 0,
6350				'implicit' => undef,
6351				'argcode' => undef,
6352				'lookahead' => 0,
6353				'line' => 86
6354				}, 'Parse::RecDescent::Subrule' ),
6355				bless( {
6356				'hashname' => '__DIRECTIVE1__',
6357				'name' => '',
6358				'lookahead' => 0,
6359				'line' => 86,
6360				'code' => '$commit = 1'
6361				}, 'Parse::RecDescent::Directive' ),
6362				bless( {
6363				'subrule' => 'strict_assign',
6364				'expected' => undef,
6365				'min' => 0,
6366				'argcode' => undef,
6367				'max' => 100000000,
6368				'matchrule' => 0,
6369				'repspec' => 's?',
6370				'lookahead' => 0,
6371				'line' => 86
6372				}, 'Parse::RecDescent::Repetition' ),
6373				bless( {
6374				'hashname' => '__ACTION1__',
6375				'lookahead' => 0,
6376				'line' => 86,
6377				'code' => '{section_checker($item[1],$item[3],$thisparser)}'
6378				}, 'Parse::RecDescent::Action' )
6379				],
6380				'line' => 86
6381				}, 'Parse::RecDescent::Production' ),
6382				bless( {
6383				'number' => '2',
6384				'strcount' => 0,
6385				'dircount' => 0,
6386				'uncommit' => undef,
6387				'error' => undef,
6388				'patcount' => 0,
6389				'actcount' => 1,
6390				'items' => [
6391				bless( {
6392				'subrule' => 'varlist',
6393				'matchrule' => 0,
6394				'implicit' => undef,
6395				'argcode' => undef,
6396				'lookahead' => 0,
6397				'line' => 87
6398				}, 'Parse::RecDescent::Subrule' ),
6399				bless( {
6400				'subrule' => 'bracket_section',
6401				'matchrule' => 0,
6402				'implicit' => undef,
6403				'argcode' => undef,
6404				'lookahead' => 0,
6405				'line' => 87
6406				}, 'Parse::RecDescent::Subrule' ),
6407				bless( {
6408				'hashname' => '__ACTION1__',
6409				'lookahead' => 0,
6410				'line' => 87,
6411				'code' => '{my $title = $item[1];
6412				$title = join(\' \',@{$item[1]}) if(ref $item[1] eq \'ARRAY\');
6413				section_checker($title,$item[2],$thisparser);
6414				}'
6415				}, 'Parse::RecDescent::Action' )
6416				],
6417				'line' => 87
6418				}, 'Parse::RecDescent::Production' ),
6419				bless( {
6420				'number' => '3',
6421				'strcount' => 0,
6422				'dircount' => 0,
6423				'uncommit' => undef,
6424				'error' => undef,
6425				'patcount' => 0,
6426				'actcount' => 0,
6427				'items' => [
6428				bless( {
6429				'subrule' => 'assign',
6430				'matchrule' => 0,
6431				'implicit' => undef,
6432				'argcode' => undef,
6433				'lookahead' => 0,
6434				'line' => 91
6435				}, 'Parse::RecDescent::Subrule' )
6436				],
6437				'line' => 91
6438				}, 'Parse::RecDescent::Production' )
6439				],
6440				'name' => 'section',
6441				'vars' => '',
6442				'line' => 84
6443				}, 'Parse::RecDescent::Rule' ),
6444				'csv' => bless( {
6445				'impcount' => 0,
6446				'calls' => [
6447				'svar'
6448				],
6449				'changed' => 0,
6450				'opcount' => 0,
6451				'prods' => [
6452				bless( {
6453				'number' => '0',
6454				'strcount' => 1,
6455				'dircount' => 0,
6456				'uncommit' => undef,
6457				'error' => undef,
6458				'patcount' => 0,
6459				'actcount' => 1,
6460				'items' => [
6461				bless( {
6462				'subrule' => 'svar',
6463				'matchrule' => 0,
6464				'implicit' => undef,
6465				'argcode' => undef,
6466				'lookahead' => 0,
6467				'line' => 140
6468				}, 'Parse::RecDescent::Subrule' ),
6469				bless( {
6470				'pattern' => ',',
6471				'hashname' => '__STRING1__',
6472				'description' => '\',\'',
6473				'lookahead' => 0,
6474				'line' => 140
6475				}, 'Parse::RecDescent::Literal' ),
6476				bless( {
6477				'hashname' => '__ACTION1__',
6478				'lookahead' => 0,
6479				'line' => 140,
6480				'code' => '{$item[1]}'
6481				}, 'Parse::RecDescent::Action' )
6482				],
6483				'line' => undef
6484				}, 'Parse::RecDescent::Production' ),
6485				bless( {
6486				'number' => '1',
6487				'strcount' => 0,
6488				'dircount' => 0,
6489				'uncommit' => undef,
6490				'error' => undef,
6491				'patcount' => 1,
6492				'actcount' => 1,
6493				'items' => [
6494				bless( {
6495				'pattern' => '([^\\n#;]*?),',
6496				'hashname' => '__PATTERN1__',
6497				'description' => '/([^\\\\n#;]*?),/',
6498				'lookahead' => 0,
6499				'rdelim' => '/',
6500				'line' => 141,
6501				'mod' => '',
6502				'ldelim' => '/'
6503				}, 'Parse::RecDescent::Token' ),
6504				bless( {
6505				'hashname' => '__ACTION1__',
6506				'lookahead' => 0,
6507				'line' => 141,
6508				'code' => '{$1;}'
6509				}, 'Parse::RecDescent::Action' )
6510				],
6511				'line' => 141
6512				}, 'Parse::RecDescent::Production' )
6513				],
6514				'name' => 'csv',
6515				'vars' => '',
6516				'line' => 140
6517				}, 'Parse::RecDescent::Rule' ),
6518				'xml_assigns' => bless( {
6519				'impcount' => 0,
6520				'calls' => [
6521				'xml_assign'
6522				],
6523				'changed' => 0,
6524				'opcount' => 0,
6525				'prods' => [
6526				bless( {
6527				'number' => '0',
6528				'strcount' => 0,
6529				'dircount' => 0,
6530				'uncommit' => undef,
6531				'error' => undef,
6532				'patcount' => 0,
6533				'actcount' => 1,
6534				'items' => [
6535				bless( {
6536				'subrule' => 'xml_assign',
6537				'expected' => undef,
6538				'min' => 0,
6539				'argcode' => undef,
6540				'max' => 100000000,
6541				'matchrule' => 0,
6542				'repspec' => 's?',
6543				'lookahead' => 0,
6544				'line' => 122
6545				}, 'Parse::RecDescent::Repetition' ),
6546				bless( {
6547				'hashname' => '__ACTION1__',
6548				'lookahead' => 0,
6549				'line' => 122,
6550				'code' => '{array2hash($item[1])}'
6551				}, 'Parse::RecDescent::Action' )
6552				],
6553				'line' => undef
6554				}, 'Parse::RecDescent::Production' )
6555				],
6556				'name' => 'xml_assigns',
6557				'vars' => '',
6558				'line' => 122
6559				}, 'Parse::RecDescent::Rule' ),
6560				'xml_single' => bless( {
6561				'impcount' => 0,
6562				'calls' => [
6563				'varlist',
6564				'xml_assigns'
6565				],
6566				'changed' => 0,
6567				'opcount' => 0,
6568				'prods' => [
6569				bless( {
6570				'number' => '0',
6571				'strcount' => 1,
6572				'dircount' => 0,
6573				'uncommit' => undef,
6574				'error' => undef,
6575				'patcount' => 0,
6576				'actcount' => 1,
6577				'items' => [
6578				bless( {
6579				'subrule' => 'varlist',
6580				'matchrule' => 0,
6581				'implicit' => undef,
6582				'argcode' => undef,
6583				'lookahead' => 0,
6584				'line' => 106
6585				}, 'Parse::RecDescent::Subrule' ),
6586				bless( {
6587				'pattern' => '\\/>',
6588				'hashname' => '__STRING1__',
6589				'description' => '\'\\\\/>\'',
6590				'lookahead' => 0,
6591				'line' => 106
6592				}, 'Parse::RecDescent::InterpLit' ),
6593				bless( {
6594				'hashname' => '__ACTION1__',
6595				'lookahead' => 0,
6596				'line' => 106,
6597				'code' => '{$item[1]}'
6598				}, 'Parse::RecDescent::Action' )
6599				],
6600				'line' => undef
6601				}, 'Parse::RecDescent::Production' ),
6602				bless( {
6603				'number' => '1',
6604				'strcount' => 1,
6605				'dircount' => 0,
6606				'uncommit' => undef,
6607				'error' => undef,
6608				'patcount' => 0,
6609				'actcount' => 1,
6610				'items' => [
6611				bless( {
6612				'subrule' => 'xml_assigns',
6613				'matchrule' => 0,
6614				'implicit' => undef,
6615				'argcode' => undef,
6616				'lookahead' => 0,
6617				'line' => 106
6618				}, 'Parse::RecDescent::Subrule' ),
6619				bless( {
6620				'pattern' => '\\/>',
6621				'hashname' => '__STRING1__',
6622				'description' => '\'\\\\/>\'',
6623				'lookahead' => 0,
6624				'line' => 106
6625				}, 'Parse::RecDescent::InterpLit' ),
6626				bless( {
6627				'hashname' => '__ACTION1__',
6628				'lookahead' => 0,
6629				'line' => 106,
6630				'code' => '{$item[1]}'
6631				}, 'Parse::RecDescent::Action' )
6632				],
6633				'line' => 106
6634				}, 'Parse::RecDescent::Production' ),
6635				bless( {
6636				'number' => '2',
6637				'strcount' => 1,
6638				'dircount' => 0,
6639				'uncommit' => undef,
6640				'error' => undef,
6641				'patcount' => 0,
6642				'actcount' => 1,
6643				'items' => [
6644				bless( {
6645				'pattern' => '\\/>',
6646				'hashname' => '__STRING1__',
6647				'description' => '\'\\\\/>\'',
6648				'lookahead' => 0,
6649				'line' => 106
6650				}, 'Parse::RecDescent::InterpLit' ),
6651				bless( {
6652				'hashname' => '__ACTION1__',
6653				'lookahead' => 0,
6654				'line' => 106,
6655				'code' => '{[]}'
6656				}, 'Parse::RecDescent::Action' )
6657				],
6658				'line' => 106
6659				}, 'Parse::RecDescent::Production' )
6660				],
6661				'name' => 'xml_single',
6662				'vars' => '',
6663				'line' => 105
6664				}, 'Parse::RecDescent::Rule' ),
6665				'xml_assign' => bless( {
6666				'impcount' => 0,
6667				'calls' => [
6668				'left',
6669				'svar'
6670				],
6671				'changed' => 0,
6672				'opcount' => 0,
6673				'prods' => [
6674				bless( {
6675				'number' => '0',
6676				'strcount' => 0,
6677				'dircount' => 1,
6678				'uncommit' => undef,
6679				'error' => undef,
6680				'patcount' => 0,
6681				'actcount' => 1,
6682				'items' => [
6683				bless( {
6684				'subrule' => 'left',
6685				'matchrule' => 0,
6686				'implicit' => undef,
6687				'argcode' => undef,
6688				'lookahead' => 0,
6689				'line' => 123
6690				}, 'Parse::RecDescent::Subrule' ),
6691				bless( {
6692				'hashname' => '__DIRECTIVE1__',
6693				'name' => '',
6694				'lookahead' => 0,
6695				'line' => 123,
6696				'code' => 'my $oldskip = $skip; $skip= $withoutnewline; $oldskip'
6697				}, 'Parse::RecDescent::Directive' ),
6698				bless( {
6699				'subrule' => 'svar',
6700				'matchrule' => 0,
6701				'implicit' => undef,
6702				'argcode' => undef,
6703				'lookahead' => 0,
6704				'line' => 123
6705				}, 'Parse::RecDescent::Subrule' ),
6706				bless( {
6707				'hashname' => '__ACTION1__',
6708				'lookahead' => 0,
6709				'line' => 123,
6710				'code' => '{ [$item[1],$item[3]] }'
6711				}, 'Parse::RecDescent::Action' )
6712				],
6713				'line' => undef
6714				}, 'Parse::RecDescent::Production' )
6715				],
6716				'name' => 'xml_assign',
6717				'vars' => '',
6718				'line' => 123
6719				}, 'Parse::RecDescent::Rule' ),
6720				'strict_right' => bless( {
6721				'impcount' => 0,
6722				'calls' => [
6723				'csvlist',
6724				'varlist'
6725				],
6726				'changed' => 0,
6727				'opcount' => 0,
6728				'prods' => [
6729				bless( {
6730				'number' => '0',
6731				'strcount' => 1,
6732				'dircount' => 0,
6733				'uncommit' => undef,
6734				'error' => undef,
6735				'patcount' => 0,
6736				'actcount' => 1,
6737				'items' => [
6738				bless( {
6739				'subrule' => 'csvlist',
6740				'matchrule' => 0,
6741				'implicit' => undef,
6742				'argcode' => undef,
6743				'lookahead' => 0,
6744				'line' => 156
6745				}, 'Parse::RecDescent::Subrule' ),
6746				bless( {
6747				'pattern' => '\\n',
6748				'hashname' => '__STRING1__',
6749				'description' => '\'\\\\n\'',
6750				'lookahead' => 0,
6751				'line' => 156
6752				}, 'Parse::RecDescent::InterpLit' ),
6753				bless( {
6754				'hashname' => '__ACTION1__',
6755				'lookahead' => 0,
6756				'line' => 156,
6757				'code' => '{$item[1]}'
6758				}, 'Parse::RecDescent::Action' )
6759				],
6760				'line' => undef
6761				}, 'Parse::RecDescent::Production' ),
6762				bless( {
6763				'number' => '1',
6764				'strcount' => 1,
6765				'dircount' => 0,
6766				'uncommit' => undef,
6767				'error' => undef,
6768				'patcount' => 0,
6769				'actcount' => 1,
6770				'items' => [
6771				bless( {
6772				'subrule' => 'varlist',
6773				'matchrule' => 0,
6774				'implicit' => undef,
6775				'argcode' => undef,
6776				'lookahead' => 0,
6777				'line' => 157
6778				}, 'Parse::RecDescent::Subrule' ),
6779				bless( {
6780				'pattern' => '\\n',
6781				'hashname' => '__STRING1__',
6782				'description' => '\'\\\\n\'',
6783				'lookahead' => 0,
6784				'line' => 157
6785				}, 'Parse::RecDescent::InterpLit' ),
6786				bless( {
6787				'hashname' => '__ACTION1__',
6788				'lookahead' => 0,
6789				'line' => 157,
6790				'code' => '{$item[1]}'
6791				}, 'Parse::RecDescent::Action' )
6792				],
6793				'line' => 156
6794				}, 'Parse::RecDescent::Production' )
6795				],
6796				'name' => 'strict_right',
6797				'vars' => '',
6798				'line' => 156
6799				}, 'Parse::RecDescent::Rule' ),
6800				'varname' => bless( {
6801				'impcount' => 0,
6802				'calls' => [],
6803				'changed' => 0,
6804				'opcount' => 0,
6805				'prods' => [
6806				bless( {
6807				'number' => '0',
6808				'strcount' => 0,
6809				'dircount' => 0,
6810				'uncommit' => undef,
6811				'error' => undef,
6812				'patcount' => 1,
6813				'actcount' => 1,
6814				'items' => [
6815				bless( {
6816				'pattern' => '[^\\s]+?(?=[\\n\\{\\}\\[\\]\$\$=:<>]\|\\/>\|<\\/)',
6817				'hashname' => '__PATTERN1__',
6818				'description' => '/[^\\\\s]+?(?=[\\\\n\\\\\\{\\\\\\}\\\\[\\\\]\\\$\\\$=:<>]\|\\\\/>\|<\\\\/)/',
6819				'lookahead' => 0,
6820				'rdelim' => '/',
6821				'line' => 60,
6822				'mod' => '',
6823				'ldelim' => '/'
6824				}, 'Parse::RecDescent::Token' ),
6825				bless( {
6826				'hashname' => '__ACTION1__',
6827				'lookahead' => 0,
6828				'line' => 60,
6829				'code' => '{
6830				#Eliminate trailing spaces
6831				$item[1]=~s/([^\\s])\\s*$/$1/;
6832				undef;
6833				$item[1] if(length($item[1])>0);
6834				}'
6835				}, 'Parse::RecDescent::Action' )
6836				],
6837				'line' => undef
6838				}, 'Parse::RecDescent::Production' )
6839				],
6840				'name' => 'varname',
6841				'vars' => '',
6842				'line' => 59
6843				}, 'Parse::RecDescent::Rule' ),
6844				'varlist' => bless( {
6845				'impcount' => 0,
6846				'calls' => [
6847				'svar'
6848				],
6849				'changed' => 0,
6850				'opcount' => 0,
6851				'prods' => [
6852				bless( {
6853				'number' => '0',
6854				'strcount' => 0,
6855				'dircount' => 0,
6856				'uncommit' => undef,
6857				'error' => undef,
6858				'patcount' => 0,
6859				'actcount' => 1,
6860				'items' => [
6861				bless( {
6862				'subrule' => 'svar',
6863				'expected' => undef,
6864				'min' => 1,
6865				'argcode' => undef,
6866				'max' => 100000000,
6867				'matchrule' => 0,
6868				'repspec' => 's',
6869				'lookahead' => 0,
6870				'line' => 160
6871				}, 'Parse::RecDescent::Repetition' ),
6872				bless( {
6873				'hashname' => '__ACTION1__',
6874				'lookahead' => 0,
6875				'line' => 161,
6876				'code' => '{
6877				if(@{$item[1]}==1) { $item[1]->[0] ; }
6878				else {$item[1]};
6879				#print (@item);
6880				#if(scalar($item[2]) && scalar(@{$item[2]->[0]})) { unshift(@{$item[2]->[0]},$item[1]); $item[2]->[0];}
6881				#else {$item[1];};
6882				}'
6883				}, 'Parse::RecDescent::Action' )
6884				],
6885				'line' => undef
6886				}, 'Parse::RecDescent::Production' )
6887				],
6888				'name' => 'varlist',
6889				'vars' => '',
6890				'line' => 159
6891				}, 'Parse::RecDescent::Rule' ),
6892				'ini_name' => bless( {
6893				'impcount' => 0,
6894				'calls' => [],
6895				'changed' => 0,
6896				'opcount' => 0,
6897				'prods' => [
6898				bless( {
6899				'number' => '0',
6900				'strcount' => 0,
6901				'dircount' => 0,
6902				'uncommit' => undef,
6903				'error' => undef,
6904				'patcount' => 1,
6905				'actcount' => 1,
6906				'items' => [
6907				bless( {
6908				'pattern' => '\\[([^\\n#]*)\\]',
6909				'hashname' => '__PATTERN1__',
6910				'description' => '/\\\\[([^\\\\n#]*)\\\\]/',
6911				'lookahead' => 0,
6912				'rdelim' => '/',
6913				'line' => 125,
6914				'mod' => '',
6915				'ldelim' => '/'
6916				}, 'Parse::RecDescent::Token' ),
6917				bless( {
6918				'hashname' => '__ACTION1__',
6919				'lookahead' => 0,
6920				'line' => 125,
6921				'code' => '{$1}'
6922				}, 'Parse::RecDescent::Action' )
6923				],
6924				'line' => undef
6925				}, 'Parse::RecDescent::Production' )
6926				],
6927				'name' => 'ini_name',
6928				'vars' => '',
6929				'line' => 125
6930				}, 'Parse::RecDescent::Rule' ),
6931				'csvlist' => bless( {
6932				'impcount' => 0,
6933				'calls' => [
6934				'csv'
6935				],
6936				'changed' => 0,
6937				'opcount' => 0,
6938				'prods' => [
6939				bless( {
6940				'number' => '0',
6941				'strcount' => 0,
6942				'dircount' => 1,
6943				'uncommit' => undef,
6944				'error' => undef,
6945				'patcount' => 1,
6946				'actcount' => 1,
6947				'items' => [
6948				bless( {
6949				'subrule' => 'csv',
6950				'expected' => undef,
6951				'min' => 1,
6952				'argcode' => undef,
6953				'max' => 100000000,
6954				'matchrule' => 0,
6955				'repspec' => 's',
6956				'lookahead' => 0,
6957				'line' => 138
6958				}, 'Parse::RecDescent::Repetition' ),
6959				bless( {
6960				'hashname' => '__DIRECTIVE1__',
6961				'name' => '',
6962				'lookahead' => 0,
6963				'line' => 138,
6964				'code' => 'my $oldskip = $skip; $skip= $withoutnewline ; $oldskip'
6965				}, 'Parse::RecDescent::Directive' ),
6966				bless( {
6967				'pattern' => '([^\\n#]*?)\\n',
6968				'hashname' => '__PATTERN1__',
6969				'description' => '/([^\\\\n#]*?)\\\\n/',
6970				'lookahead' => 0,
6971				'rdelim' => '/',
6972				'line' => 138,
6973				'mod' => '',
6974				'ldelim' => '/'
6975				}, 'Parse::RecDescent::Token' ),
6976				bless( {
6977				'hashname' => '__ACTION1__',
6978				'lookahead' => 0,
6979				'line' => 139,
6980				'code' => '{ [@{$item[1]},$1]; }'
6981				}, 'Parse::RecDescent::Action' )
6982				],
6983				'line' => undef
6984				}, 'Parse::RecDescent::Production' )
6985				],
6986				'name' => 'csvlist',
6987				'vars' => '',
6988				'line' => 138
6989				}, 'Parse::RecDescent::Rule' ),
6990				'tsv' => bless( {
6991				'impcount' => 0,
6992				'calls' => [],
6993				'changed' => 0,
6994				'opcount' => 0,
6995				'prods' => [
6996				bless( {
6997				'number' => '0',
6998				'strcount' => 0,
6999				'dircount' => 0,
7000				'uncommit' => undef,
7001				'error' => undef,
7002				'patcount' => 1,
7003				'actcount' => 1,
7004				'items' => [
7005				bless( {
7006				'pattern' => '([^\\n#]*?)\\t',
7007				'hashname' => '__PATTERN1__',
7008				'description' => '/([^\\\\n#]*?)\\\\t/',
7009				'lookahead' => 0,
7010				'rdelim' => '/',
7011				'line' => 142,
7012				'mod' => '',
7013				'ldelim' => '/'
7014				}, 'Parse::RecDescent::Token' ),
7015				bless( {
7016				'hashname' => '__ACTION1__',
7017				'lookahead' => 0,
7018				'line' => 142,
7019				'code' => '{$1;}'
7020				}, 'Parse::RecDescent::Action' )
7021				],
7022				'line' => undef
7023				}, 'Parse::RecDescent::Production' )
7024				],
7025				'name' => 'tsv',
7026				'vars' => '',
7027				'line' => 142
7028				}, 'Parse::RecDescent::Rule' ),
7029				'single' => bless( {
7030				'impcount' => 0,
7031				'calls' => [],
7032				'changed' => 0,
7033				'opcount' => 0,
7034				'prods' => [
7035				bless( {
7036				'number' => '0',
7037				'strcount' => 0,
7038				'dircount' => 0,
7039				'uncommit' => undef,
7040				'error' => undef,
7041				'patcount' => 1,
7042				'actcount' => 1,
7043				'items' => [
7044				bless( {
7045				'pattern' => '\\s(.?)(?=[\\n\\{\\}\\[\\]\$\$=:<>\\s]\|\\/>\|<\\/\|$)',
7046				'hashname' => '__PATTERN1__',
7047				'description' => '/\\\\s(.?)(?=[\\\\n\\\\\\{\\\\\\}\\\\[\\\\]\\\$\\\$=:<>\\\\s]\|\\\\/>\|<\\\\/\|$)/',
7048				'lookahead' => 0,
7049				'rdelim' => '/',
7050				'line' => 74,
7051				'mod' => '',
7052				'ldelim' => '/'
7053				}, 'Parse::RecDescent::Token' ),
7054				bless( {
7055				'hashname' => '__ACTION1__',
7056				'lookahead' => 0,
7057				'line' => 75,
7058				'code' => '{ $1 if(length($1)>0); #This has been deprecated (too slow). Only using svar now.
7059				}'
7060				}, 'Parse::RecDescent::Action' )
7061				],
7062				'line' => undef
7063				}, 'Parse::RecDescent::Production' )
7064				],
7065				'name' => 'single',
7066				'vars' => '',
7067				'line' => 74
7068				}, 'Parse::RecDescent::Rule' ),
7069				'svar' => bless( {
7070				'impcount' => 0,
7071				'calls' => [],
7072				'changed' => 0,
7073				'opcount' => 0,
7074				'prods' => [
7075				bless( {
7076				'number' => '0',
7077				'strcount' => 0,
7078				'dircount' => 0,
7079				'uncommit' => undef,
7080				'error' => undef,
7081				'patcount' => 1,
7082				'actcount' => 1,
7083				'items' => [
7084				bless( {
7085				'pattern' => '\\\'(.+?)\\\'',
7086				'hashname' => '__PATTERN1__',
7087				'description' => '/\\\\\'(.+?)\\\\\'/sm',
7088				'lookahead' => 0,
7089				'rdelim' => '/',
7090				'line' => 67,
7091				'mod' => 'sm',
7092				'ldelim' => '/'
7093				}, 'Parse::RecDescent::Token' ),
7094				bless( {
7095				'hashname' => '__ACTION1__',
7096				'lookahead' => 0,
7097				'line' => 67,
7098				'code' => '{$1;}'
7099				}, 'Parse::RecDescent::Action' )
7100				],
7101				'line' => undef
7102				}, 'Parse::RecDescent::Production' ),
7103				bless( {
7104				'number' => '1',
7105				'strcount' => 0,
7106				'dircount' => 0,
7107				'uncommit' => undef,
7108				'error' => undef,
7109				'patcount' => 1,
7110				'actcount' => 1,
7111				'items' => [
7112				bless( {
7113				'pattern' => '\\"(.+?)"',
7114				'hashname' => '__PATTERN1__',
7115				'description' => '/\\\\"(.+?)"/sm',
7116				'lookahead' => 0,
7117				'rdelim' => '/',
7118				'line' => 68,
7119				'mod' => 'sm',
7120				'ldelim' => '/'
7121				}, 'Parse::RecDescent::Token' ),
7122				bless( {
7123				'hashname' => '__ACTION1__',
7124				'lookahead' => 0,
7125				'line' => 68,
7126				'code' => '{$1;}'
7127				}, 'Parse::RecDescent::Action' )
7128				],
7129				'line' => 68
7130				}, 'Parse::RecDescent::Production' ),
7131				bless( {
7132				'number' => '2',
7133				'strcount' => 0,
7134				'dircount' => 0,
7135				'uncommit' => undef,
7136				'error' => undef,
7137				'patcount' => 1,
7138				'actcount' => 1,
7139				'items' => [
7140				bless( {
7141				'pattern' => '((?:(?:\\/[^>\\/])\|(?:[^\\{\\}\\[\\]\$\$=:<>\\/\\\\,#;\\s]))+)',
7142				'hashname' => '__PATTERN1__',
7143				'description' => '/((?:(?:\\\\/[^>\\\\/])\|(?:[^\\\\\\{\\\\\\}\\\\[\\\\]\\\$\\\$=:<>\\\\/\\\\\\\\,#;\\\\s]))+)/',
7144				'lookahead' => 0,
7145				'rdelim' => '/',
7146				'line' => 69,
7147				'mod' => '',
7148				'ldelim' => '/'
7149				}, 'Parse::RecDescent::Token' ),
7150				bless( {
7151				'hashname' => '__ACTION1__',
7152				'lookahead' => 0,
7153				'line' => 69,
7154				'code' => '{
7155				$1; #Old pattern: (?=[\\n\\{\\}\\[\\]\$\$=:<>\\s]\|\\/>\|<\\/\|$)
7156				#New pattern is more strict. No reserved characters allowed at all, and no spaces.
7157				}'
7158				}, 'Parse::RecDescent::Action' )
7159				],
7160				'line' => 69
7161				}, 'Parse::RecDescent::Production' )
7162				],
7163				'name' => 'svar',
7164				'vars' => '',
7165				'line' => 67
7166				}, 'Parse::RecDescent::Rule' ),
7167				'right' => bless( {
7168				'impcount' => 0,
7169				'calls' => [
7170				'csvlist',
7171				'varlist'
7172				],
7173				'changed' => 0,
7174				'opcount' => 0,
7175				'prods' => [
7176				bless( {
7177				'number' => '0',
7178				'strcount' => 0,
7179				'dircount' => 0,
7180				'uncommit' => undef,
7181				'error' => undef,
7182				'patcount' => 0,
7183				'actcount' => 1,
7184				'items' => [
7185				bless( {
7186				'subrule' => 'csvlist',
7187				'matchrule' => 0,
7188				'implicit' => undef,
7189				'argcode' => undef,
7190				'lookahead' => 0,
7191				'line' => 149
7192				}, 'Parse::RecDescent::Subrule' ),
7193				bless( {
7194				'hashname' => '__ACTION1__',
7195				'lookahead' => 0,
7196				'line' => 149,
7197				'code' => '{$item[1]}'
7198				}, 'Parse::RecDescent::Action' )
7199				],
7200				'line' => undef
7201				}, 'Parse::RecDescent::Production' ),
7202				bless( {
7203				'number' => '1',
7204				'strcount' => 0,
7205				'dircount' => 0,
7206				'uncommit' => undef,
7207				'error' => undef,
7208				'patcount' => 0,
7209				'actcount' => 1,
7210				'items' => [
7211				bless( {
7212				'subrule' => 'varlist',
7213				'matchrule' => 0,
7214				'implicit' => undef,
7215				'argcode' => undef,
7216				'lookahead' => 0,
7217				'line' => 150
7218				}, 'Parse::RecDescent::Subrule' ),
7219				bless( {
7220				'hashname' => '__ACTION1__',
7221				'lookahead' => 0,
7222				'line' => 150,
7223				'code' => '{$item[1]}'
7224				}, 'Parse::RecDescent::Action' )
7225				],
7226				'line' => 149
7227				}, 'Parse::RecDescent::Production' )
7228				],
7229				'name' => 'right',
7230				'vars' => '',
7231				'line' => 149
7232				}, 'Parse::RecDescent::Rule' ),
7233				'xml_full' => bless( {
7234				'impcount' => 0,
7235				'calls' => [
7236				'varlist',
7237				'xml_assigns'
7238				],
7239				'changed' => 0,
7240				'opcount' => 0,
7241				'prods' => [
7242				bless( {
7243				'number' => '0',
7244				'strcount' => 1,
7245				'dircount' => 0,
7246				'uncommit' => undef,
7247				'error' => undef,
7248				'patcount' => 0,
7249				'actcount' => 1,
7250				'items' => [
7251				bless( {
7252				'subrule' => 'varlist',
7253				'matchrule' => 0,
7254				'implicit' => undef,
7255				'argcode' => undef,
7256				'lookahead' => 0,
7257				'line' => 108
7258				}, 'Parse::RecDescent::Subrule' ),
7259				bless( {
7260				'pattern' => '>',
7261				'hashname' => '__STRING1__',
7262				'description' => '\'>\'',
7263				'lookahead' => 0,
7264				'line' => 108
7265				}, 'Parse::RecDescent::InterpLit' ),
7266				bless( {
7267				'hashname' => '__ACTION1__',
7268				'lookahead' => 0,
7269				'line' => 108,
7270				'code' => '{
7271				#if(ref($item[1])=~/ARRAY/) {
7272				["attribs",$item[1]];
7273				#for my $it (@{$item[1]})
7274				# { push(@return,$it); };
7275				# \\@return;
7276				# }
7277				#else {["attribs",$item[1]]; };
7278				}'
7279				}, 'Parse::RecDescent::Action' )
7280				],
7281				'line' => undef
7282				}, 'Parse::RecDescent::Production' ),
7283				bless( {
7284				'number' => '1',
7285				'strcount' => 1,
7286				'dircount' => 0,
7287				'uncommit' => undef,
7288				'error' => undef,
7289				'patcount' => 0,
7290				'actcount' => 1,
7291				'items' => [
7292				bless( {
7293				'subrule' => 'xml_assigns',
7294				'matchrule' => 0,
7295				'implicit' => undef,
7296				'argcode' => undef,
7297				'lookahead' => 0,
7298				'line' => 117
7299				}, 'Parse::RecDescent::Subrule' ),
7300				bless( {
7301				'pattern' => '>',
7302				'hashname' => '__STRING1__',
7303				'description' => '\'>\'',
7304				'lookahead' => 0,
7305				'line' => 117
7306				}, 'Parse::RecDescent::InterpLit' ),
7307				bless( {
7308				'hashname' => '__ACTION1__',
7309				'lookahead' => 0,
7310				'line' => 117,
7311				'code' => '{ ["attribs",$item[1]];}'
7312				}, 'Parse::RecDescent::Action' )
7313				],
7314				'line' => 117
7315				}, 'Parse::RecDescent::Production' ),
7316				bless( {
7317				'number' => '2',
7318				'strcount' => 1,
7319				'dircount' => 0,
7320				'uncommit' => undef,
7321				'error' => undef,
7322				'patcount' => 0,
7323				'actcount' => 1,
7324				'items' => [
7325				bless( {
7326				'pattern' => '>',
7327				'hashname' => '__STRING1__',
7328				'description' => '\'>\'',
7329				'lookahead' => 0,
7330				'line' => 118
7331				}, 'Parse::RecDescent::InterpLit' ),
7332				bless( {
7333				'hashname' => '__ACTION1__',
7334				'lookahead' => 0,
7335				'line' => 118,
7336				'code' => '{[]}'
7337				}, 'Parse::RecDescent::Action' )
7338				],
7339				'line' => 118
7340				}, 'Parse::RecDescent::Production' )
7341				],
7342				'name' => 'xml_full',
7343				'vars' => '',
7344				'line' => 107
7345				}, 'Parse::RecDescent::Rule' ),
7346				'assign' => bless( {
7347				'impcount' => 0,
7348				'calls' => [
7349				'left',
7350				'right',
7351				'svar'
7352				],
7353				'changed' => 0,
7354				'opcount' => 0,
7355				'prods' => [
7356				bless( {
7357				'number' => '0',
7358				'strcount' => 0,
7359				'dircount' => 1,
7360				'uncommit' => undef,
7361				'error' => undef,
7362				'patcount' => 0,
7363				'actcount' => 1,
7364				'items' => [
7365				bless( {
7366				'subrule' => 'left',
7367				'matchrule' => 0,
7368				'implicit' => undef,
7369				'argcode' => undef,
7370				'lookahead' => 0,
7371				'line' => 135
7372				}, 'Parse::RecDescent::Subrule' ),
7373				bless( {
7374				'hashname' => '__DIRECTIVE1__',
7375				'name' => '',
7376				'lookahead' => 0,
7377				'line' => 135,
7378				'code' => 'my $oldskip = $skip; $skip= $withoutnewline; $oldskip'
7379				}, 'Parse::RecDescent::Directive' ),
7380				bless( {
7381				'subrule' => 'right',
7382				'matchrule' => 0,
7383				'implicit' => undef,
7384				'argcode' => undef,
7385				'lookahead' => 0,
7386				'line' => 135
7387				}, 'Parse::RecDescent::Subrule' ),
7388				bless( {
7389				'hashname' => '__ACTION1__',
7390				'lookahead' => 0,
7391				'line' => 135,
7392				'code' => '{[$item[1],$item[3]]}'
7393				}, 'Parse::RecDescent::Action' )
7394				],
7395				'line' => undef
7396				}, 'Parse::RecDescent::Production' ),
7397				bless( {
7398				'number' => '1',
7399				'strcount' => 0,
7400				'dircount' => 1,
7401				'uncommit' => undef,
7402				'error' => undef,
7403				'patcount' => 0,
7404				'actcount' => 1,
7405				'items' => [
7406				bless( {
7407				'hashname' => '__DIRECTIVE1__',
7408				'name' => '',
7409				'lookahead' => 0,
7410				'line' => 136,
7411				'code' => 'my $oldskip = $skip; $skip= $withoutnewline ; $oldskip'
7412				}, 'Parse::RecDescent::Directive' ),
7413				bless( {
7414				'subrule' => 'svar',
7415				'matchrule' => 0,
7416				'implicit' => undef,
7417				'argcode' => undef,
7418				'lookahead' => 0,
7419				'line' => 136
7420				}, 'Parse::RecDescent::Subrule' ),
7421				bless( {
7422				'hashname' => '__ACTION1__',
7423				'lookahead' => 0,
7424				'line' => 136,
7425				'code' => '{[$item[2]]}'
7426				}, 'Parse::RecDescent::Action' )
7427				],
7428				'line' => 136
7429				}, 'Parse::RecDescent::Production' )
7430				],
7431				'name' => 'assign',
7432				'vars' => '',
7433				'line' => 134
7434				}, 'Parse::RecDescent::Rule' ),
7435				'strict_assign' => bless( {
7436				'impcount' => 0,
7437				'calls' => [
7438				'left',
7439				'strict_right',
7440				'svar'
7441				],
7442				'changed' => 0,
7443				'opcount' => 0,
7444				'prods' => [
7445				bless( {
7446				'number' => '0',
7447				'strcount' => 0,
7448				'dircount' => 1,
7449				'uncommit' => undef,
7450				'error' => undef,
7451				'patcount' => 0,
7452				'actcount' => 1,
7453				'items' => [
7454				bless( {
7455				'subrule' => 'left',
7456				'matchrule' => 0,
7457				'implicit' => undef,
7458				'argcode' => undef,
7459				'lookahead' => 0,
7460				'line' => 154
7461				}, 'Parse::RecDescent::Subrule' ),
7462				bless( {
7463				'hashname' => '__DIRECTIVE1__',
7464				'name' => '',
7465				'lookahead' => 0,
7466				'line' => 154,
7467				'code' => 'my $oldskip = $skip; $skip= $withoutnewline; $oldskip'
7468				}, 'Parse::RecDescent::Directive' ),
7469				bless( {
7470				'subrule' => 'strict_right',
7471				'matchrule' => 0,
7472				'implicit' => undef,
7473				'argcode' => undef,
7474				'lookahead' => 0,
7475				'line' => 154
7476				}, 'Parse::RecDescent::Subrule' ),
7477				bless( {
7478				'hashname' => '__ACTION1__',
7479				'lookahead' => 0,
7480				'line' => 154,
7481				'code' => '{[$item[1],$item[3]]}'
7482				}, 'Parse::RecDescent::Action' )
7483				],
7484				'line' => undef
7485				}, 'Parse::RecDescent::Production' ),
7486				bless( {
7487				'number' => '1',
7488				'strcount' => 1,
7489				'dircount' => 1,
7490				'uncommit' => undef,
7491				'error' => undef,
7492				'patcount' => 0,
7493				'actcount' => 1,
7494				'items' => [
7495				bless( {
7496				'hashname' => '__DIRECTIVE1__',
7497				'name' => '',
7498				'lookahead' => 0,
7499				'line' => 155,
7500				'code' => 'my $oldskip = $skip; $skip= $withoutnewline ; $oldskip'
7501				}, 'Parse::RecDescent::Directive' ),
7502				bless( {
7503				'subrule' => 'svar',
7504				'matchrule' => 0,
7505				'implicit' => undef,
7506				'argcode' => undef,
7507				'lookahead' => 0,
7508				'line' => 155
7509				}, 'Parse::RecDescent::Subrule' ),
7510				bless( {
7511				'pattern' => '\\n',
7512				'hashname' => '__STRING1__',
7513				'description' => '\'\\\\n\'',
7514				'lookahead' => 0,
7515				'line' => 155
7516				}, 'Parse::RecDescent::InterpLit' ),
7517				bless( {
7518				'hashname' => '__ACTION1__',
7519				'lookahead' => 0,
7520				'line' => 155,
7521				'code' => '{[$item[2]]}'
7522				}, 'Parse::RecDescent::Action' )
7523				],
7524				'line' => 155
7525				}, 'Parse::RecDescent::Production' )
7526				],
7527				'name' => 'strict_assign',
7528				'vars' => '',
7529				'line' => 153
7530				}, 'Parse::RecDescent::Rule' ),
7531				'xml_1' => bless( {
7532				'impcount' => 0,
7533				'calls' => [
7534				'xml_single',
7535				'xml_full',
7536				'section'
7537				],
7538				'changed' => 0,
7539				'opcount' => 0,
7540				'prods' => [
7541				bless( {
7542				'number' => '0',
7543				'strcount' => 0,
7544				'dircount' => 0,
7545				'uncommit' => undef,
7546				'error' => undef,
7547				'patcount' => 0,
7548				'actcount' => 0,
7549				'items' => [
7550				bless( {
7551				'subrule' => 'xml_single',
7552				'matchrule' => 0,
7553				'implicit' => undef,
7554				'argcode' => undef,
7555				'lookahead' => 0,
7556				'line' => 96
7557				}, 'Parse::RecDescent::Subrule' )
7558				],
7559				'line' => undef
7560				}, 'Parse::RecDescent::Production' ),
7561				bless( {
7562				'number' => '1',
7563				'strcount' => 3,
7564				'dircount' => 0,
7565				'uncommit' => undef,
7566				'error' => undef,
7567				'patcount' => 0,
7568				'actcount' => 1,
7569				'items' => [
7570				bless( {
7571				'subrule' => 'xml_full',
7572				'matchrule' => 0,
7573				'implicit' => undef,
7574				'argcode' => undef,
7575				'lookahead' => 0,
7576				'line' => 97
7577				}, 'Parse::RecDescent::Subrule' ),
7578				bless( {
7579				'subrule' => 'section',
7580				'expected' => undef,
7581				'min' => 0,
7582				'argcode' => undef,
7583				'max' => 100000000,
7584				'matchrule' => 0,
7585				'repspec' => 's?',
7586				'lookahead' => 0,
7587				'line' => 97
7588				}, 'Parse::RecDescent::Repetition' ),
7589				bless( {
7590				'pattern' => '<\\/',
7591				'hashname' => '__STRING1__',
7592				'description' => '\'<\\\\/\'',
7593				'lookahead' => 0,
7594				'line' => 97
7595				}, 'Parse::RecDescent::InterpLit' ),
7596				bless( {
7597				'pattern' => '$arg[0]',
7598				'hashname' => '__STRING2__',
7599				'description' => '\'$arg[0]\'',
7600				'lookahead' => 0,
7601				'line' => 97
7602				}, 'Parse::RecDescent::InterpLit' ),
7603				bless( {
7604				'pattern' => '>',
7605				'hashname' => '__STRING3__',
7606				'description' => '\'>\'',
7607				'lookahead' => 0,
7608				'line' => 97
7609				}, 'Parse::RecDescent::InterpLit' ),
7610				bless( {
7611				'hashname' => '__ACTION1__',
7612				'lookahead' => 0,
7613				'line' => 98,
7614				'code' => '{
7615				unshift (@{$item[2]},$item[1]);
7616				#else {unshift(@{$item[2]},[$item[1]]);}
7617				array2hash($item[2],$thisparser);
7618				}'
7619				}, 'Parse::RecDescent::Action' )
7620				],
7621				'line' => 97
7622				}, 'Parse::RecDescent::Production' )
7623				],
7624				'name' => 'xml_1',
7625				'vars' => '',
7626				'line' => 96
7627				}, 'Parse::RecDescent::Rule' ),
7628				'assigns' => bless( {
7629				'impcount' => 0,
7630				'calls' => [
7631				'assign'
7632				],
7633				'changed' => 0,
7634				'opcount' => 0,
7635				'prods' => [
7636				bless( {
7637				'number' => '0',
7638				'strcount' => 0,
7639				'dircount' => 0,
7640				'uncommit' => undef,
7641				'error' => undef,
7642				'patcount' => 0,
7643				'actcount' => 1,
7644				'items' => [
7645				bless( {
7646				'subrule' => 'assign',
7647				'expected' => undef,
7648				'min' => 0,
7649				'argcode' => undef,
7650				'max' => 100000000,
7651				'matchrule' => 0,
7652				'repspec' => 's?',
7653				'lookahead' => 0,
7654				'line' => 120
7655				}, 'Parse::RecDescent::Repetition' ),
7656				bless( {
7657				'hashname' => '__ACTION1__',
7658				'lookahead' => 0,
7659				'line' => 120,
7660				'code' => '{array2hash($item[1],$thisparser)}'
7661				}, 'Parse::RecDescent::Action' )
7662				],
7663				'line' => undef
7664				}, 'Parse::RecDescent::Production' )
7665				],
7666				'name' => 'assigns',
7667				'vars' => '',
7668				'line' => 120
7669				}, 'Parse::RecDescent::Rule' ),
7670				'start' => bless( {
7671				'impcount' => 0,
7672				'calls' => [
7673				'section'
7674				],
7675				'changed' => 0,
7676				'opcount' => 0,
7677				'prods' => [
7678				bless( {
7679				'number' => '0',
7680				'strcount' => 0,
7681				'dircount' => 0,
7682				'uncommit' => undef,
7683				'error' => undef,
7684				'patcount' => 0,
7685				'actcount' => 1,
7686				'items' => [
7687				bless( {
7688				'subrule' => 'section',
7689				'expected' => undef,
7690				'min' => 1,
7691				'argcode' => undef,
7692				'max' => 100000000,
7693				'matchrule' => 0,
7694				'repspec' => 's',
7695				'lookahead' => 0,
7696				'line' => 82
7697				}, 'Parse::RecDescent::Repetition' ),
7698				bless( {
7699				'hashname' => '__ACTION1__',
7700				'lookahead' => 0,
7701				'line' => 82,
7702				'code' => '{ array2hash($item[1],$thisparser);}'
7703				}, 'Parse::RecDescent::Action' )
7704				],
7705				'line' => undef
7706				}, 'Parse::RecDescent::Production' )
7707				],
7708				'name' => 'start',
7709				'vars' => '',
7710				'line' => 81
7711				}, 'Parse::RecDescent::Rule' )
7712				}
7713				}, 'Parse::RecDescent' );
7714				}