File Coverage

blib/lib/Net/IRC2/Parser.pm

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

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