File Coverage

blib/lib/Parse/FieldPath/Parser.pm

Criterion	Covered	Total	%
statement	624	780	80.0
branch	165	410	40.2
condition	58	139	41.7
subroutine	41	42	97.6
pod	0	1	0.0
total	888	1372	64.7

line	stmt	bran	cond	sub	pod	time	code
1							package Parse::FieldPath::Parser;
2							{
3							$Parse::FieldPath::Parser::VERSION = '0.005';
4							}
5	9			9		18728	use Parse::RecDescent;
	9					499691
	9					73
6
7							{ my $ERRORS;
8
9
10							package Parse::RecDescent::Parse::FieldPath::Parser;
11							{
12							$Parse::RecDescent::Parse::FieldPath::Parser::VERSION = '0.005';
13							}
14	9			9		650	use strict;
	9					17
	9					290
15	9			9		46	use vars qw($skip $AUTOLOAD );
	9					51
	9					871
16							@Parse::RecDescent::Parse::FieldPath::Parser::ISA = ();
17							$skip = '\s*';
18
19
20							{
21							local $SIG{__WARN__} = sub {0};
22							# PRETEND TO BE IN Parse::RecDescent NAMESPACE
23							*Parse::RecDescent::Parse::FieldPath::Parser::AUTOLOAD = sub
24							{
25	9			9		42	no strict 'refs';
	9					15
	9					818
26	0			0		0	$AUTOLOAD =~ s/^Parse::RecDescent::Parse::FieldPath::Parser/Parse::RecDescent/;
27	0					0	goto &{$AUTOLOAD};
	0					0
28							}
29							}
30
31							push @Parse::RecDescent::Parse::FieldPath::Parser::ISA, 'Parse::RecDescent';
32							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
33							sub Parse::RecDescent::Parse::FieldPath::Parser::field_path
34							{
35	107			107		143	my $thisparser = $_[0];
36	9			9		42	use vars q{$tracelevel};
	9					14
	9					3662
37	107		50			275	local $tracelevel = ($tracelevel\|\|0)+1;
38	107					132	$ERRORS = 0;
39	107					186	my $thisrule = $thisparser->{"rules"}{"field_path"};
40
41	107	50				204	Parse::RecDescent::_trace(q{Trying rule: [field_path]},
42							Parse::RecDescent::_tracefirst($_[1]),
43							q{field_path},
44							$tracelevel)
45							if defined $::RD_TRACE;
46
47
48	107					105	my $err_at = @{$thisparser->{errors}};
	107					176
49
50	107					129	my $score;
51							my $score_return;
52	0					0	my $_tok;
53	107					116	my $return = undef;
54	107					111	my $_matched=0;
55	107					107	my $commit=0;
56	107					137	my @item = ();
57	107					142	my %item = ();
58	107		33			295	my $repeating = defined($_[2]) && $_[2];
59	107		33			244	my $_noactions = defined($_[3]) && $_[3];
60	107	50				190	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	107					125
	107					193
61	107	50				252	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
62	107					116	my $text;
63	107					124	my $lastsep="";
64	107					109	my $current_match;
65	107					307	my $expectation = new Parse::RecDescent::Expectation(q{<leftop: field_name /\\// field_name>});
66	107					810	$expectation->at($_[1]);
67
68	107					378	my $thisline;
69	107					479	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
70
71
72
73	107		33			994	while (!$_matched && !$commit)
74							{
75
76	107	50				205	Parse::RecDescent::_trace(q{Trying production: [<leftop: field_name /\\// field_name>]},
77							Parse::RecDescent::_tracefirst($_[1]),
78							q{field_path},
79							$tracelevel)
80							if defined $::RD_TRACE;
81	107					184	my $thisprod = $thisrule->{"prods"}[0];
82	107					138	$text = $_[1];
83	107					96	my $_savetext;
84	107					190	@item = (q{field_path});
85	107					184	%item = (__RULE__ => q{field_path});
86	107					121	my $repcount = 0;
87
88
89	107	50				229	Parse::RecDescent::_trace(q{Trying operator: [<leftop: field_name /\\// field_name>]},
90							Parse::RecDescent::_tracefirst($text),
91							q{field_path},
92							$tracelevel)
93							if defined $::RD_TRACE;
94	107					261	$expectation->is(q{})->at($text);
95
96	107					588	$_tok = undef;
97	107					109	OPLOOP: while (1)
98							{
99	107					130	$repcount = 0;
100	107					126	my @item;
101
102							# MATCH LEFTARG
103
104	107	50				202	Parse::RecDescent::_trace(q{Trying subrule: [field_name]},
105							Parse::RecDescent::_tracefirst($text),
106							q{field_path},
107							$tracelevel)
108							if defined $::RD_TRACE;
109	9			9		66	if (1) { no strict qw{refs};
	9					25
	9					3935
	107					105
110	107					256	$expectation->is(q{field_name})->at($text);
111	107	50		107		889	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field_name($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	107					215
112							{
113
114	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field_name]>>},
115							Parse::RecDescent::_tracefirst($text),
116							q{field_path},
117							$tracelevel)
118							if defined $::RD_TRACE;
119	0					0	$expectation->failed();
120	0					0	last;
121							}
122	107	50				400	Parse::RecDescent::_trace(q{>>Matched subrule: [field_name]<< (return value: [}
123							. $_tok . q{]},
124
125							Parse::RecDescent::_tracefirst($text),
126							q{field_path},
127							$tracelevel)
128							if defined $::RD_TRACE;
129	107					191	$item{q{field_name}} = $_tok;
130	107					158	push @item, $_tok;
131
132							}
133
134
135	107					119	$repcount++;
136
137	107					129	my $savetext = $text;
138	107					104	my $backtrack;
139
140							# MATCH (OP RIGHTARG)(s)
141	107					263	while ($repcount < 100000000)
142							{
143	141					164	$backtrack = 0;
144
145	141	50				258	Parse::RecDescent::_trace(q{Trying terminal: [/\\//]}, Parse::RecDescent::_tracefirst($text),
146							q{field_path},
147							$tracelevel)
148							if defined $::RD_TRACE;
149	141					202	$lastsep = "";
150	141					350	$expectation->is(q{/\\//})->at($text);
151
152
153	141	50	66			1308	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\/)/)
	141	100				1007
154							{
155
156	107					285	$expectation->failed();
157	107	50				1008	Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
158							Parse::RecDescent::_tracefirst($text))
159							if defined $::RD_TRACE;
160
161	107					157	last;
162							}
163	34					129	$current_match = substr($text, $-[0], $+[0] - $-[0]);
164	34					77	substr($text,0,length($current_match),q{});
165	34	50				225	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
166							. $current_match . q{])},
167							Parse::RecDescent::_tracefirst($text))
168							if defined $::RD_TRACE;
169	34					68	push @item, $item{__PATTERN1__}=$current_match;
170
171
172	34					40	pop @item;
173	34	50				88	if (defined $1) {push @item, $item{'field_name(s)'}=$1; $backtrack=1;}
	0					0
	0					0
174
175	34	50				60	Parse::RecDescent::_trace(q{Trying subrule: [field_name]},
176							Parse::RecDescent::_tracefirst($text),
177							q{field_path},
178							$tracelevel)
179							if defined $::RD_TRACE;
180	9			9		56	if (1) { no strict qw{refs};
	9					23
	9					3276
	34					34
181	34					84	$expectation->is(q{field_name})->at($text);
182	34	50		34		389	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field_name($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	34					61
183							{
184
185	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field_name]>>},
186							Parse::RecDescent::_tracefirst($text),
187							q{field_path},
188							$tracelevel)
189							if defined $::RD_TRACE;
190	0					0	$expectation->failed();
191	0					0	last;
192							}
193	34	50				119	Parse::RecDescent::_trace(q{>>Matched subrule: [field_name]<< (return value: [}
194							. $_tok . q{]},
195
196							Parse::RecDescent::_tracefirst($text),
197							q{field_path},
198							$tracelevel)
199							if defined $::RD_TRACE;
200	34					46	$item{q{field_name}} = $_tok;
201	34					51	push @item, $_tok;
202
203							}
204
205	34					49	$savetext = $text;
206	34					72	$repcount++;
207							}
208	107					171	$text = $savetext;
209	107	50				187	pop @item if $backtrack;
210
211	107	50				202	unless (@item) { undef $_tok; last }
	0					0
	0					0
212	107					224	$_tok = [ @item ];
213	107					181	last;
214							}
215
216	107	50				218	unless ($repcount>=1)
217							{
218	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: field_name /\\// field_name>]>>},
219							Parse::RecDescent::_tracefirst($text),
220							q{field_path},
221							$tracelevel)
222							if defined $::RD_TRACE;
223	0					0	$expectation->failed();
224	0					0	last;
225							}
226	107	50				180	Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: field_name /\\// field_name>]<< (return value: [}
227	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
228							Parse::RecDescent::_tracefirst($text),
229							q{field_path},
230							$tracelevel)
231							if defined $::RD_TRACE;
232
233	107		50			315	push @item, $item{'field_name(s)'}=$_tok\|\|[];
234
235
236	107	50				192	Parse::RecDescent::_trace(q{Trying action},
237							Parse::RecDescent::_tracefirst($text),
238							q{field_path},
239							$tracelevel)
240							if defined $::RD_TRACE;
241
242
243	107	50				192	$_tok = ($_noactions) ? 0 : do {
244	9			9		55	use List::Util qw//;
	9					14
	9					5665
245
246							# Turn qw/a b c/ into { a => { b => { c => {} } } }
247	107					143	my $fields = {};
248	107	100		141		353	List::Util::reduce { $a->{$b} = {} if $b } $fields, @{$item{'field_name(s)'}};
	141					675
	107					526
249	107					329	$return = $fields;
250							};
251	107	50				249	unless (defined $_tok)
252							{
253	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
254							if defined $::RD_TRACE;
255	0					0	last;
256							}
257	107	50				202	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
258							. $_tok . q{])},
259							Parse::RecDescent::_tracefirst($text))
260							if defined $::RD_TRACE;
261	107					126	push @item, $_tok;
262	107					159	$item{__ACTION1__}=$_tok;
263
264
265
266	107	50				326	Parse::RecDescent::_trace(q{>>Matched production: [<leftop: field_name /\\// field_name>]<<},
267							Parse::RecDescent::_tracefirst($text),
268							q{field_path},
269							$tracelevel)
270							if defined $::RD_TRACE;
271	107					118	$_matched = 1;
272	107					167	last;
273							}
274
275
276	107	50	33			294	unless ( $_matched \|\| defined($score) )
277							{
278
279
280	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
281	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match rule>>},
282							Parse::RecDescent::_tracefirst($_[1]),
283							q{field_path},
284							$tracelevel)
285							if defined $::RD_TRACE;
286	0					0	return undef;
287							}
288	107	50	33			246	if (!defined($return) && defined($score))
289							{
290	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
291							q{field_path},
292							$tracelevel)
293							if defined $::RD_TRACE;
294	0					0	$return = $score_return;
295							}
296	107					118	splice @{$thisparser->{errors}}, $err_at;
	107					192
297	107	50				210	$return = $item[$#item] unless defined $return;
298	107	50				211	if (defined $::RD_TRACE)
299							{
300	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
301							$return . q{])}, "",
302							q{field_path},
303							$tracelevel);
304	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
305							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
306							Parse::RecDescent::_tracefirst($text),
307							, q{field_path},
308							$tracelevel)
309							}
310	107					142	$_[1] = $text;
311	107					834	return $return;
312							}
313
314							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
315							sub Parse::RecDescent::Parse::FieldPath::Parser::field_list
316							{
317	57			57		102	my $thisparser = $_[0];
318	9			9		53	use vars q{$tracelevel};
	9					15
	9					3584
319	57		50			169	local $tracelevel = ($tracelevel\|\|0)+1;
320	57					67	$ERRORS = 0;
321	57					96	my $thisrule = $thisparser->{"rules"}{"field_list"};
322
323	57	50				117	Parse::RecDescent::_trace(q{Trying rule: [field_list]},
324							Parse::RecDescent::_tracefirst($_[1]),
325							q{field_list},
326							$tracelevel)
327							if defined $::RD_TRACE;
328
329
330	57					53	my $err_at = @{$thisparser->{errors}};
	57					109
331
332	57					65	my $score;
333							my $score_return;
334	0					0	my $_tok;
335	57					66	my $return = undef;
336	57					92	my $_matched=0;
337	57					63	my $commit=0;
338	57					85	my @item = ();
339	57					68	my %item = ();
340	57		33			219	my $repeating = defined($_[2]) && $_[2];
341	57		33			179	my $_noactions = defined($_[3]) && $_[3];
342	57	50				131	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	57					64
	57					107
343	57	50				152	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
344	57					75	my $text;
345	57					75	my $lastsep="";
346	57					82	my $current_match;
347	57					190	my $expectation = new Parse::RecDescent::Expectation(q{field_path});
348	57					416	$expectation->at($_[1]);
349
350	57					234	my $thisline;
351	57					205	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
352
353
354
355	57		33			532	while (!$_matched && !$commit)
356							{
357
358	57	50				124	Parse::RecDescent::_trace(q{Trying production: [field_path '(' fields ')']},
359							Parse::RecDescent::_tracefirst($_[1]),
360							q{field_list},
361							$tracelevel)
362							if defined $::RD_TRACE;
363	57					106	my $thisprod = $thisrule->{"prods"}[0];
364	57					76	$text = $_[1];
365	57					60	my $_savetext;
366	57					101	@item = (q{field_list});
367	57					115	%item = (__RULE__ => q{field_list});
368	57					74	my $repcount = 0;
369
370
371	57	50				122	Parse::RecDescent::_trace(q{Trying subrule: [field_path]},
372							Parse::RecDescent::_tracefirst($text),
373							q{field_list},
374							$tracelevel)
375							if defined $::RD_TRACE;
376	9			9		48	if (1) { no strict qw{refs};
	9					17
	9					4415
	57					57
377	57					179	$expectation->is(q{})->at($text);
378	57	50		57		539	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field_path($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	57					117
379							{
380
381	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field_path]>>},
382							Parse::RecDescent::_tracefirst($text),
383							q{field_list},
384							$tracelevel)
385							if defined $::RD_TRACE;
386	0					0	$expectation->failed();
387	0					0	last;
388							}
389	57	50				200	Parse::RecDescent::_trace(q{>>Matched subrule: [field_path]<< (return value: [}
390							. $_tok . q{]},
391
392							Parse::RecDescent::_tracefirst($text),
393							q{field_list},
394							$tracelevel)
395							if defined $::RD_TRACE;
396	57					89	$item{q{field_path}} = $_tok;
397	57					77	push @item, $_tok;
398
399							}
400
401	57	50				105	Parse::RecDescent::_trace(q{Trying terminal: ['(']},
402							Parse::RecDescent::_tracefirst($text),
403							q{field_list},
404							$tracelevel)
405							if defined $::RD_TRACE;
406	57					79	$lastsep = "";
407	57					149	$expectation->is(q{'('})->at($text);
408
409
410	57	50	66			603	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\(/)
	57	100				415
411							{
412
413	50					133	$expectation->failed();
414	50	50				424	Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
415							Parse::RecDescent::_tracefirst($text))
416							if defined $::RD_TRACE;
417	50					98	last;
418							}
419	7					31	$current_match = substr($text, $-[0], $+[0] - $-[0]);
420	7					22	substr($text,0,length($current_match),q{});
421	7	50				19	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
422							. $current_match . q{])},
423							Parse::RecDescent::_tracefirst($text))
424							if defined $::RD_TRACE;
425	7					16	push @item, $item{__STRING1__}=$current_match;
426
427
428	7	50				20	Parse::RecDescent::_trace(q{Trying subrule: [fields]},
429							Parse::RecDescent::_tracefirst($text),
430							q{field_list},
431							$tracelevel)
432							if defined $::RD_TRACE;
433	9			9		60	if (1) { no strict qw{refs};
	9					26
	9					9082
	7					9
434	7					20	$expectation->is(q{fields})->at($text);
435	7	50		7		135	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::fields($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	7					20
436							{
437
438	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [fields]>>},
439							Parse::RecDescent::_tracefirst($text),
440							q{field_list},
441							$tracelevel)
442							if defined $::RD_TRACE;
443	0					0	$expectation->failed();
444	0					0	last;
445							}
446	7	50				28	Parse::RecDescent::_trace(q{>>Matched subrule: [fields]<< (return value: [}
447							. $_tok . q{]},
448
449							Parse::RecDescent::_tracefirst($text),
450							q{field_list},
451							$tracelevel)
452							if defined $::RD_TRACE;
453	7					14	$item{q{fields}} = $_tok;
454	7					11	push @item, $_tok;
455
456							}
457
458	7	50				16	Parse::RecDescent::_trace(q{Trying terminal: [')']},
459							Parse::RecDescent::_tracefirst($text),
460							q{field_list},
461							$tracelevel)
462							if defined $::RD_TRACE;
463	7					11	$lastsep = "";
464	7					23	$expectation->is(q{')'})->at($text);
465
466
467	7	50	33			155	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\)/)
	7	50				70
468							{
469
470	0					0	$expectation->failed();
471	0	0				0	Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
472							Parse::RecDescent::_tracefirst($text))
473							if defined $::RD_TRACE;
474	0					0	last;
475							}
476	7					37	$current_match = substr($text, $-[0], $+[0] - $-[0]);
477	7					20	substr($text,0,length($current_match),q{});
478	7	50				18	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
479							. $current_match . q{])},
480							Parse::RecDescent::_tracefirst($text))
481							if defined $::RD_TRACE;
482	7					22	push @item, $item{__STRING2__}=$current_match;
483
484
485	7	50				14	Parse::RecDescent::_trace(q{Trying action},
486							Parse::RecDescent::_tracefirst($text),
487							q{field_list},
488							$tracelevel)
489							if defined $::RD_TRACE;
490
491
492	7	50				24	$_tok = ($_noactions) ? 0 : do {
493							sub deepest {
494	16			16		17	my $hashref = shift;
495	16	100				52	return $hashref if scalar(keys %$hashref) == 0;
496	9					21	my $key = (keys %$hashref)[0];
497	9					32	return deepest($hashref->{$key});
498							}
499	7					21	my $deepest = deepest($item{field_path});
500	7					11	$deepest->{$_} = $item{fields}->{$_} for keys %{$item{fields}};
	7					52
501	7					19	$return = $item{field_path};
502							};
503	7	50				19	unless (defined $_tok)
504							{
505	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
506							if defined $::RD_TRACE;
507	0					0	last;
508							}
509	7	50				16	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
510							. $_tok . q{])},
511							Parse::RecDescent::_tracefirst($text))
512							if defined $::RD_TRACE;
513	7					13	push @item, $_tok;
514	7					10	$item{__ACTION1__}=$_tok;
515
516
517
518	7	50				15	Parse::RecDescent::_trace(q{>>Matched production: [field_path '(' fields ')']<<},
519							Parse::RecDescent::_tracefirst($text),
520							q{field_list},
521							$tracelevel)
522							if defined $::RD_TRACE;
523	7					11	$_matched = 1;
524	7					11	last;
525							}
526
527
528	57	100	66			274	unless ( $_matched \|\| defined($score) )
529							{
530
531
532	50					75	$_[1] = $text; # NOT SURE THIS IS NEEDED
533	50	50				116	Parse::RecDescent::_trace(q{<<Didn't match rule>>},
534							Parse::RecDescent::_tracefirst($_[1]),
535							q{field_list},
536							$tracelevel)
537							if defined $::RD_TRACE;
538	50					393	return undef;
539							}
540	7	50	33			29	if (!defined($return) && defined($score))
541							{
542	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
543							q{field_list},
544							$tracelevel)
545							if defined $::RD_TRACE;
546	0					0	$return = $score_return;
547							}
548	7					8	splice @{$thisparser->{errors}}, $err_at;
	7					27
549	7	50				19	$return = $item[$#item] unless defined $return;
550	7	50				19	if (defined $::RD_TRACE)
551							{
552	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
553							$return . q{])}, "",
554							q{field_list},
555							$tracelevel);
556	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
557							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
558							Parse::RecDescent::_tracefirst($text),
559							, q{field_list},
560							$tracelevel)
561							}
562	7					17	$_[1] = $text;
563	7					61	return $return;
564							}
565
566							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
567							sub Parse::RecDescent::Parse::FieldPath::Parser::fields
568							{
569	47			47		76	my $thisparser = $_[0];
570	9			9		53	use vars q{$tracelevel};
	9					14
	9					4199
571	47		50			136	local $tracelevel = ($tracelevel\|\|0)+1;
572	47					61	$ERRORS = 0;
573	47					98	my $thisrule = $thisparser->{"rules"}{"fields"};
574
575	47	50				97	Parse::RecDescent::_trace(q{Trying rule: [fields]},
576							Parse::RecDescent::_tracefirst($_[1]),
577							q{fields},
578							$tracelevel)
579							if defined $::RD_TRACE;
580
581
582	47					62	my $err_at = @{$thisparser->{errors}};
	47					94
583
584	47					67	my $score;
585							my $score_return;
586	0					0	my $_tok;
587	47					56	my $return = undef;
588	47					65	my $_matched=0;
589	47					56	my $commit=0;
590	47					71	my @item = ();
591	47					69	my %item = ();
592	47		33			157	my $repeating = defined($_[2]) && $_[2];
593	47		33			181	my $_noactions = defined($_[3]) && $_[3];
594	47	50				115	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	47					55
	47					102
595	47	50				132	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
596	47					59	my $text;
597	47					69	my $lastsep="";
598	47					44	my $current_match;
599	47					151	my $expectation = new Parse::RecDescent::Expectation(q{<leftop: field /,/ field>});
600	47					351	$expectation->at($_[1]);
601
602	47					177	my $thisline;
603	47					185	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
604
605
606
607	47		33			455	while (!$_matched && !$commit)
608							{
609
610	47	50				110	Parse::RecDescent::_trace(q{Trying production: [<leftop: field /,/ field>]},
611							Parse::RecDescent::_tracefirst($_[1]),
612							q{fields},
613							$tracelevel)
614							if defined $::RD_TRACE;
615	47					90	my $thisprod = $thisrule->{"prods"}[0];
616	47					78	$text = $_[1];
617	47					57	my $_savetext;
618	47					88	@item = (q{fields});
619	47					105	%item = (__RULE__ => q{fields});
620	47					56	my $repcount = 0;
621
622
623	47	50				372	Parse::RecDescent::_trace(q{Trying operator: [<leftop: field /,/ field>]},
624							Parse::RecDescent::_tracefirst($text),
625							q{fields},
626							$tracelevel)
627							if defined $::RD_TRACE;
628	47					148	$expectation->is(q{})->at($text);
629
630	47					352	$_tok = undef;
631	47					104	OPLOOP: while (1)
632							{
633	47					61	$repcount = 0;
634	47					54	my @item;
635
636							# MATCH LEFTARG
637
638	47	50				102	Parse::RecDescent::_trace(q{Trying subrule: [field]},
639							Parse::RecDescent::_tracefirst($text),
640							q{fields},
641							$tracelevel)
642							if defined $::RD_TRACE;
643	9			9		52	if (1) { no strict qw{refs};
	9					17
	9					4303
	47					56
644	47					124	$expectation->is(q{field})->at($text);
645	47	50		47		464	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	47					92
646							{
647
648	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field]>>},
649							Parse::RecDescent::_tracefirst($text),
650							q{fields},
651							$tracelevel)
652							if defined $::RD_TRACE;
653	0					0	$expectation->failed();
654	0					0	last;
655							}
656	47	50				168	Parse::RecDescent::_trace(q{>>Matched subrule: [field]<< (return value: [}
657							. $_tok . q{]},
658
659							Parse::RecDescent::_tracefirst($text),
660							q{fields},
661							$tracelevel)
662							if defined $::RD_TRACE;
663	47					69	$item{q{field}} = $_tok;
664	47					71	push @item, $_tok;
665
666							}
667
668
669	47					53	$repcount++;
670
671	47					61	my $savetext = $text;
672	47					58	my $backtrack;
673
674							# MATCH (OP RIGHTARG)(s)
675	47					108	while ($repcount < 100000000)
676							{
677	57					69	$backtrack = 0;
678
679	57	50				98	Parse::RecDescent::_trace(q{Trying terminal: [/,/]}, Parse::RecDescent::_tracefirst($text),
680							q{fields},
681							$tracelevel)
682							if defined $::RD_TRACE;
683	57					76	$lastsep = "";
684	57					154	$expectation->is(q{/,/})->at($text);
685
686
687	57	50	66			644	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:,)/)
	57	100				458
688							{
689
690	47					122	$expectation->failed();
691	47	50				403	Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
692							Parse::RecDescent::_tracefirst($text))
693							if defined $::RD_TRACE;
694
695	47					74	last;
696							}
697	10					50	$current_match = substr($text, $-[0], $+[0] - $-[0]);
698	10					33	substr($text,0,length($current_match),q{});
699	10	50				30	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
700							. $current_match . q{])},
701							Parse::RecDescent::_tracefirst($text))
702							if defined $::RD_TRACE;
703	10					29	push @item, $item{__PATTERN1__}=$current_match;
704
705
706	10					13	pop @item;
707	10	50				34	if (defined $1) {push @item, $item{'field(s)'}=$1; $backtrack=1;}
	0					0
	0					0
708
709	10	50				28	Parse::RecDescent::_trace(q{Trying subrule: [field]},
710							Parse::RecDescent::_tracefirst($text),
711							q{fields},
712							$tracelevel)
713							if defined $::RD_TRACE;
714	9			9		49	if (1) { no strict qw{refs};
	9					20
	9					3533
	10					13
715	10					33	$expectation->is(q{field})->at($text);
716	10	50		10		102	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	10					32
717							{
718
719	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field]>>},
720							Parse::RecDescent::_tracefirst($text),
721							q{fields},
722							$tracelevel)
723							if defined $::RD_TRACE;
724	0					0	$expectation->failed();
725	0					0	last;
726							}
727	10	50				41	Parse::RecDescent::_trace(q{>>Matched subrule: [field]<< (return value: [}
728							. $_tok . q{]},
729
730							Parse::RecDescent::_tracefirst($text),
731							q{fields},
732							$tracelevel)
733							if defined $::RD_TRACE;
734	10					21	$item{q{field}} = $_tok;
735	10					16	push @item, $_tok;
736
737							}
738
739	10					17	$savetext = $text;
740	10					27	$repcount++;
741							}
742	47					85	$text = $savetext;
743	47	50				96	pop @item if $backtrack;
744
745	47	50				93	unless (@item) { undef $_tok; last }
	0					0
	0					0
746	47					90	$_tok = [ @item ];
747	47					79	last;
748							}
749
750	47	50				104	unless ($repcount>=1)
751							{
752	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match operator: [<leftop: field /,/ field>]>>},
753							Parse::RecDescent::_tracefirst($text),
754							q{fields},
755							$tracelevel)
756							if defined $::RD_TRACE;
757	0					0	$expectation->failed();
758	0					0	last;
759							}
760	47	50				93	Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: field /,/ field>]<< (return value: [}
761	0	0				0	. qq{@{$_tok\|\|[]}} . q{]},
762							Parse::RecDescent::_tracefirst($text),
763							q{fields},
764							$tracelevel)
765							if defined $::RD_TRACE;
766
767	47		50			132	push @item, $item{'field(s)'}=$_tok\|\|[];
768
769
770	47	50				93	Parse::RecDescent::_trace(q{Trying action},
771							Parse::RecDescent::_tracefirst($text),
772							q{fields},
773							$tracelevel)
774							if defined $::RD_TRACE;
775
776
777	47	50				84	$_tok = ($_noactions) ? 0 : do {
778	9			9		9292	use Hash::Merge qw//;
	9					31092
	9					233
779	9			9		70	use List::Util qw//;
	9					18
	9					10952
780	47			57		188	$return = List::Util::reduce { Hash::Merge::merge($a, $b) } {}, @{$item[1]};
	57					1288
	47					162
781							};
782	47	50				36838	unless (defined $_tok)
783							{
784	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
785							if defined $::RD_TRACE;
786	0					0	last;
787							}
788	47	50				126	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
789							. $_tok . q{])},
790							Parse::RecDescent::_tracefirst($text))
791							if defined $::RD_TRACE;
792	47					76	push @item, $_tok;
793	47					82	$item{__ACTION1__}=$_tok;
794
795
796
797	47	50				109	Parse::RecDescent::_trace(q{>>Matched production: [<leftop: field /,/ field>]<<},
798							Parse::RecDescent::_tracefirst($text),
799							q{fields},
800							$tracelevel)
801							if defined $::RD_TRACE;
802	47					62	$_matched = 1;
803	47					82	last;
804							}
805
806
807	47	50	33			134	unless ( $_matched \|\| defined($score) )
808							{
809
810
811	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
812	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match rule>>},
813							Parse::RecDescent::_tracefirst($_[1]),
814							q{fields},
815							$tracelevel)
816							if defined $::RD_TRACE;
817	0					0	return undef;
818							}
819	47	50	33			132	if (!defined($return) && defined($score))
820							{
821	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
822							q{fields},
823							$tracelevel)
824							if defined $::RD_TRACE;
825	0					0	$return = $score_return;
826							}
827	47					63	splice @{$thisparser->{errors}}, $err_at;
	47					108
828	47	50				114	$return = $item[$#item] unless defined $return;
829	47	50				131	if (defined $::RD_TRACE)
830							{
831	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
832							$return . q{])}, "",
833							q{fields},
834							$tracelevel);
835	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
836							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
837							Parse::RecDescent::_tracefirst($text),
838							, q{fields},
839							$tracelevel)
840							}
841	47					82	$_[1] = $text;
842	47					451	return $return;
843							}
844
845							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
846							sub Parse::RecDescent::Parse::FieldPath::Parser::parse
847							{
848	40			40		2307	my $thisparser = $_[0];
849	9			9		52	use vars q{$tracelevel};
	9					18
	9					3666
850	40		50			230	local $tracelevel = ($tracelevel\|\|0)+1;
851	40					71	$ERRORS = 0;
852	40					102	my $thisrule = $thisparser->{"rules"}{"parse"};
853
854	40	50				142	Parse::RecDescent::_trace(q{Trying rule: [parse]},
855							Parse::RecDescent::_tracefirst($_[1]),
856							q{parse},
857							$tracelevel)
858							if defined $::RD_TRACE;
859
860
861	40					58	my $err_at = @{$thisparser->{errors}};
	40					89
862
863	40					72	my $score;
864							my $score_return;
865	0					0	my $_tok;
866	40					59	my $return = undef;
867	40					57	my $_matched=0;
868	40					68	my $commit=0;
869	40					86	my @item = ();
870	40					77	my %item = ();
871	40		33			131	my $repeating = defined($_[2]) && $_[2];
872	40		33			110	my $_noactions = defined($_[3]) && $_[3];
873	40	50				113	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	40					62
	40					120
874	40	50				257	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
875	40					50	my $text;
876	40					70	my $lastsep="";
877	40					52	my $current_match;
878	40					220	my $expectation = new Parse::RecDescent::Expectation(q{fields});
879	40					480	$expectation->at($_[1]);
880
881	40					207	my $thisline;
882	40					281	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
883
884
885
886	40		33			483	while (!$_matched && !$commit)
887							{
888
889	40	50				109	Parse::RecDescent::_trace(q{Trying production: [fields /^\\Z/]},
890							Parse::RecDescent::_tracefirst($_[1]),
891							q{parse},
892							$tracelevel)
893							if defined $::RD_TRACE;
894	40					126	my $thisprod = $thisrule->{"prods"}[0];
895	40					66	$text = $_[1];
896	40					47	my $_savetext;
897	40					82	@item = (q{parse});
898	40					108	%item = (__RULE__ => q{parse});
899	40					64	my $repcount = 0;
900
901
902	40	50				95	Parse::RecDescent::_trace(q{Trying subrule: [fields]},
903							Parse::RecDescent::_tracefirst($text),
904							q{parse},
905							$tracelevel)
906							if defined $::RD_TRACE;
907	9			9		75	if (1) { no strict qw{refs};
	9					23
	9					19114
	40					55
908	40					128	$expectation->is(q{})->at($text);
909	40	50		40		434	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::fields($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	40					100
910							{
911
912	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [fields]>>},
913							Parse::RecDescent::_tracefirst($text),
914							q{parse},
915							$tracelevel)
916							if defined $::RD_TRACE;
917	0					0	$expectation->failed();
918	0					0	last;
919							}
920	40	50				166	Parse::RecDescent::_trace(q{>>Matched subrule: [fields]<< (return value: [}
921							. $_tok . q{]},
922
923							Parse::RecDescent::_tracefirst($text),
924							q{parse},
925							$tracelevel)
926							if defined $::RD_TRACE;
927	40					74	$item{q{fields}} = $_tok;
928	40					70	push @item, $_tok;
929
930							}
931
932	40	50				91	Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text),
933							q{parse},
934							$tracelevel)
935							if defined $::RD_TRACE;
936	40					66	$lastsep = "";
937	40					145	$expectation->is(q{/^\\Z/})->at($text);
938
939
940	40	50	33			540	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:^\Z)/)
	40	50				408
941							{
942
943	0					0	$expectation->failed();
944	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
945							Parse::RecDescent::_tracefirst($text))
946							if defined $::RD_TRACE;
947
948	0					0	last;
949							}
950	40					221	$current_match = substr($text, $-[0], $+[0] - $-[0]);
951	40					123	substr($text,0,length($current_match),q{});
952	40	50				141	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
953							. $current_match . q{])},
954							Parse::RecDescent::_tracefirst($text))
955							if defined $::RD_TRACE;
956	40					105	push @item, $item{__PATTERN1__}=$current_match;
957
958
959	40	50				85	Parse::RecDescent::_trace(q{Trying action},
960							Parse::RecDescent::_tracefirst($text),
961							q{parse},
962							$tracelevel)
963							if defined $::RD_TRACE;
964
965
966	40	50				105	$_tok = ($_noactions) ? 0 : do {
967	40					77	$return = $item[1];
968							};
969	40	50				101	unless (defined $_tok)
970							{
971	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match action>> (return value: [undef])})
972							if defined $::RD_TRACE;
973	0					0	last;
974							}
975	40	50				82	Parse::RecDescent::_trace(q{>>Matched action<< (return value: [}
976							. $_tok . q{])},
977							Parse::RecDescent::_tracefirst($text))
978							if defined $::RD_TRACE;
979	40					58	push @item, $_tok;
980	40					75	$item{__ACTION1__}=$_tok;
981
982
983
984	40	50				81	Parse::RecDescent::_trace(q{>>Matched production: [fields /^\\Z/]<<},
985							Parse::RecDescent::_tracefirst($text),
986							q{parse},
987							$tracelevel)
988							if defined $::RD_TRACE;
989	40					51	$_matched = 1;
990	40					75	last;
991							}
992
993
994	40	50	33			108	unless ( $_matched \|\| defined($score) )
995							{
996
997
998	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
999	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1000							Parse::RecDescent::_tracefirst($_[1]),
1001							q{parse},
1002							$tracelevel)
1003							if defined $::RD_TRACE;
1004	0					0	return undef;
1005							}
1006	40	50	33			127	if (!defined($return) && defined($score))
1007							{
1008	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1009							q{parse},
1010							$tracelevel)
1011							if defined $::RD_TRACE;
1012	0					0	$return = $score_return;
1013							}
1014	40					55	splice @{$thisparser->{errors}}, $err_at;
	40					92
1015	40	50				89	$return = $item[$#item] unless defined $return;
1016	40	50				91	if (defined $::RD_TRACE)
1017							{
1018	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1019							$return . q{])}, "",
1020							q{parse},
1021							$tracelevel);
1022	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1023							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1024							Parse::RecDescent::_tracefirst($text),
1025							, q{parse},
1026							$tracelevel)
1027							}
1028	40					71	$_[1] = $text;
1029	40					314	return $return;
1030							}
1031
1032							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1033							sub Parse::RecDescent::Parse::FieldPath::Parser::field_name
1034							{
1035	141			141		180	my $thisparser = $_[0];
1036	9			9		58	use vars q{$tracelevel};
	9					19
	9					18978
1037	141		50			320	local $tracelevel = ($tracelevel\|\|0)+1;
1038	141					140	$ERRORS = 0;
1039	141					239	my $thisrule = $thisparser->{"rules"}{"field_name"};
1040
1041	141	50				268	Parse::RecDescent::_trace(q{Trying rule: [field_name]},
1042							Parse::RecDescent::_tracefirst($_[1]),
1043							q{field_name},
1044							$tracelevel)
1045							if defined $::RD_TRACE;
1046
1047
1048	141					147	my $err_at = @{$thisparser->{errors}};
	141					239
1049
1050	141					177	my $score;
1051							my $score_return;
1052	0					0	my $_tok;
1053	141					140	my $return = undef;
1054	141					144	my $_matched=0;
1055	141					144	my $commit=0;
1056	141					174	my @item = ();
1057	141					174	my %item = ();
1058	141		33			367	my $repeating = defined($_[2]) && $_[2];
1059	141		33			354	my $_noactions = defined($_[3]) && $_[3];
1060	141	50				251	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	141					144
	141					219
1061	141	50				315	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1062	141					145	my $text;
1063	141					161	my $lastsep="";
1064	141					141	my $current_match;
1065	141					394	my $expectation = new Parse::RecDescent::Expectation(q{/\\w+/, or '*', or ''});
1066	141					1169	$expectation->at($_[1]);
1067
1068	141					495	my $thisline;
1069	141					527	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1070
1071
1072
1073	141		33			1196	while (!$_matched && !$commit)
1074							{
1075
1076	141	50				266	Parse::RecDescent::_trace(q{Trying production: [/\\w+/]},
1077							Parse::RecDescent::_tracefirst($_[1]),
1078							q{field_name},
1079							$tracelevel)
1080							if defined $::RD_TRACE;
1081	141					238	my $thisprod = $thisrule->{"prods"}[0];
1082	141					182	$text = $_[1];
1083	141					130	my $_savetext;
1084	141					222	@item = (q{field_name});
1085	141					280	%item = (__RULE__ => q{field_name});
1086	141					169	my $repcount = 0;
1087
1088
1089	141	50				263	Parse::RecDescent::_trace(q{Trying terminal: [/\\w+/]}, Parse::RecDescent::_tracefirst($text),
1090							q{field_name},
1091							$tracelevel)
1092							if defined $::RD_TRACE;
1093	141					156	$lastsep = "";
1094	141					340	$expectation->is(q{})->at($text);
1095
1096
1097	141	50	66			1432	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A(?:\w+)/)
	141	100				1176
1098							{
1099
1100	20					65	$expectation->failed();
1101	20	50				106	Parse::RecDescent::_trace(q{<<Didn't match terminal>>},
1102							Parse::RecDescent::_tracefirst($text))
1103							if defined $::RD_TRACE;
1104
1105	20					40	last;
1106							}
1107	121					565	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1108	121					323	substr($text,0,length($current_match),q{});
1109	121	50				230	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1110							. $current_match . q{])},
1111							Parse::RecDescent::_tracefirst($text))
1112							if defined $::RD_TRACE;
1113	121					275	push @item, $item{__PATTERN1__}=$current_match;
1114
1115
1116
1117	121	50				249	Parse::RecDescent::_trace(q{>>Matched production: [/\\w+/]<<},
1118							Parse::RecDescent::_tracefirst($text),
1119							q{field_name},
1120							$tracelevel)
1121							if defined $::RD_TRACE;
1122	121					131	$_matched = 1;
1123	121					217	last;
1124							}
1125
1126
1127	141		66			393	while (!$_matched && !$commit)
1128							{
1129
1130	20	50				42	Parse::RecDescent::_trace(q{Trying production: ['*']},
1131							Parse::RecDescent::_tracefirst($_[1]),
1132							q{field_name},
1133							$tracelevel)
1134							if defined $::RD_TRACE;
1135	20					49	my $thisprod = $thisrule->{"prods"}[1];
1136	20					28	$text = $_[1];
1137	20					25	my $_savetext;
1138	20					44	@item = (q{field_name});
1139	20					42	%item = (__RULE__ => q{field_name});
1140	20					22	my $repcount = 0;
1141
1142
1143	20	50				44	Parse::RecDescent::_trace(q{Trying terminal: ['*']},
1144							Parse::RecDescent::_tracefirst($text),
1145							q{field_name},
1146							$tracelevel)
1147							if defined $::RD_TRACE;
1148	20					29	$lastsep = "";
1149	20					61	$expectation->is(q{})->at($text);
1150
1151
1152	20	50	66			237	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A\*/)
	20	100				177
1153							{
1154
1155	6					25	$expectation->failed();
1156	6	50				26	Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
1157							Parse::RecDescent::_tracefirst($text))
1158							if defined $::RD_TRACE;
1159	6					12	last;
1160							}
1161	14					78	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1162	14					46	substr($text,0,length($current_match),q{});
1163	14	50				41	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1164							. $current_match . q{])},
1165							Parse::RecDescent::_tracefirst($text))
1166							if defined $::RD_TRACE;
1167	14					54	push @item, $item{__STRING1__}=$current_match;
1168
1169
1170
1171	14	50				29	Parse::RecDescent::_trace(q{>>Matched production: ['*']<<},
1172							Parse::RecDescent::_tracefirst($text),
1173							q{field_name},
1174							$tracelevel)
1175							if defined $::RD_TRACE;
1176	14					19	$_matched = 1;
1177	14					25	last;
1178							}
1179
1180
1181	141		66			327	while (!$_matched && !$commit)
1182							{
1183
1184	6	50				20	Parse::RecDescent::_trace(q{Trying production: ['']},
1185							Parse::RecDescent::_tracefirst($_[1]),
1186							q{field_name},
1187							$tracelevel)
1188							if defined $::RD_TRACE;
1189	6					11	my $thisprod = $thisrule->{"prods"}[2];
1190	6					10	$text = $_[1];
1191	6					7	my $_savetext;
1192	6					11	@item = (q{field_name});
1193	6					12	%item = (__RULE__ => q{field_name});
1194	6					6	my $repcount = 0;
1195
1196
1197	6	50				32	Parse::RecDescent::_trace(q{Trying terminal: ['']},
1198							Parse::RecDescent::_tracefirst($text),
1199							q{field_name},
1200							$tracelevel)
1201							if defined $::RD_TRACE;
1202	6					6	$lastsep = "";
1203	6					19	$expectation->is(q{})->at($text);
1204
1205
1206	6	50	33			82	unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ m/\A/)
	6	50				55
1207							{
1208
1209	0					0	$expectation->failed();
1210	0	0				0	Parse::RecDescent::_trace(qq{<<Didn't match terminal>>},
1211							Parse::RecDescent::_tracefirst($text))
1212							if defined $::RD_TRACE;
1213	0					0	last;
1214							}
1215	6					37	$current_match = substr($text, $-[0], $+[0] - $-[0]);
1216	6					18	substr($text,0,length($current_match),q{});
1217	6	50				24	Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [}
1218							. $current_match . q{])},
1219							Parse::RecDescent::_tracefirst($text))
1220							if defined $::RD_TRACE;
1221	6					15	push @item, $item{__STRING1__}=$current_match;
1222
1223
1224
1225	6	50				13	Parse::RecDescent::_trace(q{>>Matched production: ['']<<},
1226							Parse::RecDescent::_tracefirst($text),
1227							q{field_name},
1228							$tracelevel)
1229							if defined $::RD_TRACE;
1230	6					7	$_matched = 1;
1231	6					13	last;
1232							}
1233
1234
1235	141					282	while (!$_matched)
1236							{
1237
1238	0	0				0	Parse::RecDescent::_trace(q{Trying production: [<error?:...> <reject>]},
1239							Parse::RecDescent::_tracefirst($_[1]),
1240							q{field_name},
1241							$tracelevel)
1242							if defined $::RD_TRACE;
1243	0					0	my $thisprod = $thisrule->{"prods"}[3];
1244
1245	0					0	my $_savetext;
1246	0					0	@item = (q{field_name});
1247	0					0	%item = (__RULE__ => q{field_name});
1248	0					0	my $repcount = 0;
1249
1250
1251
1252
1253	0	0				0	Parse::RecDescent::_trace(q{Trying directive: [<error?:...>]},
1254							Parse::RecDescent::_tracefirst($text),
1255							q{field_name},
1256							$tracelevel)
1257							if defined $::RD_TRACE;
1258	0	0				0	$_tok = do { if ($commit) { do {
	0	0				0
	0					0
	0					0
1259	0					0	my $rule = $item[0];
1260	0					0	$rule =~ s/_/ /g;
1261							#WAS: Parse::RecDescent::_error("Invalid $rule: " . $expectation->message() ,$thisline);
1262	0					0	push @{$thisparser->{errors}}, ["Invalid $rule: " . $expectation->message() ,$thisline];
	0					0
1263	0					0	} unless $_noactions; undef } else {0} };
1264	0	0				0	if (defined($_tok))
1265							{
1266	0	0				0	Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
1267							. $_tok . q{])},
1268							Parse::RecDescent::_tracefirst($text))
1269							if defined $::RD_TRACE;
1270							}
1271							else
1272							{
1273	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match directive>>},
1274							Parse::RecDescent::_tracefirst($text))
1275							if defined $::RD_TRACE;
1276							}
1277
1278	0	0				0	last unless defined $_tok;
1279	0					0	push @item, $item{__DIRECTIVE1__}=$_tok;
1280
1281
1282	0	0				0	Parse::RecDescent::_trace(q{>>Rejecting production<< (found <reject>)},
1283							Parse::RecDescent::_tracefirst($text),
1284							q{field_name},
1285							$tracelevel)
1286							if defined $::RD_TRACE;
1287	0					0	undef $return;
1288
1289
1290	0					0	$_tok = undef;
1291
1292	0	0				0	last unless defined $_tok;
1293
1294
1295	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: [<error?:...> <reject>]<<},
1296							Parse::RecDescent::_tracefirst($text),
1297							q{field_name},
1298							$tracelevel)
1299							if defined $::RD_TRACE;
1300	0					0	$_matched = 1;
1301	0					0	last;
1302							}
1303
1304
1305	141	50	33			342	unless ( $_matched \|\| defined($score) )
1306							{
1307
1308
1309	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
1310	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1311							Parse::RecDescent::_tracefirst($_[1]),
1312							q{field_name},
1313							$tracelevel)
1314							if defined $::RD_TRACE;
1315	0					0	return undef;
1316							}
1317	141	50	33			564	if (!defined($return) && defined($score))
1318							{
1319	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1320							q{field_name},
1321							$tracelevel)
1322							if defined $::RD_TRACE;
1323	0					0	$return = $score_return;
1324							}
1325	141					156	splice @{$thisparser->{errors}}, $err_at;
	141					276
1326	141	50				349	$return = $item[$#item] unless defined $return;
1327	141	50				274	if (defined $::RD_TRACE)
1328							{
1329	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1330							$return . q{])}, "",
1331							q{field_name},
1332							$tracelevel);
1333	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1334							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1335							Parse::RecDescent::_tracefirst($text),
1336							, q{field_name},
1337							$tracelevel)
1338							}
1339	141					187	$_[1] = $text;
1340	141					1271	return $return;
1341							}
1342
1343							# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args)
1344							sub Parse::RecDescent::Parse::FieldPath::Parser::field
1345							{
1346	57			57		89	my $thisparser = $_[0];
1347	9			9		59	use vars q{$tracelevel};
	9					16
	9					3624
1348	57		50			163	local $tracelevel = ($tracelevel\|\|0)+1;
1349	57					74	$ERRORS = 0;
1350	57					138	my $thisrule = $thisparser->{"rules"}{"field"};
1351
1352	57	50				130	Parse::RecDescent::_trace(q{Trying rule: [field]},
1353							Parse::RecDescent::_tracefirst($_[1]),
1354							q{field},
1355							$tracelevel)
1356							if defined $::RD_TRACE;
1357
1358
1359	57					56	my $err_at = @{$thisparser->{errors}};
	57					109
1360
1361	57					70	my $score;
1362							my $score_return;
1363	0					0	my $_tok;
1364	57					66	my $return = undef;
1365	57					64	my $_matched=0;
1366	57					65	my $commit=0;
1367	57					83	my @item = ();
1368	57					82	my %item = ();
1369	57		33			182	my $repeating = defined($_[2]) && $_[2];
1370	57		33			186	my $_noactions = defined($_[3]) && $_[3];
1371	57	50				121	my @arg = defined $_[4] ? @{ &{$_[4]} } : ();
	57					64
	57					111
1372	57	50				157	my %arg = ($#arg & 01) ? @arg : (@arg, undef);
1373	57					66	my $text;
1374	57					70	my $lastsep="";
1375	57					64	my $current_match;
1376	57					171	my $expectation = new Parse::RecDescent::Expectation(q{field_list, or field_path});
1377	57					404	$expectation->at($_[1]);
1378
1379	57					235	my $thisline;
1380	57					206	tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser;
1381
1382
1383
1384	57		33			521	while (!$_matched && !$commit)
1385							{
1386
1387	57	50				123	Parse::RecDescent::_trace(q{Trying production: [field_list]},
1388							Parse::RecDescent::_tracefirst($_[1]),
1389							q{field},
1390							$tracelevel)
1391							if defined $::RD_TRACE;
1392	57					102	my $thisprod = $thisrule->{"prods"}[0];
1393	57					78	$text = $_[1];
1394	57					56	my $_savetext;
1395	57					109	@item = (q{field});
1396	57					106	%item = (__RULE__ => q{field});
1397	57					94	my $repcount = 0;
1398
1399
1400	57	50				113	Parse::RecDescent::_trace(q{Trying subrule: [field_list]},
1401							Parse::RecDescent::_tracefirst($text),
1402							q{field},
1403							$tracelevel)
1404							if defined $::RD_TRACE;
1405	9			9		52	if (1) { no strict qw{refs};
	9					17
	9					3363
	57					55
1406	57					160	$expectation->is(q{})->at($text);
1407	57	100		57		601	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field_list($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	57					110
1408							{
1409
1410	50	50				102	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field_list]>>},
1411							Parse::RecDescent::_tracefirst($text),
1412							q{field},
1413							$tracelevel)
1414							if defined $::RD_TRACE;
1415	50					135	$expectation->failed();
1416	50					186	last;
1417							}
1418	7	50				30	Parse::RecDescent::_trace(q{>>Matched subrule: [field_list]<< (return value: [}
1419							. $_tok . q{]},
1420
1421							Parse::RecDescent::_tracefirst($text),
1422							q{field},
1423							$tracelevel)
1424							if defined $::RD_TRACE;
1425	7					13	$item{q{field_list}} = $_tok;
1426	7					10	push @item, $_tok;
1427
1428							}
1429
1430
1431	7	50				23	Parse::RecDescent::_trace(q{>>Matched production: [field_list]<<},
1432							Parse::RecDescent::_tracefirst($text),
1433							q{field},
1434							$tracelevel)
1435							if defined $::RD_TRACE;
1436	7					9	$_matched = 1;
1437	7					10	last;
1438							}
1439
1440
1441	57		66			333	while (!$_matched && !$commit)
1442							{
1443
1444	50	50				346	Parse::RecDescent::_trace(q{Trying production: [field_path]},
1445							Parse::RecDescent::_tracefirst($_[1]),
1446							q{field},
1447							$tracelevel)
1448							if defined $::RD_TRACE;
1449	50					103	my $thisprod = $thisrule->{"prods"}[1];
1450	50					73	$text = $_[1];
1451	50					50	my $_savetext;
1452	50					103	@item = (q{field});
1453	50					109	%item = (__RULE__ => q{field});
1454	50					72	my $repcount = 0;
1455
1456
1457	50	50				105	Parse::RecDescent::_trace(q{Trying subrule: [field_path]},
1458							Parse::RecDescent::_tracefirst($text),
1459							q{field},
1460							$tracelevel)
1461							if defined $::RD_TRACE;
1462	9			9		51	if (1) { no strict qw{refs};
	9					36
	9					21245
	50					60
1463	50					133	$expectation->is(q{})->at($text);
1464	50	50		50		528	unless (defined ($_tok = Parse::RecDescent::Parse::FieldPath::Parser::field_path($thisparser,$text,$repeating,$_noactions,sub { \@arg })))
	50					99
1465							{
1466
1467	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match subrule: [field_path]>>},
1468							Parse::RecDescent::_tracefirst($text),
1469							q{field},
1470							$tracelevel)
1471							if defined $::RD_TRACE;
1472	0					0	$expectation->failed();
1473	0					0	last;
1474							}
1475	50	50				177	Parse::RecDescent::_trace(q{>>Matched subrule: [field_path]<< (return value: [}
1476							. $_tok . q{]},
1477
1478							Parse::RecDescent::_tracefirst($text),
1479							q{field},
1480							$tracelevel)
1481							if defined $::RD_TRACE;
1482	50					75	$item{q{field_path}} = $_tok;
1483	50					71	push @item, $_tok;
1484
1485							}
1486
1487
1488	50	50				99	Parse::RecDescent::_trace(q{>>Matched production: [field_path]<<},
1489							Parse::RecDescent::_tracefirst($text),
1490							q{field},
1491							$tracelevel)
1492							if defined $::RD_TRACE;
1493	50					63	$_matched = 1;
1494	50					69	last;
1495							}
1496
1497
1498	57					122	while (!$_matched)
1499							{
1500
1501	0	0				0	Parse::RecDescent::_trace(q{Trying production: [<error...>]},
1502							Parse::RecDescent::_tracefirst($_[1]),
1503							q{field},
1504							$tracelevel)
1505							if defined $::RD_TRACE;
1506	0					0	my $thisprod = $thisrule->{"prods"}[2];
1507
1508	0					0	my $_savetext;
1509	0					0	@item = (q{field});
1510	0					0	%item = (__RULE__ => q{field});
1511	0					0	my $repcount = 0;
1512
1513
1514
1515
1516	0	0				0	Parse::RecDescent::_trace(q{Trying directive: [<error...>]},
1517							Parse::RecDescent::_tracefirst($text),
1518							q{field},
1519							$tracelevel)
1520							if defined $::RD_TRACE;
1521	0	0				0	$_tok = do { if (1) { do {
	0					0
	0					0
1522	0					0	my $rule = $item[0];
1523	0					0	$rule =~ s/_/ /g;
1524							#WAS: Parse::RecDescent::_error("Invalid $rule: " . $expectation->message() ,$thisline);
1525	0					0	push @{$thisparser->{errors}}, ["Invalid $rule: " . $expectation->message() ,$thisline];
	0					0
1526	0					0	} unless $_noactions; undef } else {0} };
1527	0	0				0	if (defined($_tok))
1528							{
1529	0	0				0	Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [}
1530							. $_tok . q{])},
1531							Parse::RecDescent::_tracefirst($text))
1532							if defined $::RD_TRACE;
1533							}
1534							else
1535							{
1536	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match directive>>},
1537							Parse::RecDescent::_tracefirst($text))
1538							if defined $::RD_TRACE;
1539							}
1540
1541	0	0				0	last unless defined $_tok;
1542	0					0	push @item, $item{__DIRECTIVE1__}=$_tok;
1543
1544
1545
1546	0	0				0	Parse::RecDescent::_trace(q{>>Matched production: [<error...>]<<},
1547							Parse::RecDescent::_tracefirst($text),
1548							q{field},
1549							$tracelevel)
1550							if defined $::RD_TRACE;
1551	0					0	$_matched = 1;
1552	0					0	last;
1553							}
1554
1555
1556	57	50	33			136	unless ( $_matched \|\| defined($score) )
1557							{
1558
1559
1560	0					0	$_[1] = $text; # NOT SURE THIS IS NEEDED
1561	0	0				0	Parse::RecDescent::_trace(q{<<Didn't match rule>>},
1562							Parse::RecDescent::_tracefirst($_[1]),
1563							q{field},
1564							$tracelevel)
1565							if defined $::RD_TRACE;
1566	0					0	return undef;
1567							}
1568	57	50	33			248	if (!defined($return) && defined($score))
1569							{
1570	0	0				0	Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "",
1571							q{field},
1572							$tracelevel)
1573							if defined $::RD_TRACE;
1574	0					0	$return = $score_return;
1575							}
1576	57					61	splice @{$thisparser->{errors}}, $err_at;
	57					112
1577	57	50				164	$return = $item[$#item] unless defined $return;
1578	57	50				145	if (defined $::RD_TRACE)
1579							{
1580	0					0	Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} .
1581							$return . q{])}, "",
1582							q{field},
1583							$tracelevel);
1584	0					0	Parse::RecDescent::_trace(q{(consumed: [} .
1585							Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])},
1586							Parse::RecDescent::_tracefirst($text),
1587							, q{field},
1588							$tracelevel)
1589							}
1590	57					77	$_[1] = $text;
1591	57					380	return $return;
1592							}
1593							}
1594	40			40	0	8858	package Parse::FieldPath::Parser; sub new { my $self = bless( {
1595							'_precompiled' => 1,
1596							'localvars' => '',
1597							'startcode' => '',
1598							'namespace' => 'Parse::RecDescent::Parse::FieldPath::Parser',
1599							'rules' => {
1600							'field_path' => bless( {
1601							'impcount' => 0,
1602							'calls' => [
1603							'field_name'
1604							],
1605							'changed' => 0,
1606							'opcount' => 0,
1607							'prods' => [
1608							bless( {
1609							'number' => '0',
1610							'strcount' => 0,
1611							'dircount' => 1,
1612							'uncommit' => undef,
1613							'error' => undef,
1614							'patcount' => 1,
1615							'actcount' => 1,
1616							'op' => [],
1617							'items' => [
1618							bless( {
1619							'expected' => '<leftop: field_name /\\\\// field_name>',
1620							'min' => 1,
1621							'name' => '\'field_name(s)\'',
1622							'max' => 100000000,
1623							'leftarg' => bless( {
1624							'subrule' => 'field_name',
1625							'matchrule' => 0,
1626							'implicit' => undef,
1627							'argcode' => undef,
1628							'lookahead' => 0,
1629							'line' => 31
1630							}, 'Parse::RecDescent::Subrule' ),
1631							'rightarg' => bless( {
1632							'subrule' => 'field_name',
1633							'matchrule' => 0,
1634							'implicit' => undef,
1635							'argcode' => undef,
1636							'lookahead' => 0,
1637							'line' => 31
1638							}, 'Parse::RecDescent::Subrule' ),
1639							'hashname' => '__DIRECTIVE1__',
1640							'type' => 'leftop',
1641							'op' => bless( {
1642							'pattern' => '\\/',
1643							'hashname' => '__PATTERN1__',
1644							'description' => '/\\\\//',
1645							'lookahead' => 0,
1646							'rdelim' => '/',
1647							'line' => 31,
1648							'mod' => '',
1649							'ldelim' => '/'
1650							}, 'Parse::RecDescent::Token' )
1651							}, 'Parse::RecDescent::Operator' ),
1652							bless( {
1653							'hashname' => '__ACTION1__',
1654							'lookahead' => 0,
1655							'line' => 32,
1656							'code' => '{
1657							use List::Util qw//;
1658
1659							# Turn qw/a b c/ into { a => { b => { c => {} } } }
1660							my $fields = {};
1661							List::Util::reduce { $a->{$b} = {} if $b } $fields, @{$item{\'field_name(s)\'}};
1662							$return = $fields;
1663							}'
1664							}, 'Parse::RecDescent::Action' )
1665							],
1666							'line' => undef
1667							}, 'Parse::RecDescent::Production' )
1668							],
1669							'name' => 'field_path',
1670							'vars' => '',
1671							'line' => 30
1672							}, 'Parse::RecDescent::Rule' ),
1673							'field_list' => bless( {
1674							'impcount' => 0,
1675							'calls' => [
1676							'field_path',
1677							'fields'
1678							],
1679							'changed' => 0,
1680							'opcount' => 0,
1681							'prods' => [
1682							bless( {
1683							'number' => '0',
1684							'strcount' => 2,
1685							'dircount' => 0,
1686							'uncommit' => undef,
1687							'error' => undef,
1688							'patcount' => 0,
1689							'actcount' => 1,
1690							'items' => [
1691							bless( {
1692							'subrule' => 'field_path',
1693							'matchrule' => 0,
1694							'implicit' => undef,
1695							'argcode' => undef,
1696							'lookahead' => 0,
1697							'line' => 17
1698							}, 'Parse::RecDescent::Subrule' ),
1699							bless( {
1700							'pattern' => '(',
1701							'hashname' => '__STRING1__',
1702							'description' => '\'(\'',
1703							'lookahead' => 0,
1704							'line' => 17
1705							}, 'Parse::RecDescent::Literal' ),
1706							bless( {
1707							'subrule' => 'fields',
1708							'matchrule' => 0,
1709							'implicit' => undef,
1710							'argcode' => undef,
1711							'lookahead' => 0,
1712							'line' => 17
1713							}, 'Parse::RecDescent::Subrule' ),
1714							bless( {
1715							'pattern' => ')',
1716							'hashname' => '__STRING2__',
1717							'description' => '\')\'',
1718							'lookahead' => 0,
1719							'line' => 17
1720							}, 'Parse::RecDescent::Literal' ),
1721							bless( {
1722							'hashname' => '__ACTION1__',
1723							'lookahead' => 0,
1724							'line' => 18,
1725							'code' => '{
1726							sub deepest {
1727							my $hashref = shift;
1728							return $hashref if scalar(keys %$hashref) == 0;
1729							my $key = (keys %$hashref)[0];
1730							return deepest($hashref->{$key});
1731							}
1732							my $deepest = deepest($item{field_path});
1733							$deepest->{$_} = $item{fields}->{$_} for keys %{$item{fields}};
1734							$return = $item{field_path};
1735							}'
1736							}, 'Parse::RecDescent::Action' )
1737							],
1738							'line' => undef
1739							}, 'Parse::RecDescent::Production' )
1740							],
1741							'name' => 'field_list',
1742							'vars' => '',
1743							'line' => 17
1744							}, 'Parse::RecDescent::Rule' ),
1745							'fields' => bless( {
1746							'impcount' => 0,
1747							'calls' => [
1748							'field'
1749							],
1750							'changed' => 0,
1751							'opcount' => 0,
1752							'prods' => [
1753							bless( {
1754							'number' => '0',
1755							'strcount' => 0,
1756							'dircount' => 1,
1757							'uncommit' => undef,
1758							'error' => undef,
1759							'patcount' => 1,
1760							'actcount' => 1,
1761							'op' => [],
1762							'items' => [
1763							bless( {
1764							'expected' => '<leftop: field /,/ field>',
1765							'min' => 1,
1766							'name' => '\'field(s)\'',
1767							'max' => 100000000,
1768							'leftarg' => bless( {
1769							'subrule' => 'field',
1770							'matchrule' => 0,
1771							'implicit' => undef,
1772							'argcode' => undef,
1773							'lookahead' => 0,
1774							'line' => 7
1775							}, 'Parse::RecDescent::Subrule' ),
1776							'rightarg' => bless( {
1777							'subrule' => 'field',
1778							'matchrule' => 0,
1779							'implicit' => undef,
1780							'argcode' => undef,
1781							'lookahead' => 0,
1782							'line' => 7
1783							}, 'Parse::RecDescent::Subrule' ),
1784							'hashname' => '__DIRECTIVE1__',
1785							'type' => 'leftop',
1786							'op' => bless( {
1787							'pattern' => ',',
1788							'hashname' => '__PATTERN1__',
1789							'description' => '/,/',
1790							'lookahead' => 0,
1791							'rdelim' => '/',
1792							'line' => 7,
1793							'mod' => '',
1794							'ldelim' => '/'
1795							}, 'Parse::RecDescent::Token' )
1796							}, 'Parse::RecDescent::Operator' ),
1797							bless( {
1798							'hashname' => '__ACTION1__',
1799							'lookahead' => 0,
1800							'line' => 8,
1801							'code' => '{
1802							use Hash::Merge qw//;
1803							use List::Util qw//;
1804							$return = List::Util::reduce { Hash::Merge::merge($a, $b) } {}, @{$item[1]};
1805							}'
1806							}, 'Parse::RecDescent::Action' )
1807							],
1808							'line' => undef
1809							}, 'Parse::RecDescent::Production' )
1810							],
1811							'name' => 'fields',
1812							'vars' => '',
1813							'line' => 7
1814							}, 'Parse::RecDescent::Rule' ),
1815							'parse' => bless( {
1816							'impcount' => 0,
1817							'calls' => [
1818							'fields'
1819							],
1820							'changed' => 0,
1821							'opcount' => 0,
1822							'prods' => [
1823							bless( {
1824							'number' => '0',
1825							'strcount' => 0,
1826							'dircount' => 0,
1827							'uncommit' => undef,
1828							'error' => undef,
1829							'patcount' => 1,
1830							'actcount' => 1,
1831							'items' => [
1832							bless( {
1833							'subrule' => 'fields',
1834							'matchrule' => 0,
1835							'implicit' => undef,
1836							'argcode' => undef,
1837							'lookahead' => 0,
1838							'line' => 2
1839							}, 'Parse::RecDescent::Subrule' ),
1840							bless( {
1841							'pattern' => '^\\Z',
1842							'hashname' => '__PATTERN1__',
1843							'description' => '/^\\\\Z/',
1844							'lookahead' => 0,
1845							'rdelim' => '/',
1846							'line' => 2,
1847							'mod' => '',
1848							'ldelim' => '/'
1849							}, 'Parse::RecDescent::Token' ),
1850							bless( {
1851							'hashname' => '__ACTION1__',
1852							'lookahead' => 0,
1853							'line' => 3,
1854							'code' => '{
1855							$return = $item[1];
1856							}'
1857							}, 'Parse::RecDescent::Action' )
1858							],
1859							'line' => undef
1860							}, 'Parse::RecDescent::Production' )
1861							],
1862							'name' => 'parse',
1863							'vars' => '',
1864							'line' => 1
1865							}, 'Parse::RecDescent::Rule' ),
1866							'field_name' => bless( {
1867							'impcount' => 0,
1868							'calls' => [],
1869							'changed' => 0,
1870							'opcount' => 0,
1871							'prods' => [
1872							bless( {
1873							'number' => '0',
1874							'strcount' => 0,
1875							'dircount' => 0,
1876							'uncommit' => undef,
1877							'error' => undef,
1878							'patcount' => 1,
1879							'actcount' => 0,
1880							'items' => [
1881							bless( {
1882							'pattern' => '\\w+',
1883							'hashname' => '__PATTERN1__',
1884							'description' => '/\\\\w+/',
1885							'lookahead' => 0,
1886							'rdelim' => '/',
1887							'line' => 16,
1888							'mod' => '',
1889							'ldelim' => '/'
1890							}, 'Parse::RecDescent::Token' )
1891							],
1892							'line' => undef
1893							}, 'Parse::RecDescent::Production' ),
1894							bless( {
1895							'number' => '1',
1896							'strcount' => 1,
1897							'dircount' => 0,
1898							'uncommit' => undef,
1899							'error' => undef,
1900							'patcount' => 0,
1901							'actcount' => 0,
1902							'items' => [
1903							bless( {
1904							'pattern' => '*',
1905							'hashname' => '__STRING1__',
1906							'description' => '\'*\'',
1907							'lookahead' => 0,
1908							'line' => 16
1909							}, 'Parse::RecDescent::Literal' )
1910							],
1911							'line' => 16
1912							}, 'Parse::RecDescent::Production' ),
1913							bless( {
1914							'number' => '2',
1915							'strcount' => 1,
1916							'dircount' => 0,
1917							'uncommit' => undef,
1918							'error' => undef,
1919							'patcount' => 0,
1920							'actcount' => 0,
1921							'items' => [
1922							bless( {
1923							'pattern' => '',
1924							'hashname' => '__STRING1__',
1925							'description' => '\'\'',
1926							'lookahead' => 0,
1927							'line' => 16
1928							}, 'Parse::RecDescent::Literal' )
1929							],
1930							'line' => 16
1931							}, 'Parse::RecDescent::Production' ),
1932							bless( {
1933							'number' => '3',
1934							'strcount' => 0,
1935							'dircount' => 1,
1936							'uncommit' => 0,
1937							'error' => 1,
1938							'patcount' => 0,
1939							'actcount' => 0,
1940							'items' => [
1941							bless( {
1942							'msg' => '',
1943							'hashname' => '__DIRECTIVE1__',
1944							'commitonly' => '?',
1945							'lookahead' => 0,
1946							'line' => 16
1947							}, 'Parse::RecDescent::Error' ),
1948							bless( {
1949							'name' => '<reject>',
1950							'lookahead' => 0,
1951							'line' => 0
1952							}, 'Parse::RecDescent::UncondReject' )
1953							],
1954							'line' => 16
1955							}, 'Parse::RecDescent::Production' )
1956							],
1957							'name' => 'field_name',
1958							'vars' => '',
1959							'line' => 16
1960							}, 'Parse::RecDescent::Rule' ),
1961							'field' => bless( {
1962							'impcount' => 0,
1963							'calls' => [
1964							'field_list',
1965							'field_path'
1966							],
1967							'changed' => 0,
1968							'opcount' => 0,
1969							'prods' => [
1970							bless( {
1971							'number' => '0',
1972							'strcount' => 0,
1973							'dircount' => 0,
1974							'uncommit' => undef,
1975							'error' => undef,
1976							'patcount' => 0,
1977							'actcount' => 0,
1978							'items' => [
1979							bless( {
1980							'subrule' => 'field_list',
1981							'matchrule' => 0,
1982							'implicit' => undef,
1983							'argcode' => undef,
1984							'lookahead' => 0,
1985							'line' => 14
1986							}, 'Parse::RecDescent::Subrule' )
1987							],
1988							'line' => undef
1989							}, 'Parse::RecDescent::Production' ),
1990							bless( {
1991							'number' => '1',
1992							'strcount' => 0,
1993							'dircount' => 0,
1994							'uncommit' => undef,
1995							'error' => undef,
1996							'patcount' => 0,
1997							'actcount' => 0,
1998							'items' => [
1999							bless( {
2000							'subrule' => 'field_path',
2001							'matchrule' => 0,
2002							'implicit' => undef,
2003							'argcode' => undef,
2004							'lookahead' => 0,
2005							'line' => 14
2006							}, 'Parse::RecDescent::Subrule' )
2007							],
2008							'line' => 14
2009							}, 'Parse::RecDescent::Production' ),
2010							bless( {
2011							'number' => '2',
2012							'strcount' => 0,
2013							'dircount' => 1,
2014							'uncommit' => 0,
2015							'error' => 1,
2016							'patcount' => 0,
2017							'actcount' => 0,
2018							'items' => [
2019							bless( {
2020							'msg' => '',
2021							'hashname' => '__DIRECTIVE1__',
2022							'commitonly' => '',
2023							'lookahead' => 0,
2024							'line' => 14
2025							}, 'Parse::RecDescent::Error' )
2026							],
2027							'line' => 14
2028							}, 'Parse::RecDescent::Production' )
2029							],
2030							'name' => 'field',
2031							'vars' => '',
2032							'line' => 14
2033							}, 'Parse::RecDescent::Rule' )
2034							},
2035							'_AUTOTREE' => undef,
2036							'_check' => {
2037							'thisoffset' => '',
2038							'itempos' => '',
2039							'prevoffset' => '',
2040							'prevline' => '',
2041							'prevcolumn' => '',
2042							'thiscolumn' => ''
2043							},
2044							'_AUTOACTION' => undef
2045							}, 'Parse::RecDescent' );
2046							}