File Coverage

blib/lib/Config/ApacheExtended/Grammar.pm

Criterion	Covered	Total	%
statement	1781	2023	88.0
branch	510	1094	46.6
condition	221	481	45.9
subroutine	108	110	98.1
pod	0	1	0.0
total	2620	3709	70.6

line	stmt	bran	cond	sub	pod	time	code
1							package Config::ApacheExtended::Grammar;
2	11			11		97	use Parse::RecDescent;
	11					24
	11					95
3
4							{ my $ERRORS;
5
6
7							package Parse::RecDescent::Config::ApacheExtended::Grammar;
8	11			11		733	use strict;
	11					23
	11					691
9	11			11		57	use vars qw($skip $AUTOLOAD );
	11					23
	11					1110
10							$skip = '\s*';
11							my $data; ;
12
13
14							{
15							local $SIG{__WARN__} = sub {0};
16							# PRETEND TO BE IN Parse::RecDescent NAMESPACE
17							*Parse::RecDescent::Config::ApacheExtended::Grammar::AUTOLOAD = sub
18							{
19	11			11		56	no strict 'refs';
	11					24
	11					1358
20	0			0		0	$AUTOLOAD =~ s/^Parse::RecDescent::Config::ApacheExtended::Grammar/Parse::RecDescent/;
21	0					0	goto &{$AUTOLOAD};
	0					0
22							}
23							}
24
25							push @Parse::RecDescent::Config::ApacheExtended::Grammar::ISA, 'Parse::RecDescent';
26							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
27							sub Parse::RecDescent::Config::ApacheExtended::Grammar::hereto_mark
28							{
29	5			5		12	my $thisparser = $_[0];
30	11			11		56	use vars q{$tracelevel};
	11					27
	11					4781
31	5		50			23	local $tracelevel = ($tracelevel\|\|0)+1;
32	5					10	$ERRORS = 0;
33	5					16	my $thisrule = $thisparser->{"rules"}{"hereto_mark"};
34
35	5	50				21	Parse::RecDescent::_trace(q{Trying rule: [hereto_mark]},
36							Parse::RecDescent::_tracefirst($_[1]),
37							q{hereto_mark},
38							$tracelevel)
39							if defined $::RD_TRACE;
40
41
42	5					10	my $err_at = @{$thisparser->{errors}};
	5					14
43
44	5					12	my $score;
45							my $score_return;
46	0					0	my $_tok;
47	5					10	my $return = undef;
48	5					7	my $_matched=0;
49	5					19	my $commit=0;
50	5					14	my @item = ();
51	5					11	my %item = ();
52	5		33			37	my $repeating = defined($_[2]) && $_[2];
53	5		33			34	my $_noactions = defined($_[3]) && $_[3];
54	5	50				19	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	5					11
	5					13
55	5	50				23	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
56	5					11	my $text;
57	5					11	my $lastsep="";
58	5					27	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
59	5					205	$expectation->at($_[1]);
60
61	5					21	my $thisline;
62	5					28	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
63
64
65
66	5		33			69	while (!$_matched && !$commit)
67							{
68
69	5	50				18	Parse::RecDescent::_trace(q{Trying production: [val]},
70							Parse::RecDescent::_tracefirst($_[1]),
71							q{hereto_mark},
72							$tracelevel)
73							if defined $::RD_TRACE;
74	5					15	my $thisprod = $thisrule->{"prods"}[0];
75	5					10	$text = $_[1];
76	5					13	my $_savetext;
77	5					15	@item = (q{hereto_mark});
78	5					107	%item = (__RULE__ => q{hereto_mark});
79	5					10	my $repcount = 0;
80
81
82	5	50				228	Parse::RecDescent::_trace(q{Trying subrule: [val]},
83							Parse::RecDescent::_tracefirst($text),
84							q{hereto_mark},
85							$tracelevel)
86							if defined $::RD_TRACE;
87	11			11		63	if (1) { no strict qw{refs};
	11					211
	11					6124
	5					9
88	5					21	$expectation->is(q{})->at($text);
89	5	50		5		56	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::val($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	5					34
90							{
91
92	0	0				0	Parse::RecDescent::_trace(q{<>},
93							Parse::RecDescent::_tracefirst($text),
94							q{hereto_mark},
95							$tracelevel)
96							if defined $::RD_TRACE;
97	0					0	$expectation->failed();
98	0					0	last;
99							}
100	5	50				36	Parse::RecDescent::_trace(q{>>Matched subrule: [val]<< (return value: [}
101							. $_tok . q{]},
102
103							Parse::RecDescent::_tracefirst($text),
104							q{hereto_mark},
105							$tracelevel)
106							if defined $::RD_TRACE;
107	5					15	$item{q{val}} = $_tok;
108	5					11	push @item, $_tok;
109
110							}
111
112
113	5	50				18	Parse::RecDescent::_trace(q{>>Matched production: [val]<<},
114							Parse::RecDescent::_tracefirst($text),
115							q{hereto_mark},
116							$tracelevel)
117							if defined $::RD_TRACE;
118	5					9	$_matched = 1;
119	5					10	last;
120							}
121
122
123	5	0	33			22	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			33
124							{
125
126
127	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
128	0	0				0	Parse::RecDescent::_trace(q{<>},
129							Parse::RecDescent::_tracefirst($_[1]),
130							q{hereto_mark},
131							$tracelevel)
132							if defined $::RD_TRACE;
133	0					0	return undef;
134							}
135	5	50	33			35	if (!defined($return) && defined($score))
136							{
137	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
138							q{hereto_mark},
139							$tracelevel)
140							if defined $::RD_TRACE;
141	0					0	$return = $score_return;
142							}
143	5					9	splice @{$thisparser->{errors}}, $err_at;
	5					21
144	5	50				20	$return = $item[$#item] unless defined $return;
145	5	50				19	if (defined $::RD_TRACE)
146							{
147	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
148							$return . q{])}, "",
149							q{hereto_mark},
150							$tracelevel);
151	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
152							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
153							Parse::RecDescent::_tracefirst($text),
154							, q{hereto_mark},
155							$tracelevel)
156							}
157	5					10	$_[1] = $text;
158	5					44	return $return;
159							}
160
161							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
162							sub Parse::RecDescent::Config::ApacheExtended::Grammar::eol
163							{
164	125			125		196	my $thisparser = $_[0];
165	11			11		70	use vars q{$tracelevel};
	11					22
	11					11277
166	125		50			350	local $tracelevel = ($tracelevel\|\|0)+1;
167	125					170	$ERRORS = 0;
168	125					252	my $thisrule = $thisparser->{"rules"}{"eol"};
169
170	125	50				254	Parse::RecDescent::_trace(q{Trying rule: [eol]},
171							Parse::RecDescent::_tracefirst($_[1]),
172							q{eol},
173							$tracelevel)
174							if defined $::RD_TRACE;
175
176
177	125					130	my $err_at = @{$thisparser->{errors}};
	125					248
178
179	125					160	my $score;
180							my $score_return;
181	0					0	my $_tok;
182	125					148	my $return = undef;
183	125					183	my $_matched=0;
184	125					151	my $commit=0;
185	125					185	my @item = ();
186	125					182	my %item = ();
187	125		33			383	my $repeating = defined($_[2]) && $_[2];
188	125		33			338	my $_noactions = defined($_[3]) && $_[3];
189	125	50				263	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	125					143
	125					236
190	125	50				335	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
191	125					155	my $text;
192	125					172	my $lastsep="";
193	125					398	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
194	125					3763	$expectation->at($_[1]);
195
196	125					538	my $thisline;
197	125					729	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
198
199
200
201	125		33			1276	while (!$_matched && !$commit)
202							{
203
204	125	50				280	Parse::RecDescent::_trace(q{Trying production: [/\\n/]},
205							Parse::RecDescent::_tracefirst($_[1]),
206							q{eol},
207							$tracelevel)
208							if defined $::RD_TRACE;
209	125					231	my $thisprod = $thisrule->{"prods"}[0];
210	125					194	$text = $_[1];
211	125					129	my $_savetext;
212	125					252	@item = (q{eol});
213	125					294	%item = (__RULE__ => q{eol});
214	125					167	my $repcount = 0;
215
216
217	125	50				300	Parse::RecDescent::_trace(q{Trying terminal: [/\\n/]}, Parse::RecDescent::_tracefirst($text),
218							q{eol},
219							$tracelevel)
220							if defined $::RD_TRACE;
221	125					158	$lastsep = "";
222	125					353	$expectation->is(q{})->at($text);
223
224
225	125	100	66			1817	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\n)//)
	125	100				1322
226							{
227
228	10					54	$expectation->failed();
229	10	50				61	Parse::RecDescent::_trace(q{<>},
230							Parse::RecDescent::_tracefirst($text))
231							if defined $::RD_TRACE;
232
233	10					28	last;
234							}
235	115	50				292	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
236							. $& . q{])},
237							Parse::RecDescent::_tracefirst($text))
238							if defined $::RD_TRACE;
239	115					336	push @item, $item{__PATTERN1__}=$&;
240
241
242
243	115	50				235	Parse::RecDescent::_trace(q{>>Matched production: [/\\n/]<<},
244							Parse::RecDescent::_tracefirst($text),
245							q{eol},
246							$tracelevel)
247							if defined $::RD_TRACE;
248	115					175	$_matched = 1;
249	115					227	last;
250							}
251
252
253	125	50	66			383	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
254							{
255
256
257	10					36	$_[1] = $text; # NOT SURE THIS IS NEEDED
258	10	50				47	Parse::RecDescent::_trace(q{<>},
259							Parse::RecDescent::_tracefirst($_[1]),
260							q{eol},
261							$tracelevel)
262							if defined $::RD_TRACE;
263	10					88	return undef;
264							}
265	115	50	33			511	if (!defined($return) && defined($score))
266							{
267	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
268							q{eol},
269							$tracelevel)
270							if defined $::RD_TRACE;
271	0					0	$return = $score_return;
272							}
273	115					136	splice @{$thisparser->{errors}}, $err_at;
	115					234
274	115	50				324	$return = $item[$#item] unless defined $return;
275	115	50				224	if (defined $::RD_TRACE)
276							{
277	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
278							$return . q{])}, "",
279							q{eol},
280							$tracelevel);
281	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
282							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
283							Parse::RecDescent::_tracefirst($text),
284							, q{eol},
285							$tracelevel)
286							}
287	115					175	$_[1] = $text;
288	115					1003	return $return;
289							}
290
291							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
292							sub Parse::RecDescent::Config::ApacheExtended::Grammar::skipline
293							{
294	33			33		66	my $thisparser = $_[0];
295	11			11		78	use vars q{$tracelevel};
	11					20
	11					5042
296	33		50			121	local $tracelevel = ($tracelevel\|\|0)+1;
297	33					53	$ERRORS = 0;
298	33					83	my $thisrule = $thisparser->{"rules"}{"skipline"};
299
300	33	50				86	Parse::RecDescent::_trace(q{Trying rule: [skipline]},
301							Parse::RecDescent::_tracefirst($_[1]),
302							q{skipline},
303							$tracelevel)
304							if defined $::RD_TRACE;
305
306
307	33					46	my $err_at = @{$thisparser->{errors}};
	33					68
308
309	33					52	my $score;
310							my $score_return;
311	0					0	my $_tok;
312	33					43	my $return = undef;
313	33					39	my $_matched=0;
314	33					51	my $commit=0;
315	33					57	my @item = ();
316	33					51	my %item = ();
317	33		33			157	my $repeating = defined($_[2]) && $_[2];
318	33		33			112	my $_noactions = defined($_[3]) && $_[3];
319	33	50				81	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	33					47
	33					73
320	33	50				145	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
321	33					43	my $text;
322	33					52	my $lastsep="";
323	33					107	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
324	33					1717	$expectation->at($_[1]);
325
326	33					123	my $thisline;
327	33					173	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
328
329
330
331	33		33			481	while (!$_matched && !$commit)
332							{
333
334	33	50				106	Parse::RecDescent::_trace(q{Trying production: [comment]},
335							Parse::RecDescent::_tracefirst($_[1]),
336							q{skipline},
337							$tracelevel)
338							if defined $::RD_TRACE;
339	33					71	my $thisprod = $thisrule->{"prods"}[0];
340	33					47	$text = $_[1];
341	33					42	my $_savetext;
342	33					65	@item = (q{skipline});
343	33					113	%item = (__RULE__ => q{skipline});
344	33					45	my $repcount = 0;
345
346
347	33	50				81	Parse::RecDescent::_trace(q{Trying subrule: [comment]},
348							Parse::RecDescent::_tracefirst($text),
349							q{skipline},
350							$tracelevel)
351							if defined $::RD_TRACE;
352	11			11		66	if (1) { no strict qw{refs};
	11					21
	11					3949
	33					36
353	33					102	$expectation->is(q{})->at($text);
354	33	50		33		359	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::comment($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	33					71
355							{
356
357	33	50				100	Parse::RecDescent::_trace(q{<>},
358							Parse::RecDescent::_tracefirst($text),
359							q{skipline},
360							$tracelevel)
361							if defined $::RD_TRACE;
362	33					91	$expectation->failed();
363	33					131	last;
364							}
365	0	0				0	Parse::RecDescent::_trace(q{>>Matched subrule: [comment]<< (return value: [}
366							. $_tok . q{]},
367
368							Parse::RecDescent::_tracefirst($text),
369							q{skipline},
370							$tracelevel)
371							if defined $::RD_TRACE;
372	0					0	$item{q{comment}} = $_tok;
373	0					0	push @item, $_tok;
374
375							}
376
377
378	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: [comment]<<},
379							Parse::RecDescent::_tracefirst($text),
380							q{skipline},
381							$tracelevel)
382							if defined $::RD_TRACE;
383	0					0	$_matched = 1;
384	0					0	last;
385							}
386
387
388	33		33			207	while (!$_matched && !$commit)
389							{
390
391	33	50				160	Parse::RecDescent::_trace(q{Trying production: [eol]},
392							Parse::RecDescent::_tracefirst($_[1]),
393							q{skipline},
394							$tracelevel)
395							if defined $::RD_TRACE;
396	33					72	my $thisprod = $thisrule->{"prods"}[1];
397	33					53	$text = $_[1];
398	33					40	my $_savetext;
399	33					77	@item = (q{skipline});
400	33					88	%item = (__RULE__ => q{skipline});
401	33					44	my $repcount = 0;
402
403
404	33	50				90	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
405							Parse::RecDescent::_tracefirst($text),
406							q{skipline},
407							$tracelevel)
408							if defined $::RD_TRACE;
409	11			11		55	if (1) { no strict qw{refs};
	11					19
	11					6945
	33					37
410	33					113	$expectation->is(q{})->at($text);
411	33	100		33		399	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	33					76
412							{
413
414	10	50				43	Parse::RecDescent::_trace(q{<>},
415							Parse::RecDescent::_tracefirst($text),
416							q{skipline},
417							$tracelevel)
418							if defined $::RD_TRACE;
419	10					39	$expectation->failed();
420	10					44	last;
421							}
422	23	50				96	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
423							. $_tok . q{]},
424
425							Parse::RecDescent::_tracefirst($text),
426							q{skipline},
427							$tracelevel)
428							if defined $::RD_TRACE;
429	23					46	$item{q{eol}} = $_tok;
430	23					46	push @item, $_tok;
431
432							}
433
434	23	50				55	Parse::RecDescent::_trace(q{Trying action},
435							Parse::RecDescent::_tracefirst($text),
436							q{skipline},
437							$tracelevel)
438							if defined $::RD_TRACE;
439
440
441	23	50				54	$_tok = ($_noactions) ? 0 : do { 0 };
	23					37
442	23	50				60	unless (defined $_tok)
443							{
444	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
445							if defined $::RD_TRACE;
446	0					0	last;
447							}
448	23	50				51	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
449							. $_tok . q{])},
450							Parse::RecDescent::_tracefirst($text))
451							if defined $::RD_TRACE;
452	23					34	push @item, $_tok;
453	23					55	$item{__ACTION1__}=$_tok;
454
455
456
457	23	50				53	Parse::RecDescent::_trace(q{>>Matched production: [eol]<<},
458							Parse::RecDescent::_tracefirst($text),
459							q{skipline},
460							$tracelevel)
461							if defined $::RD_TRACE;
462	23					49	$_matched = 1;
463	23					38	last;
464							}
465
466
467	33	50	66			214	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
468							{
469
470
471	10					58	$_[1] = $text; # NOT SURE THIS IS NEEDED
472	10	50				66	Parse::RecDescent::_trace(q{<>},
473							Parse::RecDescent::_tracefirst($_[1]),
474							q{skipline},
475							$tracelevel)
476							if defined $::RD_TRACE;
477	10					79	return undef;
478							}
479	23	50	33			126	if (!defined($return) && defined($score))
480							{
481	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
482							q{skipline},
483							$tracelevel)
484							if defined $::RD_TRACE;
485	0					0	$return = $score_return;
486							}
487	23					38	splice @{$thisparser->{errors}}, $err_at;
	23					56
488	23	50				71	$return = $item[$#item] unless defined $return;
489	23	50				55	if (defined $::RD_TRACE)
490							{
491	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
492							$return . q{])}, "",
493							q{skipline},
494							$tracelevel);
495	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
496							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
497							Parse::RecDescent::_tracefirst($text),
498							, q{skipline},
499							$tracelevel)
500							}
501	23					41	$_[1] = $text;
502	23					168	return $return;
503							}
504
505							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
506							sub Parse::RecDescent::Config::ApacheExtended::Grammar::include
507							{
508	109			109		170	my $thisparser = $_[0];
509	11			11		84	use vars q{$tracelevel};
	11					31
	11					7052
510	109		50			289	local $tracelevel = ($tracelevel\|\|0)+1;
511	109					137	$ERRORS = 0;
512	109					214	my $thisrule = $thisparser->{"rules"}{"include"};
513
514	109	50				227	Parse::RecDescent::_trace(q{Trying rule: [include]},
515							Parse::RecDescent::_tracefirst($_[1]),
516							q{include},
517							$tracelevel)
518							if defined $::RD_TRACE;
519
520
521	109					120	my $err_at = @{$thisparser->{errors}};
	109					272
522
523	109					136	my $score;
524							my $score_return;
525	0					0	my $_tok;
526	109					125	my $return = undef;
527	109					120	my $_matched=0;
528	109					118	my $commit=0;
529	109					167	my @item = ();
530	109					160	my %item = ();
531	109		33			308	my $repeating = defined($_[2]) && $_[2];
532	109		33			302	my $_noactions = defined($_[3]) && $_[3];
533	109	50				220	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	109					117
	109					340
534	109	50				453	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
535	109					128	my $text;
536	109					322	my $lastsep="";
537	109					315	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
538	109					3415	$expectation->at($_[1]);
539
540	109					411	my $thisline;
541	109					492	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
542
543
544
545	109		33			1035	while (!$_matched && !$commit)
546							{
547
548	109	50				231	Parse::RecDescent::_trace(q{Trying production: [/\\binclude\\b/i val eol]},
549							Parse::RecDescent::_tracefirst($_[1]),
550							q{include},
551							$tracelevel)
552							if defined $::RD_TRACE;
553	109					200	my $thisprod = $thisrule->{"prods"}[0];
554	109					154	$text = $_[1];
555	109					115	my $_savetext;
556	109					279	@item = (q{include});
557	109					247	%item = (__RULE__ => q{include});
558	109					141	my $repcount = 0;
559
560
561	109	50				287	Parse::RecDescent::_trace(q{Trying terminal: [/\\binclude\\b/i]}, Parse::RecDescent::_tracefirst($text),
562							q{include},
563							$tracelevel)
564							if defined $::RD_TRACE;
565	109					152	$lastsep = "";
566	109					298	$expectation->is(q{})->at($text);
567
568
569	109	100	66			1642	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\binclude\b)//i)
	109	100				1147
570							{
571
572	107					374	$expectation->failed();
573	107	50				504	Parse::RecDescent::_trace(q{<>},
574							Parse::RecDescent::_tracefirst($text))
575							if defined $::RD_TRACE;
576
577	107					217	last;
578							}
579	2	50				7	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
580							. $& . q{])},
581							Parse::RecDescent::_tracefirst($text))
582							if defined $::RD_TRACE;
583	2					8	push @item, $item{__PATTERN1__}=$&;
584
585
586	2	50				7	Parse::RecDescent::_trace(q{Trying subrule: [val]},
587							Parse::RecDescent::_tracefirst($text),
588							q{include},
589							$tracelevel)
590							if defined $::RD_TRACE;
591	11			11		80	if (1) { no strict qw{refs};
	11					42
	11					2950
	2					4
592	2					9	$expectation->is(q{val})->at($text);
593	2	50		2		23	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::val($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	2					4
594							{
595
596	0	0				0	Parse::RecDescent::_trace(q{<>},
597							Parse::RecDescent::_tracefirst($text),
598							q{include},
599							$tracelevel)
600							if defined $::RD_TRACE;
601	0					0	$expectation->failed();
602	0					0	last;
603							}
604	2	50				10	Parse::RecDescent::_trace(q{>>Matched subrule: [val]<< (return value: [}
605							. $_tok . q{]},
606
607							Parse::RecDescent::_tracefirst($text),
608							q{include},
609							$tracelevel)
610							if defined $::RD_TRACE;
611	2					6	$item{q{val}} = $_tok;
612	2					5	push @item, $_tok;
613
614							}
615
616	2	50				6	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
617							Parse::RecDescent::_tracefirst($text),
618							q{include},
619							$tracelevel)
620							if defined $::RD_TRACE;
621	11			11		62	if (1) { no strict qw{refs};
	11					20
	11					9152
	2					3
622	2					10	$expectation->is(q{eol})->at($text);
623	2	50		2		55	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	2					5
624							{
625
626	0	0				0	Parse::RecDescent::_trace(q{<>},
627							Parse::RecDescent::_tracefirst($text),
628							q{include},
629							$tracelevel)
630							if defined $::RD_TRACE;
631	0					0	$expectation->failed();
632	0					0	last;
633							}
634	2	50				11	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
635							. $_tok . q{]},
636
637							Parse::RecDescent::_tracefirst($text),
638							q{include},
639							$tracelevel)
640							if defined $::RD_TRACE;
641	2					5	$item{q{eol}} = $_tok;
642	2					4	push @item, $_tok;
643
644							}
645
646	2	50				11	Parse::RecDescent::_trace(q{Trying action},
647							Parse::RecDescent::_tracefirst($text),
648							q{include},
649							$tracelevel)
650							if defined $::RD_TRACE;
651
652
653	2	50				7	$_tok = ($_noactions) ? 0 : do { if ( $data->include ) { $text = $data->_loadFile($item[2]) . $text; } else { $return = undef; } };
	2	50				9
	2					10
	0					0
654	2	50				8	unless (defined $_tok)
655							{
656	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
657							if defined $::RD_TRACE;
658	0					0	last;
659							}
660	2	50				8	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
661							. $_tok . q{])},
662							Parse::RecDescent::_tracefirst($text))
663							if defined $::RD_TRACE;
664	2					4	push @item, $_tok;
665	2					6	$item{__ACTION1__}=$_tok;
666
667
668
669	2	50				6	Parse::RecDescent::_trace(q{>>Matched production: [/\\binclude\\b/i val eol]<<},
670							Parse::RecDescent::_tracefirst($text),
671							q{include},
672							$tracelevel)
673							if defined $::RD_TRACE;
674	2					3	$_matched = 1;
675	2					6	last;
676							}
677
678
679	109	50	66			799	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
680							{
681
682
683	107					168	$_[1] = $text; # NOT SURE THIS IS NEEDED
684	107	50				211	Parse::RecDescent::_trace(q{<>},
685							Parse::RecDescent::_tracefirst($_[1]),
686							q{include},
687							$tracelevel)
688							if defined $::RD_TRACE;
689	107					918	return undef;
690							}
691	2	50	33			14	if (!defined($return) && defined($score))
692							{
693	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
694							q{include},
695							$tracelevel)
696							if defined $::RD_TRACE;
697	0					0	$return = $score_return;
698							}
699	2					5	splice @{$thisparser->{errors}}, $err_at;
	2					7
700	2	50				8	$return = $item[$#item] unless defined $return;
701	2	50				7	if (defined $::RD_TRACE)
702							{
703	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
704							$return . q{])}, "",
705							q{include},
706							$tracelevel);
707	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
708							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
709							Parse::RecDescent::_tracefirst($text),
710							, q{include},
711							$tracelevel)
712							}
713	2					5	$_[1] = $text;
714	2					21	return $return;
715							}
716
717							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
718							sub Parse::RecDescent::Config::ApacheExtended::Grammar::block_start
719							{
720	92			92		147	my $thisparser = $_[0];
721	11			11		70	use vars q{$tracelevel};
	11					28
	11					8048
722	92		50			264	local $tracelevel = ($tracelevel\|\|0)+1;
723	92					378	$ERRORS = 0;
724	92					185	my $thisrule = $thisparser->{"rules"}{"block_start"};
725
726	92	50				194	Parse::RecDescent::_trace(q{Trying rule: [block_start]},
727							Parse::RecDescent::_tracefirst($_[1]),
728							q{block_start},
729							$tracelevel)
730							if defined $::RD_TRACE;
731
732
733	92					98	my $err_at = @{$thisparser->{errors}};
	92					170
734
735	92					131	my $score;
736							my $score_return;
737	0					0	my $_tok;
738	92					110	my $return = undef;
739	92					106	my $_matched=0;
740	92					103	my $commit=0;
741	92					293	my @item = ();
742	92					324	my %item = ();
743	92		33			282	my $repeating = defined($_[2]) && $_[2];
744	92		33			303	my $_noactions = defined($_[3]) && $_[3];
745	92	50				212	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	92					108
	92					372
746	92	50				263	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
747	92					107	my $text;
748	92					132	my $lastsep="";
749	92					449	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
750	92					3657	$expectation->at($_[1]);
751
752	92					419	my $thisline;
753	92					383	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
754
755
756
757	92		33			888	while (!$_matched && !$commit)
758							{
759
760	92	50				203	Parse::RecDescent::_trace(q{Trying production: ['<' key block_val '>' eol]},
761							Parse::RecDescent::_tracefirst($_[1]),
762							q{block_start},
763							$tracelevel)
764							if defined $::RD_TRACE;
765	92					175	my $thisprod = $thisrule->{"prods"}[0];
766	92					124	$text = $_[1];
767	92					267	my $_savetext;
768	92					170	@item = (q{block_start});
769	92					230	%item = (__RULE__ => q{block_start});
770	92					110	my $repcount = 0;
771
772
773	92	50				189	Parse::RecDescent::_trace(q{Trying terminal: ['<']},
774							Parse::RecDescent::_tracefirst($text),
775							q{block_start},
776							$tracelevel)
777							if defined $::RD_TRACE;
778	92					113	$lastsep = "";
779	92					265	$expectation->is(q{})->at($text);
780
781
782	92	100	66			1085	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\
	92	100				920
783							{
784
785	76					226	$expectation->failed();
786	76	50				346	Parse::RecDescent::_trace(qq{<>},
787							Parse::RecDescent::_tracefirst($text))
788							if defined $::RD_TRACE;
789	76					162	last;
790							}
791	16	50				72	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
792							. $& . q{])},
793							Parse::RecDescent::_tracefirst($text))
794							if defined $::RD_TRACE;
795	16					65	push @item, $item{__STRING1__}=$&;
796
797
798	16	50				113	Parse::RecDescent::_trace(q{Trying subrule: [key]},
799							Parse::RecDescent::_tracefirst($text),
800							q{block_start},
801							$tracelevel)
802							if defined $::RD_TRACE;
803	11			11		74	if (1) { no strict qw{refs};
	11					24
	11					8691
	16					35
804	16					58	$expectation->is(q{key})->at($text);
805	16	100		16		311	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::key($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	16					53
806							{
807
808	8	50				32	Parse::RecDescent::_trace(q{<>},
809							Parse::RecDescent::_tracefirst($text),
810							q{block_start},
811							$tracelevel)
812							if defined $::RD_TRACE;
813	8					32	$expectation->failed();
814	8					72	last;
815							}
816	8	50				40	Parse::RecDescent::_trace(q{>>Matched subrule: [key]<< (return value: [}
817							. $_tok . q{]},
818
819							Parse::RecDescent::_tracefirst($text),
820							q{block_start},
821							$tracelevel)
822							if defined $::RD_TRACE;
823	8					23	$item{q{key}} = $_tok;
824	8					19	push @item, $_tok;
825
826							}
827
828	8	50				27	Parse::RecDescent::_trace(q{Trying repeated subrule: [block_val]},
829							Parse::RecDescent::_tracefirst($text),
830							q{block_start},
831							$tracelevel)
832							if defined $::RD_TRACE;
833	8					41	$expectation->is(q{block_val})->at($text);
834
835	8	50				88	unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::ApacheExtended::Grammar::block_val, 0, 100000000, $_noactions,$expectation,undef)))
836							{
837	0	0				0	Parse::RecDescent::_trace(q{<>},
838							Parse::RecDescent::_tracefirst($text),
839							q{block_start},
840							$tracelevel)
841							if defined $::RD_TRACE;
842	0					0	last;
843							}
844	8	50				189	Parse::RecDescent::_trace(q{>>Matched repeated subrule: [block_val]<< (}
845							. @$_tok . q{ times)},
846
847							Parse::RecDescent::_tracefirst($text),
848							q{block_start},
849							$tracelevel)
850							if defined $::RD_TRACE;
851	8					23	$item{q{block_val(s?)}} = $_tok;
852	8					18	push @item, $_tok;
853
854
855
856	8	50				29	Parse::RecDescent::_trace(q{Trying terminal: ['>']},
857							Parse::RecDescent::_tracefirst($text),
858							q{block_start},
859							$tracelevel)
860							if defined $::RD_TRACE;
861	8					16	$lastsep = "";
862	8					30	$expectation->is(q{'>'})->at($text);
863
864
865	8	50	33			230	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\>//)
	8	50				148
866							{
867
868	0					0	$expectation->failed();
869	0	0				0	Parse::RecDescent::_trace(qq{<>},
870							Parse::RecDescent::_tracefirst($text))
871							if defined $::RD_TRACE;
872	0					0	last;
873							}
874	8	50				37	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
875							. $& . q{])},
876							Parse::RecDescent::_tracefirst($text))
877							if defined $::RD_TRACE;
878	8					37	push @item, $item{__STRING2__}=$&;
879
880
881	8	50				39	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
882							Parse::RecDescent::_tracefirst($text),
883							q{block_start},
884							$tracelevel)
885							if defined $::RD_TRACE;
886	11			11		68	if (1) { no strict qw{refs};
	11					23
	11					9347
	8					13
887	8					36	$expectation->is(q{eol})->at($text);
888	8	50		8		94	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	8					21
889							{
890
891	0	0				0	Parse::RecDescent::_trace(q{<>},
892							Parse::RecDescent::_tracefirst($text),
893							q{block_start},
894							$tracelevel)
895							if defined $::RD_TRACE;
896	0					0	$expectation->failed();
897	0					0	last;
898							}
899	8	50				47	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
900							. $_tok . q{]},
901
902							Parse::RecDescent::_tracefirst($text),
903							q{block_start},
904							$tracelevel)
905							if defined $::RD_TRACE;
906	8					22	$item{q{eol}} = $_tok;
907	8					21	push @item, $_tok;
908
909							}
910
911	8	50				28	Parse::RecDescent::_trace(q{Trying action},
912							Parse::RecDescent::_tracefirst($text),
913							q{block_start},
914							$tracelevel)
915							if defined $::RD_TRACE;
916
917
918	8	50				37	$_tok = ($_noactions) ? 0 : do { $return = $data->beginBlock($item[2], $item[3]) };
	8					64
919	8	50				33	unless (defined $_tok)
920							{
921	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
922							if defined $::RD_TRACE;
923	0					0	last;
924							}
925	8	50				27	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
926							. $_tok . q{])},
927							Parse::RecDescent::_tracefirst($text))
928							if defined $::RD_TRACE;
929	8					36	push @item, $_tok;
930	8					23	$item{__ACTION1__}=$_tok;
931
932
933
934	8	50				37	Parse::RecDescent::_trace(q{>>Matched production: ['<' key block_val '>' eol]<<},
935							Parse::RecDescent::_tracefirst($text),
936							q{block_start},
937							$tracelevel)
938							if defined $::RD_TRACE;
939	8					15	$_matched = 1;
940	8					22	last;
941							}
942
943
944	92	50	66			629	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
945							{
946
947
948	84					130	$_[1] = $text; # NOT SURE THIS IS NEEDED
949	84	50				189	Parse::RecDescent::_trace(q{<>},
950							Parse::RecDescent::_tracefirst($_[1]),
951							q{block_start},
952							$tracelevel)
953							if defined $::RD_TRACE;
954	84					588	return undef;
955							}
956	8	50	33			35	if (!defined($return) && defined($score))
957							{
958	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
959							q{block_start},
960							$tracelevel)
961							if defined $::RD_TRACE;
962	0					0	$return = $score_return;
963							}
964	8					22	splice @{$thisparser->{errors}}, $err_at;
	8					20
965	8	50				38	$return = $item[$#item] unless defined $return;
966	8	50				34	if (defined $::RD_TRACE)
967							{
968	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
969							$return . q{])}, "",
970							q{block_start},
971							$tracelevel);
972	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
973							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
974							Parse::RecDescent::_tracefirst($text),
975							, q{block_start},
976							$tracelevel)
977							}
978	8					18	$_[1] = $text;
979	8					88	return $return;
980							}
981
982							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
983							sub Parse::RecDescent::Config::ApacheExtended::Grammar::key
984							{
985	244			244		458	my $thisparser = $_[0];
986	11			11		68	use vars q{$tracelevel};
	11					19
	11					11323
987	244		50			622	local $tracelevel = ($tracelevel\|\|0)+1;
988	244					279	$ERRORS = 0;
989	244					418	my $thisrule = $thisparser->{"rules"}{"key"};
990
991	244	50				460	Parse::RecDescent::_trace(q{Trying rule: [key]},
992							Parse::RecDescent::_tracefirst($_[1]),
993							q{key},
994							$tracelevel)
995							if defined $::RD_TRACE;
996
997
998	244					246	my $err_at = @{$thisparser->{errors}};
	244					419
999
1000	244					290	my $score;
1001							my $score_return;
1002	0					0	my $_tok;
1003	244					260	my $return = undef;
1004	244					254	my $_matched=0;
1005	244					247	my $commit=0;
1006	244					332	my @item = ();
1007	244					332	my %item = ();
1008	244		33			683	my $repeating = defined($_[2]) && $_[2];
1009	244		33			647	my $_noactions = defined($_[3]) && $_[3];
1010	244	50				455	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	244					287
	244					492
1011	244	50				601	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1012	244					327	my $text;
1013	244					429	my $lastsep="";
1014	244					643	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1015	244					6970	$expectation->at($_[1]);
1016
1017	244					951	my $thisline;
1018	244					991	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1019
1020
1021
1022	244		33			2295	while (!$_matched && !$commit)
1023							{
1024
1025	244	50				551	Parse::RecDescent::_trace(q{Trying production: [/\\w+/]},
1026							Parse::RecDescent::_tracefirst($_[1]),
1027							q{key},
1028							$tracelevel)
1029							if defined $::RD_TRACE;
1030	244					395	my $thisprod = $thisrule->{"prods"}[0];
1031	244					359	$text = $_[1];
1032	244					248	my $_savetext;
1033	244					402	@item = (q{key});
1034	244					466	%item = (__RULE__ => q{key});
1035	244					272	my $repcount = 0;
1036
1037
1038	244	50				464	Parse::RecDescent::_trace(q{Trying terminal: [/\\w+/]}, Parse::RecDescent::_tracefirst($text),
1039							q{key},
1040							$tracelevel)
1041							if defined $::RD_TRACE;
1042	244					292	$lastsep = "";
1043	244					602	$expectation->is(q{})->at($text);
1044
1045
1046	244	100	66			2649	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\w+)//)
	244	100				2444
1047							{
1048
1049	120					467	$expectation->failed();
1050	120	50				547	Parse::RecDescent::_trace(q{<>},
1051							Parse::RecDescent::_tracefirst($text))
1052							if defined $::RD_TRACE;
1053
1054	120					234	last;
1055							}
1056	124	50				318	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1057							. $& . q{])},
1058							Parse::RecDescent::_tracefirst($text))
1059							if defined $::RD_TRACE;
1060	124					501	push @item, $item{__PATTERN1__}=$&;
1061
1062
1063
1064	124	50				416	Parse::RecDescent::_trace(q{>>Matched production: [/\\w+/]<<},
1065							Parse::RecDescent::_tracefirst($text),
1066							q{key},
1067							$tracelevel)
1068							if defined $::RD_TRACE;
1069	124					137	$_matched = 1;
1070	124					239	last;
1071							}
1072
1073
1074	244	50	66			1157	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
1075							{
1076
1077
1078	120					216	$_[1] = $text; # NOT SURE THIS IS NEEDED
1079	120	50				241	Parse::RecDescent::_trace(q{<>},
1080							Parse::RecDescent::_tracefirst($_[1]),
1081							q{key},
1082							$tracelevel)
1083							if defined $::RD_TRACE;
1084	120					905	return undef;
1085							}
1086	124	50	33			516	if (!defined($return) && defined($score))
1087							{
1088	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1089							q{key},
1090							$tracelevel)
1091							if defined $::RD_TRACE;
1092	0					0	$return = $score_return;
1093							}
1094	124					218	splice @{$thisparser->{errors}}, $err_at;
	124					270
1095	124	50				435	$return = $item[$#item] unless defined $return;
1096	124	50				259	if (defined $::RD_TRACE)
1097							{
1098	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1099							$return . q{])}, "",
1100							q{key},
1101							$tracelevel);
1102	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1103							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1104							Parse::RecDescent::_tracefirst($text),
1105							, q{key},
1106							$tracelevel)
1107							}
1108	124					193	$_[1] = $text;
1109	124					1187	return $return;
1110							}
1111
1112							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1113							sub Parse::RecDescent::Config::ApacheExtended::Grammar::statement
1114							{
1115	109			109		1607	my $thisparser = $_[0];
1116	11			11		71	use vars q{$tracelevel};
	11					20
	11					6652
1117	109		50			293	local $tracelevel = ($tracelevel\|\|0)+1;
1118	109					139	$ERRORS = 0;
1119	109					248	my $thisrule = $thisparser->{"rules"}{"statement"};
1120
1121	109	50				241	Parse::RecDescent::_trace(q{Trying rule: [statement]},
1122							Parse::RecDescent::_tracefirst($_[1]),
1123							q{statement},
1124							$tracelevel)
1125							if defined $::RD_TRACE;
1126
1127
1128	109					118	my $err_at = @{$thisparser->{errors}};
	109					202
1129
1130	109					147	my $score;
1131							my $score_return;
1132	0					0	my $_tok;
1133	109					130	my $return = undef;
1134	109					137	my $_matched=0;
1135	109					126	my $commit=0;
1136	109					171	my @item = ();
1137	109					172	my %item = ();
1138	109		33			398	my $repeating = defined($_[2]) && $_[2];
1139	109		33			327	my $_noactions = defined($_[3]) && $_[3];
1140	109	50				422	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	0					0
	0					0
1141	109	50				294	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1142	109					129	my $text;
1143	109					150	my $lastsep="";
1144	109					380	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1145	109					3141	$expectation->at($_[1]);
1146
1147	109					402	my $thisline;
1148	109					512	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1149
1150
1151
1152	109		33			1053	while (!$_matched && !$commit)
1153							{
1154	109	50				329	local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
1155	109	50				242	Parse::RecDescent::_trace(q{Trying production: [ include, or multiline_directive, or hereto_directive, or block_start, or block_end, or directive, or skipline]},
1156							Parse::RecDescent::_tracefirst($_[1]),
1157							q{statement},
1158							$tracelevel)
1159							if defined $::RD_TRACE;
1160	109					191	my $thisprod = $thisrule->{"prods"}[0];
1161	109					138	$text = $_[1];
1162	109					121	my $_savetext;
1163	109					193	@item = (q{statement});
1164	109					226	%item = (__RULE__ => q{statement});
1165	109					193	my $repcount = 0;
1166
1167
1168
1169
1170	109	50				255	Parse::RecDescent::_trace(q{Trying directive: []},
1171							Parse::RecDescent::_tracefirst($text),
1172							q{statement},
1173							$tracelevel)
1174							if defined $::RD_TRACE;
1175	109					119	$_tok = do { my $oldskip = $skip; $skip= qr/[ \t]*/; $oldskip };
	109					147
	109					426
	109					208
1176	109	50				228	if (defined($_tok))
1177							{
1178	109	50				247	Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
1179							. $_tok . q{])},
1180							Parse::RecDescent::_tracefirst($text))
1181							if defined $::RD_TRACE;
1182							}
1183							else
1184							{
1185	0	0				0	Parse::RecDescent::_trace(q{<>},
1186							Parse::RecDescent::_tracefirst($text))
1187							if defined $::RD_TRACE;
1188							}
1189
1190	109	50				226	last unless defined $_tok;
1191	109					308	push @item, $item{__DIRECTIVE1__}=$_tok;
1192
1193
1194	109	50				218	Parse::RecDescent::_trace(q{Trying subrule: [_alternation_1_of_production_1_of_rule_statement]},
1195							Parse::RecDescent::_tracefirst($text),
1196							q{statement},
1197							$tracelevel)
1198							if defined $::RD_TRACE;
1199	11			11		66	if (1) { no strict qw{refs};
	11					22
	11					6629
	109					117
1200	109					313	$expectation->is(q{include, or multiline_directive, or hereto_directive, or block_start, or block_end, or directive, or skipline})->at($text);
1201	109	100		109		1018	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::_alternation_1_of_production_1_of_rule_statement($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	109					227
1202							{
1203
1204	10	50				36	Parse::RecDescent::_trace(q{<>},
1205							Parse::RecDescent::_tracefirst($text),
1206							q{statement},
1207							$tracelevel)
1208							if defined $::RD_TRACE;
1209	10					39	$expectation->failed();
1210	10					109	last;
1211							}
1212	99	50				388	Parse::RecDescent::_trace(q{>>Matched subrule: [_alternation_1_of_production_1_of_rule_statement]<< (return value: [}
1213							. $_tok . q{]},
1214
1215							Parse::RecDescent::_tracefirst($text),
1216							q{statement},
1217							$tracelevel)
1218							if defined $::RD_TRACE;
1219	99					190	$item{q{_alternation_1_of_production_1_of_rule_statement}} = $_tok;
1220	99					160	push @item, $_tok;
1221
1222							}
1223
1224
1225	99	50				248	Parse::RecDescent::_trace(q{>>Matched production: [ include, or multiline_directive, or hereto_directive, or block_start, or block_end, or directive, or skipline]<<},
1226							Parse::RecDescent::_tracefirst($text),
1227							q{statement},
1228							$tracelevel)
1229							if defined $::RD_TRACE;
1230	99					119	$_matched = 1;
1231	99					264	last;
1232							}
1233
1234
1235	109	50	66			400	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
1236							{
1237
1238
1239	10					20	$_[1] = $text; # NOT SURE THIS IS NEEDED
1240	10	50				39	Parse::RecDescent::_trace(q{<>},
1241							Parse::RecDescent::_tracefirst($_[1]),
1242							q{statement},
1243							$tracelevel)
1244							if defined $::RD_TRACE;
1245	10					78	return undef;
1246							}
1247	99	50	33			446	if (!defined($return) && defined($score))
1248							{
1249	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1250							q{statement},
1251							$tracelevel)
1252							if defined $::RD_TRACE;
1253	0					0	$return = $score_return;
1254							}
1255	99					123	splice @{$thisparser->{errors}}, $err_at;
	99					205
1256	99	50				385	$return = $item[$#item] unless defined $return;
1257	99	50				217	if (defined $::RD_TRACE)
1258							{
1259	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1260							$return . q{])}, "",
1261							q{statement},
1262							$tracelevel);
1263	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1264							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1265							Parse::RecDescent::_tracefirst($text),
1266							, q{statement},
1267							$tracelevel)
1268							}
1269	99					159	$_[1] = $text;
1270	99					711	return $return;
1271							}
1272
1273							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1274							sub Parse::RecDescent::Config::ApacheExtended::Grammar::quote
1275							{
1276	141			141		195	my $thisparser = $_[0];
1277	11			11		66	use vars q{$tracelevel};
	11					22
	11					12276
1278	141		50			362	local $tracelevel = ($tracelevel\|\|0)+1;
1279	141					165	$ERRORS = 0;
1280	141					513	my $thisrule = $thisparser->{"rules"}{"quote"};
1281
1282	141	50				288	Parse::RecDescent::_trace(q{Trying rule: [quote]},
1283							Parse::RecDescent::_tracefirst($_[1]),
1284							q{quote},
1285							$tracelevel)
1286							if defined $::RD_TRACE;
1287
1288
1289	141					144	my $err_at = @{$thisparser->{errors}};
	141					247
1290
1291	141					168	my $score;
1292							my $score_return;
1293	0					0	my $_tok;
1294	141					157	my $return = undef;
1295	141					160	my $_matched=0;
1296	141					159	my $commit=0;
1297	141					197	my @item = ();
1298	141					192	my %item = ();
1299	141		33			435	my $repeating = defined($_[2]) && $_[2];
1300	141		33			406	my $_noactions = defined($_[3]) && $_[3];
1301	141	50				308	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	141					153
	141					282
1302	141	50				346	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1303	141					169	my $text;
1304	141					197	my $lastsep="";
1305	141					392	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1306	141					4143	$expectation->at($_[1]);
1307
1308	141					572	my $thisline;
1309	141					562	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1310
1311
1312
1313	141		33			6551	while (!$_matched && !$commit)
1314							{
1315
1316	141	50				517	Parse::RecDescent::_trace(q{Trying production: [/(['"])(.*?)(?
1317							Parse::RecDescent::_tracefirst($_[1]),
1318							q{quote},
1319							$tracelevel)
1320							if defined $::RD_TRACE;
1321	141					259	my $thisprod = $thisrule->{"prods"}[0];
1322	141					185	$text = $_[1];
1323	141					160	my $_savetext;
1324	141					285	@item = (q{quote});
1325	141					303	%item = (__RULE__ => q{quote});
1326	141					184	my $repcount = 0;
1327
1328
1329	141	50				313	Parse::RecDescent::_trace(q{Trying terminal: [/(['"])(.*?)(?
1330							q{quote},
1331							$tracelevel)
1332							if defined $::RD_TRACE;
1333	141					179	$lastsep = "";
1334	141					378	$expectation->is(q{})->at($text);
1335
1336
1337	141	100	66			1876	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(['"])(.*?)(?
	141	100				1662
1338							{
1339
1340	114					304	$expectation->failed();
1341	114	50				612	Parse::RecDescent::_trace(q{<>},
1342							Parse::RecDescent::_tracefirst($text))
1343							if defined $::RD_TRACE;
1344
1345	114					227	last;
1346							}
1347	27	50				87	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1348							. $& . q{])},
1349							Parse::RecDescent::_tracefirst($text))
1350							if defined $::RD_TRACE;
1351	27					87	push @item, $item{__PATTERN1__}=$&;
1352
1353
1354	27	50				74	Parse::RecDescent::_trace(q{Trying action},
1355							Parse::RecDescent::_tracefirst($text),
1356							q{quote},
1357							$tracelevel)
1358							if defined $::RD_TRACE;
1359
1360
1361	27	50				71	$_tok = ($_noactions) ? 0 : do { $2 };
	27					75
1362	27	50				110	unless (defined $_tok)
1363							{
1364	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1365							if defined $::RD_TRACE;
1366	0					0	last;
1367							}
1368	27	50				75	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1369							. $_tok . q{])},
1370							Parse::RecDescent::_tracefirst($text))
1371							if defined $::RD_TRACE;
1372	27					39	push @item, $_tok;
1373	27					62	$item{__ACTION1__}=$_tok;
1374
1375
1376
1377	27	50				81	Parse::RecDescent::_trace(q{>>Matched production: [/(['"])(.*?)(?
1378							Parse::RecDescent::_tracefirst($text),
1379							q{quote},
1380							$tracelevel)
1381							if defined $::RD_TRACE;
1382	27					39	$_matched = 1;
1383	27					56	last;
1384							}
1385
1386
1387	141	50	66			888	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
1388							{
1389
1390
1391	114					167	$_[1] = $text; # NOT SURE THIS IS NEEDED
1392	114	50				238	Parse::RecDescent::_trace(q{<>},
1393							Parse::RecDescent::_tracefirst($_[1]),
1394							q{quote},
1395							$tracelevel)
1396							if defined $::RD_TRACE;
1397	114					833	return undef;
1398							}
1399	27	50	33			167	if (!defined($return) && defined($score))
1400							{
1401	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1402							q{quote},
1403							$tracelevel)
1404							if defined $::RD_TRACE;
1405	0					0	$return = $score_return;
1406							}
1407	27					43	splice @{$thisparser->{errors}}, $err_at;
	27					69
1408	27	50				88	$return = $item[$#item] unless defined $return;
1409	27	50				68	if (defined $::RD_TRACE)
1410							{
1411	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1412							$return . q{])}, "",
1413							q{quote},
1414							$tracelevel);
1415	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1416							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1417							Parse::RecDescent::_tracefirst($text),
1418							, q{quote},
1419							$tracelevel)
1420							}
1421	27					50	$_[1] = $text;
1422	27					236	return $return;
1423							}
1424
1425							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1426							sub Parse::RecDescent::Config::ApacheExtended::Grammar::_alternation_1_of_production_1_of_rule_statement
1427							{
1428	109			109		153	my $thisparser = $_[0];
1429	11			11		77	use vars q{$tracelevel};
	11					21
	11					5655
1430	109		50			288	local $tracelevel = ($tracelevel\|\|0)+1;
1431	109					131	$ERRORS = 0;
1432	109					214	my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_1_of_rule_statement"};
1433
1434	109	50				214	Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_statement]},
1435							Parse::RecDescent::_tracefirst($_[1]),
1436							q{_alternation_1_of_production_1_of_rule_statement},
1437							$tracelevel)
1438							if defined $::RD_TRACE;
1439
1440
1441	109					118	my $err_at = @{$thisparser->{errors}};
	109					198
1442
1443	109					133	my $score;
1444							my $score_return;
1445	0					0	my $_tok;
1446	109					129	my $return = undef;
1447	109					131	my $_matched=0;
1448	109					130	my $commit=0;
1449	109					161	my @item = ();
1450	109					173	my %item = ();
1451	109		33			340	my $repeating = defined($_[2]) && $_[2];
1452	109		33			321	my $_noactions = defined($_[3]) && $_[3];
1453	109	50				211	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	109					127
	109					218
1454	109	50				302	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1455	109					136	my $text;
1456	109					147	my $lastsep="";
1457	109					311	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1458	109					20272	$expectation->at($_[1]);
1459
1460	109					433	my $thisline;
1461	109					690	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1462
1463
1464
1465	109		33			2076	while (!$_matched && !$commit)
1466							{
1467
1468	109	50				238	Parse::RecDescent::_trace(q{Trying production: [include]},
1469							Parse::RecDescent::_tracefirst($_[1]),
1470							q{_alternation_1_of_production_1_of_rule_statement},
1471							$tracelevel)
1472							if defined $::RD_TRACE;
1473	109					187	my $thisprod = $thisrule->{"prods"}[0];
1474	109					153	$text = $_[1];
1475	109					138	my $_savetext;
1476	109					331	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1477	109					222	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1478	109					143	my $repcount = 0;
1479
1480
1481	109	50				228	Parse::RecDescent::_trace(q{Trying subrule: [include]},
1482							Parse::RecDescent::_tracefirst($text),
1483							q{_alternation_1_of_production_1_of_rule_statement},
1484							$tracelevel)
1485							if defined $::RD_TRACE;
1486	11			11		65	if (1) { no strict qw{refs};
	11					22
	11					13802
	109					129
1487	109					292	$expectation->is(q{})->at($text);
1488	109	100		109		1086	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::include($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	109					245
1489							{
1490
1491	107	50				221	Parse::RecDescent::_trace(q{<>},
1492							Parse::RecDescent::_tracefirst($text),
1493							q{_alternation_1_of_production_1_of_rule_statement},
1494							$tracelevel)
1495							if defined $::RD_TRACE;
1496	107					330	$expectation->failed();
1497	107					424	last;
1498							}
1499	2	50				13	Parse::RecDescent::_trace(q{>>Matched subrule: [include]<< (return value: [}
1500							. $_tok . q{]},
1501
1502							Parse::RecDescent::_tracefirst($text),
1503							q{_alternation_1_of_production_1_of_rule_statement},
1504							$tracelevel)
1505							if defined $::RD_TRACE;
1506	2					4	$item{q{include}} = $_tok;
1507	2					5	push @item, $_tok;
1508
1509							}
1510
1511
1512	2	50				7	Parse::RecDescent::_trace(q{>>Matched production: [include]<<},
1513							Parse::RecDescent::_tracefirst($text),
1514							q{_alternation_1_of_production_1_of_rule_statement},
1515							$tracelevel)
1516							if defined $::RD_TRACE;
1517	2					5	$_matched = 1;
1518	2					4	last;
1519							}
1520
1521
1522	109		66			709	while (!$_matched && !$commit)
1523							{
1524
1525	107	50				234	Parse::RecDescent::_trace(q{Trying production: [multiline_directive]},
1526							Parse::RecDescent::_tracefirst($_[1]),
1527							q{_alternation_1_of_production_1_of_rule_statement},
1528							$tracelevel)
1529							if defined $::RD_TRACE;
1530	107					234	my $thisprod = $thisrule->{"prods"}[1];
1531	107					181	$text = $_[1];
1532	107					134	my $_savetext;
1533	107					211	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1534	107					225	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1535	107					142	my $repcount = 0;
1536
1537
1538	107	50				233	Parse::RecDescent::_trace(q{Trying subrule: [multiline_directive]},
1539							Parse::RecDescent::_tracefirst($text),
1540							q{_alternation_1_of_production_1_of_rule_statement},
1541							$tracelevel)
1542							if defined $::RD_TRACE;
1543	11			11		77	if (1) { no strict qw{refs};
	11					20
	11					4276
	107					123
1544	107					291	$expectation->is(q{})->at($text);
1545	107	100		107		1050	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::multiline_directive($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	107					227
1546							{
1547
1548	97	50				209	Parse::RecDescent::_trace(q{<>},
1549							Parse::RecDescent::_tracefirst($text),
1550							q{_alternation_1_of_production_1_of_rule_statement},
1551							$tracelevel)
1552							if defined $::RD_TRACE;
1553	97					391	$expectation->failed();
1554	97					380	last;
1555							}
1556	10	50				44	Parse::RecDescent::_trace(q{>>Matched subrule: [multiline_directive]<< (return value: [}
1557							. $_tok . q{]},
1558
1559							Parse::RecDescent::_tracefirst($text),
1560							q{_alternation_1_of_production_1_of_rule_statement},
1561							$tracelevel)
1562							if defined $::RD_TRACE;
1563	10					24	$item{q{multiline_directive}} = $_tok;
1564	10					20	push @item, $_tok;
1565
1566							}
1567
1568
1569	10	50				26	Parse::RecDescent::_trace(q{>>Matched production: [multiline_directive]<<},
1570							Parse::RecDescent::_tracefirst($text),
1571							q{_alternation_1_of_production_1_of_rule_statement},
1572							$tracelevel)
1573							if defined $::RD_TRACE;
1574	10					16	$_matched = 1;
1575	10					16	last;
1576							}
1577
1578
1579	109		66			575	while (!$_matched && !$commit)
1580							{
1581
1582	97	50				219	Parse::RecDescent::_trace(q{Trying production: [hereto_directive]},
1583							Parse::RecDescent::_tracefirst($_[1]),
1584							q{_alternation_1_of_production_1_of_rule_statement},
1585							$tracelevel)
1586							if defined $::RD_TRACE;
1587	97					194	my $thisprod = $thisrule->{"prods"}[2];
1588	97					165	$text = $_[1];
1589	97					127	my $_savetext;
1590	97					185	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1591	97					229	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1592	97					148	my $repcount = 0;
1593
1594
1595	97	50				215	Parse::RecDescent::_trace(q{Trying subrule: [hereto_directive]},
1596							Parse::RecDescent::_tracefirst($text),
1597							q{_alternation_1_of_production_1_of_rule_statement},
1598							$tracelevel)
1599							if defined $::RD_TRACE;
1600	11			11		61	if (1) { no strict qw{refs};
	11					25
	11					3989
	97					105
1601	97					295	$expectation->is(q{})->at($text);
1602	97	100		97		990	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::hereto_directive($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	97					206
1603							{
1604
1605	92	50				188	Parse::RecDescent::_trace(q{<>},
1606							Parse::RecDescent::_tracefirst($text),
1607							q{_alternation_1_of_production_1_of_rule_statement},
1608							$tracelevel)
1609							if defined $::RD_TRACE;
1610	92					267	$expectation->failed();
1611	92					531	last;
1612							}
1613	5	50				26	Parse::RecDescent::_trace(q{>>Matched subrule: [hereto_directive]<< (return value: [}
1614							. $_tok . q{]},
1615
1616							Parse::RecDescent::_tracefirst($text),
1617							q{_alternation_1_of_production_1_of_rule_statement},
1618							$tracelevel)
1619							if defined $::RD_TRACE;
1620	5					12	$item{q{hereto_directive}} = $_tok;
1621	5					11	push @item, $_tok;
1622
1623							}
1624
1625
1626	5	50				24	Parse::RecDescent::_trace(q{>>Matched production: [hereto_directive]<<},
1627							Parse::RecDescent::_tracefirst($text),
1628							q{_alternation_1_of_production_1_of_rule_statement},
1629							$tracelevel)
1630							if defined $::RD_TRACE;
1631	5					8	$_matched = 1;
1632	5					10	last;
1633							}
1634
1635
1636	109		66			511	while (!$_matched && !$commit)
1637							{
1638
1639	92	50				193	Parse::RecDescent::_trace(q{Trying production: [block_start]},
1640							Parse::RecDescent::_tracefirst($_[1]),
1641							q{_alternation_1_of_production_1_of_rule_statement},
1642							$tracelevel)
1643							if defined $::RD_TRACE;
1644	92					192	my $thisprod = $thisrule->{"prods"}[3];
1645	92					341	$text = $_[1];
1646	92					101	my $_savetext;
1647	92					173	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1648	92					209	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1649	92					106	my $repcount = 0;
1650
1651
1652	92	50				192	Parse::RecDescent::_trace(q{Trying subrule: [block_start]},
1653							Parse::RecDescent::_tracefirst($text),
1654							q{_alternation_1_of_production_1_of_rule_statement},
1655							$tracelevel)
1656							if defined $::RD_TRACE;
1657	11			11		61	if (1) { no strict qw{refs};
	11					22
	11					6343
	92					115
1658	92					451	$expectation->is(q{})->at($text);
1659	92	100		92		932	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::block_start($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	92					201
1660							{
1661
1662	84	50				180	Parse::RecDescent::_trace(q{<>},
1663							Parse::RecDescent::_tracefirst($text),
1664							q{_alternation_1_of_production_1_of_rule_statement},
1665							$tracelevel)
1666							if defined $::RD_TRACE;
1667	84					229	$expectation->failed();
1668	84					325	last;
1669							}
1670	8	50				48	Parse::RecDescent::_trace(q{>>Matched subrule: [block_start]<< (return value: [}
1671							. $_tok . q{]},
1672
1673							Parse::RecDescent::_tracefirst($text),
1674							q{_alternation_1_of_production_1_of_rule_statement},
1675							$tracelevel)
1676							if defined $::RD_TRACE;
1677	8					21	$item{q{block_start}} = $_tok;
1678	8					16	push @item, $_tok;
1679
1680							}
1681
1682
1683	8	50				27	Parse::RecDescent::_trace(q{>>Matched production: [block_start]<<},
1684							Parse::RecDescent::_tracefirst($text),
1685							q{_alternation_1_of_production_1_of_rule_statement},
1686							$tracelevel)
1687							if defined $::RD_TRACE;
1688	8					12	$_matched = 1;
1689	8					28	last;
1690							}
1691
1692
1693	109		66			515	while (!$_matched && !$commit)
1694							{
1695
1696	84	50				180	Parse::RecDescent::_trace(q{Trying production: [block_end]},
1697							Parse::RecDescent::_tracefirst($_[1]),
1698							q{_alternation_1_of_production_1_of_rule_statement},
1699							$tracelevel)
1700							if defined $::RD_TRACE;
1701	84					164	my $thisprod = $thisrule->{"prods"}[4];
1702	84					138	$text = $_[1];
1703	84					109	my $_savetext;
1704	84					177	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1705	84					185	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1706	84					110	my $repcount = 0;
1707
1708
1709	84	50				192	Parse::RecDescent::_trace(q{Trying subrule: [block_end]},
1710							Parse::RecDescent::_tracefirst($text),
1711							q{_alternation_1_of_production_1_of_rule_statement},
1712							$tracelevel)
1713							if defined $::RD_TRACE;
1714	11			11		62	if (1) { no strict qw{refs};
	11					18
	11					4387
	84					94
1715	84					226	$expectation->is(q{})->at($text);
1716	84	100		84		852	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::block_end($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	84					175
1717							{
1718
1719	76	50				168	Parse::RecDescent::_trace(q{<>},
1720							Parse::RecDescent::_tracefirst($text),
1721							q{_alternation_1_of_production_1_of_rule_statement},
1722							$tracelevel)
1723							if defined $::RD_TRACE;
1724	76					246	$expectation->failed();
1725	76					291	last;
1726							}
1727	8	50				43	Parse::RecDescent::_trace(q{>>Matched subrule: [block_end]<< (return value: [}
1728							. $_tok . q{]},
1729
1730							Parse::RecDescent::_tracefirst($text),
1731							q{_alternation_1_of_production_1_of_rule_statement},
1732							$tracelevel)
1733							if defined $::RD_TRACE;
1734	8					33	$item{q{block_end}} = $_tok;
1735	8					16	push @item, $_tok;
1736
1737							}
1738
1739
1740	8	50				33	Parse::RecDescent::_trace(q{>>Matched production: [block_end]<<},
1741							Parse::RecDescent::_tracefirst($text),
1742							q{_alternation_1_of_production_1_of_rule_statement},
1743							$tracelevel)
1744							if defined $::RD_TRACE;
1745	8					15	$_matched = 1;
1746	8					14	last;
1747							}
1748
1749
1750	109		66			471	while (!$_matched && !$commit)
1751							{
1752
1753	76	50				169	Parse::RecDescent::_trace(q{Trying production: [directive]},
1754							Parse::RecDescent::_tracefirst($_[1]),
1755							q{_alternation_1_of_production_1_of_rule_statement},
1756							$tracelevel)
1757							if defined $::RD_TRACE;
1758	76					158	my $thisprod = $thisrule->{"prods"}[5];
1759	76					114	$text = $_[1];
1760	76					86	my $_savetext;
1761	76					152	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1762	76					187	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1763	76					100	my $repcount = 0;
1764
1765
1766	76	50				167	Parse::RecDescent::_trace(q{Trying subrule: [directive]},
1767							Parse::RecDescent::_tracefirst($text),
1768							q{_alternation_1_of_production_1_of_rule_statement},
1769							$tracelevel)
1770							if defined $::RD_TRACE;
1771	11			11		58	if (1) { no strict qw{refs};
	11					19
	11					4418
	76					87
1772	76					264	$expectation->is(q{})->at($text);
1773	76	100		76		785	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::directive($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	76					186
1774							{
1775
1776	33	50				86	Parse::RecDescent::_trace(q{<>},
1777							Parse::RecDescent::_tracefirst($text),
1778							q{_alternation_1_of_production_1_of_rule_statement},
1779							$tracelevel)
1780							if defined $::RD_TRACE;
1781	33					100	$expectation->failed();
1782	33					128	last;
1783							}
1784	43	50				251	Parse::RecDescent::_trace(q{>>Matched subrule: [directive]<< (return value: [}
1785							. $_tok . q{]},
1786
1787							Parse::RecDescent::_tracefirst($text),
1788							q{_alternation_1_of_production_1_of_rule_statement},
1789							$tracelevel)
1790							if defined $::RD_TRACE;
1791	43					83	$item{q{directive}} = $_tok;
1792	43					74	push @item, $_tok;
1793
1794							}
1795
1796
1797	43	50				90	Parse::RecDescent::_trace(q{>>Matched production: [directive]<<},
1798							Parse::RecDescent::_tracefirst($text),
1799							q{_alternation_1_of_production_1_of_rule_statement},
1800							$tracelevel)
1801							if defined $::RD_TRACE;
1802	43					68	$_matched = 1;
1803	43					85	last;
1804							}
1805
1806
1807	109		66			379	while (!$_matched && !$commit)
1808							{
1809
1810	33	50				94	Parse::RecDescent::_trace(q{Trying production: [skipline]},
1811							Parse::RecDescent::_tracefirst($_[1]),
1812							q{_alternation_1_of_production_1_of_rule_statement},
1813							$tracelevel)
1814							if defined $::RD_TRACE;
1815	33					76	my $thisprod = $thisrule->{"prods"}[6];
1816	33					56	$text = $_[1];
1817	33					45	my $_savetext;
1818	33					70	@item = (q{_alternation_1_of_production_1_of_rule_statement});
1819	33					91	%item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_statement});
1820	33					53	my $repcount = 0;
1821
1822
1823	33	50				85	Parse::RecDescent::_trace(q{Trying subrule: [skipline]},
1824							Parse::RecDescent::_tracefirst($text),
1825							q{_alternation_1_of_production_1_of_rule_statement},
1826							$tracelevel)
1827							if defined $::RD_TRACE;
1828	11			11		59	if (1) { no strict qw{refs};
	11					18
	11					7711
	33					37
1829	33					107	$expectation->is(q{})->at($text);
1830	33	100		33		365	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::skipline($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	33					85
1831							{
1832
1833	10	50				35	Parse::RecDescent::_trace(q{<>},
1834							Parse::RecDescent::_tracefirst($text),
1835							q{_alternation_1_of_production_1_of_rule_statement},
1836							$tracelevel)
1837							if defined $::RD_TRACE;
1838	10					47	$expectation->failed();
1839	10					42	last;
1840							}
1841	23	50				97	Parse::RecDescent::_trace(q{>>Matched subrule: [skipline]<< (return value: [}
1842							. $_tok . q{]},
1843
1844							Parse::RecDescent::_tracefirst($text),
1845							q{_alternation_1_of_production_1_of_rule_statement},
1846							$tracelevel)
1847							if defined $::RD_TRACE;
1848	23					45	$item{q{skipline}} = $_tok;
1849	23					37	push @item, $_tok;
1850
1851							}
1852
1853
1854	23	50				82	Parse::RecDescent::_trace(q{>>Matched production: [skipline]<<},
1855							Parse::RecDescent::_tracefirst($text),
1856							q{_alternation_1_of_production_1_of_rule_statement},
1857							$tracelevel)
1858							if defined $::RD_TRACE;
1859	23					34	$_matched = 1;
1860	23					39	last;
1861							}
1862
1863
1864	109	50	66			360	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
1865							{
1866
1867
1868	10					21	$_[1] = $text; # NOT SURE THIS IS NEEDED
1869	10	50				38	Parse::RecDescent::_trace(q{<>},
1870							Parse::RecDescent::_tracefirst($_[1]),
1871							q{_alternation_1_of_production_1_of_rule_statement},
1872							$tracelevel)
1873							if defined $::RD_TRACE;
1874	10					78	return undef;
1875							}
1876	99	50	33			473	if (!defined($return) && defined($score))
1877							{
1878	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1879							q{_alternation_1_of_production_1_of_rule_statement},
1880							$tracelevel)
1881							if defined $::RD_TRACE;
1882	0					0	$return = $score_return;
1883							}
1884	99					121	splice @{$thisparser->{errors}}, $err_at;
	99					199
1885	99	50				273	$return = $item[$#item] unless defined $return;
1886	99	50				222	if (defined $::RD_TRACE)
1887							{
1888	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1889							$return . q{])}, "",
1890							q{_alternation_1_of_production_1_of_rule_statement},
1891							$tracelevel);
1892	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1893							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1894							Parse::RecDescent::_tracefirst($text),
1895							, q{_alternation_1_of_production_1_of_rule_statement},
1896							$tracelevel)
1897							}
1898	99					156	$_[1] = $text;
1899	99					796	return $return;
1900							}
1901
1902							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1903							sub Parse::RecDescent::Config::ApacheExtended::Grammar::hereto_line
1904							{
1905	5			5		12	my $thisparser = $_[0];
1906	11			11		65	use vars q{$tracelevel};
	11					25
	11					11383
1907	5		50			20	local $tracelevel = ($tracelevel\|\|0)+1;
1908	5					10	$ERRORS = 0;
1909	5					15	my $thisrule = $thisparser->{"rules"}{"hereto_line"};
1910
1911	5	50				32	Parse::RecDescent::_trace(q{Trying rule: [hereto_line]},
1912							Parse::RecDescent::_tracefirst($_[1]),
1913							q{hereto_line},
1914							$tracelevel)
1915							if defined $::RD_TRACE;
1916
1917
1918	5					7	my $err_at = @{$thisparser->{errors}};
	5					13
1919
1920	5					9	my $score;
1921							my $score_return;
1922	0					0	my $_tok;
1923	5					15	my $return = undef;
1924	5					9	my $_matched=0;
1925	5					8	my $commit=0;
1926	5					10	my @item = ();
1927	5					19	my %item = ();
1928	5		33			25	my $repeating = defined($_[2]) && $_[2];
1929	5		33			26	my $_noactions = defined($_[3]) && $_[3];
1930	5	50				23	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	5					8
	5					23
1931	5	50				30	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1932	5					8	my $text;
1933	5					12	my $lastsep="";
1934	5					25	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
1935	5					146	$expectation->at($_[1]);
1936
1937	5					21	my $thisline;
1938	5					23	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1939
1940
1941
1942	5		33			90	while (!$_matched && !$commit)
1943							{
1944
1945	5	50				31	Parse::RecDescent::_trace(q{Trying production: [/(.*?)$arg[0]/sm]},
1946							Parse::RecDescent::_tracefirst($_[1]),
1947							q{hereto_line},
1948							$tracelevel)
1949							if defined $::RD_TRACE;
1950	5					13	my $thisprod = $thisrule->{"prods"}[0];
1951	5					10	$text = $_[1];
1952	5					9	my $_savetext;
1953	5					25	@item = (q{hereto_line});
1954	5					16	%item = (__RULE__ => q{hereto_line});
1955	5					11	my $repcount = 0;
1956
1957
1958	5	50				24	Parse::RecDescent::_trace(q{Trying terminal: [/(.*?)$arg[0]/sm]}, Parse::RecDescent::_tracefirst($text),
1959							q{hereto_line},
1960							$tracelevel)
1961							if defined $::RD_TRACE;
1962	5					20	$lastsep = "";
1963	5					18	$expectation->is(q{})->at($text);
1964
1965
1966	5	50	33			125	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(.*?)$arg[0])//sm)
	5	50				263
1967							{
1968
1969	0					0	$expectation->failed();
1970	0	0				0	Parse::RecDescent::_trace(q{<>},
1971							Parse::RecDescent::_tracefirst($text))
1972							if defined $::RD_TRACE;
1973
1974	0					0	last;
1975							}
1976	5	50				31	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1977							. $& . q{])},
1978							Parse::RecDescent::_tracefirst($text))
1979							if defined $::RD_TRACE;
1980	5					26	push @item, $item{__PATTERN1__}=$&;
1981
1982
1983	5	50				28	Parse::RecDescent::_trace(q{Trying action},
1984							Parse::RecDescent::_tracefirst($text),
1985							q{hereto_line},
1986							$tracelevel)
1987							if defined $::RD_TRACE;
1988
1989
1990	5	50				17	$_tok = ($_noactions) ? 0 : do { $1 };
	5					15
1991	5	50				39	unless (defined $_tok)
1992							{
1993	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
1994							if defined $::RD_TRACE;
1995	0					0	last;
1996							}
1997	5	50				16	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
1998							. $_tok . q{])},
1999							Parse::RecDescent::_tracefirst($text))
2000							if defined $::RD_TRACE;
2001	5					12	push @item, $_tok;
2002	5					10	$item{__ACTION1__}=$_tok;
2003
2004
2005
2006	5	50				17	Parse::RecDescent::_trace(q{>>Matched production: [/(.*?)$arg[0]/sm]<<},
2007							Parse::RecDescent::_tracefirst($text),
2008							q{hereto_line},
2009							$tracelevel)
2010							if defined $::RD_TRACE;
2011	5					14	$_matched = 1;
2012	5					14	last;
2013							}
2014
2015
2016	5	0	33			20	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			33
2017							{
2018
2019
2020	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
2021	0	0				0	Parse::RecDescent::_trace(q{<>},
2022							Parse::RecDescent::_tracefirst($_[1]),
2023							q{hereto_line},
2024							$tracelevel)
2025							if defined $::RD_TRACE;
2026	0					0	return undef;
2027							}
2028	5	50	33			56	if (!defined($return) && defined($score))
2029							{
2030	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2031							q{hereto_line},
2032							$tracelevel)
2033							if defined $::RD_TRACE;
2034	0					0	$return = $score_return;
2035							}
2036	5					9	splice @{$thisparser->{errors}}, $err_at;
	5					15
2037	5	50				28	$return = $item[$#item] unless defined $return;
2038	5	50				18	if (defined $::RD_TRACE)
2039							{
2040	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2041							$return . q{])}, "",
2042							q{hereto_line},
2043							$tracelevel);
2044	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2045							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2046							Parse::RecDescent::_tracefirst($text),
2047							, q{hereto_line},
2048							$tracelevel)
2049							}
2050	5					12	$_[1] = $text;
2051	5					59	return $return;
2052							}
2053
2054							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2055							sub Parse::RecDescent::Config::ApacheExtended::Grammar::no_space
2056							{
2057	103			103		143	my $thisparser = $_[0];
2058	11			11		279	use vars q{$tracelevel};
	11					21
	11					10332
2059	103		50			292	local $tracelevel = ($tracelevel\|\|0)+1;
2060	103					122	$ERRORS = 0;
2061	103					200	my $thisrule = $thisparser->{"rules"}{"no_space"};
2062
2063	103	50				267	Parse::RecDescent::_trace(q{Trying rule: [no_space]},
2064							Parse::RecDescent::_tracefirst($_[1]),
2065							q{no_space},
2066							$tracelevel)
2067							if defined $::RD_TRACE;
2068
2069
2070	103					113	my $err_at = @{$thisparser->{errors}};
	103					182
2071
2072	103					135	my $score;
2073							my $score_return;
2074	0					0	my $_tok;
2075	103					141	my $return = undef;
2076	103					124	my $_matched=0;
2077	103					163	my $commit=0;
2078	103					147	my @item = ();
2079	103					235	my %item = ();
2080	103		33			334	my $repeating = defined($_[2]) && $_[2];
2081	103		33			381	my $_noactions = defined($_[3]) && $_[3];
2082	103	50				247	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	103					162
	103					220
2083	103	50				266	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2084	103					152	my $text;
2085	103					134	my $lastsep="";
2086	103					295	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2087	103					2940	$expectation->at($_[1]);
2088
2089	103					397	my $thisline;
2090	103					431	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2091
2092
2093
2094	103		33			938	while (!$_matched && !$commit)
2095							{
2096
2097	103	50				229	Parse::RecDescent::_trace(q{Trying production: [/\\S+/]},
2098							Parse::RecDescent::_tracefirst($_[1]),
2099							q{no_space},
2100							$tracelevel)
2101							if defined $::RD_TRACE;
2102	103					327	my $thisprod = $thisrule->{"prods"}[0];
2103	103					164	$text = $_[1];
2104	103					120	my $_savetext;
2105	103					198	@item = (q{no_space});
2106	103					223	%item = (__RULE__ => q{no_space});
2107	103					927	my $repcount = 0;
2108
2109
2110	103	50				240	Parse::RecDescent::_trace(q{Trying terminal: [/\\S+/]}, Parse::RecDescent::_tracefirst($text),
2111							q{no_space},
2112							$tracelevel)
2113							if defined $::RD_TRACE;
2114	103					134	$lastsep = "";
2115	103					419	$expectation->is(q{})->at($text);
2116
2117
2118	103	100	66			1553	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\S+)//)
	103	100				1160
2119							{
2120
2121	54					214	$expectation->failed();
2122	54	50				248	Parse::RecDescent::_trace(q{<>},
2123							Parse::RecDescent::_tracefirst($text))
2124							if defined $::RD_TRACE;
2125
2126	54					107	last;
2127							}
2128	49	50				133	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2129							. $& . q{])},
2130							Parse::RecDescent::_tracefirst($text))
2131							if defined $::RD_TRACE;
2132	49					154	push @item, $item{__PATTERN1__}=$&;
2133
2134
2135
2136	49	50				113	Parse::RecDescent::_trace(q{>>Matched production: [/\\S+/]<<},
2137							Parse::RecDescent::_tracefirst($text),
2138							q{no_space},
2139							$tracelevel)
2140							if defined $::RD_TRACE;
2141	49					63	$_matched = 1;
2142	49					91	last;
2143							}
2144
2145
2146	103	50	66			537	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
2147							{
2148
2149
2150	54					1313	$_[1] = $text; # NOT SURE THIS IS NEEDED
2151	54	50				139	Parse::RecDescent::_trace(q{<>},
2152							Parse::RecDescent::_tracefirst($_[1]),
2153							q{no_space},
2154							$tracelevel)
2155							if defined $::RD_TRACE;
2156	54					380	return undef;
2157							}
2158	49	50	33			274	if (!defined($return) && defined($score))
2159							{
2160	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2161							q{no_space},
2162							$tracelevel)
2163							if defined $::RD_TRACE;
2164	0					0	$return = $score_return;
2165							}
2166	49					64	splice @{$thisparser->{errors}}, $err_at;
	49					122
2167	49	50				168	$return = $item[$#item] unless defined $return;
2168	49	50				122	if (defined $::RD_TRACE)
2169							{
2170	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2171							$return . q{])}, "",
2172							q{no_space},
2173							$tracelevel);
2174	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2175							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2176							Parse::RecDescent::_tracefirst($text),
2177							, q{no_space},
2178							$tracelevel)
2179							}
2180	49					76	$_[1] = $text;
2181	49					388	return $return;
2182							}
2183
2184							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2185							sub Parse::RecDescent::Config::ApacheExtended::Grammar::multiline_directive
2186							{
2187	107			107		155	my $thisparser = $_[0];
2188	11			11		65	use vars q{$tracelevel};
	11					19
	11					6915
2189	107		50			335	local $tracelevel = ($tracelevel\|\|0)+1;
2190	107					1084	$ERRORS = 0;
2191	107					227	my $thisrule = $thisparser->{"rules"}{"multiline_directive"};
2192
2193	107	50				232	Parse::RecDescent::_trace(q{Trying rule: [multiline_directive]},
2194							Parse::RecDescent::_tracefirst($_[1]),
2195							q{multiline_directive},
2196							$tracelevel)
2197							if defined $::RD_TRACE;
2198
2199
2200	107					123	my $err_at = @{$thisparser->{errors}};
	107					194
2201
2202	107					142	my $score;
2203							my $score_return;
2204	0					0	my $_tok;
2205	107					127	my $return = undef;
2206	107					117	my $_matched=0;
2207	107					118	my $commit=0;
2208	107					163	my @item = ();
2209	107					161	my %item = ();
2210	107		33			320	my $repeating = defined($_[2]) && $_[2];
2211	107		33			299	my $_noactions = defined($_[3]) && $_[3];
2212	107	50				247	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	107					125
	107					202
2213	107	50				273	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2214	107					127	my $text;
2215	107					152	my $lastsep="";
2216	107					314	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2217	107					3235	$expectation->at($_[1]);
2218
2219	107					394	my $thisline;
2220	107					476	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2221
2222
2223
2224	107		33			1012	while (!$_matched && !$commit)
2225							{
2226
2227	107	50				245	Parse::RecDescent::_trace(q{Trying production: [/(.?[\\\\][ \\t]\\n)+.*/ eol]},
2228							Parse::RecDescent::_tracefirst($_[1]),
2229							q{multiline_directive},
2230							$tracelevel)
2231							if defined $::RD_TRACE;
2232	107					190	my $thisprod = $thisrule->{"prods"}[0];
2233	107					129	$text = $_[1];
2234	107					126	my $_savetext;
2235	107					361	@item = (q{multiline_directive});
2236	107					223	%item = (__RULE__ => q{multiline_directive});
2237	107					131	my $repcount = 0;
2238
2239
2240	107	50				243	Parse::RecDescent::_trace(q{Trying terminal: [/(.?[\\\\][ \\t]\\n)+.*/]}, Parse::RecDescent::_tracefirst($text),
2241							q{multiline_directive},
2242							$tracelevel)
2243							if defined $::RD_TRACE;
2244	107					133	$lastsep = "";
2245	107					292	$expectation->is(q{})->at($text);
2246
2247
2248	107	100	66			1309	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(.?[\\][ \t]\n)+.*)//)
	107	100				1180
2249							{
2250
2251	97					296	$expectation->failed();
2252	97	50				437	Parse::RecDescent::_trace(q{<>},
2253							Parse::RecDescent::_tracefirst($text))
2254							if defined $::RD_TRACE;
2255
2256	97					194	last;
2257							}
2258	10	50				36	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2259							. $& . q{])},
2260							Parse::RecDescent::_tracefirst($text))
2261							if defined $::RD_TRACE;
2262	10					42	push @item, $item{__PATTERN1__}=$&;
2263
2264
2265	10	50				133	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
2266							Parse::RecDescent::_tracefirst($text),
2267							q{multiline_directive},
2268							$tracelevel)
2269							if defined $::RD_TRACE;
2270	11			11		162	if (1) { no strict qw{refs};
	11					26
	11					8505
	10					19
2271	10					34	$expectation->is(q{eol})->at($text);
2272	10	50		10		105	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	10					25
2273							{
2274
2275	0	0				0	Parse::RecDescent::_trace(q{<>},
2276							Parse::RecDescent::_tracefirst($text),
2277							q{multiline_directive},
2278							$tracelevel)
2279							if defined $::RD_TRACE;
2280	0					0	$expectation->failed();
2281	0					0	last;
2282							}
2283	10	50				48	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
2284							. $_tok . q{]},
2285
2286							Parse::RecDescent::_tracefirst($text),
2287							q{multiline_directive},
2288							$tracelevel)
2289							if defined $::RD_TRACE;
2290	10					24	$item{q{eol}} = $_tok;
2291	10					18	push @item, $_tok;
2292
2293							}
2294
2295	10	50				28	Parse::RecDescent::_trace(q{Trying action},
2296							Parse::RecDescent::_tracefirst($text),
2297							q{multiline_directive},
2298							$tracelevel)
2299							if defined $::RD_TRACE;
2300
2301
2302	10	50				26	$_tok = ($_noactions) ? 0 : do { $item[-2] =~ s/[\\][ \t]*\n//g; $return =
	10					87
	10					185
2303							$thisparser->directive($item[-2] . "\n",1, @arg) };
2304	10	50				156	unless (defined $_tok)
2305							{
2306	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
2307							if defined $::RD_TRACE;
2308	0					0	last;
2309							}
2310	10	50				27	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
2311							. $_tok . q{])},
2312							Parse::RecDescent::_tracefirst($text))
2313							if defined $::RD_TRACE;
2314	10					20	push @item, $_tok;
2315	10					23	$item{__ACTION1__}=$_tok;
2316
2317
2318
2319	10	50				33	Parse::RecDescent::_trace(q{>>Matched production: [/(.?[\\\\][ \\t]\\n)+.*/ eol]<<},
2320							Parse::RecDescent::_tracefirst($text),
2321							q{multiline_directive},
2322							$tracelevel)
2323							if defined $::RD_TRACE;
2324	10					14	$_matched = 1;
2325	10					23	last;
2326							}
2327
2328
2329	107	50	66			719	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
2330							{
2331
2332
2333	97					151	$_[1] = $text; # NOT SURE THIS IS NEEDED
2334	97	50				192	Parse::RecDescent::_trace(q{<>},
2335							Parse::RecDescent::_tracefirst($_[1]),
2336							q{multiline_directive},
2337							$tracelevel)
2338							if defined $::RD_TRACE;
2339	97					684	return undef;
2340							}
2341	10	50	33			33	if (!defined($return) && defined($score))
2342							{
2343	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2344							q{multiline_directive},
2345							$tracelevel)
2346							if defined $::RD_TRACE;
2347	0					0	$return = $score_return;
2348							}
2349	10					14	splice @{$thisparser->{errors}}, $err_at;
	10					22
2350	10	50				37	$return = $item[$#item] unless defined $return;
2351	10	50				27	if (defined $::RD_TRACE)
2352							{
2353	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2354							$return . q{])}, "",
2355							q{multiline_directive},
2356							$tracelevel);
2357	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2358							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2359							Parse::RecDescent::_tracefirst($text),
2360							, q{multiline_directive},
2361							$tracelevel)
2362							}
2363	10					19	$_[1] = $text;
2364	10					85	return $return;
2365							}
2366
2367							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2368							sub Parse::RecDescent::Config::ApacheExtended::Grammar::val
2369							{
2370	125			125		1590	my $thisparser = $_[0];
2371	11			11		1307	use vars q{$tracelevel};
	11					22
	11					4976
2372	125		50			407	local $tracelevel = ($tracelevel\|\|0)+1;
2373	125					178	$ERRORS = 0;
2374	125					232	my $thisrule = $thisparser->{"rules"}{"val"};
2375
2376	125	50				282	Parse::RecDescent::_trace(q{Trying rule: [val]},
2377							Parse::RecDescent::_tracefirst($_[1]),
2378							q{val},
2379							$tracelevel)
2380							if defined $::RD_TRACE;
2381
2382
2383	125					133	my $err_at = @{$thisparser->{errors}};
	125					214
2384
2385	125					223	my $score;
2386							my $score_return;
2387	0					0	my $_tok;
2388	125					143	my $return = undef;
2389	125					144	my $_matched=0;
2390	125					135	my $commit=0;
2391	125					204	my @item = ();
2392	125					183	my %item = ();
2393	125		33			366	my $repeating = defined($_[2]) && $_[2];
2394	125		33			370	my $_noactions = defined($_[3]) && $_[3];
2395	125	100				298	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	7					13
	7					100
2396	125	50				304	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2397	125					144	my $text;
2398	125					162	my $lastsep="";
2399	125					351	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2400	125					6052	$expectation->at($_[1]);
2401
2402	125					469	my $thisline;
2403	125					529	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2404
2405
2406
2407	125		33			1185	while (!$_matched && !$commit)
2408							{
2409
2410	125	50				282	Parse::RecDescent::_trace(q{Trying production: [quote]},
2411							Parse::RecDescent::_tracefirst($_[1]),
2412							q{val},
2413							$tracelevel)
2414							if defined $::RD_TRACE;
2415	125					281	my $thisprod = $thisrule->{"prods"}[0];
2416	125					170	$text = $_[1];
2417	125					136	my $_savetext;
2418	125					237	@item = (q{val});
2419	125					238	%item = (__RULE__ => q{val});
2420	125					158	my $repcount = 0;
2421
2422
2423	125	50				339	Parse::RecDescent::_trace(q{Trying subrule: [quote]},
2424							Parse::RecDescent::_tracefirst($text),
2425							q{val},
2426							$tracelevel)
2427							if defined $::RD_TRACE;
2428	11			11		97	if (1) { no strict qw{refs};
	11					27
	11					4113
	125					147
2429	125					323	$expectation->is(q{})->at($text);
2430	125	100		125		1453	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::quote($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	125					263
2431							{
2432
2433	103	50				222	Parse::RecDescent::_trace(q{<>},
2434							Parse::RecDescent::_tracefirst($text),
2435							q{val},
2436							$tracelevel)
2437							if defined $::RD_TRACE;
2438	103					276	$expectation->failed();
2439	103					438	last;
2440							}
2441	22	50				98	Parse::RecDescent::_trace(q{>>Matched subrule: [quote]<< (return value: [}
2442							. $_tok . q{]},
2443
2444							Parse::RecDescent::_tracefirst($text),
2445							q{val},
2446							$tracelevel)
2447							if defined $::RD_TRACE;
2448	22					245	$item{q{quote}} = $_tok;
2449	22					40	push @item, $_tok;
2450
2451							}
2452
2453
2454	22	50				57	Parse::RecDescent::_trace(q{>>Matched production: [quote]<<},
2455							Parse::RecDescent::_tracefirst($text),
2456							q{val},
2457							$tracelevel)
2458							if defined $::RD_TRACE;
2459	22					35	$_matched = 1;
2460	22					43	last;
2461							}
2462
2463
2464	125		66			596	while (!$_matched && !$commit)
2465							{
2466
2467	103	50				289	Parse::RecDescent::_trace(q{Trying production: [no_space]},
2468							Parse::RecDescent::_tracefirst($_[1]),
2469							q{val},
2470							$tracelevel)
2471							if defined $::RD_TRACE;
2472	103					211	my $thisprod = $thisrule->{"prods"}[1];
2473	103					147	$text = $_[1];
2474	103					119	my $_savetext;
2475	103					203	@item = (q{val});
2476	103					214	%item = (__RULE__ => q{val});
2477	103					123	my $repcount = 0;
2478
2479
2480	103	50				219	Parse::RecDescent::_trace(q{Trying subrule: [no_space]},
2481							Parse::RecDescent::_tracefirst($text),
2482							q{val},
2483							$tracelevel)
2484							if defined $::RD_TRACE;
2485	11			11		76	if (1) { no strict qw{refs};
	11					22
	11					6254
	103					116
2486	103					286	$expectation->is(q{})->at($text);
2487	103	100		103		1089	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::no_space($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	103					208
2488							{
2489
2490	54	50				125	Parse::RecDescent::_trace(q{<>},
2491							Parse::RecDescent::_tracefirst($text),
2492							q{val},
2493							$tracelevel)
2494							if defined $::RD_TRACE;
2495	54					154	$expectation->failed();
2496	54					211	last;
2497							}
2498	49	50				184	Parse::RecDescent::_trace(q{>>Matched subrule: [no_space]<< (return value: [}
2499							. $_tok . q{]},
2500
2501							Parse::RecDescent::_tracefirst($text),
2502							q{val},
2503							$tracelevel)
2504							if defined $::RD_TRACE;
2505	49					100	$item{q{no_space}} = $_tok;
2506	49					81	push @item, $_tok;
2507
2508							}
2509
2510
2511	49	50				135	Parse::RecDescent::_trace(q{>>Matched production: [no_space]<<},
2512							Parse::RecDescent::_tracefirst($text),
2513							q{val},
2514							$tracelevel)
2515							if defined $::RD_TRACE;
2516	49					67	$_matched = 1;
2517	49					71	last;
2518							}
2519
2520
2521	125	50	66			629	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
2522							{
2523
2524
2525	54					86	$_[1] = $text; # NOT SURE THIS IS NEEDED
2526	54	50				119	Parse::RecDescent::_trace(q{<>},
2527							Parse::RecDescent::_tracefirst($_[1]),
2528							q{val},
2529							$tracelevel)
2530							if defined $::RD_TRACE;
2531	54					323	return undef;
2532							}
2533	71	50	33			324	if (!defined($return) && defined($score))
2534							{
2535	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2536							q{val},
2537							$tracelevel)
2538							if defined $::RD_TRACE;
2539	0					0	$return = $score_return;
2540							}
2541	71					85	splice @{$thisparser->{errors}}, $err_at;
	71					149
2542	71	50				348	$return = $item[$#item] unless defined $return;
2543	71	50				176	if (defined $::RD_TRACE)
2544							{
2545	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2546							$return . q{])}, "",
2547							q{val},
2548							$tracelevel);
2549	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2550							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2551							Parse::RecDescent::_tracefirst($text),
2552							, q{val},
2553							$tracelevel)
2554							}
2555	71					108	$_[1] = $text;
2556	71					491	return $return;
2557							}
2558
2559							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2560							sub Parse::RecDescent::Config::ApacheExtended::Grammar::block_val
2561							{
2562	16			16		224	my $thisparser = $_[0];
2563	11			11		72	use vars q{$tracelevel};
	11					19
	11					4743
2564	16		50			67	local $tracelevel = ($tracelevel\|\|0)+1;
2565	16					23	$ERRORS = 0;
2566	16					41	my $thisrule = $thisparser->{"rules"}{"block_val"};
2567
2568	16	50				54	Parse::RecDescent::_trace(q{Trying rule: [block_val]},
2569							Parse::RecDescent::_tracefirst($_[1]),
2570							q{block_val},
2571							$tracelevel)
2572							if defined $::RD_TRACE;
2573
2574
2575	16					20	my $err_at = @{$thisparser->{errors}};
	16					37
2576
2577	16					33	my $score;
2578							my $score_return;
2579	0					0	my $_tok;
2580	16					24	my $return = undef;
2581	16					22	my $_matched=0;
2582	16					21	my $commit=0;
2583	16					39	my @item = ();
2584	16					31	my %item = ();
2585	16		33			68	my $repeating = defined($_[2]) && $_[2];
2586	16		33			59	my $_noactions = defined($_[3]) && $_[3];
2587	16	50				50	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	0					0
	0					0
2588	16	50				58	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2589	16					22	my $text;
2590	16					25	my $lastsep="";
2591	16					57	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2592	16					761	$expectation->at($_[1]);
2593
2594	16					64	my $thisline;
2595	16					81	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2596
2597
2598
2599	16		33			232	while (!$_matched && !$commit)
2600							{
2601
2602	16	50				57	Parse::RecDescent::_trace(q{Trying production: [quote]},
2603							Parse::RecDescent::_tracefirst($_[1]),
2604							q{block_val},
2605							$tracelevel)
2606							if defined $::RD_TRACE;
2607	16					39	my $thisprod = $thisrule->{"prods"}[0];
2608	16					29	$text = $_[1];
2609	16					19	my $_savetext;
2610	16					41	@item = (q{block_val});
2611	16					51	%item = (__RULE__ => q{block_val});
2612	16					22	my $repcount = 0;
2613
2614
2615	16	50				55	Parse::RecDescent::_trace(q{Trying subrule: [quote]},
2616							Parse::RecDescent::_tracefirst($text),
2617							q{block_val},
2618							$tracelevel)
2619							if defined $::RD_TRACE;
2620	11			11		64	if (1) { no strict qw{refs};
	11					23
	11					9560
	16					23
2621	16					54	$expectation->is(q{})->at($text);
2622	16	100		16		179	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::quote($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	16					40
2623							{
2624
2625	11	50				40	Parse::RecDescent::_trace(q{<>},
2626							Parse::RecDescent::_tracefirst($text),
2627							q{block_val},
2628							$tracelevel)
2629							if defined $::RD_TRACE;
2630	11					45	$expectation->failed();
2631	11					48	last;
2632							}
2633	5	50				27	Parse::RecDescent::_trace(q{>>Matched subrule: [quote]<< (return value: [}
2634							. $_tok . q{]},
2635
2636							Parse::RecDescent::_tracefirst($text),
2637							q{block_val},
2638							$tracelevel)
2639							if defined $::RD_TRACE;
2640	5					14	$item{q{quote}} = $_tok;
2641	5					11	push @item, $_tok;
2642
2643							}
2644
2645
2646	5	50				24	Parse::RecDescent::_trace(q{>>Matched production: [quote]<<},
2647							Parse::RecDescent::_tracefirst($text),
2648							q{block_val},
2649							$tracelevel)
2650							if defined $::RD_TRACE;
2651	5					16	$_matched = 1;
2652	5					10	last;
2653							}
2654
2655
2656	16		66			107	while (!$_matched && !$commit)
2657							{
2658
2659	11	50				33	Parse::RecDescent::_trace(q{Trying production: [/[^\\s>]+/]},
2660							Parse::RecDescent::_tracefirst($_[1]),
2661							q{block_val},
2662							$tracelevel)
2663							if defined $::RD_TRACE;
2664	11					31	my $thisprod = $thisrule->{"prods"}[1];
2665	11					23	$text = $_[1];
2666	11					17	my $_savetext;
2667	11					27	@item = (q{block_val});
2668	11					31	%item = (__RULE__ => q{block_val});
2669	11					25	my $repcount = 0;
2670
2671
2672	11	50				35	Parse::RecDescent::_trace(q{Trying terminal: [/[^\\s>]+/]}, Parse::RecDescent::_tracefirst($text),
2673							q{block_val},
2674							$tracelevel)
2675							if defined $::RD_TRACE;
2676	11					17	$lastsep = "";
2677	11					45	$expectation->is(q{})->at($text);
2678
2679
2680	11	100	66			297	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^\s>]+)//)
	11	100				178
2681							{
2682
2683	8					37	$expectation->failed();
2684	8	50				47	Parse::RecDescent::_trace(q{<>},
2685							Parse::RecDescent::_tracefirst($text))
2686							if defined $::RD_TRACE;
2687
2688	8					21	last;
2689							}
2690	3	50				14	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2691							. $& . q{])},
2692							Parse::RecDescent::_tracefirst($text))
2693							if defined $::RD_TRACE;
2694	3					13	push @item, $item{__PATTERN1__}=$&;
2695
2696
2697
2698	3	50				10	Parse::RecDescent::_trace(q{>>Matched production: [/[^\\s>]+/]<<},
2699							Parse::RecDescent::_tracefirst($text),
2700							q{block_val},
2701							$tracelevel)
2702							if defined $::RD_TRACE;
2703	3					6	$_matched = 1;
2704	3					7	last;
2705							}
2706
2707
2708	16	50	66			138	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
2709							{
2710
2711
2712	8					19	$_[1] = $text; # NOT SURE THIS IS NEEDED
2713	8	50				36	Parse::RecDescent::_trace(q{<>},
2714							Parse::RecDescent::_tracefirst($_[1]),
2715							q{block_val},
2716							$tracelevel)
2717							if defined $::RD_TRACE;
2718	8					61	return undef;
2719							}
2720	8	50	33			67	if (!defined($return) && defined($score))
2721							{
2722	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
2723							q{block_val},
2724							$tracelevel)
2725							if defined $::RD_TRACE;
2726	0					0	$return = $score_return;
2727							}
2728	8					15	splice @{$thisparser->{errors}}, $err_at;
	8					22
2729	8	50				33	$return = $item[$#item] unless defined $return;
2730	8	50				42	if (defined $::RD_TRACE)
2731							{
2732	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
2733							$return . q{])}, "",
2734							q{block_val},
2735							$tracelevel);
2736	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
2737							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
2738							Parse::RecDescent::_tracefirst($text),
2739							, q{block_val},
2740							$tracelevel)
2741							}
2742	8					17	$_[1] = $text;
2743	8					64	return $return;
2744							}
2745
2746							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
2747							sub Parse::RecDescent::Config::ApacheExtended::Grammar::hereto_directive
2748							{
2749	97			97		146	my $thisparser = $_[0];
2750	11			11		63	use vars q{$tracelevel};
	11					19
	11					4611
2751	97		50			265	local $tracelevel = ($tracelevel\|\|0)+1;
2752	97					121	$ERRORS = 0;
2753	97					206	my $thisrule = $thisparser->{"rules"}{"hereto_directive"};
2754
2755	97	50				193	Parse::RecDescent::_trace(q{Trying rule: [hereto_directive]},
2756							Parse::RecDescent::_tracefirst($_[1]),
2757							q{hereto_directive},
2758							$tracelevel)
2759							if defined $::RD_TRACE;
2760
2761
2762	97					107	my $err_at = @{$thisparser->{errors}};
	97					210
2763
2764	97					129	my $score;
2765							my $score_return;
2766	0					0	my $_tok;
2767	97					120	my $return = undef;
2768	97					107	my $_matched=0;
2769	97					114	my $commit=0;
2770	97					145	my @item = ();
2771	97					134	my %item = ();
2772	97		33			474	my $repeating = defined($_[2]) && $_[2];
2773	97		33			268	my $_noactions = defined($_[3]) && $_[3];
2774	97	50				238	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	97					183
	97					190
2775	97	50				273	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
2776	97					116	my $text;
2777	97					127	my $lastsep="";
2778	97					314	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
2779	97					3203	$expectation->at($_[1]);
2780
2781	97					351	my $thisline;
2782	97					398	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
2783
2784
2785
2786	97		33			922	while (!$_matched && !$commit)
2787							{
2788	97	50				251	local $skip = defined($skip) ? $skip : $Parse::RecDescent::skip;
2789	97	50				228	Parse::RecDescent::_trace(q{Trying production: [key '<<' hereto_mark eol hereto_line eol]},
2790							Parse::RecDescent::_tracefirst($_[1]),
2791							q{hereto_directive},
2792							$tracelevel)
2793							if defined $::RD_TRACE;
2794	97					183	my $thisprod = $thisrule->{"prods"}[0];
2795	97					119	$text = $_[1];
2796	97					118	my $_savetext;
2797	97					169	@item = (q{hereto_directive});
2798	97					194	%item = (__RULE__ => q{hereto_directive});
2799	97					116	my $repcount = 0;
2800
2801
2802	97	50				210	Parse::RecDescent::_trace(q{Trying subrule: [key]},
2803							Parse::RecDescent::_tracefirst($text),
2804							q{hereto_directive},
2805							$tracelevel)
2806							if defined $::RD_TRACE;
2807	11			11		61	if (1) { no strict qw{refs};
	11					21
	11					4317
	97					111
2808	97					280	$expectation->is(q{})->at($text);
2809	97	100		97		936	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::key($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	97					261
2810							{
2811
2812	48	50				121	Parse::RecDescent::_trace(q{<>},
2813							Parse::RecDescent::_tracefirst($text),
2814							q{hereto_directive},
2815							$tracelevel)
2816							if defined $::RD_TRACE;
2817	48					131	$expectation->failed();
2818	48					196	last;
2819							}
2820	49	50				2897	Parse::RecDescent::_trace(q{>>Matched subrule: [key]<< (return value: [}
2821							. $_tok . q{]},
2822
2823							Parse::RecDescent::_tracefirst($text),
2824							q{hereto_directive},
2825							$tracelevel)
2826							if defined $::RD_TRACE;
2827	49					107	$item{q{key}} = $_tok;
2828	49					87	push @item, $_tok;
2829
2830							}
2831
2832	49	50				108	Parse::RecDescent::_trace(q{Trying terminal: ['<<']},
2833							Parse::RecDescent::_tracefirst($text),
2834							q{hereto_directive},
2835							$tracelevel)
2836							if defined $::RD_TRACE;
2837	49					73	$lastsep = "";
2838	49					414	$expectation->is(q{'<<'})->at($text);
2839
2840
2841	49	100	66			813	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\<\
	49	100				752
2842							{
2843
2844	44					327	$expectation->failed();
2845	44	50				670	Parse::RecDescent::_trace(qq{<>},
2846							Parse::RecDescent::_tracefirst($text))
2847							if defined $::RD_TRACE;
2848	44					101	last;
2849							}
2850	5	50				23	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
2851							. $& . q{])},
2852							Parse::RecDescent::_tracefirst($text))
2853							if defined $::RD_TRACE;
2854	5					20	push @item, $item{__STRING1__}=$&;
2855
2856
2857	5	50				19	Parse::RecDescent::_trace(q{Trying subrule: [hereto_mark]},
2858							Parse::RecDescent::_tracefirst($text),
2859							q{hereto_directive},
2860							$tracelevel)
2861							if defined $::RD_TRACE;
2862	11			11		61	if (1) { no strict qw{refs};
	11					20
	11					2173
	5					9
2863	5					21	$expectation->is(q{hereto_mark})->at($text);
2864	5	50		5		64	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::hereto_mark($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	5					20
2865							{
2866
2867	0	0				0	Parse::RecDescent::_trace(q{<>},
2868							Parse::RecDescent::_tracefirst($text),
2869							q{hereto_directive},
2870							$tracelevel)
2871							if defined $::RD_TRACE;
2872	0					0	$expectation->failed();
2873	0					0	last;
2874							}
2875	5	50				31	Parse::RecDescent::_trace(q{>>Matched subrule: [hereto_mark]<< (return value: [}
2876							. $_tok . q{]},
2877
2878							Parse::RecDescent::_tracefirst($text),
2879							q{hereto_directive},
2880							$tracelevel)
2881							if defined $::RD_TRACE;
2882	5					14	$item{q{hereto_mark}} = $_tok;
2883	5					11	push @item, $_tok;
2884
2885							}
2886
2887	5	50				22	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
2888							Parse::RecDescent::_tracefirst($text),
2889							q{hereto_directive},
2890							$tracelevel)
2891							if defined $::RD_TRACE;
2892	11			11		62	if (1) { no strict qw{refs};
	11					26
	11					18157
	5					9
2893	5					19	$expectation->is(q{eol})->at($text);
2894	5	50		5		118	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	5					15
2895							{
2896
2897	0	0				0	Parse::RecDescent::_trace(q{<>},
2898							Parse::RecDescent::_tracefirst($text),
2899							q{hereto_directive},
2900							$tracelevel)
2901							if defined $::RD_TRACE;
2902	0					0	$expectation->failed();
2903	0					0	last;
2904							}
2905	5	50				27	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
2906							. $_tok . q{]},
2907
2908							Parse::RecDescent::_tracefirst($text),
2909							q{hereto_directive},
2910							$tracelevel)
2911							if defined $::RD_TRACE;
2912	5					13	$item{q{eol}} = $_tok;
2913	5					12	push @item, $_tok;
2914
2915							}
2916
2917
2918
2919	5	50				18	Parse::RecDescent::_trace(q{Trying directive: []},
2920							Parse::RecDescent::_tracefirst($text),
2921							q{hereto_directive},
2922							$tracelevel)
2923							if defined $::RD_TRACE;
2924	5					9	$_tok = do { my $oldskip = $skip; $skip= ''; $oldskip };
	5					11
	5					9
	5					13
2925	5	50				33	if (defined($_tok))
2926							{
2927	5	50				81	Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
2928							. $_tok . q{])},
2929							Parse::RecDescent::_tracefirst($text))
2930							if defined $::RD_TRACE;
2931							}
2932							else
2933							{
2934	0	0				0	Parse::RecDescent::_trace(q{<>},
2935							Parse::RecDescent::_tracefirst($text))
2936							if defined $::RD_TRACE;
2937							}
2938
2939	5	50				26	last unless defined $_tok;
2940	5					16	push @item, $item{__DIRECTIVE1__}=$_tok;
2941
2942
2943	5	50				21	Parse::RecDescent::_trace(q{Trying subrule: [hereto_line]},
2944							Parse::RecDescent::_tracefirst($text),
2945							q{hereto_directive},
2946							$tracelevel)
2947							if defined $::RD_TRACE;
2948	11			11		68	if (1) { no strict qw{refs};
	11					20
	11					3223
	5					9
2949	5					22	$expectation->is(q{hereto_line})->at($text);
2950	5	50		5		63	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::hereto_line($thisparser,$text,$repeating,$_noactions,sub { return [$item[3]] })))
	5					19
2951							{
2952
2953	0	0				0	Parse::RecDescent::_trace(q{<>},
2954							Parse::RecDescent::_tracefirst($text),
2955							q{hereto_directive},
2956							$tracelevel)
2957							if defined $::RD_TRACE;
2958	0					0	$expectation->failed();
2959	0					0	last;
2960							}
2961	5	50				31	Parse::RecDescent::_trace(q{>>Matched subrule: [hereto_line]<< (return value: [}
2962							. $_tok . q{]},
2963
2964							Parse::RecDescent::_tracefirst($text),
2965							q{hereto_directive},
2966							$tracelevel)
2967							if defined $::RD_TRACE;
2968	5					12	$item{q{hereto_line}} = $_tok;
2969	5					14	push @item, $_tok;
2970
2971							}
2972
2973	5	50				19	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
2974							Parse::RecDescent::_tracefirst($text),
2975							q{hereto_directive},
2976							$tracelevel)
2977							if defined $::RD_TRACE;
2978	11			11		60	if (1) { no strict qw{refs};
	11					17
	11					9318
	5					15
2979	5					22	$expectation->is(q{eol})->at($text);
2980	5	50		5		60	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	5					15
2981							{
2982
2983	0	0				0	Parse::RecDescent::_trace(q{<>},
2984							Parse::RecDescent::_tracefirst($text),
2985							q{hereto_directive},
2986							$tracelevel)
2987							if defined $::RD_TRACE;
2988	0					0	$expectation->failed();
2989	0					0	last;
2990							}
2991	5	50				26	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
2992							. $_tok . q{]},
2993
2994							Parse::RecDescent::_tracefirst($text),
2995							q{hereto_directive},
2996							$tracelevel)
2997							if defined $::RD_TRACE;
2998	5					14	$item{q{eol}} = $_tok;
2999	5					11	push @item, $_tok;
3000
3001							}
3002
3003	5	50				24	Parse::RecDescent::_trace(q{Trying action},
3004							Parse::RecDescent::_tracefirst($text),
3005							q{hereto_directive},
3006							$tracelevel)
3007							if defined $::RD_TRACE;
3008
3009
3010	5	50				17	$_tok = ($_noactions) ? 0 : do { $data->newDirective($item[1], [$item[6]]) };
	5					32
3011	5	50				29	unless (defined $_tok)
3012							{
3013	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
3014							if defined $::RD_TRACE;
3015	0					0	last;
3016							}
3017	5	50				16	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3018							. $_tok . q{])},
3019							Parse::RecDescent::_tracefirst($text))
3020							if defined $::RD_TRACE;
3021	5					20	push @item, $_tok;
3022	5					16	$item{__ACTION1__}=$_tok;
3023
3024
3025
3026	5	50				17	Parse::RecDescent::_trace(q{>>Matched production: [key '<<' hereto_mark eol hereto_line eol]<<},
3027							Parse::RecDescent::_tracefirst($text),
3028							q{hereto_directive},
3029							$tracelevel)
3030							if defined $::RD_TRACE;
3031	5					9	$_matched = 1;
3032	5					14	last;
3033							}
3034
3035
3036	97	50	66			936	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
3037							{
3038
3039
3040	92					143	$_[1] = $text; # NOT SURE THIS IS NEEDED
3041	92	50				206	Parse::RecDescent::_trace(q{<>},
3042							Parse::RecDescent::_tracefirst($_[1]),
3043							q{hereto_directive},
3044							$tracelevel)
3045							if defined $::RD_TRACE;
3046	92					883	return undef;
3047							}
3048	5	50	33			47	if (!defined($return) && defined($score))
3049							{
3050	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3051							q{hereto_directive},
3052							$tracelevel)
3053							if defined $::RD_TRACE;
3054	0					0	$return = $score_return;
3055							}
3056	5					7	splice @{$thisparser->{errors}}, $err_at;
	5					54
3057	5	50				25	$return = $item[$#item] unless defined $return;
3058	5	50				25	if (defined $::RD_TRACE)
3059							{
3060	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3061							$return . q{])}, "",
3062							q{hereto_directive},
3063							$tracelevel);
3064	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3065							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3066							Parse::RecDescent::_tracefirst($text),
3067							, q{hereto_directive},
3068							$tracelevel)
3069							}
3070	5					13	$_[1] = $text;
3071	5					62	return $return;
3072							}
3073
3074							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3075							sub Parse::RecDescent::Config::ApacheExtended::Grammar::grammar
3076							{
3077	10			10		840	my $thisparser = $_[0];
3078	11			11		82	use vars q{$tracelevel};
	11					23
	11					9902
3079	10		50			84	local $tracelevel = ($tracelevel\|\|0)+1;
3080	10					75	$ERRORS = 0;
3081	10					45	my $thisrule = $thisparser->{"rules"}{"grammar"};
3082
3083	10	50				65	Parse::RecDescent::_trace(q{Trying rule: [grammar]},
3084							Parse::RecDescent::_tracefirst($_[1]),
3085							q{grammar},
3086							$tracelevel)
3087							if defined $::RD_TRACE;
3088
3089
3090	10					20	my $err_at = @{$thisparser->{errors}};
	10					51
3091
3092	10					35	my $score;
3093							my $score_return;
3094	0					0	my $_tok;
3095	10					20	my $return = undef;
3096	10					21	my $_matched=0;
3097	10					19	my $commit=0;
3098	10					23	my @item = ();
3099	10					25	my %item = ();
3100	10		33			46	my $repeating = defined($_[2]) && $_[2];
3101	10		33			48	my $_noactions = defined($_[3]) && $_[3];
3102	10	50				47	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	10					23
	10					44
3103	10	50				108	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3104	10					21	my $text;
3105	10					19	my $lastsep="";
3106	10					63	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3107	10					811	$expectation->at($_[1]);
3108
3109	10					94	my $thisline;
3110	10					173	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3111
3112
3113
3114	10		33			243	while (!$_matched && !$commit)
3115							{
3116
3117	10	50				40	Parse::RecDescent::_trace(q{Trying production: []},
3118							Parse::RecDescent::_tracefirst($_[1]),
3119							q{grammar},
3120							$tracelevel)
3121							if defined $::RD_TRACE;
3122	10					42	my $thisprod = $thisrule->{"prods"}[0];
3123	10					22	$text = $_[1];
3124	10					24	my $_savetext;
3125	10					29	@item = (q{grammar});
3126	10					35	%item = (__RULE__ => q{grammar});
3127	10					21	my $repcount = 0;
3128
3129
3130	10	50				42	Parse::RecDescent::_trace(q{Trying action},
3131							Parse::RecDescent::_tracefirst($text),
3132							q{grammar},
3133							$tracelevel)
3134							if defined $::RD_TRACE;
3135
3136
3137	10	50				42	$_tok = ($_noactions) ? 0 : do { $data = $arg[0]; };
	10					27
3138	10	50				72	unless (defined $_tok)
3139							{
3140	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
3141							if defined $::RD_TRACE;
3142	0					0	last;
3143							}
3144	10	50				36	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3145							. $_tok . q{])},
3146							Parse::RecDescent::_tracefirst($text))
3147							if defined $::RD_TRACE;
3148	10					27	push @item, $_tok;
3149	10					28	$item{__ACTION1__}=$_tok;
3150
3151
3152	10	50				71	Parse::RecDescent::_trace(q{>>Rejecting production<< (found )},
3153							Parse::RecDescent::_tracefirst($text),
3154							q{grammar},
3155							$tracelevel)
3156							if defined $::RD_TRACE;
3157	10					22	undef $return;
3158
3159
3160	10					35	$_tok = undef;
3161
3162	10	50				64	last unless defined $_tok;
3163
3164
3165	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: []<<},
3166							Parse::RecDescent::_tracefirst($text),
3167							q{grammar},
3168							$tracelevel)
3169							if defined $::RD_TRACE;
3170	0					0	$_matched = 1;
3171	0					0	last;
3172							}
3173
3174
3175	10		33			163	while (!$_matched && !$commit)
3176							{
3177
3178	10	50				42	Parse::RecDescent::_trace(q{Trying production: [statement eof]},
3179							Parse::RecDescent::_tracefirst($_[1]),
3180							q{grammar},
3181							$tracelevel)
3182							if defined $::RD_TRACE;
3183	10					30	my $thisprod = $thisrule->{"prods"}[1];
3184	10					20	$text = $_[1];
3185	10					27	my $_savetext;
3186	10					34	@item = (q{grammar});
3187	10					38	%item = (__RULE__ => q{grammar});
3188	10					19	my $repcount = 0;
3189
3190
3191	10	50				33	Parse::RecDescent::_trace(q{Trying repeated subrule: [statement]},
3192							Parse::RecDescent::_tracefirst($text),
3193							q{grammar},
3194							$tracelevel)
3195							if defined $::RD_TRACE;
3196	10					51	$expectation->is(q{})->at($text);
3197
3198	10	50				135	unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::ApacheExtended::Grammar::statement, 0, 100000000, $_noactions,$expectation,undef)))
3199							{
3200	0	0				0	Parse::RecDescent::_trace(q{<>},
3201							Parse::RecDescent::_tracefirst($text),
3202							q{grammar},
3203							$tracelevel)
3204							if defined $::RD_TRACE;
3205	0					0	last;
3206							}
3207	10	50				205	Parse::RecDescent::_trace(q{>>Matched repeated subrule: [statement]<< (}
3208							. @$_tok . q{ times)},
3209
3210							Parse::RecDescent::_tracefirst($text),
3211							q{grammar},
3212							$tracelevel)
3213							if defined $::RD_TRACE;
3214	10					26	$item{q{statement(s?)}} = $_tok;
3215	10					24	push @item, $_tok;
3216
3217
3218
3219	10	50				34	Parse::RecDescent::_trace(q{Trying subrule: [eof]},
3220							Parse::RecDescent::_tracefirst($text),
3221							q{grammar},
3222							$tracelevel)
3223							if defined $::RD_TRACE;
3224	11			11		145	if (1) { no strict qw{refs};
	11					24
	11					8823
	10					28
3225	10					179	$expectation->is(q{eof})->at($text);
3226	10	100		10		193	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eof($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	10					38
3227							{
3228
3229	1	50				4	Parse::RecDescent::_trace(q{<>},
3230							Parse::RecDescent::_tracefirst($text),
3231							q{grammar},
3232							$tracelevel)
3233							if defined $::RD_TRACE;
3234	1					3	$expectation->failed();
3235	1					9	last;
3236							}
3237	9	50				54	Parse::RecDescent::_trace(q{>>Matched subrule: [eof]<< (return value: [}
3238							. $_tok . q{]},
3239
3240							Parse::RecDescent::_tracefirst($text),
3241							q{grammar},
3242							$tracelevel)
3243							if defined $::RD_TRACE;
3244	9					26	$item{q{eof}} = $_tok;
3245	9					24	push @item, $_tok;
3246
3247							}
3248
3249	9	50				51	Parse::RecDescent::_trace(q{Trying action},
3250							Parse::RecDescent::_tracefirst($text),
3251							q{grammar},
3252							$tracelevel)
3253							if defined $::RD_TRACE;
3254
3255
3256	9	50				39	$_tok = ($_noactions) ? 0 : do { $return = $item[2] };
	9					25
3257	9	50				41	unless (defined $_tok)
3258							{
3259	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
3260							if defined $::RD_TRACE;
3261	0					0	last;
3262							}
3263	9	50				71	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3264							. $_tok . q{])},
3265							Parse::RecDescent::_tracefirst($text))
3266							if defined $::RD_TRACE;
3267	9					21	push @item, $_tok;
3268	9					22	$item{__ACTION1__}=$_tok;
3269
3270
3271
3272	9	50				51	Parse::RecDescent::_trace(q{>>Matched production: [statement eof]<<},
3273							Parse::RecDescent::_tracefirst($text),
3274							q{grammar},
3275							$tracelevel)
3276							if defined $::RD_TRACE;
3277	9					18	$_matched = 1;
3278	9					22	last;
3279							}
3280
3281
3282	10	50	66			59	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
3283							{
3284
3285
3286	1					2	$_[1] = $text; # NOT SURE THIS IS NEEDED
3287	1	50				4	Parse::RecDescent::_trace(q{<>},
3288							Parse::RecDescent::_tracefirst($_[1]),
3289							q{grammar},
3290							$tracelevel)
3291							if defined $::RD_TRACE;
3292	1					9	return undef;
3293							}
3294	9	50	33			87	if (!defined($return) && defined($score))
3295							{
3296	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3297							q{grammar},
3298							$tracelevel)
3299							if defined $::RD_TRACE;
3300	0					0	$return = $score_return;
3301							}
3302	9					16	splice @{$thisparser->{errors}}, $err_at;
	9					35
3303	9	50				36	$return = $item[$#item] unless defined $return;
3304	9	50				34	if (defined $::RD_TRACE)
3305							{
3306	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3307							$return . q{])}, "",
3308							q{grammar},
3309							$tracelevel);
3310	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3311							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3312							Parse::RecDescent::_tracefirst($text),
3313							, q{grammar},
3314							$tracelevel)
3315							}
3316	9					24	$_[1] = $text;
3317	9					120	return $return;
3318							}
3319
3320							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3321							sub Parse::RecDescent::Config::ApacheExtended::Grammar::comment
3322							{
3323	33			33		66	my $thisparser = $_[0];
3324	11			11		69	use vars q{$tracelevel};
	11					25
	11					9384
3325	33		50			106	local $tracelevel = ($tracelevel\|\|0)+1;
3326	33					50	$ERRORS = 0;
3327	33					70	my $thisrule = $thisparser->{"rules"}{"comment"};
3328
3329	33	50				95	Parse::RecDescent::_trace(q{Trying rule: [comment]},
3330							Parse::RecDescent::_tracefirst($_[1]),
3331							q{comment},
3332							$tracelevel)
3333							if defined $::RD_TRACE;
3334
3335
3336	33					38	my $err_at = @{$thisparser->{errors}};
	33					62
3337
3338	33					57	my $score;
3339							my $score_return;
3340	0					0	my $_tok;
3341	33					53	my $return = undef;
3342	33					47	my $_matched=0;
3343	33					43	my $commit=0;
3344	33					54	my @item = ();
3345	33					55	my %item = ();
3346	33		33			127	my $repeating = defined($_[2]) && $_[2];
3347	33		33			122	my $_noactions = defined($_[3]) && $_[3];
3348	33	50				88	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	33					54
	33					72
3349	33	50				105	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3350	33					45	my $text;
3351	33					62	my $lastsep="";
3352	33					104	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3353	33					959	$expectation->at($_[1]);
3354
3355	33					124	my $thisline;
3356	33					138	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3357
3358
3359
3360	33		33			375	while (!$_matched && !$commit)
3361							{
3362
3363	33	50				96	Parse::RecDescent::_trace(q{Trying production: ['#' /.*/ eol]},
3364							Parse::RecDescent::_tracefirst($_[1]),
3365							q{comment},
3366							$tracelevel)
3367							if defined $::RD_TRACE;
3368	33					67	my $thisprod = $thisrule->{"prods"}[0];
3369	33					51	$text = $_[1];
3370	33					46	my $_savetext;
3371	33					65	@item = (q{comment});
3372	33					103	%item = (__RULE__ => q{comment});
3373	33					57	my $repcount = 0;
3374
3375
3376	33	50				78	Parse::RecDescent::_trace(q{Trying terminal: ['#']},
3377							Parse::RecDescent::_tracefirst($text),
3378							q{comment},
3379							$tracelevel)
3380							if defined $::RD_TRACE;
3381	33					52	$lastsep = "";
3382	33					104	$expectation->is(q{})->at($text);
3383
3384
3385	33	50	33			590	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\#//)
	33	50				340
3386							{
3387
3388	33					109	$expectation->failed();
3389	33	50				162	Parse::RecDescent::_trace(qq{<>},
3390							Parse::RecDescent::_tracefirst($text))
3391							if defined $::RD_TRACE;
3392	33					69	last;
3393							}
3394	0	0				0	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3395							. $& . q{])},
3396							Parse::RecDescent::_tracefirst($text))
3397							if defined $::RD_TRACE;
3398	0					0	push @item, $item{__STRING1__}=$&;
3399
3400
3401	0	0				0	Parse::RecDescent::_trace(q{Trying terminal: [/.*/]}, Parse::RecDescent::_tracefirst($text),
3402							q{comment},
3403							$tracelevel)
3404							if defined $::RD_TRACE;
3405	0					0	$lastsep = "";
3406	0					0	$expectation->is(q{/.*/})->at($text);
3407
3408
3409	0	0	0			0	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:.*)//)
	0	0				0
3410							{
3411
3412	0					0	$expectation->failed();
3413	0	0				0	Parse::RecDescent::_trace(q{<>},
3414							Parse::RecDescent::_tracefirst($text))
3415							if defined $::RD_TRACE;
3416
3417	0					0	last;
3418							}
3419	0	0				0	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3420							. $& . q{])},
3421							Parse::RecDescent::_tracefirst($text))
3422							if defined $::RD_TRACE;
3423	0					0	push @item, $item{__PATTERN1__}=$&;
3424
3425
3426	0	0				0	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
3427							Parse::RecDescent::_tracefirst($text),
3428							q{comment},
3429							$tracelevel)
3430							if defined $::RD_TRACE;
3431	11			11		78	if (1) { no strict qw{refs};
	11					24
	11					7823
	0					0
3432	0					0	$expectation->is(q{eol})->at($text);
3433	0	0		0		0	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	0					0
3434							{
3435
3436	0	0				0	Parse::RecDescent::_trace(q{<>},
3437							Parse::RecDescent::_tracefirst($text),
3438							q{comment},
3439							$tracelevel)
3440							if defined $::RD_TRACE;
3441	0					0	$expectation->failed();
3442	0					0	last;
3443							}
3444	0	0				0	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
3445							. $_tok . q{]},
3446
3447							Parse::RecDescent::_tracefirst($text),
3448							q{comment},
3449							$tracelevel)
3450							if defined $::RD_TRACE;
3451	0					0	$item{q{eol}} = $_tok;
3452	0					0	push @item, $_tok;
3453
3454							}
3455
3456	0	0				0	Parse::RecDescent::_trace(q{Trying action},
3457							Parse::RecDescent::_tracefirst($text),
3458							q{comment},
3459							$tracelevel)
3460							if defined $::RD_TRACE;
3461
3462
3463	0	0				0	$_tok = ($_noactions) ? 0 : do { 0 };
	0					0
3464	0	0				0	unless (defined $_tok)
3465							{
3466	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
3467							if defined $::RD_TRACE;
3468	0					0	last;
3469							}
3470	0	0				0	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3471							. $_tok . q{])},
3472							Parse::RecDescent::_tracefirst($text))
3473							if defined $::RD_TRACE;
3474	0					0	push @item, $_tok;
3475	0					0	$item{__ACTION1__}=$_tok;
3476
3477
3478
3479	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: ['#' /.*/ eol]<<},
3480							Parse::RecDescent::_tracefirst($text),
3481							q{comment},
3482							$tracelevel)
3483							if defined $::RD_TRACE;
3484	0					0	$_matched = 1;
3485	0					0	last;
3486							}
3487
3488
3489	33	50	33			314	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			33
3490							{
3491
3492
3493	33					74	$_[1] = $text; # NOT SURE THIS IS NEEDED
3494	33	50				129	Parse::RecDescent::_trace(q{<>},
3495							Parse::RecDescent::_tracefirst($_[1]),
3496							q{comment},
3497							$tracelevel)
3498							if defined $::RD_TRACE;
3499	33					237	return undef;
3500							}
3501	0	0	0			0	if (!defined($return) && defined($score))
3502							{
3503	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3504							q{comment},
3505							$tracelevel)
3506							if defined $::RD_TRACE;
3507	0					0	$return = $score_return;
3508							}
3509	0					0	splice @{$thisparser->{errors}}, $err_at;
	0					0
3510	0	0				0	$return = $item[$#item] unless defined $return;
3511	0	0				0	if (defined $::RD_TRACE)
3512							{
3513	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3514							$return . q{])}, "",
3515							q{comment},
3516							$tracelevel);
3517	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3518							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3519							Parse::RecDescent::_tracefirst($text),
3520							, q{comment},
3521							$tracelevel)
3522							}
3523	0					0	$_[1] = $text;
3524	0					0	return $return;
3525							}
3526
3527							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3528							sub Parse::RecDescent::Config::ApacheExtended::Grammar::eof
3529							{
3530	10			10		23	my $thisparser = $_[0];
3531	11			11		70	use vars q{$tracelevel};
	11					25
	11					10109
3532	10		50			44	local $tracelevel = ($tracelevel\|\|0)+1;
3533	10					26	$ERRORS = 0;
3534	10					29	my $thisrule = $thisparser->{"rules"}{"eof"};
3535
3536	10	50				61	Parse::RecDescent::_trace(q{Trying rule: [eof]},
3537							Parse::RecDescent::_tracefirst($_[1]),
3538							q{eof},
3539							$tracelevel)
3540							if defined $::RD_TRACE;
3541
3542
3543	10					18	my $err_at = @{$thisparser->{errors}};
	10					28
3544
3545	10					26	my $score;
3546							my $score_return;
3547	0					0	my $_tok;
3548	10					18	my $return = undef;
3549	10					16	my $_matched=0;
3550	10					19	my $commit=0;
3551	10					21	my @item = ();
3552	10					21	my %item = ();
3553	10		33			94	my $repeating = defined($_[2]) && $_[2];
3554	10		33			53	my $_noactions = defined($_[3]) && $_[3];
3555	10	50				38	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	10					19
	10					33
3556	10	50				76	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3557	10					17	my $text;
3558	10					27	my $lastsep="";
3559	10					53	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3560	10					372	$expectation->at($_[1]);
3561
3562	10					122	my $thisline;
3563	10					53	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3564
3565
3566
3567	10		33			133	while (!$_matched && !$commit)
3568							{
3569
3570	10	50				51	Parse::RecDescent::_trace(q{Trying production: [/^\\z/]},
3571							Parse::RecDescent::_tracefirst($_[1]),
3572							q{eof},
3573							$tracelevel)
3574							if defined $::RD_TRACE;
3575	10					27	my $thisprod = $thisrule->{"prods"}[0];
3576	10					22	$text = $_[1];
3577	10					16	my $_savetext;
3578	10					29	@item = (q{eof});
3579	10					35	%item = (__RULE__ => q{eof});
3580	10					483	my $repcount = 0;
3581
3582
3583	10	50				41	Parse::RecDescent::_trace(q{Trying terminal: [/^\\z/]}, Parse::RecDescent::_tracefirst($text),
3584							q{eof},
3585							$tracelevel)
3586							if defined $::RD_TRACE;
3587	10					18	$lastsep = "";
3588	10					51	$expectation->is(q{})->at($text);
3589
3590
3591	10	50	66			244	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:^\z)//)
	10	100				272
3592							{
3593
3594	1					5	$expectation->failed();
3595	1	50				6	Parse::RecDescent::_trace(q{<>},
3596							Parse::RecDescent::_tracefirst($text))
3597							if defined $::RD_TRACE;
3598
3599	1					3	last;
3600							}
3601	9	50				47	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3602							. $& . q{])},
3603							Parse::RecDescent::_tracefirst($text))
3604							if defined $::RD_TRACE;
3605	9					38	push @item, $item{__PATTERN1__}=$&;
3606
3607
3608
3609	9	50				50	Parse::RecDescent::_trace(q{>>Matched production: [/^\\z/]<<},
3610							Parse::RecDescent::_tracefirst($text),
3611							q{eof},
3612							$tracelevel)
3613							if defined $::RD_TRACE;
3614	9					22	$_matched = 1;
3615	9					25	last;
3616							}
3617
3618
3619	10	50	66			56	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
3620							{
3621
3622
3623	1					2	$_[1] = $text; # NOT SURE THIS IS NEEDED
3624	1	50				4	Parse::RecDescent::_trace(q{<>},
3625							Parse::RecDescent::_tracefirst($_[1]),
3626							q{eof},
3627							$tracelevel)
3628							if defined $::RD_TRACE;
3629	1					9	return undef;
3630							}
3631	9	50	33			95	if (!defined($return) && defined($score))
3632							{
3633	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3634							q{eof},
3635							$tracelevel)
3636							if defined $::RD_TRACE;
3637	0					0	$return = $score_return;
3638							}
3639	9					19	splice @{$thisparser->{errors}}, $err_at;
	9					32
3640	9	50				48	$return = $item[$#item] unless defined $return;
3641	9	50				48	if (defined $::RD_TRACE)
3642							{
3643	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3644							$return . q{])}, "",
3645							q{eof},
3646							$tracelevel);
3647	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3648							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3649							Parse::RecDescent::_tracefirst($text),
3650							, q{eof},
3651							$tracelevel)
3652							}
3653	9					20	$_[1] = $text;
3654	9					98	return $return;
3655							}
3656
3657							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3658							sub Parse::RecDescent::Config::ApacheExtended::Grammar::block_end
3659							{
3660	84			84		147	my $thisparser = $_[0];
3661	11			11		79	use vars q{$tracelevel};
	11					18
	11					6538
3662	84		50			230	local $tracelevel = ($tracelevel\|\|0)+1;
3663	84					119	$ERRORS = 0;
3664	84					169	my $thisrule = $thisparser->{"rules"}{"block_end"};
3665
3666	84	50				194	Parse::RecDescent::_trace(q{Trying rule: [block_end]},
3667							Parse::RecDescent::_tracefirst($_[1]),
3668							q{block_end},
3669							$tracelevel)
3670							if defined $::RD_TRACE;
3671
3672
3673	84					101	my $err_at = @{$thisparser->{errors}};
	84					155
3674
3675	84					109	my $score;
3676							my $score_return;
3677	0					0	my $_tok;
3678	84					106	my $return = undef;
3679	84					107	my $_matched=0;
3680	84					100	my $commit=0;
3681	84					130	my @item = ();
3682	84					123	my %item = ();
3683	84		33			257	my $repeating = defined($_[2]) && $_[2];
3684	84		33			260	my $_noactions = defined($_[3]) && $_[3];
3685	84	50				182	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	84					100
	84					301
3686	84	50				242	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3687	84					104	my $text;
3688	84					116	my $lastsep="";
3689	84					242	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3690	84					2604	$expectation->at($_[1]);
3691
3692	84					315	my $thisline;
3693	84					348	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3694
3695
3696
3697	84		33			810	while (!$_matched && !$commit)
3698							{
3699
3700	84	50				254	Parse::RecDescent::_trace(q{Trying production: ['' eol]},
3701							Parse::RecDescent::_tracefirst($_[1]),
3702							q{block_end},
3703							$tracelevel)
3704							if defined $::RD_TRACE;
3705	84					147	my $thisprod = $thisrule->{"prods"}[0];
3706	84					123	$text = $_[1];
3707	84					97	my $_savetext;
3708	84					149	@item = (q{block_end});
3709	84					191	%item = (__RULE__ => q{block_end});
3710	84					98	my $repcount = 0;
3711
3712
3713	84	50				163	Parse::RecDescent::_trace(q{Trying terminal: ['
3714							Parse::RecDescent::_tracefirst($text),
3715							q{block_end},
3716							$tracelevel)
3717							if defined $::RD_TRACE;
3718	84					120	$lastsep = "";
3719	84					249	$expectation->is(q{})->at($text);
3720
3721
3722	84	100	66			1008	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\<\///)
	84	100				762
3723							{
3724
3725	76					221	$expectation->failed();
3726	76	50				387	Parse::RecDescent::_trace(qq{<>},
3727							Parse::RecDescent::_tracefirst($text))
3728							if defined $::RD_TRACE;
3729	76					152	last;
3730							}
3731	8	50				62	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3732							. $& . q{])},
3733							Parse::RecDescent::_tracefirst($text))
3734							if defined $::RD_TRACE;
3735	8					27	push @item, $item{__STRING1__}=$&;
3736
3737
3738	8	50				29	Parse::RecDescent::_trace(q{Trying subrule: [key]},
3739							Parse::RecDescent::_tracefirst($text),
3740							q{block_end},
3741							$tracelevel)
3742							if defined $::RD_TRACE;
3743	11			11		64	if (1) { no strict qw{refs};
	11					27
	11					4431
	8					11
3744	8					42	$expectation->is(q{key})->at($text);
3745	8	50		8		109	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::key($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	8					30
3746							{
3747
3748	0	0				0	Parse::RecDescent::_trace(q{<>},
3749							Parse::RecDescent::_tracefirst($text),
3750							q{block_end},
3751							$tracelevel)
3752							if defined $::RD_TRACE;
3753	0					0	$expectation->failed();
3754	0					0	last;
3755							}
3756	8	50				46	Parse::RecDescent::_trace(q{>>Matched subrule: [key]<< (return value: [}
3757							. $_tok . q{]},
3758
3759							Parse::RecDescent::_tracefirst($text),
3760							q{block_end},
3761							$tracelevel)
3762							if defined $::RD_TRACE;
3763	8					23	$item{q{key}} = $_tok;
3764	8					20	push @item, $_tok;
3765
3766							}
3767
3768	8	50				31	Parse::RecDescent::_trace(q{Trying terminal: ['>']},
3769							Parse::RecDescent::_tracefirst($text),
3770							q{block_end},
3771							$tracelevel)
3772							if defined $::RD_TRACE;
3773	8					16	$lastsep = "";
3774	8					29	$expectation->is(q{'>'})->at($text);
3775
3776
3777	8	50	33			235	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\>//)
	8	50				138
3778							{
3779
3780	0					0	$expectation->failed();
3781	0	0				0	Parse::RecDescent::_trace(qq{<>},
3782							Parse::RecDescent::_tracefirst($text))
3783							if defined $::RD_TRACE;
3784	0					0	last;
3785							}
3786	8	50				39	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
3787							. $& . q{])},
3788							Parse::RecDescent::_tracefirst($text))
3789							if defined $::RD_TRACE;
3790	8					32	push @item, $item{__STRING2__}=$&;
3791
3792
3793	8	50				29	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
3794							Parse::RecDescent::_tracefirst($text),
3795							q{block_end},
3796							$tracelevel)
3797							if defined $::RD_TRACE;
3798	11			11		70	if (1) { no strict qw{refs};
	11					28
	11					8320
	8					16
3799	8					42	$expectation->is(q{eol})->at($text);
3800	8	50		8		93	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	8					29
3801							{
3802
3803	0	0				0	Parse::RecDescent::_trace(q{<>},
3804							Parse::RecDescent::_tracefirst($text),
3805							q{block_end},
3806							$tracelevel)
3807							if defined $::RD_TRACE;
3808	0					0	$expectation->failed();
3809	0					0	last;
3810							}
3811	8	50				57	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
3812							. $_tok . q{]},
3813
3814							Parse::RecDescent::_tracefirst($text),
3815							q{block_end},
3816							$tracelevel)
3817							if defined $::RD_TRACE;
3818	8					22	$item{q{eol}} = $_tok;
3819	8					19	push @item, $_tok;
3820
3821							}
3822
3823	8	50				30	Parse::RecDescent::_trace(q{Trying action},
3824							Parse::RecDescent::_tracefirst($text),
3825							q{block_end},
3826							$tracelevel)
3827							if defined $::RD_TRACE;
3828
3829
3830	8	50				27	$_tok = ($_noactions) ? 0 : do { $return = $data->endBlock($item[2]) };
	8					64
3831	8	50				35	unless (defined $_tok)
3832							{
3833	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
3834							if defined $::RD_TRACE;
3835	0					0	last;
3836							}
3837	8	50				31	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
3838							. $_tok . q{])},
3839							Parse::RecDescent::_tracefirst($text))
3840							if defined $::RD_TRACE;
3841	8					36	push @item, $_tok;
3842	8					19	$item{__ACTION1__}=$_tok;
3843
3844
3845
3846	8	50				29	Parse::RecDescent::_trace(q{>>Matched production: ['' eol]<<},
3847							Parse::RecDescent::_tracefirst($text),
3848							q{block_end},
3849							$tracelevel)
3850							if defined $::RD_TRACE;
3851	8					13	$_matched = 1;
3852	8					26	last;
3853							}
3854
3855
3856	84	50	66			551	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
3857							{
3858
3859
3860	76					155	$_[1] = $text; # NOT SURE THIS IS NEEDED
3861	76	50				151	Parse::RecDescent::_trace(q{<>},
3862							Parse::RecDescent::_tracefirst($_[1]),
3863							q{block_end},
3864							$tracelevel)
3865							if defined $::RD_TRACE;
3866	76					539	return undef;
3867							}
3868	8	50	33			39	if (!defined($return) && defined($score))
3869							{
3870	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
3871							q{block_end},
3872							$tracelevel)
3873							if defined $::RD_TRACE;
3874	0					0	$return = $score_return;
3875							}
3876	8					16	splice @{$thisparser->{errors}}, $err_at;
	8					20
3877	8	50				173	$return = $item[$#item] unless defined $return;
3878	8	50				49	if (defined $::RD_TRACE)
3879							{
3880	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
3881							$return . q{])}, "",
3882							q{block_end},
3883							$tracelevel);
3884	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
3885							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
3886							Parse::RecDescent::_tracefirst($text),
3887							, q{block_end},
3888							$tracelevel)
3889							}
3890	8					19	$_[1] = $text;
3891	8					78	return $return;
3892							}
3893
3894							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
3895							sub Parse::RecDescent::Config::ApacheExtended::Grammar::directive
3896							{
3897	86			86		656	my $thisparser = $_[0];
3898	11			11		66	use vars q{$tracelevel};
	11					20
	11					6023
3899	86		50			268	local $tracelevel = ($tracelevel\|\|0)+1;
3900	86					122	$ERRORS = 0;
3901	86					196	my $thisrule = $thisparser->{"rules"}{"directive"};
3902
3903	86	50				280	Parse::RecDescent::_trace(q{Trying rule: [directive]},
3904							Parse::RecDescent::_tracefirst($_[1]),
3905							q{directive},
3906							$tracelevel)
3907							if defined $::RD_TRACE;
3908
3909
3910	86					98	my $err_at = @{$thisparser->{errors}};
	86					171
3911
3912	86					115	my $score;
3913							my $score_return;
3914	0					0	my $_tok;
3915	86					115	my $return = undef;
3916	86					119	my $_matched=0;
3917	86					782	my $commit=0;
3918	86					218	my @item = ();
3919	86					132	my %item = ();
3920	86		66			257	my $repeating = defined($_[2]) && $_[2];
3921	86		66			232	my $_noactions = defined($_[3]) && $_[3];
3922	86	50				190	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	86					105
	86					166
3923	86	50				291	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
3924	86					106	my $text;
3925	86					157	my $lastsep="";
3926	86					396	my $expectation = new Parse::RecDescent::Expectation($thisrule->expected());
3927	86					4013	$expectation->at($_[1]);
3928
3929	86					318	my $thisline;
3930	86					544	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
3931
3932
3933
3934	86		33			919	while (!$_matched && !$commit)
3935							{
3936
3937	86	50				196	Parse::RecDescent::_trace(q{Trying production: [key val eol]},
3938							Parse::RecDescent::_tracefirst($_[1]),
3939							q{directive},
3940							$tracelevel)
3941							if defined $::RD_TRACE;
3942	86					152	my $thisprod = $thisrule->{"prods"}[0];
3943	86					127	$text = $_[1];
3944	86					90	my $_savetext;
3945	86					165	@item = (q{directive});
3946	86					176	%item = (__RULE__ => q{directive});
3947	86					103	my $repcount = 0;
3948
3949
3950	86	50				197	Parse::RecDescent::_trace(q{Trying subrule: [key]},
3951							Parse::RecDescent::_tracefirst($text),
3952							q{directive},
3953							$tracelevel)
3954							if defined $::RD_TRACE;
3955	11			11		70	if (1) { no strict qw{refs};
	11					23
	11					10775
	86					88
3956	86					247	$expectation->is(q{})->at($text);
3957	86	100		86		863	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::key($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	86					187
3958							{
3959
3960	32	50				93	Parse::RecDescent::_trace(q{<>},
3961							Parse::RecDescent::_tracefirst($text),
3962							q{directive},
3963							$tracelevel)
3964							if defined $::RD_TRACE;
3965	32					236	$expectation->failed();
3966	32					127	last;
3967							}
3968	54	50				211	Parse::RecDescent::_trace(q{>>Matched subrule: [key]<< (return value: [}
3969							. $_tok . q{]},
3970
3971							Parse::RecDescent::_tracefirst($text),
3972							q{directive},
3973							$tracelevel)
3974							if defined $::RD_TRACE;
3975	54					105	$item{q{key}} = $_tok;
3976	54					102	push @item, $_tok;
3977
3978							}
3979
3980	54	50				117	Parse::RecDescent::_trace(q{Trying repeated subrule: [val]},
3981							Parse::RecDescent::_tracefirst($text),
3982							q{directive},
3983							$tracelevel)
3984							if defined $::RD_TRACE;
3985	54					166	$expectation->is(q{val})->at($text);
3986
3987	54	100				596	unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::Config::ApacheExtended::Grammar::val, 1, 100000000, $_noactions,$expectation,undef)))
3988							{
3989	5	50				89	Parse::RecDescent::_trace(q{<>},
3990							Parse::RecDescent::_tracefirst($text),
3991							q{directive},
3992							$tracelevel)
3993							if defined $::RD_TRACE;
3994	5					13	last;
3995							}
3996	49	50				641	Parse::RecDescent::_trace(q{>>Matched repeated subrule: [val]<< (}
3997							. @$_tok . q{ times)},
3998
3999							Parse::RecDescent::_tracefirst($text),
4000							q{directive},
4001							$tracelevel)
4002							if defined $::RD_TRACE;
4003	49					108	$item{q{val(s)}} = $_tok;
4004	49					78	push @item, $_tok;
4005
4006
4007
4008
4009
4010	49	50				102	Parse::RecDescent::_trace(q{Trying directive: []},
4011							Parse::RecDescent::_tracefirst($text),
4012							q{directive},
4013							$tracelevel)
4014							if defined $::RD_TRACE;
4015	49					57	$_tok = do { $commit = 1 };
	49					89
4016	49	50				102	if (defined($_tok))
4017							{
4018	49	50				113	Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
4019							. $_tok . q{])},
4020							Parse::RecDescent::_tracefirst($text))
4021							if defined $::RD_TRACE;
4022							}
4023							else
4024							{
4025	0	0				0	Parse::RecDescent::_trace(q{<>},
4026							Parse::RecDescent::_tracefirst($text))
4027							if defined $::RD_TRACE;
4028							}
4029
4030	49	50				103	last unless defined $_tok;
4031	49					112	push @item, $item{__DIRECTIVE1__}=$_tok;
4032
4033
4034	49	50				111	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
4035							Parse::RecDescent::_tracefirst($text),
4036							q{directive},
4037							$tracelevel)
4038							if defined $::RD_TRACE;
4039	11			11		148	if (1) { no strict qw{refs};
	11					23
	11					5573
	49					55
4040	49					166	$expectation->is(q{eol})->at($text);
4041	49	50		49		524	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	49					111
4042							{
4043
4044	0	0				0	Parse::RecDescent::_trace(q{<>},
4045							Parse::RecDescent::_tracefirst($text),
4046							q{directive},
4047							$tracelevel)
4048							if defined $::RD_TRACE;
4049	0					0	$expectation->failed();
4050	0					0	last;
4051							}
4052	49	50				193	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
4053							. $_tok . q{]},
4054
4055							Parse::RecDescent::_tracefirst($text),
4056							q{directive},
4057							$tracelevel)
4058							if defined $::RD_TRACE;
4059	49					98	$item{q{eol}} = $_tok;
4060	49					88	push @item, $_tok;
4061
4062							}
4063
4064	49	50				114	Parse::RecDescent::_trace(q{Trying action},
4065							Parse::RecDescent::_tracefirst($text),
4066							q{directive},
4067							$tracelevel)
4068							if defined $::RD_TRACE;
4069
4070
4071	49	50				102	$_tok = ($_noactions) ? 0 : do { $return = $data->newDirective($item[1], $item[2]) };
	49					258
4072	49	100				130	unless (defined $_tok)
4073							{
4074	1	50				4	Parse::RecDescent::_trace(q{<> (return value: [undef])})
4075							if defined $::RD_TRACE;
4076	1					3	last;
4077							}
4078	48	50				113	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4079							. $_tok . q{])},
4080							Parse::RecDescent::_tracefirst($text))
4081							if defined $::RD_TRACE;
4082	48					93	push @item, $_tok;
4083	48					114	$item{__ACTION1__}=$_tok;
4084
4085
4086
4087	48	50				104	Parse::RecDescent::_trace(q{>>Matched production: [key val eol]<<},
4088							Parse::RecDescent::_tracefirst($text),
4089							q{directive},
4090							$tracelevel)
4091							if defined $::RD_TRACE;
4092	48					60	$_matched = 1;
4093	48					82	last;
4094							}
4095
4096
4097	86		66			341	while (!$_matched && !$commit)
4098							{
4099
4100	37	50				97	Parse::RecDescent::_trace(q{Trying production: [key eol]},
4101							Parse::RecDescent::_tracefirst($_[1]),
4102							q{directive},
4103							$tracelevel)
4104							if defined $::RD_TRACE;
4105	37					131	my $thisprod = $thisrule->{"prods"}[1];
4106	37					57	$text = $_[1];
4107	37					46	my $_savetext;
4108	37					102	@item = (q{directive});
4109	37					96	%item = (__RULE__ => q{directive});
4110	37					49	my $repcount = 0;
4111
4112
4113	37	50				95	Parse::RecDescent::_trace(q{Trying subrule: [key]},
4114							Parse::RecDescent::_tracefirst($text),
4115							q{directive},
4116							$tracelevel)
4117							if defined $::RD_TRACE;
4118	11			11		67	if (1) { no strict qw{refs};
	11					22
	11					2502
	37					50
4119	37					117	$expectation->is(q{})->at($text);
4120	37	100		37		361	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::key($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	37					82
4121							{
4122
4123	32	50				84	Parse::RecDescent::_trace(q{<>},
4124							Parse::RecDescent::_tracefirst($text),
4125							q{directive},
4126							$tracelevel)
4127							if defined $::RD_TRACE;
4128	32					114	$expectation->failed();
4129	32					127	last;
4130							}
4131	5	50				32	Parse::RecDescent::_trace(q{>>Matched subrule: [key]<< (return value: [}
4132							. $_tok . q{]},
4133
4134							Parse::RecDescent::_tracefirst($text),
4135							q{directive},
4136							$tracelevel)
4137							if defined $::RD_TRACE;
4138	5					13	$item{q{key}} = $_tok;
4139	5					12	push @item, $_tok;
4140
4141							}
4142
4143	5	50				19	Parse::RecDescent::_trace(q{Trying subrule: [eol]},
4144							Parse::RecDescent::_tracefirst($text),
4145							q{directive},
4146							$tracelevel)
4147							if defined $::RD_TRACE;
4148	11			11		81	if (1) { no strict qw{refs};
	11					77
	11					61224
	5					6
4149	5					28	$expectation->is(q{eol})->at($text);
4150	5	50		5		57	unless (defined ($_tok = Parse::RecDescent::Config::ApacheExtended::Grammar::eol($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	5					13
4151							{
4152
4153	0	0				0	Parse::RecDescent::_trace(q{<>},
4154							Parse::RecDescent::_tracefirst($text),
4155							q{directive},
4156							$tracelevel)
4157							if defined $::RD_TRACE;
4158	0					0	$expectation->failed();
4159	0					0	last;
4160							}
4161	5	50				28	Parse::RecDescent::_trace(q{>>Matched subrule: [eol]<< (return value: [}
4162							. $_tok . q{]},
4163
4164							Parse::RecDescent::_tracefirst($text),
4165							q{directive},
4166							$tracelevel)
4167							if defined $::RD_TRACE;
4168	5					13	$item{q{eol}} = $_tok;
4169	5					13	push @item, $_tok;
4170
4171							}
4172
4173	5	50				25	Parse::RecDescent::_trace(q{Trying action},
4174							Parse::RecDescent::_tracefirst($text),
4175							q{directive},
4176							$tracelevel)
4177							if defined $::RD_TRACE;
4178
4179
4180	5	50				34	$_tok = ($_noactions) ? 0 : do { $return = $data->newDirective($item[1], [1]) };
	5					38
4181	5	50				20	unless (defined $_tok)
4182							{
4183	0	0				0	Parse::RecDescent::_trace(q{<> (return value: [undef])})
4184							if defined $::RD_TRACE;
4185	0					0	last;
4186							}
4187	5	50				17	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
4188							. $_tok . q{])},
4189							Parse::RecDescent::_tracefirst($text))
4190							if defined $::RD_TRACE;
4191	5					11	push @item, $_tok;
4192	5					14	$item{__ACTION1__}=$_tok;
4193
4194
4195
4196	5	50				15	Parse::RecDescent::_trace(q{>>Matched production: [key eol]<<},
4197							Parse::RecDescent::_tracefirst($text),
4198							q{directive},
4199							$tracelevel)
4200							if defined $::RD_TRACE;
4201	5					8	$_matched = 1;
4202	5					8	last;
4203							}
4204
4205
4206	86	50	66			515	unless ( $_matched \|\| defined($return) \|\| defined($score) )
			66
4207							{
4208
4209
4210	33					61	$_[1] = $text; # NOT SURE THIS IS NEEDED
4211	33	50				88	Parse::RecDescent::_trace(q{<>},
4212							Parse::RecDescent::_tracefirst($_[1]),
4213							q{directive},
4214							$tracelevel)
4215							if defined $::RD_TRACE;
4216	33					233	return undef;
4217							}
4218	53	50	33			224	if (!defined($return) && defined($score))
4219							{
4220	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
4221							q{directive},
4222							$tracelevel)
4223							if defined $::RD_TRACE;
4224	0					0	$return = $score_return;
4225							}
4226	53					64	splice @{$thisparser->{errors}}, $err_at;
	53					238
4227	53	50				140	$return = $item[$#item] unless defined $return;
4228	53	50				119	if (defined $::RD_TRACE)
4229							{
4230	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
4231							$return . q{])}, "",
4232							q{directive},
4233							$tracelevel);
4234	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
4235							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
4236							Parse::RecDescent::_tracefirst($text),
4237							, q{directive},
4238							$tracelevel)
4239							}
4240	53					87	$_[1] = $text;
4241	53					457	return $return;
4242							}
4243							}
4244	10			10	0	6786	package Config::ApacheExtended::Grammar; sub new { my $self = bless( {
4245							'_AUTOTREE' => undef,
4246							'localvars' => '',
4247							'startcode' => '',
4248							'_check' => {
4249							'thisoffset' => '',
4250							'itempos' => '',
4251							'prevoffset' => '',
4252							'prevline' => '',
4253							'prevcolumn' => '',
4254							'thiscolumn' => ''
4255							},
4256							'namespace' => 'Parse::RecDescent::Config::ApacheExtended::Grammar',
4257							'_AUTOACTION' => undef,
4258							'rules' => {
4259							'hereto_mark' => bless( {
4260							'impcount' => 0,
4261							'calls' => [
4262							'val'
4263							],
4264							'changed' => 0,
4265							'opcount' => 0,
4266							'prods' => [
4267							bless( {
4268							'number' => '0',
4269							'strcount' => 0,
4270							'dircount' => 0,
4271							'uncommit' => undef,
4272							'error' => undef,
4273							'patcount' => 0,
4274							'actcount' => 0,
4275							'items' => [
4276							bless( {
4277							'subrule' => 'val',
4278							'matchrule' => 0,
4279							'implicit' => undef,
4280							'argcode' => undef,
4281							'lookahead' => 0,
4282							'line' => 35
4283							}, 'Parse::RecDescent::Subrule' )
4284							],
4285							'line' => undef
4286							}, 'Parse::RecDescent::Production' )
4287							],
4288							'name' => 'hereto_mark',
4289							'vars' => '',
4290							'line' => 35
4291							}, 'Parse::RecDescent::Rule' ),
4292							'eol' => bless( {
4293							'impcount' => 0,
4294							'calls' => [],
4295							'changed' => 0,
4296							'opcount' => 0,
4297							'prods' => [
4298							bless( {
4299							'number' => '0',
4300							'strcount' => 0,
4301							'dircount' => 0,
4302							'uncommit' => undef,
4303							'error' => undef,
4304							'patcount' => 1,
4305							'actcount' => 0,
4306							'items' => [
4307							bless( {
4308							'pattern' => '\\n',
4309							'hashname' => '__PATTERN1__',
4310							'description' => '/\\\\n/',
4311							'lookahead' => 0,
4312							'rdelim' => '/',
4313							'line' => 45,
4314							'mod' => '',
4315							'ldelim' => '/'
4316							}, 'Parse::RecDescent::Token' )
4317							],
4318							'line' => undef
4319							}, 'Parse::RecDescent::Production' )
4320							],
4321							'name' => 'eol',
4322							'vars' => '',
4323							'line' => 45
4324							}, 'Parse::RecDescent::Rule' ),
4325							'skipline' => bless( {
4326							'impcount' => 0,
4327							'calls' => [
4328							'comment',
4329							'eol'
4330							],
4331							'changed' => 0,
4332							'opcount' => 0,
4333							'prods' => [
4334							bless( {
4335							'number' => '0',
4336							'strcount' => 0,
4337							'dircount' => 0,
4338							'uncommit' => undef,
4339							'error' => undef,
4340							'patcount' => 0,
4341							'actcount' => 0,
4342							'items' => [
4343							bless( {
4344							'subrule' => 'comment',
4345							'matchrule' => 0,
4346							'implicit' => undef,
4347							'argcode' => undef,
4348							'lookahead' => 0,
4349							'line' => 32
4350							}, 'Parse::RecDescent::Subrule' )
4351							],
4352							'line' => undef
4353							}, 'Parse::RecDescent::Production' ),
4354							bless( {
4355							'number' => '1',
4356							'strcount' => 0,
4357							'dircount' => 0,
4358							'uncommit' => undef,
4359							'error' => undef,
4360							'patcount' => 0,
4361							'actcount' => 1,
4362							'items' => [
4363							bless( {
4364							'subrule' => 'eol',
4365							'matchrule' => 0,
4366							'implicit' => undef,
4367							'argcode' => undef,
4368							'lookahead' => 0,
4369							'line' => 32
4370							}, 'Parse::RecDescent::Subrule' ),
4371							bless( {
4372							'hashname' => '__ACTION1__',
4373							'lookahead' => 0,
4374							'line' => 32,
4375							'code' => '{ 0 }'
4376							}, 'Parse::RecDescent::Action' )
4377							],
4378							'line' => 32
4379							}, 'Parse::RecDescent::Production' )
4380							],
4381							'name' => 'skipline',
4382							'vars' => '',
4383							'line' => 29
4384							}, 'Parse::RecDescent::Rule' ),
4385							'include' => bless( {
4386							'impcount' => 0,
4387							'calls' => [
4388							'val',
4389							'eol'
4390							],
4391							'changed' => 0,
4392							'opcount' => 0,
4393							'prods' => [
4394							bless( {
4395							'number' => '0',
4396							'strcount' => 0,
4397							'dircount' => 0,
4398							'uncommit' => undef,
4399							'error' => undef,
4400							'patcount' => 1,
4401							'actcount' => 1,
4402							'items' => [
4403							bless( {
4404							'pattern' => '\\binclude\\b',
4405							'hashname' => '__PATTERN1__',
4406							'description' => '/\\\\binclude\\\\b/i',
4407							'lookahead' => 0,
4408							'rdelim' => '/',
4409							'line' => 27,
4410							'mod' => 'i',
4411							'ldelim' => '/'
4412							}, 'Parse::RecDescent::Token' ),
4413							bless( {
4414							'subrule' => 'val',
4415							'matchrule' => 0,
4416							'implicit' => undef,
4417							'argcode' => undef,
4418							'lookahead' => 0,
4419							'line' => 27
4420							}, 'Parse::RecDescent::Subrule' ),
4421							bless( {
4422							'subrule' => 'eol',
4423							'matchrule' => 0,
4424							'implicit' => undef,
4425							'argcode' => undef,
4426							'lookahead' => 0,
4427							'line' => 27
4428							}, 'Parse::RecDescent::Subrule' ),
4429							bless( {
4430							'hashname' => '__ACTION1__',
4431							'lookahead' => 0,
4432							'line' => 27,
4433							'code' => '{ if ( $data->include ) { $text = $data->_loadFile($item[2]) . $text; } else { $return = undef; } }'
4434							}, 'Parse::RecDescent::Action' )
4435							],
4436							'line' => undef
4437							}, 'Parse::RecDescent::Production' )
4438							],
4439							'name' => 'include',
4440							'vars' => '',
4441							'line' => 27
4442							}, 'Parse::RecDescent::Rule' ),
4443							'block_start' => bless( {
4444							'impcount' => 0,
4445							'calls' => [
4446							'key',
4447							'block_val',
4448							'eol'
4449							],
4450							'changed' => 0,
4451							'opcount' => 0,
4452							'prods' => [
4453							bless( {
4454							'number' => '0',
4455							'strcount' => 2,
4456							'dircount' => 0,
4457							'uncommit' => undef,
4458							'error' => undef,
4459							'patcount' => 0,
4460							'actcount' => 1,
4461							'items' => [
4462							bless( {
4463							'pattern' => '<',
4464							'hashname' => '__STRING1__',
4465							'description' => '\'<\'',
4466							'lookahead' => 0,
4467							'line' => 20
4468							}, 'Parse::RecDescent::Literal' ),
4469							bless( {
4470							'subrule' => 'key',
4471							'matchrule' => 0,
4472							'implicit' => undef,
4473							'argcode' => undef,
4474							'lookahead' => 0,
4475							'line' => 20
4476							}, 'Parse::RecDescent::Subrule' ),
4477							bless( {
4478							'subrule' => 'block_val',
4479							'expected' => undef,
4480							'min' => 0,
4481							'argcode' => undef,
4482							'max' => 100000000,
4483							'matchrule' => 0,
4484							'repspec' => 's?',
4485							'lookahead' => 0,
4486							'line' => 20
4487							}, 'Parse::RecDescent::Repetition' ),
4488							bless( {
4489							'pattern' => '>',
4490							'hashname' => '__STRING2__',
4491							'description' => '\'>\'',
4492							'lookahead' => 0,
4493							'line' => 20
4494							}, 'Parse::RecDescent::Literal' ),
4495							bless( {
4496							'subrule' => 'eol',
4497							'matchrule' => 0,
4498							'implicit' => undef,
4499							'argcode' => undef,
4500							'lookahead' => 0,
4501							'line' => 20
4502							}, 'Parse::RecDescent::Subrule' ),
4503							bless( {
4504							'hashname' => '__ACTION1__',
4505							'lookahead' => 0,
4506							'line' => 21,
4507							'code' => '{ $return = $data->beginBlock($item[2], $item[3]) }'
4508							}, 'Parse::RecDescent::Action' )
4509							],
4510							'line' => undef
4511							}, 'Parse::RecDescent::Production' )
4512							],
4513							'name' => 'block_start',
4514							'vars' => '',
4515							'line' => 19
4516							}, 'Parse::RecDescent::Rule' ),
4517							'key' => bless( {
4518							'impcount' => 0,
4519							'calls' => [],
4520							'changed' => 0,
4521							'opcount' => 0,
4522							'prods' => [
4523							bless( {
4524							'number' => '0',
4525							'strcount' => 0,
4526							'dircount' => 0,
4527							'uncommit' => undef,
4528							'error' => undef,
4529							'patcount' => 1,
4530							'actcount' => 0,
4531							'items' => [
4532							bless( {
4533							'pattern' => '\\w+',
4534							'hashname' => '__PATTERN1__',
4535							'description' => '/\\\\w+/',
4536							'lookahead' => 0,
4537							'rdelim' => '/',
4538							'line' => 39,
4539							'mod' => '',
4540							'ldelim' => '/'
4541							}, 'Parse::RecDescent::Token' )
4542							],
4543							'line' => undef
4544							}, 'Parse::RecDescent::Production' )
4545							],
4546							'name' => 'key',
4547							'vars' => '',
4548							'line' => 39
4549							}, 'Parse::RecDescent::Rule' ),
4550							'statement' => bless( {
4551							'impcount' => 1,
4552							'calls' => [
4553							'_alternation_1_of_production_1_of_rule_statement'
4554							],
4555							'changed' => 0,
4556							'opcount' => 0,
4557							'prods' => [
4558							bless( {
4559							'number' => '0',
4560							'strcount' => 0,
4561							'dircount' => 1,
4562							'uncommit' => undef,
4563							'error' => undef,
4564							'patcount' => 0,
4565							'actcount' => 0,
4566							'items' => [
4567							bless( {
4568							'hashname' => '__DIRECTIVE1__',
4569							'name' => '',
4570							'lookahead' => 0,
4571							'line' => 5,
4572							'code' => 'my $oldskip = $skip; $skip= qr/[ \\t]*/; $oldskip'
4573							}, 'Parse::RecDescent::Directive' ),
4574							bless( {
4575							'subrule' => '_alternation_1_of_production_1_of_rule_statement',
4576							'matchrule' => 0,
4577							'implicit' => 'include, or multiline_directive, or hereto_directive, or block_start, or block_end, or directive, or skipline',
4578							'argcode' => undef,
4579							'lookahead' => 0,
4580							'line' => 5
4581							}, 'Parse::RecDescent::Subrule' )
4582							],
4583							'line' => undef
4584							}, 'Parse::RecDescent::Production' )
4585							],
4586							'name' => 'statement',
4587							'vars' => '',
4588							'line' => 5
4589							}, 'Parse::RecDescent::Rule' ),
4590							'quote' => bless( {
4591							'impcount' => 0,
4592							'calls' => [],
4593							'changed' => 0,
4594							'opcount' => 0,
4595							'prods' => [
4596							bless( {
4597							'number' => '0',
4598							'strcount' => 0,
4599							'dircount' => 0,
4600							'uncommit' => undef,
4601							'error' => undef,
4602							'patcount' => 1,
4603							'actcount' => 1,
4604							'items' => [
4605							bless( {
4606							'pattern' => '([\'"])(.*?)(?
4607							'hashname' => '__PATTERN1__',
4608							'description' => '/([\'"])(.*?)(?
4609							'lookahead' => 0,
4610							'rdelim' => '/',
4611							'line' => 43,
4612							'mod' => 's',
4613							'ldelim' => '/'
4614							}, 'Parse::RecDescent::Token' ),
4615							bless( {
4616							'hashname' => '__ACTION1__',
4617							'lookahead' => 0,
4618							'line' => 43,
4619							'code' => '{ $2 }'
4620							}, 'Parse::RecDescent::Action' )
4621							],
4622							'line' => undef
4623							}, 'Parse::RecDescent::Production' )
4624							],
4625							'name' => 'quote',
4626							'vars' => '',
4627							'line' => 42
4628							}, 'Parse::RecDescent::Rule' ),
4629							'_alternation_1_of_production_1_of_rule_statement' => bless( {
4630							'impcount' => 0,
4631							'calls' => [
4632							'include',
4633							'multiline_directive',
4634							'hereto_directive',
4635							'block_start',
4636							'block_end',
4637							'directive',
4638							'skipline'
4639							],
4640							'changed' => 0,
4641							'opcount' => 0,
4642							'prods' => [
4643							bless( {
4644							'number' => '0',
4645							'strcount' => 0,
4646							'dircount' => 0,
4647							'uncommit' => undef,
4648							'error' => undef,
4649							'patcount' => 0,
4650							'actcount' => 0,
4651							'items' => [
4652							bless( {
4653							'subrule' => 'include',
4654							'matchrule' => 0,
4655							'implicit' => undef,
4656							'argcode' => undef,
4657							'lookahead' => 0,
4658							'line' => 47
4659							}, 'Parse::RecDescent::Subrule' )
4660							],
4661							'line' => undef
4662							}, 'Parse::RecDescent::Production' ),
4663							bless( {
4664							'number' => '1',
4665							'strcount' => 0,
4666							'dircount' => 0,
4667							'uncommit' => undef,
4668							'error' => undef,
4669							'patcount' => 0,
4670							'actcount' => 0,
4671							'items' => [
4672							bless( {
4673							'subrule' => 'multiline_directive',
4674							'matchrule' => 0,
4675							'implicit' => undef,
4676							'argcode' => undef,
4677							'lookahead' => 0,
4678							'line' => 47
4679							}, 'Parse::RecDescent::Subrule' )
4680							],
4681							'line' => 47
4682							}, 'Parse::RecDescent::Production' ),
4683							bless( {
4684							'number' => '2',
4685							'strcount' => 0,
4686							'dircount' => 0,
4687							'uncommit' => undef,
4688							'error' => undef,
4689							'patcount' => 0,
4690							'actcount' => 0,
4691							'items' => [
4692							bless( {
4693							'subrule' => 'hereto_directive',
4694							'matchrule' => 0,
4695							'implicit' => undef,
4696							'argcode' => undef,
4697							'lookahead' => 0,
4698							'line' => 47
4699							}, 'Parse::RecDescent::Subrule' )
4700							],
4701							'line' => 47
4702							}, 'Parse::RecDescent::Production' ),
4703							bless( {
4704							'number' => '3',
4705							'strcount' => 0,
4706							'dircount' => 0,
4707							'uncommit' => undef,
4708							'error' => undef,
4709							'patcount' => 0,
4710							'actcount' => 0,
4711							'items' => [
4712							bless( {
4713							'subrule' => 'block_start',
4714							'matchrule' => 0,
4715							'implicit' => undef,
4716							'argcode' => undef,
4717							'lookahead' => 0,
4718							'line' => 47
4719							}, 'Parse::RecDescent::Subrule' )
4720							],
4721							'line' => 47
4722							}, 'Parse::RecDescent::Production' ),
4723							bless( {
4724							'number' => '4',
4725							'strcount' => 0,
4726							'dircount' => 0,
4727							'uncommit' => undef,
4728							'error' => undef,
4729							'patcount' => 0,
4730							'actcount' => 0,
4731							'items' => [
4732							bless( {
4733							'subrule' => 'block_end',
4734							'matchrule' => 0,
4735							'implicit' => undef,
4736							'argcode' => undef,
4737							'lookahead' => 0,
4738							'line' => 47
4739							}, 'Parse::RecDescent::Subrule' )
4740							],
4741							'line' => 47
4742							}, 'Parse::RecDescent::Production' ),
4743							bless( {
4744							'number' => '5',
4745							'strcount' => 0,
4746							'dircount' => 0,
4747							'uncommit' => undef,
4748							'error' => undef,
4749							'patcount' => 0,
4750							'actcount' => 0,
4751							'items' => [
4752							bless( {
4753							'subrule' => 'directive',
4754							'matchrule' => 0,
4755							'implicit' => undef,
4756							'argcode' => undef,
4757							'lookahead' => 0,
4758							'line' => 47
4759							}, 'Parse::RecDescent::Subrule' )
4760							],
4761							'line' => 47
4762							}, 'Parse::RecDescent::Production' ),
4763							bless( {
4764							'number' => '6',
4765							'strcount' => 0,
4766							'dircount' => 0,
4767							'uncommit' => undef,
4768							'error' => undef,
4769							'patcount' => 0,
4770							'actcount' => 0,
4771							'items' => [
4772							bless( {
4773							'subrule' => 'skipline',
4774							'matchrule' => 0,
4775							'implicit' => undef,
4776							'argcode' => undef,
4777							'lookahead' => 0,
4778							'line' => 47
4779							}, 'Parse::RecDescent::Subrule' )
4780							],
4781							'line' => 47
4782							}, 'Parse::RecDescent::Production' )
4783							],
4784							'name' => '_alternation_1_of_production_1_of_rule_statement',
4785							'vars' => '',
4786							'line' => 47
4787							}, 'Parse::RecDescent::Rule' ),
4788							'hereto_line' => bless( {
4789							'impcount' => 0,
4790							'calls' => [],
4791							'changed' => 0,
4792							'opcount' => 0,
4793							'prods' => [
4794							bless( {
4795							'number' => '0',
4796							'strcount' => 0,
4797							'dircount' => 0,
4798							'uncommit' => undef,
4799							'error' => undef,
4800							'patcount' => 1,
4801							'actcount' => 1,
4802							'items' => [
4803							bless( {
4804							'pattern' => '(.*?)$arg[0]',
4805							'hashname' => '__PATTERN1__',
4806							'description' => '/(.*?)$arg[0]/sm',
4807							'lookahead' => 0,
4808							'rdelim' => '/',
4809							'line' => 36,
4810							'mod' => 'sm',
4811							'ldelim' => '/'
4812							}, 'Parse::RecDescent::Token' ),
4813							bless( {
4814							'hashname' => '__ACTION1__',
4815							'lookahead' => 0,
4816							'line' => 36,
4817							'code' => '{ $1 }'
4818							}, 'Parse::RecDescent::Action' )
4819							],
4820							'line' => undef
4821							}, 'Parse::RecDescent::Production' )
4822							],
4823							'name' => 'hereto_line',
4824							'vars' => '',
4825							'line' => 36
4826							}, 'Parse::RecDescent::Rule' ),
4827							'no_space' => bless( {
4828							'impcount' => 0,
4829							'calls' => [],
4830							'changed' => 0,
4831							'opcount' => 0,
4832							'prods' => [
4833							bless( {
4834							'number' => '0',
4835							'strcount' => 0,
4836							'dircount' => 0,
4837							'uncommit' => undef,
4838							'error' => undef,
4839							'patcount' => 1,
4840							'actcount' => 0,
4841							'items' => [
4842							bless( {
4843							'pattern' => '\\S+',
4844							'hashname' => '__PATTERN1__',
4845							'description' => '/\\\\S+/',
4846							'lookahead' => 0,
4847							'rdelim' => '/',
4848							'line' => 44,
4849							'mod' => '',
4850							'ldelim' => '/'
4851							}, 'Parse::RecDescent::Token' )
4852							],
4853							'line' => undef
4854							}, 'Parse::RecDescent::Production' )
4855							],
4856							'name' => 'no_space',
4857							'vars' => '',
4858							'line' => 44
4859							}, 'Parse::RecDescent::Rule' ),
4860							'multiline_directive' => bless( {
4861							'impcount' => 0,
4862							'calls' => [
4863							'eol'
4864							],
4865							'changed' => 0,
4866							'opcount' => 0,
4867							'prods' => [
4868							bless( {
4869							'number' => '0',
4870							'strcount' => 0,
4871							'dircount' => 0,
4872							'uncommit' => undef,
4873							'error' => undef,
4874							'patcount' => 1,
4875							'actcount' => 1,
4876							'items' => [
4877							bless( {
4878							'pattern' => '(.?[\\\\][ \\t]\\n)+.*',
4879							'hashname' => '__PATTERN1__',
4880							'description' => '/(.?[\\\\\\\\][ \\\\t]\\\\n)+.*/',
4881							'lookahead' => 0,
4882							'rdelim' => '/',
4883							'line' => 8,
4884							'mod' => '',
4885							'ldelim' => '/'
4886							}, 'Parse::RecDescent::Token' ),
4887							bless( {
4888							'subrule' => 'eol',
4889							'matchrule' => 0,
4890							'implicit' => undef,
4891							'argcode' => undef,
4892							'lookahead' => 0,
4893							'line' => 8
4894							}, 'Parse::RecDescent::Subrule' ),
4895							bless( {
4896							'hashname' => '__ACTION1__',
4897							'lookahead' => 0,
4898							'line' => 9,
4899							'code' => '{ $item[-2] =~ s/[\\\\][ \\t]*\\n//g; $return =
4900							$thisparser->directive($item[-2] . "\\n",1, @arg) }'
4901							}, 'Parse::RecDescent::Action' )
4902							],
4903							'line' => undef
4904							}, 'Parse::RecDescent::Production' )
4905							],
4906							'name' => 'multiline_directive',
4907							'vars' => '',
4908							'line' => 7
4909							}, 'Parse::RecDescent::Rule' ),
4910							'val' => bless( {
4911							'impcount' => 0,
4912							'calls' => [
4913							'quote',
4914							'no_space'
4915							],
4916							'changed' => 0,
4917							'opcount' => 0,
4918							'prods' => [
4919							bless( {
4920							'number' => '0',
4921							'strcount' => 0,
4922							'dircount' => 0,
4923							'uncommit' => undef,
4924							'error' => undef,
4925							'patcount' => 0,
4926							'actcount' => 0,
4927							'items' => [
4928							bless( {
4929							'subrule' => 'quote',
4930							'matchrule' => 0,
4931							'implicit' => undef,
4932							'argcode' => undef,
4933							'lookahead' => 0,
4934							'line' => 40
4935							}, 'Parse::RecDescent::Subrule' )
4936							],
4937							'line' => undef
4938							}, 'Parse::RecDescent::Production' ),
4939							bless( {
4940							'number' => '1',
4941							'strcount' => 0,
4942							'dircount' => 0,
4943							'uncommit' => undef,
4944							'error' => undef,
4945							'patcount' => 0,
4946							'actcount' => 0,
4947							'items' => [
4948							bless( {
4949							'subrule' => 'no_space',
4950							'matchrule' => 0,
4951							'implicit' => undef,
4952							'argcode' => undef,
4953							'lookahead' => 0,
4954							'line' => 40
4955							}, 'Parse::RecDescent::Subrule' )
4956							],
4957							'line' => 40
4958							}, 'Parse::RecDescent::Production' )
4959							],
4960							'name' => 'val',
4961							'vars' => '',
4962							'line' => 40
4963							}, 'Parse::RecDescent::Rule' ),
4964							'block_val' => bless( {
4965							'impcount' => 0,
4966							'calls' => [
4967							'quote'
4968							],
4969							'changed' => 0,
4970							'opcount' => 0,
4971							'prods' => [
4972							bless( {
4973							'number' => '0',
4974							'strcount' => 0,
4975							'dircount' => 0,
4976							'uncommit' => undef,
4977							'error' => undef,
4978							'patcount' => 0,
4979							'actcount' => 0,
4980							'items' => [
4981							bless( {
4982							'subrule' => 'quote',
4983							'matchrule' => 0,
4984							'implicit' => undef,
4985							'argcode' => undef,
4986							'lookahead' => 0,
4987							'line' => 41
4988							}, 'Parse::RecDescent::Subrule' )
4989							],
4990							'line' => undef
4991							}, 'Parse::RecDescent::Production' ),
4992							bless( {
4993							'number' => '1',
4994							'strcount' => 0,
4995							'dircount' => 0,
4996							'uncommit' => undef,
4997							'error' => undef,
4998							'patcount' => 1,
4999							'actcount' => 0,
5000							'items' => [
5001							bless( {
5002							'pattern' => '[^\\s>]+',
5003							'hashname' => '__PATTERN1__',
5004							'description' => '/[^\\\\s>]+/',
5005							'lookahead' => 0,
5006							'rdelim' => '/',
5007							'line' => 41,
5008							'mod' => '',
5009							'ldelim' => '/'
5010							}, 'Parse::RecDescent::Token' )
5011							],
5012							'line' => 41
5013							}, 'Parse::RecDescent::Production' )
5014							],
5015							'name' => 'block_val',
5016							'vars' => '',
5017							'line' => 41
5018							}, 'Parse::RecDescent::Rule' ),
5019							'hereto_directive' => bless( {
5020							'impcount' => 0,
5021							'calls' => [
5022							'key',
5023							'hereto_mark',
5024							'eol',
5025							'hereto_line'
5026							],
5027							'changed' => 0,
5028							'opcount' => 0,
5029							'prods' => [
5030							bless( {
5031							'number' => '0',
5032							'strcount' => 1,
5033							'dircount' => 1,
5034							'uncommit' => undef,
5035							'error' => undef,
5036							'patcount' => 0,
5037							'actcount' => 1,
5038							'items' => [
5039							bless( {
5040							'subrule' => 'key',
5041							'matchrule' => 0,
5042							'implicit' => undef,
5043							'argcode' => undef,
5044							'lookahead' => 0,
5045							'line' => 13
5046							}, 'Parse::RecDescent::Subrule' ),
5047							bless( {
5048							'pattern' => '<<',
5049							'hashname' => '__STRING1__',
5050							'description' => '\'<<\'',
5051							'lookahead' => 0,
5052							'line' => 13
5053							}, 'Parse::RecDescent::Literal' ),
5054							bless( {
5055							'subrule' => 'hereto_mark',
5056							'matchrule' => 0,
5057							'implicit' => undef,
5058							'argcode' => undef,
5059							'lookahead' => 0,
5060							'line' => 13
5061							}, 'Parse::RecDescent::Subrule' ),
5062							bless( {
5063							'subrule' => 'eol',
5064							'matchrule' => 0,
5065							'implicit' => undef,
5066							'argcode' => undef,
5067							'lookahead' => 0,
5068							'line' => 13
5069							}, 'Parse::RecDescent::Subrule' ),
5070							bless( {
5071							'hashname' => '__DIRECTIVE1__',
5072							'name' => '',
5073							'lookahead' => 0,
5074							'line' => 13,
5075							'code' => 'my $oldskip = $skip; $skip= \'\'; $oldskip'
5076							}, 'Parse::RecDescent::Directive' ),
5077							bless( {
5078							'subrule' => 'hereto_line',
5079							'matchrule' => 0,
5080							'implicit' => undef,
5081							'argcode' => '[$item[3]]',
5082							'lookahead' => 0,
5083							'line' => 13
5084							}, 'Parse::RecDescent::Subrule' ),
5085							bless( {
5086							'subrule' => 'eol',
5087							'matchrule' => 0,
5088							'implicit' => undef,
5089							'argcode' => undef,
5090							'lookahead' => 0,
5091							'line' => 13
5092							}, 'Parse::RecDescent::Subrule' ),
5093							bless( {
5094							'hashname' => '__ACTION1__',
5095							'lookahead' => 0,
5096							'line' => 14,
5097							'code' => '{ $data->newDirective($item[1], [$item[6]]) }'
5098							}, 'Parse::RecDescent::Action' )
5099							],
5100							'line' => undef
5101							}, 'Parse::RecDescent::Production' )
5102							],
5103							'name' => 'hereto_directive',
5104							'vars' => '',
5105							'line' => 12
5106							}, 'Parse::RecDescent::Rule' ),
5107							'grammar' => bless( {
5108							'impcount' => 0,
5109							'calls' => [
5110							'statement',
5111							'eof'
5112							],
5113							'changed' => 0,
5114							'opcount' => 0,
5115							'prods' => [
5116							bless( {
5117							'number' => '0',
5118							'strcount' => 0,
5119							'dircount' => 1,
5120							'uncommit' => undef,
5121							'error' => undef,
5122							'patcount' => 0,
5123							'actcount' => 1,
5124							'items' => [
5125							bless( {
5126							'hashname' => '__ACTION1__',
5127							'lookahead' => 0,
5128							'line' => 3,
5129							'code' => '{ $data = $arg[0]; }'
5130							}, 'Parse::RecDescent::Action' ),
5131							bless( {
5132							'hashname' => '__DIRECTIVE1__',
5133							'name' => '',
5134							'lookahead' => 0,
5135							'line' => 3
5136							}, 'Parse::RecDescent::UncondReject' )
5137							],
5138							'line' => undef
5139							}, 'Parse::RecDescent::Production' ),
5140							bless( {
5141							'number' => '1',
5142							'strcount' => 0,
5143							'dircount' => 0,
5144							'uncommit' => undef,
5145							'error' => undef,
5146							'patcount' => 0,
5147							'actcount' => 1,
5148							'items' => [
5149							bless( {
5150							'subrule' => 'statement',
5151							'expected' => undef,
5152							'min' => 0,
5153							'argcode' => undef,
5154							'max' => 100000000,
5155							'matchrule' => 0,
5156							'repspec' => 's?',
5157							'lookahead' => 0,
5158							'line' => 3
5159							}, 'Parse::RecDescent::Repetition' ),
5160							bless( {
5161							'subrule' => 'eof',
5162							'matchrule' => 0,
5163							'implicit' => undef,
5164							'argcode' => undef,
5165							'lookahead' => 0,
5166							'line' => 3
5167							}, 'Parse::RecDescent::Subrule' ),
5168							bless( {
5169							'hashname' => '__ACTION1__',
5170							'lookahead' => 0,
5171							'line' => 3,
5172							'code' => '{ $return = $item[2] }'
5173							}, 'Parse::RecDescent::Action' )
5174							],
5175							'line' => 3
5176							}, 'Parse::RecDescent::Production' )
5177							],
5178							'name' => 'grammar',
5179							'vars' => '',
5180							'line' => 3
5181							}, 'Parse::RecDescent::Rule' ),
5182							'comment' => bless( {
5183							'impcount' => 0,
5184							'calls' => [
5185							'eol'
5186							],
5187							'changed' => 0,
5188							'opcount' => 0,
5189							'prods' => [
5190							bless( {
5191							'number' => '0',
5192							'strcount' => 1,
5193							'dircount' => 0,
5194							'uncommit' => undef,
5195							'error' => undef,
5196							'patcount' => 1,
5197							'actcount' => 1,
5198							'items' => [
5199							bless( {
5200							'pattern' => '#',
5201							'hashname' => '__STRING1__',
5202							'description' => '\'#\'',
5203							'lookahead' => 0,
5204							'line' => 38
5205							}, 'Parse::RecDescent::Literal' ),
5206							bless( {
5207							'pattern' => '.*',
5208							'hashname' => '__PATTERN1__',
5209							'description' => '/.*/',
5210							'lookahead' => 0,
5211							'rdelim' => '/',
5212							'line' => 38,
5213							'mod' => '',
5214							'ldelim' => '/'
5215							}, 'Parse::RecDescent::Token' ),
5216							bless( {
5217							'subrule' => 'eol',
5218							'matchrule' => 0,
5219							'implicit' => undef,
5220							'argcode' => undef,
5221							'lookahead' => 0,
5222							'line' => 38
5223							}, 'Parse::RecDescent::Subrule' ),
5224							bless( {
5225							'hashname' => '__ACTION1__',
5226							'lookahead' => 0,
5227							'line' => 38,
5228							'code' => '{ 0 }'
5229							}, 'Parse::RecDescent::Action' )
5230							],
5231							'line' => undef
5232							}, 'Parse::RecDescent::Production' )
5233							],
5234							'name' => 'comment',
5235							'vars' => '',
5236							'line' => 38
5237							}, 'Parse::RecDescent::Rule' ),
5238							'eof' => bless( {
5239							'impcount' => 0,
5240							'calls' => [],
5241							'changed' => 0,
5242							'opcount' => 0,
5243							'prods' => [
5244							bless( {
5245							'number' => '0',
5246							'strcount' => 0,
5247							'dircount' => 0,
5248							'uncommit' => undef,
5249							'error' => undef,
5250							'patcount' => 1,
5251							'actcount' => 0,
5252							'items' => [
5253							bless( {
5254							'pattern' => '^\\z',
5255							'hashname' => '__PATTERN1__',
5256							'description' => '/^\\\\z/',
5257							'lookahead' => 0,
5258							'rdelim' => '/',
5259							'line' => 46,
5260							'mod' => '',
5261							'ldelim' => '/'
5262							}, 'Parse::RecDescent::Token' )
5263							],
5264							'line' => undef
5265							}, 'Parse::RecDescent::Production' )
5266							],
5267							'name' => 'eof',
5268							'vars' => '',
5269							'line' => 46
5270							}, 'Parse::RecDescent::Rule' ),
5271							'block_end' => bless( {
5272							'impcount' => 0,
5273							'calls' => [
5274							'key',
5275							'eol'
5276							],
5277							'changed' => 0,
5278							'opcount' => 0,
5279							'prods' => [
5280							bless( {
5281							'number' => '0',
5282							'strcount' => 2,
5283							'dircount' => 0,
5284							'uncommit' => undef,
5285							'error' => undef,
5286							'patcount' => 0,
5287							'actcount' => 1,
5288							'items' => [
5289							bless( {
5290							'pattern' => '
5291							'hashname' => '__STRING1__',
5292							'description' => '\'
5293							'lookahead' => 0,
5294							'line' => 23
5295							}, 'Parse::RecDescent::Literal' ),
5296							bless( {
5297							'subrule' => 'key',
5298							'matchrule' => 0,
5299							'implicit' => undef,
5300							'argcode' => undef,
5301							'lookahead' => 0,
5302							'line' => 23
5303							}, 'Parse::RecDescent::Subrule' ),
5304							bless( {
5305							'pattern' => '>',
5306							'hashname' => '__STRING2__',
5307							'description' => '\'>\'',
5308							'lookahead' => 0,
5309							'line' => 23
5310							}, 'Parse::RecDescent::Literal' ),
5311							bless( {
5312							'subrule' => 'eol',
5313							'matchrule' => 0,
5314							'implicit' => undef,
5315							'argcode' => undef,
5316							'lookahead' => 0,
5317							'line' => 23
5318							}, 'Parse::RecDescent::Subrule' ),
5319							bless( {
5320							'hashname' => '__ACTION1__',
5321							'lookahead' => 0,
5322							'line' => 24,
5323							'code' => '{ $return = $data->endBlock($item[2]) }'
5324							}, 'Parse::RecDescent::Action' )
5325							],
5326							'line' => undef
5327							}, 'Parse::RecDescent::Production' )
5328							],
5329							'name' => 'block_end',
5330							'vars' => '',
5331							'line' => 23
5332							}, 'Parse::RecDescent::Rule' ),
5333							'directive' => bless( {
5334							'impcount' => 0,
5335							'calls' => [
5336							'key',
5337							'val',
5338							'eol'
5339							],
5340							'changed' => 0,
5341							'opcount' => 0,
5342							'prods' => [
5343							bless( {
5344							'number' => '0',
5345							'strcount' => 0,
5346							'dircount' => 1,
5347							'uncommit' => undef,
5348							'error' => undef,
5349							'patcount' => 0,
5350							'actcount' => 1,
5351							'items' => [
5352							bless( {
5353							'subrule' => 'key',
5354							'matchrule' => 0,
5355							'implicit' => undef,
5356							'argcode' => undef,
5357							'lookahead' => 0,
5358							'line' => 16
5359							}, 'Parse::RecDescent::Subrule' ),
5360							bless( {
5361							'subrule' => 'val',
5362							'expected' => undef,
5363							'min' => 1,
5364							'argcode' => undef,
5365							'max' => 100000000,
5366							'matchrule' => 0,
5367							'repspec' => 's',
5368							'lookahead' => 0,
5369							'line' => 16
5370							}, 'Parse::RecDescent::Repetition' ),
5371							bless( {
5372							'hashname' => '__DIRECTIVE1__',
5373							'name' => '',
5374							'lookahead' => 0,
5375							'line' => 16,
5376							'code' => '$commit = 1'
5377							}, 'Parse::RecDescent::Directive' ),
5378							bless( {
5379							'subrule' => 'eol',
5380							'matchrule' => 0,
5381							'implicit' => undef,
5382							'argcode' => undef,
5383							'lookahead' => 0,
5384							'line' => 16
5385							}, 'Parse::RecDescent::Subrule' ),
5386							bless( {
5387							'hashname' => '__ACTION1__',
5388							'lookahead' => 0,
5389							'line' => 16,
5390							'code' => '{ $return = $data->newDirective($item[1], $item[2]) }'
5391							}, 'Parse::RecDescent::Action' )
5392							],
5393							'line' => undef
5394							}, 'Parse::RecDescent::Production' ),
5395							bless( {
5396							'number' => '1',
5397							'strcount' => 0,
5398							'dircount' => 0,
5399							'uncommit' => undef,
5400							'error' => undef,
5401							'patcount' => 0,
5402							'actcount' => 1,
5403							'items' => [
5404							bless( {
5405							'subrule' => 'key',
5406							'matchrule' => 0,
5407							'implicit' => undef,
5408							'argcode' => undef,
5409							'lookahead' => 0,
5410							'line' => 17
5411							}, 'Parse::RecDescent::Subrule' ),
5412							bless( {
5413							'subrule' => 'eol',
5414							'matchrule' => 0,
5415							'implicit' => undef,
5416							'argcode' => undef,
5417							'lookahead' => 0,
5418							'line' => 17
5419							}, 'Parse::RecDescent::Subrule' ),
5420							bless( {
5421							'hashname' => '__ACTION1__',
5422							'lookahead' => 0,
5423							'line' => 17,
5424							'code' => '{ $return = $data->newDirective($item[1], [1]) }'
5425							}, 'Parse::RecDescent::Action' )
5426							],
5427							'line' => 17
5428							}, 'Parse::RecDescent::Production' )
5429							],
5430							'name' => 'directive',
5431							'vars' => '',
5432							'line' => 16
5433							}, 'Parse::RecDescent::Rule' )
5434							}
5435							}, 'Parse::RecDescent' );
5436							}